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/commonjs/cherow.js | 7317 +++++++++++++++++++++++ node_modules/cherow/dist/commonjs/cherow.min.js | 1 + 2 files changed, 7318 insertions(+) create mode 100644 node_modules/cherow/dist/commonjs/cherow.js create mode 100644 node_modules/cherow/dist/commonjs/cherow.min.js (limited to 'node_modules/cherow/dist/commonjs') diff --git a/node_modules/cherow/dist/commonjs/cherow.js b/node_modules/cherow/dist/commonjs/cherow.js new file mode 100644 index 0000000..6de1842 --- /dev/null +++ b/node_modules/cherow/dist/commonjs/cherow.js @@ -0,0 +1,7317 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +// 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 = [ + 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 |= exports.Flags.NewLine; + parser.index++; + if ((state & exports.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 & exports.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 |= exports.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 exports.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 & exports.Context.Strict) + return exports.Escape.StrictOctal; + parser.flags |= exports.Flags.HasOctal; + } + } + else if (context & exports.Context.Strict) { + return exports.Escape.StrictOctal; + } + else { + parser.flags |= exports.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 & exports.Context.Strict) + return exports.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 exports.Escape.EightOrNine; + // ASCII escapes + case 120 /* LowerX */: + { + const ch1 = parser.lastValue = readNext(parser); + const hi = toHex(ch1); + if (hi < 0) + return exports.Escape.InvalidHex; + const ch2 = parser.lastValue = readNext(parser); + const lo = toHex(ch2); + if (lo < 0) + return exports.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 exports.Escape.InvalidHex; + ch = parser.lastValue = readNext(parser); + while (ch !== 125 /* RightBrace */) { + const digit = toHex(ch); + if (digit < 0) + return exports.Escape.InvalidHex; + code = code * 16 + digit; + // Code point out of bounds + if (code > 1114111 /* NonBMPMax */) + return exports.Escape.OutOfRange; + ch = parser.lastValue = readNext(parser); + } + return code; + } + else { + // \uNNNN + let codePoint = toHex(ch); + if (codePoint < 0) + return exports.Escape.InvalidHex; + for (let i = 0; i < 3; i++) { + ch = parser.lastValue = readNext(parser); + const digit = toHex(ch); + if (digit < 0) + return exports.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 exports.Escape.Empty: + return; + case exports.Escape.StrictOctal: + report(parser, context & exports.Context.TaggedTemplate ? + 76 /* TemplateOctalLiteral */ : + 11 /* StrictOctalEscape */); + case exports.Escape.EightOrNine: + report(parser, 13 /* InvalidEightAndNine */); + case exports.Escape.InvalidHex: + report(parser, 75 /* MalformedEscape */, 'hexadecimal'); + case exports.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 | exports.Context.Strict, ch); + if (code >= 0) { + ret += fromCodePoint(code); + } + else if (code !== exports.Escape.Empty && context & exports.Context.TaggedTemplate) { + ret = undefined; + ch = scanLooserTemplateSegment(parser, parser.lastValue); + if (ch < 0) { + tail = false; + } + break loop; + } + else { + throwStringError(parser, context | exports.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 = exports.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 & exports.Context.OptionsNext && next === 95 /* Underscore */) { + state = scanNumericSeparator(parser, state); + continue; + } + state &= ~exports.NumericState.SeenSeparator; + const digit = toHex(next); + if (digit < 0) + break; + value = value * 16 + digit; + parser.index++; + parser.column++; + } + if (state & exports.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 = exports.NumericState.None; + while (parser.index < parser.length) { + ch = parser.source.charCodeAt(parser.index); + if (context & exports.Context.OptionsNext && ch === 95 /* Underscore */) { + state = scanNumericSeparator(parser, state); + continue; + } + state &= ~exports.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 & exports.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 & exports.Context.Strict) + report(parser, 0 /* Unexpected */); + let index = parser.index; + let column = parser.column; + let code = 0; + parser.flags |= exports.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 |= exports.Flags.HasOctal; + default: + if (context & exports.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 = exports.NumericState.None) { + let value = state & exports.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 & exports.Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) { + report(parser, 60 /* ZeroDigitNumericSeparator */); + } + state |= exports.NumericState.Float; + value = `${value}.${scanDecimalDigitsOrSeparator(parser)}`; + } + const end = parser.index; + if (consumeOpt(parser, 110 /* LowerN */)) { + if (state & exports.NumericState.Float) + report(parser, 0 /* Unexpected */); + state |= exports.NumericState.BigInt; + } + if (consumeOpt(parser, 101 /* LowerE */) || consumeOpt(parser, 69 /* UpperE */)) { + state |= exports.NumericState.Float; + value += scanSignedInteger(parser, end); + } + if (isValidIdentifierStart(parser.source.charCodeAt(parser.index))) { + report(parser, 0 /* Unexpected */); + } + return assembleNumericLiteral(parser, context, state & exports.NumericState.Float ? parseFloat(value) : parseInt(value, 10), !!(state & exports.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 & exports.NumericState.SeenSeparator) + report(parser, 59 /* TrailingNumericSeparator */); + state |= exports.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 = exports.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 & ~exports.NumericState.SeenSeparator; + parser.index++; + parser.column++; + break; + default: + break loop; + } + } + if (state & exports.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 = exports.NumericState.None; + let value = 0; + let next = parser.source.charCodeAt(parser.index); + while (next >= 48 /* Zero */ && next <= 57 /* Nine */ || next === 95 /* Underscore */) { + if (context & exports.Context.OptionsNext && next === 95 /* Underscore */) { + state = scanNumericSeparator(parser, state); + next = parser.source.charCodeAt(parser.index); + continue; + } + state &= ~exports.NumericState.SeenSeparator; + value = value * 10 + (next - 48 /* Zero */); + parser.index++; + parser.column++; + next = parser.source.charCodeAt(parser.index); + } + if (state & exports.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 & exports.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 & exports.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 |= exports.Flags.EscapedKeyword; + } + return token; + } + } + if (context & exports.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 & exports.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 & exports.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 | exports.ScannerState.NewLine; + case 10 /* LineFeed */: + case 8232 /* LineSeparator */: + case 8233 /* ParagraphSeparator */: + advanceNewline(parser); + if (collectable) + addComment(parser, context, type, start); + return state | exports.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 & exports.Context.OptionsComments); + while (parser.index < parser.length) { + switch (parser.source.charCodeAt(parser.index)) { + case 42 /* Asterisk */: + parser.index++; + parser.column++; + state &= ~exports.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 |= exports.ScannerState.NewLine | exports.ScannerState.LastIsCR; + advanceNewline(parser); + break; + case 10 /* LineFeed */: + consumeLineFeed(parser, state); + state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine; + break; + case 8232 /* LineSeparator */: + case 8233 /* ParagraphSeparator */: + state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine; + advanceNewline(parser); + break; + default: + state &= ~exports.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 & exports.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 &= ~exports.Flags.NewLine | exports.Flags.EscapedKeyword; + const lineStart = parser.index === 0; + let state = exports.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 & ~exports.ScannerState.LastIsCR | exports.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 |= exports.ScannerState.NewLine | exports.ScannerState.LastIsCR; + advanceNewline(parser); + break; + case 10 /* LineFeed */: + consumeLineFeed(parser, state); + state = state & ~exports.ScannerState.LastIsCR | exports.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 & exports.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 & exports.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, exports.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 & exports.Context.OptionsShebang && + lineStart && + next === 33 /* Exclamation */) { + parser.index = index + 1; + skipSingleLineComment(parser, context, exports.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 = exports.RegexState.Empty; + loop: while (true) { + const ch = parser.source.charCodeAt(parser.index); + parser.index++; + parser.column++; + if (preparseState & exports.RegexState.Escape) { + preparseState &= ~exports.RegexState.Escape; + } + else { + switch (ch) { + case 47 /* Slash */: + if (!preparseState) + break loop; + else + break; + case 92 /* Backslash */: + preparseState |= exports.RegexState.Escape; + break; + case 91 /* LeftBracket */: + preparseState |= exports.RegexState.Class; + break; + case 93 /* RightBracket */: + preparseState &= exports.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 = exports.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 & exports.RegexFlags.Global) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'g'); + mask |= exports.RegexFlags.Global; + break; + case 105 /* LowerI */: + if (mask & exports.RegexFlags.IgnoreCase) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'i'); + mask |= exports.RegexFlags.IgnoreCase; + break; + case 109 /* LowerM */: + if (mask & exports.RegexFlags.Multiline) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'm'); + mask |= exports.RegexFlags.Multiline; + break; + case 117 /* LowerU */: + if (mask & exports.RegexFlags.Unicode) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'u'); + mask |= exports.RegexFlags.Unicode; + break; + case 121 /* LowerY */: + if (mask & exports.RegexFlags.Sticky) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'y'); + mask |= exports.RegexFlags.Sticky; + break; + case 115 /* LowerS */: + if (mask & exports.RegexFlags.DotAll) + tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 's'); + mask |= exports.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 & exports.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 & exports.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 & (exports.Context.Async | exports.Context.Module))) { + tolerant(parser, context, 48 /* AwaitBindingIdentifier */); + } + else if (token & 1073741824 /* IsYield */ && (context & (exports.Context.Yield | exports.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 & exports.Context.Strict) + tolerant(parser, context, 17 /* StrictLHSAssignment */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + else if (context & exports.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 & exports.Context.Strict) + tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token)); + parser.flags |= exports.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 | exports.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 | exports.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 | exports.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 & exports.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 & exports.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 & exports.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 & ~exports.Context.InJSXChild); + case 167774015 /* LessThan */: + return parseJSXRootElement(parser, context & ~exports.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 & ~exports.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 | exports.Context.InJSXChild); + case 167774015 /* LessThan */: + return parseJSXRootElement(parser, context | exports.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 & exports.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 & ~exports.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 & exports.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 & exports.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 & exports.Context.InParameter) + tolerant(parser, context, 51 /* YieldInParameter */); + expect(parser, context, 1107316842 /* YieldKeyword */); + let argument = null; + let delegate = false; + if (!(parser.flags & exports.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 & exports.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 |= exports.Flags.HasStrictReserved; + } + if (token & 4194304 /* IsEvalOrArguments */) { + if (context & exports.Context.Strict) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + } + expr = [expr]; + } + return parseArrowFunction(parser, context &= ~exports.Context.Async, pos, expr); + } + if (hasBit(parser.token, 67108864 /* IsAssignOp */)) { + token = parser.token; + if (context & exports.Context.Strict && nameIsArgumentsOrEval(expr.name)) { + tolerant(parser, context, 17 /* StrictLHSAssignment */); + } + else if (consume(parser, context, 83886109 /* Assign */)) { + if (!(parser.flags & exports.Flags.AllowDestructuring)) { + tolerant(parser, context, 73 /* InvalidDestructuringTarget */); + } + // Only re-interpret if not inside a formal parameter list + if (!(context & exports.Context.InParameter)) + reinterpret(parser, context, expr); + if (context & exports.Context.InParen) + parser.flags |= exports.Flags.SimpleParameterList; + if (parser.token & 262144 /* IsAwait */) { + setPendingError(parser); + parser.flags |= exports.Flags.HasAwait; + } + else if (context & exports.Context.InParen && + context & (exports.Context.Strict | exports.Context.Yield) && + parser.token & 1073741824 /* IsYield */) { + setPendingError(parser); + parser.flags |= exports.Flags.HasYield; + } + } + else { + if (!isValidSimpleAssignmentTarget(expr)) { + tolerant(parser, context, 5 /* InvalidLHSInAssignment */); + } + parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding); + nextToken(parser, context); + } + const right = parseExpressionCoverGrammar(parser, context | exports.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 & ~exports.Context.AllowDecorator | exports.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 & exports.Context.AllowIn ^ exports.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 & ~exports.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 & exports.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 & exports.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 & exports.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 & exports.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 & exports.Context.OptionsJSX && token === 167774015 /* LessThan */) { + return parseJSXRootElement(parser, context | exports.Context.InJSXChild); + } + const expression = parseLeftHandSideExpression(parser, context, pos); + if (hasBit(parser.token, 570425344 /* IsUpdateOp */) && !(parser.flags & exports.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 & exports.Context.InParen && parser.token & 262144 /* IsAwait */) + parser.flags |= exports.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 | exports.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 & exports.Context.OptionsNext && parser.token === 33566810 /* ImportKeyword */ + ? parseCallImportOrMetaProperty(parser, context | exports.Context.AllowIn) + : parseMemberExpression(parser, context | exports.Context.AllowIn, pos); + return parseCallExpression(parser, context | exports.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 & ~exports.Flags.AllowBinding | exports.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 & ~exports.Flags.AllowBinding | exports.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 | exports.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 & ~exports.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 | exports.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, exports.ModifierState.Await, pos, [parseAndClassifyIdentifier(parser, context)]); + } + if (parser.flags & exports.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, exports.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 & exports.Context.Yield && hasBit(parser.token, 1073741824 /* IsYield */)) { + parser.flags |= exports.Flags.HasYield; + setPendingError(parser); + } + expressions.push(parseExpressionCoverGrammar(parser, context | exports.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 = exports.CoverCallState.Empty; + while (parser.token !== 16 /* RightParen */) { + if (parser.token === 14 /* Ellipsis */) { + parser.flags |= exports.Flags.SimpleParameterList; + args.push(parseSpreadElement(parser, context)); + state = exports.CoverCallState.HasSpread; + } + else { + token = parser.token; + state = validateAsyncArgumentList(parser, context, state); + args.push(restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression)); + } + if (consume(parser, context, 16777234 /* Comma */)) { + parser.flags &= ~exports.Flags.AllowDestructuring; + if (state & exports.CoverCallState.HasSpread) + state = exports.CoverCallState.SeenSpread; + } + if (parser.token === 16 /* RightParen */) + break; + } + expect(parser, context, 16 /* RightParen */); + if (parser.token === 10 /* Arrow */) { + if (state & exports.CoverCallState.SeenSpread) { + tolerant(parser, context, 78 /* ParamAfterRest */); + } + else if (state & exports.CoverCallState.EvalOrArguments) { + if (context & exports.Context.Strict) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + else if (state & exports.CoverCallState.Yield) { + if (context & exports.Context.Strict) + tolerant(parser, context, 51 /* YieldInParameter */); + parser.flags |= exports.Flags.HasStrictReserved; + } + else if (parser.flags & exports.Flags.HasYield) { + tolerant(parser, context, 51 /* YieldInParameter */); + } + else if (state & exports.CoverCallState.Await || parser.flags & exports.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 | exports.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 & exports.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 & exports.Context.Strict) + tolerant(parser, context, 50 /* UnexpectedStrictReserved */); + const pos = getLocation(parser); + const name = parser.tokenValue; + nextToken(parser, context); + if (parser.flags & exports.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 | exports.Context.TaggedTemplate); + const node = finishNode(context, parser, pos, { + type: 'Identifier', + name, + }); + if (context & exports.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 & exports.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 & exports.Context.Strict && parser.flags & exports.Flags.HasOctal) { + tolerant(parser, context, 61 /* StrictOctalLiteral */); + } + nextToken(parser, context); + const node = finishNode(context, parser, pos, { + type: 'Literal', + value, + }); + if (context & exports.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 & exports.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 & exports.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 & exports.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 & exports.Flags.EscapedKeyword) + tolerant(parser, context, 3 /* InvalidEscapedReservedWord */); + const pos = getLocation(parser); + nextToken(parser, context | exports.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 &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding); + expect(parser, context, 16777234 /* Comma */); + } + } + else { + elements.push(restoreExpressionCoverGrammar(parser, context | exports.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 &= ~(exports.Flags.AllowDestructuring | exports.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 & ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding) | exports.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, exports.CoverParenthesizedState.None); + let expr = restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression); + // Sequence expression + if (parser.token === 16777234 /* Comma */) { + state |= exports.CoverParenthesizedState.SequenceExpression; + const expressions = [expr]; + while (consume(parser, context | exports.Context.DisallowEscapedKeyword, 16777234 /* Comma */)) { + if (parser.token === 14 /* Ellipsis */) { + if (!(parser.flags & exports.Flags.AllowBinding)) + tolerant(parser, context, 77 /* NotBindable */); + parser.flags |= exports.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 & exports.CoverParenthesizedState.HasEvalOrArguments) { + if (context & exports.Context.Strict) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + else if (state & exports.CoverParenthesizedState.HasReservedWords) { + if (context & exports.Context.Strict) + tolerant(parser, context, 50 /* UnexpectedStrictReserved */); + parser.flags |= exports.Flags.HasStrictReserved; + } + else if (!(parser.flags & exports.Flags.AllowBinding)) { + tolerant(parser, context, 77 /* NotBindable */); + } + else if (parser.flags & exports.Flags.HasYield) { + tolerant(parser, context, 51 /* YieldInParameter */); + } + else if (context & exports.Context.Async && parser.flags & exports.Flags.HasAwait) { + tolerant(parser, context, 52 /* AwaitInParameter */); + } + parser.flags &= ~(exports.Flags.AllowBinding | exports.Flags.HasAwait | exports.Flags.HasYield); + return (state & exports.CoverParenthesizedState.SequenceExpression ? expr.expressions : [expr]); + } + parser.flags &= ~(exports.Flags.HasAwait | exports.Flags.HasYield | exports.Flags.AllowBinding); + if (!isValidSimpleAssignmentTarget(expr)) + parser.flags &= ~exports.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 */) ? exports.ModifierState.Generator : exports.ModifierState.None; + let id = null; + const { token } = parser; + if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) { + if (token & 4194304 /* IsEvalOrArguments */) { + if (context & exports.Context.Strict) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + if (parser.token & 1073741824 /* IsYield */ && isGenerator & exports.ModifierState.Generator) { + tolerant(parser, context, 49 /* YieldBindingIdentifier */); + } + id = parseBindingIdentifier(parser, context); + } + const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty), isGenerator, parseFormalListAndBody); + return finishNode(context, parser, pos, { + type: 'FunctionExpression', + params, + body, + async: false, + generator: !!(isGenerator & exports.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 */) ? exports.ModifierState.Generator : exports.ModifierState.None; + const isAwait = exports.ModifierState.Await; + let id = null; + const { token } = parser; + if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) { + if (token & 4194304 /* IsEvalOrArguments */) { + if (context & exports.Context.Strict || isAwait & exports.ModifierState.Await) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictFunctionName; + } + if (token & 262144 /* IsAwait */) + tolerant(parser, context, 48 /* AwaitBindingIdentifier */); + if (parser.token & 1073741824 /* IsYield */ && isGenerator & exports.ModifierState.Generator) + tolerant(parser, context, 49 /* YieldBindingIdentifier */); + id = parseBindingIdentifier(parser, context); + } + const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty), isGenerator | isAwait, parseFormalListAndBody); + return finishNode(context, parser, pos, { + type: 'FunctionExpression', + params, + body, + async: true, + generator: !!(isGenerator & exports.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 | exports.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 &= ~exports.Flags.AllowDestructuring; + const argument = parseAssignmentExpression(parser, context | exports.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 &= ~exports.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 */) ? exports.ObjectState.Generator | exports.ObjectState.Method : exports.ObjectState.Method; + const t = parser.token; + let key = parsePropertyName(parser, context); + if (!(parser.token & 16777216 /* IsShorthandProperty */)) { + if (flags & exports.Flags.EscapedKeyword) { + tolerant(parser, context, 3 /* InvalidEscapedReservedWord */); + } + else if (!(state & exports.ObjectState.Generator) && t & 524288 /* IsAsync */ && !(parser.flags & exports.Flags.NewLine)) { + state |= consume(parser, context, 167774771 /* Multiply */) ? exports.ObjectState.Generator | exports.ObjectState.Async : exports.ObjectState.Async; + key = parsePropertyName(parser, context); + } + else if (t === 69743 /* GetKeyword */) { + state = state & ~exports.ObjectState.Method | exports.ObjectState.Getter; + key = parsePropertyName(parser, context); + } + else if (t === 69744 /* SetKeyword */) { + state = state & ~exports.ObjectState.Method | exports.ObjectState.Setter; + key = parsePropertyName(parser, context); + } + if (state & (exports.ObjectState.Getter | exports.ObjectState.Setter)) { + if (state & exports.ObjectState.Generator) + tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token)); + } + } + if (parser.token === 50331659 /* LeftParen */) { + value = parseMethodDeclaration(parser, context, state); + } + else { + state &= ~exports.ObjectState.Method; + if (parser.token === 16777237 /* Colon */) { + if ((state & (exports.ObjectState.Async | exports.ObjectState.Generator))) { + tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token)); + } + else if (t !== 41943059 /* LeftBracket */ && parser.tokenValue === '__proto__') { + if (parser.flags & exports.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 |= exports.Flags.HasProtoField; + } + expect(parser, context, 16777237 /* Colon */); + // Invalid: 'async ({a: await}) => 1' + if (parser.token & 262144 /* IsAwait */) + parser.flags |= exports.Flags.HasAwait; + value = restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression); + } + else { + if ((state & (exports.ObjectState.Generator | exports.ObjectState.Async)) || !isValidIdentifier(context, t)) { + tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(t)); + } + else if (context & (exports.Context.Strict | exports.Context.Yield) && t & 1073741824 /* IsYield */) { + setPendingError(parser); + parser.flags |= exports.Flags.HasYield; + } + state |= exports.ObjectState.Shorthand; + if (parser.token === 83886109 /* Assign */) { + if (context & exports.Context.Strict && t & 4194304 /* IsEvalOrArguments */) { + report(parser, 47 /* StrictEvalArguments */); + } + else + setPendingExpressionError(parser, 91 /* InvalidCoverInitializedName */); + expect(parser, context, 83886109 /* Assign */); + if (context & (exports.Context.Strict | exports.Context.Yield | exports.Context.Async) && parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */)) { + setPendingError(parser); + parser.flags |= parser.token & 1073741824 /* IsYield */ ? exports.Flags.HasYield : exports.Flags.HasAwait; + } + value = parseAssignmentPattern(parser, context, key, pos); + } + else { + if (t & 262144 /* IsAwait */) { + if (context & exports.Context.Async) + tolerant(parser, context, 46 /* UnexpectedReserved */); + setPendingError(parser); + parser.flags |= exports.Flags.HasAwait; + } + value = key; + } + } + } + return finishNode(context, parser, pos, { + type: 'Property', + key, + value, + kind: !(state & exports.ObjectState.Getter | state & exports.ObjectState.Setter) ? 'init' : (state & exports.ObjectState.Setter) ? 'set' : 'get', + computed: t === 41943059 /* LeftBracket */, + method: !!(state & exports.ObjectState.Method), + shorthand: !!(state & exports.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 & exports.ObjectState.Generator ? exports.ModifierState.Generator : exports.ModifierState.None; + const isAsync = state & exports.ObjectState.Async ? exports.ModifierState.Await : exports.ModifierState.None; + const { params, body } = swapContext(parser, context | exports.Context.Method, isGenerator | isAsync, parseFormalListAndBody, state); + return finishNode(context, parser, pos, { + type: 'FunctionExpression', + params, + body, + async: !!(state & exports.ObjectState.Async), + generator: !!(state & exports.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 &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding); + if (parser.flags & exports.Flags.NewLine) + tolerant(parser, context, 36 /* InvalidLineBreak */, '=>'); + expect(parser, context, 10 /* Arrow */); + return parseArrowBody(parser, context & ~exports.Context.Async, params, pos, exports.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 &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding); + if (parser.flags & exports.Flags.NewLine) + tolerant(parser, context, 36 /* InvalidLineBreak */, 'async'); + expect(parser, context, 10 /* Arrow */); + return parseArrowBody(parser, context | exports.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 | exports.Context.InParameter, params[i]); + const expression = parser.token !== 41943052 /* LeftBrace */; + const body = expression ? parseExpressionCoverGrammar(parser, context & ~(exports.Context.Yield | exports.Context.InParameter), parseAssignmentExpression) : + swapContext(parser, context & ~(exports.Context.Yield | exports.Context.AllowDecorator) | exports.Context.InFunctionBody, state, parseFunctionBody); + return finishNode(context, parser, pos, { + type: 'ArrowFunctionExpression', + body, + params, + id: null, + async: !!(state & exports.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 | exports.Context.InParameter, state); + const args = paramList.args; + const params = paramList.params; + const body = parseFunctionBody(parser, context & ~exports.Context.AllowDecorator | exports.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 | exports.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 & exports.Flags.SimpleParameterList) { + tolerant(parser, context, 64 /* IllegalUseStrict */); + } + else if (parser.flags & (exports.Flags.HasStrictReserved | exports.Flags.StrictFunctionName)) { + tolerant(parser, context, 50 /* UnexpectedStrictReserved */); + } + else if (parser.flags & exports.Flags.StrictEvalArguments) { + tolerant(parser, context, 47 /* StrictEvalArguments */); + } + context |= exports.Context.Strict; + } + } + if (context & exports.Context.Strict) { + validateParams(parser, context, params); + } + const { labelSet } = parser; + parser.labelSet = {}; + const savedFlags = parser.flags; + parser.flags = parser.flags & ~(exports.Flags.StrictFunctionName | exports.Flags.StrictEvalArguments | exports.Flags.InSwitchStatement | exports.Flags.InIterationStatement) | exports.Flags.AllowDestructuring; + while (parser.token !== 17825807 /* RightBrace */) { + body.push(parseStatementListItem(parser, context)); + } + if (savedFlags & exports.Flags.InIterationStatement) + parser.flags |= exports.Flags.InIterationStatement; + if (savedFlags & exports.Flags.InSwitchStatement) + parser.flags |= exports.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 &= ~(exports.Flags.SimpleParameterList | exports.Flags.HasStrictReserved); + const args = []; + const params = []; + while (parser.token !== 16 /* RightParen */) { + if (parser.token === 14 /* Ellipsis */) { + if (state & exports.ObjectState.Setter) + tolerant(parser, context, 67 /* BadSetterRestParameter */); + parser.flags |= exports.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 & exports.ObjectState.Setter && params.length !== 1) { + tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Setter', 'one', ''); + } + if (state & exports.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 & exports.Context.Strict) + tolerant(parser, context, 50 /* UnexpectedStrictReserved */); + parser.flags |= exports.Flags.StrictFunctionName; + } + if (hasBit(parser.token, 4194304 /* IsEvalOrArguments */)) { + if (context & exports.Context.Strict) + tolerant(parser, context, 47 /* StrictEvalArguments */); + parser.flags |= exports.Flags.StrictEvalArguments; + } + } + else { + parser.flags |= exports.Flags.SimpleParameterList; + } + const left = parseBindingIdentifierOrPattern(parser, context, args); + if (!consume(parser, context, 83886109 /* Assign */)) + return left; + if (parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */) && context & (exports.Context.Yield | exports.Context.Async)) { + tolerant(parser, context, parser.token & 262144 /* IsAwait */ ? 52 /* AwaitInParameter */ : 51 /* YieldInParameter */); + } + parser.flags |= exports.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 & exports.Context.OptionsExperimental) + decorators = parseDecorators(parser, context); + expect(parser, context | exports.Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */); + const { token } = parser; + let state = exports.ObjectState.None; + let id = null; + let superClass = null; + if ((token !== 41943052 /* LeftBrace */ && token !== 12372 /* ExtendsKeyword */)) { + if (context & exports.Context.Async && token & 262144 /* IsAwait */) { + tolerant(parser, context, 48 /* AwaitBindingIdentifier */); + } + id = parseBindingIdentifier(parser, context | exports.Context.Strict); + } + if (consume(parser, context, 12372 /* ExtendsKeyword */)) { + superClass = parseLeftHandSideExpression(parser, context | exports.Context.Strict, pos); + state |= exports.ObjectState.Heritage; + } + const body = parseClassBodyAndElementList(parser, context | exports.Context.Strict, state); + return finishNode(context, parser, pos, context & exports.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 & exports.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 & exports.Context.OptionsNext && parser.token === 115 /* Hash */ + ? parsePrivateFields(parser, context, decorators) + : parseClassElement(parser, context, state, decorators)); + } + } + parser.flags &= ~exports.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 |= exports.ObjectState.Generator; + } + if (parser.token === 41943059 /* LeftBracket */) + state |= exports.ObjectState.Computed; + if (parser.tokenValue === 'constructor') { + if (state & exports.ObjectState.Generator) + tolerant(parser, context, 45 /* InvalidConstructor */, 'generator'); + else if (state & exports.ObjectState.Heritage) + context |= exports.Context.AllowSuperProperty; + state |= exports.ObjectState.Constructor; + } + let key = parsePropertyName(parser, context); + let value; + if (!(parser.token & 16777216 /* IsShorthandProperty */)) { + if (flags & exports.Flags.EscapedKeyword) + tolerant(parser, context, 3 /* InvalidEscapedReservedWord */); + if (token === 20585 /* StaticKeyword */) { + token = parser.token; + if (consume(parser, context, 167774771 /* Multiply */)) + state |= exports.ObjectState.Generator; + tokenValue = parser.tokenValue; + if (parser.token === 41943059 /* LeftBracket */) + state |= exports.ObjectState.Computed; + if (parser.tokenValue === 'prototype') + tolerant(parser, context, 65 /* StaticPrototype */); + state |= exports.ObjectState.Static; + key = parsePropertyName(parser, context); + if (context & exports.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 & exports.ObjectState.Generator) && !(parser.flags & exports.Flags.NewLine)) { + token = parser.token; + tokenValue = parser.tokenValue; + state |= exports.ObjectState.Async; + if (consume(parser, context, 167774771 /* Multiply */)) + state |= exports.ObjectState.Generator; + if (parser.token === 41943059 /* LeftBracket */) + state |= exports.ObjectState.Computed; + key = parsePropertyName(parser, context); + } + else if ((token === 69743 /* GetKeyword */ || token === 69744 /* SetKeyword */)) { + state |= token === 69743 /* GetKeyword */ ? exports.ObjectState.Getter : exports.ObjectState.Setter; + tokenValue = parser.tokenValue; + if (parser.token === 41943059 /* LeftBracket */) + state |= exports.ObjectState.Computed; + key = parsePropertyName(parser, context & ~exports.Context.Strict); + } + if (tokenValue === 'prototype') { + tolerant(parser, context, 65 /* StaticPrototype */); + } + else if (!(state & exports.ObjectState.Static) && tokenValue === 'constructor') { + tolerant(parser, context, 45 /* InvalidConstructor */, 'accessor'); + } + } + } + if (parser.token === 50331659 /* LeftParen */) { + if (!(state & exports.ObjectState.Computed) && state & exports.ObjectState.Constructor) { + if (parser.flags & exports.Flags.HasConstructor) + report(parser, 12 /* DuplicateConstructor */); + else + parser.flags |= exports.Flags.HasConstructor; + } + value = parseMethodDeclaration(parser, context, state); + } + else { + if (context & exports.Context.OptionsNext) + return parseFieldDefinition(parser, context, key, state, pos, decorators); + tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token)); + } + const kind = (state & exports.ObjectState.Constructor) ? 'constructor' : (state & exports.ObjectState.Getter) ? 'get' : + (state & exports.ObjectState.Setter) ? 'set' : 'method'; + return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? { + type: 'MethodDefinition', + kind, + static: !!(state & exports.ObjectState.Static), + computed: !!(state & exports.ObjectState.Computed), + key, + value, + decorators + } : { + type: 'MethodDefinition', + kind, + static: !!(state & exports.ObjectState.Static), + computed: !!(state & exports.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 & exports.ObjectState.Constructor) + tolerant(parser, context, 0 /* Unexpected */); + let value = null; + if (state & (exports.ObjectState.Async | exports.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 & exports.Context.OptionsExperimental ? { + type: 'FieldDefinition', + key, + value, + computed: !!(state & exports.ObjectState.Computed), + static: !!(state & exports.ObjectState.Static), + decorators + } : { + type: 'FieldDefinition', + key, + value, + computed: !!(state & exports.ObjectState.Computed), + static: !!(state & exports.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 | exports.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 & exports.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 | exports.Context.Strict, exports.ObjectState.None); + parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding); + return finishNode(context, parser, pos, context & exports.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 & exports.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 | exports.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 | exports.Context.DisallowEscapedKeyword, 16777229 /* Period */)) { + if (parser.tokenValue !== 'target' || + !(context & (exports.Context.InParameter | exports.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 & exports.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 & exports.Context.AllowSuperProperty)) + tolerant(parser, context, 54 /* BadSuperCall */); + break; + case 41943059 /* LeftBracket */: + case 16777229 /* Period */: + if (!(context & exports.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 | exports.Context.AllowDecorator)); + } + return decoratorList; +} + +(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"; +})(exports.Context || (exports.Context = {})); +(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"; +})(exports.Flags || (exports.Flags = {})); +(function (Labels) { + Labels[Labels["None"] = 0] = "None"; + Labels[Labels["NotNested"] = 1] = "NotNested"; + Labels[Labels["Nested"] = 2] = "Nested"; +})(exports.Labels || (exports.Labels = {})); +(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"; +})(exports.NumericState || (exports.NumericState = {})); +(function (ScannerState) { + ScannerState[ScannerState["None"] = 0] = "None"; + ScannerState[ScannerState["NewLine"] = 1] = "NewLine"; + ScannerState[ScannerState["LastIsCR"] = 2] = "LastIsCR"; +})(exports.ScannerState || (exports.ScannerState = {})); +(function (ModifierState) { + ModifierState[ModifierState["None"] = 0] = "None"; + ModifierState[ModifierState["Generator"] = 1] = "Generator"; + ModifierState[ModifierState["Await"] = 2] = "Await"; +})(exports.ModifierState || (exports.ModifierState = {})); +(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"; +})(exports.CoverParenthesizedState || (exports.CoverParenthesizedState = {})); +(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"; +})(exports.Escape || (exports.Escape = {})); +(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"; +})(exports.RegexFlags || (exports.RegexFlags = {})); +(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"; +})(exports.CoverCallState || (exports.CoverCallState = {})); +(function (RegexState) { + RegexState[RegexState["Empty"] = 0] = "Empty"; + RegexState[RegexState["Escape"] = 1] = "Escape"; + RegexState[RegexState["Class"] = 2] = "Class"; +})(exports.RegexState || (exports.RegexState = {})); +(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"; +})(exports.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 & exports.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) ? exports.Labels.Nested : exports.Labels.NotNested; +} +/** + * Remove label from the stack + * + * @param parser Parser object + * @param label label + */ +function popLabel(parser, label) { + parser.labelSet[`$${label}`] = exports.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 ? exports.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 & exports.Context.LocationTracker) { + if (context & exports.Context.OptionsRanges) { + node.start = meta.index; + node.end = lastIndex; + } + if (context & exports.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 = (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 & exports.Flags.NewLine + ? consume(parser, context, 17825809 /* Semicolon */) + : report(parser, !(context & exports.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 |= exports.Flags.AllowBinding | exports.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 &= ~(exports.Flags.AllowBinding | exports.Flags.AllowDestructuring); + if (flags & exports.Flags.AllowBinding) + parser.flags |= exports.Flags.AllowBinding; + if (flags & exports.Flags.AllowDestructuring) + parser.flags |= exports.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 |= exports.Flags.AllowBinding | exports.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 & exports.Flags.AllowBinding) || !(flags & exports.Flags.AllowBinding)) { + parser.flags &= ~exports.Flags.AllowBinding; + } + if (!(parser.flags & exports.Flags.AllowDestructuring) || !(flags & exports.Flags.AllowDestructuring)) { + parser.flags &= ~exports.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 = exports.ObjectState.None) { + context &= ~(exports.Context.Async | exports.Context.Yield | exports.Context.InParameter); + if (state & exports.ModifierState.Generator) + context |= exports.Context.Yield; + if (state & exports.ModifierState.Await) + context |= exports.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 = (parser, context, node) => { + switch (node.type) { + case 'Identifier': + if (context & exports.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 & exports.Context.InParameter)) + return; + // Fall through + default: + tolerant(parser, context, context & exports.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 & exports.Context.Strict) { + if (context & exports.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 & exports.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 & exports.Context.Strict) { + if (context & exports.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 & exports.Context.Yield && token & 1073741824 /* IsYield */) + tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token)); + if (context & exports.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 & exports.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 |= exports.Flags.SimpleParameterList; + } + else { + if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) { + setPendingError(parser); + state |= exports.CoverParenthesizedState.HasEvalOrArguments; + } + else if ((token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) { + setPendingError(parser); + state |= exports.CoverParenthesizedState.HasReservedWords; + } + else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) { + setPendingError(parser); + parser.flags |= exports.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 & exports.Flags.AllowBinding)) { + tolerant(parser, context, 77 /* NotBindable */); + } + else if (token & 8388608 /* IsBindingPattern */) { + parser.flags |= exports.Flags.SimpleParameterList; + } + else { + if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) { + setPendingError(parser); + state |= exports.CoverCallState.EvalOrArguments; + } + else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) { + setPendingError(parser); + state |= exports.CoverCallState.Await; + } + else if ((token & 1073741824 /* IsYield */) === 1073741824 /* IsYield */) { + setPendingError(parser); + state |= exports.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 = { + [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 & exports.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, exports.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 & exports.Context.OptionsExperimental) + decorators = parseDecorators(parser, context); + expect(parser, context | exports.Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */); + const id = (context & exports.Context.RequireIdentifier && (parser.token !== 33685505 /* Identifier */)) + ? null : + parseBindingIdentifier(parser, context | exports.Context.Strict | exports.Context.DisallowEscapedKeyword); + let state = exports.ObjectState.None; + let superClass = null; + if (consume(parser, context, 12372 /* ExtendsKeyword */)) { + superClass = parseLeftHandSideExpression(parser, context | exports.Context.Strict, pos); + state |= exports.ObjectState.Heritage; + } + const body = parseClassBodyAndElementList(parser, context & ~exports.Context.RequireIdentifier | exports.Context.Strict | exports.Context.InClass, state); + return finishNode(context, parser, pos, context & exports.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 = exports.ModifierState.None; + if (consume(parser, context, 167774771 /* Multiply */)) { + if (context & exports.Context.AllowSingleStatement && !(context & exports.Context.InFunctionBody)) { + tolerant(parser, context, 22 /* GeneratorInSingleStatementContext */); + } + isGenerator = exports.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 & exports.Context.Yield && token & 1073741824 /* IsYield */) + tolerant(parser, context, 49 /* YieldBindingIdentifier */); + if (context & exports.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 & exports.Context.RequireIdentifier)) + tolerant(parser, context, 39 /* UnNamedFunctionDecl */); + const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty | exports.Context.RequireIdentifier), state, parseFormalListAndBody); + return finishNode(context, parser, pos, { + type: 'FunctionDeclaration', + params, + body, + async: !!(state & exports.ModifierState.Await), + generator: !!(state & exports.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 = exports.ModifierState.Await; + const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? exports.ModifierState.Generator : exports.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 | exports.Context.DisallowEscapedKeyword, 83886109 /* Assign */)) { + init = parseExpressionCoverGrammar(parser, context & ~(exports.Context.BlockScope | exports.Context.ForStatement), parseAssignmentExpression); + if (isInOrOf(parser.token) && (context & exports.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 & (exports.Context.BlockScope | exports.Context.Strict | exports.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 & exports.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 | exports.Context.AllowIn); + case 33566793 /* ConstKeyword */: + return parseVariableStatement(parser, context | exports.Context.BlockScope | exports.Context.AllowIn); + case 594028 /* AsyncKeyword */: + return parseAsyncFunctionDeclarationOrStatement(parser, context); + case 33566810 /* ImportKeyword */: { + if (context & exports.Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod)) { + return parseExpressionStatement(parser, context | exports.Context.AllowIn); + } + } + case 12371 /* ExportKeyword */: + if (context & exports.Context.Module) { + tolerant(parser, context, 34 /* ImportExportDeclAtTopLevel */, tokenDesc(parser.token)); + } + default: + return parseStatement(parser, context | exports.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 | exports.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 | exports.Context.DisallowEscapedKeyword); + case 12374 /* ForKeyword */: + return parseForStatement(parser, context | exports.Context.ForStatement); + case 594028 /* AsyncKeyword */: + if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) { + tolerant(parser, context, 35 /* AsyncFunctionInSingleStatementContext */); + } + return parseExpressionOrLabelledStatement(parser, context | exports.Context.AllowSingleStatement); + case 33566808 /* FunctionKeyword */: + // V8 + tolerant(parser, context, context & exports.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 & (exports.Flags.InSwitchStatement | exports.Flags.InIterationStatement))) { + tolerant(parser, context, 30 /* InvalidNestedStatement */, tokenDesc(parser.token)); + } + let label = null; + if (!(parser.flags & exports.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 & exports.Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) { + const { tokenValue } = parser; + label = parseIdentifier(parser, context); + validateBreakOrContinueLabel(parser, context, tokenValue, false); + } + else if (!(parser.flags & (exports.Flags.InSwitchStatement | exports.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 & ~exports.Context.AllowDecorator) | exports.Context.AllowIn); + expect(parser, context, 16 /* RightParen */); + const consequent = parseConsequentOrAlternate(parser, context | exports.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 & exports.Context.Strict || parser.token !== 33566808 /* FunctionKeyword */ + ? parseStatement(parser, context & ~exports.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 & exports.Flags.NewLine) + tolerant(parser, context, 80 /* NewlineAfterThrow */); + const argument = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.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 & ~exports.Context.AllowDecorator) | exports.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 & ~exports.Context.AllowDecorator) | exports.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 & ~(exports.Context.AllowSingleStatement | exports.Context.AllowDecorator)) | exports.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 & exports.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 & exports.Context.Strict) && + context & exports.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 & ~exports.Context.AllowDecorator) | exports.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 & ~exports.Context.AllowDecorator) | exports.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 & (exports.Context.OptionsGlobalReturn | exports.Context.InFunctionBody))) { + tolerant(parser, context, 18 /* IllegalReturn */); + } + if (parser.flags & exports.Flags.EscapedKeyword) + tolerant(parser, context, 3 /* InvalidEscapedReservedWord */); + nextToken(parser, context); + const argument = !(parser.token & 1048576 /* ASI */) && !(parser.flags & exports.Flags.NewLine) + ? parseExpression(parser, (context & ~(exports.Context.InFunctionBody | exports.Context.AllowDecorator)) | exports.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 |= exports.Flags.InIterationStatement | exports.Flags.AllowDestructuring; + const body = parseStatement(parser, (context & ~exports.Context.AllowSingleStatement) | exports.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 & exports.Context.Strict) + tolerant(parser, context, 37 /* StrictModeWith */); + const pos = getLocation(parser); + nextToken(parser, context); + expect(parser, context, 50331659 /* LeftParen */); + const object = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn); + expect(parser, context, 16 /* RightParen */); + const body = parseStatement(parser, context & ~exports.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 & ~exports.Context.AllowDecorator) | exports.Context.AllowIn); + expect(parser, context, 16 /* RightParen */); + expect(parser, context | exports.Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */); + const cases = []; + const savedFlags = parser.flags; + parser.flags |= exports.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 & ~exports.Context.AllowDecorator) | exports.Context.AllowIn); + } + else { + expect(parser, context, 12368 /* DefaultKeyword */); + } + expect(parser, context, 16777237 /* Colon */); + const consequent = []; + while (!isEndOfCaseOrDefaultClauses(parser)) { + consequent.push(parseStatementListItem(parser, context | exports.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 | exports.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 & exports.Context.Async && consume(parser, context, 34017389 /* AwaitKeyword */)); + expect(parser, context | exports.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 & ~exports.Context.AllowIn) | exports.Context.BlockScope, false); + } + else if (token === 33566791 /* VarKeyword */) { + variableStatement = parseVariableStatement(parser, context & ~exports.Context.AllowIn, false); + } + else if (token !== 17825809 /* Semicolon */) { + sequencePos = getLocation(parser); + init = restoreExpressionCoverGrammar(parser, (context & ~exports.Context.AllowIn) | exports.Context.DisallowEscapedKeyword, parseAssignmentExpression); + } + if (consume(parser, context, 69746 /* OfKeyword */)) { + type = 'ForOfStatement'; + if (init) { + if (!(parser.flags & exports.Flags.AllowDestructuring) || init.type === 'AssignmentExpression') { + tolerant(parser, context, 73 /* InvalidDestructuringTarget */); + } + reinterpret(parser, context, init); + } + else + init = variableStatement; + right = parseAssignmentExpression(parser, context | exports.Context.AllowIn); + } + else if (consume(parser, context, 167786289 /* InKeyword */)) { + if (init) { + if (!(parser.flags & exports.Flags.AllowDestructuring)) + tolerant(parser, context, 73 /* InvalidDestructuringTarget */); + reinterpret(parser, context, init); + } + else + init = variableStatement; + type = 'ForInStatement'; + right = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.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 & ~exports.Context.AllowDecorator) | exports.Context.AllowIn) + : null; + expect(parser, context, 17825809 /* Semicolon */); + update = parser.token !== 16 /* RightParen */ + ? parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.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 | exports.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 & exports.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 | exports.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 | exports.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 | exports.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 | exports.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 | exports.Context.DisallowEscapedKeyword, 12368 /* DefaultKeyword */); + let declaration; + switch (parser.token) { + // export default HoistableDeclaration[Default] + case 33566808 /* FunctionKeyword */: + declaration = parseFunctionDeclaration(parser, context | exports.Context.RequireIdentifier); + break; + // export default ClassDeclaration[Default] + // export default @decl ClassDeclaration[Default] + case 120 /* At */: + case 33566797 /* ClassKeyword */: + declaration = parseClassDeclaration(parser, context & ~exports.Context.AllowIn | exports.Context.RequireIdentifier); + break; + // export default HoistableDeclaration[Default] + case 594028 /* AsyncKeyword */: + declaration = parseAsyncFunctionOrAssignmentExpression(parser, context | exports.Context.RequireIdentifier); + break; + default: + // export default [lookahead ∉ {function, class}] AssignmentExpression[In] ; + declaration = parseAssignmentExpression(parser, context | exports.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 | exports.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 | exports.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 | exports.Context.RequireIdentifier) : + parseAssignmentExpression(parser, context | exports.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: exports.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 |= exports.Context.Module; + // The flag to enable stage 3 support (ESNext) + if (options.next) + context |= exports.Context.OptionsNext; + // The flag to enable React JSX parsing + if (options.jsx) + context |= exports.Context.OptionsJSX; + // The flag to enable start and end offsets to each node + if (options.ranges) + context |= exports.Context.OptionsRanges; + // The flag to enable line/column location information to each node + if (options.loc) + context |= exports.Context.OptionsLoc; + // The flag to attach raw property to each literal node + if (options.raw) + context |= exports.Context.OptionsRaw; + // Attach raw property to each identifier node + if (options.rawIdentifier) + context |= exports.Context.OptionsRawidentifiers; + // The flag to allow return in the global scope + if (options.globalReturn) + context |= exports.Context.OptionsGlobalReturn; + // The flag to allow to skip shebang - '#' + if (options.skipShebang) + context |= exports.Context.OptionsShebang; + // Enable tolerant mode + if (options.tolerant) + context |= exports.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 |= exports.Context.OptionsComments; + // The flag to enable implied strict mode + if (options.impliedStrict) + context |= exports.Context.Strict; + // The flag to enable experimental features + if (options.experimental) + context |= exports.Context.OptionsExperimental; + // The flag to set to bypass methods in Node + if (options.node) + context |= exports.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 & exports.Context.Module ? + parseModuleItemList(parser, context) : + parseStatementList(parser, context); + const node = { + type: 'Program', + sourceType: context & exports.Context.Module ? 'module' : 'script', + body: body, + }; + if (context & exports.Context.LocationTracker) { + if (context & exports.Context.OptionsRanges) { + node.start = 0; + node.end = source.length; + } + if (context & exports.Context.OptionsLoc) { + node.loc = { + start: { line: 1, column: 0 }, + end: { line: parser.line, column: parser.column + } + }; + if (sourceFile) + node.loc.source = sourceFile; + } + } + if (context & exports.Context.OptionsComments) + node.comments = parser.comments; + if (context & exports.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 | exports.Context.DisallowEscapedKeyword); + while (parser.token !== 1048576 /* EndOfSource */) { + if (hasProlog && parser.token !== 33554435 /* StringLiteral */) + hasProlog = false; + if (hasProlog) { + if (!(context & exports.Context.Strict) && parser.tokenRaw.length === 12 && parser.tokenValue === 'use strict') { + context |= exports.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, exports.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, exports.Context.Strict | exports.Context.Module); +} + + + +var estree = /*#__PURE__*/Object.freeze({ + +}); + + + +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 +}); + + + +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 = parser; + +const version = '1.6.9'; + +exports.version = version; +exports.ESTree = estree; +exports.Scanner = index; +exports.parse = parse; +exports.parseSource = parseSource; +exports.parseModule = parseModule; +exports.parseScript = parseScript; +exports.characterType = characterType; +exports.errorMessages = errorMessages; +exports.constructError = constructError; +exports.report = report; +exports.tolerant = tolerant; +exports.tokenDesc = tokenDesc; +exports.descKeyword = descKeyword; +exports.Parser = Parser; +exports.isValidIdentifierPart = isValidIdentifierPart; +exports.isValidIdentifierStart = isValidIdentifierStart; +exports.mustEscape = mustEscape; +exports.validateBreakOrContinueLabel = validateBreakOrContinueLabel; +exports.addLabel = addLabel; +exports.popLabel = popLabel; +exports.hasLabel = hasLabel; +exports.finishNode = finishNode; +exports.expect = expect; +exports.consume = consume; +exports.nextToken = nextToken; +exports.hasBit = hasBit; +exports.consumeSemicolon = consumeSemicolon; +exports.parseExpressionCoverGrammar = parseExpressionCoverGrammar; +exports.restoreExpressionCoverGrammar = restoreExpressionCoverGrammar; +exports.swapContext = swapContext; +exports.validateParams = validateParams; +exports.reinterpret = reinterpret; +exports.lookahead = lookahead; +exports.isValidSimpleAssignmentTarget = isValidSimpleAssignmentTarget; +exports.getLocation = getLocation; +exports.isValidIdentifier = isValidIdentifier; +exports.isLexical = isLexical; +exports.isEndOfCaseOrDefaultClauses = isEndOfCaseOrDefaultClauses; +exports.nextTokenIsLeftParenOrPeriod = nextTokenIsLeftParenOrPeriod; +exports.nextTokenisIdentifierOrParen = nextTokenisIdentifierOrParen; +exports.nextTokenIsLeftParen = nextTokenIsLeftParen; +exports.nextTokenIsFuncKeywordOnSameLine = nextTokenIsFuncKeywordOnSameLine; +exports.isPropertyWithPrivateFieldKey = isPropertyWithPrivateFieldKey; +exports.parseAndClassifyIdentifier = parseAndClassifyIdentifier; +exports.nameIsArgumentsOrEval = nameIsArgumentsOrEval; +exports.setPendingError = setPendingError; +exports.isEqualTagNames = isEqualTagNames; +exports.isInstanceField = isInstanceField; +exports.validateUpdateExpression = validateUpdateExpression; +exports.setPendingExpressionError = setPendingExpressionError; +exports.validateCoverParenthesizedExpression = validateCoverParenthesizedExpression; +exports.validateAsyncArgumentList = validateAsyncArgumentList; +exports.isInOrOf = isInOrOf; diff --git a/node_modules/cherow/dist/commonjs/cherow.min.js b/node_modules/cherow/dist/commonjs/cherow.min.js new file mode 100644 index 0000000..1fb02f4 --- /dev/null +++ b/node_modules/cherow/dist/commonjs/cherow.min.js @@ -0,0 +1 @@ +"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const keywordDescTable=["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 tokenDesc(e){return keywordDescTable[255&e]}const descKeywordTable=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 descKeyword(e){return 0|descKeywordTable[e]}const 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 isValidIdentifierPart(e){return 0!=(1&convert[0+(e>>>5)]>>>e)}function isValidIdentifierStart(e){return 0!=(1&convert[34816+(e>>>5)]>>>e)}function mustEscape(e){return 0!=(1&convert[69632+(e>>>5)]>>>e)}const convert=((e,t)=>{const n=new Uint32Array(104448);let r=0,o=0;for(;r<3392;){const s=e[r++];if(s<0)o-=s;else{let a=e[r++];2&s&&(a=t[a]),1&s?n.fill(a,o,o+=e[r++]):n[o++]=a}}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 nextUnicodeChar(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 isIdentifierPart=e=>0!=(1&characterType[e])||isValidIdentifierPart(e);function escapeInvalidCharacters(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 mustEscape(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)}}`:fromCodePoint(e)}}function consumeOpt(e,t){return e.source.charCodeAt(e.index)===t&&(e.index++,e.column++,!0)}function consumeLineFeed(e,t){e.flags|=exports.Flags.NewLine,e.index++,0==(t&exports.ScannerState.LastIsCR)&&(e.column=0,e.line++)}function scanPrivateName(e,t){return t&exports.Context.InClass&&isValidIdentifierStart(e.source.charCodeAt(e.index))||report(e,1,tokenDesc(e.token)),115}function advanceNewline(e){e.flags|=exports.Flags.NewLine,e.index++,e.column=0,e.line++}const fromCodePoint=e=>e<=65535?String.fromCharCode(e):String.fromCharCode(55296+(e-65536>>10),56320+(e-65536&1023));function readNext(e){return e.index++,e.column++,e.index>=e.source.length&&report(e,14),nextUnicodeChar(e)}function toHex(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 advanceOnMaybeAstral(e,t){e.index++,e.column++,t>65535&&e.index++}function scanEscapeSequence(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++,exports.Escape.Empty;case 48:case 49:case 50:case 51:{let r=n-48,o=e.index+1,s=e.column+1,a=e.source.charCodeAt(o);if(a<48||a>55){if(0!==r||56===a||57===a){if(t&exports.Context.Strict)return exports.Escape.StrictOctal;e.flags|=exports.Flags.HasOctal}}else{if(t&exports.Context.Strict)return exports.Escape.StrictOctal;e.flags|=exports.Flags.HasOctal,e.lastValue=a,r=8*r+(a-48),o++,s++,(a=e.source.charCodeAt(o))>=48&&a<=55&&(e.lastValue=a,r=8*r+(a-48),o++,s++),e.index=o-1,e.column=s-1}return r}case 52:case 53:case 54:case 55:{if(t&exports.Context.Strict)return exports.Escape.StrictOctal;let r=n-48;const o=e.index+1,s=e.column+1,a=e.source.charCodeAt(o);return a>=48&&a<=55&&(r=8*r+(a-48),e.lastValue=a,e.index=o,e.column=s),r}case 56:case 57:return exports.Escape.EightOrNine;case 120:{const t=toHex(e.lastValue=readNext(e));if(t<0)return exports.Escape.InvalidHex;const n=toHex(e.lastValue=readNext(e));return n<0?exports.Escape.InvalidHex:t<<4|n}case 117:{let t=e.lastValue=readNext(e);if(123===t){let n=toHex(t=e.lastValue=readNext(e));if(n<0)return exports.Escape.InvalidHex;for(t=e.lastValue=readNext(e);125!==t;){const r=toHex(t);if(r<0)return exports.Escape.InvalidHex;if((n=16*n+r)>1114111)return exports.Escape.OutOfRange;t=e.lastValue=readNext(e)}return n}{let n=toHex(t);if(n<0)return exports.Escape.InvalidHex;for(let r=0;r<3;r++){const r=toHex(t=e.lastValue=readNext(e));if(r<0)return exports.Escape.InvalidHex;n=16*n+r}return n}}default:return e.source.charCodeAt(e.index)}}function throwStringError(e,t,n){switch(n){case exports.Escape.Empty:return;case exports.Escape.StrictOctal:report(e,t&exports.Context.TaggedTemplate?76:11);case exports.Escape.EightOrNine:report(e,13);case exports.Escape.InvalidHex:report(e,75,"hexadecimal");case exports.Escape.OutOfRange:report(e,14)}}function scanString(e,t,n){const{index:r,lastValue:o}=e;let s="";e.index++,e.column++;let a=e.source.charCodeAt(e.index);for(;a!==n;){switch(a){case 13:case 10:report(e,6);case 92:if((a=readNext(e))>128)s+=fromCodePoint(a);else{e.lastValue=a;const n=scanEscapeSequence(e,t,a);n>=0?s+=fromCodePoint(n):throwStringError(e,t,n),a=e.lastValue}break;default:s+=fromCodePoint(a)}a=readNext(e)}return e.index++,e.column++,e.tokenRaw=e.source.slice(r,e.index),e.tokenValue=s,e.lastValue=o,33554435}function consumeTemplateBrace(e,t){return e.index>=e.length&&report(e,9),e.index--,e.column--,scanTemplate(e,t)}function scanTemplate(e,t){const{index:n,lastValue:r}=e;let o=!0,s="",a=readNext(e);e:for(;96!==a;){switch(a){case 36:{const t=e.index+1;if(t=128)s+=fromCodePoint(a);else{e.lastValue=a;const n=scanEscapeSequence(e,t|exports.Context.Strict,a);if(n>=0)s+=fromCodePoint(n);else{if(n!==exports.Escape.Empty&&t&exports.Context.TaggedTemplate){s=void 0,(a=scanLooserTemplateSegment(e,e.lastValue))<0&&(o=!1);break e}throwStringError(e,t|exports.Context.TaggedTemplate,n)}a=e.lastValue}break;case 13:case 10:case 8232:case 8233:e.column=-1,e.line++;default:null!=s&&(s+=fromCodePoint(a))}a=readNext(e)}return e.index++,e.column++,e.tokenValue=s,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 scanLooserTemplateSegment(e,t){for(;96!==t;){if(36===t&&123===e.source.charCodeAt(e.index+1))return e.index++,e.column++,-t;t=readNext(e)}return t}function scanHexIntegerLiteral(e,t){e.index++,e.column++;let n=exports.NumericState.None,r=toHex(e.source.charCodeAt(e.index));for(r<0&&report(e,0),e.index++,e.column++;e.index=48&&r<=57)||i>=n)break;s=s*n+i,e.index++,e.column++,o++}return 0===o&&report(e,0),a&exports.NumericState.SeenSeparator&&report(e,59),assembleNumericLiteral(e,t,s,consumeOpt(e,110))}function scanImplicitOctalDigits(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&exports.Context.Strict&&report(e,0);let n=e.index,r=e.column,o=0;for(e.flags|=exports.Flags.HasOctal;n55)return scanNumericLiteral(e,t);o=8*o+(s-48),n++,r++}}return e.index=n,e.column=r,assembleNumericLiteral(e,t,o,consumeOpt(e,110))}case 56:case 57:e.flags|=exports.Flags.HasOctal;default:return t&exports.Context.OptionsNext&&95===e.source.charCodeAt(e.index)&&report(e,60),scanNumericLiteral(e,t)}}function scanSignedInteger(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||report(e,0);const r=e.index,o=scanDecimalDigitsOrSeparator(e);return e.source.substring(t,r)+o}function scanNumericLiteral(e,t,n=exports.NumericState.None){let r=n&exports.NumericState.Float?0:scanDecimalAsSmi(e,t);const o=e.source.charCodeAt(e.index);if(46!==o&&95!==o&&!isValidIdentifierStart(o))return assembleNumericLiteral(e,t,r);consumeOpt(e,46)&&(t&exports.Context.OptionsNext&&95===e.source.charCodeAt(e.index)&&report(e,60),n|=exports.NumericState.Float,r=`${r}.${scanDecimalDigitsOrSeparator(e)}`);const s=e.index;return consumeOpt(e,110)&&(n&exports.NumericState.Float&&report(e,0),n|=exports.NumericState.BigInt),(consumeOpt(e,101)||consumeOpt(e,69))&&(n|=exports.NumericState.Float,r+=scanSignedInteger(e,s)),isValidIdentifierStart(e.source.charCodeAt(e.index))&&report(e,0),assembleNumericLiteral(e,t,n&exports.NumericState.Float?parseFloat(r):parseInt(r,10),!!(n&exports.NumericState.BigInt))}function scanNumericSeparator(e,t){return e.index++,e.column++,t&exports.NumericState.SeenSeparator&&report(e,59),t|=exports.NumericState.SeenSeparator}function scanDecimalDigitsOrSeparator(e){let t=e.index,n=exports.NumericState.None,r="";e:for(;e.index=48&&o<=57||95===o;)t&exports.Context.OptionsNext&&95===o?(n=scanNumericSeparator(e,n),o=e.source.charCodeAt(e.index)):(n&=~exports.NumericState.SeenSeparator,r=10*r+(o-48),e.index++,e.column++,o=e.source.charCodeAt(e.index));return n&exports.NumericState.SeenSeparator&&report(e,59),r}function assembleNumericLiteral(e,t,n,r=!1){return e.tokenValue=n,t&exports.Context.OptionsRaw&&(e.tokenRaw=e.source.slice(e.startIndex,e.index)),r?33554551:33554434}function scanIdentifier(e,t,n){let r=e.index,o="",s=!1;n&&advanceOnMaybeAstral(e,n);e:for(;e.index=55296&&n<=56319){n=(1023&n)<<10|1023&e.source.charCodeAt(t+1)|65536}if(!isIdentifierPart(n))break e;advanceOnMaybeAstral(e,n)}}r=2&&a<=11){const n=descKeyword(o);if(n>0)return s&&(t&exports.Context.DisallowEscapedKeyword&&tolerant(e,t,3),e.flags|=exports.Flags.EscapedKeyword),n}return t&exports.Context.OptionsRawidentifiers&&(e.tokenRaw=e.source.slice(r,e.index)),33685505}function scanMaybeIdentifier(e,t,n){return isValidIdentifierStart(n=nextUnicodeChar(e))||report(e,10,escapeInvalidCharacters(n)),scanIdentifier(e,t,n)}function scanUnicodeCodePointEscape(e){const{index:t}=e;if(t+5=55296&&n<=56319&&report(e,74),isIdentifierPart(n)||report(e,75,"unicode"),fromCodePoint(n)}report(e,0)}function scanIdentifierUnicodeEscape(e){let t=e.source.charCodeAt(e.index),n=0;if(123===t){let r=toHex(t=readNext(e));for(;r>=0;)(n=n<<4|r)>1114111&&report(e,89),e.index++,e.column++,r=toHex(e.source.charCodeAt(e.index));125!==e.source.charCodeAt(e.index)&&report(e,75,"unicode"),consumeOpt(e,125)}else for(let r=0;r<4;r++){const r=toHex(t=e.source.charCodeAt(e.index));r<0&&report(e,75,"unicode"),n=n<<4|r,e.index++,e.column++}return n}function skipSingleHTMLComment(e,t,n,r){return t&exports.Context.Module&&report(e,90),skipSingleLineComment(e,t,n,r)}function skipSingleLineComment(e,t,n,r){const o=e.index,s=!!(t&exports.Context.OptionsComments);for(;e.index128)switch(o){case 8232:case 8233:r=r&~exports.ScannerState.LastIsCR|exports.ScannerState.NewLine,advanceNewline(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 scanMaybeIdentifier(e,t,o)}else switch(o){case 13:r|=exports.ScannerState.NewLine|exports.ScannerState.LastIsCR,advanceNewline(e);break;case 10:consumeLineFeed(e,r),r=r&~exports.ScannerState.LastIsCR|exports.ScannerState.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=skipSingleLineComment(e,t,r,"SingleLine");continue;case 42:e.index++,e.column++,r=skipMultiLineComment(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&exports.ScannerState.NewLine||n)&&consumeOpt(e,62)){r=skipSingleHTMLComment(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++,consumeOpt(e,33)&&consumeOpt(e,45)&&consumeOpt(e,45)){r=skipSingleHTMLComment(e,t,r,"HTMLOpen");continue}switch(e.source.charCodeAt(e.index)){case 60:return e.index++,e.column++,consumeOpt(e,61)?67108894:167774273;case 61:return e.index++,e.column++,167774013;case 47:{if(!(t&exports.Context.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++,consumeOpt(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 scanIdentifier(e,t);case 61:{e.index++,e.column++;const t=e.source.charCodeAt(e.index);return 61===t?(e.index++,e.column++,consumeOpt(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&exports.Context.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++,consumeOpt(e,61)?67108896:167774275):61===n?(e.index++,e.column++,67108895):167774274)}case 94:return e.index++,e.column++,consumeOpt(e,61)?67108903:167773254;case 96:return scanTemplate(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?(scanNumericLiteral(e,t,exports.NumericState.Float),33554434):46===r&&++n=e.source.length&&report(e,7)}const o=e.index-1;let s=exports.RegexFlags.Empty;const{index:a}=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++,consumeOpt(e,47)?25:167774015;if(123===t)return e.index++,e.column++,41943052;for(;e.index=e.source.length&&report(e,6);return e.index++,e.column++,t&exports.Context.OptionsRaw&&(e.tokenRaw=e.source.slice(r,e.index)),e.tokenValue=o,33554435}function parseJSXEmptyExpression(e,t){return finishNode(t,e,getLocation(e),{type:"JSXEmptyExpression"})}function parseJSXSpreadChild(e,t){const n=getLocation(e);expect(e,t,14);const r=parseExpression(e,t);return expect(e,t,17825807),finishNode(t,e,n,{type:"JSXSpreadChild",expression:r})}function parseJSXExpressionContainer(e,t){const n=getLocation(e);expect(e,t,41943052),17825807===e.token&&tolerant(e,t,84);const r=parseExpressionCoverGrammar(e,t&~exports.Context.InJSXChild,parseAssignmentExpression);return expect(e,t,17825807),finishNode(t,e,n,{type:"JSXExpressionContainer",expression:r})}function parseJSXExpression(e,t){const n=getLocation(e);if(expect(e,t,41943052),14===e.token)return parseJSXSpreadChild(e,t);const r=17825807===e.token?parseJSXEmptyExpression(e,t):parseExpressionCoverGrammar(e,t,parseAssignmentExpression);return nextJSXToken(e),finishNode(t,e,n,{type:"JSXExpressionContainer",expression:r})}function parseJSXClosingFragment(e,t){const n=getLocation(e);return expect(e,t,25),expect(e,t,167774016),finishNode(t,e,n,{type:"JSXClosingFragment"})}function parseJSXClosingElement(e,t){const n=getLocation(e);expect(e,t,25);const r=parseJSXElementName(e,t);return t&exports.Context.InJSXChild?expect(e,t,167774016):nextJSXToken(e),finishNode(t,e,n,{type:"JSXClosingElement",name:r})}function parseJSXIdentifier(e,t){const{token:n,tokenValue:r,tokenRaw:o}=e;135168&n||tolerant(e,t,1,tokenDesc(e.token));const s=getLocation(e);nextToken(e,t);const a=finishNode(t,e,s,{type:"JSXIdentifier",name:r});return t&exports.Context.OptionsRawidentifiers&&(a.raw=o),a}function parseJSXMemberExpression(e,t,n,r){return scanJSXIdentifier(e),finishNode(t,e,r,{type:"JSXMemberExpression",object:n,property:parseJSXIdentifier(e,t)})}function parseJSXElementName(e,t){const n=getLocation(e);scanJSXIdentifier(e);let r=parseJSXIdentifier(e,t);if(16777237===e.token)return parseJSXNamespacedName(e,t,r,n);for(;consume(e,t,16777229);)r=parseJSXMemberExpression(e,t,r,n);return r}function scanJSXIdentifier(e){const{token:t}=e;if(135168&t){const t=e.index;let n=e.source.charCodeAt(e.index);for(;e.index"),expect(e,t,10),parseArrowBody(e,t&~exports.Context.Async,r,n,exports.ModifierState.None)}function parseAsyncArrowFunction(e,t,n,r,o){return e.flags&=~(exports.Flags.AllowDestructuring|exports.Flags.AllowBinding),e.flags&exports.Flags.NewLine&&tolerant(e,t,36,"async"),expect(e,t,10),parseArrowBody(e,t|exports.Context.Async,o,r,n)}function parseArrowBody(e,t,n,r,o){e.pendingExpressionError=null;for(const r in n)reinterpret(e,t|exports.Context.InParameter,n[r]);const s=41943052!==e.token;return finishNode(t,e,r,{type:"ArrowFunctionExpression",body:s?parseExpressionCoverGrammar(e,t&~(exports.Context.Yield|exports.Context.InParameter),parseAssignmentExpression):swapContext(e,t&~(exports.Context.Yield|exports.Context.AllowDecorator)|exports.Context.InFunctionBody,o,parseFunctionBody),params:n,id:null,async:!!(o&exports.ModifierState.Await),generator:!1,expression:s})}function parseFormalListAndBody(e,t,n){const r=parseFormalParameters(e,t|exports.Context.InParameter,n),o=r.args;return{params:r.params,body:parseFunctionBody(e,t&~exports.Context.AllowDecorator|exports.Context.InFunctionBody,o)}}function parseFunctionBody(e,t,n){const r=getLocation(e);expect(e,t|exports.Context.DisallowEscapedKeyword,41943052);const o=[];for(;33554435===e.token;){const{tokenRaw:n,tokenValue:r}=e;o.push(parseDirective(e,t)),12===n.length&&"use strict"===r&&(e.flags&exports.Flags.SimpleParameterList?tolerant(e,t,64):e.flags&(exports.Flags.HasStrictReserved|exports.Flags.StrictFunctionName)?tolerant(e,t,50):e.flags&exports.Flags.StrictEvalArguments&&tolerant(e,t,47),t|=exports.Context.Strict)}t&exports.Context.Strict&&validateParams(e,t,n);const{labelSet:s}=e;e.labelSet={};const a=e.flags;for(e.flags=e.flags&~(exports.Flags.StrictFunctionName|exports.Flags.StrictEvalArguments|exports.Flags.InSwitchStatement|exports.Flags.InIterationStatement)|exports.Flags.AllowDestructuring;17825807!==e.token;)o.push(parseStatementListItem(e,t));return a&exports.Flags.InIterationStatement&&(e.flags|=exports.Flags.InIterationStatement),a&exports.Flags.InSwitchStatement&&(e.flags|=exports.Flags.InSwitchStatement),e.labelSet=s,expect(e,t,17825807),finishNode(t,e,r,{type:"BlockStatement",body:o})}function parseFormalParameters(e,t,n){expect(e,t,50331659),e.flags&=~(exports.Flags.SimpleParameterList|exports.Flags.HasStrictReserved);const r=[],o=[];for(;16!==e.token;){if(14===e.token){n&exports.ObjectState.Setter&&tolerant(e,t,67),e.flags|=exports.Flags.SimpleParameterList,o.push(parseRestElement(e,t,r));break}if(o.push(parseFormalParameterList(e,t,r)),!consume(e,t,16777234))break;if(16===e.token)break}return n&exports.ObjectState.Setter&&1!==o.length&&tolerant(e,t,66,"Setter","one",""),n&exports.ObjectState.Getter&&o.length>0&&tolerant(e,t,66,"Getter","no","s"),expect(e,t,16),{params:o,args:r}}function parseFormalParameterList(e,t,n){const r=getLocation(e);135168&e.token?(hasBit(e.token,20480)&&(t&exports.Context.Strict&&tolerant(e,t,50),e.flags|=exports.Flags.StrictFunctionName),hasBit(e.token,4194304)&&(t&exports.Context.Strict&&tolerant(e,t,47),e.flags|=exports.Flags.StrictEvalArguments)):e.flags|=exports.Flags.SimpleParameterList;const o=parseBindingIdentifierOrPattern(e,t,n);return consume(e,t,83886109)?(1074003968&e.token&&t&(exports.Context.Yield|exports.Context.Async)&&tolerant(e,t,262144&e.token?52:51),e.flags|=exports.Flags.SimpleParameterList,finishNode(t,e,r,{type:"AssignmentPattern",left:o,right:parseExpressionCoverGrammar(e,t,parseAssignmentExpression)})):o}function parseClassExpression(e,t){const n=getLocation(e);let r=[];t&exports.Context.OptionsExperimental&&(r=parseDecorators(e,t)),expect(e,t|exports.Context.DisallowEscapedKeyword,33566797);const{token:o}=e;let s=exports.ObjectState.None,a=null,i=null;41943052!==o&&12372!==o&&(t&exports.Context.Async&&262144&o&&tolerant(e,t,48),a=parseBindingIdentifier(e,t|exports.Context.Strict)),consume(e,t,12372)&&(i=parseLeftHandSideExpression(e,t|exports.Context.Strict,n),s|=exports.ObjectState.Heritage);const p=parseClassBodyAndElementList(e,t|exports.Context.Strict,s);return finishNode(t,e,n,t&exports.Context.OptionsExperimental?{type:"ClassExpression",id:a,superClass:i,body:p,decorators:r}:{type:"ClassExpression",id:a,superClass:i,body:p})}function parseClassBodyAndElementList(e,t,n){const r=getLocation(e);expect(e,t,41943052);const o=[];let s=[];for(;17825807!==e.token;)consume(e,t,17825809)||(t&exports.Context.OptionsExperimental&&(s=parseDecorators(e,t),17825807===e.token&&report(e,92),0!==s.length&&"constructor"===e.tokenValue&&report(e,93)),o.push(t&exports.Context.OptionsNext&&115===e.token?parsePrivateFields(e,t,s):parseClassElement(e,t,n,s)));return e.flags&=~exports.Flags.HasConstructor,expect(e,t,17825807),finishNode(t,e,r,{type:"ClassBody",body:o})}function parseClassElement(e,t,n,r){const o=getLocation(e);let{tokenValue:s,token:a}=e;const i=e.flags;consume(e,t,167774771)&&(n|=exports.ObjectState.Generator),41943059===e.token&&(n|=exports.ObjectState.Computed),"constructor"===e.tokenValue&&(n&exports.ObjectState.Generator?tolerant(e,t,45,"generator"):n&exports.ObjectState.Heritage&&(t|=exports.Context.AllowSuperProperty),n|=exports.ObjectState.Constructor);let p,c=parsePropertyName(e,t);if(!(16777216&e.token)){if(i&exports.Flags.EscapedKeyword&&tolerant(e,t,3),20585===a&&(a=e.token,consume(e,t,167774771)&&(n|=exports.ObjectState.Generator),s=e.tokenValue,41943059===e.token&&(n|=exports.ObjectState.Computed),"prototype"===e.tokenValue&&tolerant(e,t,65),n|=exports.ObjectState.Static,c=parsePropertyName(e,t),t&exports.Context.OptionsNext&&isInstanceField(e)))return"constructor"===s&&tolerant(e,t,1,tokenDesc(e.token)),parseFieldDefinition(e,t,c,n,o,r);50331659!==e.token&&(!(524288&a)||n&exports.ObjectState.Generator||e.flags&exports.Flags.NewLine?69743!==a&&69744!==a||(n|=69743===a?exports.ObjectState.Getter:exports.ObjectState.Setter,s=e.tokenValue,41943059===e.token&&(n|=exports.ObjectState.Computed),c=parsePropertyName(e,t&~exports.Context.Strict)):(a=e.token,s=e.tokenValue,n|=exports.ObjectState.Async,consume(e,t,167774771)&&(n|=exports.ObjectState.Generator),41943059===e.token&&(n|=exports.ObjectState.Computed),c=parsePropertyName(e,t)),"prototype"===s?tolerant(e,t,65):n&exports.ObjectState.Static||"constructor"!==s||tolerant(e,t,45,"accessor"))}if(50331659===e.token)!(n&exports.ObjectState.Computed)&&n&exports.ObjectState.Constructor&&(e.flags&exports.Flags.HasConstructor?report(e,12):e.flags|=exports.Flags.HasConstructor),p=parseMethodDeclaration(e,t,n);else{if(t&exports.Context.OptionsNext)return parseFieldDefinition(e,t,c,n,o,r);tolerant(e,t,1,tokenDesc(a))}const l=n&exports.ObjectState.Constructor?"constructor":n&exports.ObjectState.Getter?"get":n&exports.ObjectState.Setter?"set":"method";return finishNode(t,e,o,t&exports.Context.OptionsExperimental?{type:"MethodDefinition",kind:l,static:!!(n&exports.ObjectState.Static),computed:!!(n&exports.ObjectState.Computed),key:c,value:p,decorators:r}:{type:"MethodDefinition",kind:l,static:!!(n&exports.ObjectState.Static),computed:!!(n&exports.ObjectState.Computed),key:c,value:p})}function parseFieldDefinition(e,t,n,r,o,s){r&exports.ObjectState.Constructor&&tolerant(e,t,0);let a=null;return r&(exports.ObjectState.Async|exports.ObjectState.Generator)&&tolerant(e,t,0),consume(e,t,83886109)&&(4194304&e.token&&tolerant(e,t,47),a=parseAssignmentExpression(e,t)),consume(e,t,16777234),finishNode(t,e,o,t&exports.Context.OptionsExperimental?{type:"FieldDefinition",key:n,value:a,computed:!!(r&exports.ObjectState.Computed),static:!!(r&exports.ObjectState.Static),decorators:s}:{type:"FieldDefinition",key:n,value:a,computed:!!(r&exports.ObjectState.Computed),static:!!(r&exports.ObjectState.Static)})}function parsePrivateName(e,t,n){const r=e.tokenValue;return nextToken(e,t),finishNode(t,e,n,{type:"PrivateName",name:r})}function parsePrivateFields(e,t,n){const r=getLocation(e);expect(e,t|exports.Context.InClass,115),"constructor"===e.tokenValue&&tolerant(e,t,41);const o=parsePrivateName(e,t,r);if(50331659===e.token)return parsePrivateMethod(e,t,o,r,n);let s=null;return consume(e,t,83886109)&&(4194304&e.token&&tolerant(e,t,47),s=parseAssignmentExpression(e,t)),consume(e,t,16777234),finishNode(t,e,r,t&exports.Context.OptionsExperimental?{type:"FieldDefinition",key:o,value:s,computed:!1,static:!1,decorators:n}:{type:"FieldDefinition",key:o,value:s,computed:!1,static:!1})}function parsePrivateMethod(e,t,n,r,o){const s=parseMethodDeclaration(e,t|exports.Context.Strict,exports.ObjectState.None);return e.flags&=~(exports.Flags.AllowDestructuring|exports.Flags.AllowBinding),finishNode(t,e,r,t&exports.Context.OptionsExperimental?{type:"MethodDefinition",kind:"method",static:!1,computed:!1,key:n,value:s,decorators:o}:{type:"MethodDefinition",kind:"method",static:!1,computed:!1,key:n,value:s})}function parseCallImportOrMetaProperty(e,t){const n=getLocation(e),r=parseIdentifier(e,t);if(consume(e,t,16777229)){if(t&exports.Context.Module&&"meta"===e.tokenValue)return parseMetaProperty(e,t,r,n);tolerant(e,t,1,tokenDesc(e.token))}let o=parseImportExpression(e,t,n);expect(e,t,50331659);const s=parseExpressionCoverGrammar(e,t|exports.Context.AllowIn,parseAssignmentExpression);return expect(e,t,16),o=finishNode(t,e,n,{type:"CallExpression",callee:o,arguments:[s]})}function parseImportExpression(e,t,n){return finishNode(t,e,n,{type:"Import"})}function parseMetaProperty(e,t,n,r){return finishNode(t,e,r,{meta:n,type:"MetaProperty",property:parseIdentifier(e,t)})}function parseNewExpressionOrMetaProperty(e,t){const n=getLocation(e),r=parseIdentifier(e,t);return consume(e,t|exports.Context.DisallowEscapedKeyword,16777229)?("target"===e.tokenValue&&t&(exports.Context.InParameter|exports.Context.InFunctionBody)||tolerant(e,t,53),parseMetaProperty(e,t,r,n)):finishNode(t,e,n,{type:"NewExpression",callee:parseImportOrMemberExpression(e,t,n),arguments:50331659===e.token?parseArgumentList(e,t):[]})}function parseImportOrMemberExpression(e,t,n){const{token:r}=e;return t&exports.Context.OptionsNext&&33566810===r?(lookahead(e,t,nextTokenIsLeftParen)&&tolerant(e,t,1,tokenDesc(r)),parseCallImportOrMetaProperty(e,t)):parseMemberExpression(e,t,n)}function parseSuperProperty(e,t){const n=getLocation(e);switch(expect(e,t,33566813),e.token){case 50331659:t&exports.Context.AllowSuperProperty||tolerant(e,t,54);break;case 41943059:case 16777229:t&exports.Context.Method||tolerant(e,t,55);break;default:tolerant(e,t,56)}return finishNode(t,e,n,{type:"Super"})}function parseTemplateLiteral(e,t){return finishNode(t,e,getLocation(e),{type:"TemplateLiteral",expressions:[],quasis:[parseTemplateSpans(e,t)]})}function parseTemplateHead(e,t,n=null,r,o){return e.token=consumeTemplateBrace(e,t),finishNode(t,e,o,{type:"TemplateElement",value:{cooked:n,raw:r},tail:!1})}function parseTemplate(e,t,n=[],r=[]){const o=getLocation(e),{tokenValue:s,tokenRaw:a}=e;expect(e,t,33554440),n.push(parseExpression(e,t));const i=getLocation(e);return r.push(parseTemplateHead(e,t,s,a,o)),33554441===e.token?r.push(parseTemplateSpans(e,t,i)):parseTemplate(e,t,n,r),finishNode(t,e,o,{type:"TemplateLiteral",expressions:n,quasis:r})}function parseTemplateSpans(e,t,n=getLocation(e)){const{tokenValue:r,tokenRaw:o}=e;return expect(e,t,33554441),finishNode(t,e,n,{type:"TemplateElement",value:{cooked:r,raw:o},tail:!0})}function parseDecoratorList(e,t){const n=getLocation(e);return finishNode(t,e,n,{type:"Decorator",expression:parseLeftHandSideExpression(e,t,n)})}function parseDecorators(e,t){const n=[];for(;consume(e,t,120);)n.push(parseDecoratorList(e,t|exports.Context.AllowDecorator));return n}function validateBreakOrContinueLabel(e,t,n,r){const o=hasLabel(e,n);o||tolerant(e,t,32,n),!r||o&exports.Labels.Nested||tolerant(e,t,31,n)}function addLabel(e,t){void 0===e.labelSet&&(e.labelSet={}),e.labelSet[`$${t}`]=isIterationStatement(e.token)?exports.Labels.Nested:exports.Labels.NotNested}function popLabel(e,t){e.labelSet[`$${t}`]=exports.Labels.None}function hasLabel(e,t){return e.labelSet?e.labelSet[`$${t}`]:exports.Labels.None}function finishNode(e,t,n,r){const{lastIndex:o,lastLine:s,lastColumn:a,sourceFile:i,index:p}=t;return e&exports.Context.LocationTracker&&(e&exports.Context.OptionsRanges&&(r.start=n.index,r.end=o),e&exports.Context.OptionsLoc&&(r.loc={start:{line:n.line,column:n.column},end:{line:s,column:a}},i&&(r.loc.source=i))),r}function expect(e,t,n,r=1){return e.token!==n&&report(e,r,tokenDesc(e.token)),nextToken(e,t),!0}function consume(e,t,n){return e.token===n&&(nextToken(e,t),!0)}function nextToken(e,t){return e.lastIndex=e.index,e.lastLine=e.line,e.lastColumn=e.column,e.token=scan(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"}(exports.Context||(exports.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"}(exports.Flags||(exports.Flags={})),function(e){e[e.None=0]="None",e[e.NotNested=1]="NotNested",e[e.Nested=2]="Nested"}(exports.Labels||(exports.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"}(exports.NumericState||(exports.NumericState={})),function(e){e[e.None=0]="None",e[e.NewLine=1]="NewLine",e[e.LastIsCR=2]="LastIsCR"}(exports.ScannerState||(exports.ScannerState={})),function(e){e[e.None=0]="None",e[e.Generator=1]="Generator",e[e.Await=2]="Await"}(exports.ModifierState||(exports.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"}(exports.CoverParenthesizedState||(exports.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"}(exports.Escape||(exports.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"}(exports.RegexFlags||(exports.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"}(exports.CoverCallState||(exports.CoverCallState={})),function(e){e[e.Empty=0]="Empty",e[e.Escape=1]="Escape",e[e.Class=2]="Class"}(exports.RegexState||(exports.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"}(exports.ObjectState||(exports.ObjectState={}));const hasBit=(e,t)=>(e&t)===t;function consumeSemicolon(e,t){return 1048576&e.token||e.flags&exports.Flags.NewLine?consume(e,t,17825809):report(e,!(t&exports.Context.Async)&&262144&e.token?38:1,tokenDesc(e.token))}function parseExpressionCoverGrammar(e,t,n){const{flags:r,pendingExpressionError:o}=e;e.flags|=exports.Flags.AllowBinding|exports.Flags.AllowDestructuring,e.pendingExpressionError=void 0;const s=n(e,t);if(e.pendingExpressionError){const{error:n,line:r,column:o,index:s}=e.pendingExpressionError;constructError(e,t,s,r,o,n)}return e.flags&=~(exports.Flags.AllowBinding|exports.Flags.AllowDestructuring),r&exports.Flags.AllowBinding&&(e.flags|=exports.Flags.AllowBinding),r&exports.Flags.AllowDestructuring&&(e.flags|=exports.Flags.AllowDestructuring),e.pendingExpressionError=o,s}function restoreExpressionCoverGrammar(e,t,n){const{flags:r,pendingExpressionError:o}=e;e.flags|=exports.Flags.AllowBinding|exports.Flags.AllowDestructuring,e.pendingExpressionError=void 0;const s=n(e,t);return e.flags&exports.Flags.AllowBinding&&r&exports.Flags.AllowBinding||(e.flags&=~exports.Flags.AllowBinding),e.flags&exports.Flags.AllowDestructuring&&r&exports.Flags.AllowDestructuring||(e.flags&=~exports.Flags.AllowDestructuring),e.pendingExpressionError=o||e.pendingExpressionError,s}function swapContext(e,t,n,r,o=exports.ObjectState.None){return t&=~(exports.Context.Async|exports.Context.Yield|exports.Context.InParameter),n&exports.ModifierState.Generator&&(t|=exports.Context.Yield),n&exports.ModifierState.Await&&(t|=exports.Context.Async),r(e,t,o)}function validateParams(e,t,n){const r=new Map;for(let o=0;o{switch(n.type){case"Identifier":t&exports.Context.Strict&&nameIsArgumentsOrEval(n.name)&&report(e,3);case"ArrayPattern":case"AssignmentPattern":case"ObjectPattern":case"RestElement":case"MetaProperty":return;case"ArrayExpression":n.type="ArrayPattern";for(let r=0;rn[t]);constructError(e,exports.Context.Empty,r,o,s,a)}function tolerant(e,t,n,...r){const{index:o,line:s,column:a}=getErrorLocation(e);constructError(e,t,o,s,a,errorMessages[n].replace(/%(\d+)/g,(e,t)=>r[t]))}function parseClassDeclaration(e,t){const n=getLocation(e);let r=[];t&exports.Context.OptionsExperimental&&(r=parseDecorators(e,t)),expect(e,t|exports.Context.DisallowEscapedKeyword,33566797);const o=t&exports.Context.RequireIdentifier&&33685505!==e.token?null:parseBindingIdentifier(e,t|exports.Context.Strict|exports.Context.DisallowEscapedKeyword);let s=exports.ObjectState.None,a=null;consume(e,t,12372)&&(a=parseLeftHandSideExpression(e,t|exports.Context.Strict,n),s|=exports.ObjectState.Heritage);const i=parseClassBodyAndElementList(e,t&~exports.Context.RequireIdentifier|exports.Context.Strict|exports.Context.InClass,s);return finishNode(t,e,n,t&exports.Context.OptionsExperimental?{type:"ClassDeclaration",id:o,superClass:a,body:i,decorators:r}:{type:"ClassDeclaration",id:o,superClass:a,body:i})}function parseFunctionDeclaration(e,t){const n=getLocation(e);expect(e,t,33566808);let r=exports.ModifierState.None;return consume(e,t,167774771)&&(t&exports.Context.AllowSingleStatement&&!(t&exports.Context.InFunctionBody)&&tolerant(e,t,22),r=exports.ModifierState.Generator),parseFunctionDeclarationBody(e,t,r,n)}function parseFunctionDeclarationBody(e,t,n,r){const{token:o}=e;let s=null;t&exports.Context.Yield&&1073741824&o&&tolerant(e,t,49),t&exports.Context.Async&&262144&o&&tolerant(e,t,48),50331659!==o?s=parseBindingIdentifier(e,t):t&exports.Context.RequireIdentifier||tolerant(e,t,39);const{params:a,body:i}=swapContext(e,t&~(exports.Context.Method|exports.Context.AllowSuperProperty|exports.Context.RequireIdentifier),n,parseFormalListAndBody);return finishNode(t,e,r,{type:"FunctionDeclaration",params:a,body:i,async:!!(n&exports.ModifierState.Await),generator:!!(n&exports.ModifierState.Generator),expression:!1,id:s})}function parseAsyncFunctionOrAsyncGeneratorDeclaration(e,t){const n=getLocation(e);expect(e,t,594028),expect(e,t,33566808);const r=exports.ModifierState.Await;return parseFunctionDeclarationBody(e,t,(consume(e,t,167774771)?exports.ModifierState.Generator:exports.ModifierState.None)|r,n)}function parseVariableDeclaration(e,t,n){const r=getLocation(e),o=0!=(8388608&e.token),s=parseBindingIdentifierOrPattern(e,t);let a=null;return consume(e,t|exports.Context.DisallowEscapedKeyword,83886109)?(a=parseExpressionCoverGrammar(e,t&~(exports.Context.BlockScope|exports.Context.ForStatement),parseAssignmentExpression),isInOrOf(e.token)&&(t&exports.Context.ForStatement||o)&&(167786289===e.token?(t&(exports.Context.BlockScope|exports.Context.Strict|exports.Context.Async)||o)&&tolerant(e,t,25,tokenDesc(e.token)):tolerant(e,t,25,tokenDesc(e.token)))):isInOrOf(e.token)||!n&&!o||tolerant(e,t,24,n?"const":"destructuring"),finishNode(t,e,r,{type:"VariableDeclarator",init:a,id:s})}function parseVariableDeclarationList(e,t,n){const r=[parseVariableDeclaration(e,t,n)];for(;consume(e,t,16777234);)r.push(parseVariableDeclaration(e,t,n));return t&exports.Context.ForStatement&&isInOrOf(e.token)&&1!==r.length&&tolerant(e,t,26,tokenDesc(e.token)),r}function parseStatementListItem(e,t){switch(e.token){case 33566808:return parseFunctionDeclaration(e,t);case 120:case 33566797:return parseClassDeclaration(e,t);case 33574984:return parseLetOrExpressionStatement(e,t|exports.Context.AllowIn);case 33566793:return parseVariableStatement(e,t|exports.Context.BlockScope|exports.Context.AllowIn);case 594028:return parseAsyncFunctionDeclarationOrStatement(e,t);case 33566810:if(t&exports.Context.OptionsNext&&lookahead(e,t,nextTokenIsLeftParenOrPeriod))return parseExpressionStatement(e,t|exports.Context.AllowIn);case 12371:t&exports.Context.Module&&tolerant(e,t,34,tokenDesc(e.token));default:return parseStatement(e,t|exports.Context.AllowSingleStatement)}}function parseStatement(e,t){switch(e.token){case 33566791:return parseVariableStatement(e,t|exports.Context.AllowIn);case 17825809:return parseEmptyStatement(e,t);case 33566814:return parseSwitchStatement(e,t);case 41943052:return parseBlockStatement(e,t);case 12380:return parseReturnStatement(e,t);case 12377:return parseIfStatement(e,t);case 12369:return parseDoWhileStatement(e,t);case 12386:return parseWhileStatement(e,t);case 12387:return parseWithStatement(e,t);case 12362:return parseBreakStatement(e,t);case 12366:return parseContinueStatement(e,t);case 12367:return parseDebuggerStatement(e,t);case 302002272:return parseThrowStatement(e,t);case 12385:return parseTryStatement(e,t|exports.Context.DisallowEscapedKeyword);case 12374:return parseForStatement(e,t|exports.Context.ForStatement);case 594028:return lookahead(e,t,nextTokenIsFuncKeywordOnSameLine)&&tolerant(e,t,35),parseExpressionOrLabelledStatement(e,t|exports.Context.AllowSingleStatement);case 33566808:tolerant(e,t,t&exports.Context.Strict?19:20);case 33566797:tolerant(e,t,21,tokenDesc(e.token));default:return parseExpressionOrLabelledStatement(e,t)}}function parseEmptyStatement(e,t){const n=getLocation(e);return nextToken(e,t),finishNode(t,e,n,{type:"EmptyStatement"})}function parseContinueStatement(e,t){const n=getLocation(e);nextToken(e,t),e.flags&(exports.Flags.InSwitchStatement|exports.Flags.InIterationStatement)||tolerant(e,t,30,tokenDesc(e.token));let r=null;if(!(e.flags&exports.Flags.NewLine)&&135168&e.token){const{tokenValue:n}=e;r=parseIdentifier(e,t),validateBreakOrContinueLabel(e,t,n,!0)}return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ContinueStatement",label:r})}function parseBreakStatement(e,t){const n=getLocation(e);nextToken(e,t);let r=null;if(!(e.flags&exports.Flags.NewLine)&&135168&e.token){const{tokenValue:n}=e;r=parseIdentifier(e,t),validateBreakOrContinueLabel(e,t,n,!1)}else e.flags&(exports.Flags.InSwitchStatement|exports.Flags.InIterationStatement)||tolerant(e,t,30,"break");return consumeSemicolon(e,t),finishNode(t,e,n,{type:"BreakStatement",label:r})}function parseIfStatement(e,t){const n=getLocation(e);nextToken(e,t),expect(e,t,50331659);const r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return expect(e,t,16),finishNode(t,e,n,{type:"IfStatement",test:r,consequent:parseConsequentOrAlternate(e,t|exports.Context.DisallowEscapedKeyword),alternate:consume(e,t,12370)?parseConsequentOrAlternate(e,t):null})}function parseConsequentOrAlternate(e,t){return t&exports.Context.Strict||33566808!==e.token?parseStatement(e,t&~exports.Context.AllowSingleStatement):parseFunctionDeclaration(e,t)}function parseDebuggerStatement(e,t){const n=getLocation(e);return nextToken(e,t),consumeSemicolon(e,t),finishNode(t,e,n,{type:"DebuggerStatement"})}function parseTryStatement(e,t){const n=getLocation(e);nextToken(e,t);const r=parseBlockStatement(e,t),o=12364===e.token?parseCatchBlock(e,t):null,s=consume(e,t,12373)?parseBlockStatement(e,t):null;return o||s||tolerant(e,t,79),finishNode(t,e,n,{type:"TryStatement",block:r,handler:o,finalizer:s})}function parseCatchBlock(e,t){const n=getLocation(e);nextToken(e,t);let r=null;if(consume(e,t,50331659)){const n=[];r=parseBindingIdentifierOrPattern(e,t,n),validateParams(e,t,n),expect(e,t,16)}return finishNode(t,e,n,{type:"CatchClause",param:r,body:parseBlockStatement(e,t)})}function parseThrowStatement(e,t){const n=getLocation(e);nextToken(e,t),e.flags&exports.Flags.NewLine&&tolerant(e,t,80);const r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ThrowStatement",argument:r})}function parseExpressionStatement(e,t){const n=getLocation(e),r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ExpressionStatement",expression:r})}function parseDirective(e,t){const n=getLocation(e),r=e.tokenRaw.slice(1,-1),o=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ExpressionStatement",expression:o,directive:r})}function parseExpressionOrLabelledStatement(e,t){const n=getLocation(e),{tokenValue:r,token:o}=e,s=parseExpression(e,t&~(exports.Context.AllowSingleStatement|exports.Context.AllowDecorator)|exports.Context.AllowIn);if(135168&o&&16777237===e.token){t&exports.Context.Yield&&1073741824&o&&tolerant(e,t,57),expect(e,t,16777237,83),hasLabel(e,r)&&tolerant(e,t,29,r),addLabel(e,r);const a=!(t&exports.Context.Strict)&&t&exports.Context.AllowSingleStatement&&33566808===e.token?parseFunctionDeclaration(e,t):parseStatement(e,t);return popLabel(e,r),finishNode(t,e,n,{type:"LabeledStatement",label:s,body:a})}return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ExpressionStatement",expression:s})}function parseDoWhileStatement(e,t){const n=getLocation(e);nextToken(e,t);const r=parseIterationStatement(e,t);expect(e,t,12386),expect(e,t,50331659);const o=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return expect(e,t,16),consume(e,t,17825809),finishNode(t,e,n,{type:"DoWhileStatement",body:r,test:o})}function parseWhileStatement(e,t){const n=getLocation(e);nextToken(e,t),expect(e,t,50331659);const r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return expect(e,t,16),finishNode(t,e,n,{type:"WhileStatement",test:r,body:parseIterationStatement(e,t)})}function parseBlockStatement(e,t){const n=getLocation(e),r=[];for(expect(e,t,41943052);17825807!==e.token;)r.push(parseStatementListItem(e,t));return expect(e,t,17825807),finishNode(t,e,n,{type:"BlockStatement",body:r})}function parseReturnStatement(e,t){const n=getLocation(e);t&(exports.Context.OptionsGlobalReturn|exports.Context.InFunctionBody)||tolerant(e,t,18),e.flags&exports.Flags.EscapedKeyword&&tolerant(e,t,3),nextToken(e,t);const r=1048576&e.token||e.flags&exports.Flags.NewLine?null:parseExpression(e,t&~(exports.Context.InFunctionBody|exports.Context.AllowDecorator)|exports.Context.AllowIn);return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ReturnStatement",argument:r})}function parseIterationStatement(e,t){const n=e.flags;e.flags|=exports.Flags.InIterationStatement|exports.Flags.AllowDestructuring;const r=parseStatement(e,t&~exports.Context.AllowSingleStatement|exports.Context.DisallowEscapedKeyword);return e.flags=n,r}function parseWithStatement(e,t){t&exports.Context.Strict&&tolerant(e,t,37);const n=getLocation(e);nextToken(e,t),expect(e,t,50331659);const r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);return expect(e,t,16),finishNode(t,e,n,{type:"WithStatement",object:r,body:parseStatement(e,t&~exports.Context.AllowSingleStatement)})}function parseSwitchStatement(e,t){const n=getLocation(e);nextToken(e,t),expect(e,t,50331659);const r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn);expect(e,t,16),expect(e,t|exports.Context.DisallowEscapedKeyword,41943052);const o=[],s=e.flags;e.flags|=exports.Flags.InSwitchStatement;let a=!1;for(;17825807!==e.token;){const n=parseCaseOrDefaultClauses(e,t);o.push(n),null===n.test&&(a&&tolerant(e,t,33),a=!0)}return e.flags=s,expect(e,t,17825807),finishNode(t,e,n,{type:"SwitchStatement",discriminant:r,cases:o})}function parseCaseOrDefaultClauses(e,t){const n=getLocation(e);let r=null;consume(e,t,12363)?r=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn):expect(e,t,12368),expect(e,t,16777237);const o=[];for(;!isEndOfCaseOrDefaultClauses(e);)o.push(parseStatementListItem(e,t|exports.Context.AllowIn));return finishNode(t,e,n,{type:"SwitchCase",test:r,consequent:o})}function parseVariableStatement(e,t,n=!0){const r=getLocation(e),{token:o}=e,s=33566793===o;nextToken(e,t);const a=parseVariableDeclarationList(e,t,s);return n&&consumeSemicolon(e,t),finishNode(t,e,r,{type:"VariableDeclaration",kind:tokenDesc(o),declarations:a})}function parseLetOrExpressionStatement(e,t,n=!0){return lookahead(e,t,isLexical)?parseVariableStatement(e,t|exports.Context.BlockScope,n):parseExpressionOrLabelledStatement(e,t)}function parseAsyncFunctionDeclarationOrStatement(e,t){return lookahead(e,t,nextTokenIsFuncKeywordOnSameLine)?parseAsyncFunctionOrAsyncGeneratorDeclaration(e,t):parseStatement(e,t)}function parseForStatement(e,t){const n=getLocation(e);expect(e,t,12374);const r=!!(t&exports.Context.Async&&consume(e,t,34017389));expect(e,t|exports.Context.DisallowEscapedKeyword,50331659);const{token:o}=e;let s,a=null,i=null,p=null,c="ForStatement",l=null,x=null;33566793===o||33574984===o&&lookahead(e,t,isLexical)?p=parseVariableStatement(e,t&~exports.Context.AllowIn|exports.Context.BlockScope,!1):33566791===o?p=parseVariableStatement(e,t&~exports.Context.AllowIn,!1):17825809!==o&&(i=getLocation(e),a=restoreExpressionCoverGrammar(e,t&~exports.Context.AllowIn|exports.Context.DisallowEscapedKeyword,parseAssignmentExpression)),consume(e,t,69746)?(c="ForOfStatement",a?(e.flags&exports.Flags.AllowDestructuring&&"AssignmentExpression"!==a.type||tolerant(e,t,73),reinterpret(e,t,a)):a=p,s=parseAssignmentExpression(e,t|exports.Context.AllowIn)):consume(e,t,167786289)?(a?(e.flags&exports.Flags.AllowDestructuring||tolerant(e,t,73),reinterpret(e,t,a)):a=p,c="ForInStatement",s=parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn)):(16777234===e.token&&(a=parseSequenceExpression(e,t,a,i)),p&&(a=p),expect(e,t,17825809),l=17825809!==e.token?parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn):null,expect(e,t,17825809),x=16!==e.token?parseExpression(e,t&~exports.Context.AllowDecorator|exports.Context.AllowIn):null),expect(e,t,16);const u=parseIterationStatement(e,t);return finishNode(t,e,n,"ForOfStatement"===c?{type:c,body:u,left:a,right:s,await:r}:s?{type:c,body:u,left:a,right:s}:{type:c,body:u,init:a,test:l,update:x})}function parseModuleItemList(e,t){nextToken(e,t);const n=[];for(;1048576!==e.token;)n.push(33554435===e.token?parseDirective(e,t):parseModuleItem(e,t|exports.Context.AllowIn));return n}function parseModuleItem(e,t){switch(e.token){case 120:return parseDecorators(e,t);case 12371:return parseExportDeclaration(e,t);case 33566810:if(!(t&exports.Context.OptionsNext&&lookahead(e,t,nextTokenIsLeftParenOrPeriod)))return parseImportDeclaration(e,t);default:return parseStatementListItem(e,t)}}function parseExportDeclaration(e,t){const n=getLocation(e),r=[];let o=null,s=null;switch(expect(e,t|exports.Context.DisallowEscapedKeyword,12371),e.token){case 167774771:return parseExportAllDeclaration(e,t,n);case 12368:return parseExportDefault(e,t,n);case 41943052:{expect(e,t,41943052);let n=!1;for(;17825807!==e.token;)69743!==e.token&&12288&e.token&&(n=!0,setPendingError(e)),r.push(parseNamedExportDeclaration(e,t)),17825807!==e.token&&expect(e,t,16777234);expect(e,t|exports.Context.DisallowEscapedKeyword,17825807),69745===e.token?o=parseModuleSpecifier(e,t):n&&tolerant(e,t,46),consumeSemicolon(e,t);break}case 33566797:s=parseClassDeclaration(e,t);break;case 33574984:case 33566793:s=parseVariableStatement(e,t|exports.Context.BlockScope);break;case 33566791:s=parseVariableStatement(e,t);break;case 33566808:s=parseFunctionDeclaration(e,t);break;case 594028:if(lookahead(e,t,nextTokenIsFuncKeywordOnSameLine)){s=parseAsyncFunctionOrAsyncGeneratorDeclaration(e,t);break}default:report(e,1,tokenDesc(e.token))}return finishNode(t,e,n,{type:"ExportNamedDeclaration",source:o,specifiers:r,declaration:s})}function parseExportAllDeclaration(e,t,n){expect(e,t,167774771);const r=parseModuleSpecifier(e,t);return consumeSemicolon(e,t),finishNode(t,e,n,{type:"ExportAllDeclaration",source:r})}function parseNamedExportDeclaration(e,t){const n=getLocation(e),r=parseIdentifierName(e,t|exports.Context.DisallowEscapedKeyword,e.token);return finishNode(t,e,n,{type:"ExportSpecifier",local:r,exported:consume(e,t,167843947)?parseIdentifierName(e,t,e.token):r})}function parseExportDefault(e,t,n){let r;switch(expect(e,t|exports.Context.DisallowEscapedKeyword,12368),e.token){case 33566808:r=parseFunctionDeclaration(e,t|exports.Context.RequireIdentifier);break;case 120:case 33566797:r=parseClassDeclaration(e,t&~exports.Context.AllowIn|exports.Context.RequireIdentifier);break;case 594028:r=parseAsyncFunctionOrAssignmentExpression(e,t|exports.Context.RequireIdentifier);break;default:r=parseAssignmentExpression(e,t|exports.Context.AllowIn),consumeSemicolon(e,t)}return finishNode(t,e,n,{type:"ExportDefaultDeclaration",declaration:r})}function parseImportDeclaration(e,t){const n=getLocation(e);let r;expect(e,t,33566810);let o=[];return 33554435===e.token?r=parseLiteral(e,t):(o=parseImportClause(e,t|exports.Context.DisallowEscapedKeyword),r=parseModuleSpecifier(e,t)),consumeSemicolon(e,t),finishNode(t,e,n,{type:"ImportDeclaration",specifiers:o,source:r})}function parseImportClause(e,t){const n=[];switch(e.token){case 33685505:if(n.push(parseImportDefaultSpecifier(e,t)),consume(e,t,16777234))switch(e.token){case 167774771:parseNameSpaceImport(e,t,n);break;case 41943052:parseNamedImports(e,t,n);break;default:tolerant(e,t,1,tokenDesc(e.token))}break;case 41943052:parseNamedImports(e,t,n);break;case 167774771:parseNameSpaceImport(e,t,n);break;default:report(e,1,tokenDesc(e.token))}return n}function parseNamedImports(e,t,n){for(expect(e,t,41943052);17825807!==e.token;)n.push(parseImportSpecifier(e,t)),17825807!==e.token&&expect(e,t,16777234);expect(e,t,17825807)}function parseImportSpecifier(e,t){const n=getLocation(e),{token:r}=e,o=parseIdentifierName(e,t|exports.Context.DisallowEscapedKeyword,r);let s;return consume(e,t,167843947)?s=parseBindingIdentifier(e,t):(hasBit(r,12288)&&tolerant(e,t,46),hasBit(r,4194304)&&tolerant(e,t,47),s=o),finishNode(t,e,n,{type:"ImportSpecifier",local:s,imported:o})}function parseNameSpaceImport(e,t,n){const r=getLocation(e);expect(e,t,167774771),expect(e,t,167843947,82);const o=parseBindingIdentifier(e,t);n.push(finishNode(t,e,r,{type:"ImportNamespaceSpecifier",local:o}))}function parseModuleSpecifier(e,t){return expect(e,t,69745),33554435!==e.token&&report(e,1,tokenDesc(e.token)),parseLiteral(e,t)}function parseImportDefaultSpecifier(e,t){return finishNode(t,e,getLocation(e),{type:"ImportDefaultSpecifier",local:parseIdentifier(e,t)})}function parseAsyncFunctionOrAssignmentExpression(e,t){return lookahead(e,t,nextTokenIsFuncKeywordOnSameLine)?parseAsyncFunctionOrAsyncGeneratorDeclaration(e,t|exports.Context.RequireIdentifier):parseAssignmentExpression(e,t|exports.Context.AllowIn)}function createParser(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:exports.Flags.AllowDestructuring,token:1048576,tokenRaw:"",lastValue:0,comments:[],sourceFile:t,tokenRegExp:void 0,tokenValue:void 0,labelSet:void 0,errorLocation:void 0,errors:[]}}function parseSource(e,t,n){let r="";t&&(t.module&&(n|=exports.Context.Module),t.next&&(n|=exports.Context.OptionsNext),t.jsx&&(n|=exports.Context.OptionsJSX),t.ranges&&(n|=exports.Context.OptionsRanges),t.loc&&(n|=exports.Context.OptionsLoc),t.raw&&(n|=exports.Context.OptionsRaw),t.rawIdentifier&&(n|=exports.Context.OptionsRawidentifiers),t.globalReturn&&(n|=exports.Context.OptionsGlobalReturn),t.skipShebang&&(n|=exports.Context.OptionsShebang),t.tolerant&&(n|=exports.Context.OptionsTolerant),t.source&&(r=t.source),t.comments&&(n|=exports.Context.OptionsComments),t.impliedStrict&&(n|=exports.Context.Strict),t.experimental&&(n|=exports.Context.OptionsExperimental),t.node&&(n|=exports.Context.OptionsNode));const o=createParser(e,r),s=n&exports.Context.Module?parseModuleItemList(o,n):parseStatementList(o,n),a={type:"Program",sourceType:n&exports.Context.Module?"module":"script",body:s};return n&exports.Context.LocationTracker&&(n&exports.Context.OptionsRanges&&(a.start=0,a.end=e.length),n&exports.Context.OptionsLoc&&(a.loc={start:{line:1,column:0},end:{line:o.line,column:o.column}},r&&(a.loc.source=r))),n&exports.Context.OptionsComments&&(a.comments=o.comments),n&exports.Context.OptionsTolerant&&(a.errors=o.errors),a}function parseStatementList(e,t){const n=[];let r=!0;for(nextToken(e,t|exports.Context.DisallowEscapedKeyword);1048576!==e.token;)r&&33554435!==e.token&&(r=!1),r?(t&exports.Context.Strict||12!==e.tokenRaw.length||"use strict"!==e.tokenValue||(t|=exports.Context.Strict),n.push(parseDirective(e,t))):n.push(parseStatementListItem(e,t));return n}function parse(e,t){return t&&t.module?parseModule(e,t):parseScript(e,t)}function parseScript(e,t){return parseSource(e,t,exports.Context.Empty)}function parseModule(e,t){return parseSource(e,t,exports.Context.Strict|exports.Context.Module)}var estree=Object.freeze({}),index=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}),parser=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});const Parser=parser,version="1.6.9";exports.version="1.6.9",exports.ESTree=estree,exports.Scanner=index,exports.parse=parse,exports.parseSource=parseSource,exports.parseModule=parseModule,exports.parseScript=parseScript,exports.characterType=characterType,exports.errorMessages=errorMessages,exports.constructError=constructError,exports.report=report,exports.tolerant=tolerant,exports.tokenDesc=tokenDesc,exports.descKeyword=descKeyword,exports.Parser=Parser,exports.isValidIdentifierPart=isValidIdentifierPart,exports.isValidIdentifierStart=isValidIdentifierStart,exports.mustEscape=mustEscape,exports.validateBreakOrContinueLabel=validateBreakOrContinueLabel,exports.addLabel=addLabel,exports.popLabel=popLabel,exports.hasLabel=hasLabel,exports.finishNode=finishNode,exports.expect=expect,exports.consume=consume,exports.nextToken=nextToken,exports.hasBit=hasBit,exports.consumeSemicolon=consumeSemicolon,exports.parseExpressionCoverGrammar=parseExpressionCoverGrammar,exports.restoreExpressionCoverGrammar=restoreExpressionCoverGrammar,exports.swapContext=swapContext,exports.validateParams=validateParams,exports.reinterpret=reinterpret,exports.lookahead=lookahead,exports.isValidSimpleAssignmentTarget=isValidSimpleAssignmentTarget,exports.getLocation=getLocation,exports.isValidIdentifier=isValidIdentifier,exports.isLexical=isLexical,exports.isEndOfCaseOrDefaultClauses=isEndOfCaseOrDefaultClauses,exports.nextTokenIsLeftParenOrPeriod=nextTokenIsLeftParenOrPeriod,exports.nextTokenisIdentifierOrParen=nextTokenisIdentifierOrParen,exports.nextTokenIsLeftParen=nextTokenIsLeftParen,exports.nextTokenIsFuncKeywordOnSameLine=nextTokenIsFuncKeywordOnSameLine,exports.isPropertyWithPrivateFieldKey=isPropertyWithPrivateFieldKey,exports.parseAndClassifyIdentifier=parseAndClassifyIdentifier,exports.nameIsArgumentsOrEval=nameIsArgumentsOrEval,exports.setPendingError=setPendingError,exports.isEqualTagNames=isEqualTagNames,exports.isInstanceField=isInstanceField,exports.validateUpdateExpression=validateUpdateExpression,exports.setPendingExpressionError=setPendingExpressionError,exports.validateCoverParenthesizedExpression=validateCoverParenthesizedExpression,exports.validateAsyncArgumentList=validateAsyncArgumentList,exports.isInOrOf=isInOrOf; -- cgit