1 | function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
2 |
|
3 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
4 |
|
5 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
6 |
|
7 | import { Lexer } from "../lexer.mjs";
|
8 | import { Source } from "../source.mjs";
|
9 | import GraphQLGrammar from "./grammar.mjs";
|
10 | export var TokenKind = {
|
11 | NAME: 'Name',
|
12 | INT: 'Int',
|
13 | FLOAT: 'Float',
|
14 | STRING: 'String',
|
15 | BLOCK_STRING: 'BlockString',
|
16 | COMMENT: 'Comment',
|
17 | PUNCTUATION: 'Punctuation',
|
18 | EOF: '<EOF>',
|
19 | INVALID: 'Invalid'
|
20 | };
|
21 | export var RuleKind = {
|
22 | TOKEN_CONSTRAINT: 'TokenConstraint',
|
23 | OF_TYPE_CONSTRAINT: 'OfTypeConstraint',
|
24 | LIST_OF_TYPE_CONSTRAINT: 'ListOfTypeConstraint',
|
25 | PEEK_CONSTRAINT: 'PeekConstraint',
|
26 | CONSTRAINTS_SET: 'ConstraintsSet',
|
27 | CONSTRAINTS_SET_ROOT: 'ConstraintsSetRoot',
|
28 | RULE_NAME: 'RuleName',
|
29 | INVALID: 'Invalid'
|
30 | };
|
31 | export var OnlineParser = function () {
|
32 | function OnlineParser(source, state, config) {
|
33 | var _config$tabSize;
|
34 |
|
35 | this.state = state || OnlineParser.startState();
|
36 | this._config = {
|
37 | tabSize: (_config$tabSize = config === null || config === void 0 ? void 0 : config.tabSize) !== null && _config$tabSize !== void 0 ? _config$tabSize : 2
|
38 | };
|
39 | this._lexer = new Lexer(new Source(source));
|
40 | }
|
41 |
|
42 | OnlineParser.startState = function startState() {
|
43 | return {
|
44 | rules: [
|
45 | _objectSpread(_objectSpread({
|
46 | name: 'Document',
|
47 | state: 'Document',
|
48 | kind: 'ListOfTypeConstraint'
|
49 | }, GraphQLGrammar.Document), {}, {
|
50 | expanded: false,
|
51 | depth: 1,
|
52 | step: 1
|
53 | })],
|
54 | name: null,
|
55 | type: null,
|
56 | levels: [],
|
57 | indentLevel: 0,
|
58 | kind: function kind() {
|
59 | var _this$rules;
|
60 |
|
61 | return ((_this$rules = this.rules[this.rules.length - 1]) === null || _this$rules === void 0 ? void 0 : _this$rules.state) || '';
|
62 | },
|
63 | step: function step() {
|
64 | var _this$rules2;
|
65 |
|
66 | return ((_this$rules2 = this.rules[this.rules.length - 1]) === null || _this$rules2 === void 0 ? void 0 : _this$rules2.step) || 0;
|
67 | }
|
68 | };
|
69 | };
|
70 |
|
71 | OnlineParser.copyState = function copyState(state) {
|
72 | return {
|
73 | name: state.name,
|
74 | type: state.type,
|
75 | rules: JSON.parse(JSON.stringify(state.rules)),
|
76 | levels: [].concat(state.levels),
|
77 | indentLevel: state.indentLevel,
|
78 | kind: function kind() {
|
79 | var _this$rules3;
|
80 |
|
81 | return ((_this$rules3 = this.rules[this.rules.length - 1]) === null || _this$rules3 === void 0 ? void 0 : _this$rules3.state) || '';
|
82 | },
|
83 | step: function step() {
|
84 | var _this$rules4;
|
85 |
|
86 | return ((_this$rules4 = this.rules[this.rules.length - 1]) === null || _this$rules4 === void 0 ? void 0 : _this$rules4.step) || 0;
|
87 | }
|
88 | };
|
89 | };
|
90 |
|
91 | var _proto = OnlineParser.prototype;
|
92 |
|
93 | _proto.sol = function sol() {
|
94 | return this._lexer.source.locationOffset.line === 1 && this._lexer.source.locationOffset.column === 1;
|
95 | };
|
96 |
|
97 | _proto.parseToken = function parseToken() {
|
98 | var rule = this._getNextRule();
|
99 |
|
100 | if (this.sol()) {
|
101 | this.state.indentLevel = Math.floor(this.indentation() / this._config.tabSize);
|
102 | }
|
103 |
|
104 | if (!rule) {
|
105 | return {
|
106 | kind: TokenKind.INVALID,
|
107 | value: ''
|
108 | };
|
109 | }
|
110 |
|
111 | var token;
|
112 |
|
113 | if (this._lookAhead().kind === '<EOF>') {
|
114 | return {
|
115 | kind: TokenKind.EOF,
|
116 | value: '',
|
117 | ruleName: rule.name
|
118 | };
|
119 | }
|
120 |
|
121 | switch (rule.kind) {
|
122 | case RuleKind.TOKEN_CONSTRAINT:
|
123 | token = this._parseTokenConstraint(rule);
|
124 | break;
|
125 |
|
126 | case RuleKind.LIST_OF_TYPE_CONSTRAINT:
|
127 | token = this._parseListOfTypeConstraint(rule);
|
128 | break;
|
129 |
|
130 | case RuleKind.OF_TYPE_CONSTRAINT:
|
131 | token = this._parseOfTypeConstraint(rule);
|
132 | break;
|
133 |
|
134 | case RuleKind.PEEK_CONSTRAINT:
|
135 | token = this._parsePeekConstraint(rule);
|
136 | break;
|
137 |
|
138 | case RuleKind.CONSTRAINTS_SET_ROOT:
|
139 | token = this._parseConstraintsSetRule(rule);
|
140 | break;
|
141 |
|
142 | default:
|
143 | return {
|
144 | kind: TokenKind.INVALID,
|
145 | value: '',
|
146 | ruleName: rule.name
|
147 | };
|
148 | }
|
149 |
|
150 | if (token && token.kind === TokenKind.INVALID) {
|
151 | if (rule.optional === true) {
|
152 | this.state.rules.pop();
|
153 | } else {
|
154 | this._rollbackRule();
|
155 | }
|
156 |
|
157 | return this.parseToken() || token;
|
158 | }
|
159 |
|
160 | return token;
|
161 | };
|
162 |
|
163 | _proto.indentation = function indentation() {
|
164 | var match = this._lexer.source.body.match(/\s*/);
|
165 |
|
166 | var indent = 0;
|
167 |
|
168 | if (match && match.length === 0) {
|
169 | var whiteSpaces = match[0];
|
170 | var pos = 0;
|
171 |
|
172 | while (whiteSpaces.length > pos) {
|
173 | if (whiteSpaces.charCodeAt(pos) === 9) {
|
174 | indent += 2;
|
175 | } else {
|
176 | indent++;
|
177 | }
|
178 |
|
179 | pos++;
|
180 | }
|
181 | }
|
182 |
|
183 | return indent;
|
184 | };
|
185 |
|
186 | _proto._parseTokenConstraint = function _parseTokenConstraint(rule) {
|
187 | rule.expanded = true;
|
188 |
|
189 | var token = this._lookAhead();
|
190 |
|
191 | if (!this._matchToken(token, rule)) {
|
192 | return {
|
193 | kind: TokenKind.INVALID,
|
194 | value: '',
|
195 | tokenName: rule.tokenName,
|
196 | ruleName: rule.name
|
197 | };
|
198 | }
|
199 |
|
200 | this._advanceToken();
|
201 |
|
202 | var parserToken = this._transformLexerToken(token, rule);
|
203 |
|
204 | this._popMatchedRule(parserToken);
|
205 |
|
206 | return parserToken;
|
207 | };
|
208 |
|
209 | _proto._parseListOfTypeConstraint = function _parseListOfTypeConstraint(rule) {
|
210 | this._pushRule(GraphQLGrammar[rule.listOfType], rule.depth + 1, rule.listOfType, 1, rule.state);
|
211 |
|
212 | rule.expanded = true;
|
213 | var token = this.parseToken();
|
214 | return token;
|
215 | };
|
216 |
|
217 | _proto._parseOfTypeConstraint = function _parseOfTypeConstraint(rule) {
|
218 | if (rule.expanded) {
|
219 | this._popMatchedRule();
|
220 |
|
221 | return this.parseToken();
|
222 | }
|
223 |
|
224 | this._pushRule(rule.ofType, rule.depth + 1, rule.tokenName, 1, rule.state);
|
225 |
|
226 | rule.expanded = true;
|
227 | var token = this.parseToken();
|
228 | return token;
|
229 | };
|
230 |
|
231 | _proto._parsePeekConstraint = function _parsePeekConstraint(rule) {
|
232 | if (rule.expanded) {
|
233 | this._popMatchedRule();
|
234 |
|
235 | return this.parseToken();
|
236 | }
|
237 |
|
238 | while (!rule.matched && rule.index < rule.peek.length - 1) {
|
239 | rule.index++;
|
240 | var constraint = rule.peek[rule.index];
|
241 | var ifCondition = constraint.ifCondition;
|
242 |
|
243 | if (typeof ifCondition === 'string') {
|
244 | ifCondition = GraphQLGrammar[ifCondition];
|
245 | }
|
246 |
|
247 | var token = this._lookAhead();
|
248 |
|
249 | if (ifCondition && this._matchToken(token, ifCondition)) {
|
250 | rule.matched = true;
|
251 | rule.expanded = true;
|
252 |
|
253 | this._pushRule(constraint.expect, rule.depth + 1, '', 1, rule.state);
|
254 |
|
255 | token = this.parseToken();
|
256 | return token;
|
257 | }
|
258 | }
|
259 |
|
260 | return {
|
261 | kind: TokenKind.INVALID,
|
262 | value: '',
|
263 | ruleName: rule.name
|
264 | };
|
265 | };
|
266 |
|
267 | _proto._parseConstraintsSetRule = function _parseConstraintsSetRule(rule) {
|
268 | if (rule.expanded) {
|
269 | this._popMatchedRule();
|
270 |
|
271 | return this.parseToken();
|
272 | }
|
273 |
|
274 | for (var index = rule.constraints.length - 1; index >= 0; index--) {
|
275 | this._pushRule(rule.constraints[index], rule.depth + 1, '', index, rule.state);
|
276 | }
|
277 |
|
278 | rule.expanded = true;
|
279 | return this.parseToken();
|
280 | };
|
281 |
|
282 | _proto._matchToken = function _matchToken(token, rule) {
|
283 | if (typeof token.value === 'string') {
|
284 | if (typeof rule.ofValue === 'string' && token.value !== rule.ofValue || Array.isArray(rule.oneOf) && !rule.oneOf.includes(token.value) || typeof rule.ofValue !== 'string' && !Array.isArray(rule.oneOf) && token.kind !== rule.token) {
|
285 | return false;
|
286 | }
|
287 |
|
288 | return this._butNot(token, rule);
|
289 | }
|
290 |
|
291 | if (token.kind !== rule.token) {
|
292 | return false;
|
293 | }
|
294 |
|
295 | return this._butNot(token, rule);
|
296 | };
|
297 |
|
298 | _proto._butNot = function _butNot(token, rule) {
|
299 | var _this = this;
|
300 |
|
301 | if (rule.butNot) {
|
302 | if (Array.isArray(rule.butNot)) {
|
303 | if (rule.butNot.reduce(function (matched, constraint) {
|
304 | return matched || _this._matchToken(token, constraint);
|
305 | }, false)) {
|
306 | return false;
|
307 | }
|
308 |
|
309 | return true;
|
310 | }
|
311 |
|
312 | return !this._matchToken(token, rule.butNot);
|
313 | }
|
314 |
|
315 | return true;
|
316 | };
|
317 |
|
318 | _proto._transformLexerToken = function _transformLexerToken(lexerToken, rule) {
|
319 | var token;
|
320 | var ruleName = rule.name || '';
|
321 | var tokenName = rule.tokenName || '';
|
322 |
|
323 | if (lexerToken.kind === '<EOF>' || lexerToken.value !== undefined) {
|
324 | token = {
|
325 | kind: lexerToken.kind,
|
326 | value: lexerToken.value || '',
|
327 | tokenName: tokenName,
|
328 | ruleName: ruleName
|
329 | };
|
330 |
|
331 | if (token.kind === TokenKind.STRING) {
|
332 | token.value = "\"".concat(token.value, "\"");
|
333 | } else if (token.kind === TokenKind.BLOCK_STRING) {
|
334 | token.value = "\"\"\"".concat(token.value, "\"\"\"");
|
335 | }
|
336 | } else {
|
337 | token = {
|
338 | kind: TokenKind.PUNCTUATION,
|
339 | value: lexerToken.kind,
|
340 | tokenName: tokenName,
|
341 | ruleName: ruleName
|
342 | };
|
343 |
|
344 | if (/^[{([]/.test(token.value)) {
|
345 | if (this.state.indentLevel !== undefined) {
|
346 | this.state.levels = this.state.levels.concat(this.state.indentLevel + 1);
|
347 | }
|
348 | } else if (/^[})\]]/.test(token.value)) {
|
349 | this.state.levels.pop();
|
350 | }
|
351 | }
|
352 |
|
353 | return token;
|
354 | };
|
355 |
|
356 | _proto._getNextRule = function _getNextRule() {
|
357 | return this.state.rules[this.state.rules.length - 1] || null;
|
358 | };
|
359 |
|
360 | _proto._popMatchedRule = function _popMatchedRule(token) {
|
361 | var rule = this.state.rules.pop();
|
362 |
|
363 | if (!rule) {
|
364 | return;
|
365 | }
|
366 |
|
367 | if (token && rule.kind === RuleKind.TOKEN_CONSTRAINT) {
|
368 | var constraint = rule;
|
369 |
|
370 | if (typeof constraint.definitionName === 'string') {
|
371 | this.state.name = token.value || null;
|
372 | } else if (typeof constraint.typeName === 'string') {
|
373 | this.state.type = token.value || null;
|
374 | }
|
375 | }
|
376 |
|
377 | var nextRule = this._getNextRule();
|
378 |
|
379 | if (!nextRule) {
|
380 | return;
|
381 | }
|
382 |
|
383 | if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.CONSTRAINTS_SET_ROOT) {
|
384 | this.state.rules.pop();
|
385 | }
|
386 |
|
387 | if (nextRule.depth === rule.depth - 1 && nextRule.expanded && nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT) {
|
388 | nextRule.expanded = false;
|
389 | nextRule.optional = true;
|
390 | }
|
391 | };
|
392 |
|
393 | _proto._rollbackRule = function _rollbackRule() {
|
394 | var _this2 = this;
|
395 |
|
396 | if (!this.state.rules.length) {
|
397 | return;
|
398 | }
|
399 |
|
400 | var popRule = function popRule() {
|
401 | var lastPoppedRule = _this2.state.rules.pop();
|
402 |
|
403 | if (lastPoppedRule.eatNextOnFail === true) {
|
404 | _this2.state.rules.pop();
|
405 | }
|
406 | };
|
407 |
|
408 | var poppedRule = this.state.rules.pop();
|
409 |
|
410 | if (!poppedRule) {
|
411 | return;
|
412 | }
|
413 |
|
414 | var popped = 0;
|
415 |
|
416 | var nextRule = this._getNextRule();
|
417 |
|
418 | while (nextRule && (poppedRule.kind !== RuleKind.LIST_OF_TYPE_CONSTRAINT || nextRule.expanded) && nextRule.depth > poppedRule.depth - 1) {
|
419 | this.state.rules.pop();
|
420 | popped++;
|
421 | nextRule = this._getNextRule();
|
422 | }
|
423 |
|
424 | if (nextRule && nextRule.expanded) {
|
425 | if (nextRule.optional === true) {
|
426 | popRule();
|
427 | } else {
|
428 | if (nextRule.kind === RuleKind.LIST_OF_TYPE_CONSTRAINT && popped === 1) {
|
429 | this.state.rules.pop();
|
430 | return;
|
431 | }
|
432 |
|
433 | this._rollbackRule();
|
434 | }
|
435 | }
|
436 | };
|
437 |
|
438 | _proto._pushRule = function _pushRule(baseRule, depth, name, step, state) {
|
439 | var _this$_getNextRule, _this$_getNextRule2, _this$_getNextRule3, _this$_getNextRule4, _this$_getNextRule5, _this$_getNextRule6, _this$_getNextRule7, _this$_getNextRule8, _this$_getNextRule9, _this$_getNextRule10;
|
440 |
|
441 | this.state.name = null;
|
442 | this.state.type = null;
|
443 | var rule = baseRule;
|
444 |
|
445 | switch (this._getRuleKind(rule)) {
|
446 | case RuleKind.RULE_NAME:
|
447 | rule = rule;
|
448 |
|
449 | this._pushRule(GraphQLGrammar[rule], depth, (typeof name === 'string' ? name : undefined) || rule, step, state);
|
450 |
|
451 | break;
|
452 |
|
453 | case RuleKind.CONSTRAINTS_SET:
|
454 | rule = rule;
|
455 | this.state.rules.push({
|
456 | name: name || '',
|
457 | depth: depth,
|
458 | expanded: false,
|
459 | constraints: rule,
|
460 | constraintsSet: true,
|
461 | kind: RuleKind.CONSTRAINTS_SET_ROOT,
|
462 | state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule = this._getNextRule()) === null || _this$_getNextRule === void 0 ? void 0 : _this$_getNextRule.state) || '',
|
463 | step: typeof step === 'number' ? step : (((_this$_getNextRule2 = this._getNextRule()) === null || _this$_getNextRule2 === void 0 ? void 0 : _this$_getNextRule2.step) || 0) + 1
|
464 | });
|
465 | break;
|
466 |
|
467 | case RuleKind.OF_TYPE_CONSTRAINT:
|
468 | rule = rule;
|
469 | this.state.rules.push({
|
470 | name: name || '',
|
471 | ofType: rule.ofType,
|
472 | optional: Boolean(rule.optional),
|
473 | butNot: rule.butNot,
|
474 | eatNextOnFail: Boolean(rule.eatNextOnFail),
|
475 | depth: depth,
|
476 | expanded: false,
|
477 | kind: RuleKind.OF_TYPE_CONSTRAINT,
|
478 | state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule3 = this._getNextRule()) === null || _this$_getNextRule3 === void 0 ? void 0 : _this$_getNextRule3.state) || '',
|
479 | step: typeof step === 'number' ? step : (((_this$_getNextRule4 = this._getNextRule()) === null || _this$_getNextRule4 === void 0 ? void 0 : _this$_getNextRule4.step) || 0) + 1
|
480 | });
|
481 | break;
|
482 |
|
483 | case RuleKind.LIST_OF_TYPE_CONSTRAINT:
|
484 | rule = rule;
|
485 | this.state.rules.push({
|
486 | listOfType: rule.listOfType,
|
487 | optional: Boolean(rule.optional),
|
488 | butNot: rule.butNot,
|
489 | eatNextOnFail: Boolean(rule.eatNextOnFail),
|
490 | name: name || '',
|
491 | depth: depth,
|
492 | expanded: false,
|
493 | kind: RuleKind.LIST_OF_TYPE_CONSTRAINT,
|
494 | state: (typeof name === 'string' ? name : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule5 = this._getNextRule()) === null || _this$_getNextRule5 === void 0 ? void 0 : _this$_getNextRule5.state) || '',
|
495 | step: typeof step === 'number' ? step : (((_this$_getNextRule6 = this._getNextRule()) === null || _this$_getNextRule6 === void 0 ? void 0 : _this$_getNextRule6.step) || 0) + 1
|
496 | });
|
497 | break;
|
498 |
|
499 | case RuleKind.TOKEN_CONSTRAINT:
|
500 | rule = rule;
|
501 | this.state.rules.push({
|
502 | token: rule.token,
|
503 | ofValue: rule.ofValue,
|
504 | oneOf: rule.oneOf,
|
505 | definitionName: Boolean(rule.definitionName),
|
506 | typeName: Boolean(rule.typeName),
|
507 | optional: Boolean(rule.optional),
|
508 | butNot: rule.butNot,
|
509 | eatNextOnFail: Boolean(rule.eatNextOnFail),
|
510 | name: name || '',
|
511 | depth: depth,
|
512 | expanded: false,
|
513 | kind: RuleKind.TOKEN_CONSTRAINT,
|
514 | state: (typeof rule.tokenName === 'string' ? rule.tokenName : undefined) || (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule7 = this._getNextRule()) === null || _this$_getNextRule7 === void 0 ? void 0 : _this$_getNextRule7.state) || '',
|
515 | step: typeof step === 'number' ? step : (((_this$_getNextRule8 = this._getNextRule()) === null || _this$_getNextRule8 === void 0 ? void 0 : _this$_getNextRule8.step) || 0) + 1
|
516 | });
|
517 | break;
|
518 |
|
519 | case RuleKind.PEEK_CONSTRAINT:
|
520 | rule = rule;
|
521 | this.state.rules.push({
|
522 | peek: rule.peek,
|
523 | optional: Boolean(rule.optional),
|
524 | butNot: rule.butNot,
|
525 | eatNextOnFail: Boolean(rule.eatNextOnFail),
|
526 | name: name || '',
|
527 | depth: depth,
|
528 | index: -1,
|
529 | matched: false,
|
530 | expanded: false,
|
531 | kind: RuleKind.PEEK_CONSTRAINT,
|
532 | state: (typeof state === 'string' ? state : undefined) || ((_this$_getNextRule9 = this._getNextRule()) === null || _this$_getNextRule9 === void 0 ? void 0 : _this$_getNextRule9.state) || '',
|
533 | step: typeof step === 'number' ? step : (((_this$_getNextRule10 = this._getNextRule()) === null || _this$_getNextRule10 === void 0 ? void 0 : _this$_getNextRule10.step) || 0) + 1
|
534 | });
|
535 | break;
|
536 | }
|
537 | };
|
538 |
|
539 | _proto._getRuleKind = function _getRuleKind(rule) {
|
540 | if (Array.isArray(rule)) {
|
541 | return RuleKind.CONSTRAINTS_SET;
|
542 | }
|
543 |
|
544 | if (rule.constraintsSet === true) {
|
545 | return RuleKind.CONSTRAINTS_SET_ROOT;
|
546 | }
|
547 |
|
548 | if (typeof rule === 'string') {
|
549 | return RuleKind.RULE_NAME;
|
550 | }
|
551 |
|
552 | if (Object.prototype.hasOwnProperty.call(rule, 'ofType')) {
|
553 | return RuleKind.OF_TYPE_CONSTRAINT;
|
554 | }
|
555 |
|
556 | if (Object.prototype.hasOwnProperty.call(rule, 'listOfType')) {
|
557 | return RuleKind.LIST_OF_TYPE_CONSTRAINT;
|
558 | }
|
559 |
|
560 | if (Object.prototype.hasOwnProperty.call(rule, 'peek')) {
|
561 | return RuleKind.PEEK_CONSTRAINT;
|
562 | }
|
563 |
|
564 | if (Object.prototype.hasOwnProperty.call(rule, 'token')) {
|
565 | return RuleKind.TOKEN_CONSTRAINT;
|
566 | }
|
567 |
|
568 | return RuleKind.INVALID;
|
569 | };
|
570 |
|
571 | _proto._advanceToken = function _advanceToken() {
|
572 | return this._lexer.advance();
|
573 | };
|
574 |
|
575 | _proto._lookAhead = function _lookAhead() {
|
576 | try {
|
577 | return this._lexer.lookahead();
|
578 | } catch (err) {
|
579 | return {
|
580 | kind: TokenKind.INVALID,
|
581 | value: ''
|
582 | };
|
583 | }
|
584 | };
|
585 |
|
586 | return OnlineParser;
|
587 | }();
|