From d25e11bee6ca5ca523884da132d18e1400e077b9 Mon Sep 17 00:00:00 2001 From: Minteck Date: Tue, 24 Aug 2021 14:41:48 +0200 Subject: Initial commit --- node_modules/cherow/dist/system/cherow.js | 7346 +++++++++++++++++++++++++ node_modules/cherow/dist/system/cherow.min.js | 1 + 2 files changed, 7347 insertions(+) create mode 100644 node_modules/cherow/dist/system/cherow.js create mode 100644 node_modules/cherow/dist/system/cherow.min.js (limited to 'node_modules/cherow/dist/system') 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 */; + } + } + // `<`, `<=`, `<<`, `<<=`, `= 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 ''', 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=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=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;n55)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=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=55296&&n<=56319){n=(1023&n)<<10|1023&e.source.charCodeAt(t+1)|65536}if(!d(n))break e;y(e,n)}}r=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=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.index128)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)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.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)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&&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");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{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;rn[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")}}}); -- cgit