diff options
| author | Minteck <nekostarfan@gmail.com> | 2021-08-24 14:41:48 +0200 |
|---|---|---|
| committer | Minteck <nekostarfan@gmail.com> | 2021-08-24 14:41:48 +0200 |
| commit | d25e11bee6ca5ca523884da132d18e1400e077b9 (patch) | |
| tree | 8af39fde19f7ed640a60fb397c7edd647dff1c4c /node_modules/cherow/dist/system | |
| download | kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.gz kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.bz2 kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.zip | |
Initial commit
Diffstat (limited to 'node_modules/cherow/dist/system')
| -rw-r--r-- | node_modules/cherow/dist/system/cherow.js | 7346 | ||||
| -rw-r--r-- | node_modules/cherow/dist/system/cherow.min.js | 1 |
2 files changed, 7347 insertions, 0 deletions
diff --git a/node_modules/cherow/dist/system/cherow.js b/node_modules/cherow/dist/system/cherow.js new file mode 100644 index 0000000..b360863 --- /dev/null +++ b/node_modules/cherow/dist/system/cherow.js @@ -0,0 +1,7346 @@ +System.register('cherow', [], function (exports, module) { + 'use strict'; + return { + execute: function () { + + exports({ + parse: parse, + parseSource: parseSource, + parseModule: parseModule, + parseScript: parseScript, + constructError: constructError, + report: report, + tolerant: tolerant, + tokenDesc: tokenDesc, + descKeyword: descKeyword, + isValidIdentifierPart: isValidIdentifierPart, + isValidIdentifierStart: isValidIdentifierStart, + mustEscape: mustEscape, + Context: void 0, + Flags: void 0, + Labels: void 0, + NumericState: void 0, + ScannerState: void 0, + ModifierState: void 0, + CoverParenthesizedState: void 0, + Escape: void 0, + RegexFlags: void 0, + CoverCallState: void 0, + RegexState: void 0, + ObjectState: void 0, + validateBreakOrContinueLabel: validateBreakOrContinueLabel, + addLabel: addLabel, + popLabel: popLabel, + hasLabel: hasLabel, + finishNode: finishNode, + expect: expect, + consume: consume, + nextToken: nextToken, + consumeSemicolon: consumeSemicolon, + parseExpressionCoverGrammar: parseExpressionCoverGrammar, + restoreExpressionCoverGrammar: restoreExpressionCoverGrammar, + swapContext: swapContext, + validateParams: validateParams, + lookahead: lookahead, + isValidSimpleAssignmentTarget: isValidSimpleAssignmentTarget, + getLocation: getLocation, + isValidIdentifier: isValidIdentifier, + isLexical: isLexical, + isEndOfCaseOrDefaultClauses: isEndOfCaseOrDefaultClauses, + nextTokenIsLeftParenOrPeriod: nextTokenIsLeftParenOrPeriod, + nextTokenisIdentifierOrParen: nextTokenisIdentifierOrParen, + nextTokenIsLeftParen: nextTokenIsLeftParen, + nextTokenIsFuncKeywordOnSameLine: nextTokenIsFuncKeywordOnSameLine, + isPropertyWithPrivateFieldKey: isPropertyWithPrivateFieldKey, + parseAndClassifyIdentifier: parseAndClassifyIdentifier, + nameIsArgumentsOrEval: nameIsArgumentsOrEval, + setPendingError: setPendingError, + isEqualTagNames: isEqualTagNames, + isInstanceField: isInstanceField, + validateUpdateExpression: validateUpdateExpression, + setPendingExpressionError: setPendingExpressionError, + validateCoverParenthesizedExpression: validateCoverParenthesizedExpression, + validateAsyncArgumentList: validateAsyncArgumentList, + isInOrOf: isInOrOf + }); + + // Note: this *must* be kept in sync with the enum's order.
+ //
+ // It exploits the enum value ordering, and it's necessarily a complete and
+ // utter hack.
+ //
+ // All to lower it to a single monomorphic array access.
+ const keywordDescTable = [
+ 'end of source',
+ /* Constants/Bindings */
+ 'identifier', 'number', 'string', 'regular expression',
+ 'false', 'true', 'null',
+ /* Template nodes */
+ 'template continuation', 'template end',
+ /* Punctuators */
+ '=>', '(', '{', '.', '...', '}', ')', ';', ',', '[', ']', ':', '?', '\'', '"', '</', '/>',
+ /* Update operators */
+ '++', '--',
+ /* Assign operators */
+ '=', '<<=', '>>=', '>>>=', '**=', '+=', '-=', '*=', '/=', '%=', '^=', '|=',
+ '&=',
+ /* Unary/binary operators */
+ 'typeof', 'delete', 'void', '!', '~', '+', '-', 'in', 'instanceof', '*', '%', '/', '**', '&&',
+ '||', '===', '!==', '==', '!=', '<=', '>=', '<', '>', '<<', '>>', '>>>', '&', '|', '^',
+ /* Variable declaration kinds */
+ 'var', 'let', 'const',
+ /* Other reserved words */
+ 'break', 'case', 'catch', 'class', 'continue', 'debugger', 'default', 'do', 'else', 'export',
+ 'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
+ 'this', 'throw', 'try', 'while', 'with',
+ /* Strict mode reserved words */
+ 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
+ /* Contextual keywords */
+ 'as', 'async', 'await', 'constructor', 'get', 'set', 'from', 'of',
+ '#',
+ 'eval', 'arguments', 'enum', 'BigInt', '@', 'JSXText',
+ /** TS */
+ 'KeyOf', 'ReadOnly', 'is', 'unique', 'declare', 'type', 'namespace', 'abstract', 'module',
+ 'global', 'require', 'target'
+ ];
+ /**
+ * The conversion function between token and its string description/representation.
+ */
+ function tokenDesc(token) {
+ return keywordDescTable[token & 255 /* Type */];
+ }
+ // Used `Object.create(null)` to avoid potential `Object.prototype`
+ // interference.
+ const descKeywordTable = Object.create(null, {
+ this: { value: 33566815 /* ThisKeyword */ },
+ function: { value: 33566808 /* FunctionKeyword */ },
+ if: { value: 12377 /* IfKeyword */ },
+ return: { value: 12380 /* ReturnKeyword */ },
+ var: { value: 33566791 /* VarKeyword */ },
+ else: { value: 12370 /* ElseKeyword */ },
+ for: { value: 12374 /* ForKeyword */ },
+ new: { value: 33566811 /* NewKeyword */ },
+ in: { value: 167786289 /* InKeyword */ },
+ typeof: { value: 302002218 /* TypeofKeyword */ },
+ while: { value: 12386 /* WhileKeyword */ },
+ case: { value: 12363 /* CaseKeyword */ },
+ break: { value: 12362 /* BreakKeyword */ },
+ try: { value: 12385 /* TryKeyword */ },
+ catch: { value: 12364 /* CatchKeyword */ },
+ delete: { value: 302002219 /* DeleteKeyword */ },
+ throw: { value: 302002272 /* ThrowKeyword */ },
+ switch: { value: 33566814 /* SwitchKeyword */ },
+ continue: { value: 12366 /* ContinueKeyword */ },
+ default: { value: 12368 /* DefaultKeyword */ },
+ instanceof: { value: 167786290 /* InstanceofKeyword */ },
+ do: { value: 12369 /* DoKeyword */ },
+ void: { value: 302002220 /* VoidKeyword */ },
+ finally: { value: 12373 /* FinallyKeyword */ },
+ arguments: { value: 37879925 /* Arguments */ },
+ keyof: { value: 131194 /* KeyOfKeyword */ },
+ readonly: { value: 131195 /* ReadOnlyKeyword */ },
+ unique: { value: 131197 /* UniqueKeyword */ },
+ declare: { value: 131198 /* DeclareKeyword */ },
+ async: { value: 594028 /* AsyncKeyword */ },
+ await: { value: 34017389 /* AwaitKeyword */ },
+ class: { value: 33566797 /* ClassKeyword */ },
+ const: { value: 33566793 /* ConstKeyword */ },
+ constructor: { value: 69742 /* ConstructorKeyword */ },
+ debugger: { value: 12367 /* DebuggerKeyword */ },
+ enum: { value: 12406 /* EnumKeyword */ },
+ eval: { value: 37879924 /* Eval */ },
+ export: { value: 12371 /* ExportKeyword */ },
+ extends: { value: 12372 /* ExtendsKeyword */ },
+ false: { value: 33566725 /* FalseKeyword */ },
+ from: { value: 69745 /* FromKeyword */ },
+ get: { value: 69743 /* GetKeyword */ },
+ implements: { value: 20579 /* ImplementsKeyword */ },
+ import: { value: 33566810 /* ImportKeyword */ },
+ interface: { value: 20580 /* InterfaceKeyword */ },
+ let: { value: 33574984 /* LetKeyword */ },
+ null: { value: 33566727 /* NullKeyword */ },
+ of: { value: 69746 /* OfKeyword */ },
+ package: { value: 20581 /* PackageKeyword */ },
+ private: { value: 20582 /* PrivateKeyword */ },
+ protected: { value: 20583 /* ProtectedKeyword */ },
+ public: { value: 20584 /* PublicKeyword */ },
+ set: { value: 69744 /* SetKeyword */ },
+ static: { value: 20585 /* StaticKeyword */ },
+ super: { value: 33566813 /* SuperKeyword */ },
+ true: { value: 33566726 /* TrueKeyword */ },
+ with: { value: 12387 /* WithKeyword */ },
+ yield: { value: 1107316842 /* YieldKeyword */ },
+ is: { value: 131196 /* IsKeyword */ },
+ type: { value: 131199 /* TypeKeyword */ },
+ namespace: { value: 131200 /* NameSpaceKeyword */ },
+ abstract: { value: 131201 /* AbstractKeyword */ },
+ as: { value: 167843947 /* AsKeyword */ },
+ module: { value: 131202 /* ModuleKeyword */ },
+ global: { value: 131203 /* GlobalKeyword */ },
+ require: { value: 131204 /* RequireKeyword */ },
+ target: { value: 131205 /* TargetKeyword */ },
+ });
+ function descKeyword(value) {
+ return (descKeywordTable[value] | 0);
+ } + + /*@internal*/
+ const characterType = exports('characterType', [
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 16 /* Space */,
+ 48 /* Whitespace */,
+ 16 /* Space */,
+ 16 /* Space */,
+ 48 /* Whitespace */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 16 /* Space */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ ]); + + // Unicode v. 11 support
+ // tslint:disable
+ function isValidIdentifierPart(code) {
+ return (convert[(code >>> 5) + 0] >>> code & 31 & 1) !== 0;
+ }
+ function isValidIdentifierStart(code) {
+ return (convert[(code >>> 5) + 34816] >>> code & 31 & 1) !== 0;
+ }
+ function mustEscape(code) {
+ return (convert[(code >>> 5) + 69632] >>> code & 31 & 1) !== 0;
+ }
+ const convert = ((compressed, lookup) => {
+ const result = new Uint32Array(104448);
+ let index = 0;
+ let subIndex = 0;
+ while (index < 3392) {
+ const inst = compressed[index++];
+ if (inst < 0) {
+ subIndex -= inst;
+ }
+ else {
+ let code = compressed[index++];
+ if (inst & 2)
+ code = lookup[code];
+ if (inst & 1) {
+ result.fill(code, subIndex, subIndex += compressed[index++]);
+ }
+ else {
+ result[subIndex++] = code;
+ }
+ }
+ }
+ return result;
+ })([-1, 2, 28, 2, 29, 2, 5, -1, 0, 77595648, 3, 46, 2, 3, 0, 14, 2, 57, 2, 58, 3, 0, 3, 0, 3168796671, 0, 4294956992, 2, 1, 2, 0, 2, 59, 3, 0, 4, 0, 4294966523, 3, 0, 4, 2, 15, 2, 60, 2, 0, 0, 4294836735, 0, 3221225471, 0, 4294901942, 2, 61, 0, 134152192, 3, 0, 2, 0, 4294951935, 3, 0, 2, 0, 2683305983, 0, 2684354047, 2, 17, 2, 0, 0, 4294961151, 3, 0, 2, 2, 20, 2, 0, 0, 608174079, 2, 0, 2, 127, 2, 6, 2, 62, -1, 2, 64, 2, 26, 2, 1, 3, 0, 3, 0, 4294901711, 2, 40, 0, 4089839103, 0, 2961209759, 0, 1342439375, 0, 4294543342, 0, 3547201023, 0, 1577204103, 0, 4194240, 0, 4294688750, 2, 2, 0, 80831, 0, 4261478351, 0, 4294549486, 2, 2, 0, 2965387679, 0, 196559, 0, 3594373100, 0, 3288319768, 0, 8469959, 2, 171, 0, 4294828031, 0, 3825204735, 0, 123747807, 0, 65487, 2, 3, 0, 4092591615, 0, 1080049119, 0, 458703, 2, 3, 2, 0, 0, 2163244511, 0, 4227923919, 0, 4236247020, 2, 68, 0, 4284449919, 0, 851904, 2, 4, 2, 16, 0, 67076095, -1, 2, 69, 0, 1006628014, 0, 4093591391, -1, 0, 50331649, 0, 3265266687, 2, 34, 0, 4294844415, 0, 4278190047, 2, 23, 2, 125, -1, 3, 0, 2, 2, 33, 2, 0, 2, 9, 2, 0, 2, 13, 2, 14, 3, 0, 10, 2, 71, 2, 0, 2, 72, 2, 73, 2, 74, 2, 0, 2, 75, 2, 0, 2, 10, 0, 261632, 2, 19, 3, 0, 2, 2, 11, 2, 4, 3, 0, 18, 2, 76, 2, 5, 3, 0, 2, 2, 77, 0, 2088959, 2, 31, 2, 8, 0, 909311, 3, 0, 2, 0, 814743551, 2, 42, 0, 67057664, 3, 0, 2, 2, 45, 2, 0, 2, 32, 2, 0, 2, 18, 2, 7, 0, 268374015, 2, 30, 2, 51, 2, 0, 2, 78, 0, 134153215, -1, 2, 6, 2, 0, 2, 7, 0, 2684354559, 0, 67044351, 0, 1073676416, -2, 3, 0, 2, 2, 43, 0, 1046528, 3, 0, 3, 2, 8, 2, 0, 2, 41, 0, 4294960127, 2, 9, 2, 39, 2, 10, 0, 4294377472, 2, 21, 3, 0, 7, 0, 4227858431, 3, 0, 8, 2, 11, 2, 0, 2, 80, 2, 9, 2, 0, 2, 81, 2, 82, 2, 83, -1, 2, 122, 0, 1048577, 2, 84, 2, 12, -1, 2, 12, 0, 131042, 2, 85, 2, 86, 2, 87, 2, 0, 2, 35, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 1046559, 2, 0, 2, 13, 2, 0, 0, 2147516671, 2, 24, 3, 88, 2, 2, 0, -16, 2, 89, 0, 524222462, 2, 4, 2, 0, 0, 4269801471, 2, 4, 2, 0, 2, 14, 2, 79, 2, 15, 3, 0, 2, 2, 49, 2, 16, -1, 2, 17, -16, 3, 0, 205, 2, 18, -2, 3, 0, 655, 2, 19, 3, 0, 36, 2, 70, -1, 2, 17, 2, 9, 3, 0, 8, 2, 91, 2, 119, 2, 0, 0, 3220242431, 3, 0, 3, 2, 20, 2, 22, 2, 92, 3, 0, 2, 2, 93, 2, 21, -1, 2, 22, 2, 0, 2, 27, 2, 0, 2, 8, 3, 0, 2, 0, 67043391, 0, 3909091327, 2, 0, 2, 25, 2, 8, 2, 23, 3, 0, 2, 0, 67076097, 2, 7, 2, 0, 2, 24, 0, 67059711, 0, 4236247039, 3, 0, 2, 0, 939524103, 0, 8191999, 2, 97, 2, 98, 2, 14, 2, 95, 3, 0, 3, 0, 67057663, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 25, 3, 0, 2, 2, 21, -1, 0, 3774349439, 2, 101, 2, 102, 3, 0, 2, 2, 20, 2, 26, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 47, 2, 0, 2, 27, 2, 103, 2, 19, 0, 1638399, 2, 169, 2, 104, 3, 0, 3, 2, 23, 2, 28, 2, 29, 2, 5, 2, 30, 2, 0, 2, 7, 2, 105, -1, 2, 106, 2, 107, 2, 108, -1, 3, 0, 3, 2, 16, -2, 2, 0, 2, 31, -3, 2, 146, -4, 2, 23, 2, 0, 2, 37, 0, 1, 2, 0, 2, 63, 2, 32, 2, 16, 2, 9, 2, 0, 2, 109, -1, 3, 0, 4, 2, 9, 2, 33, 2, 110, 2, 6, 2, 0, 2, 111, 2, 0, 2, 50, -4, 3, 0, 9, 2, 24, 2, 18, 2, 27, -4, 2, 112, 2, 113, 2, 18, 2, 24, 2, 7, -2, 2, 114, 2, 18, 2, 21, -2, 2, 0, 2, 115, -2, 0, 4277137519, 0, 2269118463, -1, 3, 23, 2, -1, 2, 34, 2, 38, 2, 0, 3, 18, 2, 2, 36, 2, 20, -3, 3, 0, 2, 2, 35, -1, 2, 0, 2, 36, 2, 0, 2, 36, 2, 0, 2, 48, -14, 2, 23, 2, 44, 2, 37, -5, 3, 0, 2, 2, 38, 0, 2147549120, 2, 0, 2, 16, 2, 17, 2, 130, 2, 0, 2, 52, 0, 4294901872, 0, 5242879, 3, 0, 2, 0, 402595359, -1, 2, 118, 0, 1090519039, -2, 2, 120, 2, 39, 2, 0, 2, 55, 2, 40, 0, 4226678271, 0, 3766565279, 0, 2039759, -4, 3, 0, 2, 0, 1140787199, -1, 3, 0, 2, 0, 67043519, -5, 2, 0, 0, 4282384383, 0, 1056964609, -1, 3, 0, 2, 0, 67043345, -1, 2, 0, 2, 41, 2, 42, -1, 2, 10, 2, 43, -6, 2, 0, 2, 16, -3, 3, 0, 2, 0, 2147484671, -8, 2, 0, 2, 7, 2, 44, 2, 0, 0, 603979727, -1, 2, 0, 2, 45, -8, 2, 54, 2, 46, 0, 67043329, 2, 123, 2, 47, 0, 8388351, -2, 2, 124, 0, 3028287487, 2, 48, 2, 126, 0, 33259519, 2, 42, -9, 2, 24, -8, 3, 0, 28, 2, 21, -3, 3, 0, 3, 2, 49, 3, 0, 6, 2, 50, -85, 3, 0, 33, 2, 49, -126, 3, 0, 18, 2, 38, -269, 3, 0, 17, 2, 45, 2, 7, 2, 42, -2, 2, 17, 2, 51, 2, 0, 2, 24, 0, 67043343, 2, 128, 2, 19, -21, 3, 0, 2, -4, 3, 0, 2, 0, 4294901791, 2, 7, 2, 164, -2, 0, 3, 3, 0, 191, 2, 20, 3, 0, 23, 2, 36, -296, 3, 0, 8, 2, 7, -2, 2, 17, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 129, 0, 1677656575, -166, 0, 4161266656, 0, 4071, 0, 15360, -4, 0, 28, -13, 3, 0, 2, 2, 52, 2, 0, 2, 131, 2, 132, 2, 56, 2, 0, 2, 133, 2, 134, 2, 135, 3, 0, 10, 2, 136, 2, 137, 2, 14, 3, 52, 2, 3, 53, 2, 3, 54, 2, 0, 4294954999, 2, 0, -16, 2, 0, 2, 90, 2, 0, 0, 2105343, 0, 4160749584, 0, 65534, -42, 0, 4194303871, 0, 2011, -62, 3, 0, 6, 0, 8323103, -1, 3, 0, 2, 2, 55, -37, 2, 56, 2, 140, 2, 141, 2, 142, 2, 143, 2, 144, -138, 3, 0, 1334, 2, 24, -1, 3, 0, 129, 2, 31, 3, 0, 6, 2, 9, 3, 0, 180, 2, 145, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -22583, 3, 0, 7, 2, 19, -6130, 3, 5, 2, -1, 0, 69207040, 3, 46, 2, 3, 0, 14, 2, 57, 2, 58, -3, 0, 3168731136, 0, 4294956864, 2, 1, 2, 0, 2, 59, 3, 0, 4, 0, 4294966275, 3, 0, 4, 2, 15, 2, 60, 2, 0, 2, 35, -1, 2, 17, 2, 61, -1, 2, 0, 2, 62, 0, 4294885376, 3, 0, 2, 0, 3145727, 0, 2617294944, 0, 4294770688, 2, 19, 2, 63, 3, 0, 2, 0, 131135, 2, 94, 0, 70256639, 0, 71303167, 0, 272, 2, 45, 2, 62, -1, 2, 64, -2, 2, 96, 0, 603979775, 0, 4278255616, 0, 4294836227, 0, 4294549473, 0, 600178175, 0, 2952806400, 0, 268632067, 0, 4294543328, 0, 57540095, 0, 1577058304, 0, 1835008, 0, 4294688736, 2, 65, 2, 66, 0, 33554435, 2, 121, 2, 65, 2, 147, 0, 131075, 0, 3594373096, 0, 67094296, 2, 66, -1, 2, 67, 0, 603979263, 2, 156, 0, 3, 0, 4294828001, 0, 602930687, 2, 180, 0, 393219, 2, 67, 0, 671088639, 0, 2154840064, 0, 4227858435, 0, 4236247008, 2, 68, 2, 38, -1, 2, 4, 0, 917503, 2, 38, -1, 2, 69, 0, 537783470, 0, 4026531935, -1, 0, 1, -1, 2, 34, 2, 70, 0, 7936, -3, 2, 0, 0, 2147485695, 0, 1010761728, 0, 4292984930, 0, 16387, 2, 0, 2, 13, 2, 14, 3, 0, 10, 2, 71, 2, 0, 2, 72, 2, 73, 2, 74, 2, 0, 2, 75, 2, 0, 2, 16, -1, 2, 19, 3, 0, 2, 2, 11, 2, 4, 3, 0, 18, 2, 76, 2, 5, 3, 0, 2, 2, 77, 0, 253951, 3, 20, 2, 0, 122879, 2, 0, 2, 8, 0, 276824064, -2, 3, 0, 2, 2, 45, 2, 0, 0, 4294903295, 2, 0, 2, 18, 2, 7, -1, 2, 17, 2, 51, 2, 0, 2, 78, 2, 42, -1, 2, 24, 2, 0, 2, 31, -2, 0, 128, -2, 2, 79, 2, 8, 0, 4064, -1, 2, 117, 0, 4227907585, 2, 0, 2, 116, 2, 0, 2, 50, 2, 196, 2, 9, 2, 39, 2, 10, -1, 0, 6544896, 3, 0, 6, -2, 3, 0, 8, 2, 11, 2, 0, 2, 80, 2, 9, 2, 0, 2, 81, 2, 82, 2, 83, -3, 2, 84, 2, 12, -3, 2, 85, 2, 86, 2, 87, 2, 0, 2, 35, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 817183, 2, 0, 2, 13, 2, 0, 0, 33023, 2, 24, 3, 88, 2, -17, 2, 89, 0, 524157950, 2, 4, 2, 0, 2, 90, 2, 4, 2, 0, 2, 14, 2, 79, 2, 15, 3, 0, 2, 2, 49, 2, 16, -1, 2, 17, -16, 3, 0, 205, 2, 18, -2, 3, 0, 655, 2, 19, 3, 0, 36, 2, 70, -1, 2, 17, 2, 9, 3, 0, 8, 2, 91, 0, 3072, 2, 0, 0, 2147516415, 2, 9, 3, 0, 2, 2, 19, 2, 22, 2, 92, 3, 0, 2, 2, 93, 2, 21, -1, 2, 22, 0, 4294965179, 0, 7, 2, 0, 2, 8, 2, 92, 2, 8, -1, 0, 1761345536, 2, 94, 2, 95, 2, 38, 2, 23, 2, 96, 2, 36, 2, 162, 0, 2080440287, 2, 0, 2, 35, 2, 138, 0, 3296722943, 2, 0, 0, 1046675455, 0, 939524101, 0, 1837055, 2, 97, 2, 98, 2, 14, 2, 95, 3, 0, 3, 0, 7, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 25, 3, 0, 2, 2, 21, -1, 0, 2700607615, 2, 101, 2, 102, 3, 0, 2, 2, 20, 2, 26, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 47, 2, 0, 2, 27, 2, 103, -3, 2, 104, 3, 0, 3, 2, 23, -1, 3, 5, 2, 2, 30, 2, 0, 2, 7, 2, 105, -1, 2, 106, 2, 107, 2, 108, -1, 3, 0, 3, 2, 16, -2, 2, 0, 2, 31, -8, 2, 23, 2, 0, 2, 37, -1, 2, 0, 2, 63, 2, 32, 2, 18, 2, 9, 2, 0, 2, 109, -1, 3, 0, 4, 2, 9, 2, 17, 2, 110, 2, 6, 2, 0, 2, 111, 2, 0, 2, 50, -4, 3, 0, 9, 2, 24, 2, 18, 2, 27, -4, 2, 112, 2, 113, 2, 18, 2, 24, 2, 7, -2, 2, 114, 2, 18, 2, 21, -2, 2, 0, 2, 115, -2, 0, 4277075969, 2, 18, -1, 3, 23, 2, -1, 2, 34, 2, 139, 2, 0, 3, 18, 2, 2, 36, 2, 20, -3, 3, 0, 2, 2, 35, -1, 2, 0, 2, 36, 2, 0, 2, 36, 2, 0, 2, 50, -14, 2, 23, 2, 44, 2, 116, -5, 2, 117, 2, 41, -2, 2, 117, 2, 19, 2, 17, 2, 35, 2, 117, 2, 38, 0, 4294901776, 0, 4718591, 2, 117, 2, 36, 0, 335544350, -1, 2, 118, 2, 119, -2, 2, 120, 2, 39, 2, 7, -1, 2, 121, 2, 65, 0, 3758161920, 0, 3, -4, 2, 0, 2, 31, 2, 174, -1, 2, 0, 2, 19, 0, 176, -5, 2, 0, 2, 49, 2, 182, -1, 2, 0, 2, 19, 2, 194, -1, 2, 0, 2, 62, -2, 2, 16, -7, 2, 0, 2, 119, -3, 3, 0, 2, 2, 122, -8, 0, 4294965249, 0, 67633151, 0, 4026597376, 2, 0, 0, 536871887, -1, 2, 0, 2, 45, -8, 2, 54, 2, 49, 0, 1, 2, 123, 2, 19, -3, 2, 124, 2, 37, 2, 125, 2, 126, 0, 16778239, -10, 2, 36, -8, 3, 0, 28, 2, 21, -3, 3, 0, 3, 2, 49, 3, 0, 6, 2, 50, -85, 3, 0, 33, 2, 49, -126, 3, 0, 18, 2, 38, -269, 3, 0, 17, 2, 45, 2, 7, -3, 2, 17, 2, 127, 2, 0, 2, 19, 2, 50, 2, 128, 2, 19, -21, 3, 0, 2, -4, 3, 0, 2, 0, 65567, -1, 2, 26, -2, 0, 3, 3, 0, 191, 2, 20, 3, 0, 23, 2, 36, -296, 3, 0, 8, 2, 7, -2, 2, 17, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 129, 2, 130, -187, 3, 0, 2, 2, 52, 2, 0, 2, 131, 2, 132, 2, 56, 2, 0, 2, 133, 2, 134, 2, 135, 3, 0, 10, 2, 136, 2, 137, 2, 14, 3, 52, 2, 3, 53, 2, 3, 54, 2, 2, 138, -129, 3, 0, 6, 2, 139, -1, 3, 0, 2, 2, 50, -37, 2, 56, 2, 140, 2, 141, 2, 142, 2, 143, 2, 144, -138, 3, 0, 1334, 2, 24, -1, 3, 0, 129, 2, 31, 3, 0, 6, 2, 9, 3, 0, 180, 2, 145, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -28719, 2, 0, 0, 1, -1, 2, 122, 2, 0, 0, 8193, -21, 0, 50331648, 0, 10255, 0, 4, -11, 2, 66, 2, 168, -1, 0, 71680, -1, 2, 157, 0, 4292900864, 0, 805306431, -5, 2, 146, -1, 2, 176, -1, 0, 6144, -2, 2, 123, -1, 2, 150, -1, 2, 153, 2, 147, 2, 161, 2, 0, 0, 3223322624, 2, 36, 0, 4, -4, 2, 188, 0, 205128192, 0, 1333757536, 0, 2147483696, 0, 423953, 0, 747766272, 0, 2717763192, 0, 4286578751, 0, 278545, 2, 148, 0, 4294886464, 0, 33292336, 0, 417809, 2, 148, 0, 1329579616, 0, 4278190128, 0, 700594195, 0, 1006647527, 0, 4286497336, 0, 4160749631, 2, 149, 0, 469762560, 0, 4171219488, 0, 16711728, 2, 149, 0, 202375680, 0, 3214918176, 0, 4294508592, 0, 139280, -1, 0, 983584, 2, 190, 0, 58720275, 0, 3489923072, 0, 10517376, 0, 4293066815, 0, 1, 0, 2013265920, 2, 175, 2, 0, 0, 17816169, 0, 3288339281, 0, 201375904, 2, 0, -2, 0, 256, 0, 122880, 0, 16777216, 2, 146, 0, 4160757760, 2, 0, -6, 2, 163, -11, 0, 3263218176, -1, 0, 49664, 0, 2160197632, 0, 8388802, -1, 0, 12713984, -1, 2, 150, 2, 155, 2, 158, -2, 2, 159, -20, 0, 3758096385, -2, 2, 151, 0, 4292878336, 2, 22, 2, 166, 0, 4294057984, -2, 2, 160, 2, 152, 2, 172, -2, 2, 151, -1, 2, 179, -1, 2, 167, 2, 122, 0, 4026593280, 0, 14, 0, 4292919296, -1, 2, 154, 0, 939588608, -1, 0, 805306368, -1, 2, 122, 0, 1610612736, 2, 152, 2, 153, 3, 0, 2, -2, 2, 154, 2, 155, -3, 0, 267386880, -1, 2, 156, 0, 7168, -1, 0, 65024, 2, 150, 2, 157, 2, 158, -7, 2, 165, -8, 2, 159, -1, 0, 1426112704, 2, 160, -1, 2, 185, 0, 271581216, 0, 2149777408, 2, 19, 2, 157, 2, 122, 0, 851967, 0, 3758129152, -1, 2, 19, 2, 178, -4, 2, 154, -20, 2, 192, 2, 161, -56, 0, 3145728, 2, 184, -1, 2, 191, 2, 122, -1, 2, 162, 2, 122, -4, 0, 32505856, -1, 2, 163, -1, 0, 2147385088, 2, 22, 1, 2155905152, 2, -3, 2, 164, 2, 0, 2, 165, -2, 2, 166, -6, 2, 167, 0, 4026597375, 0, 1, -1, 0, 1, -1, 2, 168, -3, 2, 139, 2, 66, -2, 2, 162, 2, 177, -1, 2, 173, 2, 122, -6, 2, 122, -213, 2, 167, -657, 2, 17, -36, 2, 169, -1, 2, 186, -10, 0, 4294963200, -5, 2, 170, -5, 2, 158, 2, 0, 2, 24, -1, 0, 4227919872, -1, 2, 170, -2, 0, 4227874752, -3, 0, 2146435072, 2, 155, -2, 0, 1006649344, 2, 122, -1, 2, 22, 0, 201375744, -3, 0, 134217720, 2, 22, 0, 4286677377, 0, 32896, -1, 2, 171, -3, 2, 172, -349, 2, 173, 2, 174, 2, 175, 3, 0, 264, -11, 2, 176, -2, 2, 158, 2, 0, 0, 520617856, 0, 2692743168, 0, 36, -3, 0, 524284, -11, 2, 19, -1, 2, 183, -1, 2, 181, 0, 3221291007, 2, 158, -1, 0, 524288, 0, 2158720, -3, 2, 155, 0, 1, -4, 2, 122, 0, 3808625411, 0, 3489628288, 0, 4096, 0, 1207959680, 0, 3221274624, 2, 0, -3, 2, 177, 0, 120, 0, 7340032, -2, 0, 4026564608, 2, 4, 2, 19, 2, 160, 3, 0, 4, 2, 155, -1, 2, 178, 2, 175, -1, 0, 8176, 2, 179, 2, 177, 2, 180, -1, 0, 4290773232, 2, 0, -4, 2, 160, 2, 187, 0, 15728640, 2, 175, -1, 2, 157, -1, 0, 4294934512, 3, 0, 4, -9, 2, 22, 2, 167, 2, 181, 3, 0, 4, 0, 704, 0, 1849688064, 0, 4194304, -1, 2, 122, 0, 4294901887, 2, 0, 0, 130547712, 0, 1879048192, 0, 2080374784, 3, 0, 2, -1, 2, 182, 2, 183, -1, 0, 17829776, 0, 2025848832, 0, 4261477888, -2, 2, 0, -1, 0, 4286580608, -1, 0, 29360128, 2, 184, 0, 16252928, 0, 3791388672, 2, 39, 3, 0, 2, -2, 2, 193, 2, 0, -1, 2, 26, -1, 0, 66584576, -1, 2, 189, 3, 0, 9, 2, 122, 3, 0, 4, -1, 2, 157, 2, 158, 3, 0, 5, -2, 0, 245760, 0, 2147418112, -1, 2, 146, 2, 199, 0, 4227923456, -1, 2, 185, 2, 186, 2, 22, -2, 2, 176, 0, 4292870145, 0, 262144, 2, 122, 3, 0, 2, 0, 1073758848, 2, 187, -1, 0, 4227921920, 2, 188, 0, 68289024, 0, 528402016, 0, 4292927536, 3, 0, 4, -2, 0, 2483027968, 2, 0, -2, 2, 189, 3, 0, 5, -1, 2, 184, 2, 160, 2, 0, -2, 0, 4227923936, 2, 63, -1, 2, 170, 2, 94, 2, 0, 2, 150, 2, 154, 3, 0, 6, -1, 2, 175, 3, 0, 3, -2, 0, 2146959360, 3, 0, 8, -2, 2, 157, -1, 2, 190, 2, 117, -1, 2, 151, 3, 0, 8, 2, 191, 0, 8388608, 2, 171, 2, 169, 2, 183, 0, 4286578944, 3, 0, 2, 0, 1152, 0, 1266679808, 2, 189, 0, 576, 0, 4261707776, 2, 94, 3, 0, 9, 2, 151, 3, 0, 8, -28, 2, 158, 3, 0, 3, -3, 0, 4292902912, -6, 2, 96, 3, 0, 85, -33, 2, 164, 3, 0, 126, -18, 2, 192, 3, 0, 269, -17, 2, 151, 2, 122, 0, 4294917120, 3, 0, 2, 2, 19, 0, 4290822144, -2, 0, 67174336, 0, 520093700, 2, 17, 3, 0, 21, -2, 2, 177, 3, 0, 3, -2, 0, 65504, 2, 122, 2, 49, 3, 0, 2, 2, 92, -191, 2, 123, -23, 2, 26, 3, 0, 296, -8, 2, 122, 3, 0, 2, 2, 19, -11, 2, 175, 3, 0, 72, -3, 0, 3758159872, 0, 201391616, 3, 0, 155, -7, 2, 167, -1, 0, 384, -1, 0, 133693440, -3, 2, 193, -2, 2, 30, 3, 0, 4, 2, 166, -2, 2, 22, 2, 151, 3, 0, 4, -2, 2, 185, -1, 2, 146, 0, 335552923, 2, 194, -1, 0, 538974272, 0, 2214592512, 0, 132000, -10, 0, 192, -8, 0, 12288, -21, 0, 134213632, 0, 4294901761, 3, 0, 42, 0, 100663424, 0, 4294965284, 3, 0, 62, -6, 0, 4286578784, 2, 0, -2, 0, 1006696448, 3, 0, 24, 2, 37, -1, 2, 195, 3, 0, 10, 2, 194, 0, 4110942569, 0, 1432950139, 0, 2701658217, 0, 4026532864, 0, 4026532881, 2, 0, 2, 47, 3, 0, 8, -1, 2, 154, -2, 2, 166, 0, 98304, 0, 65537, 2, 167, 2, 169, -2, 2, 154, -1, 2, 63, 2, 0, 2, 116, 2, 197, 2, 175, 0, 4294770176, 2, 30, 3, 0, 4, -30, 2, 195, 2, 196, -3, 2, 166, -2, 2, 151, 2, 0, 2, 154, -1, 2, 189, -1, 2, 157, 2, 198, 3, 0, 2, 2, 154, 2, 122, -1, 0, 193331200, -1, 0, 4227923960, 2, 197, -1, 3, 0, 3, 2, 198, 3, 0, 44, -1334, 2, 22, 2, 0, -129, 2, 195, -6, 2, 160, -180, 2, 199, -233, 2, 4, 3, 0, 96, -16, 2, 160, 3, 0, 22583, -7, 2, 17, 3, 0, 6128], [4294967295, 4294967291, 4092460543, 4294828015, 4294967294, 134217726, 268435455, 2147483647, 1048575, 1073741823, 3892314111, 1061158911, 536805376, 4294910143, 4160749567, 4294901759, 134217727, 4294901760, 4194303, 65535, 262143, 67108863, 4286578688, 536870911, 8388607, 4294918143, 4294443008, 255, 67043328, 2281701374, 4294967232, 2097151, 4294903807, 4294902783, 4294967039, 511, 524287, 131071, 127, 4294902271, 4294549487, 16777215, 1023, 67047423, 4294901888, 33554431, 4286578687, 4294770687, 67043583, 32767, 15, 2047999, 4292870143, 4294934527, 4294966783, 67045375, 4294967279, 262083, 20511, 4290772991, 41943039, 493567, 2047, 4294959104, 1071644671, 602799615, 65536, 4294828000, 805044223, 4277151126, 8191, 1031749119, 4294917631, 2134769663, 4286578493, 4282253311, 4294942719, 33540095, 4294905855, 4294967264, 2868854591, 1608515583, 265232348, 534519807, 2147614720, 1060109444, 4093640016, 17376, 2139062143, 224, 4169138175, 4294909951, 4294967292, 4294965759, 4294966272, 4294901823, 4294967280, 8289918, 4294934399, 4294901775, 4294965375, 1602223615, 4294967259, 268369920, 4292804608, 486341884, 4294963199, 3087007615, 1073692671, 4128527, 4279238655, 4294902015, 4294966591, 2445279231, 3670015, 3238002687, 63, 4294967288, 4294705151, 4095, 3221208447, 4294549472, 2147483648, 4294705152, 4294966143, 64, 4294966719, 16383, 3774873592, 536807423, 67043839, 3758096383, 3959414372, 3755993023, 2080374783, 4294835295, 4294967103, 4160749565, 4087, 31, 184024726, 2862017156, 1593309078, 268434431, 268434414, 4294901763, 536870912, 2952790016, 202506752, 139264, 402653184, 4261412864, 4227922944, 2147532800, 61440, 3758096384, 117440512, 65280, 4227858432, 3233808384, 3221225472, 4294965248, 32768, 57152, 4294934528, 67108864, 4293918720, 4290772992, 25165824, 57344, 4278190080, 65472, 4227907584, 65520, 1920, 4026531840, 49152, 4160749568, 4294836224, 63488, 1073741824, 4294967040, 251658240, 196608, 12582912, 2097152, 65408, 64512, 417808, 4227923712, 48, 512, 4294967168, 4294966784, 16, 4292870144, 4227915776, 65528, 4294950912, 65532]); + + /**
+ * Return the next unicodechar in the stream
+ *
+ * @param parser Parser object
+ */
+ function nextUnicodeChar(parser) {
+ const { index } = parser;
+ const hi = parser.source.charCodeAt(index);
+ if (hi < 55296 /* LeadSurrogateMin */ || hi > 56319 /* LeadSurrogateMax */)
+ return hi;
+ const lo = parser.source.charCodeAt(index + 1);
+ if (lo < 56320 /* TrailSurrogateMin */ || lo > 57343 /* TrailSurrogateMax */)
+ return hi;
+ return 65536 /* NonBMPMin */ + ((hi & 0x3FF) << 10) | lo & 0x3FF;
+ }
+ /**
+ * Returns true if this is a valid identifier part
+ *
+ * @param code Codepoint
+ */
+ const isIdentifierPart = (code) => (characterType[code] & 1 /* IdentifierStart */) !== 0 || isValidIdentifierPart(code);
+ function escapeInvalidCharacters(code) {
+ switch (code) {
+ case 0 /* Null */:
+ return '\\0';
+ case 8 /* Backspace */:
+ return '\\b';
+ case 9 /* Tab */:
+ return '\\t';
+ case 10 /* LineFeed */:
+ return '\\n';
+ case 11 /* VerticalTab */:
+ return '\\v';
+ case 12 /* FormFeed */:
+ return '\\f';
+ case 13 /* CarriageReturn */:
+ return '\\r';
+ default:
+ if (!mustEscape(code))
+ return fromCodePoint(code);
+ if (code < 0x10)
+ return `\\x0${code.toString(16)}`;
+ if (code < 0x100)
+ return `\\x${code.toString(16)}`;
+ if (code < 0x1000)
+ return `\\u0${code.toString(16)}`;
+ if (code < 0x10000)
+ return `\\u${code.toString(16)}`;
+ return `\\u{${code.toString(16)}}`;
+ }
+ }
+ /**
+ * Consume an token in the scanner on match. This is an equalent to
+ * 'consume' used in the parser code itself.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeOpt(parser, code) {
+ if (parser.source.charCodeAt(parser.index) !== code)
+ return false;
+ parser.index++;
+ parser.column++;
+ return true;
+ }
+ /**
+ * Consumes line feed
+ *
+ * @param parser Parser object
+ * @param state Scanner state
+ */
+ function consumeLineFeed(parser, state) {
+ parser.flags |= Flags.NewLine;
+ parser.index++;
+ if ((state & ScannerState.LastIsCR) === 0) {
+ parser.column = 0;
+ parser.line++;
+ }
+ }
+ /**
+ * Scans private name. Stage 3 proposal related
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanPrivateName(parser, context) {
+ if (!(context & Context.InClass) || !isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return 115 /* Hash */;
+ }
+ /**
+ * Advance to new line
+ *
+ * @param parser Parser object
+ */
+ function advanceNewline(parser) {
+ parser.flags |= Flags.NewLine;
+ parser.index++;
+ parser.column = 0;
+ parser.line++;
+ }
+ const fromCodePoint = (code) => {
+ return code <= 0xFFFF ?
+ String.fromCharCode(code) :
+ String.fromCharCode(((code - 65536 /* NonBMPMin */) >> 10) + 55296 /* LeadSurrogateMin */, ((code - 65536 /* NonBMPMin */) & (1024 - 1)) + 56320 /* TrailSurrogateMin */);
+ };
+ function readNext(parser) {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.source.length)
+ report(parser, 14 /* UnicodeOutOfRange */);
+ return nextUnicodeChar(parser);
+ }
+ function toHex(code) {
+ if (code < 48 /* Zero */)
+ return -1;
+ if (code <= 57 /* Nine */)
+ return code - 48 /* Zero */;
+ if (code < 65 /* UpperA */)
+ return -1;
+ if (code <= 70 /* UpperF */)
+ return code - 65 /* UpperA */ + 10;
+ if (code < 97 /* LowerA */)
+ return -1;
+ if (code <= 102 /* LowerF */)
+ return code - 97 /* LowerA */ + 10;
+ return -1;
+ }
+ function advanceOnMaybeAstral(parser, ch) {
+ parser.index++;
+ parser.column++;
+ if (ch > 0xFFFF)
+ parser.index++;
+ } + + /**
+ * Scan escape sequence
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanEscapeSequence(parser, context, first) {
+ switch (first) {
+ case 98 /* LowerB */:
+ return 8 /* Backspace */;
+ case 102 /* LowerF */:
+ return 12 /* FormFeed */;
+ case 114 /* LowerR */:
+ return 13 /* CarriageReturn */;
+ case 110 /* LowerN */:
+ return 10 /* LineFeed */;
+ case 116 /* LowerT */:
+ return 9 /* Tab */;
+ case 118 /* LowerV */:
+ return 11 /* VerticalTab */;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ return Escape.Empty;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ {
+ // 1 to 3 octal digits
+ let code = first - 48 /* Zero */;
+ let index = parser.index + 1;
+ let column = parser.column + 1;
+ let next = parser.source.charCodeAt(index);
+ if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ // Strict mode code allows only \0, then a non-digit.
+ if (code !== 0 || next === 56 /* Eight */ || next === 57 /* Nine */) {
+ if (context & Context.Strict)
+ return Escape.StrictOctal;
+ parser.flags |= Flags.HasOctal;
+ }
+ }
+ else if (context & Context.Strict) {
+ return Escape.StrictOctal;
+ }
+ else {
+ parser.flags |= Flags.HasOctal;
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ parser.index = index - 1;
+ parser.column = column - 1;
+ }
+ return code;
+ }
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ // 1 to 2 octal digits
+ if (context & Context.Strict)
+ return Escape.StrictOctal;
+ let code = first - 48 /* Zero */;
+ const index = parser.index + 1;
+ const column = parser.column + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ code = code * 8 + (next - 48 /* Zero */);
+ parser.lastValue = next;
+ parser.index = index;
+ parser.column = column;
+ }
+ return code;
+ }
+ // `8`, `9` (invalid escapes)
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return Escape.EightOrNine;
+ // ASCII escapes
+ case 120 /* LowerX */:
+ {
+ const ch1 = parser.lastValue = readNext(parser);
+ const hi = toHex(ch1);
+ if (hi < 0)
+ return Escape.InvalidHex;
+ const ch2 = parser.lastValue = readNext(parser);
+ const lo = toHex(ch2);
+ if (lo < 0)
+ return Escape.InvalidHex;
+ return hi << 4 | lo;
+ }
+ // UCS-2/Unicode escapes
+ case 117 /* LowerU */:
+ {
+ let ch = parser.lastValue = readNext(parser);
+ if (ch === 123 /* LeftBrace */) {
+ ch = parser.lastValue = readNext(parser);
+ let code = toHex(ch);
+ if (code < 0)
+ return Escape.InvalidHex;
+ ch = parser.lastValue = readNext(parser);
+ while (ch !== 125 /* RightBrace */) {
+ const digit = toHex(ch);
+ if (digit < 0)
+ return Escape.InvalidHex;
+ code = code * 16 + digit;
+ // Code point out of bounds
+ if (code > 1114111 /* NonBMPMax */)
+ return Escape.OutOfRange;
+ ch = parser.lastValue = readNext(parser);
+ }
+ return code;
+ }
+ else {
+ // \uNNNN
+ let codePoint = toHex(ch);
+ if (codePoint < 0)
+ return Escape.InvalidHex;
+ for (let i = 0; i < 3; i++) {
+ ch = parser.lastValue = readNext(parser);
+ const digit = toHex(ch);
+ if (digit < 0)
+ return Escape.InvalidHex;
+ codePoint = codePoint * 16 + digit;
+ }
+ return codePoint;
+ }
+ }
+ default:
+ return parser.source.charCodeAt(parser.index);
+ }
+ }
+ /**
+ * Throws a string error for either string or template literal
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function throwStringError(parser, context, code) {
+ switch (code) {
+ case Escape.Empty:
+ return;
+ case Escape.StrictOctal:
+ report(parser, context & Context.TaggedTemplate ?
+ 76 /* TemplateOctalLiteral */ :
+ 11 /* StrictOctalEscape */);
+ case Escape.EightOrNine:
+ report(parser, 13 /* InvalidEightAndNine */);
+ case Escape.InvalidHex:
+ report(parser, 75 /* MalformedEscape */, 'hexadecimal');
+ case Escape.OutOfRange:
+ report(parser, 14 /* UnicodeOutOfRange */);
+ /* istanbul ignore next */
+ default:
+ // ignore
+ }
+ }
+ /**
+ * Scan a string literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote codepoint
+ */
+ function scanString(parser, context, quote) {
+ const { index: start, lastValue } = parser;
+ let ret = '';
+ parser.index++;
+ parser.column++; // consume quote
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ switch (ch) {
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ report(parser, 6 /* UnterminatedString */);
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch > 128 /* MaxAsciiCharacter */) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ const code = scanEscapeSequence(parser, context, ch);
+ if (code >= 0)
+ ret += fromCodePoint(code);
+ else
+ throwStringError(parser, context, code);
+ ch = parser.lastValue;
+ }
+ break;
+ default:
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++; // consume quote
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ return 33554435 /* StringLiteral */;
+ } + + /**
+ * Consumes template brace
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeTemplateBrace(parser, context) {
+ if (parser.index >= parser.length)
+ report(parser, 9 /* UnterminatedTemplate */);
+ // Upon reaching a '}', consume it and rewind the scanner state
+ parser.index--;
+ parser.column--;
+ return scanTemplate(parser, context);
+ }
+ /**
+ * Scan template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param first Codepoint
+ */
+ function scanTemplate(parser, context) {
+ const { index: start, lastValue } = parser;
+ let tail = true;
+ let ret = '';
+ let ch = readNext(parser);
+ loop: while (ch !== 96 /* Backtick */) {
+ switch (ch) {
+ // Break after a literal `${` (thus the dedicated code path).
+ case 36 /* Dollar */:
+ {
+ const index = parser.index + 1;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 123 /* LeftBrace */) {
+ parser.index = index;
+ parser.column++;
+ tail = false;
+ break loop;
+ }
+ ret += '$';
+ break;
+ }
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch >= 128) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ // Because octals are forbidden in escaped template sequences and the fact that
+ // both string and template scanning uses the same method - 'scanEscapeSequence',
+ // we set the strict context mask.
+ const code = scanEscapeSequence(parser, context | Context.Strict, ch);
+ if (code >= 0) {
+ ret += fromCodePoint(code);
+ }
+ else if (code !== Escape.Empty && context & Context.TaggedTemplate) {
+ ret = undefined;
+ ch = scanLooserTemplateSegment(parser, parser.lastValue);
+ if (ch < 0) {
+ tail = false;
+ }
+ break loop;
+ }
+ else {
+ throwStringError(parser, context | Context.TaggedTemplate, code);
+ }
+ ch = parser.lastValue;
+ }
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ // falls through
+ default:
+ if (ret != null)
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++;
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ if (tail) {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 1);
+ return 33554441 /* TemplateTail */;
+ }
+ else {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 2);
+ return 33554440 /* TemplateCont */;
+ }
+ }
+ /**
+ * Scan looser template segment
+ *
+ * @param parser Parser object
+ * @param ch codepoint
+ */
+ function scanLooserTemplateSegment(parser, ch) {
+ while (ch !== 96 /* Backtick */) {
+ if (ch === 36 /* Dollar */ && parser.source.charCodeAt(parser.index + 1) === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return -ch;
+ }
+ // Skip '\' and continue to scan the template token to search
+ // for the end, without validating any escape sequences
+ ch = readNext(parser);
+ }
+ return ch;
+ } + + // 11.8.3 Numeric Literals
+ /**
+ * Scans hex integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HexIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanHexIntegerLiteral(parser, context) {
+ parser.index++;
+ parser.column++;
+ let state = NumericState.None;
+ let value = toHex(parser.source.charCodeAt(parser.index));
+ if (value < 0)
+ report(parser, 0 /* Unexpected */);
+ parser.index++;
+ parser.column++;
+ while (parser.index < parser.length) {
+ const next = parser.source.charCodeAt(parser.index);
+ if (context & Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ const digit = toHex(next);
+ if (digit < 0)
+ break;
+ value = value * 16 + digit;
+ parser.index++;
+ parser.column++;
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+ }
+ /**
+ * Scans binary and octal integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalIntegerLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BinaryIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanOctalOrBinary(parser, context, base) {
+ parser.index++;
+ parser.column++;
+ let digits = 0;
+ let ch;
+ let value = 0;
+ let state = NumericState.None;
+ while (parser.index < parser.length) {
+ ch = parser.source.charCodeAt(parser.index);
+ if (context & Context.OptionsNext && ch === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ const converted = ch - 48 /* Zero */;
+ if (!(ch >= 48 /* Zero */ && ch <= 57 /* Nine */) || converted >= base)
+ break;
+ value = value * base + converted;
+ parser.index++;
+ parser.column++;
+ digits++;
+ }
+ if (digits === 0)
+ report(parser, 0 /* Unexpected */);
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+ }
+ /**
+ * Scans implicit octal digits
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalDigits)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanImplicitOctalDigits(parser, context) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ if (context & Context.Strict)
+ report(parser, 0 /* Unexpected */);
+ let index = parser.index;
+ let column = parser.column;
+ let code = 0;
+ parser.flags |= Flags.HasOctal;
+ // Implicit octal, unless there is a non-octal digit.
+ // (Annex B.1.1 on Numeric Literals)
+ while (index < parser.length) {
+ const next = parser.source.charCodeAt(index);
+ if (next === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ else if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ return scanNumericLiteral(parser, context);
+ }
+ else {
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ }
+ parser.index = index;
+ parser.column = column;
+ return assembleNumericLiteral(parser, context, code, consumeOpt(parser, 110 /* LowerN */));
+ }
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ parser.flags |= Flags.HasOctal;
+ default:
+ if (context & Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ return scanNumericLiteral(parser, context);
+ }
+ }
+ /**
+ * Scans signed integer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SignedInteger)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanSignedInteger(parser, end) {
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 43 /* Plus */ || next === 45 /* Hyphen */) {
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (!(next >= 48 /* Zero */ && next <= 57 /* Nine */)) {
+ report(parser, 0 /* Unexpected */);
+ }
+ const preNumericPart = parser.index;
+ const finalFragment = scanDecimalDigitsOrSeparator(parser);
+ return parser.source.substring(end, preNumericPart) + finalFragment;
+ }
+ /**
+ * Scans numeric literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanNumericLiteral(parser, context, state = NumericState.None) {
+ let value = state & NumericState.Float ?
+ 0 :
+ scanDecimalAsSmi(parser, context);
+ const next = parser.source.charCodeAt(parser.index);
+ // I know I'm causing a bug here. The question is - will anyone figure this out?
+ if (next !== 46 /* Period */ && next !== 95 /* Underscore */ && !isValidIdentifierStart(next)) {
+ return assembleNumericLiteral(parser, context, value);
+ }
+ if (consumeOpt(parser, 46 /* Period */)) {
+ if (context & Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ state |= NumericState.Float;
+ value = `${value}.${scanDecimalDigitsOrSeparator(parser)}`;
+ }
+ const end = parser.index;
+ if (consumeOpt(parser, 110 /* LowerN */)) {
+ if (state & NumericState.Float)
+ report(parser, 0 /* Unexpected */);
+ state |= NumericState.BigInt;
+ }
+ if (consumeOpt(parser, 101 /* LowerE */) || consumeOpt(parser, 69 /* UpperE */)) {
+ state |= NumericState.Float;
+ value += scanSignedInteger(parser, end);
+ }
+ if (isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 0 /* Unexpected */);
+ }
+ return assembleNumericLiteral(parser, context, state & NumericState.Float ? parseFloat(value) : parseInt(value, 10), !!(state & NumericState.BigInt));
+ }
+ /**
+ * Internal helper function for scanning numeric separators.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state NumericState state
+ */
+ function scanNumericSeparator(parser, state) {
+ parser.index++;
+ parser.column++;
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ state |= NumericState.SeenSeparator;
+ return state;
+ }
+ /**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanDecimalDigitsOrSeparator(parser) {
+ let start = parser.index;
+ let state = NumericState.None;
+ let ret = '';
+ loop: while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 95 /* Underscore */:
+ const preUnderscoreIndex = parser.index;
+ state = scanNumericSeparator(parser, state);
+ ret += parser.source.substring(start, preUnderscoreIndex);
+ start = parser.index;
+ continue;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ state = state & ~NumericState.SeenSeparator;
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ break loop;
+ }
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return ret + parser.source.substring(start, parser.index);
+ }
+ /**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanDecimalAsSmi(parser, context) {
+ let state = NumericState.None;
+ let value = 0;
+ let next = parser.source.charCodeAt(parser.index);
+ while (next >= 48 /* Zero */ && next <= 57 /* Nine */ || next === 95 /* Underscore */) {
+ if (context & Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ next = parser.source.charCodeAt(parser.index);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ value = value * 10 + (next - 48 /* Zero */);
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return value;
+ }
+ /**
+ * Internal helper function that assamble the number scanning parts and return
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param value The numeric value
+ */
+ function assembleNumericLiteral(parser, context, value, isBigInt = false) {
+ parser.tokenValue = value;
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ return isBigInt ? 33554551 /* BigIntLiteral */ : 33554434 /* NumericLiteral */;
+ } + + /**
+ * Scan identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanIdentifier(parser, context, first) {
+ let start = parser.index;
+ let ret = '';
+ let isEscaped = false;
+ if (first)
+ advanceOnMaybeAstral(parser, first);
+ loop: while (parser.index < parser.length) {
+ const index = parser.index;
+ let ch = parser.source.charCodeAt(index);
+ switch (ch) {
+ case 92 /* Backslash */:
+ ret += parser.source.slice(start, index);
+ ret += scanUnicodeCodePointEscape(parser);
+ start = parser.index;
+ isEscaped = true;
+ break;
+ default:
+ if (ch >= 0xD800 && ch <= 0xDBFF) {
+ const lo = parser.source.charCodeAt(index + 1);
+ ch = (ch & 0x3FF) << 10 | lo & 0x3FF | 0x10000;
+ }
+ if (!isIdentifierPart(ch))
+ break loop;
+ advanceOnMaybeAstral(parser, ch);
+ }
+ }
+ if (start < parser.index)
+ ret += parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ const len = ret.length;
+ // Keywords are between 2 and 11 characters long and start with a lowercase letter
+ // https://tc39.github.io/ecma262/#sec-keywords
+ if (len >= 2 && len <= 11) {
+ const token = descKeyword(ret);
+ if (token > 0) {
+ if (isEscaped) {
+ if (context & Context.DisallowEscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ // Here we fall back to a mutual parser flag if the escaped keyword isn't disallowed through
+ // context masks. This is similiar to how V8 does it - they are using an
+ // 'escaped_keyword' token.
+ // - J.K. Thomas
+ parser.flags |= Flags.EscapedKeyword;
+ }
+ return token;
+ }
+ }
+ if (context & Context.OptionsRawidentifiers)
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ return 33685505 /* Identifier */;
+ }
+ /**
+ * Scanning chars in the range 0...127, and treat them as an possible
+ * identifier. This allows subsequent checking to be faster.
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param first Code point
+ */
+ function scanMaybeIdentifier(parser, context, first) {
+ first = nextUnicodeChar(parser);
+ if (!isValidIdentifierStart(first)) {
+ report(parser, 10 /* UnexpectedChar */, escapeInvalidCharacters(first));
+ }
+ return scanIdentifier(parser, context, first);
+ }
+ /**
+ * Scan unicode codepoint escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanUnicodeCodePointEscape(parser) {
+ const { index } = parser;
+ if (index + 5 < parser.length) {
+ if (parser.source.charCodeAt(index + 1) !== 117 /* LowerU */) {
+ report(parser, 0 /* Unexpected */);
+ }
+ parser.index += 2;
+ parser.column += 2;
+ const code = scanIdentifierUnicodeEscape(parser);
+ if (code >= 55296 /* LeadSurrogateMin */ && code <= 56319 /* LeadSurrogateMax */) {
+ report(parser, 74 /* UnexpectedSurrogate */);
+ }
+ if (!isIdentifierPart(code)) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ return fromCodePoint(code);
+ }
+ report(parser, 0 /* Unexpected */);
+ }
+ /**
+ * Scan identifier unicode escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanIdentifierUnicodeEscape(parser) {
+ // Accept both \uxxxx and \u{xxxxxx}. In the latter case, the number of
+ // hex digits between { } is arbitrary. \ and u have already been read.
+ let ch = parser.source.charCodeAt(parser.index);
+ let codePoint = 0;
+ // '\u{DDDDDDDD}'
+ if (ch === 123 /* LeftBrace */) { // {
+ ch = readNext(parser);
+ let digit = toHex(ch);
+ while (digit >= 0) {
+ codePoint = (codePoint << 4) | digit;
+ if (codePoint > 1114111 /* NonBMPMax */) {
+ report(parser, 89 /* UndefinedUnicodeCodePoint */);
+ }
+ parser.index++;
+ parser.column++;
+ digit = toHex(parser.source.charCodeAt(parser.index));
+ }
+ if (parser.source.charCodeAt(parser.index) !== 125 /* RightBrace */) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ consumeOpt(parser, 125 /* RightBrace */);
+ // '\uDDDD'
+ }
+ else {
+ for (let i = 0; i < 4; i++) {
+ ch = parser.source.charCodeAt(parser.index);
+ const digit = toHex(ch);
+ if (digit < 0)
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ codePoint = (codePoint << 4) | digit;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ return codePoint;
+ } + + // 11.4 Comments
+ /**
+ * Skips single HTML comments. Same behavior as in V8.
+ *
+ * @param parser Parser Object
+ * @param context Context masks.
+ * @param state Scanner state
+ * @param type Comment type
+ */
+ function skipSingleHTMLComment(parser, context, state, type) {
+ if (context & Context.Module)
+ report(parser, 90 /* HtmlCommentInModule */);
+ return skipSingleLineComment(parser, context, state, type);
+ }
+ /**
+ * Skips SingleLineComment, SingleLineHTMLCloseComment and SingleLineHTMLOpenComment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SingleLineComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLOpenComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLCloseComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ * @param type Comment type
+ */
+ function skipSingleLineComment(parser, context, state, type) {
+ const start = parser.index;
+ const collectable = !!(context & Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 13 /* CarriageReturn */:
+ advanceNewline(parser);
+ if ((parser.index < parser.length) && parser.source.charCodeAt(parser.index) === 10 /* LineFeed */)
+ parser.index++;
+ return state | ScannerState.NewLine;
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ advanceNewline(parser);
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state | ScannerState.NewLine;
+ default:
+ parser.index++;
+ parser.column++;
+ }
+ }
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state;
+ }
+ /**
+ * Skips multiline comment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-MultiLineComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ */
+ function skipMultiLineComment(parser, context, state) {
+ const start = parser.index;
+ const collectable = !!(context & Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 42 /* Asterisk */:
+ parser.index++;
+ parser.column++;
+ state &= ~ScannerState.LastIsCR;
+ if (consumeOpt(parser, 47 /* Slash */)) {
+ if (collectable)
+ addComment(parser, context, 'MultiLine', start);
+ return state;
+ }
+ break;
+ // Mark multiline comments containing linebreaks as new lines
+ // so we can perfectly handle edge cases like: '1/*\n*/--> a comment'
+ case 13 /* CarriageReturn */:
+ state |= ScannerState.NewLine | ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ break;
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ default:
+ state &= ~ScannerState.LastIsCR;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ // Unterminated multi-line comment.
+ tolerant(parser, context, 8 /* UnterminatedComment */);
+ }
+ /**
+ * Add comments
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param type Comment type
+ * @param commentStart Start position of comment
+ */
+ function addComment(parser, context, type, commentStart) {
+ const { index, startIndex: start, startLine, startColumn, lastLine, lastColumn } = parser;
+ const comment = {
+ type,
+ value: parser.source.slice(commentStart, type === 'MultiLine' ? index - 2 : index),
+ start,
+ end: index,
+ };
+ if (context & Context.OptionsLoc) {
+ comment.loc = {
+ start: { line: startLine, column: startColumn },
+ end: { line: lastLine, column: lastColumn },
+ };
+ }
+ parser.comments.push(comment);
+ } + + /**
+ * Scan
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-punctuatorss)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scan(parser, context) {
+ parser.flags &= ~Flags.NewLine | Flags.EscapedKeyword;
+ const lineStart = parser.index === 0;
+ let state = ScannerState.None;
+ while (parser.index < parser.length) {
+ if (!lineStart) {
+ parser.startIndex = parser.index;
+ parser.startColumn = parser.column;
+ parser.startLine = parser.line;
+ }
+ const first = parser.source.charCodeAt(parser.index);
+ if (first > 128 /* MaxAsciiCharacter */) {
+ switch (first) {
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ case 65519 /* ByteOrderMark */:
+ case 160 /* NonBreakingSpace */:
+ case 5760 /* Ogham */:
+ case 8192 /* EnQuad */:
+ case 8193 /* EmQuad */:
+ case 8194 /* EnSpace */:
+ case 8195 /* EmSpace */:
+ case 8196 /* ThreePerEmSpace */:
+ case 8197 /* FourPerEmSpace */:
+ case 8198 /* SixPerEmSpace */:
+ case 8199 /* FigureSpace */:
+ case 8200 /* PunctuationSpace */:
+ case 8201 /* ThinSpace */:
+ case 8202 /* HairSpace */:
+ case 8239 /* NarrowNoBreakSpace */:
+ case 8287 /* MathematicalSpace */:
+ case 12288 /* IdeographicSpace */:
+ case 65279 /* Zwnbs */:
+ case 8205 /* Zwj */:
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ return scanMaybeIdentifier(parser, context, first);
+ }
+ }
+ else {
+ // Note: Here we first get rid of LT and WS, then we make sure that the lookup time
+ // for the single punctuator char is short as possible. A single punctuator
+ // char is a valid token that cannot also be a prefix of a combination
+ // of long tokens - e.g. '(', ')' and '=' is valid. '==' is not.
+ switch (first) {
+ case 13 /* CarriageReturn */:
+ state |= ScannerState.NewLine | ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ break;
+ case 9 /* Tab */:
+ case 11 /* VerticalTab */:
+ case 12 /* FormFeed */:
+ case 32 /* Space */:
+ parser.index++;
+ parser.column++;
+ break;
+ // `(`
+ case 40 /* LeftParen */:
+ parser.index++;
+ parser.column++;
+ return 50331659 /* LeftParen */;
+ // `)`
+ case 41 /* RightParen */:
+ parser.index++;
+ parser.column++;
+ return 16 /* RightParen */;
+ // `,`
+ case 44 /* Comma */:
+ parser.index++;
+ parser.column++;
+ return 16777234 /* Comma */;
+ // `:`
+ case 58 /* Colon */:
+ parser.index++;
+ parser.column++;
+ return 16777237 /* Colon */;
+ // `;`
+ case 59 /* Semicolon */:
+ parser.index++;
+ parser.column++;
+ return 17825809 /* Semicolon */;
+ // `?`
+ case 63 /* QuestionMark */:
+ parser.index++;
+ parser.column++;
+ return 22 /* QuestionMark */;
+ // `]`
+ case 93 /* RightBracket */:
+ parser.index++;
+ parser.column++;
+ return 20 /* RightBracket */;
+ // `{`
+ case 123 /* LeftBrace */:
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ // `}`
+ case 125 /* RightBrace */:
+ parser.index++;
+ parser.column++;
+ return 17825807 /* RightBrace */;
+ // `~`
+ case 126 /* Tilde */:
+ parser.index++;
+ parser.column++;
+ return 301989934 /* Complement */;
+ // `[`
+ case 91 /* LeftBracket */:
+ parser.index++;
+ parser.column++;
+ return 41943059 /* LeftBracket */;
+ // `@`
+ case 64 /* At */:
+ parser.index++;
+ parser.column++;
+ return 120 /* At */;
+ // `/`, `/=`, `/>`
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774773 /* Divide */;
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipSingleLineComment(parser, context, state, 'SingleLine');
+ continue;
+ }
+ case 42 /* Asterisk */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipMultiLineComment(parser, context, state);
+ continue;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 100663333 /* DivideAssign */;
+ }
+ default:
+ return 167774773 /* Divide */;
+ }
+ }
+ // `-`, `--`, `-=`
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++; // skip `-`
+ const next = parser.source.charCodeAt(parser.index);
+ switch (next) {
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++;
+ if ((state & ScannerState.NewLine || lineStart) &&
+ consumeOpt(parser, 62 /* GreaterThan */)) {
+ state = skipSingleHTMLComment(parser, context, state, 'HTMLClose');
+ continue;
+ }
+ return 570425372 /* Decrement */;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 67108899 /* SubtractAssign */;
+ }
+ default:
+ return 436209968 /* Subtract */;
+ }
+ }
+ // `<`, `<=`, `<<`, `<<=`, `</`, <!--
+ case 60 /* LessThan */:
+ parser.index++;
+ parser.column++; // skip `<`
+ if (consumeOpt(parser, 33 /* Exclamation */) &&
+ consumeOpt(parser, 45 /* Hyphen */) &&
+ consumeOpt(parser, 45 /* Hyphen */)) {
+ state = skipSingleHTMLComment(parser, context, state, 'HTMLOpen');
+ continue;
+ }
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 60 /* LessThan */:
+ parser.index++;
+ parser.column++;
+ return consumeOpt(parser, 61 /* EqualSign */) ?
+ 67108894 /* ShiftLeftAssign */ :
+ 167774273 /* ShiftLeft */;
+ case 61 /* EqualSign */:
+ parser.index++;
+ parser.column++;
+ return 167774013 /* LessThanOrEqual */;
+ case 47 /* Slash */:
+ {
+ if (!(context & Context.OptionsJSX))
+ break;
+ const index = parser.index + 1;
+ // Check that it's not a comment start.
+ if (index < parser.length) {
+ const next = parser.source.charCodeAt(index);
+ if (next === 42 /* Asterisk */ || next === 47 /* Slash */)
+ break;
+ }
+ parser.index++;
+ parser.column++;
+ return 25 /* JSXClose */;
+ }
+ default: // ignore
+ return 167774015 /* LessThan */;
+ }
+ // `!`, `!=`, `!==`
+ case 33 /* Exclamation */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 301989933 /* Negate */;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167773756 /* LooseNotEqual */;
+ return 167773754 /* StrictNotEqual */;
+ // `'string'`, `"string"`
+ case 39 /* SingleQuote */:
+ case 34 /* DoubleQuote */:
+ return scanString(parser, context, first);
+ // `%`, `%=`
+ case 37 /* Percent */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167774772 /* Modulo */;
+ return 67108902 /* ModuloAssign */;
+ // `&`, `&&`, `&=`
+ case 38 /* Ampersand */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 38 /* Ampersand */) {
+ parser.index++;
+ parser.column++;
+ return 169869879 /* LogicalAnd */;
+ }
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108905 /* BitwiseAndAssign */;
+ }
+ return 167773508 /* BitwiseAnd */;
+ }
+ // `*`, `**`, `*=`, `**=`
+ case 42 /* Asterisk */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774771 /* Multiply */;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108900 /* MultiplyAssign */;
+ }
+ if (next !== 42 /* Asterisk */)
+ return 167774771 /* Multiply */;
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167775030 /* Exponentiate */;
+ return 67108897 /* ExponentiateAssign */;
+ }
+ // `+`, `++`, `+=`
+ case 43 /* Plus */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 436209967 /* Add */;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 43 /* Plus */) {
+ parser.index++;
+ parser.column++;
+ return 570425371 /* Increment */;
+ }
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108898 /* AddAssign */;
+ }
+ return 436209967 /* Add */;
+ }
+ // `\\u{N}var`
+ case 92 /* Backslash */:
+ return scanIdentifier(parser, context);
+ // `=`, `==`, `===`, `=>`
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ if (consumeOpt(parser, 61 /* EqualSign */)) {
+ return 167773753 /* StrictEqual */;
+ }
+ else {
+ return 167773755 /* LooseEqual */;
+ }
+ }
+ else if (next === 62 /* GreaterThan */) {
+ parser.index++;
+ parser.column++;
+ return 10 /* Arrow */;
+ }
+ return 83886109 /* Assign */;
+ }
+ // `>`, `>=`, `>>`, `>>>`, `>>=`, `>>>=`
+ case 62 /* GreaterThan */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774016 /* GreaterThan */;
+ if (context & Context.InJSXChild)
+ return 167774016 /* GreaterThan */;
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 167774014 /* GreaterThanOrEqual */;
+ }
+ if (next !== 62 /* GreaterThan */)
+ return 167774016 /* GreaterThan */;
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ if (next === 62 /* GreaterThan */) {
+ parser.index++;
+ parser.column++;
+ if (consumeOpt(parser, 61 /* EqualSign */)) {
+ return 67108896 /* LogicalShiftRightAssign */;
+ }
+ else {
+ return 167774275 /* LogicalShiftRight */;
+ }
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108895 /* ShiftRightAssign */;
+ }
+ return 167774274 /* ShiftRight */;
+ }
+ // `^`, `^=`
+ case 94 /* Caret */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167773254 /* BitwiseXor */;
+ return 67108903 /* BitwiseXorAssign */;
+ // ``string``
+ case 96 /* Backtick */:
+ return scanTemplate(parser, context);
+ // `|`, `||`, `|=`
+ case 124 /* VerticalBar */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 124 /* VerticalBar */) {
+ parser.index++;
+ parser.column++;
+ return 169869624 /* LogicalOr */;
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108904 /* BitwiseOrAssign */;
+ }
+ return 167772997 /* BitwiseOr */;
+ }
+ // `.`, `...`, `.123` (numeric literal)
+ case 46 /* Period */:
+ {
+ let index = parser.index + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 57 /* Nine */) {
+ scanNumericLiteral(parser, context, NumericState.Float);
+ return 33554434 /* NumericLiteral */;
+ }
+ else if (next === 46 /* Period */) {
+ index++;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 46 /* Period */) {
+ parser.index = index + 1;
+ parser.column += 3;
+ return 14 /* Ellipsis */;
+ }
+ }
+ parser.index++;
+ parser.column++;
+ return 16777229 /* Period */;
+ }
+ // `#`
+ case 35 /* Hash */:
+ {
+ parser.index++;
+ parser.column++;
+ const index = parser.index;
+ const next = parser.source.charCodeAt(index);
+ if (context & Context.OptionsShebang &&
+ lineStart &&
+ next === 33 /* Exclamation */) {
+ parser.index = index + 1;
+ skipSingleLineComment(parser, context, ScannerState.None, 'SheBang');
+ continue;
+ }
+ return scanPrivateName(parser, context);
+ }
+ // `0`...`9`
+ case 48 /* Zero */:
+ {
+ parser.index++;
+ parser.column++;
+ switch (parser.source.charCodeAt(parser.index)) {
+ // Hex number - '0x', '0X'
+ case 88 /* UpperX */:
+ case 120 /* LowerX */:
+ return scanHexIntegerLiteral(parser, context);
+ // Binary number - '0b', '0B'
+ case 66 /* UpperB */:
+ case 98 /* LowerB */:
+ return scanOctalOrBinary(parser, context, 2);
+ // Octal number - '0o', '0O'
+ case 79 /* UpperO */:
+ case 111 /* LowerO */:
+ return scanOctalOrBinary(parser, context, 8);
+ default:
+ // Implicit octal digits startign with '0'
+ return scanImplicitOctalDigits(parser, context);
+ }
+ }
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return scanNumericLiteral(parser, context);
+ // `a`...`z`, `A`...`Z`, `_var`, `$var`
+ case 65 /* UpperA */:
+ case 66 /* UpperB */:
+ case 67 /* UpperC */:
+ case 68 /* UpperD */:
+ case 69 /* UpperE */:
+ case 70 /* UpperF */:
+ case 71 /* UpperG */:
+ case 72 /* UpperH */:
+ case 73 /* UpperI */:
+ case 74 /* UpperJ */:
+ case 75 /* UpperK */:
+ case 76 /* UpperL */:
+ case 77 /* UpperM */:
+ case 78 /* UpperN */:
+ case 79 /* UpperO */:
+ case 80 /* UpperP */:
+ case 81 /* UpperQ */:
+ case 82 /* UpperR */:
+ case 83 /* UpperS */:
+ case 84 /* UpperT */:
+ case 85 /* UpperU */:
+ case 86 /* UpperV */:
+ case 87 /* UpperW */:
+ case 88 /* UpperX */:
+ case 89 /* UpperY */:
+ case 90 /* UpperZ */:
+ case 36 /* Dollar */:
+ case 95 /* Underscore */:
+ case 97 /* LowerA */:
+ case 98 /* LowerB */:
+ case 99 /* LowerC */:
+ case 100 /* LowerD */:
+ case 101 /* LowerE */:
+ case 102 /* LowerF */:
+ case 103 /* LowerG */:
+ case 104 /* LowerH */:
+ case 105 /* LowerI */:
+ case 106 /* LowerJ */:
+ case 107 /* LowerK */:
+ case 108 /* LowerL */:
+ case 109 /* LowerM */:
+ case 110 /* LowerN */:
+ case 111 /* LowerO */:
+ case 112 /* LowerP */:
+ case 113 /* LowerQ */:
+ case 114 /* LowerR */:
+ case 115 /* LowerS */:
+ case 116 /* LowerT */:
+ case 117 /* LowerU */:
+ case 118 /* LowerV */:
+ case 119 /* LowerW */:
+ case 120 /* LowerX */:
+ case 121 /* LowerY */:
+ case 122 /* LowerZ */:
+ default:
+ return scanIdentifier(parser, context, first);
+ }
+ }
+ }
+ return 1048576 /* EndOfSource */;
+ } + + /**
+ * Scans regular expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanRegularExpression(parser, context) {
+ const bodyStart = parser.index;
+ let preparseState = RegexState.Empty;
+ loop: while (true) {
+ const ch = parser.source.charCodeAt(parser.index);
+ parser.index++;
+ parser.column++;
+ if (preparseState & RegexState.Escape) {
+ preparseState &= ~RegexState.Escape;
+ }
+ else {
+ switch (ch) {
+ case 47 /* Slash */:
+ if (!preparseState)
+ break loop;
+ else
+ break;
+ case 92 /* Backslash */:
+ preparseState |= RegexState.Escape;
+ break;
+ case 91 /* LeftBracket */:
+ preparseState |= RegexState.Class;
+ break;
+ case 93 /* RightBracket */:
+ preparseState &= RegexState.Escape;
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ report(parser, 7 /* UnterminatedRegExp */);
+ default: // ignore
+ }
+ }
+ if (parser.index >= parser.source.length) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ const bodyEnd = parser.index - 1;
+ let mask = RegexFlags.Empty;
+ const { index: flagStart } = parser;
+ loop: while (parser.index < parser.source.length) {
+ const code = parser.source.charCodeAt(parser.index);
+ switch (code) {
+ case 103 /* LowerG */:
+ if (mask & RegexFlags.Global)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'g');
+ mask |= RegexFlags.Global;
+ break;
+ case 105 /* LowerI */:
+ if (mask & RegexFlags.IgnoreCase)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'i');
+ mask |= RegexFlags.IgnoreCase;
+ break;
+ case 109 /* LowerM */:
+ if (mask & RegexFlags.Multiline)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'm');
+ mask |= RegexFlags.Multiline;
+ break;
+ case 117 /* LowerU */:
+ if (mask & RegexFlags.Unicode)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'u');
+ mask |= RegexFlags.Unicode;
+ break;
+ case 121 /* LowerY */:
+ if (mask & RegexFlags.Sticky)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'y');
+ mask |= RegexFlags.Sticky;
+ break;
+ case 115 /* LowerS */:
+ if (mask & RegexFlags.DotAll)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 's');
+ mask |= RegexFlags.DotAll;
+ break;
+ default:
+ if (!isIdentifierPart(code))
+ break loop;
+ report(parser, 16 /* UnexpectedTokenRegExpFlag */, fromCodePoint(code));
+ }
+ parser.index++;
+ parser.column++;
+ }
+ const flags = parser.source.slice(flagStart, parser.index);
+ const pattern = parser.source.slice(bodyStart, bodyEnd);
+ parser.tokenRegExp = { pattern, flags };
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ parser.tokenValue = validate(parser, context, pattern, flags);
+ return 33554436 /* RegularExpression */;
+ }
+ /**
+ * Validates regular expressions
+ *
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param pattern Regexp body
+ * @param flags Regexp flags
+ */
+ function validate(parser, context, pattern, flags) {
+ if (!(context & Context.OptionsNode)) {
+ try {
+ }
+ catch (e) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ try {
+ return new RegExp(pattern, flags);
+ }
+ catch (e) {
+ return null;
+ }
+ } + + // 12.15.5 Destructuring Assignment
+ /**
+ * Parses either a binding identifier or binding pattern
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingIdentifierOrPattern(parser, context, args = []) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ return token === 41943052 /* LeftBrace */ ?
+ parserObjectAssignmentPattern(parser, context) :
+ parseArrayAssignmentPattern(parser, context, args);
+ }
+ else if (token & (262144 /* IsAwait */ | 1073741824 /* IsYield */)) {
+ if (token & 262144 /* IsAwait */ && (context & (Context.Async | Context.Module))) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ else if (token & 1073741824 /* IsYield */ && (context & (Context.Yield | Context.Strict))) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ }
+ args.push(parser.tokenValue);
+ return parseBindingIdentifier(parser, context);
+ }
+ /**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BindingIdentifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingIdentifier(parser, context) {
+ const { token } = parser;
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (context & Context.BlockScope && token === 33574984 /* LetKeyword */) {
+ // let is disallowed as a lexically bound name
+ tolerant(parser, context, 27 /* LetInLexicalBinding */);
+ }
+ else if (hasBit(token, 20480 /* FutureReserved */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ else if (!isValidIdentifier(context, token)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ }
+ /**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentRestElement(parser, context, args) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * Parse rest property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ // tslint:disable-next-line:function-name
+ function AssignmentRestProperty(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const { token } = parser;
+ const argument = parseBindingIdentifierOrPattern(parser, context);
+ if (hasBit(token, 8388608 /* IsBindingPattern */))
+ tolerant(parser, context, 94 /* InvalidRestBindingPattern */);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * ArrayAssignmentPattern[Yield] :
+ * [ Elisionopt AssignmentRestElement[?Yield]opt ]
+ * [ AssignmentElementList[?Yield] ]
+ * [ AssignmentElementList[?Yield] , Elisionopt AssignmentRestElement[?Yield]opt ]
+ *
+ * AssignmentRestElement[Yield] :
+ * ... DestructuringAssignmentTarget[?Yield]
+ *
+ * AssignmentElementList[Yield] :
+ * AssignmentElisionElement[?Yield]
+ * AssignmentElementList[?Yield] , AssignmentElisionElement[?Yield]
+ *
+ * AssignmentElisionElement[Yield] :
+ * Elisionopt AssignmentElement[?Yield]
+ *
+ * AssignmentElement[Yield] :
+ * DestructuringAssignmentTarget[?Yield] Initializer[In,?Yield]opt
+ *
+ * DestructuringAssignmentTarget[Yield] :
+ * LeftHandSideExpression[?Yield]
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param Parser object
+ * @param Context masks
+ */
+ function parseArrayAssignmentPattern(parser, context, args) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else {
+ if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseAssignmentRestElement(parser, context, args));
+ break;
+ }
+ else {
+ elements.push(parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseBindingInitializer));
+ }
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ // tslint:disable-next-line:no-object-literal-type-assertion
+ return finishNode(context, parser, pos, {
+ type: 'ArrayPattern',
+ elements,
+ });
+ }
+ /**
+ * Parse object assignment pattern
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parserObjectAssignmentPattern(parser, context) {
+ const pos = getLocation(parser);
+ const properties = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ properties.push(AssignmentRestProperty(parser, context));
+ break;
+ }
+ properties.push(parseAssignmentProperty(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ObjectPattern',
+ properties,
+ });
+ }
+ /** Parse assignment pattern
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param left LHS of assignment pattern
+ * @param pos Location
+ */
+ function parseAssignmentPattern(parser, context, left, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse binding initializer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingInitializer(parser, context) {
+ const pos = getLocation(parser);
+ const left = parseBindingIdentifierOrPattern(parser, context);
+ return !consume(parser, context, 83886109 /* Assign */) ?
+ left :
+ finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseAssignmentExpression(parser, context | Context.AllowIn),
+ });
+ }
+ /**
+ * Parse assignment property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentProperty(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ let key;
+ let value;
+ let computed = false;
+ let shorthand = false;
+ // single name binding
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ key = parseIdentifier(parser, context);
+ shorthand = !consume(parser, context, 16777237 /* Colon */);
+ if (shorthand) {
+ const hasInitializer = consume(parser, context, 83886109 /* Assign */);
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (!isValidIdentifier(context, token))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ value = hasInitializer ? parseAssignmentPattern(parser, context, key, pos) : key;
+ }
+ else
+ value = parseBindingInitializer(parser, context);
+ }
+ else {
+ computed = token === 41943059 /* LeftBracket */;
+ key = parsePropertyName(parser, context);
+ expect(parser, context, 16777237 /* Colon */);
+ value = parseExpressionCoverGrammar(parser, context, parseBindingInitializer);
+ }
+ // Note! The specs specifically state that this is "assignment property", but
+ // nothing in ESTree specs explains the difference between this "property" and the "property" for object literals.
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ kind: 'init',
+ key,
+ computed,
+ value,
+ method: false,
+ shorthand,
+ });
+ } + + // JSX Specification
+ // https://facebook.github.io/jsx/
+ /**
+ * Parses JSX element or JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXRootElement(parser, context) {
+ const pos = getLocation(parser);
+ let children = [];
+ let closingElement = null;
+ let selfClosing = false;
+ let openingElement;
+ expect(parser, context, 167774015 /* LessThan */);
+ const isFragment = parser.token === 167774016 /* GreaterThan */;
+ if (isFragment) {
+ openingElement = parseJSXOpeningFragment(parser, context, pos);
+ }
+ else {
+ const name = parseJSXElementName(parser, context);
+ const attributes = parseJSXAttributes(parser, context);
+ selfClosing = consume(parser, context, 167774773 /* Divide */);
+ openingElement = parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos);
+ }
+ if (isFragment)
+ return parseJSXFragment(parser, context, openingElement, pos);
+ if (!selfClosing) {
+ children = parseJSXChildren(parser, context);
+ closingElement = parseJSXClosingElement(parser, context);
+ const open = isEqualTagNames(openingElement.name);
+ const close = isEqualTagNames(closingElement.name);
+ if (open !== close)
+ report(parser, 85 /* ExpectedJSXClosingTag */, close);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'JSXElement',
+ children,
+ openingElement,
+ closingElement,
+ });
+ }
+ /**
+ * Parses JSX opening element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param name Element name
+ * @param attributes Element attributes
+ * @param selfClosing True if this is a selfclosing JSX Element
+ * @param pos Line / Column tracking
+ */
+ function parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos) {
+ if (context & Context.InJSXChild && selfClosing)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningElement',
+ name,
+ attributes,
+ selfClosing,
+ });
+ }
+ /**
+ * Parse JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param openingElement Opening fragment
+ * @param pos Line / Column location
+ */
+ function parseJSXFragment(parser, context, openingElement, pos) {
+ const children = parseJSXChildren(parser, context);
+ const closingFragment = parseJSXClosingFragment(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXFragment',
+ children,
+ openingElement,
+ closingFragment,
+ });
+ }
+ /**
+ * Parse JSX opening fragmentD
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXOpeningFragment(parser, context, pos) {
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningFragment',
+ });
+ }
+ /**
+ * Prime the scanner and advance to the next JSX token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextJSXToken(parser) {
+ return parser.token = scanJSXToken(parser);
+ }
+ /**
+ * Mini scanner
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanJSXToken(parser) {
+ if (parser.index >= parser.source.length)
+ return 1048576 /* EndOfSource */;
+ parser.lastIndex = parser.startIndex = parser.index;
+ const char = parser.source.charCodeAt(parser.index);
+ if (char === 60 /* LessThan */) {
+ parser.index++;
+ parser.column++;
+ return consumeOpt(parser, 47 /* Slash */) ? 25 /* JSXClose */ : 167774015 /* LessThan */;
+ }
+ else if (char === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ }
+ while (parser.index < parser.source.length) {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 123 /* LeftBrace */ || next === 60 /* LessThan */)
+ break;
+ }
+ return 121 /* JSXText */;
+ }
+ /**
+ * Parses JSX children
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXChildren(parser, context) {
+ const children = [];
+ while (parser.token !== 25 /* JSXClose */) {
+ children.push(parseJSXChild(parser, context));
+ }
+ return children;
+ }
+ /**
+ * Parses JSX Text
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXText(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.source.slice(parser.startIndex, parser.index);
+ parser.token = scanJSXToken(parser);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXText',
+ value,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = value;
+ return node;
+ }
+ /**
+ * Parses JSX Child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXChild(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ case 121 /* JSXText */:
+ return parseJSXText(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpression(parser, context & ~Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context & ~Context.InJSXChild);
+ default:
+ report(parser, 0 /* Unexpected */);
+ }
+ return undefined; // note: get rid of this
+ }
+ /**
+ * Parses JSX attributes
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributes(parser, context) {
+ const attributes = [];
+ while (parser.index < parser.source.length) {
+ if (parser.token === 167774773 /* Divide */ || parser.token === 167774016 /* GreaterThan */)
+ break;
+ attributes.push(parseJSXAttribute(parser, context));
+ }
+ return attributes;
+ }
+ /**
+ * Parses JSX spread attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXSpreadAttribute(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadAttribute',
+ argument: expression,
+ });
+ }
+ /**
+ * Parses JSX namespace name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param namespace Identifier
+ * @param pos Line / Column location
+ */
+ function parseJSXNamespacedName(parser, context, namespace, pos) {
+ expect(parser, context, 16777237 /* Colon */);
+ const name = parseJSXIdentifier(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXNamespacedName',
+ namespace,
+ name,
+ });
+ }
+ /**
+ * Parses JSX attribute name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributeName(parser, context) {
+ const pos = getLocation(parser);
+ const identifier = parseJSXIdentifier(parser, context);
+ return parser.token === 16777237 /* Colon */ ?
+ parseJSXNamespacedName(parser, context, identifier, pos) :
+ identifier;
+ }
+ /**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributeValue(parser, context) {
+ switch (scanJSXAttributeValue(parser, context)) {
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpressionContainer(parser, context | Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context | Context.InJSXChild);
+ default:
+ tolerant(parser, context, 87 /* InvalidJSXAttributeValue */);
+ return undefined; // note: get rid of this
+ }
+ }
+ /**
+ * Parses JSX Attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttribute(parser, context) {
+ const pos = getLocation(parser);
+ if (parser.token === 41943052 /* LeftBrace */)
+ return parseJSXSpreadAttribute(parser, context);
+ scanJSXIdentifier(parser);
+ const attrName = parseJSXAttributeName(parser, context);
+ const value = parser.token === 83886109 /* Assign */ ? parseJSXAttributeValue(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'JSXAttribute',
+ value: value,
+ name: attrName,
+ });
+ }
+ /**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanJSXAttributeValue(parser, context) {
+ parser.lastIndex = parser.index;
+ const ch = parser.source.charCodeAt(parser.index);
+ switch (ch) {
+ case 34 /* DoubleQuote */:
+ case 39 /* SingleQuote */:
+ return scanJSXString(parser, context, ch);
+ default:
+ return nextToken(parser, context);
+ }
+ }
+ /**
+ * Parses JSX String
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote Code point
+ */
+ function scanJSXString(parser, context, quote) {
+ const rawStart = parser.index;
+ parser.index++;
+ parser.column++;
+ let ret = '';
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ ret += fromCodePoint(ch);
+ parser.index++;
+ parser.column++;
+ ch = parser.source.charCodeAt(parser.index);
+ if (parser.index >= parser.source.length)
+ report(parser, 6 /* UnterminatedString */);
+ }
+ parser.index++;
+ parser.column++; // skip the quote
+ // raw
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(rawStart, parser.index);
+ parser.tokenValue = ret;
+ return 33554435 /* StringLiteral */;
+ }
+ /**
+ * Parses JJSX Empty Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXEmptyExpression(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXEmptyExpression',
+ });
+ }
+ /**
+ * Parses JSX Spread child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXSpreadChild(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpression(parser, context);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadChild',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Expression container
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXExpressionContainer(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ // Note: JSX Expressions can't be empty
+ if (parser.token === 17825807 /* RightBrace */)
+ tolerant(parser, context, 84 /* NonEmptyJSXExpression */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ if (parser.token === 14 /* Ellipsis */)
+ return parseJSXSpreadChild(parser, context);
+ const expression = parser.token === 17825807 /* RightBrace */ ?
+ parseJSXEmptyExpression(parser, context) :
+ parseExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Closing fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXClosingFragment(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ expect(parser, context, 167774016 /* GreaterThan */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingFragment',
+ });
+ }
+ /**
+ * Parses JSX Closing Element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXClosingElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ const name = parseJSXElementName(parser, context);
+ if (context & Context.InJSXChild)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingElement',
+ name,
+ });
+ }
+ /**
+ * Parses JSX Identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXIdentifier(parser, context) {
+ const { token, tokenValue: name, tokenRaw: raw } = parser;
+ if (!(token & (131072 /* IsIdentifier */ | 4096 /* Keyword */))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXIdentifier',
+ name,
+ });
+ if (context & Context.OptionsRawidentifiers)
+ node.raw = raw;
+ return node;
+ }
+ /**
+ * Parses JSX Member expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXMemberExpression(parser, context, expr, pos) {
+ // Note: In order to be able to parse cases like ''<A.B.C.D.E.foo-bar />', where the dash is located at the
+ // end, we must rescan for the JSX Identifier now. This because JSX identifiers differ from normal identifiers
+ scanJSXIdentifier(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXMemberExpression',
+ object: expr,
+ property: parseJSXIdentifier(parser, context),
+ });
+ }
+ /**
+ * Parses JSX Element name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXElementName(parser, context) {
+ const pos = getLocation(parser);
+ scanJSXIdentifier(parser);
+ let elementName = parseJSXIdentifier(parser, context);
+ if (parser.token === 16777237 /* Colon */)
+ return parseJSXNamespacedName(parser, context, elementName, pos);
+ while (consume(parser, context, 16777229 /* Period */)) {
+ elementName = parseJSXMemberExpression(parser, context, elementName, pos);
+ }
+ return elementName;
+ }
+ /**
+ * Scans JSX Identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanJSXIdentifier(parser) {
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const firstCharPosition = parser.index;
+ let ch = parser.source.charCodeAt(parser.index);
+ while ((parser.index < parser.source.length) && (ch === 45 /* Hyphen */ || (isValidIdentifierPart(ch)))) {
+ ch = readNext(parser);
+ }
+ parser.tokenValue += parser.source.substr(firstCharPosition, parser.index - firstCharPosition);
+ }
+ return parser.token;
+ } + + /**
+ * Expression :
+ * AssignmentExpression
+ * Expression , AssignmentExpression
+ *
+ * ExpressionNoIn :
+ * AssignmentExpressionNoIn
+ * ExpressionNoIn , AssignmentExpressionNoIn
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Expression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExpression(parser, context) {
+ const pos = getLocation(parser);
+ const expr = parseExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ return parser.token === 16777234 /* Comma */ ?
+ parseSequenceExpression(parser, context, expr, pos) :
+ expr;
+ }
+ /**
+ * Parse secuence expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSequenceExpression(parser, context, left, pos) {
+ const expressions = [left];
+ while (consume(parser, context, 16777234 /* Comma */)) {
+ expressions.push(parseExpressionCoverGrammar(parser, context, parseAssignmentExpression));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'SequenceExpression',
+ expressions,
+ });
+ }
+ /**
+ * Parse yield expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-YieldExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseYieldExpression(parser, context, pos) {
+ // YieldExpression[In] :
+ // yield
+ // yield [no LineTerminator here] AssignmentExpression[?In, Yield]
+ // yield [no LineTerminator here] * AssignmentExpression[?In, Yield]
+ // https://tc39.github.io/ecma262/#sec-generator-function-definitions-static-semantics-early-errors
+ if (context & Context.InParameter)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ expect(parser, context, 1107316842 /* YieldKeyword */);
+ let argument = null;
+ let delegate = false;
+ if (!(parser.flags & Flags.NewLine)) {
+ delegate = consume(parser, context, 167774771 /* Multiply */);
+ // 'Token.IsExpressionStart' bitmask contains the complete set of
+ // tokens that can appear after an AssignmentExpression, and none of them
+ // can start an AssignmentExpression.
+ if (delegate || parser.token & 33554432 /* IsExpressionStart */) {
+ argument = parseAssignmentExpression(parser, context);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'YieldExpression',
+ argument,
+ delegate,
+ });
+ }
+ /**
+ * AssignmentExpression :
+ * ConditionalExpression
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpression
+ * LeftHandSideExpression AssignmentOperator AssignmentExpression
+ *
+ * AssignmentExpressionNoIn :
+ * ConditionalExpressionNoIn
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpressionNoIn
+ * LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentExpression(parser, context) {
+ const pos = getLocation(parser);
+ let { token } = parser;
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ return parseYieldExpression(parser, context, pos);
+ let expr = token & 524288 /* IsAsync */ && lookahead(parser, context, nextTokenisIdentifierOrParen)
+ ? parserCoverCallExpressionAndAsyncArrowHead(parser, context)
+ : parseConditionalExpression(parser, context, pos);
+ if (parser.token === 10 /* Arrow */) {
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & (20480 /* FutureReserved */ | 4194304 /* IsEvalOrArguments */)) {
+ // Invalid: ' yield => { 'use strict'; 0 };'
+ if (token & 20480 /* FutureReserved */) {
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ }
+ expr = [expr];
+ }
+ return parseArrowFunction(parser, context &= ~Context.Async, pos, expr);
+ }
+ if (hasBit(parser.token, 67108864 /* IsAssignOp */)) {
+ token = parser.token;
+ if (context & Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ }
+ else if (consume(parser, context, 83886109 /* Assign */)) {
+ if (!(parser.flags & Flags.AllowDestructuring)) {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ // Only re-interpret if not inside a formal parameter list
+ if (!(context & Context.InParameter))
+ reinterpret(parser, context, expr);
+ if (context & Context.InParen)
+ parser.flags |= Flags.SimpleParameterList;
+ if (parser.token & 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ else if (context & Context.InParen &&
+ context & (Context.Strict | Context.Yield) &&
+ parser.token & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasYield;
+ }
+ }
+ else {
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ nextToken(parser, context);
+ }
+ const right = parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ parser.pendingExpressionError = null;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentExpression',
+ left: expr,
+ operator: tokenDesc(token),
+ right,
+ });
+ }
+ return expr;
+ }
+ /**
+ * Parse conditional expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ConditionalExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseConditionalExpression(parser, context, pos) {
+ const test = parseBinaryExpression(parser, context, 0, pos);
+ if (!consume(parser, context, 22 /* QuestionMark */))
+ return test;
+ const consequent = parseExpressionCoverGrammar(parser, context & ~Context.AllowDecorator | Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16777237 /* Colon */);
+ return finishNode(context, parser, pos, {
+ type: 'ConditionalExpression',
+ test,
+ consequent,
+ alternate: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse binary expression.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-exp-operator)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-additive-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-bitwise-shift-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-equality-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-relational-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-multiplicative-operators)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param minPrec Minimum precedence value
+ * @param pos Line / Column info
+ * @param Left Left hand side of the binary expression
+ */
+ function parseBinaryExpression(parser, context, minPrec, pos, left = parseUnaryExpression(parser, context)) {
+ // Shift-reduce parser for the binary operator part of the JS expression
+ // syntax.
+ const bit = context & Context.AllowIn ^ Context.AllowIn;
+ while (hasBit(parser.token, 167772160 /* IsBinaryOp */)) {
+ const t = parser.token;
+ const prec = t & 3840 /* Precedence */;
+ const delta = (t === 167775030 /* Exponentiate */) << 8 /* PrecStart */;
+ if (bit && t === 167786289 /* InKeyword */)
+ break;
+ // When the next token is no longer a binary operator, it's potentially the
+ // start of an expression, so we break the loop
+ if (prec + delta <= minPrec)
+ break;
+ nextToken(parser, context);
+ left = finishNode(context, parser, pos, {
+ type: t & 2097152 /* IsLogical */ ? 'LogicalExpression' : 'BinaryExpression',
+ left,
+ right: parseBinaryExpression(parser, context & ~Context.AllowIn, prec, getLocation(parser)),
+ operator: tokenDesc(t),
+ });
+ }
+ return left;
+ }
+ /**
+ * Parse await expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AwaitExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ */
+ function parseAwaitExpression(parser, context, pos) {
+ if (context & Context.InParameter)
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ expect(parser, context, 34017389 /* AwaitKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'AwaitExpression',
+ argument: parseUnaryExpression(parser, context),
+ });
+ }
+ /**
+ * Parses unary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UnaryExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseUnaryExpression(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ if (hasBit(token, 301989888 /* IsUnaryOp */)) {
+ nextToken(parser, context);
+ if (parser.flags & Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ const argument = parseExpressionCoverGrammar(parser, context, parseUnaryExpression);
+ if (parser.token === 167775030 /* Exponentiate */) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & Context.Strict && token === 302002219 /* DeleteKeyword */) {
+ if (argument.type === 'Identifier') {
+ tolerant(parser, context, 43 /* StrictDelete */);
+ }
+ else if (isPropertyWithPrivateFieldKey(argument)) {
+ tolerant(parser, context, 44 /* DeletePrivateField */);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'UnaryExpression',
+ operator: tokenDesc(token),
+ argument,
+ prefix: true,
+ });
+ }
+ return context & Context.Async && token & 262144 /* IsAwait */
+ ? parseAwaitExpression(parser, context, pos)
+ : parseUpdateExpression(parser, context, pos);
+ }
+ /**
+ * Parses update expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UpdateExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseUpdateExpression(parser, context, pos) {
+ const { token } = parser;
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */)) {
+ nextToken(parser, context);
+ const expr = parseLeftHandSideExpression(parser, context, pos);
+ validateUpdateExpression(parser, context, expr, 'Prefix');
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expr,
+ operator: tokenDesc(token),
+ prefix: true,
+ });
+ }
+ else if (context & Context.OptionsJSX && token === 167774015 /* LessThan */) {
+ return parseJSXRootElement(parser, context | Context.InJSXChild);
+ }
+ const expression = parseLeftHandSideExpression(parser, context, pos);
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */) && !(parser.flags & Flags.NewLine)) {
+ validateUpdateExpression(parser, context, expression, 'Postfix');
+ const operator = parser.token;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expression,
+ operator: tokenDesc(operator),
+ prefix: false,
+ });
+ }
+ return expression;
+ }
+ /**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseRestElement(parser, context, args = []) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (context & Context.InParen && parser.token & 262144 /* IsAwait */)
+ parser.flags |= Flags.HasAwait;
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * Parse spread element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SpreadElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSpreadElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+ }
+ /**
+ * Parse left hand side expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LeftHandSideExpression)
+ *
+ * @param Parser Parer instance
+ * @param Context Contextmasks
+ * @param pos Location info
+ */
+ function parseLeftHandSideExpression(parser, context, pos) {
+ const expr = context & Context.OptionsNext && parser.token === 33566810 /* ImportKeyword */
+ ? parseCallImportOrMetaProperty(parser, context | Context.AllowIn)
+ : parseMemberExpression(parser, context | Context.AllowIn, pos);
+ return parseCallExpression(parser, context | Context.AllowIn, pos, expr);
+ }
+ /**
+ * Parse member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ * @param expr Expression
+ */
+ function parseMemberExpression(parser, context, pos, expr = parsePrimaryExpression(parser, context)) {
+ while (true) {
+ switch (parser.token) {
+ case 16777229 /* Period */: {
+ consume(parser, context, 16777229 /* Period */);
+ parser.flags = parser.flags & ~Flags.AllowBinding | Flags.AllowDestructuring;
+ const property = parseIdentifierNameOrPrivateName(parser, context);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ property,
+ });
+ continue;
+ }
+ case 41943059 /* LeftBracket */: {
+ consume(parser, context, 41943059 /* LeftBracket */);
+ parser.flags = parser.flags & ~Flags.AllowBinding | Flags.AllowDestructuring;
+ const property = parseExpression(parser, context);
+ expect(parser, context, 20 /* RightBracket */);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ property,
+ });
+ continue;
+ }
+ case 33554441 /* TemplateTail */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplateLiteral(parser, context),
+ });
+ continue;
+ }
+ case 33554440 /* TemplateCont */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplate(parser, context | Context.TaggedTemplate),
+ });
+ continue;
+ }
+ default:
+ return expr;
+ }
+ }
+ }
+ /**
+ * Parse call expression
+ *
+ * @param parser Parer instance
+ * @param context Context masks
+ * @param pos Line / Colum info
+ * @param expr Expression
+ */
+ function parseCallExpression(parser, context, pos, expr) {
+ while (true) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ if (parser.token !== 50331659 /* LeftParen */)
+ return expr;
+ const args = parseArgumentList(parser, context & ~Context.AllowDecorator);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+ }
+ /**
+ * Parse cover call expression and async arrow head
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parserCoverCallExpressionAndAsyncArrowHead(parser, context) {
+ const pos = getLocation(parser);
+ let expr = parseMemberExpression(parser, context | Context.AllowIn, pos);
+ // Here we jump right into it and parse a simple, faster sub-grammar for
+ // async arrow / async identifier + call expression. This could have been done different
+ // but ESTree sucks!
+ //
+ // - J.K. Thomas
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (parser.token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */);
+ return parseAsyncArrowFunction(parser, context, ModifierState.Await, pos, [parseAndClassifyIdentifier(parser, context)]);
+ }
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ while (parser.token === 50331659 /* LeftParen */) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ const args = parseAsyncArgumentList(parser, context);
+ if (parser.token === 10 /* Arrow */) {
+ expr = parseAsyncArrowFunction(parser, context, ModifierState.Await, pos, args);
+ break;
+ }
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+ return expr;
+ }
+ /**
+ * Parse argument list
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parseArgumentList(parser, context) {
+ // ArgumentList :
+ // AssignmentOrSpreadExpression
+ // ArgumentList , AssignmentOrSpreadExpression
+ //
+ // AssignmentOrSpreadExpression :
+ // ... AssignmentExpression
+ // AssignmentExpression
+ expect(parser, context, 50331659 /* LeftParen */);
+ const expressions = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ expressions.push(parseSpreadElement(parser, context));
+ }
+ else {
+ if (context & Context.Yield && hasBit(parser.token, 1073741824 /* IsYield */)) {
+ parser.flags |= Flags.HasYield;
+ setPendingError(parser);
+ }
+ expressions.push(parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ }
+ if (parser.token !== 16 /* RightParen */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return expressions;
+ }
+ /**
+ * Parse argument list for async arrow / async call expression
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parseAsyncArgumentList(parser, context) {
+ // Here we are parsing an "extended" argument list tweaked to handle async arrows. This is
+ // done here to avoid overhead and possible performance loss if we only
+ // parse out a simple call expression - E.g 'async(foo, bar)' or 'async(foo, bar)()';
+ //
+ // - J.K. Thomas
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = [];
+ let { token } = parser;
+ let state = CoverCallState.Empty;
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ parser.flags |= Flags.SimpleParameterList;
+ args.push(parseSpreadElement(parser, context));
+ state = CoverCallState.HasSpread;
+ }
+ else {
+ token = parser.token;
+ state = validateAsyncArgumentList(parser, context, state);
+ args.push(restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ }
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ parser.flags &= ~Flags.AllowDestructuring;
+ if (state & CoverCallState.HasSpread)
+ state = CoverCallState.SeenSpread;
+ }
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & CoverCallState.SeenSpread) {
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ }
+ else if (state & CoverCallState.EvalOrArguments) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (state & CoverCallState.Yield) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ else if (parser.flags & Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (state & CoverCallState.Await || parser.flags & Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ }
+ return args;
+ }
+ /**
+ * Parse primary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PrimaryExpression)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parsePrimaryExpression(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ return parseIdentifier(parser, context);
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionOrIdentifier(parser, context);
+ case 50331659 /* LeftParen */:
+ return parseParenthesizedExpression(parser, context | Context.InParen);
+ case 41943059 /* LeftBracket */:
+ return restoreExpressionCoverGrammar(parser, context, parseArrayLiteral);
+ case 41943052 /* LeftBrace */:
+ return restoreExpressionCoverGrammar(parser, context, parseObjectLiteral);
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionExpression(parser, context);
+ case 33566727 /* NullKeyword */:
+ case 33566726 /* TrueKeyword */:
+ case 33566725 /* FalseKeyword */:
+ return parseNullOrTrueOrFalseLiteral(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassExpression(parser, context);
+ case 33566811 /* NewKeyword */:
+ return parseNewExpressionOrMetaProperty(parser, context);
+ case 33566813 /* SuperKeyword */:
+ return parseSuperProperty(parser, context);
+ case 33554551 /* BigIntLiteral */:
+ return parseBigIntLiteral(parser, context);
+ case 33566815 /* ThisKeyword */:
+ return parseThisExpression(parser, context);
+ case 115 /* Hash */:
+ return parseIdentifierNameOrPrivateName(parser, context);
+ case 167774773 /* Divide */:
+ case 100663333 /* DivideAssign */:
+ scanRegularExpression(parser, context);
+ return parseRegularExpressionLiteral(parser, context);
+ case 33554441 /* TemplateTail */:
+ return parseTemplateLiteral(parser, context);
+ case 33554440 /* TemplateCont */:
+ return parseTemplate(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetAsIdentifier(parser, context);
+ case 12369 /* DoKeyword */:
+ if (context & Context.OptionsExperimental)
+ return parseDoExpression(parser, context);
+ default:
+ return parseAndClassifyIdentifier(parser, context);
+ }
+ }
+ /**
+ * Parse do expression (*experimental*)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDoExpression(parser, context) {
+ // AssignmentExpression ::
+ // do '{' StatementList '}'
+ const pos = getLocation(parser);
+ expect(parser, context, 12369 /* DoKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'DoExpression',
+ body: parseBlockStatement(parser, context)
+ });
+ }
+ /**
+ * Parse 'let' as identifier in 'sloppy mode', and throws
+ * in 'strict mode' / 'module code'. We also avoid a lookahead on the
+ * ASI restictions while checking this after parsing out the 'let' keyword
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+ function parseLetAsIdentifier(parser, context) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ if (parser.flags & Flags.NewLine) {
+ if (parser.token === 41943059 /* LeftBracket */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, 'let');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ }
+ /**
+ * Parse either async function expression or identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+ function parseAsyncFunctionOrIdentifier(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) :
+ parseIdentifier(parser, context);
+ }
+ /**
+ * Parses identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIdentifier(parser, context) {
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context | Context.TaggedTemplate);
+ const node = finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ if (context & Context.OptionsRawidentifiers)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parse regular expression literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseRegularExpressionLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenRegExp, tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ regex: tokenRegExp,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = tokenRaw;
+ return node;
+ }
+ /**
+ * Parses string and number literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StringLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.tokenValue;
+ if (context & Context.Strict && parser.flags & Flags.HasOctal) {
+ tolerant(parser, context, 61 /* StrictOctalLiteral */);
+ }
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parses BigInt literal (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/proposal-bigint/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBigIntLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ bigint: tokenRaw,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parses either null or boolean literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BooleanLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNullOrTrueOrFalseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const raw = tokenDesc(token);
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: token === 33566727 /* NullKeyword */ ? null : raw === 'true',
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = raw;
+ return node;
+ }
+ /**
+ * Parse this expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseThisExpression(parser, context) {
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ const pos = getLocation(parser);
+ nextToken(parser, context | Context.DisallowEscapedKeyword);
+ return finishNode(context, parser, pos, {
+ type: 'ThisExpression',
+ });
+ }
+ /**
+ * Parse identifier name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-IdentifierName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t token
+ */
+ function parseIdentifierName(parser, context, t) {
+ if (!(t & (131072 /* IsIdentifier */ | 4096 /* Keyword */)))
+ tolerant(parser, context, 4 /* UnexpectedKeyword */, tokenDesc(t));
+ return parseIdentifier(parser, context);
+ }
+ /**
+ * Parse identifier name or private name (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIdentifierNameOrPrivateName(parser, context) {
+ if (!consume(parser, context, 115 /* Hash */))
+ return parseIdentifierName(parser, context, parser.token);
+ const { tokenValue } = parser;
+ const pos = getLocation(parser);
+ const name = tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+ }
+ /**
+ * Parse array literal
+ *
+ * ArrayLiteral :
+ * [ Elisionopt ]
+ * [ ElementList ]
+ * [ ElementList , Elisionopt ]
+ *
+ * ElementList :
+ * Elisionopt AssignmentExpression
+ * Elisionopt ... AssignmentExpression
+ * ElementList , Elisionopt AssignmentExpression
+ * ElementList , Elisionopt SpreadElement
+ *
+ * Elision :
+ * ,
+ * Elision ,
+ *
+ * SpreadElement :
+ * ... AssignmentExpression
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseArrayLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseSpreadElement(parser, context));
+ if (parser.token !== 20 /* RightBracket */) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ else {
+ elements.push(restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ return finishNode(context, parser, pos, {
+ type: 'ArrayExpression',
+ elements,
+ });
+ }
+ /**
+ * Parses cover parenthesized expression and arrow parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-parseCoverParenthesizedExpressionAndArrowParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseParenthesizedExpression(parser, context) {
+ expect(parser, context, 50331659 /* LeftParen */);
+ if (consume(parser, context, 16 /* RightParen */)) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.token === 10 /* Arrow */)
+ return [];
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ const restExpr = [parseRestElement(parser, context)];
+ expect(parser, context, 16 /* RightParen */);
+ parser.flags = parser.flags & ~(Flags.AllowDestructuring | Flags.AllowBinding) | Flags.SimpleParameterList;
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return restExpr;
+ }
+ // Record the sequence position
+ const sequencepos = getLocation(parser);
+ let state = validateCoverParenthesizedExpression(parser, CoverParenthesizedState.None);
+ let expr = restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ // Sequence expression
+ if (parser.token === 16777234 /* Comma */) {
+ state |= CoverParenthesizedState.SequenceExpression;
+ const expressions = [expr];
+ while (consume(parser, context | Context.DisallowEscapedKeyword, 16777234 /* Comma */)) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (!(parser.flags & Flags.AllowBinding))
+ tolerant(parser, context, 77 /* NotBindable */);
+ parser.flags |= Flags.SimpleParameterList;
+ const restElement = parseRestElement(parser, context);
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ expressions.push(restElement);
+ return expressions;
+ }
+ else if (consume(parser, context, 16 /* RightParen */)) {
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return expressions;
+ }
+ else {
+ state = validateCoverParenthesizedExpression(parser, state);
+ expressions.push(restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression));
+ }
+ }
+ expr = finishNode(context, parser, sequencepos, {
+ type: 'SequenceExpression',
+ expressions,
+ });
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & CoverParenthesizedState.HasEvalOrArguments) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (state & CoverParenthesizedState.HasReservedWords) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ else if (!(parser.flags & Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (parser.flags & Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (context & Context.Async && parser.flags & Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ parser.flags &= ~(Flags.AllowBinding | Flags.HasAwait | Flags.HasYield);
+ return (state & CoverParenthesizedState.SequenceExpression ? expr.expressions : [expr]);
+ }
+ parser.flags &= ~(Flags.HasAwait | Flags.HasYield | Flags.AllowBinding);
+ if (!isValidSimpleAssignmentTarget(expr))
+ parser.flags &= ~Flags.AllowDestructuring;
+ return expr;
+ }
+ /**
+ * Parses function expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & ModifierState.Generator) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty), isGenerator, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: false,
+ generator: !!(isGenerator & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parses async function or async generator expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ const isAwait = ModifierState.Await;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict || isAwait & ModifierState.Await)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ if (token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & ModifierState.Generator)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty), isGenerator | isAwait, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: true,
+ generator: !!(isGenerator & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parse computed property names
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ComputedPropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseComputedPropertyName(parser, context) {
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const key = parseAssignmentExpression(parser, context | Context.AllowIn);
+ expect(parser, context, 20 /* RightBracket */);
+ return key;
+ }
+ /**
+ * Parse property name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePropertyName(parser, context) {
+ switch (parser.token) {
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943059 /* LeftBracket */:
+ return parseComputedPropertyName(parser, context);
+ default:
+ return parseIdentifier(parser, context);
+ }
+ }
+ /**
+ * Parse object spread properties
+ *
+ * @see [Link](https://tc39.github.io/proposal-object-rest-spread/#Spread)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSpreadProperties(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (parser.token & 8388608 /* IsBindingPattern */)
+ parser.flags &= ~Flags.AllowDestructuring;
+ const argument = parseAssignmentExpression(parser, context | Context.AllowIn);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+ }
+ /**
+ * Parses object literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ObjectLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseObjectLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const properties = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ properties.push(parser.token === 14 /* Ellipsis */ ?
+ parseSpreadProperties(parser, context) :
+ parsePropertyDefinition(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ parser.flags &= ~Flags.HasProtoField;
+ return finishNode(context, parser, pos, {
+ type: 'ObjectExpression',
+ properties,
+ });
+ }
+ /**
+ * Parse property definition
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyDefinition)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePropertyDefinition(parser, context) {
+ const pos = getLocation(parser);
+ const flags = parser.flags;
+ let value;
+ let state = consume(parser, context, 167774771 /* Multiply */) ? ObjectState.Generator | ObjectState.Method : ObjectState.Method;
+ const t = parser.token;
+ let key = parsePropertyName(parser, context);
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ else if (!(state & ObjectState.Generator) && t & 524288 /* IsAsync */ && !(parser.flags & Flags.NewLine)) {
+ state |= consume(parser, context, 167774771 /* Multiply */) ? ObjectState.Generator | ObjectState.Async : ObjectState.Async;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69743 /* GetKeyword */) {
+ state = state & ~ObjectState.Method | ObjectState.Getter;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69744 /* SetKeyword */) {
+ state = state & ~ObjectState.Method | ObjectState.Setter;
+ key = parsePropertyName(parser, context);
+ }
+ if (state & (ObjectState.Getter | ObjectState.Setter)) {
+ if (state & ObjectState.Generator)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ state &= ~ObjectState.Method;
+ if (parser.token === 16777237 /* Colon */) {
+ if ((state & (ObjectState.Async | ObjectState.Generator))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ else if (t !== 41943059 /* LeftBracket */ && parser.tokenValue === '__proto__') {
+ if (parser.flags & Flags.HasProtoField) {
+ // Record the error and put it on hold until we've determined
+ // whether or not we're destructuring
+ setPendingExpressionError(parser, 63 /* DuplicateProto */);
+ }
+ else
+ parser.flags |= Flags.HasProtoField;
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ // Invalid: 'async ({a: await}) => 1'
+ if (parser.token & 262144 /* IsAwait */)
+ parser.flags |= Flags.HasAwait;
+ value = restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ }
+ else {
+ if ((state & (ObjectState.Generator | ObjectState.Async)) || !isValidIdentifier(context, t)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(t));
+ }
+ else if (context & (Context.Strict | Context.Yield) && t & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasYield;
+ }
+ state |= ObjectState.Shorthand;
+ if (parser.token === 83886109 /* Assign */) {
+ if (context & Context.Strict && t & 4194304 /* IsEvalOrArguments */) {
+ report(parser, 47 /* StrictEvalArguments */);
+ }
+ else
+ setPendingExpressionError(parser, 91 /* InvalidCoverInitializedName */);
+ expect(parser, context, 83886109 /* Assign */);
+ if (context & (Context.Strict | Context.Yield | Context.Async) && parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */)) {
+ setPendingError(parser);
+ parser.flags |= parser.token & 1073741824 /* IsYield */ ? Flags.HasYield : Flags.HasAwait;
+ }
+ value = parseAssignmentPattern(parser, context, key, pos);
+ }
+ else {
+ if (t & 262144 /* IsAwait */) {
+ if (context & Context.Async)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ value = key;
+ }
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ key,
+ value,
+ kind: !(state & ObjectState.Getter | state & ObjectState.Setter) ? 'init' : (state & ObjectState.Setter) ? 'set' : 'get',
+ computed: t === 41943059 /* LeftBracket */,
+ method: !!(state & ObjectState.Method),
+ shorthand: !!(state & ObjectState.Shorthand),
+ });
+ }
+ /**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseMethodDeclaration(parser, context, state) {
+ const pos = getLocation(parser);
+ const isGenerator = state & ObjectState.Generator ? ModifierState.Generator : ModifierState.None;
+ const isAsync = state & ObjectState.Async ? ModifierState.Await : ModifierState.None;
+ const { params, body } = swapContext(parser, context | Context.Method, isGenerator | isAsync, parseFormalListAndBody, state);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: !!(state & ObjectState.Async),
+ generator: !!(state & ObjectState.Generator),
+ expression: false,
+ id: null,
+ });
+ }
+ /**
+ * Parse arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseArrowFunction(parser, context, pos, params) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, '=>');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context & ~Context.Async, params, pos, ModifierState.None);
+ }
+ /**
+ * Parse async arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncArrowFunction(parser, context, state, pos, params) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context | Context.Async, params, pos, state);
+ }
+ /**
+ * Shared helper function for both async arrow and arrows
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ // https://tc39.github.io/ecma262/#prod-AsyncArrowFunction
+ function parseArrowBody(parser, context, params, pos, state) {
+ parser.pendingExpressionError = null;
+ for (const i in params)
+ reinterpret(parser, context | Context.InParameter, params[i]);
+ const expression = parser.token !== 41943052 /* LeftBrace */;
+ const body = expression ? parseExpressionCoverGrammar(parser, context & ~(Context.Yield | Context.InParameter), parseAssignmentExpression) :
+ swapContext(parser, context & ~(Context.Yield | Context.AllowDecorator) | Context.InFunctionBody, state, parseFunctionBody);
+ return finishNode(context, parser, pos, {
+ type: 'ArrowFunctionExpression',
+ body,
+ params,
+ id: null,
+ async: !!(state & ModifierState.Await),
+ generator: false,
+ expression,
+ });
+ }
+ /**
+ * Parses formal parameters and function body.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFormalListAndBody(parser, context, state) {
+ const paramList = parseFormalParameters(parser, context | Context.InParameter, state);
+ const args = paramList.args;
+ const params = paramList.params;
+ const body = parseFunctionBody(parser, context & ~Context.AllowDecorator | Context.InFunctionBody, args);
+ return { params, body };
+ }
+ /**
+ * Parse funciton body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionBody(parser, context, params) {
+ // Note! The 'params' has an 'any' type now because it's really shouldn't be there. This should have been
+ // on the parser object instead. So for now the 'params' arg are only used within the
+ // 'parseFormalListAndBody' method, and not within the arrow function body.
+ const pos = getLocation(parser);
+ expect(parser, context | Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const body = [];
+ while (parser.token === 33554435 /* StringLiteral */) {
+ const { tokenRaw, tokenValue } = parser;
+ body.push(parseDirective(parser, context));
+ if (tokenRaw.length === /* length of prologue*/ 12 && tokenValue === 'use strict') {
+ if (parser.flags & Flags.SimpleParameterList) {
+ tolerant(parser, context, 64 /* IllegalUseStrict */);
+ }
+ else if (parser.flags & (Flags.HasStrictReserved | Flags.StrictFunctionName)) {
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ }
+ else if (parser.flags & Flags.StrictEvalArguments) {
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ }
+ context |= Context.Strict;
+ }
+ }
+ if (context & Context.Strict) {
+ validateParams(parser, context, params);
+ }
+ const { labelSet } = parser;
+ parser.labelSet = {};
+ const savedFlags = parser.flags;
+ parser.flags = parser.flags & ~(Flags.StrictFunctionName | Flags.StrictEvalArguments | Flags.InSwitchStatement | Flags.InIterationStatement) | Flags.AllowDestructuring;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ if (savedFlags & Flags.InIterationStatement)
+ parser.flags |= Flags.InIterationStatement;
+ if (savedFlags & Flags.InSwitchStatement)
+ parser.flags |= Flags.InSwitchStatement;
+ parser.labelSet = labelSet;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body,
+ });
+ }
+ /**
+ * Parse formal parameters
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param Parser object
+ * @param Context masks
+ * @param Optional objectstate. Default to none
+ */
+ function parseFormalParameters(parser, context, state) {
+ // FormalParameterList :
+ // [empty]
+ // FunctionRestParameter
+ // FormalsList
+ // FormalsList , FunctionRestParameter
+ //
+ // FunctionRestParameter :
+ // ... BindingIdentifier
+ //
+ // FormalsList :
+ // FormalParameter
+ // FormalsList , FormalParameter
+ //
+ // FormalParameter :
+ // BindingElement
+ //
+ // BindingElement :
+ // SingleNameBinding
+ // BindingPattern Initializeropt
+ expect(parser, context, 50331659 /* LeftParen */);
+ parser.flags &= ~(Flags.SimpleParameterList | Flags.HasStrictReserved);
+ const args = [];
+ const params = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (state & ObjectState.Setter)
+ tolerant(parser, context, 67 /* BadSetterRestParameter */);
+ parser.flags |= Flags.SimpleParameterList;
+ params.push(parseRestElement(parser, context, args));
+ break;
+ }
+ params.push(parseFormalParameterList(parser, context, args));
+ if (!consume(parser, context, 16777234 /* Comma */))
+ break;
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ if (state & ObjectState.Setter && params.length !== 1) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Setter', 'one', '');
+ }
+ if (state & ObjectState.Getter && params.length > 0) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Getter', 'no', 's');
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return { params, args };
+ }
+ /**
+ * Parse formal parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFormalParameterList(parser, context, args) {
+ const pos = getLocation(parser);
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (hasBit(parser.token, 20480 /* FutureReserved */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ if (hasBit(parser.token, 4194304 /* IsEvalOrArguments */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ }
+ else {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ const left = parseBindingIdentifierOrPattern(parser, context, args);
+ if (!consume(parser, context, 83886109 /* Assign */))
+ return left;
+ if (parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */) && context & (Context.Yield | Context.Async)) {
+ tolerant(parser, context, parser.token & 262144 /* IsAwait */ ? 52 /* AwaitInParameter */ : 51 /* YieldInParameter */);
+ }
+ parser.flags |= Flags.SimpleParameterList;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse class expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassExpression(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const { token } = parser;
+ let state = ObjectState.None;
+ let id = null;
+ let superClass = null;
+ if ((token !== 41943052 /* LeftBrace */ && token !== 12372 /* ExtendsKeyword */)) {
+ if (context & Context.Async && token & 262144 /* IsAwait */) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context | Context.Strict);
+ }
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | Context.Strict, pos);
+ state |= ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context | Context.Strict, state);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ });
+ }
+ /**
+ * Parse class body and element list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElementList)
+ *
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassBodyAndElementList(parser, context, state) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const body = [];
+ let decorators = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (!consume(parser, context, 17825809 /* Semicolon */)) {
+ if (context & Context.OptionsExperimental) {
+ decorators = parseDecorators(parser, context);
+ if (parser.token === 17825807 /* RightBrace */)
+ report(parser, 92 /* TrailingDecorators */);
+ if (decorators.length !== 0 && parser.tokenValue === 'constructor') {
+ report(parser, 93 /* GeneratorConstructor */);
+ }
+ }
+ body.push(context & Context.OptionsNext && parser.token === 115 /* Hash */
+ ? parsePrivateFields(parser, context, decorators)
+ : parseClassElement(parser, context, state, decorators));
+ }
+ }
+ parser.flags &= ~Flags.HasConstructor;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ClassBody',
+ body,
+ });
+ }
+ /**
+ * Parse class element and class public instance fields & private instance fields
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElement)
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassElement(parser, context, state, decorators) {
+ const pos = getLocation(parser);
+ let { tokenValue, token } = parser;
+ const flags = parser.flags;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ state |= ObjectState.Generator;
+ }
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ if (parser.tokenValue === 'constructor') {
+ if (state & ObjectState.Generator)
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'generator');
+ else if (state & ObjectState.Heritage)
+ context |= Context.AllowSuperProperty;
+ state |= ObjectState.Constructor;
+ }
+ let key = parsePropertyName(parser, context);
+ let value;
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ if (token === 20585 /* StaticKeyword */) {
+ token = parser.token;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= ObjectState.Generator;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ if (parser.tokenValue === 'prototype')
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ state |= ObjectState.Static;
+ key = parsePropertyName(parser, context);
+ if (context & Context.OptionsNext && isInstanceField(parser)) {
+ if (tokenValue === 'constructor')
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ }
+ }
+ if (parser.token !== 50331659 /* LeftParen */) {
+ if (token & 524288 /* IsAsync */ && !(state & ObjectState.Generator) && !(parser.flags & Flags.NewLine)) {
+ token = parser.token;
+ tokenValue = parser.tokenValue;
+ state |= ObjectState.Async;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= ObjectState.Generator;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ key = parsePropertyName(parser, context);
+ }
+ else if ((token === 69743 /* GetKeyword */ || token === 69744 /* SetKeyword */)) {
+ state |= token === 69743 /* GetKeyword */ ? ObjectState.Getter : ObjectState.Setter;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ key = parsePropertyName(parser, context & ~Context.Strict);
+ }
+ if (tokenValue === 'prototype') {
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ }
+ else if (!(state & ObjectState.Static) && tokenValue === 'constructor') {
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'accessor');
+ }
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ if (!(state & ObjectState.Computed) && state & ObjectState.Constructor) {
+ if (parser.flags & Flags.HasConstructor)
+ report(parser, 12 /* DuplicateConstructor */);
+ else
+ parser.flags |= Flags.HasConstructor;
+ }
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ if (context & Context.OptionsNext)
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const kind = (state & ObjectState.Constructor) ? 'constructor' : (state & ObjectState.Getter) ? 'get' :
+ (state & ObjectState.Setter) ? 'set' : 'method';
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & ObjectState.Static),
+ computed: !!(state & ObjectState.Computed),
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & ObjectState.Static),
+ computed: !!(state & ObjectState.Computed),
+ key,
+ value,
+ });
+ }
+ /**
+ * Parses field definition.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFieldDefinition(parser, context, key, state, pos, decorators) {
+ if (state & ObjectState.Constructor)
+ tolerant(parser, context, 0 /* Unexpected */);
+ let value = null;
+ if (state & (ObjectState.Async | ObjectState.Generator))
+ tolerant(parser, context, 0 /* Unexpected */);
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & ObjectState.Computed),
+ static: !!(state & ObjectState.Static),
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & ObjectState.Computed),
+ static: !!(state & ObjectState.Static),
+ });
+ }
+ /**
+ * Parse private name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePrivateName(parser, context, pos) {
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+ }
+ /**
+ * Parses private instance fields
+ *
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePrivateFields(parser, context, decorators) {
+ const pos = getLocation(parser);
+ expect(parser, context | Context.InClass, 115 /* Hash */);
+ if (parser.tokenValue === 'constructor')
+ tolerant(parser, context, 41 /* PrivateFieldConstructor */);
+ const key = parsePrivateName(parser, context, pos);
+ if (parser.token === 50331659 /* LeftParen */)
+ return parsePrivateMethod(parser, context, key, pos, decorators);
+ let value = null;
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ });
+ }
+ function parsePrivateMethod(parser, context, key, pos, decorators) {
+ const value = parseMethodDeclaration(parser, context | Context.Strict, ObjectState.None);
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ });
+ }
+ /**
+ * Parse either call expression or import expressions
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCallImportOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ // Import.meta - Stage 3 proposal
+ if (consume(parser, context, 16777229 /* Period */)) {
+ if (context & Context.Module && parser.tokenValue === 'meta')
+ return parseMetaProperty(parser, context, id, pos);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ let expr = parseImportExpression(parser, context, pos);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16 /* RightParen */);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: [args],
+ });
+ return expr;
+ }
+ /**
+ * Parse Import() expression. (Stage 3 proposal)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+ function parseImportExpression(parser, context, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'Import',
+ });
+ }
+ /**
+ * Parse meta property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Identifier
+ * @param pos Location
+ */
+ function parseMetaProperty(parser, context, meta, pos) {
+ return finishNode(context, parser, pos, {
+ meta,
+ type: 'MetaProperty',
+ property: parseIdentifier(parser, context),
+ });
+ }
+ /**
+ * Parse new expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NewExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNewExpressionOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ if (consume(parser, context | Context.DisallowEscapedKeyword, 16777229 /* Period */)) {
+ if (parser.tokenValue !== 'target' ||
+ !(context & (Context.InParameter | Context.InFunctionBody)))
+ tolerant(parser, context, 53 /* MetaNotInFunctionBody */);
+ return parseMetaProperty(parser, context, id, pos);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'NewExpression',
+ callee: parseImportOrMemberExpression(parser, context, pos),
+ arguments: parser.token === 50331659 /* LeftParen */ ? parseArgumentList(parser, context) : [],
+ });
+ }
+ /**
+ * Parse either import or member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportOrMemberExpression(parser, context, pos) {
+ const { token } = parser;
+ if (context & Context.OptionsNext && token === 33566810 /* ImportKeyword */) {
+ // Invalid: '"new import(x)"'
+ if (lookahead(parser, context, nextTokenIsLeftParen))
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ // Fixes cases like ''new import.meta','
+ return parseCallImportOrMetaProperty(parser, context);
+ }
+ return parseMemberExpression(parser, context, pos);
+ }
+ /**
+ * Parse super property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SuperProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSuperProperty(parser, context) {
+ // SuperProperty[Yield, Await]:
+ // super[Expression[+In, ?Yield, ?Await]]
+ // super.IdentifierName
+ const pos = getLocation(parser);
+ expect(parser, context, 33566813 /* SuperKeyword */);
+ switch (parser.token) {
+ case 50331659 /* LeftParen */:
+ // The super property has to be within a class constructor
+ if (!(context & Context.AllowSuperProperty))
+ tolerant(parser, context, 54 /* BadSuperCall */);
+ break;
+ case 41943059 /* LeftBracket */:
+ case 16777229 /* Period */:
+ if (!(context & Context.Method))
+ tolerant(parser, context, 55 /* UnexpectedSuper */);
+ break;
+ default:
+ tolerant(parser, context, 56 /* LoneSuper */);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Super',
+ });
+ }
+ /**
+ * Parse template literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseTemplateLiteral(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions: [],
+ quasis: [parseTemplateSpans(parser, context)],
+ });
+ }
+ /**
+ * Parse template head
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param cooked Cooked template value
+ * @param raw Raw template value
+ * @param pos Current location
+ */
+ function parseTemplateHead(parser, context, cooked = null, raw, pos) {
+ parser.token = consumeTemplateBrace(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked,
+ raw,
+ },
+ tail: false,
+ });
+ }
+ /**
+ * Parse template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expression Expression AST node
+ * @param quasis Array of Template elements
+ */
+ function parseTemplate(parser, context, expressions = [], quasis = []) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554440 /* TemplateCont */);
+ expressions.push(parseExpression(parser, context));
+ const t = getLocation(parser);
+ quasis.push(parseTemplateHead(parser, context, tokenValue, tokenRaw, pos));
+ if (parser.token === 33554441 /* TemplateTail */) {
+ quasis.push(parseTemplateSpans(parser, context, t));
+ }
+ else {
+ parseTemplate(parser, context, expressions, quasis);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions,
+ quasis,
+ });
+ }
+ /**
+ * Parse template spans
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateSpans)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param loc Current AST node location
+ */
+ function parseTemplateSpans(parser, context, pos = getLocation(parser)) {
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554441 /* TemplateTail */);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked: tokenValue,
+ raw: tokenRaw,
+ },
+ tail: true,
+ });
+ }
+ /**
+ * Parses decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDecoratorList(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'Decorator',
+ expression: parseLeftHandSideExpression(parser, context, pos)
+ });
+ }
+ /**
+ * Parses a list of decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDecorators(parser, context) {
+ const decoratorList = [];
+ while (consume(parser, context, 120 /* At */)) {
+ decoratorList.push(parseDecoratorList(parser, context | Context.AllowDecorator));
+ }
+ return decoratorList;
+ } + + // Context masks
+ var Context;
+ (function (Context) {
+ Context[Context["Empty"] = 0] = "Empty";
+ Context[Context["OptionsNext"] = 1] = "OptionsNext";
+ Context[Context["OptionsRanges"] = 2] = "OptionsRanges";
+ Context[Context["OptionsJSX"] = 4] = "OptionsJSX";
+ Context[Context["OptionsRaw"] = 8] = "OptionsRaw";
+ Context[Context["OptionsLoc"] = 16] = "OptionsLoc";
+ Context[Context["OptionsGlobalReturn"] = 32] = "OptionsGlobalReturn";
+ Context[Context["OptionsComments"] = 64] = "OptionsComments";
+ Context[Context["OptionsShebang"] = 128] = "OptionsShebang";
+ Context[Context["OptionsRawidentifiers"] = 256] = "OptionsRawidentifiers";
+ Context[Context["OptionsTolerant"] = 512] = "OptionsTolerant";
+ Context[Context["OptionsNode"] = 1024] = "OptionsNode";
+ Context[Context["OptionsExperimental"] = 2048] = "OptionsExperimental";
+ Context[Context["Strict"] = 4096] = "Strict";
+ Context[Context["Module"] = 8192] = "Module";
+ Context[Context["TaggedTemplate"] = 16384] = "TaggedTemplate";
+ Context[Context["InClass"] = 32768] = "InClass";
+ Context[Context["AllowIn"] = 65536] = "AllowIn";
+ Context[Context["Async"] = 131072] = "Async";
+ Context[Context["Yield"] = 262144] = "Yield";
+ Context[Context["InParameter"] = 524288] = "InParameter";
+ Context[Context["InFunctionBody"] = 1048576] = "InFunctionBody";
+ Context[Context["AllowSingleStatement"] = 2097152] = "AllowSingleStatement";
+ Context[Context["BlockScope"] = 4194304] = "BlockScope";
+ Context[Context["ForStatement"] = 8388608] = "ForStatement";
+ Context[Context["RequireIdentifier"] = 16777216] = "RequireIdentifier";
+ Context[Context["Method"] = 33554432] = "Method";
+ Context[Context["AllowSuperProperty"] = 67108864] = "AllowSuperProperty";
+ Context[Context["InParen"] = 134217728] = "InParen";
+ Context[Context["InJSXChild"] = 268435456] = "InJSXChild";
+ Context[Context["DisallowEscapedKeyword"] = 536870912] = "DisallowEscapedKeyword";
+ Context[Context["AllowDecorator"] = 1073741824] = "AllowDecorator";
+ Context[Context["LocationTracker"] = 18] = "LocationTracker";
+ })(Context || (Context = exports('Context', {})));
+ // Mutual parser flags
+ var Flags;
+ (function (Flags) {
+ Flags[Flags["None"] = 0] = "None";
+ Flags[Flags["NewLine"] = 1] = "NewLine";
+ Flags[Flags["AllowBinding"] = 2] = "AllowBinding";
+ Flags[Flags["AllowDestructuring"] = 4] = "AllowDestructuring";
+ Flags[Flags["SimpleParameterList"] = 8] = "SimpleParameterList";
+ Flags[Flags["InSwitchStatement"] = 16] = "InSwitchStatement";
+ Flags[Flags["InIterationStatement"] = 32] = "InIterationStatement";
+ Flags[Flags["HasStrictReserved"] = 64] = "HasStrictReserved";
+ Flags[Flags["HasOctal"] = 128] = "HasOctal";
+ Flags[Flags["SimpleAssignmentTarget"] = 256] = "SimpleAssignmentTarget";
+ Flags[Flags["HasProtoField"] = 512] = "HasProtoField";
+ Flags[Flags["StrictFunctionName"] = 1024] = "StrictFunctionName";
+ Flags[Flags["StrictEvalArguments"] = 2048] = "StrictEvalArguments";
+ Flags[Flags["InFunctionBody"] = 4096] = "InFunctionBody";
+ Flags[Flags["HasAwait"] = 8192] = "HasAwait";
+ Flags[Flags["HasYield"] = 16384] = "HasYield";
+ Flags[Flags["EscapedKeyword"] = 32768] = "EscapedKeyword";
+ Flags[Flags["HasConstructor"] = 65536] = "HasConstructor";
+ })(Flags || (Flags = exports('Flags', {})));
+ // Label tracking state
+ var Labels;
+ (function (Labels) {
+ Labels[Labels["None"] = 0] = "None";
+ Labels[Labels["NotNested"] = 1] = "NotNested";
+ Labels[Labels["Nested"] = 2] = "Nested";
+ })(Labels || (Labels = exports('Labels', {})));
+ var NumericState;
+ (function (NumericState) {
+ NumericState[NumericState["None"] = 0] = "None";
+ NumericState[NumericState["SeenSeparator"] = 1] = "SeenSeparator";
+ NumericState[NumericState["EigthOrNine"] = 2] = "EigthOrNine";
+ NumericState[NumericState["Float"] = 4] = "Float";
+ NumericState[NumericState["BigInt"] = 8] = "BigInt";
+ })(NumericState || (NumericState = exports('NumericState', {})));
+ var ScannerState;
+ (function (ScannerState) {
+ ScannerState[ScannerState["None"] = 0] = "None";
+ ScannerState[ScannerState["NewLine"] = 1] = "NewLine";
+ ScannerState[ScannerState["LastIsCR"] = 2] = "LastIsCR";
+ })(ScannerState || (ScannerState = exports('ScannerState', {})));
+ var ModifierState;
+ (function (ModifierState) {
+ ModifierState[ModifierState["None"] = 0] = "None";
+ ModifierState[ModifierState["Generator"] = 1] = "Generator";
+ ModifierState[ModifierState["Await"] = 2] = "Await";
+ })(ModifierState || (ModifierState = exports('ModifierState', {})));
+ var CoverParenthesizedState;
+ (function (CoverParenthesizedState) {
+ CoverParenthesizedState[CoverParenthesizedState["None"] = 0] = "None";
+ CoverParenthesizedState[CoverParenthesizedState["SequenceExpression"] = 1] = "SequenceExpression";
+ CoverParenthesizedState[CoverParenthesizedState["HasEvalOrArguments"] = 2] = "HasEvalOrArguments";
+ CoverParenthesizedState[CoverParenthesizedState["HasReservedWords"] = 4] = "HasReservedWords";
+ CoverParenthesizedState[CoverParenthesizedState["HasYield"] = 8] = "HasYield";
+ CoverParenthesizedState[CoverParenthesizedState["HasBinding"] = 16] = "HasBinding";
+ })(CoverParenthesizedState || (CoverParenthesizedState = exports('CoverParenthesizedState', {})));
+ var Escape;
+ (function (Escape) {
+ Escape[Escape["Empty"] = -1] = "Empty";
+ Escape[Escape["StrictOctal"] = -2] = "StrictOctal";
+ Escape[Escape["EightOrNine"] = -3] = "EightOrNine";
+ Escape[Escape["InvalidHex"] = -4] = "InvalidHex";
+ Escape[Escape["OutOfRange"] = -5] = "OutOfRange";
+ })(Escape || (Escape = exports('Escape', {})));
+ var RegexFlags;
+ (function (RegexFlags) {
+ RegexFlags[RegexFlags["Empty"] = 0] = "Empty";
+ RegexFlags[RegexFlags["IgnoreCase"] = 1] = "IgnoreCase";
+ RegexFlags[RegexFlags["Global"] = 2] = "Global";
+ RegexFlags[RegexFlags["Multiline"] = 4] = "Multiline";
+ RegexFlags[RegexFlags["Unicode"] = 8] = "Unicode";
+ RegexFlags[RegexFlags["Sticky"] = 16] = "Sticky";
+ RegexFlags[RegexFlags["DotAll"] = 32] = "DotAll";
+ })(RegexFlags || (RegexFlags = exports('RegexFlags', {})));
+ var CoverCallState;
+ (function (CoverCallState) {
+ CoverCallState[CoverCallState["Empty"] = 0] = "Empty";
+ CoverCallState[CoverCallState["SeenSpread"] = 1] = "SeenSpread";
+ CoverCallState[CoverCallState["HasSpread"] = 2] = "HasSpread";
+ CoverCallState[CoverCallState["SimpleParameter"] = 4] = "SimpleParameter";
+ CoverCallState[CoverCallState["EvalOrArguments"] = 8] = "EvalOrArguments";
+ CoverCallState[CoverCallState["Yield"] = 16] = "Yield";
+ CoverCallState[CoverCallState["Await"] = 32] = "Await";
+ })(CoverCallState || (CoverCallState = exports('CoverCallState', {})));
+ var RegexState;
+ (function (RegexState) {
+ RegexState[RegexState["Empty"] = 0] = "Empty";
+ RegexState[RegexState["Escape"] = 1] = "Escape";
+ RegexState[RegexState["Class"] = 2] = "Class";
+ })(RegexState || (RegexState = exports('RegexState', {})));
+ // Shared between class expr / decl & object literal
+ var ObjectState;
+ (function (ObjectState) {
+ ObjectState[ObjectState["None"] = 0] = "None";
+ ObjectState[ObjectState["Async"] = 1] = "Async";
+ ObjectState[ObjectState["Generator"] = 2] = "Generator";
+ ObjectState[ObjectState["Getter"] = 4] = "Getter";
+ ObjectState[ObjectState["Setter"] = 8] = "Setter";
+ ObjectState[ObjectState["Computed"] = 16] = "Computed";
+ ObjectState[ObjectState["Method"] = 32] = "Method";
+ ObjectState[ObjectState["Shorthand"] = 64] = "Shorthand";
+ ObjectState[ObjectState["Static"] = 128] = "Static";
+ ObjectState[ObjectState["Constructor"] = 256] = "Constructor";
+ ObjectState[ObjectState["Heritage"] = 512] = "Heritage";
+ })(ObjectState || (ObjectState = exports('ObjectState', {})));
+ /**
+ * Validate break and continue statement
+ *
+ * @param parser Parser object
+ * @param label label
+ * @param isContinue true if validation continue statement
+ */
+ function validateBreakOrContinueLabel(parser, context, label, isContinue) {
+ const state = hasLabel(parser, label);
+ if (!state)
+ tolerant(parser, context, 32 /* UnknownLabel */, label);
+ if (isContinue && !(state & Labels.Nested))
+ tolerant(parser, context, 31 /* IllegalContinue */, label);
+ }
+ /**
+ * Add label to the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+ function addLabel(parser, label) {
+ if (parser.labelSet === undefined)
+ parser.labelSet = {};
+ parser.labelSet[`$${label}`] = isIterationStatement(parser.token) ? Labels.Nested : Labels.NotNested;
+ }
+ /**
+ * Remove label from the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+ function popLabel(parser, label) {
+ parser.labelSet[`$${label}`] = Labels.None;
+ }
+ /**
+ * Returns either true or false. Depends if the label exist.
+ *
+ * @param parser Parser object
+ * @param label Label
+ */
+ function hasLabel(parser, label) {
+ return !parser.labelSet ? Labels.None : parser.labelSet[`$${label}`];
+ }
+ /**
+ * Finish each the node for each parse. Set line / and column on the node if the
+ * options are set for it
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Line / column
+ * @param node AST node
+ */
+ function finishNode(context, parser, meta, node) {
+ const { lastIndex, lastLine, lastColumn, sourceFile, index } = parser;
+ if (context & Context.LocationTracker) {
+ if (context & Context.OptionsRanges) {
+ node.start = meta.index;
+ node.end = lastIndex;
+ }
+ if (context & Context.OptionsLoc) {
+ node.loc = {
+ start: { line: meta.line, column: meta.column },
+ end: { line: lastLine, column: lastColumn }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ return node;
+ }
+ /**
+ * Consumes the next token. If the consumed token is not of the expected type
+ * then report an error and return null. Otherwise return true.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ * @param Err Optionally error message to be thrown
+ */
+ function expect(parser, context, token, err = 1 /* UnexpectedToken */) {
+ if (parser.token !== token)
+ report(parser, err, tokenDesc(parser.token));
+ nextToken(parser, context);
+ return true;
+ }
+ /**
+ * If the next token matches the given token, this consumes the token
+ * and returns true. Otherwise return false.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ */
+ function consume(parser, context, token) {
+ if (parser.token !== token)
+ return false;
+ nextToken(parser, context);
+ return true;
+ }
+ /**
+ * Advance and return the next token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextToken(parser, context) {
+ parser.lastIndex = parser.index;
+ parser.lastLine = parser.line;
+ parser.lastColumn = parser.column;
+ return (parser.token = scan(parser, context));
+ }
+ const hasBit = exports('hasBit', (mask, flags) => (mask & flags) === flags);
+ /**
+ * Automatic Semicolon Insertion
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeSemicolon(parser, context) {
+ return parser.token & 1048576 /* ASI */ || parser.flags & Flags.NewLine
+ ? consume(parser, context, 17825809 /* Semicolon */)
+ : report(parser, !(context & Context.Async) && parser.token & 262144 /* IsAwait */ ? 38 /* AwaitOutsideAsync */ : 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ /**
+ * Bit fiddle current grammar state and keep track of the state during the parse and restore
+ * it back to original state after finish parsing or throw.
+ *
+ * Ideas for this is basicly from V8 and SM, but also the Esprima parser does this in a similar way.
+ *
+ * However this implementation is an major improvement over similiar implementations, and
+ * does not require additonal bitmasks to be set / unset during the parsing outside this function.
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ * @param errMsg Optional error message
+ */
+ function parseExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= Flags.AllowBinding | Flags.AllowDestructuring;
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // If there exist an pending expression error, we throw an error at
+ // the same location it was recorded
+ if (!!parser.pendingExpressionError) {
+ const { error, line, column, index } = parser.pendingExpressionError;
+ constructError(parser, context, index, line, column, error);
+ }
+ // Here we - just in case - disallow both binding and destructuring
+ // and only set the bitmaks if the previous flags (before the callback)
+ // is positive.
+ // Note that this bitmasks may have been turned off during parsing
+ // the callback
+ parser.flags &= ~(Flags.AllowBinding | Flags.AllowDestructuring);
+ if (flags & Flags.AllowBinding)
+ parser.flags |= Flags.AllowBinding;
+ if (flags & Flags.AllowDestructuring)
+ parser.flags |= Flags.AllowDestructuring;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+ }
+ /**
+ * Restor current grammar to previous state, or unset necessary bitmasks
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ */
+ function restoreExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= Flags.AllowBinding | Flags.AllowDestructuring;
+ // Clear pending expression error
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // Both the previous bitmasks and bitmasks set during parsing the callback
+ // has to be positive for us to allow further binding or destructuring.
+ // Note that we allow both before the callback, so this is the only thing
+ // we need to check for.
+ if (!(parser.flags & Flags.AllowBinding) || !(flags & Flags.AllowBinding)) {
+ parser.flags &= ~Flags.AllowBinding;
+ }
+ if (!(parser.flags & Flags.AllowDestructuring) || !(flags & Flags.AllowDestructuring)) {
+ parser.flags &= ~Flags.AllowDestructuring;
+ }
+ // Here we either
+ // 1) restore to previous pending expression error
+ // or
+ // 2) if a pending expression error have been set during the parse (*only in object literal*)
+ // we overwrite previous error, and keep the new one
+ parser.pendingExpressionError = pendingExpressionError || parser.pendingExpressionError;
+ return res;
+ }
+ /**
+ * Set / unset yield / await context masks based on the
+ * ModifierState masks before invoking the callback and
+ * returning it's content
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Modifier state
+ * @param callback Callback function to be invoked
+ * @param methodState Optional Objectstate.
+ */
+ function swapContext(parser, context, state, callback, methodState = ObjectState.None) {
+ context &= ~(Context.Async | Context.Yield | Context.InParameter);
+ if (state & ModifierState.Generator)
+ context |= Context.Yield;
+ if (state & ModifierState.Await)
+ context |= Context.Async;
+ return callback(parser, context, methodState);
+ }
+ /**
+ * Validates function params
+ *
+ * Note! In case anyone want to enable full scoping, replace 'paramSet' with an similiar
+ * object on the parser object itself. Then push / set the tokenValue to
+ * it an use an bitmask to mark it as an 'variable' not 'blockscope'. Then when
+ * implementing lexical scoping, you can use that for validation.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param params Array of token values
+ */
+ function validateParams(parser, context, params) {
+ const paramSet = new Map();
+ for (let i = 0; i < params.length; i++) {
+ const key = `@${params[i]}`;
+ if (paramSet.get(key)) {
+ tolerant(parser, context, 81 /* ParamDupe */);
+ }
+ else
+ paramSet.set(key, true);
+ }
+ }
+ /**
+ * Reinterpret various expressions as pattern
+ * This is only used for assignment and arrow parameter list
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param node AST node
+ */
+ const reinterpret = exports('reinterpret', (parser, context, node) => {
+ switch (node.type) {
+ case 'Identifier':
+ if (context & Context.Strict && nameIsArgumentsOrEval(node.name))
+ report(parser, 3 /* InvalidEscapedReservedWord */);
+ case 'ArrayPattern':
+ case 'AssignmentPattern':
+ case 'ObjectPattern':
+ case 'RestElement':
+ case 'MetaProperty':
+ return;
+ case 'ArrayExpression':
+ node.type = 'ArrayPattern';
+ for (let i = 0; i < node.elements.length; ++i) {
+ // skip holes in pattern
+ if (node.elements[i] !== null) {
+ reinterpret(parser, context, node.elements[i]);
+ }
+ }
+ return;
+ case 'ObjectExpression':
+ node.type = 'ObjectPattern';
+ for (let i = 0; i < node.properties.length; i++) {
+ reinterpret(parser, context, node.properties[i]);
+ }
+ return;
+ case 'Property':
+ reinterpret(parser, context, node.value);
+ return;
+ case 'SpreadElement':
+ node.type = 'RestElement';
+ if (node.argument.type !== 'ArrayExpression' &&
+ node.argument.type !== 'ObjectExpression' &&
+ !isValidSimpleAssignmentTarget(node.argument)) {
+ tolerant(parser, context, 71 /* RestDefaultInitializer */);
+ }
+ reinterpret(parser, context, node.argument);
+ break;
+ case 'AssignmentExpression':
+ node.type = 'AssignmentPattern';
+ delete node.operator; // operator is not relevant for assignment pattern
+ reinterpret(parser, context, node.left); // recursive descent
+ return;
+ case 'MemberExpression':
+ if (!(context & Context.InParameter))
+ return;
+ // Fall through
+ default:
+ tolerant(parser, context, context & Context.InParameter ? 77 /* NotBindable */ : 73 /* InvalidDestructuringTarget */, node.type);
+ }
+ });
+ /**
+ * Does a lookahead.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param callback Callback function to be invoked
+ */
+ function lookahead(parser, context, callback) {
+ const { tokenValue, flags, line, column, startColumn, index, lastColumn, startLine, lastLine, lastIndex, startIndex, tokenRaw, token, lastValue, tokenRegExp, labelSet, errors, errorLocation, pendingExpressionError } = parser;
+ const res = callback(parser, context);
+ parser.index = index;
+ parser.token = token;
+ parser.tokenValue = tokenValue;
+ parser.tokenValue = tokenValue;
+ parser.flags = flags;
+ parser.line = line;
+ parser.column = column;
+ parser.tokenRaw = tokenRaw;
+ parser.lastValue = lastValue;
+ parser.startColumn = startColumn;
+ parser.lastColumn = lastColumn;
+ parser.startLine = startLine;
+ parser.lastLine = lastLine;
+ parser.lastIndex = lastIndex;
+ parser.startIndex = startIndex;
+ parser.tokenRegExp = tokenRegExp;
+ parser.labelSet = labelSet;
+ parser.errors = errors;
+ parser.errorLocation = errorLocation;
+ parser.tokenRegExp = tokenRegExp;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+ }
+ /**
+ * Returns true if this an valid simple assignment target
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isValidSimpleAssignmentTarget(node) {
+ return node.type === 'Identifier' || node.type === 'MemberExpression' ? true : false;
+ }
+ /**
+ * Get current node location
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function getLocation(parser) {
+ return {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+ }
+ /**
+ * Returns true if this is an valid identifier
+ *
+ * @param context Context masks
+ * @param t Token
+ */
+ function isValidIdentifier(context, t) {
+ if (context & Context.Strict) {
+ if (context & Context.Module && t & 262144 /* IsAwait */)
+ return false;
+ if (t & 1073741824 /* IsYield */)
+ return false;
+ return (t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (t & 69632 /* Contextual */) === 69632 /* Contextual */;
+ }
+ return ((t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (t & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (t & 20480 /* FutureReserved */) === 20480 /* FutureReserved */);
+ }
+ /**
+ * Returns true if this an valid lexical binding and not an identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isLexical(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return !!(token & (131072 /* IsIdentifier */ | 8388608 /* IsBindingPattern */ | 1073741824 /* IsYield */ | 262144 /* IsAwait */) ||
+ token === 33574984 /* LetKeyword */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */);
+ }
+ /**
+ * Returns true if this is end of case or default clauses
+ *
+ * @param parser Parser object
+ */
+ function isEndOfCaseOrDefaultClauses(parser) {
+ return (parser.token === 12368 /* DefaultKeyword */ || parser.token === 17825807 /* RightBrace */ || parser.token === 12363 /* CaseKeyword */);
+ }
+ /**
+ * Validates if the next token in the stream is a left paren or a period
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsLeftParenOrPeriod(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */ || parser.token === 16777229 /* Period */;
+ }
+ /**
+ * Validates if the next token in the stream is a identifier or left paren
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenisIdentifierOrParen(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return token & (131072 /* IsIdentifier */ | 1073741824 /* IsYield */) || token === 50331659 /* LeftParen */;
+ }
+ /**
+ * Validates if the next token in the stream is left parenthesis.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsLeftParen(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */;
+ }
+ /**
+ * Validates if the next token in the stream is a function keyword on the same line.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsFuncKeywordOnSameLine(parser, context) {
+ nextToken(parser, context);
+ return !(parser.flags & Flags.NewLine) && parser.token === 33566808 /* FunctionKeyword */;
+ }
+ /**
+ * Checks if the property has any private field key
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isPropertyWithPrivateFieldKey(expr) {
+ return !expr.property ? false : expr.property.type === 'PrivateName';
+ }
+ /**
+ * Parse and classify itendifier - similar method as in V8
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAndClassifyIdentifier(parser, context) {
+ const { token, tokenValue: name } = parser;
+ if (context & Context.Strict) {
+ if (context & Context.Module && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (token & 69632 /* Contextual */) === 69632 /* Contextual */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (context & Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ function nameIsArgumentsOrEval(value) {
+ return value === 'eval' || value === 'arguments';
+ }
+ /**
+ * Records an error from current position. If we report an error later, we'll do it from
+ * this position.
+ *
+ * @param parser Parser object
+ */
+ function setPendingError(parser) {
+ parser.errorLocation = {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+ }
+ /**
+ * Returns tagName for JSX element
+ *
+ * @param elementName JSX Element name
+ */
+ function isEqualTagNames(elementName) {
+ // tslint:disable-next-line:switch-default | this switch is exhaustive
+ switch (elementName.type) {
+ case 'JSXIdentifier':
+ return elementName.name;
+ case 'JSXNamespacedName':
+ return `${isEqualTagNames(elementName.namespace)}:${isEqualTagNames(elementName.name)}`;
+ case 'JSXMemberExpression':
+ return `${isEqualTagNames(elementName.object)}.${isEqualTagNames(elementName.property)}`;
+ }
+ }
+ /**
+ * Returns true if this is an instance field ( stage 3 proposal)
+ *
+ * @param parser Parser object
+ */
+ function isInstanceField(parser) {
+ const { token } = parser;
+ return token === 17825807 /* RightBrace */ || token === 17825809 /* Semicolon */ || token === 83886109 /* Assign */;
+ }
+ /**
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expr AST expressions
+ * @param prefix prefix
+ */
+ function validateUpdateExpression(parser, context, expr, prefix) {
+ if (context & Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 68 /* StrictLHSPrefixPostFix */, prefix);
+ }
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+ }
+ /**
+ * Record expression error
+ *
+ * @param parser Parser object
+ * @param error Error message
+ */
+ function setPendingExpressionError(parser, type) {
+ parser.pendingExpressionError = {
+ error: errorMessages[type],
+ line: parser.line,
+ column: parser.column,
+ index: parser.index
+ };
+ }
+ /**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+ function validateCoverParenthesizedExpression(parser, state) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= CoverParenthesizedState.HasEvalOrArguments;
+ }
+ else if ((token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ setPendingError(parser);
+ state |= CoverParenthesizedState.HasReservedWords;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ }
+ return state;
+ }
+ /**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+ function validateAsyncArgumentList(parser, context, state) {
+ const { token } = parser;
+ if (!(parser.flags & Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= CoverCallState.EvalOrArguments;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ state |= CoverCallState.Await;
+ }
+ else if ((token & 1073741824 /* IsYield */) === 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ state |= CoverCallState.Yield;
+ }
+ }
+ return state;
+ }
+ /**
+ * Returns true if iteration statement. Otherwise return false,
+ *
+ * @param t Token
+ */
+ function isIterationStatement(t) {
+ return t === 12369 /* DoKeyword */ || t === 12386 /* WhileKeyword */ || t === 12374 /* ForKeyword */;
+ }
+ /**
+ * Returns true if in or of token. Otherwise return false,
+ *
+ * @param t Token
+ */
+ function isInOrOf(t) {
+ return t === 69746 /* OfKeyword */ || t === 167786289 /* InKeyword */;
+ } + + /*@internal*/
+ const errorMessages = exports('errorMessages', {
+ [0 /* Unexpected */]: 'Unexpected token',
+ [1 /* UnexpectedToken */]: 'Unexpected token \'%0\'',
+ [2 /* ExpectedToken */]: 'Expected token \'%0\'',
+ [3 /* InvalidEscapedReservedWord */]: 'Keyword must not contain escaped characters',
+ [4 /* UnexpectedKeyword */]: 'Keyword \'%0\' is reserved',
+ [5 /* InvalidLHSInAssignment */]: 'Invalid left-hand side in assignment',
+ [6 /* UnterminatedString */]: 'Unterminated string literal',
+ [7 /* UnterminatedRegExp */]: 'Unterminated regular expression literal',
+ [8 /* UnterminatedComment */]: 'Unterminated MultiLineComment',
+ [9 /* UnterminatedTemplate */]: 'Unterminated template literal',
+ [10 /* UnexpectedChar */]: 'Invalid character \'%0\'',
+ [11 /* StrictOctalEscape */]: 'Octal escapes are not allowed in strict mode',
+ [13 /* InvalidEightAndNine */]: 'Escapes \\8 or \\9 are not syntactically valid escapes',
+ [14 /* UnicodeOutOfRange */]: 'Unicode escape code point out of range',
+ [15 /* DuplicateRegExpFlag */]: 'Duplicate regular expression flag \'%0\'',
+ [16 /* UnexpectedTokenRegExpFlag */]: 'Unexpected regular expression flag \'%0\'',
+ [17 /* StrictLHSAssignment */]: 'Eval or arguments can\'t be assigned to in strict mode code',
+ [18 /* IllegalReturn */]: 'Illegal return statement',
+ [19 /* StrictFunction */]: 'In strict mode code, functions can only be declared at top level or inside a block',
+ [20 /* SloppyFunction */]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+ [21 /* ForbiddenAsStatement */]: '%0 can\'t appear in single-statement context',
+ [22 /* GeneratorInSingleStatementContext */]: 'Generators can only be declared at the top level or inside a block',
+ [23 /* ForAwaitNotOf */]: '\'for await\' loop should be used with \'of\'',
+ [24 /* DeclarationMissingInitializer */]: 'Missing initializer in %0 declaration',
+ [25 /* ForInOfLoopInitializer */]: '\'for-%0\' loop variable declaration may not have an initializer',
+ [26 /* ForInOfLoopMultiBindings */]: 'Invalid left-hand side in for-%0 loop: Must have a single binding.',
+ [27 /* LetInLexicalBinding */]: 'let is disallowed as a lexically bound name',
+ [28 /* UnexpectedLexicalDeclaration */]: 'Lexical declaration cannot appear in a single-statement context',
+ [29 /* LabelRedeclaration */]: 'Label \'%0\' has already been declared',
+ [30 /* InvalidNestedStatement */]: '%0 statement must be nested within an iteration statement',
+ [31 /* IllegalContinue */]: 'Illegal continue statement: \'%0\' does not denote an iteration statement',
+ [32 /* UnknownLabel */]: 'Undefined label \'%0\'',
+ [33 /* MultipleDefaultsInSwitch */]: 'More than one default clause in switch statement',
+ [34 /* ImportExportDeclAtTopLevel */]: '%0 declarations may only appear at top level of a module',
+ [35 /* AsyncFunctionInSingleStatementContext */]: 'Async functions can only be declared at the top level or inside a block',
+ [36 /* InvalidLineBreak */]: 'No line break is allowed after \'%0\'',
+ [37 /* StrictModeWith */]: 'Strict mode code may not include a with statement',
+ [38 /* AwaitOutsideAsync */]: 'Await is only valid in async functions',
+ [39 /* UnNamedFunctionDecl */]: 'Function declaration must have a name in this context',
+ [12 /* DuplicateConstructor */]: 'Duplicate constructor method in class',
+ [40 /* DisallowedInContext */]: '\'%0\' may not be used as an identifier in this context',
+ [43 /* StrictDelete */]: 'Delete of an unqualified identifier in strict mode',
+ [44 /* DeletePrivateField */]: 'Private fields can not be deleted',
+ [41 /* PrivateFieldConstructor */]: 'Classes may not have a private field named \'#constructor\'',
+ [42 /* PublicFieldConstructor */]: 'Classes may not have a field named \'constructor\'',
+ [45 /* InvalidConstructor */]: 'Class constructor may not be a \'%0\'',
+ [46 /* UnexpectedReserved */]: 'Unexpected reserved word',
+ [47 /* StrictEvalArguments */]: 'Unexpected eval or arguments in strict mode',
+ [48 /* AwaitBindingIdentifier */]: '\'await\' is not a valid identifier inside an async function',
+ [49 /* YieldBindingIdentifier */]: '\'yield\' is not a valid identifier inside an generator function',
+ [50 /* UnexpectedStrictReserved */]: 'Unexpected strict mode reserved word',
+ [52 /* AwaitInParameter */]: 'Await expression not allowed in formal parameter',
+ [51 /* YieldInParameter */]: 'Yield expression not allowed in formal parameter',
+ [53 /* MetaNotInFunctionBody */]: 'new.target only allowed within functions',
+ [54 /* BadSuperCall */]: 'super() is not allowed in this context',
+ [55 /* UnexpectedSuper */]: 'Member access from super not allowed in this context',
+ [56 /* LoneSuper */]: 'Only "(" or "." or "[" are allowed after \'super\'',
+ [57 /* YieldReservedKeyword */]: '\'yield\' is a reserved keyword within generator function bodies',
+ [58 /* ContinuousNumericSeparator */]: 'Only one underscore is allowed as numeric separator',
+ [59 /* TrailingNumericSeparator */]: 'Numeric separators are not allowed at the end of numeric literals',
+ [60 /* ZeroDigitNumericSeparator */]: 'Numeric separator can not be used after leading 0.',
+ [61 /* StrictOctalLiteral */]: 'Legacy octal literals are not allowed in strict mode',
+ [62 /* InvalidLhsInAssignment */]: 'Invalid left-hand side in assignment',
+ [63 /* DuplicateProto */]: 'Property name __proto__ appears more than once in object literal',
+ [64 /* IllegalUseStrict */]: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ [65 /* StaticPrototype */]: 'Classes may not have a static property named \'prototype\'',
+ [66 /* AccessorWrongArgs */]: '%0 functions must have %1 argument%2',
+ [67 /* BadSetterRestParameter */]: 'Setter function argument must not be a rest parameter',
+ [68 /* StrictLHSPrefixPostFix */]: '%0 increment/decrement may not have eval or arguments operand in strict mode',
+ [69 /* InvalidElisonInObjPropList */]: 'Elision not allowed in object property list',
+ [70 /* ElementAfterRest */]: 'Rest element must be last element',
+ [72 /* ElementAfterSpread */]: 'Spread element must be last element',
+ [71 /* RestDefaultInitializer */]: 'Rest parameter may not have a default initializer',
+ [73 /* InvalidDestructuringTarget */]: 'Invalid destructuring assignment target',
+ [74 /* UnexpectedSurrogate */]: 'Unexpected surrogate pair',
+ [75 /* MalformedEscape */]: 'Malformed %0 character escape sequence',
+ [76 /* TemplateOctalLiteral */]: 'Template literals may not contain octal escape sequences',
+ [77 /* NotBindable */]: 'Invalid binding pattern',
+ [78 /* ParamAfterRest */]: 'Rest parameter must be last formal parameter',
+ [79 /* NoCatchOrFinally */]: 'Missing catch or finally after try',
+ [80 /* NewlineAfterThrow */]: 'Illegal newline after throw',
+ [81 /* ParamDupe */]: 'Duplicate parameter name not allowed in this context',
+ [82 /* AsAfterImportStart */]: 'Missing keyword \'as\' after import *',
+ [83 /* LabelNoColon */]: 'Labels must be followed by a \':\'',
+ [84 /* NonEmptyJSXExpression */]: 'JSX attributes must only be assigned a non-empty \'expression\'',
+ [85 /* ExpectedJSXClosingTag */]: 'Expected corresponding JSX closing tag for %0',
+ [86 /* AdjacentJSXElements */]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+ [87 /* InvalidJSXAttributeValue */]: 'Invalid JSX attribute value',
+ [88 /* RestWithComma */]: 'Rest element may not have a trailing comma',
+ [89 /* UndefinedUnicodeCodePoint */]: 'Undefined Unicode code-point',
+ [90 /* HtmlCommentInModule */]: 'HTML comments are not allowed in modules',
+ [91 /* InvalidCoverInitializedName */]: 'Invalid shorthand property initializer',
+ [92 /* TrailingDecorators */]: 'Trailing decorator may be followed by method',
+ [93 /* GeneratorConstructor */]: 'Decorators can\'t be used with a constructor',
+ [94 /* InvalidRestBindingPattern */]: '`...` must be followed by an identifier in declaration contexts',
+ });
+ /**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param index The 0-based end index of the error.
+ * @param line The 0-based line position of the error.
+ * @param column The 0-based column position of the error.
+ * @param parser The 0-based end index of the current node.
+ * @param description Error description
+ */
+ /*@internal*/
+ function constructError(parser, context, index, line, column, description) {
+ const error = new SyntaxError(`Line ${line}, column ${column}: ${description}`);
+ error.index = index;
+ error.line = line;
+ error.column = column;
+ error.description = description;
+ if (context & Context.OptionsTolerant) {
+ parser.errors.push(error);
+ }
+ else
+ throw error;
+ }
+ /**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ */
+ function getErrorLocation(parser) {
+ let { index, startLine: line, startColumn: column } = parser;
+ const errorLoc = parser.errorLocation;
+ if (!!errorLoc) {
+ index = errorLoc.index;
+ line = errorLoc.line;
+ column = errorLoc.column;
+ }
+ return { index, line, column };
+ }
+ /**
+ * Throws an error
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+ /*@internal*/
+ function report(parser, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, Context.Empty, index, line, column, errorMessage);
+ }
+ /**
+ * If in tolerant mode, all errors are pushed to a top-level error array containing
+ * otherwise throws
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+ /*@internal*/
+ function tolerant(parser, context, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, context, index, line, column, errorMessage);
+ } + + // Declarations
+ /**
+ * Parses class declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const id = (context & Context.RequireIdentifier && (parser.token !== 33685505 /* Identifier */))
+ ? null :
+ parseBindingIdentifier(parser, context | Context.Strict | Context.DisallowEscapedKeyword);
+ let state = ObjectState.None;
+ let superClass = null;
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | Context.Strict, pos);
+ state |= ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context & ~Context.RequireIdentifier | Context.Strict | Context.InClass, state);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body
+ });
+ }
+ /**
+ * Parses function declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ let isGenerator = ModifierState.None;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ if (context & Context.AllowSingleStatement && !(context & Context.InFunctionBody)) {
+ tolerant(parser, context, 22 /* GeneratorInSingleStatementContext */);
+ }
+ isGenerator = ModifierState.Generator;
+ }
+ return parseFunctionDeclarationBody(parser, context, isGenerator, pos);
+ }
+ /**
+ * Parses out a function declartion body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context mask
+ * @param state Modifier state
+ * @param pos Current location
+ */
+ function parseFunctionDeclarationBody(parser, context, state, pos) {
+ const { token } = parser;
+ let id = null;
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (context & Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (token !== 50331659 /* LeftParen */) {
+ id = parseBindingIdentifier(parser, context);
+ // Unnamed functions are forbidden in statement context.
+ }
+ else if (!(context & Context.RequireIdentifier))
+ tolerant(parser, context, 39 /* UnNamedFunctionDecl */);
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty | Context.RequireIdentifier), state, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionDeclaration',
+ params,
+ body,
+ async: !!(state & ModifierState.Await),
+ generator: !!(state & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parses async function or async generator declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isAwait = ModifierState.Await;
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ return parseFunctionDeclarationBody(parser, context, isGenerator | isAwait, pos);
+ }
+ /**
+ * VariableDeclaration :
+ * BindingIdentifier Initializeropt
+ * BindingPattern Initializer
+ *
+ * VariableDeclarationNoIn :
+ * BindingIdentifier InitializerNoInopt
+ * BindingPattern InitializerNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableDeclaration(parser, context, isConst) {
+ const pos = getLocation(parser);
+ const isBindingPattern = (parser.token & 8388608 /* IsBindingPattern */) !== 0;
+ const id = parseBindingIdentifierOrPattern(parser, context);
+ let init = null;
+ if (consume(parser, context | Context.DisallowEscapedKeyword, 83886109 /* Assign */)) {
+ init = parseExpressionCoverGrammar(parser, context & ~(Context.BlockScope | Context.ForStatement), parseAssignmentExpression);
+ if (isInOrOf(parser.token) && (context & Context.ForStatement || isBindingPattern)) {
+ if (parser.token === 167786289 /* InKeyword */) {
+ // https://github.com/tc39/test262/blob/master/test/annexB/language/statements/for-in/strict-initializer.js
+ if (context & (Context.BlockScope | Context.Strict | Context.Async) || isBindingPattern) {
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ }
+ else
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ // Note: Initializers are required for 'const' and binding patterns
+ }
+ else if (!isInOrOf(parser.token) && (isConst || isBindingPattern)) {
+ tolerant(parser, context, 24 /* DeclarationMissingInitializer */, isConst ? 'const' : 'destructuring');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclarator',
+ init,
+ id,
+ });
+ }
+ /**
+ * Parses variable declaration list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclarationList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableDeclarationList(parser, context, isConst) {
+ const list = [parseVariableDeclaration(parser, context, isConst)];
+ while (consume(parser, context, 16777234 /* Comma */))
+ list.push(parseVariableDeclaration(parser, context, isConst));
+ if (context & Context.ForStatement && isInOrOf(parser.token) && list.length !== 1) {
+ tolerant(parser, context, 26 /* ForInOfLoopMultiBindings */, tokenDesc(parser.token));
+ }
+ return list;
+ } + + // Statements
+ /**
+ * Parses statement list items
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementListItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseStatementListItem(parser, context) {
+ switch (parser.token) {
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionDeclaration(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassDeclaration(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetOrExpressionStatement(parser, context | Context.AllowIn);
+ case 33566793 /* ConstKeyword */:
+ return parseVariableStatement(parser, context | Context.BlockScope | Context.AllowIn);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionDeclarationOrStatement(parser, context);
+ case 33566810 /* ImportKeyword */: {
+ if (context & Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod)) {
+ return parseExpressionStatement(parser, context | Context.AllowIn);
+ }
+ }
+ case 12371 /* ExportKeyword */:
+ if (context & Context.Module) {
+ tolerant(parser, context, 34 /* ImportExportDeclAtTopLevel */, tokenDesc(parser.token));
+ }
+ default:
+ return parseStatement(parser, context | Context.AllowSingleStatement);
+ }
+ }
+ /**
+ * Parses statements
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseStatement(parser, context) {
+ switch (parser.token) {
+ case 33566791 /* VarKeyword */:
+ return parseVariableStatement(parser, context | Context.AllowIn);
+ case 17825809 /* Semicolon */:
+ return parseEmptyStatement(parser, context);
+ case 33566814 /* SwitchKeyword */:
+ return parseSwitchStatement(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseBlockStatement(parser, context);
+ case 12380 /* ReturnKeyword */:
+ return parseReturnStatement(parser, context);
+ case 12377 /* IfKeyword */:
+ return parseIfStatement(parser, context);
+ case 12369 /* DoKeyword */:
+ return parseDoWhileStatement(parser, context);
+ case 12386 /* WhileKeyword */:
+ return parseWhileStatement(parser, context);
+ case 12387 /* WithKeyword */:
+ return parseWithStatement(parser, context);
+ case 12362 /* BreakKeyword */:
+ return parseBreakStatement(parser, context);
+ case 12366 /* ContinueKeyword */:
+ return parseContinueStatement(parser, context);
+ case 12367 /* DebuggerKeyword */:
+ return parseDebuggerStatement(parser, context);
+ case 302002272 /* ThrowKeyword */:
+ return parseThrowStatement(parser, context);
+ case 12385 /* TryKeyword */:
+ return parseTryStatement(parser, context | Context.DisallowEscapedKeyword);
+ case 12374 /* ForKeyword */:
+ return parseForStatement(parser, context | Context.ForStatement);
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ tolerant(parser, context, 35 /* AsyncFunctionInSingleStatementContext */);
+ }
+ return parseExpressionOrLabelledStatement(parser, context | Context.AllowSingleStatement);
+ case 33566808 /* FunctionKeyword */:
+ // V8
+ tolerant(parser, context, context & Context.Strict ? 19 /* StrictFunction */ : 20 /* SloppyFunction */);
+ case 33566797 /* ClassKeyword */:
+ tolerant(parser, context, 21 /* ForbiddenAsStatement */, tokenDesc(parser.token));
+ default:
+ return parseExpressionOrLabelledStatement(parser, context);
+ }
+ }
+ /**
+ * Parses empty statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-EmptyStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseEmptyStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'EmptyStatement'
+ });
+ }
+ /**
+ * Parses the continue statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ContinueStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseContinueStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ // Appearing of continue without an IterationStatement leads to syntax error
+ if (!(parser.flags & (Flags.InSwitchStatement | Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, tokenDesc(parser.token));
+ }
+ let label = null;
+ if (!(parser.flags & Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, true);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ContinueStatement',
+ label
+ });
+ }
+ /**
+ * Parses the break statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BreakStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBreakStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let label = null;
+ if (!(parser.flags & Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, false);
+ }
+ else if (!(parser.flags & (Flags.InSwitchStatement | Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, 'break');
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'BreakStatement',
+ label
+ });
+ }
+ /**
+ * Parses the if statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-if-statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIfStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const consequent = parseConsequentOrAlternate(parser, context | Context.DisallowEscapedKeyword);
+ const alternate = consume(parser, context, 12370 /* ElseKeyword */) ? parseConsequentOrAlternate(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'IfStatement',
+ test,
+ consequent,
+ alternate
+ });
+ }
+ /**
+ * Parse either consequent or alternate. Supports AnnexB.
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseConsequentOrAlternate(parser, context) {
+ return context & Context.Strict || parser.token !== 33566808 /* FunctionKeyword */
+ ? parseStatement(parser, context & ~Context.AllowSingleStatement)
+ : parseFunctionDeclaration(parser, context);
+ }
+ /**
+ * Parses the debugger statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DebuggerStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDebuggerStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'DebuggerStatement'
+ });
+ }
+ /**
+ * Parses try statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TryStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseTryStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const block = parseBlockStatement(parser, context);
+ const handler = parser.token === 12364 /* CatchKeyword */ ? parseCatchBlock(parser, context) : null;
+ const finalizer = consume(parser, context, 12373 /* FinallyKeyword */) ? parseBlockStatement(parser, context) : null;
+ if (!handler && !finalizer)
+ tolerant(parser, context, 79 /* NoCatchOrFinally */);
+ return finishNode(context, parser, pos, {
+ type: 'TryStatement',
+ block,
+ handler,
+ finalizer
+ });
+ }
+ /**
+ * Parses catch block
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Catch)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCatchBlock(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let param = null;
+ if (consume(parser, context, 50331659 /* LeftParen */)) {
+ const params = [];
+ param = parseBindingIdentifierOrPattern(parser, context, params);
+ validateParams(parser, context, params);
+ expect(parser, context, 16 /* RightParen */);
+ }
+ const body = parseBlockStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'CatchClause',
+ param,
+ body
+ });
+ }
+ /**
+ * Parses throw statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ThrowStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseThrowStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 80 /* NewlineAfterThrow */);
+ const argument = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ThrowStatement',
+ argument
+ });
+ }
+ /**
+ * Parses expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExpressionStatement(parser, context) {
+ const pos = getLocation(parser);
+ const expr = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+ }
+ /**
+ * Parse directive node
+ *
+ * * @see [Link](https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDirective(parser, context) {
+ const pos = getLocation(parser);
+ const directive = parser.tokenRaw.slice(1, -1);
+ const expr = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr,
+ directive
+ });
+ }
+ /**
+ * Parses either expression or labelled statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LabelledStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExpressionOrLabelledStatement(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, token } = parser;
+ const expr = parseExpression(parser, (context & ~(Context.AllowSingleStatement | Context.AllowDecorator)) | Context.AllowIn);
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */) && parser.token === 16777237 /* Colon */) {
+ // If within generator function bodies, we do it like this so we can throw an nice error message
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 57 /* YieldReservedKeyword */);
+ expect(parser, context, 16777237 /* Colon */, 83 /* LabelNoColon */);
+ if (hasLabel(parser, tokenValue))
+ tolerant(parser, context, 29 /* LabelRedeclaration */, tokenValue);
+ addLabel(parser, tokenValue);
+ const body = !(context & Context.Strict) &&
+ context & Context.AllowSingleStatement &&
+ parser.token === 33566808 /* FunctionKeyword */
+ ? parseFunctionDeclaration(parser, context)
+ : parseStatement(parser, context);
+ popLabel(parser, tokenValue);
+ return finishNode(context, parser, pos, {
+ type: 'LabeledStatement',
+ label: expr,
+ body
+ });
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+ }
+ /**
+ * Parses do while statement
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDoWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const body = parseIterationStatement(parser, context);
+ expect(parser, context, 12386 /* WhileKeyword */);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ consume(parser, context, 17825809 /* Semicolon */);
+ return finishNode(context, parser, pos, {
+ type: 'DoWhileStatement',
+ body,
+ test
+ });
+ }
+ /**
+ * Parses while statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-WhileStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'WhileStatement',
+ test,
+ body
+ });
+ }
+ /**
+ * Parses block statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BlockStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Block)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBlockStatement(parser, context) {
+ const pos = getLocation(parser);
+ const body = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body
+ });
+ }
+ /**
+ * Parses return statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ReturnStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseReturnStatement(parser, context) {
+ const pos = getLocation(parser);
+ if (!(context & (Context.OptionsGlobalReturn | Context.InFunctionBody))) {
+ tolerant(parser, context, 18 /* IllegalReturn */);
+ }
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const argument = !(parser.token & 1048576 /* ASI */) && !(parser.flags & Flags.NewLine)
+ ? parseExpression(parser, (context & ~(Context.InFunctionBody | Context.AllowDecorator)) | Context.AllowIn)
+ : null;
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ReturnStatement',
+ argument
+ });
+ }
+ /**
+ * Sets the necessary mutable parser flags. The parser flags will
+ * be unset after done parsing out the statements.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-IterationStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIterationStatement(parser, context) {
+ // Note: We are deviating from the original grammar here beauce the original grammar says that the
+ // 'iterationStatement' should return either'for', 'do' or 'while' statements. We are doing some
+ // bitfiddling before and after to modify the parser state before we let the 'parseStatement'
+ // return the mentioned statements (to match the original grammar).
+ const savedFlags = parser.flags;
+ parser.flags |= Flags.InIterationStatement | Flags.AllowDestructuring;
+ const body = parseStatement(parser, (context & ~Context.AllowSingleStatement) | Context.DisallowEscapedKeyword);
+ parser.flags = savedFlags;
+ return body;
+ }
+ /**
+ * Parses with statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-WithStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseWithStatement(parser, context) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 37 /* StrictModeWith */);
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const object = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseStatement(parser, context & ~Context.AllowSingleStatement);
+ return finishNode(context, parser, pos, {
+ type: 'WithStatement',
+ object,
+ body
+ });
+ }
+ /**
+ * Parses switch statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SwitchStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSwitchStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const discriminant = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ expect(parser, context | Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const cases = [];
+ const savedFlags = parser.flags;
+ parser.flags |= Flags.InSwitchStatement;
+ let seenDefault = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ const clause = parseCaseOrDefaultClauses(parser, context);
+ cases.push(clause);
+ if (clause.test === null) {
+ if (seenDefault)
+ tolerant(parser, context, 33 /* MultipleDefaultsInSwitch */);
+ seenDefault = true;
+ }
+ }
+ parser.flags = savedFlags;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'SwitchStatement',
+ discriminant,
+ cases
+ });
+ }
+ /**
+ * Parses either default clause or case clauses
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CaseClauses)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DefaultClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCaseOrDefaultClauses(parser, context) {
+ const pos = getLocation(parser);
+ let test = null;
+ if (consume(parser, context, 12363 /* CaseKeyword */)) {
+ test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ }
+ else {
+ expect(parser, context, 12368 /* DefaultKeyword */);
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ const consequent = [];
+ while (!isEndOfCaseOrDefaultClauses(parser)) {
+ consequent.push(parseStatementListItem(parser, context | Context.AllowIn));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'SwitchCase',
+ test,
+ consequent
+ });
+ }
+ /**
+ * Parses variable statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableStatement(parser, context, shouldConsume = true) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const isConst = token === 33566793 /* ConstKeyword */;
+ nextToken(parser, context);
+ const declarations = parseVariableDeclarationList(parser, context, isConst);
+ // Only consume semicolons if not inside the 'ForStatement' production
+ if (shouldConsume)
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclaration',
+ kind: tokenDesc(token),
+ declarations
+ });
+ }
+ /**
+ * Parses either an lexical declaration (let) or an expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-let-and-const-declarations)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseLetOrExpressionStatement(parser, context, shouldConsume = true) {
+ return lookahead(parser, context, isLexical)
+ ? parseVariableStatement(parser, context | Context.BlockScope, shouldConsume)
+ : parseExpressionOrLabelledStatement(parser, context);
+ }
+ /**
+ * Parses either async function declaration or statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionDeclarationOrStatement(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)
+ ? parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context)
+ : parseStatement(parser, context);
+ }
+ /**
+ * Parses either For, ForIn or ForOf statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-statement)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseForStatement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 12374 /* ForKeyword */);
+ const awaitToken = !!(context & Context.Async && consume(parser, context, 34017389 /* AwaitKeyword */));
+ expect(parser, context | Context.DisallowEscapedKeyword, 50331659 /* LeftParen */);
+ const { token } = parser;
+ let init = null;
+ let sequencePos = null;
+ let variableStatement = null;
+ let type = 'ForStatement';
+ let test = null;
+ let update = null;
+ let right;
+ if (token === 33566793 /* ConstKeyword */ || (token === 33574984 /* LetKeyword */ && lookahead(parser, context, isLexical))) {
+ variableStatement = parseVariableStatement(parser, (context & ~Context.AllowIn) | Context.BlockScope, false);
+ }
+ else if (token === 33566791 /* VarKeyword */) {
+ variableStatement = parseVariableStatement(parser, context & ~Context.AllowIn, false);
+ }
+ else if (token !== 17825809 /* Semicolon */) {
+ sequencePos = getLocation(parser);
+ init = restoreExpressionCoverGrammar(parser, (context & ~Context.AllowIn) | Context.DisallowEscapedKeyword, parseAssignmentExpression);
+ }
+ if (consume(parser, context, 69746 /* OfKeyword */)) {
+ type = 'ForOfStatement';
+ if (init) {
+ if (!(parser.flags & Flags.AllowDestructuring) || init.type === 'AssignmentExpression') {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ right = parseAssignmentExpression(parser, context | Context.AllowIn);
+ }
+ else if (consume(parser, context, 167786289 /* InKeyword */)) {
+ if (init) {
+ if (!(parser.flags & Flags.AllowDestructuring))
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ type = 'ForInStatement';
+ right = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ }
+ else {
+ if (parser.token === 16777234 /* Comma */)
+ init = parseSequenceExpression(parser, context, init, sequencePos);
+ if (variableStatement)
+ init = variableStatement;
+ expect(parser, context, 17825809 /* Semicolon */);
+ test = parser.token !== 17825809 /* Semicolon */
+ ? parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn)
+ : null;
+ expect(parser, context, 17825809 /* Semicolon */);
+ update = parser.token !== 16 /* RightParen */
+ ? parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn)
+ : null;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, type === 'ForOfStatement'
+ ? {
+ type,
+ body,
+ left: init,
+ right,
+ await: awaitToken
+ }
+ : right
+ ? {
+ type: type,
+ body,
+ left: init,
+ right
+ }
+ : {
+ type: type,
+ body,
+ init,
+ test,
+ update
+ });
+ } + + // 15.2 Modules
+ /**
+ * Parse module item list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItemList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleItemList(parser, context) {
+ // Prime the scanner
+ nextToken(parser, context);
+ const statements = [];
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ statements.push(parser.token === 33554435 /* StringLiteral */ ?
+ parseDirective(parser, context) :
+ parseModuleItem(parser, context | Context.AllowIn));
+ }
+ return statements;
+ }
+ /**
+ * Parse module item
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleItem(parser, context) {
+ switch (parser.token) {
+ // @decorator
+ case 120 /* At */:
+ return parseDecorators(parser, context);
+ // ExportDeclaration
+ case 12371 /* ExportKeyword */:
+ return parseExportDeclaration(parser, context);
+ // ImportDeclaration
+ case 33566810 /* ImportKeyword */:
+ // 'Dynamic Import' or meta property disallowed here
+ if (!(context & Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod))) {
+ return parseImportDeclaration(parser, context);
+ }
+ // falls through
+ default:
+ return parseStatementListItem(parser, context);
+ }
+ }
+ /**
+ * Parse export declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ const specifiers = [];
+ let source = null;
+ let declaration = null;
+ expect(parser, context | Context.DisallowEscapedKeyword, 12371 /* ExportKeyword */);
+ switch (parser.token) {
+ // export * FromClause ;
+ case 167774771 /* Multiply */:
+ return parseExportAllDeclaration(parser, context, pos);
+ case 12368 /* DefaultKeyword */:
+ return parseExportDefault(parser, context, pos);
+ case 41943052 /* LeftBrace */:
+ {
+ // export ExportClause FromClause ;
+ // export ExportClause ;
+ expect(parser, context, 41943052 /* LeftBrace */);
+ let hasReservedWord = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token !== 69743 /* GetKeyword */ && parser.token & 12288 /* Reserved */) {
+ hasReservedWord = true;
+ setPendingError(parser);
+ }
+ specifiers.push(parseNamedExportDeclaration(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context | Context.DisallowEscapedKeyword, 17825807 /* RightBrace */);
+ if (parser.token === 69745 /* FromKeyword */) {
+ source = parseModuleSpecifier(parser, context);
+ // The left hand side can't be a keyword where there is no
+ // 'from' keyword since it references a local binding.
+ }
+ else if (hasReservedWord)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ consumeSemicolon(parser, context);
+ break;
+ }
+ // export ClassDeclaration
+ case 33566797 /* ClassKeyword */:
+ declaration = (parseClassDeclaration(parser, context));
+ break;
+ // export LexicalDeclaration
+ case 33574984 /* LetKeyword */:
+ case 33566793 /* ConstKeyword */:
+ declaration = parseVariableStatement(parser, context | Context.BlockScope);
+ break;
+ // export VariableDeclaration
+ case 33566791 /* VarKeyword */:
+ declaration = parseVariableStatement(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ declaration = parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context);
+ break;
+ }
+ // Falls through
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportNamedDeclaration',
+ source,
+ specifiers,
+ declaration,
+ });
+ }
+ /**
+ * Parse export all declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExportAllDeclaration(parser, context, pos) {
+ expect(parser, context, 167774771 /* Multiply */);
+ const source = parseModuleSpecifier(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExportAllDeclaration',
+ source,
+ });
+ }
+ /**
+ * Parse named export declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNamedExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ // ExportSpecifier :
+ // IdentifierName
+ // IdentifierName as IdentifierName
+ const local = parseIdentifierName(parser, context | Context.DisallowEscapedKeyword, parser.token);
+ const exported = consume(parser, context, 167843947 /* AsKeyword */)
+ ? parseIdentifierName(parser, context, parser.token)
+ : local;
+ return finishNode(context, parser, pos, {
+ type: 'ExportSpecifier',
+ local,
+ exported,
+ });
+ }
+ /**
+ * Parse export default
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+ function parseExportDefault(parser, context, pos) {
+ expect(parser, context | Context.DisallowEscapedKeyword, 12368 /* DefaultKeyword */);
+ let declaration;
+ switch (parser.token) {
+ // export default HoistableDeclaration[Default]
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context | Context.RequireIdentifier);
+ break;
+ // export default ClassDeclaration[Default]
+ // export default @decl ClassDeclaration[Default]
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ declaration = parseClassDeclaration(parser, context & ~Context.AllowIn | Context.RequireIdentifier);
+ break;
+ // export default HoistableDeclaration[Default]
+ case 594028 /* AsyncKeyword */:
+ declaration = parseAsyncFunctionOrAssignmentExpression(parser, context | Context.RequireIdentifier);
+ break;
+ default:
+ // export default [lookahead ∉ {function, class}] AssignmentExpression[In] ;
+ declaration = parseAssignmentExpression(parser, context | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportDefaultDeclaration',
+ declaration,
+ });
+ }
+ /**
+ * Parse import declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566810 /* ImportKeyword */);
+ let source;
+ let specifiers = [];
+ // 'import' ModuleSpecifier ';'
+ if (parser.token === 33554435 /* StringLiteral */) {
+ source = parseLiteral(parser, context);
+ }
+ else {
+ specifiers = parseImportClause(parser, context | Context.DisallowEscapedKeyword);
+ source = parseModuleSpecifier(parser, context);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ImportDeclaration',
+ specifiers,
+ source,
+ });
+ }
+ /**
+ * Parse import clause
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportClause(parser, context) {
+ const specifiers = [];
+ switch (parser.token) {
+ // 'import' ModuleSpecifier ';'
+ case 33685505 /* Identifier */:
+ {
+ specifiers.push(parseImportDefaultSpecifier(parser, context));
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ switch (parser.token) {
+ // import a, * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ // import a, {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ default:
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ break;
+ }
+ // import {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ // import * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return specifiers;
+ }
+ /**
+ * Parse named imports
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NamedImports)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNamedImports(parser, context, specifiers) {
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ specifiers.push(parseImportSpecifier(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ }
+ /**
+ * Parse import specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportSpecifier(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const imported = parseIdentifierName(parser, context | Context.DisallowEscapedKeyword, token);
+ let local;
+ if (consume(parser, context, 167843947 /* AsKeyword */)) {
+ local = parseBindingIdentifier(parser, context);
+ }
+ else {
+ // An import name that is a keyword is a syntax error if it is not followed
+ // by the keyword 'as'.
+ if (hasBit(token, 12288 /* Reserved */))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ if (hasBit(token, 4194304 /* IsEvalOrArguments */))
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ local = imported;
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ImportSpecifier',
+ local,
+ imported,
+ });
+ }
+ /**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NameSpaceImport)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNameSpaceImport(parser, context, specifiers) {
+ // NameSpaceImport:
+ // * as ImportedBinding
+ const pos = getLocation(parser);
+ expect(parser, context, 167774771 /* Multiply */);
+ expect(parser, context, 167843947 /* AsKeyword */, 82 /* AsAfterImportStart */);
+ const local = parseBindingIdentifier(parser, context);
+ specifiers.push(finishNode(context, parser, pos, {
+ type: 'ImportNamespaceSpecifier',
+ local,
+ }));
+ }
+ /**
+ * Parse module specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleSpecifier(parser, context) {
+ // ModuleSpecifier :
+ // StringLiteral
+ expect(parser, context, 69745 /* FromKeyword */);
+ if (parser.token !== 33554435 /* StringLiteral */)
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseLiteral(parser, context);
+ }
+ /**
+ * Parse import default specifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportDefaultSpecifier(parser, context) {
+ return finishNode(context, parser, getLocation(parser), {
+ type: 'ImportDefaultSpecifier',
+ local: parseIdentifier(parser, context),
+ });
+ }
+ /**
+ * Parses either async function or assignment expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAssignmentExpression(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context | Context.RequireIdentifier) :
+ parseAssignmentExpression(parser, context | Context.AllowIn);
+ } + + /**
+ * Creates the parser object
+ *
+ * @param source The source coode to parser
+ * @param sourceFile Optional source file info to be attached in every node
+ */
+ function createParser(source, sourceFile) {
+ return {
+ // The source code to parse
+ source,
+ // Source length
+ length: source.length,
+ // Current position
+ index: 0,
+ // Current line
+ line: 1,
+ // Current column
+ column: 0,
+ // Start position before current token
+ startIndex: 0,
+ // Start position column before current token
+ startColumn: 0,
+ // Start position line before current token
+ startLine: 1,
+ // End position after parsing after current token
+ lastIndex: 0,
+ // End column position after current token
+ lastColumn: 0,
+ // End line position after current token
+ lastLine: 0,
+ // Pending cover grammar errors
+ pendingExpressionError: undefined,
+ // Mutable parser flags. Allows destructuring by default.
+ flags: Flags.AllowDestructuring,
+ // The tokens
+ token: 1048576 /* EndOfSource */,
+ // Misc
+ tokenRaw: '',
+ lastValue: 0,
+ comments: [],
+ sourceFile,
+ tokenRegExp: undefined,
+ tokenValue: undefined,
+ labelSet: undefined,
+ errorLocation: undefined,
+ errors: [],
+ };
+ }
+ /**
+ * Creating the parser
+ *
+ * @param source The source coode to parser
+ * @param options The parser options
+ * @param context Context masks
+ */
+ function parseSource(source, options, /*@internal*/ context) {
+ let sourceFile = '';
+ if (!!options) {
+ // The flag to enable module syntax support
+ if (options.module)
+ context |= Context.Module;
+ // The flag to enable stage 3 support (ESNext)
+ if (options.next)
+ context |= Context.OptionsNext;
+ // The flag to enable React JSX parsing
+ if (options.jsx)
+ context |= Context.OptionsJSX;
+ // The flag to enable start and end offsets to each node
+ if (options.ranges)
+ context |= Context.OptionsRanges;
+ // The flag to enable line/column location information to each node
+ if (options.loc)
+ context |= Context.OptionsLoc;
+ // The flag to attach raw property to each literal node
+ if (options.raw)
+ context |= Context.OptionsRaw;
+ // Attach raw property to each identifier node
+ if (options.rawIdentifier)
+ context |= Context.OptionsRawidentifiers;
+ // The flag to allow return in the global scope
+ if (options.globalReturn)
+ context |= Context.OptionsGlobalReturn;
+ // The flag to allow to skip shebang - '#'
+ if (options.skipShebang)
+ context |= Context.OptionsShebang;
+ // Enable tolerant mode
+ if (options.tolerant)
+ context |= Context.OptionsTolerant;
+ // Set to true to record the source file in every node's loc object when the loc option is set.
+ if (!!options.source)
+ sourceFile = options.source;
+ // Create a top-level comments array containing all comments
+ if (!!options.comments)
+ context |= Context.OptionsComments;
+ // The flag to enable implied strict mode
+ if (options.impliedStrict)
+ context |= Context.Strict;
+ // The flag to enable experimental features
+ if (options.experimental)
+ context |= Context.OptionsExperimental;
+ // The flag to set to bypass methods in Node
+ if (options.node)
+ context |= Context.OptionsNode;
+ // Accepts a callback function to be invoked for each syntax node (as the node is constructed)
+ }
+ const parser = createParser(source, sourceFile);
+ const body = context & Context.Module ?
+ parseModuleItemList(parser, context) :
+ parseStatementList(parser, context);
+ const node = {
+ type: 'Program',
+ sourceType: context & Context.Module ? 'module' : 'script',
+ body: body,
+ };
+ if (context & Context.LocationTracker) {
+ if (context & Context.OptionsRanges) {
+ node.start = 0;
+ node.end = source.length;
+ }
+ if (context & Context.OptionsLoc) {
+ node.loc = {
+ start: { line: 1, column: 0 },
+ end: { line: parser.line, column: parser.column
+ }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ if (context & Context.OptionsComments)
+ node.comments = parser.comments;
+ if (context & Context.OptionsTolerant)
+ node.errors = parser.errors;
+ return node;
+ }
+ /**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function parseStatementList(parser, context) {
+ const statements = [];
+ let hasProlog = true; // Parsing directive prologue.
+ // prime the scanner
+ nextToken(parser, context | Context.DisallowEscapedKeyword);
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ if (hasProlog && parser.token !== 33554435 /* StringLiteral */)
+ hasProlog = false;
+ if (hasProlog) {
+ if (!(context & Context.Strict) && parser.tokenRaw.length === 12 && parser.tokenValue === 'use strict') {
+ context |= Context.Strict;
+ }
+ statements.push(parseDirective(parser, context));
+ }
+ else {
+ statements.push(parseStatementListItem(parser, context));
+ }
+ }
+ return statements;
+ }
+ /**
+ * Parse either script code or module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parse(source, options) {
+ return options && options.module
+ ? parseModule(source, options)
+ : parseScript(source, options);
+ }
+ /**
+ * Parse script code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parseScript(source, options) {
+ return parseSource(source, options, Context.Empty);
+ }
+ /**
+ * Parse module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parseModule(source, options) {
+ return parseSource(source, options, Context.Strict | Context.Module);
+ } + + + + var estree = /*#__PURE__*/Object.freeze({ + + }); + exports('ESTree', estree); + + + + var index = /*#__PURE__*/Object.freeze({ + scanIdentifier: scanIdentifier, + scanMaybeIdentifier: scanMaybeIdentifier, + scanHexIntegerLiteral: scanHexIntegerLiteral, + scanOctalOrBinary: scanOctalOrBinary, + scanImplicitOctalDigits: scanImplicitOctalDigits, + scanSignedInteger: scanSignedInteger, + scanNumericLiteral: scanNumericLiteral, + scanNumericSeparator: scanNumericSeparator, + scanDecimalDigitsOrSeparator: scanDecimalDigitsOrSeparator, + scanDecimalAsSmi: scanDecimalAsSmi, + scanRegularExpression: scanRegularExpression, + scan: scan, + scanEscapeSequence: scanEscapeSequence, + throwStringError: throwStringError, + scanString: scanString, + consumeTemplateBrace: consumeTemplateBrace, + scanTemplate: scanTemplate, + skipSingleHTMLComment: skipSingleHTMLComment, + skipSingleLineComment: skipSingleLineComment, + skipMultiLineComment: skipMultiLineComment, + addComment: addComment, + nextUnicodeChar: nextUnicodeChar, + isIdentifierPart: isIdentifierPart, + escapeInvalidCharacters: escapeInvalidCharacters, + consumeOpt: consumeOpt, + consumeLineFeed: consumeLineFeed, + scanPrivateName: scanPrivateName, + advanceNewline: advanceNewline, + fromCodePoint: fromCodePoint, + readNext: readNext, + toHex: toHex, + advanceOnMaybeAstral: advanceOnMaybeAstral + }); + exports('Scanner', index); + + + + var parser = /*#__PURE__*/Object.freeze({ + parseClassDeclaration: parseClassDeclaration, + parseFunctionDeclaration: parseFunctionDeclaration, + parseAsyncFunctionOrAsyncGeneratorDeclaration: parseAsyncFunctionOrAsyncGeneratorDeclaration, + parseVariableDeclarationList: parseVariableDeclarationList, + parseExpression: parseExpression, + parseSequenceExpression: parseSequenceExpression, + parseAssignmentExpression: parseAssignmentExpression, + parseRestElement: parseRestElement, + parseLeftHandSideExpression: parseLeftHandSideExpression, + parsePrimaryExpression: parsePrimaryExpression, + parseIdentifier: parseIdentifier, + parseLiteral: parseLiteral, + parseBigIntLiteral: parseBigIntLiteral, + parseIdentifierName: parseIdentifierName, + parseFunctionExpression: parseFunctionExpression, + parseAsyncFunctionOrAsyncGeneratorExpression: parseAsyncFunctionOrAsyncGeneratorExpression, + parsePropertyName: parsePropertyName, + parseObjectLiteral: parseObjectLiteral, + parseFormalListAndBody: parseFormalListAndBody, + parseFunctionBody: parseFunctionBody, + parseFormalParameters: parseFormalParameters, + parseFormalParameterList: parseFormalParameterList, + parseClassBodyAndElementList: parseClassBodyAndElementList, + parseClassElement: parseClassElement, + parseDecorators: parseDecorators, + parseModuleItemList: parseModuleItemList, + parseModuleItem: parseModuleItem, + parseExportDeclaration: parseExportDeclaration, + parseImportDeclaration: parseImportDeclaration, + createParser: createParser, + parseSource: parseSource, + parseStatementList: parseStatementList, + parse: parse, + parseScript: parseScript, + parseModule: parseModule, + parseBindingIdentifierOrPattern: parseBindingIdentifierOrPattern, + parseBindingIdentifier: parseBindingIdentifier, + parseAssignmentRestElement: parseAssignmentRestElement, + parseAssignmentPattern: parseAssignmentPattern, + parseBindingInitializer: parseBindingInitializer, + parseStatementListItem: parseStatementListItem, + parseStatement: parseStatement, + parseEmptyStatement: parseEmptyStatement, + parseContinueStatement: parseContinueStatement, + parseBreakStatement: parseBreakStatement, + parseIfStatement: parseIfStatement, + parseDebuggerStatement: parseDebuggerStatement, + parseTryStatement: parseTryStatement, + parseCatchBlock: parseCatchBlock, + parseThrowStatement: parseThrowStatement, + parseExpressionStatement: parseExpressionStatement, + parseDirective: parseDirective, + parseExpressionOrLabelledStatement: parseExpressionOrLabelledStatement, + parseDoWhileStatement: parseDoWhileStatement, + parseWhileStatement: parseWhileStatement, + parseBlockStatement: parseBlockStatement, + parseReturnStatement: parseReturnStatement, + parseIterationStatement: parseIterationStatement, + parseWithStatement: parseWithStatement, + parseSwitchStatement: parseSwitchStatement, + parseCaseOrDefaultClauses: parseCaseOrDefaultClauses, + parseVariableStatement: parseVariableStatement, + parseJSXRootElement: parseJSXRootElement, + parseJSXOpeningElement: parseJSXOpeningElement, + nextJSXToken: nextJSXToken, + scanJSXToken: scanJSXToken, + parseJSXText: parseJSXText, + parseJSXAttributes: parseJSXAttributes, + parseJSXSpreadAttribute: parseJSXSpreadAttribute, + parseJSXNamespacedName: parseJSXNamespacedName, + parseJSXAttributeName: parseJSXAttributeName, + parseJSXAttribute: parseJSXAttribute, + parseJSXEmptyExpression: parseJSXEmptyExpression, + parseJSXSpreadChild: parseJSXSpreadChild, + parseJSXExpressionContainer: parseJSXExpressionContainer, + parseJSXExpression: parseJSXExpression, + parseJSXClosingFragment: parseJSXClosingFragment, + parseJSXClosingElement: parseJSXClosingElement, + parseJSXIdentifier: parseJSXIdentifier, + parseJSXMemberExpression: parseJSXMemberExpression, + parseJSXElementName: parseJSXElementName, + scanJSXIdentifier: scanJSXIdentifier + }); + + // tslint:disable-next-line:variable-name
+ const Parser = exports('Parser', parser); + + const version = exports('version', '1.6.9'); + + } + }; +}); diff --git a/node_modules/cherow/dist/system/cherow.min.js b/node_modules/cherow/dist/system/cherow.min.js new file mode 100644 index 0000000..6afc797 --- /dev/null +++ b/node_modules/cherow/dist/system/cherow.min.js @@ -0,0 +1 @@ +System.register("cherow",[],function(e,t){"use strict";return{execute:function(){e({parse:zn,parseSource:jn,parseModule:_n,parseScript:Wn,constructError:rn,report:an,tolerant:sn,tokenDesc:n,descKeyword:o,isValidIdentifierPart:s,isValidIdentifierStart:i,mustEscape:c,Context:void 0,Flags:void 0,Labels:void 0,NumericState:void 0,ScannerState:void 0,ModifierState:void 0,CoverParenthesizedState:void 0,Escape:void 0,RegexFlags:void 0,CoverCallState:void 0,RegexState:void 0,ObjectState:void 0,validateBreakOrContinueLabel:yt,addLabel:ht,popLabel:At,hasLabel:Et,finishNode:It,expect:bt,consume:vt,nextToken:Ct,consumeSemicolon:Nt,parseExpressionCoverGrammar:Lt,restoreExpressionCoverGrammar:Dt,swapContext:Rt,validateParams:Pt,lookahead:Ft,isValidSimpleAssignmentTarget:Bt,getLocation:Vt,isValidIdentifier:Mt,isLexical:Jt,isEndOfCaseOrDefaultClauses:Tt,nextTokenIsLeftParenOrPeriod:Xt,nextTokenisIdentifierOrParen:Gt,nextTokenIsLeftParen:Kt,nextTokenIsFuncKeywordOnSameLine:Yt,isPropertyWithPrivateFieldKey:qt,parseAndClassifyIdentifier:Ut,nameIsArgumentsOrEval:jt,setPendingError:$t,isEqualTagNames:zt,isInstanceField:Wt,validateUpdateExpression:_t,setPendingExpressionError:Qt,validateCoverParenthesizedExpression:Zt,validateAsyncArgumentList:en,isInOrOf:tn});const t=["end of source","identifier","number","string","regular expression","false","true","null","template continuation","template end","=>","(","{",".","...","}",")",";",",","[","]",":","?","'",'"',"</","/>","++","--","=","<<=",">>=",">>>=","**=","+=","-=","*=","/=","%=","^=","|=","&=","typeof","delete","void","!","~","+","-","in","instanceof","*","%","/","**","&&","||","===","!==","==","!=","<=",">=","<",">","<<",">>",">>>","&","|","^","var","let","const","break","case","catch","class","continue","debugger","default","do","else","export","extends","finally","for","function","if","import","new","return","super","switch","this","throw","try","while","with","implements","interface","package","private","protected","public","static","yield","as","async","await","constructor","get","set","from","of","#","eval","arguments","enum","BigInt","@","JSXText","KeyOf","ReadOnly","is","unique","declare","type","namespace","abstract","module","global","require","target"];function n(e){return t[255&e]}const r=Object.create(null,{this:{value:33566815},function:{value:33566808},if:{value:12377},return:{value:12380},var:{value:33566791},else:{value:12370},for:{value:12374},new:{value:33566811},in:{value:167786289},typeof:{value:302002218},while:{value:12386},case:{value:12363},break:{value:12362},try:{value:12385},catch:{value:12364},delete:{value:302002219},throw:{value:302002272},switch:{value:33566814},continue:{value:12366},default:{value:12368},instanceof:{value:167786290},do:{value:12369},void:{value:302002220},finally:{value:12373},arguments:{value:37879925},keyof:{value:131194},readonly:{value:131195},unique:{value:131197},declare:{value:131198},async:{value:594028},await:{value:34017389},class:{value:33566797},const:{value:33566793},constructor:{value:69742},debugger:{value:12367},enum:{value:12406},eval:{value:37879924},export:{value:12371},extends:{value:12372},false:{value:33566725},from:{value:69745},get:{value:69743},implements:{value:20579},import:{value:33566810},interface:{value:20580},let:{value:33574984},null:{value:33566727},of:{value:69746},package:{value:20581},private:{value:20582},protected:{value:20583},public:{value:20584},set:{value:69744},static:{value:20585},super:{value:33566813},true:{value:33566726},with:{value:12387},yield:{value:1107316842},is:{value:131196},type:{value:131199},namespace:{value:131200},abstract:{value:131201},as:{value:167843947},module:{value:131202},global:{value:131203},require:{value:131204},target:{value:131205}});function o(e){return 0|r[e]}const a=e("characterType",[0,0,0,0,0,0,0,0,0,16,48,16,16,48,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,9,9,9,9,9,9,9,9,9,9,0,0,0,0,0,0,0,7,7,7,7,7,7,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,3,0,7,7,7,7,7,7,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,0,0,0,0,0]);function s(e){return 0!=(1&l[0+(e>>>5)]>>>e)}function i(e){return 0!=(1&l[34816+(e>>>5)]>>>e)}function c(e){return 0!=(1&l[69632+(e>>>5)]>>>e)}const l=((e,t)=>{const n=new Uint32Array(104448);let r=0,o=0;for(;r<3392;){const a=e[r++];if(a<0)o-=a;else{let s=e[r++];2&a&&(s=t[s]),1&a?n.fill(s,o,o+=e[r++]):n[o++]=s}}return n})([-1,2,28,2,29,2,5,-1,0,77595648,3,46,2,3,0,14,2,57,2,58,3,0,3,0,3168796671,0,4294956992,2,1,2,0,2,59,3,0,4,0,4294966523,3,0,4,2,15,2,60,2,0,0,4294836735,0,3221225471,0,4294901942,2,61,0,134152192,3,0,2,0,4294951935,3,0,2,0,2683305983,0,2684354047,2,17,2,0,0,4294961151,3,0,2,2,20,2,0,0,608174079,2,0,2,127,2,6,2,62,-1,2,64,2,26,2,1,3,0,3,0,4294901711,2,40,0,4089839103,0,2961209759,0,1342439375,0,4294543342,0,3547201023,0,1577204103,0,4194240,0,4294688750,2,2,0,80831,0,4261478351,0,4294549486,2,2,0,2965387679,0,196559,0,3594373100,0,3288319768,0,8469959,2,171,0,4294828031,0,3825204735,0,123747807,0,65487,2,3,0,4092591615,0,1080049119,0,458703,2,3,2,0,0,2163244511,0,4227923919,0,4236247020,2,68,0,4284449919,0,851904,2,4,2,16,0,67076095,-1,2,69,0,1006628014,0,4093591391,-1,0,50331649,0,3265266687,2,34,0,4294844415,0,4278190047,2,23,2,125,-1,3,0,2,2,33,2,0,2,9,2,0,2,13,2,14,3,0,10,2,71,2,0,2,72,2,73,2,74,2,0,2,75,2,0,2,10,0,261632,2,19,3,0,2,2,11,2,4,3,0,18,2,76,2,5,3,0,2,2,77,0,2088959,2,31,2,8,0,909311,3,0,2,0,814743551,2,42,0,67057664,3,0,2,2,45,2,0,2,32,2,0,2,18,2,7,0,268374015,2,30,2,51,2,0,2,78,0,134153215,-1,2,6,2,0,2,7,0,2684354559,0,67044351,0,1073676416,-2,3,0,2,2,43,0,1046528,3,0,3,2,8,2,0,2,41,0,4294960127,2,9,2,39,2,10,0,4294377472,2,21,3,0,7,0,4227858431,3,0,8,2,11,2,0,2,80,2,9,2,0,2,81,2,82,2,83,-1,2,122,0,1048577,2,84,2,12,-1,2,12,0,131042,2,85,2,86,2,87,2,0,2,35,-83,2,0,2,53,2,7,3,0,4,0,1046559,2,0,2,13,2,0,0,2147516671,2,24,3,88,2,2,0,-16,2,89,0,524222462,2,4,2,0,0,4269801471,2,4,2,0,2,14,2,79,2,15,3,0,2,2,49,2,16,-1,2,17,-16,3,0,205,2,18,-2,3,0,655,2,19,3,0,36,2,70,-1,2,17,2,9,3,0,8,2,91,2,119,2,0,0,3220242431,3,0,3,2,20,2,22,2,92,3,0,2,2,93,2,21,-1,2,22,2,0,2,27,2,0,2,8,3,0,2,0,67043391,0,3909091327,2,0,2,25,2,8,2,23,3,0,2,0,67076097,2,7,2,0,2,24,0,67059711,0,4236247039,3,0,2,0,939524103,0,8191999,2,97,2,98,2,14,2,95,3,0,3,0,67057663,3,0,349,2,99,2,100,2,6,-264,3,0,11,2,25,3,0,2,2,21,-1,0,3774349439,2,101,2,102,3,0,2,2,20,2,26,3,0,10,2,9,2,17,2,0,2,47,2,0,2,27,2,103,2,19,0,1638399,2,169,2,104,3,0,3,2,23,2,28,2,29,2,5,2,30,2,0,2,7,2,105,-1,2,106,2,107,2,108,-1,3,0,3,2,16,-2,2,0,2,31,-3,2,146,-4,2,23,2,0,2,37,0,1,2,0,2,63,2,32,2,16,2,9,2,0,2,109,-1,3,0,4,2,9,2,33,2,110,2,6,2,0,2,111,2,0,2,50,-4,3,0,9,2,24,2,18,2,27,-4,2,112,2,113,2,18,2,24,2,7,-2,2,114,2,18,2,21,-2,2,0,2,115,-2,0,4277137519,0,2269118463,-1,3,23,2,-1,2,34,2,38,2,0,3,18,2,2,36,2,20,-3,3,0,2,2,35,-1,2,0,2,36,2,0,2,36,2,0,2,48,-14,2,23,2,44,2,37,-5,3,0,2,2,38,0,2147549120,2,0,2,16,2,17,2,130,2,0,2,52,0,4294901872,0,5242879,3,0,2,0,402595359,-1,2,118,0,1090519039,-2,2,120,2,39,2,0,2,55,2,40,0,4226678271,0,3766565279,0,2039759,-4,3,0,2,0,1140787199,-1,3,0,2,0,67043519,-5,2,0,0,4282384383,0,1056964609,-1,3,0,2,0,67043345,-1,2,0,2,41,2,42,-1,2,10,2,43,-6,2,0,2,16,-3,3,0,2,0,2147484671,-8,2,0,2,7,2,44,2,0,0,603979727,-1,2,0,2,45,-8,2,54,2,46,0,67043329,2,123,2,47,0,8388351,-2,2,124,0,3028287487,2,48,2,126,0,33259519,2,42,-9,2,24,-8,3,0,28,2,21,-3,3,0,3,2,49,3,0,6,2,50,-85,3,0,33,2,49,-126,3,0,18,2,38,-269,3,0,17,2,45,2,7,2,42,-2,2,17,2,51,2,0,2,24,0,67043343,2,128,2,19,-21,3,0,2,-4,3,0,2,0,4294901791,2,7,2,164,-2,0,3,3,0,191,2,20,3,0,23,2,36,-296,3,0,8,2,7,-2,2,17,3,0,11,2,6,-72,3,0,3,2,129,0,1677656575,-166,0,4161266656,0,4071,0,15360,-4,0,28,-13,3,0,2,2,52,2,0,2,131,2,132,2,56,2,0,2,133,2,134,2,135,3,0,10,2,136,2,137,2,14,3,52,2,3,53,2,3,54,2,0,4294954999,2,0,-16,2,0,2,90,2,0,0,2105343,0,4160749584,0,65534,-42,0,4194303871,0,2011,-62,3,0,6,0,8323103,-1,3,0,2,2,55,-37,2,56,2,140,2,141,2,142,2,143,2,144,-138,3,0,1334,2,24,-1,3,0,129,2,31,3,0,6,2,9,3,0,180,2,145,3,0,233,0,1,-96,3,0,16,2,9,-22583,3,0,7,2,19,-6130,3,5,2,-1,0,69207040,3,46,2,3,0,14,2,57,2,58,-3,0,3168731136,0,4294956864,2,1,2,0,2,59,3,0,4,0,4294966275,3,0,4,2,15,2,60,2,0,2,35,-1,2,17,2,61,-1,2,0,2,62,0,4294885376,3,0,2,0,3145727,0,2617294944,0,4294770688,2,19,2,63,3,0,2,0,131135,2,94,0,70256639,0,71303167,0,272,2,45,2,62,-1,2,64,-2,2,96,0,603979775,0,4278255616,0,4294836227,0,4294549473,0,600178175,0,2952806400,0,268632067,0,4294543328,0,57540095,0,1577058304,0,1835008,0,4294688736,2,65,2,66,0,33554435,2,121,2,65,2,147,0,131075,0,3594373096,0,67094296,2,66,-1,2,67,0,603979263,2,156,0,3,0,4294828001,0,602930687,2,180,0,393219,2,67,0,671088639,0,2154840064,0,4227858435,0,4236247008,2,68,2,38,-1,2,4,0,917503,2,38,-1,2,69,0,537783470,0,4026531935,-1,0,1,-1,2,34,2,70,0,7936,-3,2,0,0,2147485695,0,1010761728,0,4292984930,0,16387,2,0,2,13,2,14,3,0,10,2,71,2,0,2,72,2,73,2,74,2,0,2,75,2,0,2,16,-1,2,19,3,0,2,2,11,2,4,3,0,18,2,76,2,5,3,0,2,2,77,0,253951,3,20,2,0,122879,2,0,2,8,0,276824064,-2,3,0,2,2,45,2,0,0,4294903295,2,0,2,18,2,7,-1,2,17,2,51,2,0,2,78,2,42,-1,2,24,2,0,2,31,-2,0,128,-2,2,79,2,8,0,4064,-1,2,117,0,4227907585,2,0,2,116,2,0,2,50,2,196,2,9,2,39,2,10,-1,0,6544896,3,0,6,-2,3,0,8,2,11,2,0,2,80,2,9,2,0,2,81,2,82,2,83,-3,2,84,2,12,-3,2,85,2,86,2,87,2,0,2,35,-83,2,0,2,53,2,7,3,0,4,0,817183,2,0,2,13,2,0,0,33023,2,24,3,88,2,-17,2,89,0,524157950,2,4,2,0,2,90,2,4,2,0,2,14,2,79,2,15,3,0,2,2,49,2,16,-1,2,17,-16,3,0,205,2,18,-2,3,0,655,2,19,3,0,36,2,70,-1,2,17,2,9,3,0,8,2,91,0,3072,2,0,0,2147516415,2,9,3,0,2,2,19,2,22,2,92,3,0,2,2,93,2,21,-1,2,22,0,4294965179,0,7,2,0,2,8,2,92,2,8,-1,0,1761345536,2,94,2,95,2,38,2,23,2,96,2,36,2,162,0,2080440287,2,0,2,35,2,138,0,3296722943,2,0,0,1046675455,0,939524101,0,1837055,2,97,2,98,2,14,2,95,3,0,3,0,7,3,0,349,2,99,2,100,2,6,-264,3,0,11,2,25,3,0,2,2,21,-1,0,2700607615,2,101,2,102,3,0,2,2,20,2,26,3,0,10,2,9,2,17,2,0,2,47,2,0,2,27,2,103,-3,2,104,3,0,3,2,23,-1,3,5,2,2,30,2,0,2,7,2,105,-1,2,106,2,107,2,108,-1,3,0,3,2,16,-2,2,0,2,31,-8,2,23,2,0,2,37,-1,2,0,2,63,2,32,2,18,2,9,2,0,2,109,-1,3,0,4,2,9,2,17,2,110,2,6,2,0,2,111,2,0,2,50,-4,3,0,9,2,24,2,18,2,27,-4,2,112,2,113,2,18,2,24,2,7,-2,2,114,2,18,2,21,-2,2,0,2,115,-2,0,4277075969,2,18,-1,3,23,2,-1,2,34,2,139,2,0,3,18,2,2,36,2,20,-3,3,0,2,2,35,-1,2,0,2,36,2,0,2,36,2,0,2,50,-14,2,23,2,44,2,116,-5,2,117,2,41,-2,2,117,2,19,2,17,2,35,2,117,2,38,0,4294901776,0,4718591,2,117,2,36,0,335544350,-1,2,118,2,119,-2,2,120,2,39,2,7,-1,2,121,2,65,0,3758161920,0,3,-4,2,0,2,31,2,174,-1,2,0,2,19,0,176,-5,2,0,2,49,2,182,-1,2,0,2,19,2,194,-1,2,0,2,62,-2,2,16,-7,2,0,2,119,-3,3,0,2,2,122,-8,0,4294965249,0,67633151,0,4026597376,2,0,0,536871887,-1,2,0,2,45,-8,2,54,2,49,0,1,2,123,2,19,-3,2,124,2,37,2,125,2,126,0,16778239,-10,2,36,-8,3,0,28,2,21,-3,3,0,3,2,49,3,0,6,2,50,-85,3,0,33,2,49,-126,3,0,18,2,38,-269,3,0,17,2,45,2,7,-3,2,17,2,127,2,0,2,19,2,50,2,128,2,19,-21,3,0,2,-4,3,0,2,0,65567,-1,2,26,-2,0,3,3,0,191,2,20,3,0,23,2,36,-296,3,0,8,2,7,-2,2,17,3,0,11,2,6,-72,3,0,3,2,129,2,130,-187,3,0,2,2,52,2,0,2,131,2,132,2,56,2,0,2,133,2,134,2,135,3,0,10,2,136,2,137,2,14,3,52,2,3,53,2,3,54,2,2,138,-129,3,0,6,2,139,-1,3,0,2,2,50,-37,2,56,2,140,2,141,2,142,2,143,2,144,-138,3,0,1334,2,24,-1,3,0,129,2,31,3,0,6,2,9,3,0,180,2,145,3,0,233,0,1,-96,3,0,16,2,9,-28719,2,0,0,1,-1,2,122,2,0,0,8193,-21,0,50331648,0,10255,0,4,-11,2,66,2,168,-1,0,71680,-1,2,157,0,4292900864,0,805306431,-5,2,146,-1,2,176,-1,0,6144,-2,2,123,-1,2,150,-1,2,153,2,147,2,161,2,0,0,3223322624,2,36,0,4,-4,2,188,0,205128192,0,1333757536,0,2147483696,0,423953,0,747766272,0,2717763192,0,4286578751,0,278545,2,148,0,4294886464,0,33292336,0,417809,2,148,0,1329579616,0,4278190128,0,700594195,0,1006647527,0,4286497336,0,4160749631,2,149,0,469762560,0,4171219488,0,16711728,2,149,0,202375680,0,3214918176,0,4294508592,0,139280,-1,0,983584,2,190,0,58720275,0,3489923072,0,10517376,0,4293066815,0,1,0,2013265920,2,175,2,0,0,17816169,0,3288339281,0,201375904,2,0,-2,0,256,0,122880,0,16777216,2,146,0,4160757760,2,0,-6,2,163,-11,0,3263218176,-1,0,49664,0,2160197632,0,8388802,-1,0,12713984,-1,2,150,2,155,2,158,-2,2,159,-20,0,3758096385,-2,2,151,0,4292878336,2,22,2,166,0,4294057984,-2,2,160,2,152,2,172,-2,2,151,-1,2,179,-1,2,167,2,122,0,4026593280,0,14,0,4292919296,-1,2,154,0,939588608,-1,0,805306368,-1,2,122,0,1610612736,2,152,2,153,3,0,2,-2,2,154,2,155,-3,0,267386880,-1,2,156,0,7168,-1,0,65024,2,150,2,157,2,158,-7,2,165,-8,2,159,-1,0,1426112704,2,160,-1,2,185,0,271581216,0,2149777408,2,19,2,157,2,122,0,851967,0,3758129152,-1,2,19,2,178,-4,2,154,-20,2,192,2,161,-56,0,3145728,2,184,-1,2,191,2,122,-1,2,162,2,122,-4,0,32505856,-1,2,163,-1,0,2147385088,2,22,1,2155905152,2,-3,2,164,2,0,2,165,-2,2,166,-6,2,167,0,4026597375,0,1,-1,0,1,-1,2,168,-3,2,139,2,66,-2,2,162,2,177,-1,2,173,2,122,-6,2,122,-213,2,167,-657,2,17,-36,2,169,-1,2,186,-10,0,4294963200,-5,2,170,-5,2,158,2,0,2,24,-1,0,4227919872,-1,2,170,-2,0,4227874752,-3,0,2146435072,2,155,-2,0,1006649344,2,122,-1,2,22,0,201375744,-3,0,134217720,2,22,0,4286677377,0,32896,-1,2,171,-3,2,172,-349,2,173,2,174,2,175,3,0,264,-11,2,176,-2,2,158,2,0,0,520617856,0,2692743168,0,36,-3,0,524284,-11,2,19,-1,2,183,-1,2,181,0,3221291007,2,158,-1,0,524288,0,2158720,-3,2,155,0,1,-4,2,122,0,3808625411,0,3489628288,0,4096,0,1207959680,0,3221274624,2,0,-3,2,177,0,120,0,7340032,-2,0,4026564608,2,4,2,19,2,160,3,0,4,2,155,-1,2,178,2,175,-1,0,8176,2,179,2,177,2,180,-1,0,4290773232,2,0,-4,2,160,2,187,0,15728640,2,175,-1,2,157,-1,0,4294934512,3,0,4,-9,2,22,2,167,2,181,3,0,4,0,704,0,1849688064,0,4194304,-1,2,122,0,4294901887,2,0,0,130547712,0,1879048192,0,2080374784,3,0,2,-1,2,182,2,183,-1,0,17829776,0,2025848832,0,4261477888,-2,2,0,-1,0,4286580608,-1,0,29360128,2,184,0,16252928,0,3791388672,2,39,3,0,2,-2,2,193,2,0,-1,2,26,-1,0,66584576,-1,2,189,3,0,9,2,122,3,0,4,-1,2,157,2,158,3,0,5,-2,0,245760,0,2147418112,-1,2,146,2,199,0,4227923456,-1,2,185,2,186,2,22,-2,2,176,0,4292870145,0,262144,2,122,3,0,2,0,1073758848,2,187,-1,0,4227921920,2,188,0,68289024,0,528402016,0,4292927536,3,0,4,-2,0,2483027968,2,0,-2,2,189,3,0,5,-1,2,184,2,160,2,0,-2,0,4227923936,2,63,-1,2,170,2,94,2,0,2,150,2,154,3,0,6,-1,2,175,3,0,3,-2,0,2146959360,3,0,8,-2,2,157,-1,2,190,2,117,-1,2,151,3,0,8,2,191,0,8388608,2,171,2,169,2,183,0,4286578944,3,0,2,0,1152,0,1266679808,2,189,0,576,0,4261707776,2,94,3,0,9,2,151,3,0,8,-28,2,158,3,0,3,-3,0,4292902912,-6,2,96,3,0,85,-33,2,164,3,0,126,-18,2,192,3,0,269,-17,2,151,2,122,0,4294917120,3,0,2,2,19,0,4290822144,-2,0,67174336,0,520093700,2,17,3,0,21,-2,2,177,3,0,3,-2,0,65504,2,122,2,49,3,0,2,2,92,-191,2,123,-23,2,26,3,0,296,-8,2,122,3,0,2,2,19,-11,2,175,3,0,72,-3,0,3758159872,0,201391616,3,0,155,-7,2,167,-1,0,384,-1,0,133693440,-3,2,193,-2,2,30,3,0,4,2,166,-2,2,22,2,151,3,0,4,-2,2,185,-1,2,146,0,335552923,2,194,-1,0,538974272,0,2214592512,0,132e3,-10,0,192,-8,0,12288,-21,0,134213632,0,4294901761,3,0,42,0,100663424,0,4294965284,3,0,62,-6,0,4286578784,2,0,-2,0,1006696448,3,0,24,2,37,-1,2,195,3,0,10,2,194,0,4110942569,0,1432950139,0,2701658217,0,4026532864,0,4026532881,2,0,2,47,3,0,8,-1,2,154,-2,2,166,0,98304,0,65537,2,167,2,169,-2,2,154,-1,2,63,2,0,2,116,2,197,2,175,0,4294770176,2,30,3,0,4,-30,2,195,2,196,-3,2,166,-2,2,151,2,0,2,154,-1,2,189,-1,2,157,2,198,3,0,2,2,154,2,122,-1,0,193331200,-1,0,4227923960,2,197,-1,3,0,3,2,198,3,0,44,-1334,2,22,2,0,-129,2,195,-6,2,160,-180,2,199,-233,2,4,3,0,96,-16,2,160,3,0,22583,-7,2,17,3,0,6128],[4294967295,4294967291,4092460543,4294828015,4294967294,134217726,268435455,2147483647,1048575,1073741823,3892314111,1061158911,536805376,4294910143,4160749567,4294901759,134217727,4294901760,4194303,65535,262143,67108863,4286578688,536870911,8388607,4294918143,4294443008,255,67043328,2281701374,4294967232,2097151,4294903807,4294902783,4294967039,511,524287,131071,127,4294902271,4294549487,16777215,1023,67047423,4294901888,33554431,4286578687,4294770687,67043583,32767,15,2047999,4292870143,4294934527,4294966783,67045375,4294967279,262083,20511,4290772991,41943039,493567,2047,4294959104,1071644671,602799615,65536,4294828e3,805044223,4277151126,8191,1031749119,4294917631,2134769663,4286578493,4282253311,4294942719,33540095,4294905855,4294967264,2868854591,1608515583,265232348,534519807,2147614720,1060109444,4093640016,17376,2139062143,224,4169138175,4294909951,4294967292,4294965759,4294966272,4294901823,4294967280,8289918,4294934399,4294901775,4294965375,1602223615,4294967259,268369920,4292804608,486341884,4294963199,3087007615,1073692671,4128527,4279238655,4294902015,4294966591,2445279231,3670015,3238002687,63,4294967288,4294705151,4095,3221208447,4294549472,2147483648,4294705152,4294966143,64,4294966719,16383,3774873592,536807423,67043839,3758096383,3959414372,3755993023,2080374783,4294835295,4294967103,4160749565,4087,31,184024726,2862017156,1593309078,268434431,268434414,4294901763,536870912,2952790016,202506752,139264,402653184,4261412864,4227922944,2147532800,61440,3758096384,117440512,65280,4227858432,3233808384,3221225472,4294965248,32768,57152,4294934528,67108864,4293918720,4290772992,25165824,57344,4278190080,65472,4227907584,65520,1920,4026531840,49152,4160749568,4294836224,63488,1073741824,4294967040,251658240,196608,12582912,2097152,65408,64512,417808,4227923712,48,512,4294967168,4294966784,16,4292870144,4227915776,65528,4294950912,65532]);function u(e){const{index:t}=e,n=e.source.charCodeAt(t);if(n<55296||n>56319)return n;const r=e.source.charCodeAt(t+1);return r<56320||r>57343?n:65536+((1023&n)<<10)|1023&r}const d=e=>0!=(1&a[e])||s(e);function p(e){switch(e){case 0:return"\\0";case 8:return"\\b";case 9:return"\\t";case 10:return"\\n";case 11:return"\\v";case 12:return"\\f";case 13:return"\\r";default:return c(e)?e<16?`\\x0${e.toString(16)}`:e<256?`\\x${e.toString(16)}`:e<4096?`\\u0${e.toString(16)}`:e<65536?`\\u${e.toString(16)}`:`\\u{${e.toString(16)}}`:k(e)}}function f(e,t){return e.source.charCodeAt(e.index)===t&&(e.index++,e.column++,!0)}function m(e,t){e.flags|=lt.NewLine,e.index++,0==(t&pt.LastIsCR)&&(e.column=0,e.line++)}function g(e,t){return t&ct.InClass&&i(e.source.charCodeAt(e.index))||an(e,1,n(e.token)),115}function x(e){e.flags|=lt.NewLine,e.index++,e.column=0,e.line++}const k=e=>e<=65535?String.fromCharCode(e):String.fromCharCode(55296+(e-65536>>10),56320+(e-65536&1023));function S(e){return e.index++,e.column++,e.index>=e.source.length&&an(e,14),u(e)}function w(e){return e<48?-1:e<=57?e-48:e<65?-1:e<=70?e-65+10:e<97?-1:e<=102?e-97+10:-1}function y(e,t){e.index++,e.column++,t>65535&&e.index++}function h(e,t,n){switch(n){case 98:return 8;case 102:return 12;case 114:return 13;case 110:return 10;case 116:return 9;case 118:return 11;case 13:case 10:case 8232:case 8233:return e.column=-1,e.line++,gt.Empty;case 48:case 49:case 50:case 51:{let r=n-48,o=e.index+1,a=e.column+1,s=e.source.charCodeAt(o);if(s<48||s>55){if(0!==r||56===s||57===s){if(t&ct.Strict)return gt.StrictOctal;e.flags|=lt.HasOctal}}else{if(t&ct.Strict)return gt.StrictOctal;e.flags|=lt.HasOctal,e.lastValue=s,r=8*r+(s-48),o++,a++,(s=e.source.charCodeAt(o))>=48&&s<=55&&(e.lastValue=s,r=8*r+(s-48),o++,a++),e.index=o-1,e.column=a-1}return r}case 52:case 53:case 54:case 55:{if(t&ct.Strict)return gt.StrictOctal;let r=n-48;const o=e.index+1,a=e.column+1,s=e.source.charCodeAt(o);return s>=48&&s<=55&&(r=8*r+(s-48),e.lastValue=s,e.index=o,e.column=a),r}case 56:case 57:return gt.EightOrNine;case 120:{const t=w(e.lastValue=S(e));if(t<0)return gt.InvalidHex;const n=w(e.lastValue=S(e));return n<0?gt.InvalidHex:t<<4|n}case 117:{let t=e.lastValue=S(e);if(123===t){let n=w(t=e.lastValue=S(e));if(n<0)return gt.InvalidHex;for(t=e.lastValue=S(e);125!==t;){const r=w(t);if(r<0)return gt.InvalidHex;if((n=16*n+r)>1114111)return gt.OutOfRange;t=e.lastValue=S(e)}return n}{let n=w(t);if(n<0)return gt.InvalidHex;for(let r=0;r<3;r++){const r=w(t=e.lastValue=S(e));if(r<0)return gt.InvalidHex;n=16*n+r}return n}}default:return e.source.charCodeAt(e.index)}}function A(e,t,n){switch(n){case gt.Empty:return;case gt.StrictOctal:an(e,t&ct.TaggedTemplate?76:11);case gt.EightOrNine:an(e,13);case gt.InvalidHex:an(e,75,"hexadecimal");case gt.OutOfRange:an(e,14)}}function E(e,t,n){const{index:r,lastValue:o}=e;let a="";e.index++,e.column++;let s=e.source.charCodeAt(e.index);for(;s!==n;){switch(s){case 13:case 10:an(e,6);case 92:if((s=S(e))>128)a+=k(s);else{e.lastValue=s;const n=h(e,t,s);n>=0?a+=k(n):A(e,t,n),s=e.lastValue}break;default:a+=k(s)}s=S(e)}return e.index++,e.column++,e.tokenRaw=e.source.slice(r,e.index),e.tokenValue=a,e.lastValue=o,33554435}function I(e,t){return e.index>=e.length&&an(e,9),e.index--,e.column--,b(e,t)}function b(e,t){const{index:n,lastValue:r}=e;let o=!0,a="",s=S(e);e:for(;96!==s;){switch(s){case 36:{const t=e.index+1;if(t<e.length&&123===e.source.charCodeAt(t)){e.index=t,e.column++,o=!1;break e}a+="$";break}case 92:if((s=S(e))>=128)a+=k(s);else{e.lastValue=s;const n=h(e,t|ct.Strict,s);if(n>=0)a+=k(n);else{if(n!==gt.Empty&&t&ct.TaggedTemplate){a=void 0,(s=v(e,e.lastValue))<0&&(o=!1);break e}A(e,t|ct.TaggedTemplate,n)}s=e.lastValue}break;case 13:case 10:case 8232:case 8233:e.column=-1,e.line++;default:null!=a&&(a+=k(s))}s=S(e)}return e.index++,e.column++,e.tokenValue=a,e.lastValue=r,o?(e.tokenRaw=e.source.slice(n+1,e.index-1),33554441):(e.tokenRaw=e.source.slice(n+1,e.index-2),33554440)}function v(e,t){for(;96!==t;){if(36===t&&123===e.source.charCodeAt(e.index+1))return e.index++,e.column++,-t;t=S(e)}return t}function C(e,t){e.index++,e.column++;let n=dt.None,r=w(e.source.charCodeAt(e.index));for(r<0&&an(e,0),e.index++,e.column++;e.index<e.length;){const o=e.source.charCodeAt(e.index);if(t&ct.OptionsNext&&95===o){n=R(e,n);continue}n&=~dt.SeenSeparator;const a=w(o);if(a<0)break;r=16*r+a,e.index++,e.column++}return n&dt.SeenSeparator&&an(e,59),F(e,t,r,f(e,110))}function O(e,t,n){e.index++,e.column++;let r,o=0,a=0,s=dt.None;for(;e.index<e.length;){if(r=e.source.charCodeAt(e.index),t&ct.OptionsNext&&95===r){s=R(e,s);continue}s&=~dt.SeenSeparator;const i=r-48;if(!(r>=48&&r<=57)||i>=n)break;a=a*n+i,e.index++,e.column++,o++}return 0===o&&an(e,0),s&dt.SeenSeparator&&an(e,59),F(e,t,a,f(e,110))}function N(e,t){switch(e.source.charCodeAt(e.index)){case 48:case 49:case 50:case 51:case 52:case 53:case 54:case 55:{t&ct.Strict&&an(e,0);let n=e.index,r=e.column,o=0;for(e.flags|=lt.HasOctal;n<e.length;){const a=e.source.charCodeAt(n);if(95===a)an(e,60);else{if(a<48||a>55)return D(e,t);o=8*o+(a-48),n++,r++}}return e.index=n,e.column=r,F(e,t,o,f(e,110))}case 56:case 57:e.flags|=lt.HasOctal;default:return t&ct.OptionsNext&&95===e.source.charCodeAt(e.index)&&an(e,60),D(e,t)}}function L(e,t){let n=e.source.charCodeAt(e.index);43!==n&&45!==n||(e.index++,e.column++,n=e.source.charCodeAt(e.index)),n>=48&&n<=57||an(e,0);const r=e.index,o=P(e);return e.source.substring(t,r)+o}function D(e,t,n=dt.None){let r=n&dt.Float?0:H(e,t);const o=e.source.charCodeAt(e.index);if(46!==o&&95!==o&&!i(o))return F(e,t,r);f(e,46)&&(t&ct.OptionsNext&&95===e.source.charCodeAt(e.index)&&an(e,60),n|=dt.Float,r=`${r}.${P(e)}`);const a=e.index;return f(e,110)&&(n&dt.Float&&an(e,0),n|=dt.BigInt),(f(e,101)||f(e,69))&&(n|=dt.Float,r+=L(e,a)),i(e.source.charCodeAt(e.index))&&an(e,0),F(e,t,n&dt.Float?parseFloat(r):parseInt(r,10),!!(n&dt.BigInt))}function R(e,t){return e.index++,e.column++,t&dt.SeenSeparator&&an(e,59),t|=dt.SeenSeparator}function P(e){let t=e.index,n=dt.None,r="";e:for(;e.index<e.length;)switch(e.source.charCodeAt(e.index)){case 95:const o=e.index;n=R(e,n),r+=e.source.substring(t,o),t=e.index;continue;case 48:case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:n&=~dt.SeenSeparator,e.index++,e.column++;break;default:break e}return n&dt.SeenSeparator&&an(e,59),r+e.source.substring(t,e.index)}function H(e,t){let n=dt.None,r=0,o=e.source.charCodeAt(e.index);for(;o>=48&&o<=57||95===o;)t&ct.OptionsNext&&95===o?(n=R(e,n),o=e.source.charCodeAt(e.index)):(n&=~dt.SeenSeparator,r=10*r+(o-48),e.index++,e.column++,o=e.source.charCodeAt(e.index));return n&dt.SeenSeparator&&an(e,59),r}function F(e,t,n,r=!1){return e.tokenValue=n,t&ct.OptionsRaw&&(e.tokenRaw=e.source.slice(e.startIndex,e.index)),r?33554551:33554434}function B(e,t,n){let r=e.index,a="",s=!1;n&&y(e,n);e:for(;e.index<e.length;){const t=e.index;let n=e.source.charCodeAt(t);switch(n){case 92:a+=e.source.slice(r,t),a+=M(e),r=e.index,s=!0;break;default:if(n>=55296&&n<=56319){n=(1023&n)<<10|1023&e.source.charCodeAt(t+1)|65536}if(!d(n))break e;y(e,n)}}r<e.index&&(a+=e.source.slice(r,e.index)),e.tokenValue=a;const i=a.length;if(i>=2&&i<=11){const n=o(a);if(n>0)return s&&(t&ct.DisallowEscapedKeyword&&sn(e,t,3),e.flags|=lt.EscapedKeyword),n}return t&ct.OptionsRawidentifiers&&(e.tokenRaw=e.source.slice(r,e.index)),33685505}function V(e,t,n){return i(n=u(e))||an(e,10,p(n)),B(e,t,n)}function M(e){const{index:t}=e;if(t+5<e.length){117!==e.source.charCodeAt(t+1)&&an(e,0),e.index+=2,e.column+=2;const n=function(e){let t=e.source.charCodeAt(e.index),n=0;if(123===t){let r=w(t=S(e));for(;r>=0;)(n=n<<4|r)>1114111&&an(e,89),e.index++,e.column++,r=w(e.source.charCodeAt(e.index));125!==e.source.charCodeAt(e.index)&&an(e,75,"unicode"),f(e,125)}else for(let r=0;r<4;r++){const r=w(t=e.source.charCodeAt(e.index));r<0&&an(e,75,"unicode"),n=n<<4|r,e.index++,e.column++}return n}(e);return n>=55296&&n<=56319&&an(e,74),d(n)||an(e,75,"unicode"),k(n)}an(e,0)}function J(e,t,n,r){return t&ct.Module&&an(e,90),T(e,t,n,r)}function T(e,t,n,r){const o=e.index,a=!!(t&ct.OptionsComments);for(;e.index<e.length;)switch(e.source.charCodeAt(e.index)){case 13:return x(e),e.index<e.length&&10===e.source.charCodeAt(e.index)&&e.index++,n|pt.NewLine;case 10:case 8232:case 8233:return x(e),a&&G(e,t,r,o),n|pt.NewLine;default:e.index++,e.column++}return a&&G(e,t,r,o),n}function X(e,t,n){const r=e.index,o=!!(t&ct.OptionsComments);for(;e.index<e.length;)switch(e.source.charCodeAt(e.index)){case 42:if(e.index++,e.column++,n&=~pt.LastIsCR,f(e,47))return o&&G(e,t,"MultiLine",r),n;break;case 13:n|=pt.NewLine|pt.LastIsCR,x(e);break;case 10:m(e,n),n=n&~pt.LastIsCR|pt.NewLine;break;case 8232:case 8233:n=n&~pt.LastIsCR|pt.NewLine,x(e);break;default:n&=~pt.LastIsCR,e.index++,e.column++}sn(e,t,8)}function G(e,t,n,r){const{index:o,startIndex:a,startLine:s,startColumn:i,lastLine:c,lastColumn:l}=e,u={type:n,value:e.source.slice(r,"MultiLine"===n?o-2:o),start:a,end:o};t&ct.OptionsLoc&&(u.loc={start:{line:s,column:i},end:{line:c,column:l}}),e.comments.push(u)}function K(e,t){e.flags&=~lt.NewLine|lt.EscapedKeyword;const n=0===e.index;let r=pt.None;for(;e.index<e.length;){n||(e.startIndex=e.index,e.startColumn=e.column,e.startLine=e.line);const o=e.source.charCodeAt(e.index);if(o>128)switch(o){case 8232:case 8233:r=r&~pt.LastIsCR|pt.NewLine,x(e);break;case 65519:case 160:case 5760:case 8192:case 8193:case 8194:case 8195:case 8196:case 8197:case 8198:case 8199:case 8200:case 8201:case 8202:case 8239:case 8287:case 12288:case 65279:case 8205:e.index++,e.column++;break;default:return V(e,t,o)}else switch(o){case 13:r|=pt.NewLine|pt.LastIsCR,x(e);break;case 10:m(e,r),r=r&~pt.LastIsCR|pt.NewLine;break;case 9:case 11:case 12:case 32:e.index++,e.column++;break;case 40:return e.index++,e.column++,50331659;case 41:return e.index++,e.column++,16;case 44:return e.index++,e.column++,16777234;case 58:return e.index++,e.column++,16777237;case 59:return e.index++,e.column++,17825809;case 63:return e.index++,e.column++,22;case 93:return e.index++,e.column++,20;case 123:return e.index++,e.column++,41943052;case 125:return e.index++,e.column++,17825807;case 126:return e.index++,e.column++,301989934;case 91:return e.index++,e.column++,41943059;case 64:return e.index++,e.column++,120;case 47:if(e.index++,e.column++,e.index>=e.length)return 167774773;switch(e.source.charCodeAt(e.index)){case 47:e.index++,e.column++,r=T(e,t,r,"SingleLine");continue;case 42:e.index++,e.column++,r=X(e,t,r);continue;case 61:return e.index++,e.column++,100663333;default:return 167774773}case 45:switch(e.index++,e.column++,e.source.charCodeAt(e.index)){case 45:if(e.index++,e.column++,(r&pt.NewLine||n)&&f(e,62)){r=J(e,t,r,"HTMLClose");continue}return 570425372;case 61:return e.index++,e.column++,67108899;default:return 436209968}case 60:if(e.index++,e.column++,f(e,33)&&f(e,45)&&f(e,45)){r=J(e,t,r,"HTMLOpen");continue}switch(e.source.charCodeAt(e.index)){case 60:return e.index++,e.column++,f(e,61)?67108894:167774273;case 61:return e.index++,e.column++,167774013;case 47:{if(!(t&ct.OptionsJSX))break;const n=e.index+1;if(n<e.length){const t=e.source.charCodeAt(n);if(42===t||47===t)break}return e.index++,e.column++,25}default:return 167774015}case 33:return e.index++,e.column++,f(e,61)?f(e,61)?167773754:167773756:301989933;case 39:case 34:return E(e,t,o);case 37:return e.index++,e.column++,f(e,61)?67108902:167774772;case 38:{e.index++,e.column++;const t=e.source.charCodeAt(e.index);return 38===t?(e.index++,e.column++,169869879):61===t?(e.index++,e.column++,67108905):167773508}case 42:{if(e.index++,e.column++,e.index>=e.length)return 167774771;const t=e.source.charCodeAt(e.index);return 61===t?(e.index++,e.column++,67108900):42!==t?167774771:(e.index++,e.column++,f(e,61)?67108897:167775030)}case 43:{if(e.index++,e.column++,e.index>=e.length)return 436209967;const t=e.source.charCodeAt(e.index);return 43===t?(e.index++,e.column++,570425371):61===t?(e.index++,e.column++,67108898):436209967}case 92:return B(e,t);case 61:{e.index++,e.column++;const t=e.source.charCodeAt(e.index);return 61===t?(e.index++,e.column++,f(e,61)?167773753:167773755):62===t?(e.index++,e.column++,10):83886109}case 62:{if(e.index++,e.column++,e.index>=e.length)return 167774016;if(t&ct.InJSXChild)return 167774016;let n=e.source.charCodeAt(e.index);return 61===n?(e.index++,e.column++,167774014):62!==n?167774016:(e.index++,e.column++,62===(n=e.source.charCodeAt(e.index))?(e.index++,e.column++,f(e,61)?67108896:167774275):61===n?(e.index++,e.column++,67108895):167774274)}case 94:return e.index++,e.column++,f(e,61)?67108903:167773254;case 96:return b(e,t);case 124:{e.index++,e.column++;const t=e.source.charCodeAt(e.index);return 124===t?(e.index++,e.column++,169869624):61===t?(e.index++,e.column++,67108904):167772997}case 46:{let n=e.index+1;const r=e.source.charCodeAt(n);return r>=48&&r<=57?(D(e,t,dt.Float),33554434):46===r&&++n<e.length&&46===e.source.charCodeAt(n)?(e.index=n+1,e.column+=3,14):(e.index++,e.column++,16777229)}case 35:{e.index++,e.column++;const r=e.index,o=e.source.charCodeAt(r);if(t&ct.OptionsShebang&&n&&33===o){e.index=r+1,T(e,t,pt.None,"SheBang");continue}return g(e,t)}case 48:switch(e.index++,e.column++,e.source.charCodeAt(e.index)){case 88:case 120:return C(e,t);case 66:case 98:return O(e,t,2);case 79:case 111:return O(e,t,8);default:return N(e,t)}case 49:case 50:case 51:case 52:case 53:case 54:case 55:case 56:case 57:return D(e,t);case 65:case 66:case 67:case 68:case 69:case 70:case 71:case 72:case 73:case 74:case 75:case 76:case 77:case 78:case 79:case 80:case 81:case 82:case 83:case 84:case 85:case 86:case 87:case 88:case 89:case 90:case 36:case 95:case 97:case 98:case 99:case 100:case 101:case 102:case 103:case 104:case 105:case 106:case 107:case 108:case 109:case 110:case 111:case 112:case 113:case 114:case 115:case 116:case 117:case 118:case 119:case 120:case 121:case 122:default:return B(e,t,o)}}return 1048576}function Y(e,t){const n=e.index;let r=St.Empty;e:for(;;){const t=e.source.charCodeAt(e.index);if(e.index++,e.column++,r&St.Escape)r&=~St.Escape;else switch(t){case 47:if(r)break;break e;case 92:r|=St.Escape;break;case 91:r|=St.Class;break;case 93:r&=St.Escape;break;case 13:case 10:case 8232:case 8233:an(e,7)}e.index>=e.source.length&&an(e,7)}const o=e.index-1;let a=xt.Empty;const{index:s}=e;e:for(;e.index<e.source.length;){const n=e.source.charCodeAt(e.index);switch(n){case 103:a&xt.Global&&sn(e,t,15,"g"),a|=xt.Global;break;case 105:a&xt.IgnoreCase&&sn(e,t,15,"i"),a|=xt.IgnoreCase;break;case 109:a&xt.Multiline&&sn(e,t,15,"m"),a|=xt.Multiline;break;case 117:a&xt.Unicode&&sn(e,t,15,"u"),a|=xt.Unicode;break;case 121:a&xt.Sticky&&sn(e,t,15,"y"),a|=xt.Sticky;break;case 115:a&xt.DotAll&&sn(e,t,15,"s"),a|=xt.DotAll;break;default:if(!d(n))break e;an(e,16,k(n))}e.index++,e.column++}const i=e.source.slice(s,e.index),c=e.source.slice(n,o);return e.tokenRegExp={pattern:c,flags:i},t&ct.OptionsRaw&&(e.tokenRaw=e.source.slice(e.startIndex,e.index)),e.tokenValue=function(e,t,n,r){ct.OptionsNode;try{return new RegExp(n,r)}catch(e){return null}}(0,0,c,i),33554436}function q(e,t,n=[]){const{token:r}=e;return 8388608&r?41943052===r?function(e,t){const n=Vt(e),r=[];bt(e,t,41943052);for(;17825807!==e.token;){if(14===e.token){r.push($(e,t));break}r.push(_(e,t)),17825807!==e.token&&bt(e,t,16777234)}return bt(e,t,17825807),It(t,e,n,{type:"ObjectPattern",properties:r})}(e,t):function(e,t,n){const r=Vt(e);Ct(e,t);const o=[];for(;20!==e.token;)if(vt(e,t,16777234))o.push(null);else{if(14===e.token){o.push(j(e,t,n));break}o.push(Lt(e,t|ct.AllowIn,W)),20!==e.token&&bt(e,t,16777234)}return bt(e,t,20),It(t,e,r,{type:"ArrayPattern",elements:o})}(e,t,n):(1074003968&r&&(262144&r&&t&(ct.Async|ct.Module)?sn(e,t,48):1073741824&r&&t&(ct.Yield|ct.Strict)&&sn(e,t,49)),n.push(e.tokenValue),U(e,t))}function U(e,t){const{token:r}=e;4194304&r?(t&ct.Strict&&sn(e,t,17),e.flags|=lt.StrictEvalArguments):t&ct.BlockScope&&33574984===r?sn(e,t,27):Ot(r,20480)?(t&ct.Strict&&sn(e,t,1,n(r)),e.flags|=lt.StrictFunctionName):Mt(t,r)||sn(e,t,1,n(r));const o=Vt(e),a=e.tokenValue;return Ct(e,t),It(t,e,o,{type:"Identifier",name:a})}function j(e,t,n){const r=Vt(e);bt(e,t,14);const o=q(e,t,n);return 16777234===e.token&&sn(e,t,88),It(t,e,r,{type:"RestElement",argument:o})}function $(e,t){const n=Vt(e);bt(e,t,14);const{token:r}=e,o=q(e,t);return Ot(r,8388608)&&sn(e,t,94),16777234===e.token&&sn(e,t,88),It(t,e,n,{type:"RestElement",argument:o})}function z(e,t,n,r){return It(t,e,r,{type:"AssignmentPattern",left:n,right:Lt(e,t|ct.AllowIn,Ee)})}function W(e,t){const n=Vt(e),r=q(e,t);return vt(e,t,83886109)?It(t,e,n,{type:"AssignmentPattern",left:r,right:Ee(e,t|ct.AllowIn)}):r}function _(e,t){const n=Vt(e),{token:r}=e;let o,a,s=!1,i=!1;if(135168&r)if(o=Re(e,t),i=!vt(e,t,16777237)){const s=vt(e,t,83886109);t&ct.Yield&&1073741824&r&&sn(e,t,49),Mt(t,r)||sn(e,t,46),a=s?z(e,t,o,n):o}else a=W(e,t);else s=41943059===r,o=Te(e,t),bt(e,t,16777237),a=Lt(e,t,W);return It(t,e,n,{type:"Property",kind:"init",key:o,computed:s,value:a,method:!1,shorthand:i})}function Q(e,t){const n=Vt(e);let r,o=[],a=null,s=!1;bt(e,t,167774015);const i=167774016===e.token;if(i)r=function(e,t,n){return ee(e),It(t,e,n,{type:"JSXOpeningFragment"})}(e,t,n);else{r=Z(e,t,we(e,t),ae(e,t),s=vt(e,t,167774773),n)}if(i)return function(e,t,n,r){const o=ne(e,t),a=ge(e,t);return It(t,e,r,{type:"JSXFragment",children:o,openingElement:n,closingFragment:a})}(e,t,r,n);if(!s){o=ne(e,t),a=xe(e,t);const n=zt(r.name),s=zt(a.name);n!==s&&an(e,85,s)}return It(t,e,n,{type:"JSXElement",children:o,openingElement:r,closingElement:a})}function Z(e,t,n,r,o,a){return t&ct.InJSXChild&&o?bt(e,t,167774016):ee(e),It(t,e,a,{type:"JSXOpeningElement",name:n,attributes:r,selfClosing:o})}function ee(e){return e.token=te(e)}function te(e){if(e.index>=e.source.length)return 1048576;e.lastIndex=e.startIndex=e.index;const t=e.source.charCodeAt(e.index);if(60===t)return e.index++,e.column++,f(e,47)?25:167774015;if(123===t)return e.index++,e.column++,41943052;for(;e.index<e.source.length;){e.index++,e.column++;const t=e.source.charCodeAt(e.index);if(123===t||60===t)break}return 121}function ne(e,t){const n=[];for(;25!==e.token;)n.push(oe(e,t));return n}function re(e,t){const n=Vt(e),r=e.source.slice(e.startIndex,e.index);e.token=te(e);const o=It(t,e,n,{type:"JSXText",value:r});return t&ct.OptionsRaw&&(o.raw=r),o}function oe(e,t){switch(e.token){case 33685505:case 121:return re(e,t);case 41943052:return me(e,t&~ct.InJSXChild);case 167774015:return Q(e,t&~ct.InJSXChild);default:an(e,0)}}function ae(e,t){const n=[];for(;e.index<e.source.length&&167774773!==e.token&&167774016!==e.token;)n.push(ue(e,t));return n}function se(e,t){const n=Vt(e);bt(e,t,41943052),bt(e,t,14);const r=Lt(e,t&~ct.InJSXChild,Ee);return bt(e,t,17825807),It(t,e,n,{type:"JSXSpreadAttribute",argument:r})}function ie(e,t,n,r){return bt(e,t,16777237),It(t,e,r,{type:"JSXNamespacedName",namespace:n,name:ke(e,t)})}function ce(e,t){const n=Vt(e),r=ke(e,t);return 16777237===e.token?ie(e,t,r,n):r}function le(e,t){switch(function(e,t){e.lastIndex=e.index;const n=e.source.charCodeAt(e.index);switch(n){case 34:case 39:return function(e,t,n){const r=e.index;e.index++,e.column++;let o="",a=e.source.charCodeAt(e.index);for(;a!==n;)o+=k(a),e.index++,e.column++,a=e.source.charCodeAt(e.index),e.index>=e.source.length&&an(e,6);e.index++,e.column++,t&ct.OptionsRaw&&(e.tokenRaw=e.source.slice(r,e.index));return e.tokenValue=o,33554435}(e,t,n);default:return Ct(e,t)}}(e,t)){case 33554435:return Pe(e,t);case 41943052:return fe(e,t|ct.InJSXChild);case 167774015:return Q(e,t|ct.InJSXChild);default:return void sn(e,t,87)}}function ue(e,t){const n=Vt(e);if(41943052===e.token)return se(e,t);ye(e);const r=ce(e,t);return It(t,e,n,{type:"JSXAttribute",value:83886109===e.token?le(e,t):null,name:r})}function de(e,t){return It(t,e,Vt(e),{type:"JSXEmptyExpression"})}function pe(e,t){const n=Vt(e);bt(e,t,14);const r=he(e,t);return bt(e,t,17825807),It(t,e,n,{type:"JSXSpreadChild",expression:r})}function fe(e,t){const n=Vt(e);bt(e,t,41943052),17825807===e.token&&sn(e,t,84);const r=Lt(e,t&~ct.InJSXChild,Ee);return bt(e,t,17825807),It(t,e,n,{type:"JSXExpressionContainer",expression:r})}function me(e,t){const n=Vt(e);if(bt(e,t,41943052),14===e.token)return pe(e,t);const r=17825807===e.token?de(e,t):Lt(e,t,Ee);return ee(e),It(t,e,n,{type:"JSXExpressionContainer",expression:r})}function ge(e,t){const n=Vt(e);return bt(e,t,25),bt(e,t,167774016),It(t,e,n,{type:"JSXClosingFragment"})}function xe(e,t){const n=Vt(e);bt(e,t,25);const r=we(e,t);return t&ct.InJSXChild?bt(e,t,167774016):ee(e),It(t,e,n,{type:"JSXClosingElement",name:r})}function ke(e,t){const{token:r,tokenValue:o,tokenRaw:a}=e;135168&r||sn(e,t,1,n(e.token));const s=Vt(e);Ct(e,t);const i=It(t,e,s,{type:"JSXIdentifier",name:o});return t&ct.OptionsRawidentifiers&&(i.raw=a),i}function Se(e,t,n,r){return ye(e),It(t,e,r,{type:"JSXMemberExpression",object:n,property:ke(e,t)})}function we(e,t){const n=Vt(e);ye(e);let r=ke(e,t);if(16777237===e.token)return ie(e,t,r,n);for(;vt(e,t,16777229);)r=Se(e,t,r,n);return r}function ye(e){const{token:t}=e;if(135168&t){const t=e.index;let n=e.source.charCodeAt(e.index);for(;e.index<e.source.length&&(45===n||s(n));)n=S(e);e.tokenValue+=e.source.substr(t,e.index-t)}return e.token}function he(e,t){const n=Vt(e),r=Lt(e,t,Ee);return 16777234===e.token?Ae(e,t,r,n):r}function Ae(e,t,n,r){const o=[n];for(;vt(e,t,16777234);)o.push(Lt(e,t,Ee));return It(t,e,r,{type:"SequenceExpression",expressions:o})}function Ee(e,t){const r=Vt(e);let{token:o}=e;if(t&ct.Yield&&1073741824&o)return function(e,t,n){t&ct.InParameter&&sn(e,t,51),bt(e,t,1107316842);let r=null,o=!1;return e.flags<.NewLine||((o=vt(e,t,167774771))||33554432&e.token)&&(r=Ee(e,t)),It(t,e,n,{type:"YieldExpression",argument:r,delegate:o})}(e,t,r);let a=524288&o&&Ft(e,t,Gt)?function(e,t){const n=Vt(e);let r=Oe(e,t|ct.AllowIn,n);if(135168&e.token)return 262144&e.token&&sn(e,t,40),qe(e,t,ft.Await,n,[Ut(e,t)]);e.flags<.NewLine&&sn(e,t,36,"async");for(;50331659===e.token;){r=Oe(e,t,n,r);const o=Le(e,t);if(10===e.token){r=qe(e,t,ft.Await,n,o);break}r=It(t,e,n,{type:"CallExpression",callee:r,arguments:o})}return r}(e,t):function(e,t,r){const o=function e(t,r,o,a,s=Ie(t,r)){const i=r&ct.AllowIn^ct.AllowIn;for(;Ot(t.token,167772160);){const c=t.token,l=3840&c,u=(167775030===c)<<8;if(i&&167786289===c)break;if(l+u<=o)break;Ct(t,r),s=It(r,t,a,{type:2097152&c?"LogicalExpression":"BinaryExpression",left:s,right:e(t,r&~ct.AllowIn,l,Vt(t)),operator:n(c)})}return s}(e,t,0,r);if(!vt(e,t,22))return o;const a=Lt(e,t&~ct.AllowDecorator|ct.AllowIn,Ee);return bt(e,t,16777237),It(t,e,r,{type:"ConditionalExpression",test:o,consequent:a,alternate:Lt(e,t,Ee)})}(e,t,r);if(10===e.token)return 135168&o&&(4214784&o&&(20480&o&&(e.flags|=lt.HasStrictReserved),4194304&o&&(t&ct.Strict&&sn(e,t,47),e.flags|=lt.StrictEvalArguments)),a=[a]),function(e,t,n,r){e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),e.flags<.NewLine&&sn(e,t,36,"=>");return bt(e,t,10),Ue(e,t&~ct.Async,r,n,ft.None)}(e,t&=~ct.Async,r,a);if(Ot(e.token,67108864)){o=e.token,t&ct.Strict&&jt(a.name)?sn(e,t,17):vt(e,t,83886109)?(e.flags<.AllowDestructuring||sn(e,t,73),t&ct.InParameter||Ht(e,t,a),t&ct.InParen&&(e.flags|=lt.SimpleParameterList),262144&e.token?($t(e),e.flags|=lt.HasAwait):t&ct.InParen&&t&(ct.Strict|ct.Yield)&&1073741824&e.token&&($t(e),e.flags|=lt.HasYield)):(Bt(a)||sn(e,t,5),e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),Ct(e,t));const s=Lt(e,t|ct.AllowIn,Ee);return e.pendingExpressionError=null,It(t,e,r,{type:"AssignmentExpression",left:a,operator:n(o),right:s})}return a}function Ie(e,t){const r=Vt(e),{token:o}=e;if(Ot(o,301989888)){Ct(e,t),e.flags<.EscapedKeyword&&sn(e,t,3);const a=Lt(e,t,Ie);return 167775030===e.token&&sn(e,t,1,n(e.token)),t&ct.Strict&&302002219===o&&("Identifier"===a.type?sn(e,t,43):qt(a)&&sn(e,t,44)),It(t,e,r,{type:"UnaryExpression",operator:n(o),argument:a,prefix:!0})}return t&ct.Async&&262144&o?function(e,t,n){return t&ct.InParameter&&sn(e,t,52),bt(e,t,34017389),It(t,e,n,{type:"AwaitExpression",argument:Ie(e,t)})}(e,t,r):function(e,t,r){const{token:o}=e;if(Ot(e.token,570425344)){Ct(e,t);const a=Ce(e,t,r);return _t(e,t,a,"Prefix"),It(t,e,r,{type:"UpdateExpression",argument:a,operator:n(o),prefix:!0})}if(t&ct.OptionsJSX&&167774015===o)return Q(e,t|ct.InJSXChild);const a=Ce(e,t,r);if(Ot(e.token,570425344)&&!(e.flags<.NewLine)){_t(e,t,a,"Postfix");const o=e.token;return Ct(e,t),It(t,e,r,{type:"UpdateExpression",argument:a,operator:n(o),prefix:!1})}return a}(e,t,r)}function be(e,t,n=[]){const r=Vt(e);return bt(e,t,14),t&ct.InParen&&262144&e.token&&(e.flags|=lt.HasAwait),It(t,e,r,{type:"RestElement",argument:q(e,t,n)})}function ve(e,t){const n=Vt(e);return bt(e,t,14),It(t,e,n,{type:"SpreadElement",argument:Dt(e,t|ct.AllowIn,Ee)})}function Ce(e,t,n){const r=t&ct.OptionsNext&&33566810===e.token?tt(e,t|ct.AllowIn):Oe(e,t|ct.AllowIn,n);return function(e,t,n,r){for(;;){if(r=Oe(e,t,n,r),50331659!==e.token)return r;const o=Ne(e,t&~ct.AllowDecorator);r=It(t,e,n,{type:"CallExpression",callee:r,arguments:o})}}(e,t|ct.AllowIn,n,r)}function Oe(e,t,n,r=De(e,t)){for(;;)switch(e.token){case 16777229:vt(e,t,16777229),e.flags=e.flags&~lt.AllowBinding|lt.AllowDestructuring,r=It(t,e,n,{type:"MemberExpression",object:r,computed:!1,property:Be(e,t)});continue;case 41943059:{vt(e,t,41943059),e.flags=e.flags&~lt.AllowBinding|lt.AllowDestructuring;const o=he(e,t);bt(e,t,20),r=It(t,e,n,{type:"MemberExpression",object:r,computed:!0,property:o});continue}case 33554441:r=It(t,e,n,{type:"TaggedTemplateExpression",tag:r,quasi:rt(e,t)});continue;case 33554440:r=It(t,e,n,{type:"TaggedTemplateExpression",tag:r,quasi:ot(e,t|ct.TaggedTemplate)});continue;default:return r}}function Ne(e,t){bt(e,t,50331659);const n=[];for(;16!==e.token;)14===e.token?n.push(ve(e,t)):(t&ct.Yield&&Ot(e.token,1073741824)&&(e.flags|=lt.HasYield,$t(e)),n.push(Lt(e,t|ct.AllowIn,Ee))),16!==e.token&&bt(e,t,16777234);return bt(e,t,16),n}function Le(e,t){bt(e,t,50331659);const n=[];let{token:r}=e,o=kt.Empty;for(;16!==e.token&&(14===e.token?(e.flags|=lt.SimpleParameterList,n.push(ve(e,t)),o=kt.HasSpread):(r=e.token,o=en(e,t,o),n.push(Dt(e,t|ct.AllowIn,Ee))),vt(e,t,16777234)&&(e.flags&=~lt.AllowDestructuring,o&kt.HasSpread&&(o=kt.SeenSpread)),16!==e.token););return bt(e,t,16),10===e.token&&(o&kt.SeenSpread?sn(e,t,78):o&kt.EvalOrArguments?(t&ct.Strict&&sn(e,t,47),e.flags|=lt.StrictEvalArguments):o&kt.Yield?(t&ct.Strict&&sn(e,t,51),e.flags|=lt.HasStrictReserved):e.flags<.HasYield?sn(e,t,51):(o&kt.Await||e.flags<.HasAwait)&&sn(e,t,52)),n}function De(e,t){switch(e.token){case 33685505:return Re(e,t);case 33554434:case 33554435:return Pe(e,t);case 594028:return function(e,t){return Ft(e,t,Yt)?Je(e,t):Re(e,t)}(e,t);case 50331659:return function(e,t){if(bt(e,t,50331659),vt(e,t,16)){if(e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),10===e.token)return[]}else if(14===e.token){const r=[be(e,t)];return bt(e,t,16),e.flags=e.flags&~(lt.AllowDestructuring|lt.AllowBinding)|lt.SimpleParameterList,10!==e.token&&sn(e,t,1,n(e.token)),r}const r=Vt(e);let o=Zt(e,mt.None),a=Dt(e,t|ct.AllowIn,Ee);if(16777234===e.token){o|=mt.SequenceExpression;const s=[a];for(;vt(e,t|ct.DisallowEscapedKeyword,16777234);){if(14===e.token){e.flags<.AllowBinding||sn(e,t,77),e.flags|=lt.SimpleParameterList;const n=be(e,t);return bt(e,t,16),10!==e.token&&sn(e,t,78),s.push(n),s}if(vt(e,t,16))return 10!==e.token&&sn(e,t,1,n(e.token)),s;o=Zt(e,o),s.push(Dt(e,t,Ee))}a=It(t,e,r,{type:"SequenceExpression",expressions:s})}if(bt(e,t,16),10===e.token)return o&mt.HasEvalOrArguments?(t&ct.Strict&&sn(e,t,47),e.flags|=lt.StrictEvalArguments):o&mt.HasReservedWords?(t&ct.Strict&&sn(e,t,50),e.flags|=lt.HasStrictReserved):e.flags<.AllowBinding?e.flags<.HasYield?sn(e,t,51):t&ct.Async&&e.flags<.HasAwait&&sn(e,t,52):sn(e,t,77),e.flags&=~(lt.AllowBinding|lt.HasAwait|lt.HasYield),o&mt.SequenceExpression?a.expressions:[a];e.flags&=~(lt.HasAwait|lt.HasYield|lt.AllowBinding),Bt(a)||(e.flags&=~lt.AllowDestructuring);return a}(e,t|ct.InParen);case 41943059:return Dt(e,t,Ve);case 41943052:return Dt(e,t,Ge);case 33566808:return Me(e,t);case 33566727:case 33566726:case 33566725:return function(e,t){const r=Vt(e),{token:o}=e,a=n(o);e.flags<.EscapedKeyword&&sn(e,t,3);Ct(e,t);const s=It(t,e,r,{type:"Literal",value:33566727===o?null:"true"===a});t&ct.OptionsRaw&&(s.raw=a);return s}(e,t);case 120:case 33566797:return function(e,t){const n=Vt(e);let r=[];t&ct.OptionsExperimental&&(r=it(e,t));bt(e,t|ct.DisallowEscapedKeyword,33566797);const{token:o}=e;let a=wt.None,s=null,i=null;41943052!==o&&12372!==o&&(t&ct.Async&&262144&o&&sn(e,t,48),s=U(e,t|ct.Strict));vt(e,t,12372)&&(i=Ce(e,t|ct.Strict,n),a|=wt.Heritage);const c=_e(e,t|ct.Strict,a);return It(t,e,n,t&ct.OptionsExperimental?{type:"ClassExpression",id:s,superClass:i,body:c,decorators:r}:{type:"ClassExpression",id:s,superClass:i,body:c})}(e,t);case 33566811:return function(e,t){const r=Vt(e),o=Re(e,t);if(vt(e,t|ct.DisallowEscapedKeyword,16777229))return"target"===e.tokenValue&&t&(ct.InParameter|ct.InFunctionBody)||sn(e,t,53),nt(e,t,o,r);return It(t,e,r,{type:"NewExpression",callee:function(e,t,r){const{token:o}=e;if(t&ct.OptionsNext&&33566810===o)return Ft(e,t,Kt)&&sn(e,t,1,n(o)),tt(e,t);return Oe(e,t,r)}(e,t,r),arguments:50331659===e.token?Ne(e,t):[]})}(e,t);case 33566813:return function(e,t){const n=Vt(e);switch(bt(e,t,33566813),e.token){case 50331659:t&ct.AllowSuperProperty||sn(e,t,54);break;case 41943059:case 16777229:t&ct.Method||sn(e,t,55);break;default:sn(e,t,56)}return It(t,e,n,{type:"Super"})}(e,t);case 33554551:return He(e,t);case 33566815:return function(e,t){e.flags<.EscapedKeyword&&sn(e,t,3);const n=Vt(e);return Ct(e,t|ct.DisallowEscapedKeyword),It(t,e,n,{type:"ThisExpression"})}(e,t);case 115:return Be(e,t);case 167774773:case 100663333:return Y(e,t),function(e,t){const n=Vt(e),{tokenRegExp:r,tokenValue:o,tokenRaw:a}=e;Ct(e,t);const s=It(t,e,n,{type:"Literal",value:o,regex:r});t&ct.OptionsRaw&&(s.raw=a);return s}(e,t);case 33554441:return rt(e,t);case 33554440:return ot(e,t);case 33574984:return function(e,t){t&ct.Strict&&sn(e,t,50);const n=Vt(e),r=e.tokenValue;Ct(e,t),e.flags<.NewLine&&41943059===e.token&&sn(e,t,1,"let");return It(t,e,n,{type:"Identifier",name:r})}(e,t);case 12369:if(t&ct.OptionsExperimental)return function(e,t){const n=Vt(e);return bt(e,t,12369),It(t,e,n,{type:"DoExpression",body:Ln(e,t)})}(e,t);default:return Ut(e,t)}}function Re(e,t){const n=Vt(e),r=e.tokenValue;Ct(e,t|ct.TaggedTemplate);const o=It(t,e,n,{type:"Identifier",name:r});return t&ct.OptionsRawidentifiers&&(o.raw=e.tokenRaw),o}function Pe(e,t){const n=Vt(e),r=e.tokenValue;t&ct.Strict&&e.flags<.HasOctal&&sn(e,t,61),Ct(e,t);const o=It(t,e,n,{type:"Literal",value:r});return t&ct.OptionsRaw&&(o.raw=e.tokenRaw),o}function He(e,t){const n=Vt(e),{tokenValue:r,tokenRaw:o}=e;Ct(e,t);const a=It(t,e,n,{type:"Literal",value:r,bigint:o});return t&ct.OptionsRaw&&(a.raw=e.tokenRaw),a}function Fe(e,t,r){return 135168&r||sn(e,t,4,n(r)),Re(e,t)}function Be(e,t){if(!vt(e,t,115))return Fe(e,t,e.token);const{tokenValue:n}=e,r=Vt(e),o=n;return Ct(e,t),It(t,e,r,{type:"PrivateName",name:o})}function Ve(e,t){const n=Vt(e);bt(e,t,41943059);const r=[];for(;20!==e.token;)vt(e,t,16777234)?r.push(null):14===e.token?(r.push(ve(e,t)),20!==e.token&&(e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),bt(e,t,16777234))):(r.push(Dt(e,t|ct.AllowIn,Ee)),20!==e.token&&bt(e,t,16777234));return bt(e,t,20),It(t,e,n,{type:"ArrayExpression",elements:r})}function Me(e,t){const n=Vt(e);bt(e,t,33566808);const r=vt(e,t,167774771)?ft.Generator:ft.None;let o=null;const{token:a}=e;135168&a&&(4194304&a&&(t&ct.Strict&&sn(e,t,47),e.flags|=lt.StrictEvalArguments),1073741824&e.token&&r&ft.Generator&&sn(e,t,49),o=U(e,t));const{params:s,body:i}=Rt(e,t&~(ct.Method|ct.AllowSuperProperty),r,je);return It(t,e,n,{type:"FunctionExpression",params:s,body:i,async:!1,generator:!!(r&ft.Generator),expression:!1,id:o})}function Je(e,t){const n=Vt(e);bt(e,t,594028),bt(e,t,33566808);const r=vt(e,t,167774771)?ft.Generator:ft.None,o=ft.Await;let a=null;const{token:s}=e;135168&s&&(4194304&s&&((t&ct.Strict||o&ft.Await)&&sn(e,t,47),e.flags|=lt.StrictFunctionName),262144&s&&sn(e,t,48),1073741824&e.token&&r&ft.Generator&&sn(e,t,49),a=U(e,t));const{params:i,body:c}=Rt(e,t&~(ct.Method|ct.AllowSuperProperty),r|o,je);return It(t,e,n,{type:"FunctionExpression",params:i,body:c,async:!0,generator:!!(r&ft.Generator),expression:!1,id:a})}function Te(e,t){switch(e.token){case 33554434:case 33554435:return Pe(e,t);case 41943059:return function(e,t){bt(e,t,41943059);const n=Ee(e,t|ct.AllowIn);return bt(e,t,20),n}(e,t);default:return Re(e,t)}}function Xe(e,t){const n=Vt(e);return bt(e,t,14),8388608&e.token&&(e.flags&=~lt.AllowDestructuring),It(t,e,n,{type:"SpreadElement",argument:Ee(e,t|ct.AllowIn)})}function Ge(e,t){const n=Vt(e);bt(e,t,41943052);const r=[];for(;17825807!==e.token;)r.push(14===e.token?Xe(e,t):Ke(e,t)),17825807!==e.token&&bt(e,t,16777234);return bt(e,t,17825807),e.flags&=~lt.HasProtoField,It(t,e,n,{type:"ObjectExpression",properties:r})}function Ke(e,t){const r=Vt(e),o=e.flags;let a,s=vt(e,t,167774771)?wt.Generator|wt.Method:wt.Method;const i=e.token;let c=Te(e,t);return 16777216&e.token||(o<.EscapedKeyword?sn(e,t,3):s&wt.Generator||!(524288&i)||e.flags<.NewLine?69743===i?(s=s&~wt.Method|wt.Getter,c=Te(e,t)):69744===i&&(s=s&~wt.Method|wt.Setter,c=Te(e,t)):(s|=vt(e,t,167774771)?wt.Generator|wt.Async:wt.Async,c=Te(e,t)),s&(wt.Getter|wt.Setter)&&s&wt.Generator&&sn(e,t,1,n(e.token))),50331659===e.token?a=Ye(e,t,s):(s&=~wt.Method,16777237===e.token?(s&(wt.Async|wt.Generator)?sn(e,t,1,n(e.token)):41943059!==i&&"__proto__"===e.tokenValue&&(e.flags<.HasProtoField?Qt(e,63):e.flags|=lt.HasProtoField),bt(e,t,16777237),262144&e.token&&(e.flags|=lt.HasAwait),a=Dt(e,t,Ee)):(s&(wt.Generator|wt.Async)||!Mt(t,i)?sn(e,t,1,n(i)):t&(ct.Strict|ct.Yield)&&1073741824&i&&($t(e),e.flags|=lt.HasYield),s|=wt.Shorthand,83886109===e.token?(t&ct.Strict&&4194304&i?an(e,47):Qt(e,91),bt(e,t,83886109),t&(ct.Strict|ct.Yield|ct.Async)&&1074003968&e.token&&($t(e),e.flags|=1073741824&e.token?lt.HasYield:lt.HasAwait),a=z(e,t,c,r)):(262144&i&&(t&ct.Async&&sn(e,t,46),$t(e),e.flags|=lt.HasAwait),a=c))),It(t,e,r,{type:"Property",key:c,value:a,kind:s&wt.Getter|s&wt.Setter?s&wt.Setter?"set":"get":"init",computed:41943059===i,method:!!(s&wt.Method),shorthand:!!(s&wt.Shorthand)})}function Ye(e,t,n){const r=Vt(e),o=n&wt.Generator?ft.Generator:ft.None,a=n&wt.Async?ft.Await:ft.None,{params:s,body:i}=Rt(e,t|ct.Method,o|a,je,n);return It(t,e,r,{type:"FunctionExpression",params:s,body:i,async:!!(n&wt.Async),generator:!!(n&wt.Generator),expression:!1,id:null})}function qe(e,t,n,r,o){return e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),e.flags<.NewLine&&sn(e,t,36,"async"),bt(e,t,10),Ue(e,t|ct.Async,o,r,n)}function Ue(e,t,n,r,o){e.pendingExpressionError=null;for(const r in n)Ht(e,t|ct.InParameter,n[r]);const a=41943052!==e.token;return It(t,e,r,{type:"ArrowFunctionExpression",body:a?Lt(e,t&~(ct.Yield|ct.InParameter),Ee):Rt(e,t&~(ct.Yield|ct.AllowDecorator)|ct.InFunctionBody,o,$e),params:n,id:null,async:!!(o&ft.Await),generator:!1,expression:a})}function je(e,t,n){const r=ze(e,t|ct.InParameter,n),o=r.args;return{params:r.params,body:$e(e,t&~ct.AllowDecorator|ct.InFunctionBody,o)}}function $e(e,t,n){const r=Vt(e);bt(e,t|ct.DisallowEscapedKeyword,41943052);const o=[];for(;33554435===e.token;){const{tokenRaw:n,tokenValue:r}=e;o.push(vn(e,t)),12===n.length&&"use strict"===r&&(e.flags<.SimpleParameterList?sn(e,t,64):e.flags&(lt.HasStrictReserved|lt.StrictFunctionName)?sn(e,t,50):e.flags<.StrictEvalArguments&&sn(e,t,47),t|=ct.Strict)}t&ct.Strict&&Pt(e,t,n);const{labelSet:a}=e;e.labelSet={};const s=e.flags;for(e.flags=e.flags&~(lt.StrictFunctionName|lt.StrictEvalArguments|lt.InSwitchStatement|lt.InIterationStatement)|lt.AllowDestructuring;17825807!==e.token;)o.push(mn(e,t));return s<.InIterationStatement&&(e.flags|=lt.InIterationStatement),s<.InSwitchStatement&&(e.flags|=lt.InSwitchStatement),e.labelSet=a,bt(e,t,17825807),It(t,e,r,{type:"BlockStatement",body:o})}function ze(e,t,n){bt(e,t,50331659),e.flags&=~(lt.SimpleParameterList|lt.HasStrictReserved);const r=[],o=[];for(;16!==e.token;){if(14===e.token){n&wt.Setter&&sn(e,t,67),e.flags|=lt.SimpleParameterList,o.push(be(e,t,r));break}if(o.push(We(e,t,r)),!vt(e,t,16777234))break;if(16===e.token)break}return n&wt.Setter&&1!==o.length&&sn(e,t,66,"Setter","one",""),n&wt.Getter&&o.length>0&&sn(e,t,66,"Getter","no","s"),bt(e,t,16),{params:o,args:r}}function We(e,t,n){const r=Vt(e);135168&e.token?(Ot(e.token,20480)&&(t&ct.Strict&&sn(e,t,50),e.flags|=lt.StrictFunctionName),Ot(e.token,4194304)&&(t&ct.Strict&&sn(e,t,47),e.flags|=lt.StrictEvalArguments)):e.flags|=lt.SimpleParameterList;const o=q(e,t,n);return vt(e,t,83886109)?(1074003968&e.token&&t&(ct.Yield|ct.Async)&&sn(e,t,262144&e.token?52:51),e.flags|=lt.SimpleParameterList,It(t,e,r,{type:"AssignmentPattern",left:o,right:Lt(e,t,Ee)})):o}function _e(e,t,n){const r=Vt(e);bt(e,t,41943052);const o=[];let a=[];for(;17825807!==e.token;)vt(e,t,17825809)||(t&ct.OptionsExperimental&&(a=it(e,t),17825807===e.token&&an(e,92),0!==a.length&&"constructor"===e.tokenValue&&an(e,93)),o.push(t&ct.OptionsNext&&115===e.token?et(e,t,a):Qe(e,t,n,a)));return e.flags&=~lt.HasConstructor,bt(e,t,17825807),It(t,e,r,{type:"ClassBody",body:o})}function Qe(e,t,r,o){const a=Vt(e);let{tokenValue:s,token:i}=e;const c=e.flags;vt(e,t,167774771)&&(r|=wt.Generator),41943059===e.token&&(r|=wt.Computed),"constructor"===e.tokenValue&&(r&wt.Generator?sn(e,t,45,"generator"):r&wt.Heritage&&(t|=ct.AllowSuperProperty),r|=wt.Constructor);let l,u=Te(e,t);if(!(16777216&e.token)){if(c<.EscapedKeyword&&sn(e,t,3),20585===i&&(i=e.token,vt(e,t,167774771)&&(r|=wt.Generator),s=e.tokenValue,41943059===e.token&&(r|=wt.Computed),"prototype"===e.tokenValue&&sn(e,t,65),r|=wt.Static,u=Te(e,t),t&ct.OptionsNext&&Wt(e)))return"constructor"===s&&sn(e,t,1,n(e.token)),Ze(e,t,u,r,a,o);50331659!==e.token&&(!(524288&i)||r&wt.Generator||e.flags<.NewLine?69743!==i&&69744!==i||(r|=69743===i?wt.Getter:wt.Setter,s=e.tokenValue,41943059===e.token&&(r|=wt.Computed),u=Te(e,t&~ct.Strict)):(i=e.token,s=e.tokenValue,r|=wt.Async,vt(e,t,167774771)&&(r|=wt.Generator),41943059===e.token&&(r|=wt.Computed),u=Te(e,t)),"prototype"===s?sn(e,t,65):r&wt.Static||"constructor"!==s||sn(e,t,45,"accessor"))}if(50331659===e.token)!(r&wt.Computed)&&r&wt.Constructor&&(e.flags<.HasConstructor?an(e,12):e.flags|=lt.HasConstructor),l=Ye(e,t,r);else{if(t&ct.OptionsNext)return Ze(e,t,u,r,a,o);sn(e,t,1,n(i))}const d=r&wt.Constructor?"constructor":r&wt.Getter?"get":r&wt.Setter?"set":"method";return It(t,e,a,t&ct.OptionsExperimental?{type:"MethodDefinition",kind:d,static:!!(r&wt.Static),computed:!!(r&wt.Computed),key:u,value:l,decorators:o}:{type:"MethodDefinition",kind:d,static:!!(r&wt.Static),computed:!!(r&wt.Computed),key:u,value:l})}function Ze(e,t,n,r,o,a){r&wt.Constructor&&sn(e,t,0);let s=null;return r&(wt.Async|wt.Generator)&&sn(e,t,0),vt(e,t,83886109)&&(4194304&e.token&&sn(e,t,47),s=Ee(e,t)),vt(e,t,16777234),It(t,e,o,t&ct.OptionsExperimental?{type:"FieldDefinition",key:n,value:s,computed:!!(r&wt.Computed),static:!!(r&wt.Static),decorators:a}:{type:"FieldDefinition",key:n,value:s,computed:!!(r&wt.Computed),static:!!(r&wt.Static)})}function et(e,t,n){const r=Vt(e);bt(e,t|ct.InClass,115),"constructor"===e.tokenValue&&sn(e,t,41);const o=function(e,t,n){const r=e.tokenValue;return Ct(e,t),It(t,e,n,{type:"PrivateName",name:r})}(e,t,r);if(50331659===e.token)return function(e,t,n,r,o){const a=Ye(e,t|ct.Strict,wt.None);return e.flags&=~(lt.AllowDestructuring|lt.AllowBinding),It(t,e,r,t&ct.OptionsExperimental?{type:"MethodDefinition",kind:"method",static:!1,computed:!1,key:n,value:a,decorators:o}:{type:"MethodDefinition",kind:"method",static:!1,computed:!1,key:n,value:a})}(e,t,o,r,n);let a=null;return vt(e,t,83886109)&&(4194304&e.token&&sn(e,t,47),a=Ee(e,t)),vt(e,t,16777234),It(t,e,r,t&ct.OptionsExperimental?{type:"FieldDefinition",key:o,value:a,computed:!1,static:!1,decorators:n}:{type:"FieldDefinition",key:o,value:a,computed:!1,static:!1})}function tt(e,t){const r=Vt(e),o=Re(e,t);if(vt(e,t,16777229)){if(t&ct.Module&&"meta"===e.tokenValue)return nt(e,t,o,r);sn(e,t,1,n(e.token))}let a=function(e,t,n){return It(t,e,n,{type:"Import"})}(e,t,r);bt(e,t,50331659);const s=Lt(e,t|ct.AllowIn,Ee);return bt(e,t,16),a=It(t,e,r,{type:"CallExpression",callee:a,arguments:[s]})}function nt(e,t,n,r){return It(t,e,r,{meta:n,type:"MetaProperty",property:Re(e,t)})}function rt(e,t){return It(t,e,Vt(e),{type:"TemplateLiteral",expressions:[],quasis:[at(e,t)]})}function ot(e,t,n=[],r=[]){const o=Vt(e),{tokenValue:a,tokenRaw:s}=e;bt(e,t,33554440),n.push(he(e,t));const i=Vt(e);return r.push(function(e,t,n=null,r,o){return e.token=I(e,t),It(t,e,o,{type:"TemplateElement",value:{cooked:n,raw:r},tail:!1})}(e,t,a,s,o)),33554441===e.token?r.push(at(e,t,i)):ot(e,t,n,r),It(t,e,o,{type:"TemplateLiteral",expressions:n,quasis:r})}function at(e,t,n=Vt(e)){const{tokenValue:r,tokenRaw:o}=e;return bt(e,t,33554441),It(t,e,n,{type:"TemplateElement",value:{cooked:r,raw:o},tail:!0})}function st(e,t){const n=Vt(e);return It(t,e,n,{type:"Decorator",expression:Ce(e,t,n)})}function it(e,t){const n=[];for(;vt(e,t,120);)n.push(st(e,t|ct.AllowDecorator));return n}var ct,lt,ut,dt,pt,ft,mt,gt,xt,kt,St,wt;function yt(e,t,n,r){const o=Et(e,n);o||sn(e,t,32,n),!r||o&ut.Nested||sn(e,t,31,n)}function ht(e,t){var n;void 0===e.labelSet&&(e.labelSet={}),e.labelSet[`$${t}`]=12369===(n=e.token)||12386===n||12374===n?ut.Nested:ut.NotNested}function At(e,t){e.labelSet[`$${t}`]=ut.None}function Et(e,t){return e.labelSet?e.labelSet[`$${t}`]:ut.None}function It(e,t,n,r){const{lastIndex:o,lastLine:a,lastColumn:s,sourceFile:i,index:c}=t;return e&ct.LocationTracker&&(e&ct.OptionsRanges&&(r.start=n.index,r.end=o),e&ct.OptionsLoc&&(r.loc={start:{line:n.line,column:n.column},end:{line:a,column:s}},i&&(r.loc.source=i))),r}function bt(e,t,r,o=1){return e.token!==r&&an(e,o,n(e.token)),Ct(e,t),!0}function vt(e,t,n){return e.token===n&&(Ct(e,t),!0)}function Ct(e,t){return e.lastIndex=e.index,e.lastLine=e.line,e.lastColumn=e.column,e.token=K(e,t)}!function(e){e[e.Empty=0]="Empty",e[e.OptionsNext=1]="OptionsNext",e[e.OptionsRanges=2]="OptionsRanges",e[e.OptionsJSX=4]="OptionsJSX",e[e.OptionsRaw=8]="OptionsRaw",e[e.OptionsLoc=16]="OptionsLoc",e[e.OptionsGlobalReturn=32]="OptionsGlobalReturn",e[e.OptionsComments=64]="OptionsComments",e[e.OptionsShebang=128]="OptionsShebang",e[e.OptionsRawidentifiers=256]="OptionsRawidentifiers",e[e.OptionsTolerant=512]="OptionsTolerant",e[e.OptionsNode=1024]="OptionsNode",e[e.OptionsExperimental=2048]="OptionsExperimental",e[e.Strict=4096]="Strict",e[e.Module=8192]="Module",e[e.TaggedTemplate=16384]="TaggedTemplate",e[e.InClass=32768]="InClass",e[e.AllowIn=65536]="AllowIn",e[e.Async=131072]="Async",e[e.Yield=262144]="Yield",e[e.InParameter=524288]="InParameter",e[e.InFunctionBody=1048576]="InFunctionBody",e[e.AllowSingleStatement=2097152]="AllowSingleStatement",e[e.BlockScope=4194304]="BlockScope",e[e.ForStatement=8388608]="ForStatement",e[e.RequireIdentifier=16777216]="RequireIdentifier",e[e.Method=33554432]="Method",e[e.AllowSuperProperty=67108864]="AllowSuperProperty",e[e.InParen=134217728]="InParen",e[e.InJSXChild=268435456]="InJSXChild",e[e.DisallowEscapedKeyword=536870912]="DisallowEscapedKeyword",e[e.AllowDecorator=1073741824]="AllowDecorator",e[e.LocationTracker=18]="LocationTracker"}(ct||(ct=e("Context",{}))),function(e){e[e.None=0]="None",e[e.NewLine=1]="NewLine",e[e.AllowBinding=2]="AllowBinding",e[e.AllowDestructuring=4]="AllowDestructuring",e[e.SimpleParameterList=8]="SimpleParameterList",e[e.InSwitchStatement=16]="InSwitchStatement",e[e.InIterationStatement=32]="InIterationStatement",e[e.HasStrictReserved=64]="HasStrictReserved",e[e.HasOctal=128]="HasOctal",e[e.SimpleAssignmentTarget=256]="SimpleAssignmentTarget",e[e.HasProtoField=512]="HasProtoField",e[e.StrictFunctionName=1024]="StrictFunctionName",e[e.StrictEvalArguments=2048]="StrictEvalArguments",e[e.InFunctionBody=4096]="InFunctionBody",e[e.HasAwait=8192]="HasAwait",e[e.HasYield=16384]="HasYield",e[e.EscapedKeyword=32768]="EscapedKeyword",e[e.HasConstructor=65536]="HasConstructor"}(lt||(lt=e("Flags",{}))),function(e){e[e.None=0]="None",e[e.NotNested=1]="NotNested",e[e.Nested=2]="Nested"}(ut||(ut=e("Labels",{}))),function(e){e[e.None=0]="None",e[e.SeenSeparator=1]="SeenSeparator",e[e.EigthOrNine=2]="EigthOrNine",e[e.Float=4]="Float",e[e.BigInt=8]="BigInt"}(dt||(dt=e("NumericState",{}))),function(e){e[e.None=0]="None",e[e.NewLine=1]="NewLine",e[e.LastIsCR=2]="LastIsCR"}(pt||(pt=e("ScannerState",{}))),function(e){e[e.None=0]="None",e[e.Generator=1]="Generator",e[e.Await=2]="Await"}(ft||(ft=e("ModifierState",{}))),function(e){e[e.None=0]="None",e[e.SequenceExpression=1]="SequenceExpression",e[e.HasEvalOrArguments=2]="HasEvalOrArguments",e[e.HasReservedWords=4]="HasReservedWords",e[e.HasYield=8]="HasYield",e[e.HasBinding=16]="HasBinding"}(mt||(mt=e("CoverParenthesizedState",{}))),function(e){e[e.Empty=-1]="Empty",e[e.StrictOctal=-2]="StrictOctal",e[e.EightOrNine=-3]="EightOrNine",e[e.InvalidHex=-4]="InvalidHex",e[e.OutOfRange=-5]="OutOfRange"}(gt||(gt=e("Escape",{}))),function(e){e[e.Empty=0]="Empty",e[e.IgnoreCase=1]="IgnoreCase",e[e.Global=2]="Global",e[e.Multiline=4]="Multiline",e[e.Unicode=8]="Unicode",e[e.Sticky=16]="Sticky",e[e.DotAll=32]="DotAll"}(xt||(xt=e("RegexFlags",{}))),function(e){e[e.Empty=0]="Empty",e[e.SeenSpread=1]="SeenSpread",e[e.HasSpread=2]="HasSpread",e[e.SimpleParameter=4]="SimpleParameter",e[e.EvalOrArguments=8]="EvalOrArguments",e[e.Yield=16]="Yield",e[e.Await=32]="Await"}(kt||(kt=e("CoverCallState",{}))),function(e){e[e.Empty=0]="Empty",e[e.Escape=1]="Escape",e[e.Class=2]="Class"}(St||(St=e("RegexState",{}))),function(e){e[e.None=0]="None",e[e.Async=1]="Async",e[e.Generator=2]="Generator",e[e.Getter=4]="Getter",e[e.Setter=8]="Setter",e[e.Computed=16]="Computed",e[e.Method=32]="Method",e[e.Shorthand=64]="Shorthand",e[e.Static=128]="Static",e[e.Constructor=256]="Constructor",e[e.Heritage=512]="Heritage"}(wt||(wt=e("ObjectState",{})));const Ot=e("hasBit",(e,t)=>(e&t)===t);function Nt(e,t){return 1048576&e.token||e.flags<.NewLine?vt(e,t,17825809):an(e,!(t&ct.Async)&&262144&e.token?38:1,n(e.token))}function Lt(e,t,n){const{flags:r,pendingExpressionError:o}=e;e.flags|=lt.AllowBinding|lt.AllowDestructuring,e.pendingExpressionError=void 0;const a=n(e,t);if(e.pendingExpressionError){const{error:n,line:r,column:o,index:a}=e.pendingExpressionError;rn(e,t,a,r,o,n)}return e.flags&=~(lt.AllowBinding|lt.AllowDestructuring),r<.AllowBinding&&(e.flags|=lt.AllowBinding),r<.AllowDestructuring&&(e.flags|=lt.AllowDestructuring),e.pendingExpressionError=o,a}function Dt(e,t,n){const{flags:r,pendingExpressionError:o}=e;e.flags|=lt.AllowBinding|lt.AllowDestructuring,e.pendingExpressionError=void 0;const a=n(e,t);return e.flags<.AllowBinding&&r<.AllowBinding||(e.flags&=~lt.AllowBinding),e.flags<.AllowDestructuring&&r<.AllowDestructuring||(e.flags&=~lt.AllowDestructuring),e.pendingExpressionError=o||e.pendingExpressionError,a}function Rt(e,t,n,r,o=wt.None){return t&=~(ct.Async|ct.Yield|ct.InParameter),n&ft.Generator&&(t|=ct.Yield),n&ft.Await&&(t|=ct.Async),r(e,t,o)}function Pt(e,t,n){const r=new Map;for(let o=0;o<n.length;o++){const a=`@${n[o]}`;r.get(a)?sn(e,t,81):r.set(a,!0)}}const Ht=e("reinterpret",(e,t,n)=>{switch(n.type){case"Identifier":t&ct.Strict&&jt(n.name)&&an(e,3);case"ArrayPattern":case"AssignmentPattern":case"ObjectPattern":case"RestElement":case"MetaProperty":return;case"ArrayExpression":n.type="ArrayPattern";for(let r=0;r<n.elements.length;++r)null!==n.elements[r]&&Ht(e,t,n.elements[r]);return;case"ObjectExpression":n.type="ObjectPattern";for(let r=0;r<n.properties.length;r++)Ht(e,t,n.properties[r]);return;case"Property":return void Ht(e,t,n.value);case"SpreadElement":n.type="RestElement","ArrayExpression"===n.argument.type||"ObjectExpression"===n.argument.type||Bt(n.argument)||sn(e,t,71),Ht(e,t,n.argument);break;case"AssignmentExpression":return n.type="AssignmentPattern",delete n.operator,void Ht(e,t,n.left);case"MemberExpression":if(!(t&ct.InParameter))return;default:sn(e,t,t&ct.InParameter?77:73,n.type)}});function Ft(e,t,n){const{tokenValue:r,flags:o,line:a,column:s,startColumn:i,index:c,lastColumn:l,startLine:u,lastLine:d,lastIndex:p,startIndex:f,tokenRaw:m,token:g,lastValue:x,tokenRegExp:k,labelSet:S,errors:w,errorLocation:y,pendingExpressionError:h}=e,A=n(e,t);return e.index=c,e.token=g,e.tokenValue=r,e.tokenValue=r,e.flags=o,e.line=a,e.column=s,e.tokenRaw=m,e.lastValue=x,e.startColumn=i,e.lastColumn=l,e.startLine=u,e.lastLine=d,e.lastIndex=p,e.startIndex=f,e.tokenRegExp=k,e.labelSet=S,e.errors=w,e.errorLocation=y,e.tokenRegExp=k,e.pendingExpressionError=h,A}function Bt(e){return"Identifier"===e.type||"MemberExpression"===e.type}function Vt(e){return{line:e.startLine,column:e.startColumn,index:e.startIndex}}function Mt(e,t){return e&ct.Strict?!(e&ct.Module&&262144&t)&&(!(1073741824&t)&&(131072==(131072&t)||69632==(69632&t))):131072==(131072&t)||69632==(69632&t)||20480==(20480&t)}function Jt(e,t){Ct(e,t);const{token:n}=e;return!!(1082523648&n||33574984===n||69632==(69632&n))}function Tt(e){return 12368===e.token||17825807===e.token||12363===e.token}function Xt(e,t){return Ct(e,t),50331659===e.token||16777229===e.token}function Gt(e,t){Ct(e,t);const{token:n}=e;return 1073872896&n||50331659===n}function Kt(e,t){return Ct(e,t),50331659===e.token}function Yt(e,t){return Ct(e,t),!(e.flags<.NewLine)&&33566808===e.token}function qt(e){return!!e.property&&"PrivateName"===e.property.type}function Ut(e,t){const{token:r,tokenValue:o}=e;if(t&ct.Strict){if(t&ct.Module&&262144&r&&sn(e,t,40,n(e.token)),1073741824&r&&sn(e,t,40,n(e.token)),131072==(131072&r)||69632==(69632&r))return Re(e,t);an(e,1,n(e.token))}if(t&ct.Yield&&1073741824&r&&sn(e,t,40,n(e.token)),t&ct.Async&&262144&r&&sn(e,t,40,n(e.token)),131072==(131072&r)||69632==(69632&r)||20480==(20480&r))return Re(e,t);an(e,1,n(e.token))}function jt(e){return"eval"===e||"arguments"===e}function $t(e){e.errorLocation={line:e.startLine,column:e.startColumn,index:e.startIndex}}function zt(e){switch(e.type){case"JSXIdentifier":return e.name;case"JSXNamespacedName":return`${zt(e.namespace)}:${zt(e.name)}`;case"JSXMemberExpression":return`${zt(e.object)}.${zt(e.property)}`}}function Wt(e){const{token:t}=e;return 17825807===t||17825809===t||83886109===t}function _t(e,t,n,r){t&ct.Strict&&jt(n.name)&&sn(e,t,68,r),Bt(n)||sn(e,t,5)}function Qt(e,t){e.pendingExpressionError={error:nn[t],line:e.line,column:e.column,index:e.index}}function Zt(e,t){const{token:n}=e;return 8388608&n?e.flags|=lt.SimpleParameterList:4194304==(4194304&n)?($t(e),t|=mt.HasEvalOrArguments):20480==(20480&n)?($t(e),t|=mt.HasReservedWords):262144==(262144&n)&&($t(e),e.flags|=lt.HasAwait),t}function en(e,t,n){const{token:r}=e;return e.flags<.AllowBinding?8388608&r?e.flags|=lt.SimpleParameterList:4194304==(4194304&r)?($t(e),n|=kt.EvalOrArguments):262144==(262144&r)?($t(e),n|=kt.Await):1073741824==(1073741824&r)&&($t(e),n|=kt.Yield):sn(e,t,77),n}function tn(e){return 69746===e||167786289===e}const nn=e("errorMessages",{0:"Unexpected token",1:"Unexpected token '%0'",2:"Expected token '%0'",3:"Keyword must not contain escaped characters",4:"Keyword '%0' is reserved",5:"Invalid left-hand side in assignment",6:"Unterminated string literal",7:"Unterminated regular expression literal",8:"Unterminated MultiLineComment",9:"Unterminated template literal",10:"Invalid character '%0'",11:"Octal escapes are not allowed in strict mode",13:"Escapes \\8 or \\9 are not syntactically valid escapes",14:"Unicode escape code point out of range",15:"Duplicate regular expression flag '%0'",16:"Unexpected regular expression flag '%0'",17:"Eval or arguments can't be assigned to in strict mode code",18:"Illegal return statement",19:"In strict mode code, functions can only be declared at top level or inside a block",20:"In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement",21:"%0 can't appear in single-statement context",22:"Generators can only be declared at the top level or inside a block",23:"'for await' loop should be used with 'of'",24:"Missing initializer in %0 declaration",25:"'for-%0' loop variable declaration may not have an initializer",26:"Invalid left-hand side in for-%0 loop: Must have a single binding.",27:"let is disallowed as a lexically bound name",28:"Lexical declaration cannot appear in a single-statement context",29:"Label '%0' has already been declared",30:"%0 statement must be nested within an iteration statement",31:"Illegal continue statement: '%0' does not denote an iteration statement",32:"Undefined label '%0'",33:"More than one default clause in switch statement",34:"%0 declarations may only appear at top level of a module",35:"Async functions can only be declared at the top level or inside a block",36:"No line break is allowed after '%0'",37:"Strict mode code may not include a with statement",38:"Await is only valid in async functions",39:"Function declaration must have a name in this context",12:"Duplicate constructor method in class",40:"'%0' may not be used as an identifier in this context",43:"Delete of an unqualified identifier in strict mode",44:"Private fields can not be deleted",41:"Classes may not have a private field named '#constructor'",42:"Classes may not have a field named 'constructor'",45:"Class constructor may not be a '%0'",46:"Unexpected reserved word",47:"Unexpected eval or arguments in strict mode",48:"'await' is not a valid identifier inside an async function",49:"'yield' is not a valid identifier inside an generator function",50:"Unexpected strict mode reserved word",52:"Await expression not allowed in formal parameter",51:"Yield expression not allowed in formal parameter",53:"new.target only allowed within functions",54:"super() is not allowed in this context",55:"Member access from super not allowed in this context",56:'Only "(" or "." or "[" are allowed after \'super\'',57:"'yield' is a reserved keyword within generator function bodies",58:"Only one underscore is allowed as numeric separator",59:"Numeric separators are not allowed at the end of numeric literals",60:"Numeric separator can not be used after leading 0.",61:"Legacy octal literals are not allowed in strict mode",62:"Invalid left-hand side in assignment",63:"Property name __proto__ appears more than once in object literal",64:"Illegal 'use strict' directive in function with non-simple parameter list",65:"Classes may not have a static property named 'prototype'",66:"%0 functions must have %1 argument%2",67:"Setter function argument must not be a rest parameter",68:"%0 increment/decrement may not have eval or arguments operand in strict mode",69:"Elision not allowed in object property list",70:"Rest element must be last element",72:"Spread element must be last element",71:"Rest parameter may not have a default initializer",73:"Invalid destructuring assignment target",74:"Unexpected surrogate pair",75:"Malformed %0 character escape sequence",76:"Template literals may not contain octal escape sequences",77:"Invalid binding pattern",78:"Rest parameter must be last formal parameter",79:"Missing catch or finally after try",80:"Illegal newline after throw",81:"Duplicate parameter name not allowed in this context",82:"Missing keyword 'as' after import *",83:"Labels must be followed by a ':'",84:"JSX attributes must only be assigned a non-empty 'expression'",85:"Expected corresponding JSX closing tag for %0",86:"Adjacent JSX elements must be wrapped in an enclosing tag",87:"Invalid JSX attribute value",88:"Rest element may not have a trailing comma",89:"Undefined Unicode code-point",90:"HTML comments are not allowed in modules",91:"Invalid shorthand property initializer",92:"Trailing decorator may be followed by method",93:"Decorators can't be used with a constructor",94:"`...` must be followed by an identifier in declaration contexts"});function rn(e,t,n,r,o,a){const s=new SyntaxError(`Line ${r}, column ${o}: ${a}`);if(s.index=n,s.line=r,s.column=o,s.description=a,!(t&ct.OptionsTolerant))throw s;e.errors.push(s)}function on(e){let{index:t,startLine:n,startColumn:r}=e;const o=e.errorLocation;return o&&(t=o.index,n=o.line,r=o.column),{index:t,line:n,column:r}}function an(e,t,...n){const{index:r,line:o,column:a}=on(e),s=nn[t].replace(/%(\d+)/g,(e,t)=>n[t]);rn(e,ct.Empty,r,o,a,s)}function sn(e,t,n,...r){const{index:o,line:a,column:s}=on(e);rn(e,t,o,a,s,nn[n].replace(/%(\d+)/g,(e,t)=>r[t]))}function cn(e,t){const n=Vt(e);let r=[];t&ct.OptionsExperimental&&(r=it(e,t)),bt(e,t|ct.DisallowEscapedKeyword,33566797);const o=t&ct.RequireIdentifier&&33685505!==e.token?null:U(e,t|ct.Strict|ct.DisallowEscapedKeyword);let a=wt.None,s=null;vt(e,t,12372)&&(s=Ce(e,t|ct.Strict,n),a|=wt.Heritage);const i=_e(e,t&~ct.RequireIdentifier|ct.Strict|ct.InClass,a);return It(t,e,n,t&ct.OptionsExperimental?{type:"ClassDeclaration",id:o,superClass:s,body:i,decorators:r}:{type:"ClassDeclaration",id:o,superClass:s,body:i})}function ln(e,t){const n=Vt(e);bt(e,t,33566808);let r=ft.None;return vt(e,t,167774771)&&(t&ct.AllowSingleStatement&&!(t&ct.InFunctionBody)&&sn(e,t,22),r=ft.Generator),un(e,t,r,n)}function un(e,t,n,r){const{token:o}=e;let a=null;t&ct.Yield&&1073741824&o&&sn(e,t,49),t&ct.Async&&262144&o&&sn(e,t,48),50331659!==o?a=U(e,t):t&ct.RequireIdentifier||sn(e,t,39);const{params:s,body:i}=Rt(e,t&~(ct.Method|ct.AllowSuperProperty|ct.RequireIdentifier),n,je);return It(t,e,r,{type:"FunctionDeclaration",params:s,body:i,async:!!(n&ft.Await),generator:!!(n&ft.Generator),expression:!1,id:a})}function dn(e,t){const n=Vt(e);bt(e,t,594028),bt(e,t,33566808);const r=ft.Await;return un(e,t,(vt(e,t,167774771)?ft.Generator:ft.None)|r,n)}function pn(e,t,r){const o=Vt(e),a=0!=(8388608&e.token),s=q(e,t);let i=null;return vt(e,t|ct.DisallowEscapedKeyword,83886109)?(i=Lt(e,t&~(ct.BlockScope|ct.ForStatement),Ee),tn(e.token)&&(t&ct.ForStatement||a)&&(167786289===e.token?(t&(ct.BlockScope|ct.Strict|ct.Async)||a)&&sn(e,t,25,n(e.token)):sn(e,t,25,n(e.token)))):tn(e.token)||!r&&!a||sn(e,t,24,r?"const":"destructuring"),It(t,e,o,{type:"VariableDeclarator",init:i,id:s})}function fn(e,t,r){const o=[pn(e,t,r)];for(;vt(e,t,16777234);)o.push(pn(e,t,r));return t&ct.ForStatement&&tn(e.token)&&1!==o.length&&sn(e,t,26,n(e.token)),o}function mn(e,t){switch(e.token){case 33566808:return ln(e,t);case 120:case 33566797:return cn(e,t);case 33574984:return function(e,t,n=!0){return Ft(e,t,Jt)?Bn(e,t|ct.BlockScope,n):Cn(e,t)}(e,t|ct.AllowIn);case 33566793:return Bn(e,t|ct.BlockScope|ct.AllowIn);case 594028:return function(e,t){return Ft(e,t,Yt)?dn(e,t):gn(e,t)}(e,t);case 33566810:if(t&ct.OptionsNext&&Ft(e,t,Xt))return bn(e,t|ct.AllowIn);case 12371:t&ct.Module&&sn(e,t,34,n(e.token));default:return gn(e,t|ct.AllowSingleStatement)}}function gn(e,t){switch(e.token){case 33566791:return Bn(e,t|ct.AllowIn);case 17825809:return xn(e,t);case 33566814:return Hn(e,t);case 41943052:return Ln(e,t);case 12380:return Dn(e,t);case 12377:return wn(e,t);case 12369:return On(e,t);case 12386:return Nn(e,t);case 12387:return Pn(e,t);case 12362:return Sn(e,t);case 12366:return kn(e,t);case 12367:return hn(e,t);case 302002272:return In(e,t);case 12385:return An(e,t|ct.DisallowEscapedKeyword);case 12374:return function(e,t){const n=Vt(e);bt(e,t,12374);const r=!!(t&ct.Async&&vt(e,t,34017389));bt(e,t|ct.DisallowEscapedKeyword,50331659);const{token:o}=e;let a,s=null,i=null,c=null,l="ForStatement",u=null,d=null;33566793===o||33574984===o&&Ft(e,t,Jt)?c=Bn(e,t&~ct.AllowIn|ct.BlockScope,!1):33566791===o?c=Bn(e,t&~ct.AllowIn,!1):17825809!==o&&(i=Vt(e),s=Dt(e,t&~ct.AllowIn|ct.DisallowEscapedKeyword,Ee));vt(e,t,69746)?(l="ForOfStatement",s?(e.flags<.AllowDestructuring&&"AssignmentExpression"!==s.type||sn(e,t,73),Ht(e,t,s)):s=c,a=Ee(e,t|ct.AllowIn)):vt(e,t,167786289)?(s?(e.flags<.AllowDestructuring||sn(e,t,73),Ht(e,t,s)):s=c,l="ForInStatement",a=he(e,t&~ct.AllowDecorator|ct.AllowIn)):(16777234===e.token&&(s=Ae(e,t,s,i)),c&&(s=c),bt(e,t,17825809),u=17825809!==e.token?he(e,t&~ct.AllowDecorator|ct.AllowIn):null,bt(e,t,17825809),d=16!==e.token?he(e,t&~ct.AllowDecorator|ct.AllowIn):null);bt(e,t,16);const p=Rn(e,t);return It(t,e,n,"ForOfStatement"===l?{type:l,body:p,left:s,right:a,await:r}:a?{type:l,body:p,left:s,right:a}:{type:l,body:p,init:s,test:u,update:d})}(e,t|ct.ForStatement);case 594028:return Ft(e,t,Yt)&&sn(e,t,35),Cn(e,t|ct.AllowSingleStatement);case 33566808:sn(e,t,t&ct.Strict?19:20);case 33566797:sn(e,t,21,n(e.token));default:return Cn(e,t)}}function xn(e,t){const n=Vt(e);return Ct(e,t),It(t,e,n,{type:"EmptyStatement"})}function kn(e,t){const r=Vt(e);Ct(e,t),e.flags&(lt.InSwitchStatement|lt.InIterationStatement)||sn(e,t,30,n(e.token));let o=null;if(!(e.flags<.NewLine)&&135168&e.token){const{tokenValue:n}=e;o=Re(e,t),yt(e,t,n,!0)}return Nt(e,t),It(t,e,r,{type:"ContinueStatement",label:o})}function Sn(e,t){const n=Vt(e);Ct(e,t);let r=null;if(!(e.flags<.NewLine)&&135168&e.token){const{tokenValue:n}=e;r=Re(e,t),yt(e,t,n,!1)}else e.flags&(lt.InSwitchStatement|lt.InIterationStatement)||sn(e,t,30,"break");return Nt(e,t),It(t,e,n,{type:"BreakStatement",label:r})}function wn(e,t){const n=Vt(e);Ct(e,t),bt(e,t,50331659);const r=he(e,t&~ct.AllowDecorator|ct.AllowIn);return bt(e,t,16),It(t,e,n,{type:"IfStatement",test:r,consequent:yn(e,t|ct.DisallowEscapedKeyword),alternate:vt(e,t,12370)?yn(e,t):null})}function yn(e,t){return t&ct.Strict||33566808!==e.token?gn(e,t&~ct.AllowSingleStatement):ln(e,t)}function hn(e,t){const n=Vt(e);return Ct(e,t),Nt(e,t),It(t,e,n,{type:"DebuggerStatement"})}function An(e,t){const n=Vt(e);Ct(e,t);const r=Ln(e,t),o=12364===e.token?En(e,t):null,a=vt(e,t,12373)?Ln(e,t):null;return o||a||sn(e,t,79),It(t,e,n,{type:"TryStatement",block:r,handler:o,finalizer:a})}function En(e,t){const n=Vt(e);Ct(e,t);let r=null;if(vt(e,t,50331659)){const n=[];r=q(e,t,n),Pt(e,t,n),bt(e,t,16)}return It(t,e,n,{type:"CatchClause",param:r,body:Ln(e,t)})}function In(e,t){const n=Vt(e);Ct(e,t),e.flags<.NewLine&&sn(e,t,80);const r=he(e,t&~ct.AllowDecorator|ct.AllowIn);return Nt(e,t),It(t,e,n,{type:"ThrowStatement",argument:r})}function bn(e,t){const n=Vt(e),r=he(e,t&~ct.AllowDecorator|ct.AllowIn);return Nt(e,t),It(t,e,n,{type:"ExpressionStatement",expression:r})}function vn(e,t){const n=Vt(e),r=e.tokenRaw.slice(1,-1),o=he(e,t&~ct.AllowDecorator|ct.AllowIn);return Nt(e,t),It(t,e,n,{type:"ExpressionStatement",expression:o,directive:r})}function Cn(e,t){const n=Vt(e),{tokenValue:r,token:o}=e,a=he(e,t&~(ct.AllowSingleStatement|ct.AllowDecorator)|ct.AllowIn);if(135168&o&&16777237===e.token){t&ct.Yield&&1073741824&o&&sn(e,t,57),bt(e,t,16777237,83),Et(e,r)&&sn(e,t,29,r),ht(e,r);const s=!(t&ct.Strict)&&t&ct.AllowSingleStatement&&33566808===e.token?ln(e,t):gn(e,t);return At(e,r),It(t,e,n,{type:"LabeledStatement",label:a,body:s})}return Nt(e,t),It(t,e,n,{type:"ExpressionStatement",expression:a})}function On(e,t){const n=Vt(e);Ct(e,t);const r=Rn(e,t);bt(e,t,12386),bt(e,t,50331659);const o=he(e,t&~ct.AllowDecorator|ct.AllowIn);return bt(e,t,16),vt(e,t,17825809),It(t,e,n,{type:"DoWhileStatement",body:r,test:o})}function Nn(e,t){const n=Vt(e);Ct(e,t),bt(e,t,50331659);const r=he(e,t&~ct.AllowDecorator|ct.AllowIn);return bt(e,t,16),It(t,e,n,{type:"WhileStatement",test:r,body:Rn(e,t)})}function Ln(e,t){const n=Vt(e),r=[];for(bt(e,t,41943052);17825807!==e.token;)r.push(mn(e,t));return bt(e,t,17825807),It(t,e,n,{type:"BlockStatement",body:r})}function Dn(e,t){const n=Vt(e);t&(ct.OptionsGlobalReturn|ct.InFunctionBody)||sn(e,t,18),e.flags<.EscapedKeyword&&sn(e,t,3),Ct(e,t);const r=1048576&e.token||e.flags<.NewLine?null:he(e,t&~(ct.InFunctionBody|ct.AllowDecorator)|ct.AllowIn);return Nt(e,t),It(t,e,n,{type:"ReturnStatement",argument:r})}function Rn(e,t){const n=e.flags;e.flags|=lt.InIterationStatement|lt.AllowDestructuring;const r=gn(e,t&~ct.AllowSingleStatement|ct.DisallowEscapedKeyword);return e.flags=n,r}function Pn(e,t){t&ct.Strict&&sn(e,t,37);const n=Vt(e);Ct(e,t),bt(e,t,50331659);const r=he(e,t&~ct.AllowDecorator|ct.AllowIn);return bt(e,t,16),It(t,e,n,{type:"WithStatement",object:r,body:gn(e,t&~ct.AllowSingleStatement)})}function Hn(e,t){const n=Vt(e);Ct(e,t),bt(e,t,50331659);const r=he(e,t&~ct.AllowDecorator|ct.AllowIn);bt(e,t,16),bt(e,t|ct.DisallowEscapedKeyword,41943052);const o=[],a=e.flags;e.flags|=lt.InSwitchStatement;let s=!1;for(;17825807!==e.token;){const n=Fn(e,t);o.push(n),null===n.test&&(s&&sn(e,t,33),s=!0)}return e.flags=a,bt(e,t,17825807),It(t,e,n,{type:"SwitchStatement",discriminant:r,cases:o})}function Fn(e,t){const n=Vt(e);let r=null;vt(e,t,12363)?r=he(e,t&~ct.AllowDecorator|ct.AllowIn):bt(e,t,12368),bt(e,t,16777237);const o=[];for(;!Tt(e);)o.push(mn(e,t|ct.AllowIn));return It(t,e,n,{type:"SwitchCase",test:r,consequent:o})}function Bn(e,t,r=!0){const o=Vt(e),{token:a}=e,s=33566793===a;Ct(e,t);const i=fn(e,t,s);return r&&Nt(e,t),It(t,e,o,{type:"VariableDeclaration",kind:n(a),declarations:i})}function Vn(e,t){Ct(e,t);const n=[];for(;1048576!==e.token;)n.push(33554435===e.token?vn(e,t):Mn(e,t|ct.AllowIn));return n}function Mn(e,t){switch(e.token){case 120:return it(e,t);case 12371:return Jn(e,t);case 33566810:if(!(t&ct.OptionsNext&&Ft(e,t,Xt)))return Xn(e,t);default:return mn(e,t)}}function Jn(e,t){const r=Vt(e),o=[];let a=null,s=null;switch(bt(e,t|ct.DisallowEscapedKeyword,12371),e.token){case 167774771:return function(e,t,n){bt(e,t,167774771);const r=qn(e,t);return Nt(e,t),It(t,e,n,{type:"ExportAllDeclaration",source:r})}(e,t,r);case 12368:return function(e,t,n){let r;switch(bt(e,t|ct.DisallowEscapedKeyword,12368),e.token){case 33566808:r=ln(e,t|ct.RequireIdentifier);break;case 120:case 33566797:r=cn(e,t&~ct.AllowIn|ct.RequireIdentifier);break;case 594028:r=function(e,t){return Ft(e,t,Yt)?dn(e,t|ct.RequireIdentifier):Ee(e,t|ct.AllowIn)}(e,t|ct.RequireIdentifier);break;default:r=Ee(e,t|ct.AllowIn),Nt(e,t)}return It(t,e,n,{type:"ExportDefaultDeclaration",declaration:r})}(e,t,r);case 41943052:{bt(e,t,41943052);let n=!1;for(;17825807!==e.token;)69743!==e.token&&12288&e.token&&(n=!0,$t(e)),o.push(Tn(e,t)),17825807!==e.token&&bt(e,t,16777234);bt(e,t|ct.DisallowEscapedKeyword,17825807),69745===e.token?a=qn(e,t):n&&sn(e,t,46),Nt(e,t);break}case 33566797:s=cn(e,t);break;case 33574984:case 33566793:s=Bn(e,t|ct.BlockScope);break;case 33566791:s=Bn(e,t);break;case 33566808:s=ln(e,t);break;case 594028:if(Ft(e,t,Yt)){s=dn(e,t);break}default:an(e,1,n(e.token))}return It(t,e,r,{type:"ExportNamedDeclaration",source:a,specifiers:o,declaration:s})}function Tn(e,t){const n=Vt(e),r=Fe(e,t|ct.DisallowEscapedKeyword,e.token);return It(t,e,n,{type:"ExportSpecifier",local:r,exported:vt(e,t,167843947)?Fe(e,t,e.token):r})}function Xn(e,t){const r=Vt(e);let o;bt(e,t,33566810);let a=[];return 33554435===e.token?o=Pe(e,t):(a=function(e,t){const r=[];switch(e.token){case 33685505:if(r.push(function(e,t){return It(t,e,Vt(e),{type:"ImportDefaultSpecifier",local:Re(e,t)})}(e,t)),vt(e,t,16777234))switch(e.token){case 167774771:Yn(e,t,r);break;case 41943052:Gn(e,t,r);break;default:sn(e,t,1,n(e.token))}break;case 41943052:Gn(e,t,r);break;case 167774771:Yn(e,t,r);break;default:an(e,1,n(e.token))}return r}(e,t|ct.DisallowEscapedKeyword),o=qn(e,t)),Nt(e,t),It(t,e,r,{type:"ImportDeclaration",specifiers:a,source:o})}function Gn(e,t,n){for(bt(e,t,41943052);17825807!==e.token;)n.push(Kn(e,t)),17825807!==e.token&&bt(e,t,16777234);bt(e,t,17825807)}function Kn(e,t){const n=Vt(e),{token:r}=e,o=Fe(e,t|ct.DisallowEscapedKeyword,r);let a;return vt(e,t,167843947)?a=U(e,t):(Ot(r,12288)&&sn(e,t,46),Ot(r,4194304)&&sn(e,t,47),a=o),It(t,e,n,{type:"ImportSpecifier",local:a,imported:o})}function Yn(e,t,n){const r=Vt(e);bt(e,t,167774771),bt(e,t,167843947,82);const o=U(e,t);n.push(It(t,e,r,{type:"ImportNamespaceSpecifier",local:o}))}function qn(e,t){return bt(e,t,69745),33554435!==e.token&&an(e,1,n(e.token)),Pe(e,t)}function Un(e,t){return{source:e,length:e.length,index:0,line:1,column:0,startIndex:0,startColumn:0,startLine:1,lastIndex:0,lastColumn:0,lastLine:0,pendingExpressionError:void 0,flags:lt.AllowDestructuring,token:1048576,tokenRaw:"",lastValue:0,comments:[],sourceFile:t,tokenRegExp:void 0,tokenValue:void 0,labelSet:void 0,errorLocation:void 0,errors:[]}}function jn(e,t,n){let r="";t&&(t.module&&(n|=ct.Module),t.next&&(n|=ct.OptionsNext),t.jsx&&(n|=ct.OptionsJSX),t.ranges&&(n|=ct.OptionsRanges),t.loc&&(n|=ct.OptionsLoc),t.raw&&(n|=ct.OptionsRaw),t.rawIdentifier&&(n|=ct.OptionsRawidentifiers),t.globalReturn&&(n|=ct.OptionsGlobalReturn),t.skipShebang&&(n|=ct.OptionsShebang),t.tolerant&&(n|=ct.OptionsTolerant),t.source&&(r=t.source),t.comments&&(n|=ct.OptionsComments),t.impliedStrict&&(n|=ct.Strict),t.experimental&&(n|=ct.OptionsExperimental),t.node&&(n|=ct.OptionsNode));const o=Un(e,r),a=n&ct.Module?Vn(o,n):$n(o,n),s={type:"Program",sourceType:n&ct.Module?"module":"script",body:a};return n&ct.LocationTracker&&(n&ct.OptionsRanges&&(s.start=0,s.end=e.length),n&ct.OptionsLoc&&(s.loc={start:{line:1,column:0},end:{line:o.line,column:o.column}},r&&(s.loc.source=r))),n&ct.OptionsComments&&(s.comments=o.comments),n&ct.OptionsTolerant&&(s.errors=o.errors),s}function $n(e,t){const n=[];let r=!0;for(Ct(e,t|ct.DisallowEscapedKeyword);1048576!==e.token;)r&&33554435!==e.token&&(r=!1),r?(t&ct.Strict||12!==e.tokenRaw.length||"use strict"!==e.tokenValue||(t|=ct.Strict),n.push(vn(e,t))):n.push(mn(e,t));return n}function zn(e,t){return t&&t.module?_n(e,t):Wn(e,t)}function Wn(e,t){return jn(e,t,ct.Empty)}function _n(e,t){return jn(e,t,ct.Strict|ct.Module)}e("ESTree",Object.freeze({})),e("Scanner",Object.freeze({scanIdentifier:B,scanMaybeIdentifier:V,scanHexIntegerLiteral:C,scanOctalOrBinary:O,scanImplicitOctalDigits:N,scanSignedInteger:L,scanNumericLiteral:D,scanNumericSeparator:R,scanDecimalDigitsOrSeparator:P,scanDecimalAsSmi:H,scanRegularExpression:Y,scan:K,scanEscapeSequence:h,throwStringError:A,scanString:E,consumeTemplateBrace:I,scanTemplate:b,skipSingleHTMLComment:J,skipSingleLineComment:T,skipMultiLineComment:X,addComment:G,nextUnicodeChar:u,isIdentifierPart:d,escapeInvalidCharacters:p,consumeOpt:f,consumeLineFeed:m,scanPrivateName:g,advanceNewline:x,fromCodePoint:k,readNext:S,toHex:w,advanceOnMaybeAstral:y}));e("Parser",Object.freeze({parseClassDeclaration:cn,parseFunctionDeclaration:ln,parseAsyncFunctionOrAsyncGeneratorDeclaration:dn,parseVariableDeclarationList:fn,parseExpression:he,parseSequenceExpression:Ae,parseAssignmentExpression:Ee,parseRestElement:be,parseLeftHandSideExpression:Ce,parsePrimaryExpression:De,parseIdentifier:Re,parseLiteral:Pe,parseBigIntLiteral:He,parseIdentifierName:Fe,parseFunctionExpression:Me,parseAsyncFunctionOrAsyncGeneratorExpression:Je,parsePropertyName:Te,parseObjectLiteral:Ge,parseFormalListAndBody:je,parseFunctionBody:$e,parseFormalParameters:ze,parseFormalParameterList:We,parseClassBodyAndElementList:_e,parseClassElement:Qe,parseDecorators:it,parseModuleItemList:Vn,parseModuleItem:Mn,parseExportDeclaration:Jn,parseImportDeclaration:Xn,createParser:Un,parseSource:jn,parseStatementList:$n,parse:zn,parseScript:Wn,parseModule:_n,parseBindingIdentifierOrPattern:q,parseBindingIdentifier:U,parseAssignmentRestElement:j,parseAssignmentPattern:z,parseBindingInitializer:W,parseStatementListItem:mn,parseStatement:gn,parseEmptyStatement:xn,parseContinueStatement:kn,parseBreakStatement:Sn,parseIfStatement:wn,parseDebuggerStatement:hn,parseTryStatement:An,parseCatchBlock:En,parseThrowStatement:In,parseExpressionStatement:bn,parseDirective:vn,parseExpressionOrLabelledStatement:Cn,parseDoWhileStatement:On,parseWhileStatement:Nn,parseBlockStatement:Ln,parseReturnStatement:Dn,parseIterationStatement:Rn,parseWithStatement:Pn,parseSwitchStatement:Hn,parseCaseOrDefaultClauses:Fn,parseVariableStatement:Bn,parseJSXRootElement:Q,parseJSXOpeningElement:Z,nextJSXToken:ee,scanJSXToken:te,parseJSXText:re,parseJSXAttributes:ae,parseJSXSpreadAttribute:se,parseJSXNamespacedName:ie,parseJSXAttributeName:ce,parseJSXAttribute:ue,parseJSXEmptyExpression:de,parseJSXSpreadChild:pe,parseJSXExpressionContainer:fe,parseJSXExpression:me,parseJSXClosingFragment:ge,parseJSXClosingElement:xe,parseJSXIdentifier:ke,parseJSXMemberExpression:Se,parseJSXElementName:we,scanJSXIdentifier:ye})),e("version","1.6.9")}}}); |