diff options
Diffstat (limited to 'node_modules/cherow/dist/native-modules/cherow.js')
| -rw-r--r-- | node_modules/cherow/dist/native-modules/cherow.js | 7276 |
1 files changed, 7276 insertions, 0 deletions
diff --git a/node_modules/cherow/dist/native-modules/cherow.js b/node_modules/cherow/dist/native-modules/cherow.js new file mode 100644 index 0000000..aad8f46 --- /dev/null +++ b/node_modules/cherow/dist/native-modules/cherow.js @@ -0,0 +1,7276 @@ +// 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 |= Flags.NewLine;
+ parser.index++;
+ if ((state & ScannerState.LastIsCR) === 0) {
+ parser.column = 0;
+ parser.line++;
+ }
+}
+/**
+ * Scans private name. Stage 3 proposal related
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanPrivateName(parser, context) {
+ if (!(context & Context.InClass) || !isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return 115 /* Hash */;
+}
+/**
+ * Advance to new line
+ *
+ * @param parser Parser object
+ */
+function advanceNewline(parser) {
+ parser.flags |= Flags.NewLine;
+ parser.index++;
+ parser.column = 0;
+ parser.line++;
+}
+const fromCodePoint = (code) => {
+ return code <= 0xFFFF ?
+ String.fromCharCode(code) :
+ String.fromCharCode(((code - 65536 /* NonBMPMin */) >> 10) + 55296 /* LeadSurrogateMin */, ((code - 65536 /* NonBMPMin */) & (1024 - 1)) + 56320 /* TrailSurrogateMin */);
+};
+function readNext(parser) {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.source.length)
+ report(parser, 14 /* UnicodeOutOfRange */);
+ return nextUnicodeChar(parser);
+}
+function toHex(code) {
+ if (code < 48 /* Zero */)
+ return -1;
+ if (code <= 57 /* Nine */)
+ return code - 48 /* Zero */;
+ if (code < 65 /* UpperA */)
+ return -1;
+ if (code <= 70 /* UpperF */)
+ return code - 65 /* UpperA */ + 10;
+ if (code < 97 /* LowerA */)
+ return -1;
+ if (code <= 102 /* LowerF */)
+ return code - 97 /* LowerA */ + 10;
+ return -1;
+}
+function advanceOnMaybeAstral(parser, ch) {
+ parser.index++;
+ parser.column++;
+ if (ch > 0xFFFF)
+ parser.index++;
+} + +/**
+ * Scan escape sequence
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanEscapeSequence(parser, context, first) {
+ switch (first) {
+ case 98 /* LowerB */:
+ return 8 /* Backspace */;
+ case 102 /* LowerF */:
+ return 12 /* FormFeed */;
+ case 114 /* LowerR */:
+ return 13 /* CarriageReturn */;
+ case 110 /* LowerN */:
+ return 10 /* LineFeed */;
+ case 116 /* LowerT */:
+ return 9 /* Tab */;
+ case 118 /* LowerV */:
+ return 11 /* VerticalTab */;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ return Escape.Empty;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ {
+ // 1 to 3 octal digits
+ let code = first - 48 /* Zero */;
+ let index = parser.index + 1;
+ let column = parser.column + 1;
+ let next = parser.source.charCodeAt(index);
+ if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ // Strict mode code allows only \0, then a non-digit.
+ if (code !== 0 || next === 56 /* Eight */ || next === 57 /* Nine */) {
+ if (context & Context.Strict)
+ return Escape.StrictOctal;
+ parser.flags |= Flags.HasOctal;
+ }
+ }
+ else if (context & Context.Strict) {
+ return Escape.StrictOctal;
+ }
+ else {
+ parser.flags |= Flags.HasOctal;
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ parser.index = index - 1;
+ parser.column = column - 1;
+ }
+ return code;
+ }
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ // 1 to 2 octal digits
+ if (context & Context.Strict)
+ return Escape.StrictOctal;
+ let code = first - 48 /* Zero */;
+ const index = parser.index + 1;
+ const column = parser.column + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ code = code * 8 + (next - 48 /* Zero */);
+ parser.lastValue = next;
+ parser.index = index;
+ parser.column = column;
+ }
+ return code;
+ }
+ // `8`, `9` (invalid escapes)
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return Escape.EightOrNine;
+ // ASCII escapes
+ case 120 /* LowerX */:
+ {
+ const ch1 = parser.lastValue = readNext(parser);
+ const hi = toHex(ch1);
+ if (hi < 0)
+ return Escape.InvalidHex;
+ const ch2 = parser.lastValue = readNext(parser);
+ const lo = toHex(ch2);
+ if (lo < 0)
+ return Escape.InvalidHex;
+ return hi << 4 | lo;
+ }
+ // UCS-2/Unicode escapes
+ case 117 /* LowerU */:
+ {
+ let ch = parser.lastValue = readNext(parser);
+ if (ch === 123 /* LeftBrace */) {
+ ch = parser.lastValue = readNext(parser);
+ let code = toHex(ch);
+ if (code < 0)
+ return Escape.InvalidHex;
+ ch = parser.lastValue = readNext(parser);
+ while (ch !== 125 /* RightBrace */) {
+ const digit = toHex(ch);
+ if (digit < 0)
+ return Escape.InvalidHex;
+ code = code * 16 + digit;
+ // Code point out of bounds
+ if (code > 1114111 /* NonBMPMax */)
+ return Escape.OutOfRange;
+ ch = parser.lastValue = readNext(parser);
+ }
+ return code;
+ }
+ else {
+ // \uNNNN
+ let codePoint = toHex(ch);
+ if (codePoint < 0)
+ return Escape.InvalidHex;
+ for (let i = 0; i < 3; i++) {
+ ch = parser.lastValue = readNext(parser);
+ const digit = toHex(ch);
+ if (digit < 0)
+ return Escape.InvalidHex;
+ codePoint = codePoint * 16 + digit;
+ }
+ return codePoint;
+ }
+ }
+ default:
+ return parser.source.charCodeAt(parser.index);
+ }
+}
+/**
+ * Throws a string error for either string or template literal
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function throwStringError(parser, context, code) {
+ switch (code) {
+ case Escape.Empty:
+ return;
+ case Escape.StrictOctal:
+ report(parser, context & Context.TaggedTemplate ?
+ 76 /* TemplateOctalLiteral */ :
+ 11 /* StrictOctalEscape */);
+ case Escape.EightOrNine:
+ report(parser, 13 /* InvalidEightAndNine */);
+ case Escape.InvalidHex:
+ report(parser, 75 /* MalformedEscape */, 'hexadecimal');
+ case Escape.OutOfRange:
+ report(parser, 14 /* UnicodeOutOfRange */);
+ /* istanbul ignore next */
+ default:
+ // ignore
+ }
+}
+/**
+ * Scan a string literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote codepoint
+ */
+function scanString(parser, context, quote) {
+ const { index: start, lastValue } = parser;
+ let ret = '';
+ parser.index++;
+ parser.column++; // consume quote
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ switch (ch) {
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ report(parser, 6 /* UnterminatedString */);
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch > 128 /* MaxAsciiCharacter */) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ const code = scanEscapeSequence(parser, context, ch);
+ if (code >= 0)
+ ret += fromCodePoint(code);
+ else
+ throwStringError(parser, context, code);
+ ch = parser.lastValue;
+ }
+ break;
+ default:
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++; // consume quote
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ return 33554435 /* StringLiteral */;
+} + +/**
+ * Consumes template brace
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function consumeTemplateBrace(parser, context) {
+ if (parser.index >= parser.length)
+ report(parser, 9 /* UnterminatedTemplate */);
+ // Upon reaching a '}', consume it and rewind the scanner state
+ parser.index--;
+ parser.column--;
+ return scanTemplate(parser, context);
+}
+/**
+ * Scan template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param first Codepoint
+ */
+function scanTemplate(parser, context) {
+ const { index: start, lastValue } = parser;
+ let tail = true;
+ let ret = '';
+ let ch = readNext(parser);
+ loop: while (ch !== 96 /* Backtick */) {
+ switch (ch) {
+ // Break after a literal `${` (thus the dedicated code path).
+ case 36 /* Dollar */:
+ {
+ const index = parser.index + 1;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 123 /* LeftBrace */) {
+ parser.index = index;
+ parser.column++;
+ tail = false;
+ break loop;
+ }
+ ret += '$';
+ break;
+ }
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch >= 128) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ // Because octals are forbidden in escaped template sequences and the fact that
+ // both string and template scanning uses the same method - 'scanEscapeSequence',
+ // we set the strict context mask.
+ const code = scanEscapeSequence(parser, context | Context.Strict, ch);
+ if (code >= 0) {
+ ret += fromCodePoint(code);
+ }
+ else if (code !== Escape.Empty && context & Context.TaggedTemplate) {
+ ret = undefined;
+ ch = scanLooserTemplateSegment(parser, parser.lastValue);
+ if (ch < 0) {
+ tail = false;
+ }
+ break loop;
+ }
+ else {
+ throwStringError(parser, context | Context.TaggedTemplate, code);
+ }
+ ch = parser.lastValue;
+ }
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ // falls through
+ default:
+ if (ret != null)
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++;
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ if (tail) {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 1);
+ return 33554441 /* TemplateTail */;
+ }
+ else {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 2);
+ return 33554440 /* TemplateCont */;
+ }
+}
+/**
+ * Scan looser template segment
+ *
+ * @param parser Parser object
+ * @param ch codepoint
+ */
+function scanLooserTemplateSegment(parser, ch) {
+ while (ch !== 96 /* Backtick */) {
+ if (ch === 36 /* Dollar */ && parser.source.charCodeAt(parser.index + 1) === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return -ch;
+ }
+ // Skip '\' and continue to scan the template token to search
+ // for the end, without validating any escape sequences
+ ch = readNext(parser);
+ }
+ return ch;
+} + +// 11.8.3 Numeric Literals
+/**
+ * Scans hex integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HexIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanHexIntegerLiteral(parser, context) {
+ parser.index++;
+ parser.column++;
+ let state = NumericState.None;
+ let value = toHex(parser.source.charCodeAt(parser.index));
+ if (value < 0)
+ report(parser, 0 /* Unexpected */);
+ parser.index++;
+ parser.column++;
+ while (parser.index < parser.length) {
+ const next = parser.source.charCodeAt(parser.index);
+ if (context & Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ const digit = toHex(next);
+ if (digit < 0)
+ break;
+ value = value * 16 + digit;
+ parser.index++;
+ parser.column++;
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+}
+/**
+ * Scans binary and octal integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalIntegerLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BinaryIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanOctalOrBinary(parser, context, base) {
+ parser.index++;
+ parser.column++;
+ let digits = 0;
+ let ch;
+ let value = 0;
+ let state = NumericState.None;
+ while (parser.index < parser.length) {
+ ch = parser.source.charCodeAt(parser.index);
+ if (context & Context.OptionsNext && ch === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ const converted = ch - 48 /* Zero */;
+ if (!(ch >= 48 /* Zero */ && ch <= 57 /* Nine */) || converted >= base)
+ break;
+ value = value * base + converted;
+ parser.index++;
+ parser.column++;
+ digits++;
+ }
+ if (digits === 0)
+ report(parser, 0 /* Unexpected */);
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+}
+/**
+ * Scans implicit octal digits
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalDigits)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanImplicitOctalDigits(parser, context) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ if (context & Context.Strict)
+ report(parser, 0 /* Unexpected */);
+ let index = parser.index;
+ let column = parser.column;
+ let code = 0;
+ parser.flags |= Flags.HasOctal;
+ // Implicit octal, unless there is a non-octal digit.
+ // (Annex B.1.1 on Numeric Literals)
+ while (index < parser.length) {
+ const next = parser.source.charCodeAt(index);
+ if (next === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ else if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ return scanNumericLiteral(parser, context);
+ }
+ else {
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ }
+ parser.index = index;
+ parser.column = column;
+ return assembleNumericLiteral(parser, context, code, consumeOpt(parser, 110 /* LowerN */));
+ }
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ parser.flags |= Flags.HasOctal;
+ default:
+ if (context & Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ return scanNumericLiteral(parser, context);
+ }
+}
+/**
+ * Scans signed integer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SignedInteger)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanSignedInteger(parser, end) {
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 43 /* Plus */ || next === 45 /* Hyphen */) {
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (!(next >= 48 /* Zero */ && next <= 57 /* Nine */)) {
+ report(parser, 0 /* Unexpected */);
+ }
+ const preNumericPart = parser.index;
+ const finalFragment = scanDecimalDigitsOrSeparator(parser);
+ return parser.source.substring(end, preNumericPart) + finalFragment;
+}
+/**
+ * Scans numeric literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanNumericLiteral(parser, context, state = NumericState.None) {
+ let value = state & NumericState.Float ?
+ 0 :
+ scanDecimalAsSmi(parser, context);
+ const next = parser.source.charCodeAt(parser.index);
+ // I know I'm causing a bug here. The question is - will anyone figure this out?
+ if (next !== 46 /* Period */ && next !== 95 /* Underscore */ && !isValidIdentifierStart(next)) {
+ return assembleNumericLiteral(parser, context, value);
+ }
+ if (consumeOpt(parser, 46 /* Period */)) {
+ if (context & Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ state |= NumericState.Float;
+ value = `${value}.${scanDecimalDigitsOrSeparator(parser)}`;
+ }
+ const end = parser.index;
+ if (consumeOpt(parser, 110 /* LowerN */)) {
+ if (state & NumericState.Float)
+ report(parser, 0 /* Unexpected */);
+ state |= NumericState.BigInt;
+ }
+ if (consumeOpt(parser, 101 /* LowerE */) || consumeOpt(parser, 69 /* UpperE */)) {
+ state |= NumericState.Float;
+ value += scanSignedInteger(parser, end);
+ }
+ if (isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 0 /* Unexpected */);
+ }
+ return assembleNumericLiteral(parser, context, state & NumericState.Float ? parseFloat(value) : parseInt(value, 10), !!(state & NumericState.BigInt));
+}
+/**
+ * Internal helper function for scanning numeric separators.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state NumericState state
+ */
+function scanNumericSeparator(parser, state) {
+ parser.index++;
+ parser.column++;
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ state |= NumericState.SeenSeparator;
+ return state;
+}
+/**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanDecimalDigitsOrSeparator(parser) {
+ let start = parser.index;
+ let state = NumericState.None;
+ let ret = '';
+ loop: while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 95 /* Underscore */:
+ const preUnderscoreIndex = parser.index;
+ state = scanNumericSeparator(parser, state);
+ ret += parser.source.substring(start, preUnderscoreIndex);
+ start = parser.index;
+ continue;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ state = state & ~NumericState.SeenSeparator;
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ break loop;
+ }
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return ret + parser.source.substring(start, parser.index);
+}
+/**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanDecimalAsSmi(parser, context) {
+ let state = NumericState.None;
+ let value = 0;
+ let next = parser.source.charCodeAt(parser.index);
+ while (next >= 48 /* Zero */ && next <= 57 /* Nine */ || next === 95 /* Underscore */) {
+ if (context & Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ next = parser.source.charCodeAt(parser.index);
+ continue;
+ }
+ state &= ~NumericState.SeenSeparator;
+ value = value * 10 + (next - 48 /* Zero */);
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (state & NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return value;
+}
+/**
+ * Internal helper function that assamble the number scanning parts and return
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param value The numeric value
+ */
+function assembleNumericLiteral(parser, context, value, isBigInt = false) {
+ parser.tokenValue = value;
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ return isBigInt ? 33554551 /* BigIntLiteral */ : 33554434 /* NumericLiteral */;
+} + +/**
+ * Scan identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+function scanIdentifier(parser, context, first) {
+ let start = parser.index;
+ let ret = '';
+ let isEscaped = false;
+ if (first)
+ advanceOnMaybeAstral(parser, first);
+ loop: while (parser.index < parser.length) {
+ const index = parser.index;
+ let ch = parser.source.charCodeAt(index);
+ switch (ch) {
+ case 92 /* Backslash */:
+ ret += parser.source.slice(start, index);
+ ret += scanUnicodeCodePointEscape(parser);
+ start = parser.index;
+ isEscaped = true;
+ break;
+ default:
+ if (ch >= 0xD800 && ch <= 0xDBFF) {
+ const lo = parser.source.charCodeAt(index + 1);
+ ch = (ch & 0x3FF) << 10 | lo & 0x3FF | 0x10000;
+ }
+ if (!isIdentifierPart(ch))
+ break loop;
+ advanceOnMaybeAstral(parser, ch);
+ }
+ }
+ if (start < parser.index)
+ ret += parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ const len = ret.length;
+ // Keywords are between 2 and 11 characters long and start with a lowercase letter
+ // https://tc39.github.io/ecma262/#sec-keywords
+ if (len >= 2 && len <= 11) {
+ const token = descKeyword(ret);
+ if (token > 0) {
+ if (isEscaped) {
+ if (context & Context.DisallowEscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ // Here we fall back to a mutual parser flag if the escaped keyword isn't disallowed through
+ // context masks. This is similiar to how V8 does it - they are using an
+ // 'escaped_keyword' token.
+ // - J.K. Thomas
+ parser.flags |= Flags.EscapedKeyword;
+ }
+ return token;
+ }
+ }
+ if (context & Context.OptionsRawidentifiers)
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ return 33685505 /* Identifier */;
+}
+/**
+ * Scanning chars in the range 0...127, and treat them as an possible
+ * identifier. This allows subsequent checking to be faster.
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param first Code point
+ */
+function scanMaybeIdentifier(parser, context, first) {
+ first = nextUnicodeChar(parser);
+ if (!isValidIdentifierStart(first)) {
+ report(parser, 10 /* UnexpectedChar */, escapeInvalidCharacters(first));
+ }
+ return scanIdentifier(parser, context, first);
+}
+/**
+ * Scan unicode codepoint escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+function scanUnicodeCodePointEscape(parser) {
+ const { index } = parser;
+ if (index + 5 < parser.length) {
+ if (parser.source.charCodeAt(index + 1) !== 117 /* LowerU */) {
+ report(parser, 0 /* Unexpected */);
+ }
+ parser.index += 2;
+ parser.column += 2;
+ const code = scanIdentifierUnicodeEscape(parser);
+ if (code >= 55296 /* LeadSurrogateMin */ && code <= 56319 /* LeadSurrogateMax */) {
+ report(parser, 74 /* UnexpectedSurrogate */);
+ }
+ if (!isIdentifierPart(code)) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ return fromCodePoint(code);
+ }
+ report(parser, 0 /* Unexpected */);
+}
+/**
+ * Scan identifier unicode escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+function scanIdentifierUnicodeEscape(parser) {
+ // Accept both \uxxxx and \u{xxxxxx}. In the latter case, the number of
+ // hex digits between { } is arbitrary. \ and u have already been read.
+ let ch = parser.source.charCodeAt(parser.index);
+ let codePoint = 0;
+ // '\u{DDDDDDDD}'
+ if (ch === 123 /* LeftBrace */) { // {
+ ch = readNext(parser);
+ let digit = toHex(ch);
+ while (digit >= 0) {
+ codePoint = (codePoint << 4) | digit;
+ if (codePoint > 1114111 /* NonBMPMax */) {
+ report(parser, 89 /* UndefinedUnicodeCodePoint */);
+ }
+ parser.index++;
+ parser.column++;
+ digit = toHex(parser.source.charCodeAt(parser.index));
+ }
+ if (parser.source.charCodeAt(parser.index) !== 125 /* RightBrace */) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ consumeOpt(parser, 125 /* RightBrace */);
+ // '\uDDDD'
+ }
+ else {
+ for (let i = 0; i < 4; i++) {
+ ch = parser.source.charCodeAt(parser.index);
+ const digit = toHex(ch);
+ if (digit < 0)
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ codePoint = (codePoint << 4) | digit;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ return codePoint;
+} + +// 11.4 Comments
+/**
+ * Skips single HTML comments. Same behavior as in V8.
+ *
+ * @param parser Parser Object
+ * @param context Context masks.
+ * @param state Scanner state
+ * @param type Comment type
+ */
+function skipSingleHTMLComment(parser, context, state, type) {
+ if (context & Context.Module)
+ report(parser, 90 /* HtmlCommentInModule */);
+ return skipSingleLineComment(parser, context, state, type);
+}
+/**
+ * Skips SingleLineComment, SingleLineHTMLCloseComment and SingleLineHTMLOpenComment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SingleLineComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLOpenComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLCloseComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ * @param type Comment type
+ */
+function skipSingleLineComment(parser, context, state, type) {
+ const start = parser.index;
+ const collectable = !!(context & Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 13 /* CarriageReturn */:
+ advanceNewline(parser);
+ if ((parser.index < parser.length) && parser.source.charCodeAt(parser.index) === 10 /* LineFeed */)
+ parser.index++;
+ return state | ScannerState.NewLine;
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ advanceNewline(parser);
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state | ScannerState.NewLine;
+ default:
+ parser.index++;
+ parser.column++;
+ }
+ }
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state;
+}
+/**
+ * Skips multiline comment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-MultiLineComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ */
+function skipMultiLineComment(parser, context, state) {
+ const start = parser.index;
+ const collectable = !!(context & Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 42 /* Asterisk */:
+ parser.index++;
+ parser.column++;
+ state &= ~ScannerState.LastIsCR;
+ if (consumeOpt(parser, 47 /* Slash */)) {
+ if (collectable)
+ addComment(parser, context, 'MultiLine', start);
+ return state;
+ }
+ break;
+ // Mark multiline comments containing linebreaks as new lines
+ // so we can perfectly handle edge cases like: '1/*\n*/--> a comment'
+ case 13 /* CarriageReturn */:
+ state |= ScannerState.NewLine | ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ break;
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ default:
+ state &= ~ScannerState.LastIsCR;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ // Unterminated multi-line comment.
+ tolerant(parser, context, 8 /* UnterminatedComment */);
+}
+/**
+ * Add comments
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param type Comment type
+ * @param commentStart Start position of comment
+ */
+function addComment(parser, context, type, commentStart) {
+ const { index, startIndex: start, startLine, startColumn, lastLine, lastColumn } = parser;
+ const comment = {
+ type,
+ value: parser.source.slice(commentStart, type === 'MultiLine' ? index - 2 : index),
+ start,
+ end: index,
+ };
+ if (context & Context.OptionsLoc) {
+ comment.loc = {
+ start: { line: startLine, column: startColumn },
+ end: { line: lastLine, column: lastColumn },
+ };
+ }
+ parser.comments.push(comment);
+} + +/**
+ * Scan
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-punctuatorss)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scan(parser, context) {
+ parser.flags &= ~Flags.NewLine | Flags.EscapedKeyword;
+ const lineStart = parser.index === 0;
+ let state = ScannerState.None;
+ while (parser.index < parser.length) {
+ if (!lineStart) {
+ parser.startIndex = parser.index;
+ parser.startColumn = parser.column;
+ parser.startLine = parser.line;
+ }
+ const first = parser.source.charCodeAt(parser.index);
+ if (first > 128 /* MaxAsciiCharacter */) {
+ switch (first) {
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ case 65519 /* ByteOrderMark */:
+ case 160 /* NonBreakingSpace */:
+ case 5760 /* Ogham */:
+ case 8192 /* EnQuad */:
+ case 8193 /* EmQuad */:
+ case 8194 /* EnSpace */:
+ case 8195 /* EmSpace */:
+ case 8196 /* ThreePerEmSpace */:
+ case 8197 /* FourPerEmSpace */:
+ case 8198 /* SixPerEmSpace */:
+ case 8199 /* FigureSpace */:
+ case 8200 /* PunctuationSpace */:
+ case 8201 /* ThinSpace */:
+ case 8202 /* HairSpace */:
+ case 8239 /* NarrowNoBreakSpace */:
+ case 8287 /* MathematicalSpace */:
+ case 12288 /* IdeographicSpace */:
+ case 65279 /* Zwnbs */:
+ case 8205 /* Zwj */:
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ return scanMaybeIdentifier(parser, context, first);
+ }
+ }
+ else {
+ // Note: Here we first get rid of LT and WS, then we make sure that the lookup time
+ // for the single punctuator char is short as possible. A single punctuator
+ // char is a valid token that cannot also be a prefix of a combination
+ // of long tokens - e.g. '(', ')' and '=' is valid. '==' is not.
+ switch (first) {
+ case 13 /* CarriageReturn */:
+ state |= ScannerState.NewLine | ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~ScannerState.LastIsCR | ScannerState.NewLine;
+ break;
+ case 9 /* Tab */:
+ case 11 /* VerticalTab */:
+ case 12 /* FormFeed */:
+ case 32 /* Space */:
+ parser.index++;
+ parser.column++;
+ break;
+ // `(`
+ case 40 /* LeftParen */:
+ parser.index++;
+ parser.column++;
+ return 50331659 /* LeftParen */;
+ // `)`
+ case 41 /* RightParen */:
+ parser.index++;
+ parser.column++;
+ return 16 /* RightParen */;
+ // `,`
+ case 44 /* Comma */:
+ parser.index++;
+ parser.column++;
+ return 16777234 /* Comma */;
+ // `:`
+ case 58 /* Colon */:
+ parser.index++;
+ parser.column++;
+ return 16777237 /* Colon */;
+ // `;`
+ case 59 /* Semicolon */:
+ parser.index++;
+ parser.column++;
+ return 17825809 /* Semicolon */;
+ // `?`
+ case 63 /* QuestionMark */:
+ parser.index++;
+ parser.column++;
+ return 22 /* QuestionMark */;
+ // `]`
+ case 93 /* RightBracket */:
+ parser.index++;
+ parser.column++;
+ return 20 /* RightBracket */;
+ // `{`
+ case 123 /* LeftBrace */:
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ // `}`
+ case 125 /* RightBrace */:
+ parser.index++;
+ parser.column++;
+ return 17825807 /* RightBrace */;
+ // `~`
+ case 126 /* Tilde */:
+ parser.index++;
+ parser.column++;
+ return 301989934 /* Complement */;
+ // `[`
+ case 91 /* LeftBracket */:
+ parser.index++;
+ parser.column++;
+ return 41943059 /* LeftBracket */;
+ // `@`
+ case 64 /* At */:
+ parser.index++;
+ parser.column++;
+ return 120 /* At */;
+ // `/`, `/=`, `/>`
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774773 /* Divide */;
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipSingleLineComment(parser, context, state, 'SingleLine');
+ continue;
+ }
+ case 42 /* Asterisk */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipMultiLineComment(parser, context, state);
+ continue;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 100663333 /* DivideAssign */;
+ }
+ default:
+ return 167774773 /* Divide */;
+ }
+ }
+ // `-`, `--`, `-=`
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++; // skip `-`
+ const next = parser.source.charCodeAt(parser.index);
+ switch (next) {
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++;
+ if ((state & ScannerState.NewLine || lineStart) &&
+ consumeOpt(parser, 62 /* GreaterThan */)) {
+ state = skipSingleHTMLComment(parser, context, state, 'HTMLClose');
+ continue;
+ }
+ return 570425372 /* Decrement */;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 67108899 /* SubtractAssign */;
+ }
+ default:
+ return 436209968 /* Subtract */;
+ }
+ }
+ // `<`, `<=`, `<<`, `<<=`, `</`, <!--
+ case 60 /* LessThan */:
+ parser.index++;
+ parser.column++; // skip `<`
+ if (consumeOpt(parser, 33 /* Exclamation */) &&
+ consumeOpt(parser, 45 /* Hyphen */) &&
+ consumeOpt(parser, 45 /* Hyphen */)) {
+ state = skipSingleHTMLComment(parser, context, state, 'HTMLOpen');
+ continue;
+ }
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 60 /* LessThan */:
+ parser.index++;
+ parser.column++;
+ return consumeOpt(parser, 61 /* EqualSign */) ?
+ 67108894 /* ShiftLeftAssign */ :
+ 167774273 /* ShiftLeft */;
+ case 61 /* EqualSign */:
+ parser.index++;
+ parser.column++;
+ return 167774013 /* LessThanOrEqual */;
+ case 47 /* Slash */:
+ {
+ if (!(context & Context.OptionsJSX))
+ break;
+ const index = parser.index + 1;
+ // Check that it's not a comment start.
+ if (index < parser.length) {
+ const next = parser.source.charCodeAt(index);
+ if (next === 42 /* Asterisk */ || next === 47 /* Slash */)
+ break;
+ }
+ parser.index++;
+ parser.column++;
+ return 25 /* JSXClose */;
+ }
+ default: // ignore
+ return 167774015 /* LessThan */;
+ }
+ // `!`, `!=`, `!==`
+ case 33 /* Exclamation */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 301989933 /* Negate */;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167773756 /* LooseNotEqual */;
+ return 167773754 /* StrictNotEqual */;
+ // `'string'`, `"string"`
+ case 39 /* SingleQuote */:
+ case 34 /* DoubleQuote */:
+ return scanString(parser, context, first);
+ // `%`, `%=`
+ case 37 /* Percent */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167774772 /* Modulo */;
+ return 67108902 /* ModuloAssign */;
+ // `&`, `&&`, `&=`
+ case 38 /* Ampersand */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 38 /* Ampersand */) {
+ parser.index++;
+ parser.column++;
+ return 169869879 /* LogicalAnd */;
+ }
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108905 /* BitwiseAndAssign */;
+ }
+ return 167773508 /* BitwiseAnd */;
+ }
+ // `*`, `**`, `*=`, `**=`
+ case 42 /* Asterisk */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774771 /* Multiply */;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108900 /* MultiplyAssign */;
+ }
+ if (next !== 42 /* Asterisk */)
+ return 167774771 /* Multiply */;
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167775030 /* Exponentiate */;
+ return 67108897 /* ExponentiateAssign */;
+ }
+ // `+`, `++`, `+=`
+ case 43 /* Plus */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 436209967 /* Add */;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 43 /* Plus */) {
+ parser.index++;
+ parser.column++;
+ return 570425371 /* Increment */;
+ }
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108898 /* AddAssign */;
+ }
+ return 436209967 /* Add */;
+ }
+ // `\\u{N}var`
+ case 92 /* Backslash */:
+ return scanIdentifier(parser, context);
+ // `=`, `==`, `===`, `=>`
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ if (consumeOpt(parser, 61 /* EqualSign */)) {
+ return 167773753 /* StrictEqual */;
+ }
+ else {
+ return 167773755 /* LooseEqual */;
+ }
+ }
+ else if (next === 62 /* GreaterThan */) {
+ parser.index++;
+ parser.column++;
+ return 10 /* Arrow */;
+ }
+ return 83886109 /* Assign */;
+ }
+ // `>`, `>=`, `>>`, `>>>`, `>>=`, `>>>=`
+ case 62 /* GreaterThan */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774016 /* GreaterThan */;
+ if (context & Context.InJSXChild)
+ return 167774016 /* GreaterThan */;
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 167774014 /* GreaterThanOrEqual */;
+ }
+ if (next !== 62 /* GreaterThan */)
+ return 167774016 /* GreaterThan */;
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ if (next === 62 /* GreaterThan */) {
+ parser.index++;
+ parser.column++;
+ if (consumeOpt(parser, 61 /* EqualSign */)) {
+ return 67108896 /* LogicalShiftRightAssign */;
+ }
+ else {
+ return 167774275 /* LogicalShiftRight */;
+ }
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108895 /* ShiftRightAssign */;
+ }
+ return 167774274 /* ShiftRight */;
+ }
+ // `^`, `^=`
+ case 94 /* Caret */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167773254 /* BitwiseXor */;
+ return 67108903 /* BitwiseXorAssign */;
+ // ``string``
+ case 96 /* Backtick */:
+ return scanTemplate(parser, context);
+ // `|`, `||`, `|=`
+ case 124 /* VerticalBar */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 124 /* VerticalBar */) {
+ parser.index++;
+ parser.column++;
+ return 169869624 /* LogicalOr */;
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108904 /* BitwiseOrAssign */;
+ }
+ return 167772997 /* BitwiseOr */;
+ }
+ // `.`, `...`, `.123` (numeric literal)
+ case 46 /* Period */:
+ {
+ let index = parser.index + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 57 /* Nine */) {
+ scanNumericLiteral(parser, context, NumericState.Float);
+ return 33554434 /* NumericLiteral */;
+ }
+ else if (next === 46 /* Period */) {
+ index++;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 46 /* Period */) {
+ parser.index = index + 1;
+ parser.column += 3;
+ return 14 /* Ellipsis */;
+ }
+ }
+ parser.index++;
+ parser.column++;
+ return 16777229 /* Period */;
+ }
+ // `#`
+ case 35 /* Hash */:
+ {
+ parser.index++;
+ parser.column++;
+ const index = parser.index;
+ const next = parser.source.charCodeAt(index);
+ if (context & Context.OptionsShebang &&
+ lineStart &&
+ next === 33 /* Exclamation */) {
+ parser.index = index + 1;
+ skipSingleLineComment(parser, context, ScannerState.None, 'SheBang');
+ continue;
+ }
+ return scanPrivateName(parser, context);
+ }
+ // `0`...`9`
+ case 48 /* Zero */:
+ {
+ parser.index++;
+ parser.column++;
+ switch (parser.source.charCodeAt(parser.index)) {
+ // Hex number - '0x', '0X'
+ case 88 /* UpperX */:
+ case 120 /* LowerX */:
+ return scanHexIntegerLiteral(parser, context);
+ // Binary number - '0b', '0B'
+ case 66 /* UpperB */:
+ case 98 /* LowerB */:
+ return scanOctalOrBinary(parser, context, 2);
+ // Octal number - '0o', '0O'
+ case 79 /* UpperO */:
+ case 111 /* LowerO */:
+ return scanOctalOrBinary(parser, context, 8);
+ default:
+ // Implicit octal digits startign with '0'
+ return scanImplicitOctalDigits(parser, context);
+ }
+ }
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return scanNumericLiteral(parser, context);
+ // `a`...`z`, `A`...`Z`, `_var`, `$var`
+ case 65 /* UpperA */:
+ case 66 /* UpperB */:
+ case 67 /* UpperC */:
+ case 68 /* UpperD */:
+ case 69 /* UpperE */:
+ case 70 /* UpperF */:
+ case 71 /* UpperG */:
+ case 72 /* UpperH */:
+ case 73 /* UpperI */:
+ case 74 /* UpperJ */:
+ case 75 /* UpperK */:
+ case 76 /* UpperL */:
+ case 77 /* UpperM */:
+ case 78 /* UpperN */:
+ case 79 /* UpperO */:
+ case 80 /* UpperP */:
+ case 81 /* UpperQ */:
+ case 82 /* UpperR */:
+ case 83 /* UpperS */:
+ case 84 /* UpperT */:
+ case 85 /* UpperU */:
+ case 86 /* UpperV */:
+ case 87 /* UpperW */:
+ case 88 /* UpperX */:
+ case 89 /* UpperY */:
+ case 90 /* UpperZ */:
+ case 36 /* Dollar */:
+ case 95 /* Underscore */:
+ case 97 /* LowerA */:
+ case 98 /* LowerB */:
+ case 99 /* LowerC */:
+ case 100 /* LowerD */:
+ case 101 /* LowerE */:
+ case 102 /* LowerF */:
+ case 103 /* LowerG */:
+ case 104 /* LowerH */:
+ case 105 /* LowerI */:
+ case 106 /* LowerJ */:
+ case 107 /* LowerK */:
+ case 108 /* LowerL */:
+ case 109 /* LowerM */:
+ case 110 /* LowerN */:
+ case 111 /* LowerO */:
+ case 112 /* LowerP */:
+ case 113 /* LowerQ */:
+ case 114 /* LowerR */:
+ case 115 /* LowerS */:
+ case 116 /* LowerT */:
+ case 117 /* LowerU */:
+ case 118 /* LowerV */:
+ case 119 /* LowerW */:
+ case 120 /* LowerX */:
+ case 121 /* LowerY */:
+ case 122 /* LowerZ */:
+ default:
+ return scanIdentifier(parser, context, first);
+ }
+ }
+ }
+ return 1048576 /* EndOfSource */;
+} + +/**
+ * Scans regular expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanRegularExpression(parser, context) {
+ const bodyStart = parser.index;
+ let preparseState = RegexState.Empty;
+ loop: while (true) {
+ const ch = parser.source.charCodeAt(parser.index);
+ parser.index++;
+ parser.column++;
+ if (preparseState & RegexState.Escape) {
+ preparseState &= ~RegexState.Escape;
+ }
+ else {
+ switch (ch) {
+ case 47 /* Slash */:
+ if (!preparseState)
+ break loop;
+ else
+ break;
+ case 92 /* Backslash */:
+ preparseState |= RegexState.Escape;
+ break;
+ case 91 /* LeftBracket */:
+ preparseState |= RegexState.Class;
+ break;
+ case 93 /* RightBracket */:
+ preparseState &= RegexState.Escape;
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ report(parser, 7 /* UnterminatedRegExp */);
+ default: // ignore
+ }
+ }
+ if (parser.index >= parser.source.length) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ const bodyEnd = parser.index - 1;
+ let mask = RegexFlags.Empty;
+ const { index: flagStart } = parser;
+ loop: while (parser.index < parser.source.length) {
+ const code = parser.source.charCodeAt(parser.index);
+ switch (code) {
+ case 103 /* LowerG */:
+ if (mask & RegexFlags.Global)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'g');
+ mask |= RegexFlags.Global;
+ break;
+ case 105 /* LowerI */:
+ if (mask & RegexFlags.IgnoreCase)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'i');
+ mask |= RegexFlags.IgnoreCase;
+ break;
+ case 109 /* LowerM */:
+ if (mask & RegexFlags.Multiline)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'm');
+ mask |= RegexFlags.Multiline;
+ break;
+ case 117 /* LowerU */:
+ if (mask & RegexFlags.Unicode)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'u');
+ mask |= RegexFlags.Unicode;
+ break;
+ case 121 /* LowerY */:
+ if (mask & RegexFlags.Sticky)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'y');
+ mask |= RegexFlags.Sticky;
+ break;
+ case 115 /* LowerS */:
+ if (mask & RegexFlags.DotAll)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 's');
+ mask |= RegexFlags.DotAll;
+ break;
+ default:
+ if (!isIdentifierPart(code))
+ break loop;
+ report(parser, 16 /* UnexpectedTokenRegExpFlag */, fromCodePoint(code));
+ }
+ parser.index++;
+ parser.column++;
+ }
+ const flags = parser.source.slice(flagStart, parser.index);
+ const pattern = parser.source.slice(bodyStart, bodyEnd);
+ parser.tokenRegExp = { pattern, flags };
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ parser.tokenValue = validate(parser, context, pattern, flags);
+ return 33554436 /* RegularExpression */;
+}
+/**
+ * Validates regular expressions
+ *
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param pattern Regexp body
+ * @param flags Regexp flags
+ */
+function validate(parser, context, pattern, flags) {
+ if (!(context & Context.OptionsNode)) {
+ try {
+ }
+ catch (e) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ try {
+ return new RegExp(pattern, flags);
+ }
+ catch (e) {
+ return null;
+ }
+} + +// 12.15.5 Destructuring Assignment
+/**
+ * Parses either a binding identifier or binding pattern
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBindingIdentifierOrPattern(parser, context, args = []) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ return token === 41943052 /* LeftBrace */ ?
+ parserObjectAssignmentPattern(parser, context) :
+ parseArrayAssignmentPattern(parser, context, args);
+ }
+ else if (token & (262144 /* IsAwait */ | 1073741824 /* IsYield */)) {
+ if (token & 262144 /* IsAwait */ && (context & (Context.Async | Context.Module))) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ else if (token & 1073741824 /* IsYield */ && (context & (Context.Yield | Context.Strict))) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ }
+ args.push(parser.tokenValue);
+ return parseBindingIdentifier(parser, context);
+}
+/**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BindingIdentifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBindingIdentifier(parser, context) {
+ const { token } = parser;
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (context & Context.BlockScope && token === 33574984 /* LetKeyword */) {
+ // let is disallowed as a lexically bound name
+ tolerant(parser, context, 27 /* LetInLexicalBinding */);
+ }
+ else if (hasBit(token, 20480 /* FutureReserved */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ else if (!isValidIdentifier(context, token)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+}
+/**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAssignmentRestElement(parser, context, args) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+}
+/**
+ * Parse rest property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+// tslint:disable-next-line:function-name
+function AssignmentRestProperty(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const { token } = parser;
+ const argument = parseBindingIdentifierOrPattern(parser, context);
+ if (hasBit(token, 8388608 /* IsBindingPattern */))
+ tolerant(parser, context, 94 /* InvalidRestBindingPattern */);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+}
+/**
+ * ArrayAssignmentPattern[Yield] :
+ * [ Elisionopt AssignmentRestElement[?Yield]opt ]
+ * [ AssignmentElementList[?Yield] ]
+ * [ AssignmentElementList[?Yield] , Elisionopt AssignmentRestElement[?Yield]opt ]
+ *
+ * AssignmentRestElement[Yield] :
+ * ... DestructuringAssignmentTarget[?Yield]
+ *
+ * AssignmentElementList[Yield] :
+ * AssignmentElisionElement[?Yield]
+ * AssignmentElementList[?Yield] , AssignmentElisionElement[?Yield]
+ *
+ * AssignmentElisionElement[Yield] :
+ * Elisionopt AssignmentElement[?Yield]
+ *
+ * AssignmentElement[Yield] :
+ * DestructuringAssignmentTarget[?Yield] Initializer[In,?Yield]opt
+ *
+ * DestructuringAssignmentTarget[Yield] :
+ * LeftHandSideExpression[?Yield]
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param Parser object
+ * @param Context masks
+ */
+function parseArrayAssignmentPattern(parser, context, args) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else {
+ if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseAssignmentRestElement(parser, context, args));
+ break;
+ }
+ else {
+ elements.push(parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseBindingInitializer));
+ }
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ // tslint:disable-next-line:no-object-literal-type-assertion
+ return finishNode(context, parser, pos, {
+ type: 'ArrayPattern',
+ elements,
+ });
+}
+/**
+ * Parse object assignment pattern
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+function parserObjectAssignmentPattern(parser, context) {
+ const pos = getLocation(parser);
+ const properties = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ properties.push(AssignmentRestProperty(parser, context));
+ break;
+ }
+ properties.push(parseAssignmentProperty(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ObjectPattern',
+ properties,
+ });
+}
+/** Parse assignment pattern
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param left LHS of assignment pattern
+ * @param pos Location
+ */
+function parseAssignmentPattern(parser, context, left, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression),
+ });
+}
+/**
+ * Parse binding initializer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBindingInitializer(parser, context) {
+ const pos = getLocation(parser);
+ const left = parseBindingIdentifierOrPattern(parser, context);
+ return !consume(parser, context, 83886109 /* Assign */) ?
+ left :
+ finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseAssignmentExpression(parser, context | Context.AllowIn),
+ });
+}
+/**
+ * Parse assignment property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAssignmentProperty(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ let key;
+ let value;
+ let computed = false;
+ let shorthand = false;
+ // single name binding
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ key = parseIdentifier(parser, context);
+ shorthand = !consume(parser, context, 16777237 /* Colon */);
+ if (shorthand) {
+ const hasInitializer = consume(parser, context, 83886109 /* Assign */);
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (!isValidIdentifier(context, token))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ value = hasInitializer ? parseAssignmentPattern(parser, context, key, pos) : key;
+ }
+ else
+ value = parseBindingInitializer(parser, context);
+ }
+ else {
+ computed = token === 41943059 /* LeftBracket */;
+ key = parsePropertyName(parser, context);
+ expect(parser, context, 16777237 /* Colon */);
+ value = parseExpressionCoverGrammar(parser, context, parseBindingInitializer);
+ }
+ // Note! The specs specifically state that this is "assignment property", but
+ // nothing in ESTree specs explains the difference between this "property" and the "property" for object literals.
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ kind: 'init',
+ key,
+ computed,
+ value,
+ method: false,
+ shorthand,
+ });
+} + +// JSX Specification
+// https://facebook.github.io/jsx/
+/**
+ * Parses JSX element or JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXRootElement(parser, context) {
+ const pos = getLocation(parser);
+ let children = [];
+ let closingElement = null;
+ let selfClosing = false;
+ let openingElement;
+ expect(parser, context, 167774015 /* LessThan */);
+ const isFragment = parser.token === 167774016 /* GreaterThan */;
+ if (isFragment) {
+ openingElement = parseJSXOpeningFragment(parser, context, pos);
+ }
+ else {
+ const name = parseJSXElementName(parser, context);
+ const attributes = parseJSXAttributes(parser, context);
+ selfClosing = consume(parser, context, 167774773 /* Divide */);
+ openingElement = parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos);
+ }
+ if (isFragment)
+ return parseJSXFragment(parser, context, openingElement, pos);
+ if (!selfClosing) {
+ children = parseJSXChildren(parser, context);
+ closingElement = parseJSXClosingElement(parser, context);
+ const open = isEqualTagNames(openingElement.name);
+ const close = isEqualTagNames(closingElement.name);
+ if (open !== close)
+ report(parser, 85 /* ExpectedJSXClosingTag */, close);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'JSXElement',
+ children,
+ openingElement,
+ closingElement,
+ });
+}
+/**
+ * Parses JSX opening element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param name Element name
+ * @param attributes Element attributes
+ * @param selfClosing True if this is a selfclosing JSX Element
+ * @param pos Line / Column tracking
+ */
+function parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos) {
+ if (context & Context.InJSXChild && selfClosing)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningElement',
+ name,
+ attributes,
+ selfClosing,
+ });
+}
+/**
+ * Parse JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param openingElement Opening fragment
+ * @param pos Line / Column location
+ */
+function parseJSXFragment(parser, context, openingElement, pos) {
+ const children = parseJSXChildren(parser, context);
+ const closingFragment = parseJSXClosingFragment(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXFragment',
+ children,
+ openingElement,
+ closingFragment,
+ });
+}
+/**
+ * Parse JSX opening fragmentD
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+function parseJSXOpeningFragment(parser, context, pos) {
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningFragment',
+ });
+}
+/**
+ * Prime the scanner and advance to the next JSX token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextJSXToken(parser) {
+ return parser.token = scanJSXToken(parser);
+}
+/**
+ * Mini scanner
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanJSXToken(parser) {
+ if (parser.index >= parser.source.length)
+ return 1048576 /* EndOfSource */;
+ parser.lastIndex = parser.startIndex = parser.index;
+ const char = parser.source.charCodeAt(parser.index);
+ if (char === 60 /* LessThan */) {
+ parser.index++;
+ parser.column++;
+ return consumeOpt(parser, 47 /* Slash */) ? 25 /* JSXClose */ : 167774015 /* LessThan */;
+ }
+ else if (char === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ }
+ while (parser.index < parser.source.length) {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 123 /* LeftBrace */ || next === 60 /* LessThan */)
+ break;
+ }
+ return 121 /* JSXText */;
+}
+/**
+ * Parses JSX children
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXChildren(parser, context) {
+ const children = [];
+ while (parser.token !== 25 /* JSXClose */) {
+ children.push(parseJSXChild(parser, context));
+ }
+ return children;
+}
+/**
+ * Parses JSX Text
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXText(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.source.slice(parser.startIndex, parser.index);
+ parser.token = scanJSXToken(parser);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXText',
+ value,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = value;
+ return node;
+}
+/**
+ * Parses JSX Child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXChild(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ case 121 /* JSXText */:
+ return parseJSXText(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpression(parser, context & ~Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context & ~Context.InJSXChild);
+ default:
+ report(parser, 0 /* Unexpected */);
+ }
+ return undefined; // note: get rid of this
+}
+/**
+ * Parses JSX attributes
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXAttributes(parser, context) {
+ const attributes = [];
+ while (parser.index < parser.source.length) {
+ if (parser.token === 167774773 /* Divide */ || parser.token === 167774016 /* GreaterThan */)
+ break;
+ attributes.push(parseJSXAttribute(parser, context));
+ }
+ return attributes;
+}
+/**
+ * Parses JSX spread attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXSpreadAttribute(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadAttribute',
+ argument: expression,
+ });
+}
+/**
+ * Parses JSX namespace name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param namespace Identifier
+ * @param pos Line / Column location
+ */
+function parseJSXNamespacedName(parser, context, namespace, pos) {
+ expect(parser, context, 16777237 /* Colon */);
+ const name = parseJSXIdentifier(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXNamespacedName',
+ namespace,
+ name,
+ });
+}
+/**
+ * Parses JSX attribute name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXAttributeName(parser, context) {
+ const pos = getLocation(parser);
+ const identifier = parseJSXIdentifier(parser, context);
+ return parser.token === 16777237 /* Colon */ ?
+ parseJSXNamespacedName(parser, context, identifier, pos) :
+ identifier;
+}
+/**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXAttributeValue(parser, context) {
+ switch (scanJSXAttributeValue(parser, context)) {
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpressionContainer(parser, context | Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context | Context.InJSXChild);
+ default:
+ tolerant(parser, context, 87 /* InvalidJSXAttributeValue */);
+ return undefined; // note: get rid of this
+ }
+}
+/**
+ * Parses JSX Attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXAttribute(parser, context) {
+ const pos = getLocation(parser);
+ if (parser.token === 41943052 /* LeftBrace */)
+ return parseJSXSpreadAttribute(parser, context);
+ scanJSXIdentifier(parser);
+ const attrName = parseJSXAttributeName(parser, context);
+ const value = parser.token === 83886109 /* Assign */ ? parseJSXAttributeValue(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'JSXAttribute',
+ value: value,
+ name: attrName,
+ });
+}
+/**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanJSXAttributeValue(parser, context) {
+ parser.lastIndex = parser.index;
+ const ch = parser.source.charCodeAt(parser.index);
+ switch (ch) {
+ case 34 /* DoubleQuote */:
+ case 39 /* SingleQuote */:
+ return scanJSXString(parser, context, ch);
+ default:
+ return nextToken(parser, context);
+ }
+}
+/**
+ * Parses JSX String
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote Code point
+ */
+function scanJSXString(parser, context, quote) {
+ const rawStart = parser.index;
+ parser.index++;
+ parser.column++;
+ let ret = '';
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ ret += fromCodePoint(ch);
+ parser.index++;
+ parser.column++;
+ ch = parser.source.charCodeAt(parser.index);
+ if (parser.index >= parser.source.length)
+ report(parser, 6 /* UnterminatedString */);
+ }
+ parser.index++;
+ parser.column++; // skip the quote
+ // raw
+ if (context & Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(rawStart, parser.index);
+ parser.tokenValue = ret;
+ return 33554435 /* StringLiteral */;
+}
+/**
+ * Parses JJSX Empty Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXEmptyExpression(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXEmptyExpression',
+ });
+}
+/**
+ * Parses JSX Spread child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXSpreadChild(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpression(parser, context);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadChild',
+ expression,
+ });
+}
+/**
+ * Parses JSX Expression container
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXExpressionContainer(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ // Note: JSX Expressions can't be empty
+ if (parser.token === 17825807 /* RightBrace */)
+ tolerant(parser, context, 84 /* NonEmptyJSXExpression */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+}
+/**
+ * Parses JSX Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+function parseJSXExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ if (parser.token === 14 /* Ellipsis */)
+ return parseJSXSpreadChild(parser, context);
+ const expression = parser.token === 17825807 /* RightBrace */ ?
+ parseJSXEmptyExpression(parser, context) :
+ parseExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+}
+/**
+ * Parses JSX Closing fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXClosingFragment(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ expect(parser, context, 167774016 /* GreaterThan */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingFragment',
+ });
+}
+/**
+ * Parses JSX Closing Element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+function parseJSXClosingElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ const name = parseJSXElementName(parser, context);
+ if (context & Context.InJSXChild)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingElement',
+ name,
+ });
+}
+/**
+ * Parses JSX Identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXIdentifier(parser, context) {
+ const { token, tokenValue: name, tokenRaw: raw } = parser;
+ if (!(token & (131072 /* IsIdentifier */ | 4096 /* Keyword */))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXIdentifier',
+ name,
+ });
+ if (context & Context.OptionsRawidentifiers)
+ node.raw = raw;
+ return node;
+}
+/**
+ * Parses JSX Member expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+function parseJSXMemberExpression(parser, context, expr, pos) {
+ // Note: In order to be able to parse cases like ''<A.B.C.D.E.foo-bar />', where the dash is located at the
+ // end, we must rescan for the JSX Identifier now. This because JSX identifiers differ from normal identifiers
+ scanJSXIdentifier(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXMemberExpression',
+ object: expr,
+ property: parseJSXIdentifier(parser, context),
+ });
+}
+/**
+ * Parses JSX Element name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseJSXElementName(parser, context) {
+ const pos = getLocation(parser);
+ scanJSXIdentifier(parser);
+ let elementName = parseJSXIdentifier(parser, context);
+ if (parser.token === 16777237 /* Colon */)
+ return parseJSXNamespacedName(parser, context, elementName, pos);
+ while (consume(parser, context, 16777229 /* Period */)) {
+ elementName = parseJSXMemberExpression(parser, context, elementName, pos);
+ }
+ return elementName;
+}
+/**
+ * Scans JSX Identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function scanJSXIdentifier(parser) {
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const firstCharPosition = parser.index;
+ let ch = parser.source.charCodeAt(parser.index);
+ while ((parser.index < parser.source.length) && (ch === 45 /* Hyphen */ || (isValidIdentifierPart(ch)))) {
+ ch = readNext(parser);
+ }
+ parser.tokenValue += parser.source.substr(firstCharPosition, parser.index - firstCharPosition);
+ }
+ return parser.token;
+} + +/**
+ * Expression :
+ * AssignmentExpression
+ * Expression , AssignmentExpression
+ *
+ * ExpressionNoIn :
+ * AssignmentExpressionNoIn
+ * ExpressionNoIn , AssignmentExpressionNoIn
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Expression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseExpression(parser, context) {
+ const pos = getLocation(parser);
+ const expr = parseExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ return parser.token === 16777234 /* Comma */ ?
+ parseSequenceExpression(parser, context, expr, pos) :
+ expr;
+}
+/**
+ * Parse secuence expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseSequenceExpression(parser, context, left, pos) {
+ const expressions = [left];
+ while (consume(parser, context, 16777234 /* Comma */)) {
+ expressions.push(parseExpressionCoverGrammar(parser, context, parseAssignmentExpression));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'SequenceExpression',
+ expressions,
+ });
+}
+/**
+ * Parse yield expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-YieldExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseYieldExpression(parser, context, pos) {
+ // YieldExpression[In] :
+ // yield
+ // yield [no LineTerminator here] AssignmentExpression[?In, Yield]
+ // yield [no LineTerminator here] * AssignmentExpression[?In, Yield]
+ // https://tc39.github.io/ecma262/#sec-generator-function-definitions-static-semantics-early-errors
+ if (context & Context.InParameter)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ expect(parser, context, 1107316842 /* YieldKeyword */);
+ let argument = null;
+ let delegate = false;
+ if (!(parser.flags & Flags.NewLine)) {
+ delegate = consume(parser, context, 167774771 /* Multiply */);
+ // 'Token.IsExpressionStart' bitmask contains the complete set of
+ // tokens that can appear after an AssignmentExpression, and none of them
+ // can start an AssignmentExpression.
+ if (delegate || parser.token & 33554432 /* IsExpressionStart */) {
+ argument = parseAssignmentExpression(parser, context);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'YieldExpression',
+ argument,
+ delegate,
+ });
+}
+/**
+ * AssignmentExpression :
+ * ConditionalExpression
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpression
+ * LeftHandSideExpression AssignmentOperator AssignmentExpression
+ *
+ * AssignmentExpressionNoIn :
+ * ConditionalExpressionNoIn
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpressionNoIn
+ * LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAssignmentExpression(parser, context) {
+ const pos = getLocation(parser);
+ let { token } = parser;
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ return parseYieldExpression(parser, context, pos);
+ let expr = token & 524288 /* IsAsync */ && lookahead(parser, context, nextTokenisIdentifierOrParen)
+ ? parserCoverCallExpressionAndAsyncArrowHead(parser, context)
+ : parseConditionalExpression(parser, context, pos);
+ if (parser.token === 10 /* Arrow */) {
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & (20480 /* FutureReserved */ | 4194304 /* IsEvalOrArguments */)) {
+ // Invalid: ' yield => { 'use strict'; 0 };'
+ if (token & 20480 /* FutureReserved */) {
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ }
+ expr = [expr];
+ }
+ return parseArrowFunction(parser, context &= ~Context.Async, pos, expr);
+ }
+ if (hasBit(parser.token, 67108864 /* IsAssignOp */)) {
+ token = parser.token;
+ if (context & Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ }
+ else if (consume(parser, context, 83886109 /* Assign */)) {
+ if (!(parser.flags & Flags.AllowDestructuring)) {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ // Only re-interpret if not inside a formal parameter list
+ if (!(context & Context.InParameter))
+ reinterpret(parser, context, expr);
+ if (context & Context.InParen)
+ parser.flags |= Flags.SimpleParameterList;
+ if (parser.token & 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ else if (context & Context.InParen &&
+ context & (Context.Strict | Context.Yield) &&
+ parser.token & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasYield;
+ }
+ }
+ else {
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ nextToken(parser, context);
+ }
+ const right = parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ parser.pendingExpressionError = null;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentExpression',
+ left: expr,
+ operator: tokenDesc(token),
+ right,
+ });
+ }
+ return expr;
+}
+/**
+ * Parse conditional expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ConditionalExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseConditionalExpression(parser, context, pos) {
+ const test = parseBinaryExpression(parser, context, 0, pos);
+ if (!consume(parser, context, 22 /* QuestionMark */))
+ return test;
+ const consequent = parseExpressionCoverGrammar(parser, context & ~Context.AllowDecorator | Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16777237 /* Colon */);
+ return finishNode(context, parser, pos, {
+ type: 'ConditionalExpression',
+ test,
+ consequent,
+ alternate: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+}
+/**
+ * Parse binary expression.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-exp-operator)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-additive-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-bitwise-shift-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-equality-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-relational-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-multiplicative-operators)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param minPrec Minimum precedence value
+ * @param pos Line / Column info
+ * @param Left Left hand side of the binary expression
+ */
+function parseBinaryExpression(parser, context, minPrec, pos, left = parseUnaryExpression(parser, context)) {
+ // Shift-reduce parser for the binary operator part of the JS expression
+ // syntax.
+ const bit = context & Context.AllowIn ^ Context.AllowIn;
+ while (hasBit(parser.token, 167772160 /* IsBinaryOp */)) {
+ const t = parser.token;
+ const prec = t & 3840 /* Precedence */;
+ const delta = (t === 167775030 /* Exponentiate */) << 8 /* PrecStart */;
+ if (bit && t === 167786289 /* InKeyword */)
+ break;
+ // When the next token is no longer a binary operator, it's potentially the
+ // start of an expression, so we break the loop
+ if (prec + delta <= minPrec)
+ break;
+ nextToken(parser, context);
+ left = finishNode(context, parser, pos, {
+ type: t & 2097152 /* IsLogical */ ? 'LogicalExpression' : 'BinaryExpression',
+ left,
+ right: parseBinaryExpression(parser, context & ~Context.AllowIn, prec, getLocation(parser)),
+ operator: tokenDesc(t),
+ });
+ }
+ return left;
+}
+/**
+ * Parse await expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AwaitExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ */
+function parseAwaitExpression(parser, context, pos) {
+ if (context & Context.InParameter)
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ expect(parser, context, 34017389 /* AwaitKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'AwaitExpression',
+ argument: parseUnaryExpression(parser, context),
+ });
+}
+/**
+ * Parses unary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UnaryExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseUnaryExpression(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ if (hasBit(token, 301989888 /* IsUnaryOp */)) {
+ nextToken(parser, context);
+ if (parser.flags & Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ const argument = parseExpressionCoverGrammar(parser, context, parseUnaryExpression);
+ if (parser.token === 167775030 /* Exponentiate */) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & Context.Strict && token === 302002219 /* DeleteKeyword */) {
+ if (argument.type === 'Identifier') {
+ tolerant(parser, context, 43 /* StrictDelete */);
+ }
+ else if (isPropertyWithPrivateFieldKey(argument)) {
+ tolerant(parser, context, 44 /* DeletePrivateField */);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'UnaryExpression',
+ operator: tokenDesc(token),
+ argument,
+ prefix: true,
+ });
+ }
+ return context & Context.Async && token & 262144 /* IsAwait */
+ ? parseAwaitExpression(parser, context, pos)
+ : parseUpdateExpression(parser, context, pos);
+}
+/**
+ * Parses update expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UpdateExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseUpdateExpression(parser, context, pos) {
+ const { token } = parser;
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */)) {
+ nextToken(parser, context);
+ const expr = parseLeftHandSideExpression(parser, context, pos);
+ validateUpdateExpression(parser, context, expr, 'Prefix');
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expr,
+ operator: tokenDesc(token),
+ prefix: true,
+ });
+ }
+ else if (context & Context.OptionsJSX && token === 167774015 /* LessThan */) {
+ return parseJSXRootElement(parser, context | Context.InJSXChild);
+ }
+ const expression = parseLeftHandSideExpression(parser, context, pos);
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */) && !(parser.flags & Flags.NewLine)) {
+ validateUpdateExpression(parser, context, expression, 'Postfix');
+ const operator = parser.token;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expression,
+ operator: tokenDesc(operator),
+ prefix: false,
+ });
+ }
+ return expression;
+}
+/**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseRestElement(parser, context, args = []) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (context & Context.InParen && parser.token & 262144 /* IsAwait */)
+ parser.flags |= Flags.HasAwait;
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+}
+/**
+ * Parse spread element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SpreadElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseSpreadElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+}
+/**
+ * Parse left hand side expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LeftHandSideExpression)
+ *
+ * @param Parser Parer instance
+ * @param Context Contextmasks
+ * @param pos Location info
+ */
+function parseLeftHandSideExpression(parser, context, pos) {
+ const expr = context & Context.OptionsNext && parser.token === 33566810 /* ImportKeyword */
+ ? parseCallImportOrMetaProperty(parser, context | Context.AllowIn)
+ : parseMemberExpression(parser, context | Context.AllowIn, pos);
+ return parseCallExpression(parser, context | Context.AllowIn, pos, expr);
+}
+/**
+ * Parse member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ * @param expr Expression
+ */
+function parseMemberExpression(parser, context, pos, expr = parsePrimaryExpression(parser, context)) {
+ while (true) {
+ switch (parser.token) {
+ case 16777229 /* Period */: {
+ consume(parser, context, 16777229 /* Period */);
+ parser.flags = parser.flags & ~Flags.AllowBinding | Flags.AllowDestructuring;
+ const property = parseIdentifierNameOrPrivateName(parser, context);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ property,
+ });
+ continue;
+ }
+ case 41943059 /* LeftBracket */: {
+ consume(parser, context, 41943059 /* LeftBracket */);
+ parser.flags = parser.flags & ~Flags.AllowBinding | Flags.AllowDestructuring;
+ const property = parseExpression(parser, context);
+ expect(parser, context, 20 /* RightBracket */);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ property,
+ });
+ continue;
+ }
+ case 33554441 /* TemplateTail */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplateLiteral(parser, context),
+ });
+ continue;
+ }
+ case 33554440 /* TemplateCont */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplate(parser, context | Context.TaggedTemplate),
+ });
+ continue;
+ }
+ default:
+ return expr;
+ }
+ }
+}
+/**
+ * Parse call expression
+ *
+ * @param parser Parer instance
+ * @param context Context masks
+ * @param pos Line / Colum info
+ * @param expr Expression
+ */
+function parseCallExpression(parser, context, pos, expr) {
+ while (true) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ if (parser.token !== 50331659 /* LeftParen */)
+ return expr;
+ const args = parseArgumentList(parser, context & ~Context.AllowDecorator);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+}
+/**
+ * Parse cover call expression and async arrow head
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parserCoverCallExpressionAndAsyncArrowHead(parser, context) {
+ const pos = getLocation(parser);
+ let expr = parseMemberExpression(parser, context | Context.AllowIn, pos);
+ // Here we jump right into it and parse a simple, faster sub-grammar for
+ // async arrow / async identifier + call expression. This could have been done different
+ // but ESTree sucks!
+ //
+ // - J.K. Thomas
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (parser.token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */);
+ return parseAsyncArrowFunction(parser, context, ModifierState.Await, pos, [parseAndClassifyIdentifier(parser, context)]);
+ }
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ while (parser.token === 50331659 /* LeftParen */) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ const args = parseAsyncArgumentList(parser, context);
+ if (parser.token === 10 /* Arrow */) {
+ expr = parseAsyncArrowFunction(parser, context, ModifierState.Await, pos, args);
+ break;
+ }
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+ return expr;
+}
+/**
+ * Parse argument list
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+function parseArgumentList(parser, context) {
+ // ArgumentList :
+ // AssignmentOrSpreadExpression
+ // ArgumentList , AssignmentOrSpreadExpression
+ //
+ // AssignmentOrSpreadExpression :
+ // ... AssignmentExpression
+ // AssignmentExpression
+ expect(parser, context, 50331659 /* LeftParen */);
+ const expressions = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ expressions.push(parseSpreadElement(parser, context));
+ }
+ else {
+ if (context & Context.Yield && hasBit(parser.token, 1073741824 /* IsYield */)) {
+ parser.flags |= Flags.HasYield;
+ setPendingError(parser);
+ }
+ expressions.push(parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ }
+ if (parser.token !== 16 /* RightParen */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return expressions;
+}
+/**
+ * Parse argument list for async arrow / async call expression
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+function parseAsyncArgumentList(parser, context) {
+ // Here we are parsing an "extended" argument list tweaked to handle async arrows. This is
+ // done here to avoid overhead and possible performance loss if we only
+ // parse out a simple call expression - E.g 'async(foo, bar)' or 'async(foo, bar)()';
+ //
+ // - J.K. Thomas
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = [];
+ let { token } = parser;
+ let state = CoverCallState.Empty;
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ parser.flags |= Flags.SimpleParameterList;
+ args.push(parseSpreadElement(parser, context));
+ state = CoverCallState.HasSpread;
+ }
+ else {
+ token = parser.token;
+ state = validateAsyncArgumentList(parser, context, state);
+ args.push(restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ }
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ parser.flags &= ~Flags.AllowDestructuring;
+ if (state & CoverCallState.HasSpread)
+ state = CoverCallState.SeenSpread;
+ }
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & CoverCallState.SeenSpread) {
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ }
+ else if (state & CoverCallState.EvalOrArguments) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (state & CoverCallState.Yield) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ else if (parser.flags & Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (state & CoverCallState.Await || parser.flags & Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ }
+ return args;
+}
+/**
+ * Parse primary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PrimaryExpression)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+function parsePrimaryExpression(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ return parseIdentifier(parser, context);
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionOrIdentifier(parser, context);
+ case 50331659 /* LeftParen */:
+ return parseParenthesizedExpression(parser, context | Context.InParen);
+ case 41943059 /* LeftBracket */:
+ return restoreExpressionCoverGrammar(parser, context, parseArrayLiteral);
+ case 41943052 /* LeftBrace */:
+ return restoreExpressionCoverGrammar(parser, context, parseObjectLiteral);
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionExpression(parser, context);
+ case 33566727 /* NullKeyword */:
+ case 33566726 /* TrueKeyword */:
+ case 33566725 /* FalseKeyword */:
+ return parseNullOrTrueOrFalseLiteral(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassExpression(parser, context);
+ case 33566811 /* NewKeyword */:
+ return parseNewExpressionOrMetaProperty(parser, context);
+ case 33566813 /* SuperKeyword */:
+ return parseSuperProperty(parser, context);
+ case 33554551 /* BigIntLiteral */:
+ return parseBigIntLiteral(parser, context);
+ case 33566815 /* ThisKeyword */:
+ return parseThisExpression(parser, context);
+ case 115 /* Hash */:
+ return parseIdentifierNameOrPrivateName(parser, context);
+ case 167774773 /* Divide */:
+ case 100663333 /* DivideAssign */:
+ scanRegularExpression(parser, context);
+ return parseRegularExpressionLiteral(parser, context);
+ case 33554441 /* TemplateTail */:
+ return parseTemplateLiteral(parser, context);
+ case 33554440 /* TemplateCont */:
+ return parseTemplate(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetAsIdentifier(parser, context);
+ case 12369 /* DoKeyword */:
+ if (context & Context.OptionsExperimental)
+ return parseDoExpression(parser, context);
+ default:
+ return parseAndClassifyIdentifier(parser, context);
+ }
+}
+/**
+ * Parse do expression (*experimental*)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDoExpression(parser, context) {
+ // AssignmentExpression ::
+ // do '{' StatementList '}'
+ const pos = getLocation(parser);
+ expect(parser, context, 12369 /* DoKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'DoExpression',
+ body: parseBlockStatement(parser, context)
+ });
+}
+/**
+ * Parse 'let' as identifier in 'sloppy mode', and throws
+ * in 'strict mode' / 'module code'. We also avoid a lookahead on the
+ * ASI restictions while checking this after parsing out the 'let' keyword
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+function parseLetAsIdentifier(parser, context) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ if (parser.flags & Flags.NewLine) {
+ if (parser.token === 41943059 /* LeftBracket */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, 'let');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+}
+/**
+ * Parse either async function expression or identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+function parseAsyncFunctionOrIdentifier(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) :
+ parseIdentifier(parser, context);
+}
+/**
+ * Parses identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseIdentifier(parser, context) {
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context | Context.TaggedTemplate);
+ const node = finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ if (context & Context.OptionsRawidentifiers)
+ node.raw = parser.tokenRaw;
+ return node;
+}
+/**
+ * Parse regular expression literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseRegularExpressionLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenRegExp, tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ regex: tokenRegExp,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = tokenRaw;
+ return node;
+}
+/**
+ * Parses string and number literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StringLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.tokenValue;
+ if (context & Context.Strict && parser.flags & Flags.HasOctal) {
+ tolerant(parser, context, 61 /* StrictOctalLiteral */);
+ }
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+}
+/**
+ * Parses BigInt literal (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/proposal-bigint/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBigIntLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ bigint: tokenRaw,
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+}
+/**
+ * Parses either null or boolean literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BooleanLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseNullOrTrueOrFalseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const raw = tokenDesc(token);
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: token === 33566727 /* NullKeyword */ ? null : raw === 'true',
+ });
+ if (context & Context.OptionsRaw)
+ node.raw = raw;
+ return node;
+}
+/**
+ * Parse this expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseThisExpression(parser, context) {
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ const pos = getLocation(parser);
+ nextToken(parser, context | Context.DisallowEscapedKeyword);
+ return finishNode(context, parser, pos, {
+ type: 'ThisExpression',
+ });
+}
+/**
+ * Parse identifier name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-IdentifierName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t token
+ */
+function parseIdentifierName(parser, context, t) {
+ if (!(t & (131072 /* IsIdentifier */ | 4096 /* Keyword */)))
+ tolerant(parser, context, 4 /* UnexpectedKeyword */, tokenDesc(t));
+ return parseIdentifier(parser, context);
+}
+/**
+ * Parse identifier name or private name (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseIdentifierNameOrPrivateName(parser, context) {
+ if (!consume(parser, context, 115 /* Hash */))
+ return parseIdentifierName(parser, context, parser.token);
+ const { tokenValue } = parser;
+ const pos = getLocation(parser);
+ const name = tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+}
+/**
+ * Parse array literal
+ *
+ * ArrayLiteral :
+ * [ Elisionopt ]
+ * [ ElementList ]
+ * [ ElementList , Elisionopt ]
+ *
+ * ElementList :
+ * Elisionopt AssignmentExpression
+ * Elisionopt ... AssignmentExpression
+ * ElementList , Elisionopt AssignmentExpression
+ * ElementList , Elisionopt SpreadElement
+ *
+ * Elision :
+ * ,
+ * Elision ,
+ *
+ * SpreadElement :
+ * ... AssignmentExpression
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseArrayLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseSpreadElement(parser, context));
+ if (parser.token !== 20 /* RightBracket */) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ else {
+ elements.push(restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression));
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ return finishNode(context, parser, pos, {
+ type: 'ArrayExpression',
+ elements,
+ });
+}
+/**
+ * Parses cover parenthesized expression and arrow parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-parseCoverParenthesizedExpressionAndArrowParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseParenthesizedExpression(parser, context) {
+ expect(parser, context, 50331659 /* LeftParen */);
+ if (consume(parser, context, 16 /* RightParen */)) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.token === 10 /* Arrow */)
+ return [];
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ const restExpr = [parseRestElement(parser, context)];
+ expect(parser, context, 16 /* RightParen */);
+ parser.flags = parser.flags & ~(Flags.AllowDestructuring | Flags.AllowBinding) | Flags.SimpleParameterList;
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return restExpr;
+ }
+ // Record the sequence position
+ const sequencepos = getLocation(parser);
+ let state = validateCoverParenthesizedExpression(parser, CoverParenthesizedState.None);
+ let expr = restoreExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ // Sequence expression
+ if (parser.token === 16777234 /* Comma */) {
+ state |= CoverParenthesizedState.SequenceExpression;
+ const expressions = [expr];
+ while (consume(parser, context | Context.DisallowEscapedKeyword, 16777234 /* Comma */)) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (!(parser.flags & Flags.AllowBinding))
+ tolerant(parser, context, 77 /* NotBindable */);
+ parser.flags |= Flags.SimpleParameterList;
+ const restElement = parseRestElement(parser, context);
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ expressions.push(restElement);
+ return expressions;
+ }
+ else if (consume(parser, context, 16 /* RightParen */)) {
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return expressions;
+ }
+ else {
+ state = validateCoverParenthesizedExpression(parser, state);
+ expressions.push(restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression));
+ }
+ }
+ expr = finishNode(context, parser, sequencepos, {
+ type: 'SequenceExpression',
+ expressions,
+ });
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & CoverParenthesizedState.HasEvalOrArguments) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ else if (state & CoverParenthesizedState.HasReservedWords) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= Flags.HasStrictReserved;
+ }
+ else if (!(parser.flags & Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (parser.flags & Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (context & Context.Async && parser.flags & Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ parser.flags &= ~(Flags.AllowBinding | Flags.HasAwait | Flags.HasYield);
+ return (state & CoverParenthesizedState.SequenceExpression ? expr.expressions : [expr]);
+ }
+ parser.flags &= ~(Flags.HasAwait | Flags.HasYield | Flags.AllowBinding);
+ if (!isValidSimpleAssignmentTarget(expr))
+ parser.flags &= ~Flags.AllowDestructuring;
+ return expr;
+}
+/**
+ * Parses function expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFunctionExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & ModifierState.Generator) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty), isGenerator, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: false,
+ generator: !!(isGenerator & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+}
+/**
+ * Parses async function or async generator expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ const isAwait = ModifierState.Await;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & Context.Strict || isAwait & ModifierState.Await)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ if (token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & ModifierState.Generator)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty), isGenerator | isAwait, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: true,
+ generator: !!(isGenerator & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+}
+/**
+ * Parse computed property names
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ComputedPropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseComputedPropertyName(parser, context) {
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const key = parseAssignmentExpression(parser, context | Context.AllowIn);
+ expect(parser, context, 20 /* RightBracket */);
+ return key;
+}
+/**
+ * Parse property name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parsePropertyName(parser, context) {
+ switch (parser.token) {
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943059 /* LeftBracket */:
+ return parseComputedPropertyName(parser, context);
+ default:
+ return parseIdentifier(parser, context);
+ }
+}
+/**
+ * Parse object spread properties
+ *
+ * @see [Link](https://tc39.github.io/proposal-object-rest-spread/#Spread)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseSpreadProperties(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (parser.token & 8388608 /* IsBindingPattern */)
+ parser.flags &= ~Flags.AllowDestructuring;
+ const argument = parseAssignmentExpression(parser, context | Context.AllowIn);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+}
+/**
+ * Parses object literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ObjectLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseObjectLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const properties = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ properties.push(parser.token === 14 /* Ellipsis */ ?
+ parseSpreadProperties(parser, context) :
+ parsePropertyDefinition(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ parser.flags &= ~Flags.HasProtoField;
+ return finishNode(context, parser, pos, {
+ type: 'ObjectExpression',
+ properties,
+ });
+}
+/**
+ * Parse property definition
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyDefinition)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parsePropertyDefinition(parser, context) {
+ const pos = getLocation(parser);
+ const flags = parser.flags;
+ let value;
+ let state = consume(parser, context, 167774771 /* Multiply */) ? ObjectState.Generator | ObjectState.Method : ObjectState.Method;
+ const t = parser.token;
+ let key = parsePropertyName(parser, context);
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ else if (!(state & ObjectState.Generator) && t & 524288 /* IsAsync */ && !(parser.flags & Flags.NewLine)) {
+ state |= consume(parser, context, 167774771 /* Multiply */) ? ObjectState.Generator | ObjectState.Async : ObjectState.Async;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69743 /* GetKeyword */) {
+ state = state & ~ObjectState.Method | ObjectState.Getter;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69744 /* SetKeyword */) {
+ state = state & ~ObjectState.Method | ObjectState.Setter;
+ key = parsePropertyName(parser, context);
+ }
+ if (state & (ObjectState.Getter | ObjectState.Setter)) {
+ if (state & ObjectState.Generator)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ state &= ~ObjectState.Method;
+ if (parser.token === 16777237 /* Colon */) {
+ if ((state & (ObjectState.Async | ObjectState.Generator))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ else if (t !== 41943059 /* LeftBracket */ && parser.tokenValue === '__proto__') {
+ if (parser.flags & Flags.HasProtoField) {
+ // Record the error and put it on hold until we've determined
+ // whether or not we're destructuring
+ setPendingExpressionError(parser, 63 /* DuplicateProto */);
+ }
+ else
+ parser.flags |= Flags.HasProtoField;
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ // Invalid: 'async ({a: await}) => 1'
+ if (parser.token & 262144 /* IsAwait */)
+ parser.flags |= Flags.HasAwait;
+ value = restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ }
+ else {
+ if ((state & (ObjectState.Generator | ObjectState.Async)) || !isValidIdentifier(context, t)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(t));
+ }
+ else if (context & (Context.Strict | Context.Yield) && t & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasYield;
+ }
+ state |= ObjectState.Shorthand;
+ if (parser.token === 83886109 /* Assign */) {
+ if (context & Context.Strict && t & 4194304 /* IsEvalOrArguments */) {
+ report(parser, 47 /* StrictEvalArguments */);
+ }
+ else
+ setPendingExpressionError(parser, 91 /* InvalidCoverInitializedName */);
+ expect(parser, context, 83886109 /* Assign */);
+ if (context & (Context.Strict | Context.Yield | Context.Async) && parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */)) {
+ setPendingError(parser);
+ parser.flags |= parser.token & 1073741824 /* IsYield */ ? Flags.HasYield : Flags.HasAwait;
+ }
+ value = parseAssignmentPattern(parser, context, key, pos);
+ }
+ else {
+ if (t & 262144 /* IsAwait */) {
+ if (context & Context.Async)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ value = key;
+ }
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ key,
+ value,
+ kind: !(state & ObjectState.Getter | state & ObjectState.Setter) ? 'init' : (state & ObjectState.Setter) ? 'set' : 'get',
+ computed: t === 41943059 /* LeftBracket */,
+ method: !!(state & ObjectState.Method),
+ shorthand: !!(state & ObjectState.Shorthand),
+ });
+}
+/**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseMethodDeclaration(parser, context, state) {
+ const pos = getLocation(parser);
+ const isGenerator = state & ObjectState.Generator ? ModifierState.Generator : ModifierState.None;
+ const isAsync = state & ObjectState.Async ? ModifierState.Await : ModifierState.None;
+ const { params, body } = swapContext(parser, context | Context.Method, isGenerator | isAsync, parseFormalListAndBody, state);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: !!(state & ObjectState.Async),
+ generator: !!(state & ObjectState.Generator),
+ expression: false,
+ id: null,
+ });
+}
+/**
+ * Parse arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseArrowFunction(parser, context, pos, params) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, '=>');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context & ~Context.Async, params, pos, ModifierState.None);
+}
+/**
+ * Parse async arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAsyncArrowFunction(parser, context, state, pos, params) {
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context | Context.Async, params, pos, state);
+}
+/**
+ * Shared helper function for both async arrow and arrows
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+// https://tc39.github.io/ecma262/#prod-AsyncArrowFunction
+function parseArrowBody(parser, context, params, pos, state) {
+ parser.pendingExpressionError = null;
+ for (const i in params)
+ reinterpret(parser, context | Context.InParameter, params[i]);
+ const expression = parser.token !== 41943052 /* LeftBrace */;
+ const body = expression ? parseExpressionCoverGrammar(parser, context & ~(Context.Yield | Context.InParameter), parseAssignmentExpression) :
+ swapContext(parser, context & ~(Context.Yield | Context.AllowDecorator) | Context.InFunctionBody, state, parseFunctionBody);
+ return finishNode(context, parser, pos, {
+ type: 'ArrowFunctionExpression',
+ body,
+ params,
+ id: null,
+ async: !!(state & ModifierState.Await),
+ generator: false,
+ expression,
+ });
+}
+/**
+ * Parses formal parameters and function body.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFormalListAndBody(parser, context, state) {
+ const paramList = parseFormalParameters(parser, context | Context.InParameter, state);
+ const args = paramList.args;
+ const params = paramList.params;
+ const body = parseFunctionBody(parser, context & ~Context.AllowDecorator | Context.InFunctionBody, args);
+ return { params, body };
+}
+/**
+ * Parse funciton body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFunctionBody(parser, context, params) {
+ // Note! The 'params' has an 'any' type now because it's really shouldn't be there. This should have been
+ // on the parser object instead. So for now the 'params' arg are only used within the
+ // 'parseFormalListAndBody' method, and not within the arrow function body.
+ const pos = getLocation(parser);
+ expect(parser, context | Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const body = [];
+ while (parser.token === 33554435 /* StringLiteral */) {
+ const { tokenRaw, tokenValue } = parser;
+ body.push(parseDirective(parser, context));
+ if (tokenRaw.length === /* length of prologue*/ 12 && tokenValue === 'use strict') {
+ if (parser.flags & Flags.SimpleParameterList) {
+ tolerant(parser, context, 64 /* IllegalUseStrict */);
+ }
+ else if (parser.flags & (Flags.HasStrictReserved | Flags.StrictFunctionName)) {
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ }
+ else if (parser.flags & Flags.StrictEvalArguments) {
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ }
+ context |= Context.Strict;
+ }
+ }
+ if (context & Context.Strict) {
+ validateParams(parser, context, params);
+ }
+ const { labelSet } = parser;
+ parser.labelSet = {};
+ const savedFlags = parser.flags;
+ parser.flags = parser.flags & ~(Flags.StrictFunctionName | Flags.StrictEvalArguments | Flags.InSwitchStatement | Flags.InIterationStatement) | Flags.AllowDestructuring;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ if (savedFlags & Flags.InIterationStatement)
+ parser.flags |= Flags.InIterationStatement;
+ if (savedFlags & Flags.InSwitchStatement)
+ parser.flags |= Flags.InSwitchStatement;
+ parser.labelSet = labelSet;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body,
+ });
+}
+/**
+ * Parse formal parameters
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param Parser object
+ * @param Context masks
+ * @param Optional objectstate. Default to none
+ */
+function parseFormalParameters(parser, context, state) {
+ // FormalParameterList :
+ // [empty]
+ // FunctionRestParameter
+ // FormalsList
+ // FormalsList , FunctionRestParameter
+ //
+ // FunctionRestParameter :
+ // ... BindingIdentifier
+ //
+ // FormalsList :
+ // FormalParameter
+ // FormalsList , FormalParameter
+ //
+ // FormalParameter :
+ // BindingElement
+ //
+ // BindingElement :
+ // SingleNameBinding
+ // BindingPattern Initializeropt
+ expect(parser, context, 50331659 /* LeftParen */);
+ parser.flags &= ~(Flags.SimpleParameterList | Flags.HasStrictReserved);
+ const args = [];
+ const params = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (state & ObjectState.Setter)
+ tolerant(parser, context, 67 /* BadSetterRestParameter */);
+ parser.flags |= Flags.SimpleParameterList;
+ params.push(parseRestElement(parser, context, args));
+ break;
+ }
+ params.push(parseFormalParameterList(parser, context, args));
+ if (!consume(parser, context, 16777234 /* Comma */))
+ break;
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ if (state & ObjectState.Setter && params.length !== 1) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Setter', 'one', '');
+ }
+ if (state & ObjectState.Getter && params.length > 0) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Getter', 'no', 's');
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return { params, args };
+}
+/**
+ * Parse formal parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFormalParameterList(parser, context, args) {
+ const pos = getLocation(parser);
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (hasBit(parser.token, 20480 /* FutureReserved */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= Flags.StrictFunctionName;
+ }
+ if (hasBit(parser.token, 4194304 /* IsEvalOrArguments */)) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= Flags.StrictEvalArguments;
+ }
+ }
+ else {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ const left = parseBindingIdentifierOrPattern(parser, context, args);
+ if (!consume(parser, context, 83886109 /* Assign */))
+ return left;
+ if (parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */) && context & (Context.Yield | Context.Async)) {
+ tolerant(parser, context, parser.token & 262144 /* IsAwait */ ? 52 /* AwaitInParameter */ : 51 /* YieldInParameter */);
+ }
+ parser.flags |= Flags.SimpleParameterList;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+}
+/**
+ * Parse class expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseClassExpression(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const { token } = parser;
+ let state = ObjectState.None;
+ let id = null;
+ let superClass = null;
+ if ((token !== 41943052 /* LeftBrace */ && token !== 12372 /* ExtendsKeyword */)) {
+ if (context & Context.Async && token & 262144 /* IsAwait */) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context | Context.Strict);
+ }
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | Context.Strict, pos);
+ state |= ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context | Context.Strict, state);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ });
+}
+/**
+ * Parse class body and element list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElementList)
+ *
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseClassBodyAndElementList(parser, context, state) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const body = [];
+ let decorators = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (!consume(parser, context, 17825809 /* Semicolon */)) {
+ if (context & Context.OptionsExperimental) {
+ decorators = parseDecorators(parser, context);
+ if (parser.token === 17825807 /* RightBrace */)
+ report(parser, 92 /* TrailingDecorators */);
+ if (decorators.length !== 0 && parser.tokenValue === 'constructor') {
+ report(parser, 93 /* GeneratorConstructor */);
+ }
+ }
+ body.push(context & Context.OptionsNext && parser.token === 115 /* Hash */
+ ? parsePrivateFields(parser, context, decorators)
+ : parseClassElement(parser, context, state, decorators));
+ }
+ }
+ parser.flags &= ~Flags.HasConstructor;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ClassBody',
+ body,
+ });
+}
+/**
+ * Parse class element and class public instance fields & private instance fields
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElement)
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseClassElement(parser, context, state, decorators) {
+ const pos = getLocation(parser);
+ let { tokenValue, token } = parser;
+ const flags = parser.flags;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ state |= ObjectState.Generator;
+ }
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ if (parser.tokenValue === 'constructor') {
+ if (state & ObjectState.Generator)
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'generator');
+ else if (state & ObjectState.Heritage)
+ context |= Context.AllowSuperProperty;
+ state |= ObjectState.Constructor;
+ }
+ let key = parsePropertyName(parser, context);
+ let value;
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ if (token === 20585 /* StaticKeyword */) {
+ token = parser.token;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= ObjectState.Generator;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ if (parser.tokenValue === 'prototype')
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ state |= ObjectState.Static;
+ key = parsePropertyName(parser, context);
+ if (context & Context.OptionsNext && isInstanceField(parser)) {
+ if (tokenValue === 'constructor')
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ }
+ }
+ if (parser.token !== 50331659 /* LeftParen */) {
+ if (token & 524288 /* IsAsync */ && !(state & ObjectState.Generator) && !(parser.flags & Flags.NewLine)) {
+ token = parser.token;
+ tokenValue = parser.tokenValue;
+ state |= ObjectState.Async;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= ObjectState.Generator;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ key = parsePropertyName(parser, context);
+ }
+ else if ((token === 69743 /* GetKeyword */ || token === 69744 /* SetKeyword */)) {
+ state |= token === 69743 /* GetKeyword */ ? ObjectState.Getter : ObjectState.Setter;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= ObjectState.Computed;
+ key = parsePropertyName(parser, context & ~Context.Strict);
+ }
+ if (tokenValue === 'prototype') {
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ }
+ else if (!(state & ObjectState.Static) && tokenValue === 'constructor') {
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'accessor');
+ }
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ if (!(state & ObjectState.Computed) && state & ObjectState.Constructor) {
+ if (parser.flags & Flags.HasConstructor)
+ report(parser, 12 /* DuplicateConstructor */);
+ else
+ parser.flags |= Flags.HasConstructor;
+ }
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ if (context & Context.OptionsNext)
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const kind = (state & ObjectState.Constructor) ? 'constructor' : (state & ObjectState.Getter) ? 'get' :
+ (state & ObjectState.Setter) ? 'set' : 'method';
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & ObjectState.Static),
+ computed: !!(state & ObjectState.Computed),
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & ObjectState.Static),
+ computed: !!(state & ObjectState.Computed),
+ key,
+ value,
+ });
+}
+/**
+ * Parses field definition.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFieldDefinition(parser, context, key, state, pos, decorators) {
+ if (state & ObjectState.Constructor)
+ tolerant(parser, context, 0 /* Unexpected */);
+ let value = null;
+ if (state & (ObjectState.Async | ObjectState.Generator))
+ tolerant(parser, context, 0 /* Unexpected */);
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & ObjectState.Computed),
+ static: !!(state & ObjectState.Static),
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & ObjectState.Computed),
+ static: !!(state & ObjectState.Static),
+ });
+}
+/**
+ * Parse private name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parsePrivateName(parser, context, pos) {
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+}
+/**
+ * Parses private instance fields
+ *
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parsePrivateFields(parser, context, decorators) {
+ const pos = getLocation(parser);
+ expect(parser, context | Context.InClass, 115 /* Hash */);
+ if (parser.tokenValue === 'constructor')
+ tolerant(parser, context, 41 /* PrivateFieldConstructor */);
+ const key = parsePrivateName(parser, context, pos);
+ if (parser.token === 50331659 /* LeftParen */)
+ return parsePrivateMethod(parser, context, key, pos, decorators);
+ let value = null;
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ });
+}
+function parsePrivateMethod(parser, context, key, pos, decorators) {
+ const value = parseMethodDeclaration(parser, context | Context.Strict, ObjectState.None);
+ parser.flags &= ~(Flags.AllowDestructuring | Flags.AllowBinding);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ });
+}
+/**
+ * Parse either call expression or import expressions
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseCallImportOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ // Import.meta - Stage 3 proposal
+ if (consume(parser, context, 16777229 /* Period */)) {
+ if (context & Context.Module && parser.tokenValue === 'meta')
+ return parseMetaProperty(parser, context, id, pos);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ let expr = parseImportExpression(parser, context, pos);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = parseExpressionCoverGrammar(parser, context | Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16 /* RightParen */);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: [args],
+ });
+ return expr;
+}
+/**
+ * Parse Import() expression. (Stage 3 proposal)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+function parseImportExpression(parser, context, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'Import',
+ });
+}
+/**
+ * Parse meta property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Identifier
+ * @param pos Location
+ */
+function parseMetaProperty(parser, context, meta, pos) {
+ return finishNode(context, parser, pos, {
+ meta,
+ type: 'MetaProperty',
+ property: parseIdentifier(parser, context),
+ });
+}
+/**
+ * Parse new expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NewExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseNewExpressionOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ if (consume(parser, context | Context.DisallowEscapedKeyword, 16777229 /* Period */)) {
+ if (parser.tokenValue !== 'target' ||
+ !(context & (Context.InParameter | Context.InFunctionBody)))
+ tolerant(parser, context, 53 /* MetaNotInFunctionBody */);
+ return parseMetaProperty(parser, context, id, pos);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'NewExpression',
+ callee: parseImportOrMemberExpression(parser, context, pos),
+ arguments: parser.token === 50331659 /* LeftParen */ ? parseArgumentList(parser, context) : [],
+ });
+}
+/**
+ * Parse either import or member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseImportOrMemberExpression(parser, context, pos) {
+ const { token } = parser;
+ if (context & Context.OptionsNext && token === 33566810 /* ImportKeyword */) {
+ // Invalid: '"new import(x)"'
+ if (lookahead(parser, context, nextTokenIsLeftParen))
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ // Fixes cases like ''new import.meta','
+ return parseCallImportOrMetaProperty(parser, context);
+ }
+ return parseMemberExpression(parser, context, pos);
+}
+/**
+ * Parse super property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SuperProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseSuperProperty(parser, context) {
+ // SuperProperty[Yield, Await]:
+ // super[Expression[+In, ?Yield, ?Await]]
+ // super.IdentifierName
+ const pos = getLocation(parser);
+ expect(parser, context, 33566813 /* SuperKeyword */);
+ switch (parser.token) {
+ case 50331659 /* LeftParen */:
+ // The super property has to be within a class constructor
+ if (!(context & Context.AllowSuperProperty))
+ tolerant(parser, context, 54 /* BadSuperCall */);
+ break;
+ case 41943059 /* LeftBracket */:
+ case 16777229 /* Period */:
+ if (!(context & Context.Method))
+ tolerant(parser, context, 55 /* UnexpectedSuper */);
+ break;
+ default:
+ tolerant(parser, context, 56 /* LoneSuper */);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Super',
+ });
+}
+/**
+ * Parse template literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseTemplateLiteral(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions: [],
+ quasis: [parseTemplateSpans(parser, context)],
+ });
+}
+/**
+ * Parse template head
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param cooked Cooked template value
+ * @param raw Raw template value
+ * @param pos Current location
+ */
+function parseTemplateHead(parser, context, cooked = null, raw, pos) {
+ parser.token = consumeTemplateBrace(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked,
+ raw,
+ },
+ tail: false,
+ });
+}
+/**
+ * Parse template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expression Expression AST node
+ * @param quasis Array of Template elements
+ */
+function parseTemplate(parser, context, expressions = [], quasis = []) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554440 /* TemplateCont */);
+ expressions.push(parseExpression(parser, context));
+ const t = getLocation(parser);
+ quasis.push(parseTemplateHead(parser, context, tokenValue, tokenRaw, pos));
+ if (parser.token === 33554441 /* TemplateTail */) {
+ quasis.push(parseTemplateSpans(parser, context, t));
+ }
+ else {
+ parseTemplate(parser, context, expressions, quasis);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions,
+ quasis,
+ });
+}
+/**
+ * Parse template spans
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateSpans)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param loc Current AST node location
+ */
+function parseTemplateSpans(parser, context, pos = getLocation(parser)) {
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554441 /* TemplateTail */);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked: tokenValue,
+ raw: tokenRaw,
+ },
+ tail: true,
+ });
+}
+/**
+ * Parses decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDecoratorList(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'Decorator',
+ expression: parseLeftHandSideExpression(parser, context, pos)
+ });
+}
+/**
+ * Parses a list of decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDecorators(parser, context) {
+ const decoratorList = [];
+ while (consume(parser, context, 120 /* At */)) {
+ decoratorList.push(parseDecoratorList(parser, context | Context.AllowDecorator));
+ }
+ return decoratorList;
+} + +// Context masks
+var Context;
+(function (Context) {
+ Context[Context["Empty"] = 0] = "Empty";
+ Context[Context["OptionsNext"] = 1] = "OptionsNext";
+ Context[Context["OptionsRanges"] = 2] = "OptionsRanges";
+ Context[Context["OptionsJSX"] = 4] = "OptionsJSX";
+ Context[Context["OptionsRaw"] = 8] = "OptionsRaw";
+ Context[Context["OptionsLoc"] = 16] = "OptionsLoc";
+ Context[Context["OptionsGlobalReturn"] = 32] = "OptionsGlobalReturn";
+ Context[Context["OptionsComments"] = 64] = "OptionsComments";
+ Context[Context["OptionsShebang"] = 128] = "OptionsShebang";
+ Context[Context["OptionsRawidentifiers"] = 256] = "OptionsRawidentifiers";
+ Context[Context["OptionsTolerant"] = 512] = "OptionsTolerant";
+ Context[Context["OptionsNode"] = 1024] = "OptionsNode";
+ Context[Context["OptionsExperimental"] = 2048] = "OptionsExperimental";
+ Context[Context["Strict"] = 4096] = "Strict";
+ Context[Context["Module"] = 8192] = "Module";
+ Context[Context["TaggedTemplate"] = 16384] = "TaggedTemplate";
+ Context[Context["InClass"] = 32768] = "InClass";
+ Context[Context["AllowIn"] = 65536] = "AllowIn";
+ Context[Context["Async"] = 131072] = "Async";
+ Context[Context["Yield"] = 262144] = "Yield";
+ Context[Context["InParameter"] = 524288] = "InParameter";
+ Context[Context["InFunctionBody"] = 1048576] = "InFunctionBody";
+ Context[Context["AllowSingleStatement"] = 2097152] = "AllowSingleStatement";
+ Context[Context["BlockScope"] = 4194304] = "BlockScope";
+ Context[Context["ForStatement"] = 8388608] = "ForStatement";
+ Context[Context["RequireIdentifier"] = 16777216] = "RequireIdentifier";
+ Context[Context["Method"] = 33554432] = "Method";
+ Context[Context["AllowSuperProperty"] = 67108864] = "AllowSuperProperty";
+ Context[Context["InParen"] = 134217728] = "InParen";
+ Context[Context["InJSXChild"] = 268435456] = "InJSXChild";
+ Context[Context["DisallowEscapedKeyword"] = 536870912] = "DisallowEscapedKeyword";
+ Context[Context["AllowDecorator"] = 1073741824] = "AllowDecorator";
+ Context[Context["LocationTracker"] = 18] = "LocationTracker";
+})(Context || (Context = {}));
+// Mutual parser flags
+var Flags;
+(function (Flags) {
+ Flags[Flags["None"] = 0] = "None";
+ Flags[Flags["NewLine"] = 1] = "NewLine";
+ Flags[Flags["AllowBinding"] = 2] = "AllowBinding";
+ Flags[Flags["AllowDestructuring"] = 4] = "AllowDestructuring";
+ Flags[Flags["SimpleParameterList"] = 8] = "SimpleParameterList";
+ Flags[Flags["InSwitchStatement"] = 16] = "InSwitchStatement";
+ Flags[Flags["InIterationStatement"] = 32] = "InIterationStatement";
+ Flags[Flags["HasStrictReserved"] = 64] = "HasStrictReserved";
+ Flags[Flags["HasOctal"] = 128] = "HasOctal";
+ Flags[Flags["SimpleAssignmentTarget"] = 256] = "SimpleAssignmentTarget";
+ Flags[Flags["HasProtoField"] = 512] = "HasProtoField";
+ Flags[Flags["StrictFunctionName"] = 1024] = "StrictFunctionName";
+ Flags[Flags["StrictEvalArguments"] = 2048] = "StrictEvalArguments";
+ Flags[Flags["InFunctionBody"] = 4096] = "InFunctionBody";
+ Flags[Flags["HasAwait"] = 8192] = "HasAwait";
+ Flags[Flags["HasYield"] = 16384] = "HasYield";
+ Flags[Flags["EscapedKeyword"] = 32768] = "EscapedKeyword";
+ Flags[Flags["HasConstructor"] = 65536] = "HasConstructor";
+})(Flags || (Flags = {}));
+// Label tracking state
+var Labels;
+(function (Labels) {
+ Labels[Labels["None"] = 0] = "None";
+ Labels[Labels["NotNested"] = 1] = "NotNested";
+ Labels[Labels["Nested"] = 2] = "Nested";
+})(Labels || (Labels = {}));
+var NumericState;
+(function (NumericState) {
+ NumericState[NumericState["None"] = 0] = "None";
+ NumericState[NumericState["SeenSeparator"] = 1] = "SeenSeparator";
+ NumericState[NumericState["EigthOrNine"] = 2] = "EigthOrNine";
+ NumericState[NumericState["Float"] = 4] = "Float";
+ NumericState[NumericState["BigInt"] = 8] = "BigInt";
+})(NumericState || (NumericState = {}));
+var ScannerState;
+(function (ScannerState) {
+ ScannerState[ScannerState["None"] = 0] = "None";
+ ScannerState[ScannerState["NewLine"] = 1] = "NewLine";
+ ScannerState[ScannerState["LastIsCR"] = 2] = "LastIsCR";
+})(ScannerState || (ScannerState = {}));
+var ModifierState;
+(function (ModifierState) {
+ ModifierState[ModifierState["None"] = 0] = "None";
+ ModifierState[ModifierState["Generator"] = 1] = "Generator";
+ ModifierState[ModifierState["Await"] = 2] = "Await";
+})(ModifierState || (ModifierState = {}));
+var CoverParenthesizedState;
+(function (CoverParenthesizedState) {
+ CoverParenthesizedState[CoverParenthesizedState["None"] = 0] = "None";
+ CoverParenthesizedState[CoverParenthesizedState["SequenceExpression"] = 1] = "SequenceExpression";
+ CoverParenthesizedState[CoverParenthesizedState["HasEvalOrArguments"] = 2] = "HasEvalOrArguments";
+ CoverParenthesizedState[CoverParenthesizedState["HasReservedWords"] = 4] = "HasReservedWords";
+ CoverParenthesizedState[CoverParenthesizedState["HasYield"] = 8] = "HasYield";
+ CoverParenthesizedState[CoverParenthesizedState["HasBinding"] = 16] = "HasBinding";
+})(CoverParenthesizedState || (CoverParenthesizedState = {}));
+var Escape;
+(function (Escape) {
+ Escape[Escape["Empty"] = -1] = "Empty";
+ Escape[Escape["StrictOctal"] = -2] = "StrictOctal";
+ Escape[Escape["EightOrNine"] = -3] = "EightOrNine";
+ Escape[Escape["InvalidHex"] = -4] = "InvalidHex";
+ Escape[Escape["OutOfRange"] = -5] = "OutOfRange";
+})(Escape || (Escape = {}));
+var RegexFlags;
+(function (RegexFlags) {
+ RegexFlags[RegexFlags["Empty"] = 0] = "Empty";
+ RegexFlags[RegexFlags["IgnoreCase"] = 1] = "IgnoreCase";
+ RegexFlags[RegexFlags["Global"] = 2] = "Global";
+ RegexFlags[RegexFlags["Multiline"] = 4] = "Multiline";
+ RegexFlags[RegexFlags["Unicode"] = 8] = "Unicode";
+ RegexFlags[RegexFlags["Sticky"] = 16] = "Sticky";
+ RegexFlags[RegexFlags["DotAll"] = 32] = "DotAll";
+})(RegexFlags || (RegexFlags = {}));
+var CoverCallState;
+(function (CoverCallState) {
+ CoverCallState[CoverCallState["Empty"] = 0] = "Empty";
+ CoverCallState[CoverCallState["SeenSpread"] = 1] = "SeenSpread";
+ CoverCallState[CoverCallState["HasSpread"] = 2] = "HasSpread";
+ CoverCallState[CoverCallState["SimpleParameter"] = 4] = "SimpleParameter";
+ CoverCallState[CoverCallState["EvalOrArguments"] = 8] = "EvalOrArguments";
+ CoverCallState[CoverCallState["Yield"] = 16] = "Yield";
+ CoverCallState[CoverCallState["Await"] = 32] = "Await";
+})(CoverCallState || (CoverCallState = {}));
+var RegexState;
+(function (RegexState) {
+ RegexState[RegexState["Empty"] = 0] = "Empty";
+ RegexState[RegexState["Escape"] = 1] = "Escape";
+ RegexState[RegexState["Class"] = 2] = "Class";
+})(RegexState || (RegexState = {}));
+// Shared between class expr / decl & object literal
+var ObjectState;
+(function (ObjectState) {
+ ObjectState[ObjectState["None"] = 0] = "None";
+ ObjectState[ObjectState["Async"] = 1] = "Async";
+ ObjectState[ObjectState["Generator"] = 2] = "Generator";
+ ObjectState[ObjectState["Getter"] = 4] = "Getter";
+ ObjectState[ObjectState["Setter"] = 8] = "Setter";
+ ObjectState[ObjectState["Computed"] = 16] = "Computed";
+ ObjectState[ObjectState["Method"] = 32] = "Method";
+ ObjectState[ObjectState["Shorthand"] = 64] = "Shorthand";
+ ObjectState[ObjectState["Static"] = 128] = "Static";
+ ObjectState[ObjectState["Constructor"] = 256] = "Constructor";
+ ObjectState[ObjectState["Heritage"] = 512] = "Heritage";
+})(ObjectState || (ObjectState = {}));
+/**
+ * Validate break and continue statement
+ *
+ * @param parser Parser object
+ * @param label label
+ * @param isContinue true if validation continue statement
+ */
+function validateBreakOrContinueLabel(parser, context, label, isContinue) {
+ const state = hasLabel(parser, label);
+ if (!state)
+ tolerant(parser, context, 32 /* UnknownLabel */, label);
+ if (isContinue && !(state & Labels.Nested))
+ tolerant(parser, context, 31 /* IllegalContinue */, label);
+}
+/**
+ * Add label to the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+function addLabel(parser, label) {
+ if (parser.labelSet === undefined)
+ parser.labelSet = {};
+ parser.labelSet[`$${label}`] = isIterationStatement(parser.token) ? Labels.Nested : Labels.NotNested;
+}
+/**
+ * Remove label from the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+function popLabel(parser, label) {
+ parser.labelSet[`$${label}`] = Labels.None;
+}
+/**
+ * Returns either true or false. Depends if the label exist.
+ *
+ * @param parser Parser object
+ * @param label Label
+ */
+function hasLabel(parser, label) {
+ return !parser.labelSet ? Labels.None : parser.labelSet[`$${label}`];
+}
+/**
+ * Finish each the node for each parse. Set line / and column on the node if the
+ * options are set for it
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Line / column
+ * @param node AST node
+ */
+function finishNode(context, parser, meta, node) {
+ const { lastIndex, lastLine, lastColumn, sourceFile, index } = parser;
+ if (context & Context.LocationTracker) {
+ if (context & Context.OptionsRanges) {
+ node.start = meta.index;
+ node.end = lastIndex;
+ }
+ if (context & Context.OptionsLoc) {
+ node.loc = {
+ start: { line: meta.line, column: meta.column },
+ end: { line: lastLine, column: lastColumn }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ return node;
+}
+/**
+ * Consumes the next token. If the consumed token is not of the expected type
+ * then report an error and return null. Otherwise return true.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ * @param Err Optionally error message to be thrown
+ */
+function expect(parser, context, token, err = 1 /* UnexpectedToken */) {
+ if (parser.token !== token)
+ report(parser, err, tokenDesc(parser.token));
+ nextToken(parser, context);
+ return true;
+}
+/**
+ * If the next token matches the given token, this consumes the token
+ * and returns true. Otherwise return false.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ */
+function consume(parser, context, token) {
+ if (parser.token !== token)
+ return false;
+ nextToken(parser, context);
+ return true;
+}
+/**
+ * Advance and return the next token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextToken(parser, context) {
+ parser.lastIndex = parser.index;
+ parser.lastLine = parser.line;
+ parser.lastColumn = parser.column;
+ return (parser.token = scan(parser, context));
+}
+const hasBit = (mask, flags) => (mask & flags) === flags;
+/**
+ * Automatic Semicolon Insertion
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function consumeSemicolon(parser, context) {
+ return parser.token & 1048576 /* ASI */ || parser.flags & Flags.NewLine
+ ? consume(parser, context, 17825809 /* Semicolon */)
+ : report(parser, !(context & Context.Async) && parser.token & 262144 /* IsAwait */ ? 38 /* AwaitOutsideAsync */ : 1 /* UnexpectedToken */, tokenDesc(parser.token));
+}
+/**
+ * Bit fiddle current grammar state and keep track of the state during the parse and restore
+ * it back to original state after finish parsing or throw.
+ *
+ * Ideas for this is basicly from V8 and SM, but also the Esprima parser does this in a similar way.
+ *
+ * However this implementation is an major improvement over similiar implementations, and
+ * does not require additonal bitmasks to be set / unset during the parsing outside this function.
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ * @param errMsg Optional error message
+ */
+function parseExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= Flags.AllowBinding | Flags.AllowDestructuring;
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // If there exist an pending expression error, we throw an error at
+ // the same location it was recorded
+ if (!!parser.pendingExpressionError) {
+ const { error, line, column, index } = parser.pendingExpressionError;
+ constructError(parser, context, index, line, column, error);
+ }
+ // Here we - just in case - disallow both binding and destructuring
+ // and only set the bitmaks if the previous flags (before the callback)
+ // is positive.
+ // Note that this bitmasks may have been turned off during parsing
+ // the callback
+ parser.flags &= ~(Flags.AllowBinding | Flags.AllowDestructuring);
+ if (flags & Flags.AllowBinding)
+ parser.flags |= Flags.AllowBinding;
+ if (flags & Flags.AllowDestructuring)
+ parser.flags |= Flags.AllowDestructuring;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+}
+/**
+ * Restor current grammar to previous state, or unset necessary bitmasks
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ */
+function restoreExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= Flags.AllowBinding | Flags.AllowDestructuring;
+ // Clear pending expression error
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // Both the previous bitmasks and bitmasks set during parsing the callback
+ // has to be positive for us to allow further binding or destructuring.
+ // Note that we allow both before the callback, so this is the only thing
+ // we need to check for.
+ if (!(parser.flags & Flags.AllowBinding) || !(flags & Flags.AllowBinding)) {
+ parser.flags &= ~Flags.AllowBinding;
+ }
+ if (!(parser.flags & Flags.AllowDestructuring) || !(flags & Flags.AllowDestructuring)) {
+ parser.flags &= ~Flags.AllowDestructuring;
+ }
+ // Here we either
+ // 1) restore to previous pending expression error
+ // or
+ // 2) if a pending expression error have been set during the parse (*only in object literal*)
+ // we overwrite previous error, and keep the new one
+ parser.pendingExpressionError = pendingExpressionError || parser.pendingExpressionError;
+ return res;
+}
+/**
+ * Set / unset yield / await context masks based on the
+ * ModifierState masks before invoking the callback and
+ * returning it's content
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Modifier state
+ * @param callback Callback function to be invoked
+ * @param methodState Optional Objectstate.
+ */
+function swapContext(parser, context, state, callback, methodState = ObjectState.None) {
+ context &= ~(Context.Async | Context.Yield | Context.InParameter);
+ if (state & ModifierState.Generator)
+ context |= Context.Yield;
+ if (state & ModifierState.Await)
+ context |= Context.Async;
+ return callback(parser, context, methodState);
+}
+/**
+ * Validates function params
+ *
+ * Note! In case anyone want to enable full scoping, replace 'paramSet' with an similiar
+ * object on the parser object itself. Then push / set the tokenValue to
+ * it an use an bitmask to mark it as an 'variable' not 'blockscope'. Then when
+ * implementing lexical scoping, you can use that for validation.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param params Array of token values
+ */
+function validateParams(parser, context, params) {
+ const paramSet = new Map();
+ for (let i = 0; i < params.length; i++) {
+ const key = `@${params[i]}`;
+ if (paramSet.get(key)) {
+ tolerant(parser, context, 81 /* ParamDupe */);
+ }
+ else
+ paramSet.set(key, true);
+ }
+}
+/**
+ * Reinterpret various expressions as pattern
+ * This is only used for assignment and arrow parameter list
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param node AST node
+ */
+const reinterpret = (parser, context, node) => {
+ switch (node.type) {
+ case 'Identifier':
+ if (context & Context.Strict && nameIsArgumentsOrEval(node.name))
+ report(parser, 3 /* InvalidEscapedReservedWord */);
+ case 'ArrayPattern':
+ case 'AssignmentPattern':
+ case 'ObjectPattern':
+ case 'RestElement':
+ case 'MetaProperty':
+ return;
+ case 'ArrayExpression':
+ node.type = 'ArrayPattern';
+ for (let i = 0; i < node.elements.length; ++i) {
+ // skip holes in pattern
+ if (node.elements[i] !== null) {
+ reinterpret(parser, context, node.elements[i]);
+ }
+ }
+ return;
+ case 'ObjectExpression':
+ node.type = 'ObjectPattern';
+ for (let i = 0; i < node.properties.length; i++) {
+ reinterpret(parser, context, node.properties[i]);
+ }
+ return;
+ case 'Property':
+ reinterpret(parser, context, node.value);
+ return;
+ case 'SpreadElement':
+ node.type = 'RestElement';
+ if (node.argument.type !== 'ArrayExpression' &&
+ node.argument.type !== 'ObjectExpression' &&
+ !isValidSimpleAssignmentTarget(node.argument)) {
+ tolerant(parser, context, 71 /* RestDefaultInitializer */);
+ }
+ reinterpret(parser, context, node.argument);
+ break;
+ case 'AssignmentExpression':
+ node.type = 'AssignmentPattern';
+ delete node.operator; // operator is not relevant for assignment pattern
+ reinterpret(parser, context, node.left); // recursive descent
+ return;
+ case 'MemberExpression':
+ if (!(context & Context.InParameter))
+ return;
+ // Fall through
+ default:
+ tolerant(parser, context, context & Context.InParameter ? 77 /* NotBindable */ : 73 /* InvalidDestructuringTarget */, node.type);
+ }
+};
+/**
+ * Does a lookahead.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param callback Callback function to be invoked
+ */
+function lookahead(parser, context, callback) {
+ const { tokenValue, flags, line, column, startColumn, index, lastColumn, startLine, lastLine, lastIndex, startIndex, tokenRaw, token, lastValue, tokenRegExp, labelSet, errors, errorLocation, pendingExpressionError } = parser;
+ const res = callback(parser, context);
+ parser.index = index;
+ parser.token = token;
+ parser.tokenValue = tokenValue;
+ parser.tokenValue = tokenValue;
+ parser.flags = flags;
+ parser.line = line;
+ parser.column = column;
+ parser.tokenRaw = tokenRaw;
+ parser.lastValue = lastValue;
+ parser.startColumn = startColumn;
+ parser.lastColumn = lastColumn;
+ parser.startLine = startLine;
+ parser.lastLine = lastLine;
+ parser.lastIndex = lastIndex;
+ parser.startIndex = startIndex;
+ parser.tokenRegExp = tokenRegExp;
+ parser.labelSet = labelSet;
+ parser.errors = errors;
+ parser.errorLocation = errorLocation;
+ parser.tokenRegExp = tokenRegExp;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+}
+/**
+ * Returns true if this an valid simple assignment target
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function isValidSimpleAssignmentTarget(node) {
+ return node.type === 'Identifier' || node.type === 'MemberExpression' ? true : false;
+}
+/**
+ * Get current node location
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function getLocation(parser) {
+ return {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+}
+/**
+ * Returns true if this is an valid identifier
+ *
+ * @param context Context masks
+ * @param t Token
+ */
+function isValidIdentifier(context, t) {
+ if (context & Context.Strict) {
+ if (context & Context.Module && t & 262144 /* IsAwait */)
+ return false;
+ if (t & 1073741824 /* IsYield */)
+ return false;
+ return (t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (t & 69632 /* Contextual */) === 69632 /* Contextual */;
+ }
+ return ((t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (t & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (t & 20480 /* FutureReserved */) === 20480 /* FutureReserved */);
+}
+/**
+ * Returns true if this an valid lexical binding and not an identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function isLexical(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return !!(token & (131072 /* IsIdentifier */ | 8388608 /* IsBindingPattern */ | 1073741824 /* IsYield */ | 262144 /* IsAwait */) ||
+ token === 33574984 /* LetKeyword */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */);
+}
+/**
+ * Returns true if this is end of case or default clauses
+ *
+ * @param parser Parser object
+ */
+function isEndOfCaseOrDefaultClauses(parser) {
+ return (parser.token === 12368 /* DefaultKeyword */ || parser.token === 17825807 /* RightBrace */ || parser.token === 12363 /* CaseKeyword */);
+}
+/**
+ * Validates if the next token in the stream is a left paren or a period
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextTokenIsLeftParenOrPeriod(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */ || parser.token === 16777229 /* Period */;
+}
+/**
+ * Validates if the next token in the stream is a identifier or left paren
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextTokenisIdentifierOrParen(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return token & (131072 /* IsIdentifier */ | 1073741824 /* IsYield */) || token === 50331659 /* LeftParen */;
+}
+/**
+ * Validates if the next token in the stream is left parenthesis.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextTokenIsLeftParen(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */;
+}
+/**
+ * Validates if the next token in the stream is a function keyword on the same line.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function nextTokenIsFuncKeywordOnSameLine(parser, context) {
+ nextToken(parser, context);
+ return !(parser.flags & Flags.NewLine) && parser.token === 33566808 /* FunctionKeyword */;
+}
+/**
+ * Checks if the property has any private field key
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function isPropertyWithPrivateFieldKey(expr) {
+ return !expr.property ? false : expr.property.type === 'PrivateName';
+}
+/**
+ * Parse and classify itendifier - similar method as in V8
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAndClassifyIdentifier(parser, context) {
+ const { token, tokenValue: name } = parser;
+ if (context & Context.Strict) {
+ if (context & Context.Module && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (token & 69632 /* Contextual */) === 69632 /* Contextual */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (context & Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+}
+function nameIsArgumentsOrEval(value) {
+ return value === 'eval' || value === 'arguments';
+}
+/**
+ * Records an error from current position. If we report an error later, we'll do it from
+ * this position.
+ *
+ * @param parser Parser object
+ */
+function setPendingError(parser) {
+ parser.errorLocation = {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+}
+/**
+ * Returns tagName for JSX element
+ *
+ * @param elementName JSX Element name
+ */
+function isEqualTagNames(elementName) {
+ // tslint:disable-next-line:switch-default | this switch is exhaustive
+ switch (elementName.type) {
+ case 'JSXIdentifier':
+ return elementName.name;
+ case 'JSXNamespacedName':
+ return `${isEqualTagNames(elementName.namespace)}:${isEqualTagNames(elementName.name)}`;
+ case 'JSXMemberExpression':
+ return `${isEqualTagNames(elementName.object)}.${isEqualTagNames(elementName.property)}`;
+ }
+}
+/**
+ * Returns true if this is an instance field ( stage 3 proposal)
+ *
+ * @param parser Parser object
+ */
+function isInstanceField(parser) {
+ const { token } = parser;
+ return token === 17825807 /* RightBrace */ || token === 17825809 /* Semicolon */ || token === 83886109 /* Assign */;
+}
+/**
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expr AST expressions
+ * @param prefix prefix
+ */
+function validateUpdateExpression(parser, context, expr, prefix) {
+ if (context & Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 68 /* StrictLHSPrefixPostFix */, prefix);
+ }
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+}
+/**
+ * Record expression error
+ *
+ * @param parser Parser object
+ * @param error Error message
+ */
+function setPendingExpressionError(parser, type) {
+ parser.pendingExpressionError = {
+ error: errorMessages[type],
+ line: parser.line,
+ column: parser.column,
+ index: parser.index
+ };
+}
+/**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+function validateCoverParenthesizedExpression(parser, state) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= CoverParenthesizedState.HasEvalOrArguments;
+ }
+ else if ((token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ setPendingError(parser);
+ state |= CoverParenthesizedState.HasReservedWords;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= Flags.HasAwait;
+ }
+ }
+ return state;
+}
+/**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+function validateAsyncArgumentList(parser, context, state) {
+ const { token } = parser;
+ if (!(parser.flags & Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= CoverCallState.EvalOrArguments;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ state |= CoverCallState.Await;
+ }
+ else if ((token & 1073741824 /* IsYield */) === 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ state |= CoverCallState.Yield;
+ }
+ }
+ return state;
+}
+/**
+ * Returns true if iteration statement. Otherwise return false,
+ *
+ * @param t Token
+ */
+function isIterationStatement(t) {
+ return t === 12369 /* DoKeyword */ || t === 12386 /* WhileKeyword */ || t === 12374 /* ForKeyword */;
+}
+/**
+ * Returns true if in or of token. Otherwise return false,
+ *
+ * @param t Token
+ */
+function isInOrOf(t) {
+ return t === 69746 /* OfKeyword */ || t === 167786289 /* InKeyword */;
+} + +/*@internal*/
+const errorMessages = {
+ [0 /* Unexpected */]: 'Unexpected token',
+ [1 /* UnexpectedToken */]: 'Unexpected token \'%0\'',
+ [2 /* ExpectedToken */]: 'Expected token \'%0\'',
+ [3 /* InvalidEscapedReservedWord */]: 'Keyword must not contain escaped characters',
+ [4 /* UnexpectedKeyword */]: 'Keyword \'%0\' is reserved',
+ [5 /* InvalidLHSInAssignment */]: 'Invalid left-hand side in assignment',
+ [6 /* UnterminatedString */]: 'Unterminated string literal',
+ [7 /* UnterminatedRegExp */]: 'Unterminated regular expression literal',
+ [8 /* UnterminatedComment */]: 'Unterminated MultiLineComment',
+ [9 /* UnterminatedTemplate */]: 'Unterminated template literal',
+ [10 /* UnexpectedChar */]: 'Invalid character \'%0\'',
+ [11 /* StrictOctalEscape */]: 'Octal escapes are not allowed in strict mode',
+ [13 /* InvalidEightAndNine */]: 'Escapes \\8 or \\9 are not syntactically valid escapes',
+ [14 /* UnicodeOutOfRange */]: 'Unicode escape code point out of range',
+ [15 /* DuplicateRegExpFlag */]: 'Duplicate regular expression flag \'%0\'',
+ [16 /* UnexpectedTokenRegExpFlag */]: 'Unexpected regular expression flag \'%0\'',
+ [17 /* StrictLHSAssignment */]: 'Eval or arguments can\'t be assigned to in strict mode code',
+ [18 /* IllegalReturn */]: 'Illegal return statement',
+ [19 /* StrictFunction */]: 'In strict mode code, functions can only be declared at top level or inside a block',
+ [20 /* SloppyFunction */]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+ [21 /* ForbiddenAsStatement */]: '%0 can\'t appear in single-statement context',
+ [22 /* GeneratorInSingleStatementContext */]: 'Generators can only be declared at the top level or inside a block',
+ [23 /* ForAwaitNotOf */]: '\'for await\' loop should be used with \'of\'',
+ [24 /* DeclarationMissingInitializer */]: 'Missing initializer in %0 declaration',
+ [25 /* ForInOfLoopInitializer */]: '\'for-%0\' loop variable declaration may not have an initializer',
+ [26 /* ForInOfLoopMultiBindings */]: 'Invalid left-hand side in for-%0 loop: Must have a single binding.',
+ [27 /* LetInLexicalBinding */]: 'let is disallowed as a lexically bound name',
+ [28 /* UnexpectedLexicalDeclaration */]: 'Lexical declaration cannot appear in a single-statement context',
+ [29 /* LabelRedeclaration */]: 'Label \'%0\' has already been declared',
+ [30 /* InvalidNestedStatement */]: '%0 statement must be nested within an iteration statement',
+ [31 /* IllegalContinue */]: 'Illegal continue statement: \'%0\' does not denote an iteration statement',
+ [32 /* UnknownLabel */]: 'Undefined label \'%0\'',
+ [33 /* MultipleDefaultsInSwitch */]: 'More than one default clause in switch statement',
+ [34 /* ImportExportDeclAtTopLevel */]: '%0 declarations may only appear at top level of a module',
+ [35 /* AsyncFunctionInSingleStatementContext */]: 'Async functions can only be declared at the top level or inside a block',
+ [36 /* InvalidLineBreak */]: 'No line break is allowed after \'%0\'',
+ [37 /* StrictModeWith */]: 'Strict mode code may not include a with statement',
+ [38 /* AwaitOutsideAsync */]: 'Await is only valid in async functions',
+ [39 /* UnNamedFunctionDecl */]: 'Function declaration must have a name in this context',
+ [12 /* DuplicateConstructor */]: 'Duplicate constructor method in class',
+ [40 /* DisallowedInContext */]: '\'%0\' may not be used as an identifier in this context',
+ [43 /* StrictDelete */]: 'Delete of an unqualified identifier in strict mode',
+ [44 /* DeletePrivateField */]: 'Private fields can not be deleted',
+ [41 /* PrivateFieldConstructor */]: 'Classes may not have a private field named \'#constructor\'',
+ [42 /* PublicFieldConstructor */]: 'Classes may not have a field named \'constructor\'',
+ [45 /* InvalidConstructor */]: 'Class constructor may not be a \'%0\'',
+ [46 /* UnexpectedReserved */]: 'Unexpected reserved word',
+ [47 /* StrictEvalArguments */]: 'Unexpected eval or arguments in strict mode',
+ [48 /* AwaitBindingIdentifier */]: '\'await\' is not a valid identifier inside an async function',
+ [49 /* YieldBindingIdentifier */]: '\'yield\' is not a valid identifier inside an generator function',
+ [50 /* UnexpectedStrictReserved */]: 'Unexpected strict mode reserved word',
+ [52 /* AwaitInParameter */]: 'Await expression not allowed in formal parameter',
+ [51 /* YieldInParameter */]: 'Yield expression not allowed in formal parameter',
+ [53 /* MetaNotInFunctionBody */]: 'new.target only allowed within functions',
+ [54 /* BadSuperCall */]: 'super() is not allowed in this context',
+ [55 /* UnexpectedSuper */]: 'Member access from super not allowed in this context',
+ [56 /* LoneSuper */]: 'Only "(" or "." or "[" are allowed after \'super\'',
+ [57 /* YieldReservedKeyword */]: '\'yield\' is a reserved keyword within generator function bodies',
+ [58 /* ContinuousNumericSeparator */]: 'Only one underscore is allowed as numeric separator',
+ [59 /* TrailingNumericSeparator */]: 'Numeric separators are not allowed at the end of numeric literals',
+ [60 /* ZeroDigitNumericSeparator */]: 'Numeric separator can not be used after leading 0.',
+ [61 /* StrictOctalLiteral */]: 'Legacy octal literals are not allowed in strict mode',
+ [62 /* InvalidLhsInAssignment */]: 'Invalid left-hand side in assignment',
+ [63 /* DuplicateProto */]: 'Property name __proto__ appears more than once in object literal',
+ [64 /* IllegalUseStrict */]: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ [65 /* StaticPrototype */]: 'Classes may not have a static property named \'prototype\'',
+ [66 /* AccessorWrongArgs */]: '%0 functions must have %1 argument%2',
+ [67 /* BadSetterRestParameter */]: 'Setter function argument must not be a rest parameter',
+ [68 /* StrictLHSPrefixPostFix */]: '%0 increment/decrement may not have eval or arguments operand in strict mode',
+ [69 /* InvalidElisonInObjPropList */]: 'Elision not allowed in object property list',
+ [70 /* ElementAfterRest */]: 'Rest element must be last element',
+ [72 /* ElementAfterSpread */]: 'Spread element must be last element',
+ [71 /* RestDefaultInitializer */]: 'Rest parameter may not have a default initializer',
+ [73 /* InvalidDestructuringTarget */]: 'Invalid destructuring assignment target',
+ [74 /* UnexpectedSurrogate */]: 'Unexpected surrogate pair',
+ [75 /* MalformedEscape */]: 'Malformed %0 character escape sequence',
+ [76 /* TemplateOctalLiteral */]: 'Template literals may not contain octal escape sequences',
+ [77 /* NotBindable */]: 'Invalid binding pattern',
+ [78 /* ParamAfterRest */]: 'Rest parameter must be last formal parameter',
+ [79 /* NoCatchOrFinally */]: 'Missing catch or finally after try',
+ [80 /* NewlineAfterThrow */]: 'Illegal newline after throw',
+ [81 /* ParamDupe */]: 'Duplicate parameter name not allowed in this context',
+ [82 /* AsAfterImportStart */]: 'Missing keyword \'as\' after import *',
+ [83 /* LabelNoColon */]: 'Labels must be followed by a \':\'',
+ [84 /* NonEmptyJSXExpression */]: 'JSX attributes must only be assigned a non-empty \'expression\'',
+ [85 /* ExpectedJSXClosingTag */]: 'Expected corresponding JSX closing tag for %0',
+ [86 /* AdjacentJSXElements */]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+ [87 /* InvalidJSXAttributeValue */]: 'Invalid JSX attribute value',
+ [88 /* RestWithComma */]: 'Rest element may not have a trailing comma',
+ [89 /* UndefinedUnicodeCodePoint */]: 'Undefined Unicode code-point',
+ [90 /* HtmlCommentInModule */]: 'HTML comments are not allowed in modules',
+ [91 /* InvalidCoverInitializedName */]: 'Invalid shorthand property initializer',
+ [92 /* TrailingDecorators */]: 'Trailing decorator may be followed by method',
+ [93 /* GeneratorConstructor */]: 'Decorators can\'t be used with a constructor',
+ [94 /* InvalidRestBindingPattern */]: '`...` must be followed by an identifier in declaration contexts',
+};
+/**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param index The 0-based end index of the error.
+ * @param line The 0-based line position of the error.
+ * @param column The 0-based column position of the error.
+ * @param parser The 0-based end index of the current node.
+ * @param description Error description
+ */
+/*@internal*/
+function constructError(parser, context, index, line, column, description) {
+ const error = new SyntaxError(`Line ${line}, column ${column}: ${description}`);
+ error.index = index;
+ error.line = line;
+ error.column = column;
+ error.description = description;
+ if (context & Context.OptionsTolerant) {
+ parser.errors.push(error);
+ }
+ else
+ throw error;
+}
+/**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ */
+function getErrorLocation(parser) {
+ let { index, startLine: line, startColumn: column } = parser;
+ const errorLoc = parser.errorLocation;
+ if (!!errorLoc) {
+ index = errorLoc.index;
+ line = errorLoc.line;
+ column = errorLoc.column;
+ }
+ return { index, line, column };
+}
+/**
+ * Throws an error
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+/*@internal*/
+function report(parser, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, Context.Empty, index, line, column, errorMessage);
+}
+/**
+ * If in tolerant mode, all errors are pushed to a top-level error array containing
+ * otherwise throws
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+/*@internal*/
+function tolerant(parser, context, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, context, index, line, column, errorMessage);
+} + +// Declarations
+/**
+ * Parses class declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseClassDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const id = (context & Context.RequireIdentifier && (parser.token !== 33685505 /* Identifier */))
+ ? null :
+ parseBindingIdentifier(parser, context | Context.Strict | Context.DisallowEscapedKeyword);
+ let state = ObjectState.None;
+ let superClass = null;
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | Context.Strict, pos);
+ state |= ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context & ~Context.RequireIdentifier | Context.Strict | Context.InClass, state);
+ return finishNode(context, parser, pos, context & Context.OptionsExperimental ? {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body
+ });
+}
+/**
+ * Parses function declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseFunctionDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ let isGenerator = ModifierState.None;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ if (context & Context.AllowSingleStatement && !(context & Context.InFunctionBody)) {
+ tolerant(parser, context, 22 /* GeneratorInSingleStatementContext */);
+ }
+ isGenerator = ModifierState.Generator;
+ }
+ return parseFunctionDeclarationBody(parser, context, isGenerator, pos);
+}
+/**
+ * Parses out a function declartion body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context mask
+ * @param state Modifier state
+ * @param pos Current location
+ */
+function parseFunctionDeclarationBody(parser, context, state, pos) {
+ const { token } = parser;
+ let id = null;
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (context & Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (token !== 50331659 /* LeftParen */) {
+ id = parseBindingIdentifier(parser, context);
+ // Unnamed functions are forbidden in statement context.
+ }
+ else if (!(context & Context.RequireIdentifier))
+ tolerant(parser, context, 39 /* UnNamedFunctionDecl */);
+ const { params, body } = swapContext(parser, context & ~(Context.Method | Context.AllowSuperProperty | Context.RequireIdentifier), state, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionDeclaration',
+ params,
+ body,
+ async: !!(state & ModifierState.Await),
+ generator: !!(state & ModifierState.Generator),
+ expression: false,
+ id,
+ });
+}
+/**
+ * Parses async function or async generator declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isAwait = ModifierState.Await;
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? ModifierState.Generator : ModifierState.None;
+ return parseFunctionDeclarationBody(parser, context, isGenerator | isAwait, pos);
+}
+/**
+ * VariableDeclaration :
+ * BindingIdentifier Initializeropt
+ * BindingPattern Initializer
+ *
+ * VariableDeclarationNoIn :
+ * BindingIdentifier InitializerNoInopt
+ * BindingPattern InitializerNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseVariableDeclaration(parser, context, isConst) {
+ const pos = getLocation(parser);
+ const isBindingPattern = (parser.token & 8388608 /* IsBindingPattern */) !== 0;
+ const id = parseBindingIdentifierOrPattern(parser, context);
+ let init = null;
+ if (consume(parser, context | Context.DisallowEscapedKeyword, 83886109 /* Assign */)) {
+ init = parseExpressionCoverGrammar(parser, context & ~(Context.BlockScope | Context.ForStatement), parseAssignmentExpression);
+ if (isInOrOf(parser.token) && (context & Context.ForStatement || isBindingPattern)) {
+ if (parser.token === 167786289 /* InKeyword */) {
+ // https://github.com/tc39/test262/blob/master/test/annexB/language/statements/for-in/strict-initializer.js
+ if (context & (Context.BlockScope | Context.Strict | Context.Async) || isBindingPattern) {
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ }
+ else
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ // Note: Initializers are required for 'const' and binding patterns
+ }
+ else if (!isInOrOf(parser.token) && (isConst || isBindingPattern)) {
+ tolerant(parser, context, 24 /* DeclarationMissingInitializer */, isConst ? 'const' : 'destructuring');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclarator',
+ init,
+ id,
+ });
+}
+/**
+ * Parses variable declaration list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclarationList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseVariableDeclarationList(parser, context, isConst) {
+ const list = [parseVariableDeclaration(parser, context, isConst)];
+ while (consume(parser, context, 16777234 /* Comma */))
+ list.push(parseVariableDeclaration(parser, context, isConst));
+ if (context & Context.ForStatement && isInOrOf(parser.token) && list.length !== 1) {
+ tolerant(parser, context, 26 /* ForInOfLoopMultiBindings */, tokenDesc(parser.token));
+ }
+ return list;
+} + +// Statements
+/**
+ * Parses statement list items
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementListItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseStatementListItem(parser, context) {
+ switch (parser.token) {
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionDeclaration(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassDeclaration(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetOrExpressionStatement(parser, context | Context.AllowIn);
+ case 33566793 /* ConstKeyword */:
+ return parseVariableStatement(parser, context | Context.BlockScope | Context.AllowIn);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionDeclarationOrStatement(parser, context);
+ case 33566810 /* ImportKeyword */: {
+ if (context & Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod)) {
+ return parseExpressionStatement(parser, context | Context.AllowIn);
+ }
+ }
+ case 12371 /* ExportKeyword */:
+ if (context & Context.Module) {
+ tolerant(parser, context, 34 /* ImportExportDeclAtTopLevel */, tokenDesc(parser.token));
+ }
+ default:
+ return parseStatement(parser, context | Context.AllowSingleStatement);
+ }
+}
+/**
+ * Parses statements
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseStatement(parser, context) {
+ switch (parser.token) {
+ case 33566791 /* VarKeyword */:
+ return parseVariableStatement(parser, context | Context.AllowIn);
+ case 17825809 /* Semicolon */:
+ return parseEmptyStatement(parser, context);
+ case 33566814 /* SwitchKeyword */:
+ return parseSwitchStatement(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseBlockStatement(parser, context);
+ case 12380 /* ReturnKeyword */:
+ return parseReturnStatement(parser, context);
+ case 12377 /* IfKeyword */:
+ return parseIfStatement(parser, context);
+ case 12369 /* DoKeyword */:
+ return parseDoWhileStatement(parser, context);
+ case 12386 /* WhileKeyword */:
+ return parseWhileStatement(parser, context);
+ case 12387 /* WithKeyword */:
+ return parseWithStatement(parser, context);
+ case 12362 /* BreakKeyword */:
+ return parseBreakStatement(parser, context);
+ case 12366 /* ContinueKeyword */:
+ return parseContinueStatement(parser, context);
+ case 12367 /* DebuggerKeyword */:
+ return parseDebuggerStatement(parser, context);
+ case 302002272 /* ThrowKeyword */:
+ return parseThrowStatement(parser, context);
+ case 12385 /* TryKeyword */:
+ return parseTryStatement(parser, context | Context.DisallowEscapedKeyword);
+ case 12374 /* ForKeyword */:
+ return parseForStatement(parser, context | Context.ForStatement);
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ tolerant(parser, context, 35 /* AsyncFunctionInSingleStatementContext */);
+ }
+ return parseExpressionOrLabelledStatement(parser, context | Context.AllowSingleStatement);
+ case 33566808 /* FunctionKeyword */:
+ // V8
+ tolerant(parser, context, context & Context.Strict ? 19 /* StrictFunction */ : 20 /* SloppyFunction */);
+ case 33566797 /* ClassKeyword */:
+ tolerant(parser, context, 21 /* ForbiddenAsStatement */, tokenDesc(parser.token));
+ default:
+ return parseExpressionOrLabelledStatement(parser, context);
+ }
+}
+/**
+ * Parses empty statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-EmptyStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseEmptyStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'EmptyStatement'
+ });
+}
+/**
+ * Parses the continue statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ContinueStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseContinueStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ // Appearing of continue without an IterationStatement leads to syntax error
+ if (!(parser.flags & (Flags.InSwitchStatement | Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, tokenDesc(parser.token));
+ }
+ let label = null;
+ if (!(parser.flags & Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, true);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ContinueStatement',
+ label
+ });
+}
+/**
+ * Parses the break statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BreakStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBreakStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let label = null;
+ if (!(parser.flags & Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, false);
+ }
+ else if (!(parser.flags & (Flags.InSwitchStatement | Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, 'break');
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'BreakStatement',
+ label
+ });
+}
+/**
+ * Parses the if statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-if-statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseIfStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const consequent = parseConsequentOrAlternate(parser, context | Context.DisallowEscapedKeyword);
+ const alternate = consume(parser, context, 12370 /* ElseKeyword */) ? parseConsequentOrAlternate(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'IfStatement',
+ test,
+ consequent,
+ alternate
+ });
+}
+/**
+ * Parse either consequent or alternate. Supports AnnexB.
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseConsequentOrAlternate(parser, context) {
+ return context & Context.Strict || parser.token !== 33566808 /* FunctionKeyword */
+ ? parseStatement(parser, context & ~Context.AllowSingleStatement)
+ : parseFunctionDeclaration(parser, context);
+}
+/**
+ * Parses the debugger statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DebuggerStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDebuggerStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'DebuggerStatement'
+ });
+}
+/**
+ * Parses try statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TryStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseTryStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const block = parseBlockStatement(parser, context);
+ const handler = parser.token === 12364 /* CatchKeyword */ ? parseCatchBlock(parser, context) : null;
+ const finalizer = consume(parser, context, 12373 /* FinallyKeyword */) ? parseBlockStatement(parser, context) : null;
+ if (!handler && !finalizer)
+ tolerant(parser, context, 79 /* NoCatchOrFinally */);
+ return finishNode(context, parser, pos, {
+ type: 'TryStatement',
+ block,
+ handler,
+ finalizer
+ });
+}
+/**
+ * Parses catch block
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Catch)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseCatchBlock(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let param = null;
+ if (consume(parser, context, 50331659 /* LeftParen */)) {
+ const params = [];
+ param = parseBindingIdentifierOrPattern(parser, context, params);
+ validateParams(parser, context, params);
+ expect(parser, context, 16 /* RightParen */);
+ }
+ const body = parseBlockStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'CatchClause',
+ param,
+ body
+ });
+}
+/**
+ * Parses throw statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ThrowStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseThrowStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ if (parser.flags & Flags.NewLine)
+ tolerant(parser, context, 80 /* NewlineAfterThrow */);
+ const argument = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ThrowStatement',
+ argument
+ });
+}
+/**
+ * Parses expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseExpressionStatement(parser, context) {
+ const pos = getLocation(parser);
+ const expr = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+}
+/**
+ * Parse directive node
+ *
+ * * @see [Link](https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDirective(parser, context) {
+ const pos = getLocation(parser);
+ const directive = parser.tokenRaw.slice(1, -1);
+ const expr = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr,
+ directive
+ });
+}
+/**
+ * Parses either expression or labelled statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LabelledStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseExpressionOrLabelledStatement(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, token } = parser;
+ const expr = parseExpression(parser, (context & ~(Context.AllowSingleStatement | Context.AllowDecorator)) | Context.AllowIn);
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */) && parser.token === 16777237 /* Colon */) {
+ // If within generator function bodies, we do it like this so we can throw an nice error message
+ if (context & Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 57 /* YieldReservedKeyword */);
+ expect(parser, context, 16777237 /* Colon */, 83 /* LabelNoColon */);
+ if (hasLabel(parser, tokenValue))
+ tolerant(parser, context, 29 /* LabelRedeclaration */, tokenValue);
+ addLabel(parser, tokenValue);
+ const body = !(context & Context.Strict) &&
+ context & Context.AllowSingleStatement &&
+ parser.token === 33566808 /* FunctionKeyword */
+ ? parseFunctionDeclaration(parser, context)
+ : parseStatement(parser, context);
+ popLabel(parser, tokenValue);
+ return finishNode(context, parser, pos, {
+ type: 'LabeledStatement',
+ label: expr,
+ body
+ });
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+}
+/**
+ * Parses do while statement
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseDoWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const body = parseIterationStatement(parser, context);
+ expect(parser, context, 12386 /* WhileKeyword */);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ consume(parser, context, 17825809 /* Semicolon */);
+ return finishNode(context, parser, pos, {
+ type: 'DoWhileStatement',
+ body,
+ test
+ });
+}
+/**
+ * Parses while statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-WhileStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'WhileStatement',
+ test,
+ body
+ });
+}
+/**
+ * Parses block statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BlockStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Block)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseBlockStatement(parser, context) {
+ const pos = getLocation(parser);
+ const body = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body
+ });
+}
+/**
+ * Parses return statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ReturnStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseReturnStatement(parser, context) {
+ const pos = getLocation(parser);
+ if (!(context & (Context.OptionsGlobalReturn | Context.InFunctionBody))) {
+ tolerant(parser, context, 18 /* IllegalReturn */);
+ }
+ if (parser.flags & Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const argument = !(parser.token & 1048576 /* ASI */) && !(parser.flags & Flags.NewLine)
+ ? parseExpression(parser, (context & ~(Context.InFunctionBody | Context.AllowDecorator)) | Context.AllowIn)
+ : null;
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ReturnStatement',
+ argument
+ });
+}
+/**
+ * Sets the necessary mutable parser flags. The parser flags will
+ * be unset after done parsing out the statements.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-IterationStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseIterationStatement(parser, context) {
+ // Note: We are deviating from the original grammar here beauce the original grammar says that the
+ // 'iterationStatement' should return either'for', 'do' or 'while' statements. We are doing some
+ // bitfiddling before and after to modify the parser state before we let the 'parseStatement'
+ // return the mentioned statements (to match the original grammar).
+ const savedFlags = parser.flags;
+ parser.flags |= Flags.InIterationStatement | Flags.AllowDestructuring;
+ const body = parseStatement(parser, (context & ~Context.AllowSingleStatement) | Context.DisallowEscapedKeyword);
+ parser.flags = savedFlags;
+ return body;
+}
+/**
+ * Parses with statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-WithStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseWithStatement(parser, context) {
+ if (context & Context.Strict)
+ tolerant(parser, context, 37 /* StrictModeWith */);
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const object = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseStatement(parser, context & ~Context.AllowSingleStatement);
+ return finishNode(context, parser, pos, {
+ type: 'WithStatement',
+ object,
+ body
+ });
+}
+/**
+ * Parses switch statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SwitchStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseSwitchStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const discriminant = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ expect(parser, context | Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const cases = [];
+ const savedFlags = parser.flags;
+ parser.flags |= Flags.InSwitchStatement;
+ let seenDefault = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ const clause = parseCaseOrDefaultClauses(parser, context);
+ cases.push(clause);
+ if (clause.test === null) {
+ if (seenDefault)
+ tolerant(parser, context, 33 /* MultipleDefaultsInSwitch */);
+ seenDefault = true;
+ }
+ }
+ parser.flags = savedFlags;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'SwitchStatement',
+ discriminant,
+ cases
+ });
+}
+/**
+ * Parses either default clause or case clauses
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CaseClauses)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DefaultClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseCaseOrDefaultClauses(parser, context) {
+ const pos = getLocation(parser);
+ let test = null;
+ if (consume(parser, context, 12363 /* CaseKeyword */)) {
+ test = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ }
+ else {
+ expect(parser, context, 12368 /* DefaultKeyword */);
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ const consequent = [];
+ while (!isEndOfCaseOrDefaultClauses(parser)) {
+ consequent.push(parseStatementListItem(parser, context | Context.AllowIn));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'SwitchCase',
+ test,
+ consequent
+ });
+}
+/**
+ * Parses variable statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseVariableStatement(parser, context, shouldConsume = true) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const isConst = token === 33566793 /* ConstKeyword */;
+ nextToken(parser, context);
+ const declarations = parseVariableDeclarationList(parser, context, isConst);
+ // Only consume semicolons if not inside the 'ForStatement' production
+ if (shouldConsume)
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclaration',
+ kind: tokenDesc(token),
+ declarations
+ });
+}
+/**
+ * Parses either an lexical declaration (let) or an expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-let-and-const-declarations)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseLetOrExpressionStatement(parser, context, shouldConsume = true) {
+ return lookahead(parser, context, isLexical)
+ ? parseVariableStatement(parser, context | Context.BlockScope, shouldConsume)
+ : parseExpressionOrLabelledStatement(parser, context);
+}
+/**
+ * Parses either async function declaration or statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAsyncFunctionDeclarationOrStatement(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)
+ ? parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context)
+ : parseStatement(parser, context);
+}
+/**
+ * Parses either For, ForIn or ForOf statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-statement)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseForStatement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 12374 /* ForKeyword */);
+ const awaitToken = !!(context & Context.Async && consume(parser, context, 34017389 /* AwaitKeyword */));
+ expect(parser, context | Context.DisallowEscapedKeyword, 50331659 /* LeftParen */);
+ const { token } = parser;
+ let init = null;
+ let sequencePos = null;
+ let variableStatement = null;
+ let type = 'ForStatement';
+ let test = null;
+ let update = null;
+ let right;
+ if (token === 33566793 /* ConstKeyword */ || (token === 33574984 /* LetKeyword */ && lookahead(parser, context, isLexical))) {
+ variableStatement = parseVariableStatement(parser, (context & ~Context.AllowIn) | Context.BlockScope, false);
+ }
+ else if (token === 33566791 /* VarKeyword */) {
+ variableStatement = parseVariableStatement(parser, context & ~Context.AllowIn, false);
+ }
+ else if (token !== 17825809 /* Semicolon */) {
+ sequencePos = getLocation(parser);
+ init = restoreExpressionCoverGrammar(parser, (context & ~Context.AllowIn) | Context.DisallowEscapedKeyword, parseAssignmentExpression);
+ }
+ if (consume(parser, context, 69746 /* OfKeyword */)) {
+ type = 'ForOfStatement';
+ if (init) {
+ if (!(parser.flags & Flags.AllowDestructuring) || init.type === 'AssignmentExpression') {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ right = parseAssignmentExpression(parser, context | Context.AllowIn);
+ }
+ else if (consume(parser, context, 167786289 /* InKeyword */)) {
+ if (init) {
+ if (!(parser.flags & Flags.AllowDestructuring))
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ type = 'ForInStatement';
+ right = parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn);
+ }
+ else {
+ if (parser.token === 16777234 /* Comma */)
+ init = parseSequenceExpression(parser, context, init, sequencePos);
+ if (variableStatement)
+ init = variableStatement;
+ expect(parser, context, 17825809 /* Semicolon */);
+ test = parser.token !== 17825809 /* Semicolon */
+ ? parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn)
+ : null;
+ expect(parser, context, 17825809 /* Semicolon */);
+ update = parser.token !== 16 /* RightParen */
+ ? parseExpression(parser, (context & ~Context.AllowDecorator) | Context.AllowIn)
+ : null;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, type === 'ForOfStatement'
+ ? {
+ type,
+ body,
+ left: init,
+ right,
+ await: awaitToken
+ }
+ : right
+ ? {
+ type: type,
+ body,
+ left: init,
+ right
+ }
+ : {
+ type: type,
+ body,
+ init,
+ test,
+ update
+ });
+} + +// 15.2 Modules
+/**
+ * Parse module item list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItemList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseModuleItemList(parser, context) {
+ // Prime the scanner
+ nextToken(parser, context);
+ const statements = [];
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ statements.push(parser.token === 33554435 /* StringLiteral */ ?
+ parseDirective(parser, context) :
+ parseModuleItem(parser, context | Context.AllowIn));
+ }
+ return statements;
+}
+/**
+ * Parse module item
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseModuleItem(parser, context) {
+ switch (parser.token) {
+ // @decorator
+ case 120 /* At */:
+ return parseDecorators(parser, context);
+ // ExportDeclaration
+ case 12371 /* ExportKeyword */:
+ return parseExportDeclaration(parser, context);
+ // ImportDeclaration
+ case 33566810 /* ImportKeyword */:
+ // 'Dynamic Import' or meta property disallowed here
+ if (!(context & Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod))) {
+ return parseImportDeclaration(parser, context);
+ }
+ // falls through
+ default:
+ return parseStatementListItem(parser, context);
+ }
+}
+/**
+ * Parse export declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ const specifiers = [];
+ let source = null;
+ let declaration = null;
+ expect(parser, context | Context.DisallowEscapedKeyword, 12371 /* ExportKeyword */);
+ switch (parser.token) {
+ // export * FromClause ;
+ case 167774771 /* Multiply */:
+ return parseExportAllDeclaration(parser, context, pos);
+ case 12368 /* DefaultKeyword */:
+ return parseExportDefault(parser, context, pos);
+ case 41943052 /* LeftBrace */:
+ {
+ // export ExportClause FromClause ;
+ // export ExportClause ;
+ expect(parser, context, 41943052 /* LeftBrace */);
+ let hasReservedWord = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token !== 69743 /* GetKeyword */ && parser.token & 12288 /* Reserved */) {
+ hasReservedWord = true;
+ setPendingError(parser);
+ }
+ specifiers.push(parseNamedExportDeclaration(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context | Context.DisallowEscapedKeyword, 17825807 /* RightBrace */);
+ if (parser.token === 69745 /* FromKeyword */) {
+ source = parseModuleSpecifier(parser, context);
+ // The left hand side can't be a keyword where there is no
+ // 'from' keyword since it references a local binding.
+ }
+ else if (hasReservedWord)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ consumeSemicolon(parser, context);
+ break;
+ }
+ // export ClassDeclaration
+ case 33566797 /* ClassKeyword */:
+ declaration = (parseClassDeclaration(parser, context));
+ break;
+ // export LexicalDeclaration
+ case 33574984 /* LetKeyword */:
+ case 33566793 /* ConstKeyword */:
+ declaration = parseVariableStatement(parser, context | Context.BlockScope);
+ break;
+ // export VariableDeclaration
+ case 33566791 /* VarKeyword */:
+ declaration = parseVariableStatement(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ declaration = parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context);
+ break;
+ }
+ // Falls through
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportNamedDeclaration',
+ source,
+ specifiers,
+ declaration,
+ });
+}
+/**
+ * Parse export all declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseExportAllDeclaration(parser, context, pos) {
+ expect(parser, context, 167774771 /* Multiply */);
+ const source = parseModuleSpecifier(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExportAllDeclaration',
+ source,
+ });
+}
+/**
+ * Parse named export declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseNamedExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ // ExportSpecifier :
+ // IdentifierName
+ // IdentifierName as IdentifierName
+ const local = parseIdentifierName(parser, context | Context.DisallowEscapedKeyword, parser.token);
+ const exported = consume(parser, context, 167843947 /* AsKeyword */)
+ ? parseIdentifierName(parser, context, parser.token)
+ : local;
+ return finishNode(context, parser, pos, {
+ type: 'ExportSpecifier',
+ local,
+ exported,
+ });
+}
+/**
+ * Parse export default
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+function parseExportDefault(parser, context, pos) {
+ expect(parser, context | Context.DisallowEscapedKeyword, 12368 /* DefaultKeyword */);
+ let declaration;
+ switch (parser.token) {
+ // export default HoistableDeclaration[Default]
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context | Context.RequireIdentifier);
+ break;
+ // export default ClassDeclaration[Default]
+ // export default @decl ClassDeclaration[Default]
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ declaration = parseClassDeclaration(parser, context & ~Context.AllowIn | Context.RequireIdentifier);
+ break;
+ // export default HoistableDeclaration[Default]
+ case 594028 /* AsyncKeyword */:
+ declaration = parseAsyncFunctionOrAssignmentExpression(parser, context | Context.RequireIdentifier);
+ break;
+ default:
+ // export default [lookahead ∉ {function, class}] AssignmentExpression[In] ;
+ declaration = parseAssignmentExpression(parser, context | Context.AllowIn);
+ consumeSemicolon(parser, context);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportDefaultDeclaration',
+ declaration,
+ });
+}
+/**
+ * Parse import declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseImportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566810 /* ImportKeyword */);
+ let source;
+ let specifiers = [];
+ // 'import' ModuleSpecifier ';'
+ if (parser.token === 33554435 /* StringLiteral */) {
+ source = parseLiteral(parser, context);
+ }
+ else {
+ specifiers = parseImportClause(parser, context | Context.DisallowEscapedKeyword);
+ source = parseModuleSpecifier(parser, context);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ImportDeclaration',
+ specifiers,
+ source,
+ });
+}
+/**
+ * Parse import clause
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseImportClause(parser, context) {
+ const specifiers = [];
+ switch (parser.token) {
+ // 'import' ModuleSpecifier ';'
+ case 33685505 /* Identifier */:
+ {
+ specifiers.push(parseImportDefaultSpecifier(parser, context));
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ switch (parser.token) {
+ // import a, * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ // import a, {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ default:
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ break;
+ }
+ // import {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ // import * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return specifiers;
+}
+/**
+ * Parse named imports
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NamedImports)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseNamedImports(parser, context, specifiers) {
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ specifiers.push(parseImportSpecifier(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+}
+/**
+ * Parse import specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseImportSpecifier(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const imported = parseIdentifierName(parser, context | Context.DisallowEscapedKeyword, token);
+ let local;
+ if (consume(parser, context, 167843947 /* AsKeyword */)) {
+ local = parseBindingIdentifier(parser, context);
+ }
+ else {
+ // An import name that is a keyword is a syntax error if it is not followed
+ // by the keyword 'as'.
+ if (hasBit(token, 12288 /* Reserved */))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ if (hasBit(token, 4194304 /* IsEvalOrArguments */))
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ local = imported;
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ImportSpecifier',
+ local,
+ imported,
+ });
+}
+/**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NameSpaceImport)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseNameSpaceImport(parser, context, specifiers) {
+ // NameSpaceImport:
+ // * as ImportedBinding
+ const pos = getLocation(parser);
+ expect(parser, context, 167774771 /* Multiply */);
+ expect(parser, context, 167843947 /* AsKeyword */, 82 /* AsAfterImportStart */);
+ const local = parseBindingIdentifier(parser, context);
+ specifiers.push(finishNode(context, parser, pos, {
+ type: 'ImportNamespaceSpecifier',
+ local,
+ }));
+}
+/**
+ * Parse module specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseModuleSpecifier(parser, context) {
+ // ModuleSpecifier :
+ // StringLiteral
+ expect(parser, context, 69745 /* FromKeyword */);
+ if (parser.token !== 33554435 /* StringLiteral */)
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseLiteral(parser, context);
+}
+/**
+ * Parse import default specifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseImportDefaultSpecifier(parser, context) {
+ return finishNode(context, parser, getLocation(parser), {
+ type: 'ImportDefaultSpecifier',
+ local: parseIdentifier(parser, context),
+ });
+}
+/**
+ * Parses either async function or assignment expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+function parseAsyncFunctionOrAssignmentExpression(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context | Context.RequireIdentifier) :
+ parseAssignmentExpression(parser, context | Context.AllowIn);
+} + +/**
+ * Creates the parser object
+ *
+ * @param source The source coode to parser
+ * @param sourceFile Optional source file info to be attached in every node
+ */
+function createParser(source, sourceFile) {
+ return {
+ // The source code to parse
+ source,
+ // Source length
+ length: source.length,
+ // Current position
+ index: 0,
+ // Current line
+ line: 1,
+ // Current column
+ column: 0,
+ // Start position before current token
+ startIndex: 0,
+ // Start position column before current token
+ startColumn: 0,
+ // Start position line before current token
+ startLine: 1,
+ // End position after parsing after current token
+ lastIndex: 0,
+ // End column position after current token
+ lastColumn: 0,
+ // End line position after current token
+ lastLine: 0,
+ // Pending cover grammar errors
+ pendingExpressionError: undefined,
+ // Mutable parser flags. Allows destructuring by default.
+ flags: Flags.AllowDestructuring,
+ // The tokens
+ token: 1048576 /* EndOfSource */,
+ // Misc
+ tokenRaw: '',
+ lastValue: 0,
+ comments: [],
+ sourceFile,
+ tokenRegExp: undefined,
+ tokenValue: undefined,
+ labelSet: undefined,
+ errorLocation: undefined,
+ errors: [],
+ };
+}
+/**
+ * Creating the parser
+ *
+ * @param source The source coode to parser
+ * @param options The parser options
+ * @param context Context masks
+ */
+function parseSource(source, options, /*@internal*/ context) {
+ let sourceFile = '';
+ if (!!options) {
+ // The flag to enable module syntax support
+ if (options.module)
+ context |= Context.Module;
+ // The flag to enable stage 3 support (ESNext)
+ if (options.next)
+ context |= Context.OptionsNext;
+ // The flag to enable React JSX parsing
+ if (options.jsx)
+ context |= Context.OptionsJSX;
+ // The flag to enable start and end offsets to each node
+ if (options.ranges)
+ context |= Context.OptionsRanges;
+ // The flag to enable line/column location information to each node
+ if (options.loc)
+ context |= Context.OptionsLoc;
+ // The flag to attach raw property to each literal node
+ if (options.raw)
+ context |= Context.OptionsRaw;
+ // Attach raw property to each identifier node
+ if (options.rawIdentifier)
+ context |= Context.OptionsRawidentifiers;
+ // The flag to allow return in the global scope
+ if (options.globalReturn)
+ context |= Context.OptionsGlobalReturn;
+ // The flag to allow to skip shebang - '#'
+ if (options.skipShebang)
+ context |= Context.OptionsShebang;
+ // Enable tolerant mode
+ if (options.tolerant)
+ context |= Context.OptionsTolerant;
+ // Set to true to record the source file in every node's loc object when the loc option is set.
+ if (!!options.source)
+ sourceFile = options.source;
+ // Create a top-level comments array containing all comments
+ if (!!options.comments)
+ context |= Context.OptionsComments;
+ // The flag to enable implied strict mode
+ if (options.impliedStrict)
+ context |= Context.Strict;
+ // The flag to enable experimental features
+ if (options.experimental)
+ context |= Context.OptionsExperimental;
+ // The flag to set to bypass methods in Node
+ if (options.node)
+ context |= Context.OptionsNode;
+ // Accepts a callback function to be invoked for each syntax node (as the node is constructed)
+ }
+ const parser = createParser(source, sourceFile);
+ const body = context & Context.Module ?
+ parseModuleItemList(parser, context) :
+ parseStatementList(parser, context);
+ const node = {
+ type: 'Program',
+ sourceType: context & Context.Module ? 'module' : 'script',
+ body: body,
+ };
+ if (context & Context.LocationTracker) {
+ if (context & Context.OptionsRanges) {
+ node.start = 0;
+ node.end = source.length;
+ }
+ if (context & Context.OptionsLoc) {
+ node.loc = {
+ start: { line: 1, column: 0 },
+ end: { line: parser.line, column: parser.column
+ }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ if (context & Context.OptionsComments)
+ node.comments = parser.comments;
+ if (context & Context.OptionsTolerant)
+ node.errors = parser.errors;
+ return node;
+}
+/**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+function parseStatementList(parser, context) {
+ const statements = [];
+ let hasProlog = true; // Parsing directive prologue.
+ // prime the scanner
+ nextToken(parser, context | Context.DisallowEscapedKeyword);
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ if (hasProlog && parser.token !== 33554435 /* StringLiteral */)
+ hasProlog = false;
+ if (hasProlog) {
+ if (!(context & Context.Strict) && parser.tokenRaw.length === 12 && parser.tokenValue === 'use strict') {
+ context |= Context.Strict;
+ }
+ statements.push(parseDirective(parser, context));
+ }
+ else {
+ statements.push(parseStatementListItem(parser, context));
+ }
+ }
+ return statements;
+}
+/**
+ * Parse either script code or module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+function parse(source, options) {
+ return options && options.module
+ ? parseModule(source, options)
+ : parseScript(source, options);
+}
+/**
+ * Parse script code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+function parseScript(source, options) {
+ return parseSource(source, options, Context.Empty);
+}
+/**
+ * Parse module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+function parseModule(source, options) {
+ return parseSource(source, options, Context.Strict | Context.Module);
+} + + + +var estree = /*#__PURE__*/Object.freeze({ + +}); + + + +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'; + +export { version, estree as ESTree, index as Scanner, parse, parseSource, parseModule, parseScript, characterType, errorMessages, constructError, report, tolerant, tokenDesc, descKeyword, Parser, isValidIdentifierPart, isValidIdentifierStart, mustEscape, Context, Flags, Labels, NumericState, ScannerState, ModifierState, CoverParenthesizedState, Escape, RegexFlags, CoverCallState, RegexState, ObjectState, validateBreakOrContinueLabel, addLabel, popLabel, hasLabel, finishNode, expect, consume, nextToken, hasBit, consumeSemicolon, parseExpressionCoverGrammar, restoreExpressionCoverGrammar, swapContext, validateParams, reinterpret, lookahead, isValidSimpleAssignmentTarget, getLocation, isValidIdentifier, isLexical, isEndOfCaseOrDefaultClauses, nextTokenIsLeftParenOrPeriod, nextTokenisIdentifierOrParen, nextTokenIsLeftParen, nextTokenIsFuncKeywordOnSameLine, isPropertyWithPrivateFieldKey, parseAndClassifyIdentifier, nameIsArgumentsOrEval, setPendingError, isEqualTagNames, isInstanceField, validateUpdateExpression, setPendingExpressionError, validateCoverParenthesizedExpression, validateAsyncArgumentList, isInOrOf }; |