diff options
| author | Minteck <nekostarfan@gmail.com> | 2021-08-24 14:41:48 +0200 |
|---|---|---|
| committer | Minteck <nekostarfan@gmail.com> | 2021-08-24 14:41:48 +0200 |
| commit | d25e11bee6ca5ca523884da132d18e1400e077b9 (patch) | |
| tree | 8af39fde19f7ed640a60fb397c7edd647dff1c4c /node_modules/cherow/dist/amd/cherow.js | |
| download | kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.gz kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.tar.bz2 kartik-iridium-d25e11bee6ca5ca523884da132d18e1400e077b9.zip | |
Initial commit
Diffstat (limited to 'node_modules/cherow/dist/amd/cherow.js')
| -rw-r--r-- | node_modules/cherow/dist/amd/cherow.js | 7319 |
1 files changed, 7319 insertions, 0 deletions
diff --git a/node_modules/cherow/dist/amd/cherow.js b/node_modules/cherow/dist/amd/cherow.js new file mode 100644 index 0000000..542cb0b --- /dev/null +++ b/node_modules/cherow/dist/amd/cherow.js @@ -0,0 +1,7319 @@ +define('cherow', ['exports'], function (exports) { 'use strict'; + + // Note: this *must* be kept in sync with the enum's order.
+ //
+ // It exploits the enum value ordering, and it's necessarily a complete and
+ // utter hack.
+ //
+ // All to lower it to a single monomorphic array access.
+ const keywordDescTable = [
+ 'end of source',
+ /* Constants/Bindings */
+ 'identifier', 'number', 'string', 'regular expression',
+ 'false', 'true', 'null',
+ /* Template nodes */
+ 'template continuation', 'template end',
+ /* Punctuators */
+ '=>', '(', '{', '.', '...', '}', ')', ';', ',', '[', ']', ':', '?', '\'', '"', '</', '/>',
+ /* Update operators */
+ '++', '--',
+ /* Assign operators */
+ '=', '<<=', '>>=', '>>>=', '**=', '+=', '-=', '*=', '/=', '%=', '^=', '|=',
+ '&=',
+ /* Unary/binary operators */
+ 'typeof', 'delete', 'void', '!', '~', '+', '-', 'in', 'instanceof', '*', '%', '/', '**', '&&',
+ '||', '===', '!==', '==', '!=', '<=', '>=', '<', '>', '<<', '>>', '>>>', '&', '|', '^',
+ /* Variable declaration kinds */
+ 'var', 'let', 'const',
+ /* Other reserved words */
+ 'break', 'case', 'catch', 'class', 'continue', 'debugger', 'default', 'do', 'else', 'export',
+ 'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
+ 'this', 'throw', 'try', 'while', 'with',
+ /* Strict mode reserved words */
+ 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
+ /* Contextual keywords */
+ 'as', 'async', 'await', 'constructor', 'get', 'set', 'from', 'of',
+ '#',
+ 'eval', 'arguments', 'enum', 'BigInt', '@', 'JSXText',
+ /** TS */
+ 'KeyOf', 'ReadOnly', 'is', 'unique', 'declare', 'type', 'namespace', 'abstract', 'module',
+ 'global', 'require', 'target'
+ ];
+ /**
+ * The conversion function between token and its string description/representation.
+ */
+ function tokenDesc(token) {
+ return keywordDescTable[token & 255 /* Type */];
+ }
+ // Used `Object.create(null)` to avoid potential `Object.prototype`
+ // interference.
+ const descKeywordTable = Object.create(null, {
+ this: { value: 33566815 /* ThisKeyword */ },
+ function: { value: 33566808 /* FunctionKeyword */ },
+ if: { value: 12377 /* IfKeyword */ },
+ return: { value: 12380 /* ReturnKeyword */ },
+ var: { value: 33566791 /* VarKeyword */ },
+ else: { value: 12370 /* ElseKeyword */ },
+ for: { value: 12374 /* ForKeyword */ },
+ new: { value: 33566811 /* NewKeyword */ },
+ in: { value: 167786289 /* InKeyword */ },
+ typeof: { value: 302002218 /* TypeofKeyword */ },
+ while: { value: 12386 /* WhileKeyword */ },
+ case: { value: 12363 /* CaseKeyword */ },
+ break: { value: 12362 /* BreakKeyword */ },
+ try: { value: 12385 /* TryKeyword */ },
+ catch: { value: 12364 /* CatchKeyword */ },
+ delete: { value: 302002219 /* DeleteKeyword */ },
+ throw: { value: 302002272 /* ThrowKeyword */ },
+ switch: { value: 33566814 /* SwitchKeyword */ },
+ continue: { value: 12366 /* ContinueKeyword */ },
+ default: { value: 12368 /* DefaultKeyword */ },
+ instanceof: { value: 167786290 /* InstanceofKeyword */ },
+ do: { value: 12369 /* DoKeyword */ },
+ void: { value: 302002220 /* VoidKeyword */ },
+ finally: { value: 12373 /* FinallyKeyword */ },
+ arguments: { value: 37879925 /* Arguments */ },
+ keyof: { value: 131194 /* KeyOfKeyword */ },
+ readonly: { value: 131195 /* ReadOnlyKeyword */ },
+ unique: { value: 131197 /* UniqueKeyword */ },
+ declare: { value: 131198 /* DeclareKeyword */ },
+ async: { value: 594028 /* AsyncKeyword */ },
+ await: { value: 34017389 /* AwaitKeyword */ },
+ class: { value: 33566797 /* ClassKeyword */ },
+ const: { value: 33566793 /* ConstKeyword */ },
+ constructor: { value: 69742 /* ConstructorKeyword */ },
+ debugger: { value: 12367 /* DebuggerKeyword */ },
+ enum: { value: 12406 /* EnumKeyword */ },
+ eval: { value: 37879924 /* Eval */ },
+ export: { value: 12371 /* ExportKeyword */ },
+ extends: { value: 12372 /* ExtendsKeyword */ },
+ false: { value: 33566725 /* FalseKeyword */ },
+ from: { value: 69745 /* FromKeyword */ },
+ get: { value: 69743 /* GetKeyword */ },
+ implements: { value: 20579 /* ImplementsKeyword */ },
+ import: { value: 33566810 /* ImportKeyword */ },
+ interface: { value: 20580 /* InterfaceKeyword */ },
+ let: { value: 33574984 /* LetKeyword */ },
+ null: { value: 33566727 /* NullKeyword */ },
+ of: { value: 69746 /* OfKeyword */ },
+ package: { value: 20581 /* PackageKeyword */ },
+ private: { value: 20582 /* PrivateKeyword */ },
+ protected: { value: 20583 /* ProtectedKeyword */ },
+ public: { value: 20584 /* PublicKeyword */ },
+ set: { value: 69744 /* SetKeyword */ },
+ static: { value: 20585 /* StaticKeyword */ },
+ super: { value: 33566813 /* SuperKeyword */ },
+ true: { value: 33566726 /* TrueKeyword */ },
+ with: { value: 12387 /* WithKeyword */ },
+ yield: { value: 1107316842 /* YieldKeyword */ },
+ is: { value: 131196 /* IsKeyword */ },
+ type: { value: 131199 /* TypeKeyword */ },
+ namespace: { value: 131200 /* NameSpaceKeyword */ },
+ abstract: { value: 131201 /* AbstractKeyword */ },
+ as: { value: 167843947 /* AsKeyword */ },
+ module: { value: 131202 /* ModuleKeyword */ },
+ global: { value: 131203 /* GlobalKeyword */ },
+ require: { value: 131204 /* RequireKeyword */ },
+ target: { value: 131205 /* TargetKeyword */ },
+ });
+ function descKeyword(value) {
+ return (descKeywordTable[value] | 0);
+ } + + /*@internal*/
+ const characterType = [
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 16 /* Space */,
+ 48 /* Whitespace */,
+ 16 /* Space */,
+ 16 /* Space */,
+ 48 /* Whitespace */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 16 /* Space */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 9 /* Decimals */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 7 /* Hexadecimal */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 3 /* Letters */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ 0 /* Unknown */,
+ ]; + + // Unicode v. 11 support
+ // tslint:disable
+ function isValidIdentifierPart(code) {
+ return (convert[(code >>> 5) + 0] >>> code & 31 & 1) !== 0;
+ }
+ function isValidIdentifierStart(code) {
+ return (convert[(code >>> 5) + 34816] >>> code & 31 & 1) !== 0;
+ }
+ function mustEscape(code) {
+ return (convert[(code >>> 5) + 69632] >>> code & 31 & 1) !== 0;
+ }
+ const convert = ((compressed, lookup) => {
+ const result = new Uint32Array(104448);
+ let index = 0;
+ let subIndex = 0;
+ while (index < 3392) {
+ const inst = compressed[index++];
+ if (inst < 0) {
+ subIndex -= inst;
+ }
+ else {
+ let code = compressed[index++];
+ if (inst & 2)
+ code = lookup[code];
+ if (inst & 1) {
+ result.fill(code, subIndex, subIndex += compressed[index++]);
+ }
+ else {
+ result[subIndex++] = code;
+ }
+ }
+ }
+ return result;
+ })([-1, 2, 28, 2, 29, 2, 5, -1, 0, 77595648, 3, 46, 2, 3, 0, 14, 2, 57, 2, 58, 3, 0, 3, 0, 3168796671, 0, 4294956992, 2, 1, 2, 0, 2, 59, 3, 0, 4, 0, 4294966523, 3, 0, 4, 2, 15, 2, 60, 2, 0, 0, 4294836735, 0, 3221225471, 0, 4294901942, 2, 61, 0, 134152192, 3, 0, 2, 0, 4294951935, 3, 0, 2, 0, 2683305983, 0, 2684354047, 2, 17, 2, 0, 0, 4294961151, 3, 0, 2, 2, 20, 2, 0, 0, 608174079, 2, 0, 2, 127, 2, 6, 2, 62, -1, 2, 64, 2, 26, 2, 1, 3, 0, 3, 0, 4294901711, 2, 40, 0, 4089839103, 0, 2961209759, 0, 1342439375, 0, 4294543342, 0, 3547201023, 0, 1577204103, 0, 4194240, 0, 4294688750, 2, 2, 0, 80831, 0, 4261478351, 0, 4294549486, 2, 2, 0, 2965387679, 0, 196559, 0, 3594373100, 0, 3288319768, 0, 8469959, 2, 171, 0, 4294828031, 0, 3825204735, 0, 123747807, 0, 65487, 2, 3, 0, 4092591615, 0, 1080049119, 0, 458703, 2, 3, 2, 0, 0, 2163244511, 0, 4227923919, 0, 4236247020, 2, 68, 0, 4284449919, 0, 851904, 2, 4, 2, 16, 0, 67076095, -1, 2, 69, 0, 1006628014, 0, 4093591391, -1, 0, 50331649, 0, 3265266687, 2, 34, 0, 4294844415, 0, 4278190047, 2, 23, 2, 125, -1, 3, 0, 2, 2, 33, 2, 0, 2, 9, 2, 0, 2, 13, 2, 14, 3, 0, 10, 2, 71, 2, 0, 2, 72, 2, 73, 2, 74, 2, 0, 2, 75, 2, 0, 2, 10, 0, 261632, 2, 19, 3, 0, 2, 2, 11, 2, 4, 3, 0, 18, 2, 76, 2, 5, 3, 0, 2, 2, 77, 0, 2088959, 2, 31, 2, 8, 0, 909311, 3, 0, 2, 0, 814743551, 2, 42, 0, 67057664, 3, 0, 2, 2, 45, 2, 0, 2, 32, 2, 0, 2, 18, 2, 7, 0, 268374015, 2, 30, 2, 51, 2, 0, 2, 78, 0, 134153215, -1, 2, 6, 2, 0, 2, 7, 0, 2684354559, 0, 67044351, 0, 1073676416, -2, 3, 0, 2, 2, 43, 0, 1046528, 3, 0, 3, 2, 8, 2, 0, 2, 41, 0, 4294960127, 2, 9, 2, 39, 2, 10, 0, 4294377472, 2, 21, 3, 0, 7, 0, 4227858431, 3, 0, 8, 2, 11, 2, 0, 2, 80, 2, 9, 2, 0, 2, 81, 2, 82, 2, 83, -1, 2, 122, 0, 1048577, 2, 84, 2, 12, -1, 2, 12, 0, 131042, 2, 85, 2, 86, 2, 87, 2, 0, 2, 35, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 1046559, 2, 0, 2, 13, 2, 0, 0, 2147516671, 2, 24, 3, 88, 2, 2, 0, -16, 2, 89, 0, 524222462, 2, 4, 2, 0, 0, 4269801471, 2, 4, 2, 0, 2, 14, 2, 79, 2, 15, 3, 0, 2, 2, 49, 2, 16, -1, 2, 17, -16, 3, 0, 205, 2, 18, -2, 3, 0, 655, 2, 19, 3, 0, 36, 2, 70, -1, 2, 17, 2, 9, 3, 0, 8, 2, 91, 2, 119, 2, 0, 0, 3220242431, 3, 0, 3, 2, 20, 2, 22, 2, 92, 3, 0, 2, 2, 93, 2, 21, -1, 2, 22, 2, 0, 2, 27, 2, 0, 2, 8, 3, 0, 2, 0, 67043391, 0, 3909091327, 2, 0, 2, 25, 2, 8, 2, 23, 3, 0, 2, 0, 67076097, 2, 7, 2, 0, 2, 24, 0, 67059711, 0, 4236247039, 3, 0, 2, 0, 939524103, 0, 8191999, 2, 97, 2, 98, 2, 14, 2, 95, 3, 0, 3, 0, 67057663, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 25, 3, 0, 2, 2, 21, -1, 0, 3774349439, 2, 101, 2, 102, 3, 0, 2, 2, 20, 2, 26, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 47, 2, 0, 2, 27, 2, 103, 2, 19, 0, 1638399, 2, 169, 2, 104, 3, 0, 3, 2, 23, 2, 28, 2, 29, 2, 5, 2, 30, 2, 0, 2, 7, 2, 105, -1, 2, 106, 2, 107, 2, 108, -1, 3, 0, 3, 2, 16, -2, 2, 0, 2, 31, -3, 2, 146, -4, 2, 23, 2, 0, 2, 37, 0, 1, 2, 0, 2, 63, 2, 32, 2, 16, 2, 9, 2, 0, 2, 109, -1, 3, 0, 4, 2, 9, 2, 33, 2, 110, 2, 6, 2, 0, 2, 111, 2, 0, 2, 50, -4, 3, 0, 9, 2, 24, 2, 18, 2, 27, -4, 2, 112, 2, 113, 2, 18, 2, 24, 2, 7, -2, 2, 114, 2, 18, 2, 21, -2, 2, 0, 2, 115, -2, 0, 4277137519, 0, 2269118463, -1, 3, 23, 2, -1, 2, 34, 2, 38, 2, 0, 3, 18, 2, 2, 36, 2, 20, -3, 3, 0, 2, 2, 35, -1, 2, 0, 2, 36, 2, 0, 2, 36, 2, 0, 2, 48, -14, 2, 23, 2, 44, 2, 37, -5, 3, 0, 2, 2, 38, 0, 2147549120, 2, 0, 2, 16, 2, 17, 2, 130, 2, 0, 2, 52, 0, 4294901872, 0, 5242879, 3, 0, 2, 0, 402595359, -1, 2, 118, 0, 1090519039, -2, 2, 120, 2, 39, 2, 0, 2, 55, 2, 40, 0, 4226678271, 0, 3766565279, 0, 2039759, -4, 3, 0, 2, 0, 1140787199, -1, 3, 0, 2, 0, 67043519, -5, 2, 0, 0, 4282384383, 0, 1056964609, -1, 3, 0, 2, 0, 67043345, -1, 2, 0, 2, 41, 2, 42, -1, 2, 10, 2, 43, -6, 2, 0, 2, 16, -3, 3, 0, 2, 0, 2147484671, -8, 2, 0, 2, 7, 2, 44, 2, 0, 0, 603979727, -1, 2, 0, 2, 45, -8, 2, 54, 2, 46, 0, 67043329, 2, 123, 2, 47, 0, 8388351, -2, 2, 124, 0, 3028287487, 2, 48, 2, 126, 0, 33259519, 2, 42, -9, 2, 24, -8, 3, 0, 28, 2, 21, -3, 3, 0, 3, 2, 49, 3, 0, 6, 2, 50, -85, 3, 0, 33, 2, 49, -126, 3, 0, 18, 2, 38, -269, 3, 0, 17, 2, 45, 2, 7, 2, 42, -2, 2, 17, 2, 51, 2, 0, 2, 24, 0, 67043343, 2, 128, 2, 19, -21, 3, 0, 2, -4, 3, 0, 2, 0, 4294901791, 2, 7, 2, 164, -2, 0, 3, 3, 0, 191, 2, 20, 3, 0, 23, 2, 36, -296, 3, 0, 8, 2, 7, -2, 2, 17, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 129, 0, 1677656575, -166, 0, 4161266656, 0, 4071, 0, 15360, -4, 0, 28, -13, 3, 0, 2, 2, 52, 2, 0, 2, 131, 2, 132, 2, 56, 2, 0, 2, 133, 2, 134, 2, 135, 3, 0, 10, 2, 136, 2, 137, 2, 14, 3, 52, 2, 3, 53, 2, 3, 54, 2, 0, 4294954999, 2, 0, -16, 2, 0, 2, 90, 2, 0, 0, 2105343, 0, 4160749584, 0, 65534, -42, 0, 4194303871, 0, 2011, -62, 3, 0, 6, 0, 8323103, -1, 3, 0, 2, 2, 55, -37, 2, 56, 2, 140, 2, 141, 2, 142, 2, 143, 2, 144, -138, 3, 0, 1334, 2, 24, -1, 3, 0, 129, 2, 31, 3, 0, 6, 2, 9, 3, 0, 180, 2, 145, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -22583, 3, 0, 7, 2, 19, -6130, 3, 5, 2, -1, 0, 69207040, 3, 46, 2, 3, 0, 14, 2, 57, 2, 58, -3, 0, 3168731136, 0, 4294956864, 2, 1, 2, 0, 2, 59, 3, 0, 4, 0, 4294966275, 3, 0, 4, 2, 15, 2, 60, 2, 0, 2, 35, -1, 2, 17, 2, 61, -1, 2, 0, 2, 62, 0, 4294885376, 3, 0, 2, 0, 3145727, 0, 2617294944, 0, 4294770688, 2, 19, 2, 63, 3, 0, 2, 0, 131135, 2, 94, 0, 70256639, 0, 71303167, 0, 272, 2, 45, 2, 62, -1, 2, 64, -2, 2, 96, 0, 603979775, 0, 4278255616, 0, 4294836227, 0, 4294549473, 0, 600178175, 0, 2952806400, 0, 268632067, 0, 4294543328, 0, 57540095, 0, 1577058304, 0, 1835008, 0, 4294688736, 2, 65, 2, 66, 0, 33554435, 2, 121, 2, 65, 2, 147, 0, 131075, 0, 3594373096, 0, 67094296, 2, 66, -1, 2, 67, 0, 603979263, 2, 156, 0, 3, 0, 4294828001, 0, 602930687, 2, 180, 0, 393219, 2, 67, 0, 671088639, 0, 2154840064, 0, 4227858435, 0, 4236247008, 2, 68, 2, 38, -1, 2, 4, 0, 917503, 2, 38, -1, 2, 69, 0, 537783470, 0, 4026531935, -1, 0, 1, -1, 2, 34, 2, 70, 0, 7936, -3, 2, 0, 0, 2147485695, 0, 1010761728, 0, 4292984930, 0, 16387, 2, 0, 2, 13, 2, 14, 3, 0, 10, 2, 71, 2, 0, 2, 72, 2, 73, 2, 74, 2, 0, 2, 75, 2, 0, 2, 16, -1, 2, 19, 3, 0, 2, 2, 11, 2, 4, 3, 0, 18, 2, 76, 2, 5, 3, 0, 2, 2, 77, 0, 253951, 3, 20, 2, 0, 122879, 2, 0, 2, 8, 0, 276824064, -2, 3, 0, 2, 2, 45, 2, 0, 0, 4294903295, 2, 0, 2, 18, 2, 7, -1, 2, 17, 2, 51, 2, 0, 2, 78, 2, 42, -1, 2, 24, 2, 0, 2, 31, -2, 0, 128, -2, 2, 79, 2, 8, 0, 4064, -1, 2, 117, 0, 4227907585, 2, 0, 2, 116, 2, 0, 2, 50, 2, 196, 2, 9, 2, 39, 2, 10, -1, 0, 6544896, 3, 0, 6, -2, 3, 0, 8, 2, 11, 2, 0, 2, 80, 2, 9, 2, 0, 2, 81, 2, 82, 2, 83, -3, 2, 84, 2, 12, -3, 2, 85, 2, 86, 2, 87, 2, 0, 2, 35, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 817183, 2, 0, 2, 13, 2, 0, 0, 33023, 2, 24, 3, 88, 2, -17, 2, 89, 0, 524157950, 2, 4, 2, 0, 2, 90, 2, 4, 2, 0, 2, 14, 2, 79, 2, 15, 3, 0, 2, 2, 49, 2, 16, -1, 2, 17, -16, 3, 0, 205, 2, 18, -2, 3, 0, 655, 2, 19, 3, 0, 36, 2, 70, -1, 2, 17, 2, 9, 3, 0, 8, 2, 91, 0, 3072, 2, 0, 0, 2147516415, 2, 9, 3, 0, 2, 2, 19, 2, 22, 2, 92, 3, 0, 2, 2, 93, 2, 21, -1, 2, 22, 0, 4294965179, 0, 7, 2, 0, 2, 8, 2, 92, 2, 8, -1, 0, 1761345536, 2, 94, 2, 95, 2, 38, 2, 23, 2, 96, 2, 36, 2, 162, 0, 2080440287, 2, 0, 2, 35, 2, 138, 0, 3296722943, 2, 0, 0, 1046675455, 0, 939524101, 0, 1837055, 2, 97, 2, 98, 2, 14, 2, 95, 3, 0, 3, 0, 7, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 25, 3, 0, 2, 2, 21, -1, 0, 2700607615, 2, 101, 2, 102, 3, 0, 2, 2, 20, 2, 26, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 47, 2, 0, 2, 27, 2, 103, -3, 2, 104, 3, 0, 3, 2, 23, -1, 3, 5, 2, 2, 30, 2, 0, 2, 7, 2, 105, -1, 2, 106, 2, 107, 2, 108, -1, 3, 0, 3, 2, 16, -2, 2, 0, 2, 31, -8, 2, 23, 2, 0, 2, 37, -1, 2, 0, 2, 63, 2, 32, 2, 18, 2, 9, 2, 0, 2, 109, -1, 3, 0, 4, 2, 9, 2, 17, 2, 110, 2, 6, 2, 0, 2, 111, 2, 0, 2, 50, -4, 3, 0, 9, 2, 24, 2, 18, 2, 27, -4, 2, 112, 2, 113, 2, 18, 2, 24, 2, 7, -2, 2, 114, 2, 18, 2, 21, -2, 2, 0, 2, 115, -2, 0, 4277075969, 2, 18, -1, 3, 23, 2, -1, 2, 34, 2, 139, 2, 0, 3, 18, 2, 2, 36, 2, 20, -3, 3, 0, 2, 2, 35, -1, 2, 0, 2, 36, 2, 0, 2, 36, 2, 0, 2, 50, -14, 2, 23, 2, 44, 2, 116, -5, 2, 117, 2, 41, -2, 2, 117, 2, 19, 2, 17, 2, 35, 2, 117, 2, 38, 0, 4294901776, 0, 4718591, 2, 117, 2, 36, 0, 335544350, -1, 2, 118, 2, 119, -2, 2, 120, 2, 39, 2, 7, -1, 2, 121, 2, 65, 0, 3758161920, 0, 3, -4, 2, 0, 2, 31, 2, 174, -1, 2, 0, 2, 19, 0, 176, -5, 2, 0, 2, 49, 2, 182, -1, 2, 0, 2, 19, 2, 194, -1, 2, 0, 2, 62, -2, 2, 16, -7, 2, 0, 2, 119, -3, 3, 0, 2, 2, 122, -8, 0, 4294965249, 0, 67633151, 0, 4026597376, 2, 0, 0, 536871887, -1, 2, 0, 2, 45, -8, 2, 54, 2, 49, 0, 1, 2, 123, 2, 19, -3, 2, 124, 2, 37, 2, 125, 2, 126, 0, 16778239, -10, 2, 36, -8, 3, 0, 28, 2, 21, -3, 3, 0, 3, 2, 49, 3, 0, 6, 2, 50, -85, 3, 0, 33, 2, 49, -126, 3, 0, 18, 2, 38, -269, 3, 0, 17, 2, 45, 2, 7, -3, 2, 17, 2, 127, 2, 0, 2, 19, 2, 50, 2, 128, 2, 19, -21, 3, 0, 2, -4, 3, 0, 2, 0, 65567, -1, 2, 26, -2, 0, 3, 3, 0, 191, 2, 20, 3, 0, 23, 2, 36, -296, 3, 0, 8, 2, 7, -2, 2, 17, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 129, 2, 130, -187, 3, 0, 2, 2, 52, 2, 0, 2, 131, 2, 132, 2, 56, 2, 0, 2, 133, 2, 134, 2, 135, 3, 0, 10, 2, 136, 2, 137, 2, 14, 3, 52, 2, 3, 53, 2, 3, 54, 2, 2, 138, -129, 3, 0, 6, 2, 139, -1, 3, 0, 2, 2, 50, -37, 2, 56, 2, 140, 2, 141, 2, 142, 2, 143, 2, 144, -138, 3, 0, 1334, 2, 24, -1, 3, 0, 129, 2, 31, 3, 0, 6, 2, 9, 3, 0, 180, 2, 145, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -28719, 2, 0, 0, 1, -1, 2, 122, 2, 0, 0, 8193, -21, 0, 50331648, 0, 10255, 0, 4, -11, 2, 66, 2, 168, -1, 0, 71680, -1, 2, 157, 0, 4292900864, 0, 805306431, -5, 2, 146, -1, 2, 176, -1, 0, 6144, -2, 2, 123, -1, 2, 150, -1, 2, 153, 2, 147, 2, 161, 2, 0, 0, 3223322624, 2, 36, 0, 4, -4, 2, 188, 0, 205128192, 0, 1333757536, 0, 2147483696, 0, 423953, 0, 747766272, 0, 2717763192, 0, 4286578751, 0, 278545, 2, 148, 0, 4294886464, 0, 33292336, 0, 417809, 2, 148, 0, 1329579616, 0, 4278190128, 0, 700594195, 0, 1006647527, 0, 4286497336, 0, 4160749631, 2, 149, 0, 469762560, 0, 4171219488, 0, 16711728, 2, 149, 0, 202375680, 0, 3214918176, 0, 4294508592, 0, 139280, -1, 0, 983584, 2, 190, 0, 58720275, 0, 3489923072, 0, 10517376, 0, 4293066815, 0, 1, 0, 2013265920, 2, 175, 2, 0, 0, 17816169, 0, 3288339281, 0, 201375904, 2, 0, -2, 0, 256, 0, 122880, 0, 16777216, 2, 146, 0, 4160757760, 2, 0, -6, 2, 163, -11, 0, 3263218176, -1, 0, 49664, 0, 2160197632, 0, 8388802, -1, 0, 12713984, -1, 2, 150, 2, 155, 2, 158, -2, 2, 159, -20, 0, 3758096385, -2, 2, 151, 0, 4292878336, 2, 22, 2, 166, 0, 4294057984, -2, 2, 160, 2, 152, 2, 172, -2, 2, 151, -1, 2, 179, -1, 2, 167, 2, 122, 0, 4026593280, 0, 14, 0, 4292919296, -1, 2, 154, 0, 939588608, -1, 0, 805306368, -1, 2, 122, 0, 1610612736, 2, 152, 2, 153, 3, 0, 2, -2, 2, 154, 2, 155, -3, 0, 267386880, -1, 2, 156, 0, 7168, -1, 0, 65024, 2, 150, 2, 157, 2, 158, -7, 2, 165, -8, 2, 159, -1, 0, 1426112704, 2, 160, -1, 2, 185, 0, 271581216, 0, 2149777408, 2, 19, 2, 157, 2, 122, 0, 851967, 0, 3758129152, -1, 2, 19, 2, 178, -4, 2, 154, -20, 2, 192, 2, 161, -56, 0, 3145728, 2, 184, -1, 2, 191, 2, 122, -1, 2, 162, 2, 122, -4, 0, 32505856, -1, 2, 163, -1, 0, 2147385088, 2, 22, 1, 2155905152, 2, -3, 2, 164, 2, 0, 2, 165, -2, 2, 166, -6, 2, 167, 0, 4026597375, 0, 1, -1, 0, 1, -1, 2, 168, -3, 2, 139, 2, 66, -2, 2, 162, 2, 177, -1, 2, 173, 2, 122, -6, 2, 122, -213, 2, 167, -657, 2, 17, -36, 2, 169, -1, 2, 186, -10, 0, 4294963200, -5, 2, 170, -5, 2, 158, 2, 0, 2, 24, -1, 0, 4227919872, -1, 2, 170, -2, 0, 4227874752, -3, 0, 2146435072, 2, 155, -2, 0, 1006649344, 2, 122, -1, 2, 22, 0, 201375744, -3, 0, 134217720, 2, 22, 0, 4286677377, 0, 32896, -1, 2, 171, -3, 2, 172, -349, 2, 173, 2, 174, 2, 175, 3, 0, 264, -11, 2, 176, -2, 2, 158, 2, 0, 0, 520617856, 0, 2692743168, 0, 36, -3, 0, 524284, -11, 2, 19, -1, 2, 183, -1, 2, 181, 0, 3221291007, 2, 158, -1, 0, 524288, 0, 2158720, -3, 2, 155, 0, 1, -4, 2, 122, 0, 3808625411, 0, 3489628288, 0, 4096, 0, 1207959680, 0, 3221274624, 2, 0, -3, 2, 177, 0, 120, 0, 7340032, -2, 0, 4026564608, 2, 4, 2, 19, 2, 160, 3, 0, 4, 2, 155, -1, 2, 178, 2, 175, -1, 0, 8176, 2, 179, 2, 177, 2, 180, -1, 0, 4290773232, 2, 0, -4, 2, 160, 2, 187, 0, 15728640, 2, 175, -1, 2, 157, -1, 0, 4294934512, 3, 0, 4, -9, 2, 22, 2, 167, 2, 181, 3, 0, 4, 0, 704, 0, 1849688064, 0, 4194304, -1, 2, 122, 0, 4294901887, 2, 0, 0, 130547712, 0, 1879048192, 0, 2080374784, 3, 0, 2, -1, 2, 182, 2, 183, -1, 0, 17829776, 0, 2025848832, 0, 4261477888, -2, 2, 0, -1, 0, 4286580608, -1, 0, 29360128, 2, 184, 0, 16252928, 0, 3791388672, 2, 39, 3, 0, 2, -2, 2, 193, 2, 0, -1, 2, 26, -1, 0, 66584576, -1, 2, 189, 3, 0, 9, 2, 122, 3, 0, 4, -1, 2, 157, 2, 158, 3, 0, 5, -2, 0, 245760, 0, 2147418112, -1, 2, 146, 2, 199, 0, 4227923456, -1, 2, 185, 2, 186, 2, 22, -2, 2, 176, 0, 4292870145, 0, 262144, 2, 122, 3, 0, 2, 0, 1073758848, 2, 187, -1, 0, 4227921920, 2, 188, 0, 68289024, 0, 528402016, 0, 4292927536, 3, 0, 4, -2, 0, 2483027968, 2, 0, -2, 2, 189, 3, 0, 5, -1, 2, 184, 2, 160, 2, 0, -2, 0, 4227923936, 2, 63, -1, 2, 170, 2, 94, 2, 0, 2, 150, 2, 154, 3, 0, 6, -1, 2, 175, 3, 0, 3, -2, 0, 2146959360, 3, 0, 8, -2, 2, 157, -1, 2, 190, 2, 117, -1, 2, 151, 3, 0, 8, 2, 191, 0, 8388608, 2, 171, 2, 169, 2, 183, 0, 4286578944, 3, 0, 2, 0, 1152, 0, 1266679808, 2, 189, 0, 576, 0, 4261707776, 2, 94, 3, 0, 9, 2, 151, 3, 0, 8, -28, 2, 158, 3, 0, 3, -3, 0, 4292902912, -6, 2, 96, 3, 0, 85, -33, 2, 164, 3, 0, 126, -18, 2, 192, 3, 0, 269, -17, 2, 151, 2, 122, 0, 4294917120, 3, 0, 2, 2, 19, 0, 4290822144, -2, 0, 67174336, 0, 520093700, 2, 17, 3, 0, 21, -2, 2, 177, 3, 0, 3, -2, 0, 65504, 2, 122, 2, 49, 3, 0, 2, 2, 92, -191, 2, 123, -23, 2, 26, 3, 0, 296, -8, 2, 122, 3, 0, 2, 2, 19, -11, 2, 175, 3, 0, 72, -3, 0, 3758159872, 0, 201391616, 3, 0, 155, -7, 2, 167, -1, 0, 384, -1, 0, 133693440, -3, 2, 193, -2, 2, 30, 3, 0, 4, 2, 166, -2, 2, 22, 2, 151, 3, 0, 4, -2, 2, 185, -1, 2, 146, 0, 335552923, 2, 194, -1, 0, 538974272, 0, 2214592512, 0, 132000, -10, 0, 192, -8, 0, 12288, -21, 0, 134213632, 0, 4294901761, 3, 0, 42, 0, 100663424, 0, 4294965284, 3, 0, 62, -6, 0, 4286578784, 2, 0, -2, 0, 1006696448, 3, 0, 24, 2, 37, -1, 2, 195, 3, 0, 10, 2, 194, 0, 4110942569, 0, 1432950139, 0, 2701658217, 0, 4026532864, 0, 4026532881, 2, 0, 2, 47, 3, 0, 8, -1, 2, 154, -2, 2, 166, 0, 98304, 0, 65537, 2, 167, 2, 169, -2, 2, 154, -1, 2, 63, 2, 0, 2, 116, 2, 197, 2, 175, 0, 4294770176, 2, 30, 3, 0, 4, -30, 2, 195, 2, 196, -3, 2, 166, -2, 2, 151, 2, 0, 2, 154, -1, 2, 189, -1, 2, 157, 2, 198, 3, 0, 2, 2, 154, 2, 122, -1, 0, 193331200, -1, 0, 4227923960, 2, 197, -1, 3, 0, 3, 2, 198, 3, 0, 44, -1334, 2, 22, 2, 0, -129, 2, 195, -6, 2, 160, -180, 2, 199, -233, 2, 4, 3, 0, 96, -16, 2, 160, 3, 0, 22583, -7, 2, 17, 3, 0, 6128], [4294967295, 4294967291, 4092460543, 4294828015, 4294967294, 134217726, 268435455, 2147483647, 1048575, 1073741823, 3892314111, 1061158911, 536805376, 4294910143, 4160749567, 4294901759, 134217727, 4294901760, 4194303, 65535, 262143, 67108863, 4286578688, 536870911, 8388607, 4294918143, 4294443008, 255, 67043328, 2281701374, 4294967232, 2097151, 4294903807, 4294902783, 4294967039, 511, 524287, 131071, 127, 4294902271, 4294549487, 16777215, 1023, 67047423, 4294901888, 33554431, 4286578687, 4294770687, 67043583, 32767, 15, 2047999, 4292870143, 4294934527, 4294966783, 67045375, 4294967279, 262083, 20511, 4290772991, 41943039, 493567, 2047, 4294959104, 1071644671, 602799615, 65536, 4294828000, 805044223, 4277151126, 8191, 1031749119, 4294917631, 2134769663, 4286578493, 4282253311, 4294942719, 33540095, 4294905855, 4294967264, 2868854591, 1608515583, 265232348, 534519807, 2147614720, 1060109444, 4093640016, 17376, 2139062143, 224, 4169138175, 4294909951, 4294967292, 4294965759, 4294966272, 4294901823, 4294967280, 8289918, 4294934399, 4294901775, 4294965375, 1602223615, 4294967259, 268369920, 4292804608, 486341884, 4294963199, 3087007615, 1073692671, 4128527, 4279238655, 4294902015, 4294966591, 2445279231, 3670015, 3238002687, 63, 4294967288, 4294705151, 4095, 3221208447, 4294549472, 2147483648, 4294705152, 4294966143, 64, 4294966719, 16383, 3774873592, 536807423, 67043839, 3758096383, 3959414372, 3755993023, 2080374783, 4294835295, 4294967103, 4160749565, 4087, 31, 184024726, 2862017156, 1593309078, 268434431, 268434414, 4294901763, 536870912, 2952790016, 202506752, 139264, 402653184, 4261412864, 4227922944, 2147532800, 61440, 3758096384, 117440512, 65280, 4227858432, 3233808384, 3221225472, 4294965248, 32768, 57152, 4294934528, 67108864, 4293918720, 4290772992, 25165824, 57344, 4278190080, 65472, 4227907584, 65520, 1920, 4026531840, 49152, 4160749568, 4294836224, 63488, 1073741824, 4294967040, 251658240, 196608, 12582912, 2097152, 65408, 64512, 417808, 4227923712, 48, 512, 4294967168, 4294966784, 16, 4292870144, 4227915776, 65528, 4294950912, 65532]); + + /**
+ * Return the next unicodechar in the stream
+ *
+ * @param parser Parser object
+ */
+ function nextUnicodeChar(parser) {
+ const { index } = parser;
+ const hi = parser.source.charCodeAt(index);
+ if (hi < 55296 /* LeadSurrogateMin */ || hi > 56319 /* LeadSurrogateMax */)
+ return hi;
+ const lo = parser.source.charCodeAt(index + 1);
+ if (lo < 56320 /* TrailSurrogateMin */ || lo > 57343 /* TrailSurrogateMax */)
+ return hi;
+ return 65536 /* NonBMPMin */ + ((hi & 0x3FF) << 10) | lo & 0x3FF;
+ }
+ /**
+ * Returns true if this is a valid identifier part
+ *
+ * @param code Codepoint
+ */
+ const isIdentifierPart = (code) => (characterType[code] & 1 /* IdentifierStart */) !== 0 || isValidIdentifierPart(code);
+ function escapeInvalidCharacters(code) {
+ switch (code) {
+ case 0 /* Null */:
+ return '\\0';
+ case 8 /* Backspace */:
+ return '\\b';
+ case 9 /* Tab */:
+ return '\\t';
+ case 10 /* LineFeed */:
+ return '\\n';
+ case 11 /* VerticalTab */:
+ return '\\v';
+ case 12 /* FormFeed */:
+ return '\\f';
+ case 13 /* CarriageReturn */:
+ return '\\r';
+ default:
+ if (!mustEscape(code))
+ return fromCodePoint(code);
+ if (code < 0x10)
+ return `\\x0${code.toString(16)}`;
+ if (code < 0x100)
+ return `\\x${code.toString(16)}`;
+ if (code < 0x1000)
+ return `\\u0${code.toString(16)}`;
+ if (code < 0x10000)
+ return `\\u${code.toString(16)}`;
+ return `\\u{${code.toString(16)}}`;
+ }
+ }
+ /**
+ * Consume an token in the scanner on match. This is an equalent to
+ * 'consume' used in the parser code itself.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeOpt(parser, code) {
+ if (parser.source.charCodeAt(parser.index) !== code)
+ return false;
+ parser.index++;
+ parser.column++;
+ return true;
+ }
+ /**
+ * Consumes line feed
+ *
+ * @param parser Parser object
+ * @param state Scanner state
+ */
+ function consumeLineFeed(parser, state) {
+ parser.flags |= exports.Flags.NewLine;
+ parser.index++;
+ if ((state & exports.ScannerState.LastIsCR) === 0) {
+ parser.column = 0;
+ parser.line++;
+ }
+ }
+ /**
+ * Scans private name. Stage 3 proposal related
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanPrivateName(parser, context) {
+ if (!(context & exports.Context.InClass) || !isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return 115 /* Hash */;
+ }
+ /**
+ * Advance to new line
+ *
+ * @param parser Parser object
+ */
+ function advanceNewline(parser) {
+ parser.flags |= exports.Flags.NewLine;
+ parser.index++;
+ parser.column = 0;
+ parser.line++;
+ }
+ const fromCodePoint = (code) => {
+ return code <= 0xFFFF ?
+ String.fromCharCode(code) :
+ String.fromCharCode(((code - 65536 /* NonBMPMin */) >> 10) + 55296 /* LeadSurrogateMin */, ((code - 65536 /* NonBMPMin */) & (1024 - 1)) + 56320 /* TrailSurrogateMin */);
+ };
+ function readNext(parser) {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.source.length)
+ report(parser, 14 /* UnicodeOutOfRange */);
+ return nextUnicodeChar(parser);
+ }
+ function toHex(code) {
+ if (code < 48 /* Zero */)
+ return -1;
+ if (code <= 57 /* Nine */)
+ return code - 48 /* Zero */;
+ if (code < 65 /* UpperA */)
+ return -1;
+ if (code <= 70 /* UpperF */)
+ return code - 65 /* UpperA */ + 10;
+ if (code < 97 /* LowerA */)
+ return -1;
+ if (code <= 102 /* LowerF */)
+ return code - 97 /* LowerA */ + 10;
+ return -1;
+ }
+ function advanceOnMaybeAstral(parser, ch) {
+ parser.index++;
+ parser.column++;
+ if (ch > 0xFFFF)
+ parser.index++;
+ } + + /**
+ * Scan escape sequence
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanEscapeSequence(parser, context, first) {
+ switch (first) {
+ case 98 /* LowerB */:
+ return 8 /* Backspace */;
+ case 102 /* LowerF */:
+ return 12 /* FormFeed */;
+ case 114 /* LowerR */:
+ return 13 /* CarriageReturn */;
+ case 110 /* LowerN */:
+ return 10 /* LineFeed */;
+ case 116 /* LowerT */:
+ return 9 /* Tab */;
+ case 118 /* LowerV */:
+ return 11 /* VerticalTab */;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ return exports.Escape.Empty;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ {
+ // 1 to 3 octal digits
+ let code = first - 48 /* Zero */;
+ let index = parser.index + 1;
+ let column = parser.column + 1;
+ let next = parser.source.charCodeAt(index);
+ if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ // Strict mode code allows only \0, then a non-digit.
+ if (code !== 0 || next === 56 /* Eight */ || next === 57 /* Nine */) {
+ if (context & exports.Context.Strict)
+ return exports.Escape.StrictOctal;
+ parser.flags |= exports.Flags.HasOctal;
+ }
+ }
+ else if (context & exports.Context.Strict) {
+ return exports.Escape.StrictOctal;
+ }
+ else {
+ parser.flags |= exports.Flags.HasOctal;
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ parser.lastValue = next;
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ parser.index = index - 1;
+ parser.column = column - 1;
+ }
+ return code;
+ }
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ // 1 to 2 octal digits
+ if (context & exports.Context.Strict)
+ return exports.Escape.StrictOctal;
+ let code = first - 48 /* Zero */;
+ const index = parser.index + 1;
+ const column = parser.column + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 55 /* Seven */) {
+ code = code * 8 + (next - 48 /* Zero */);
+ parser.lastValue = next;
+ parser.index = index;
+ parser.column = column;
+ }
+ return code;
+ }
+ // `8`, `9` (invalid escapes)
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return exports.Escape.EightOrNine;
+ // ASCII escapes
+ case 120 /* LowerX */:
+ {
+ const ch1 = parser.lastValue = readNext(parser);
+ const hi = toHex(ch1);
+ if (hi < 0)
+ return exports.Escape.InvalidHex;
+ const ch2 = parser.lastValue = readNext(parser);
+ const lo = toHex(ch2);
+ if (lo < 0)
+ return exports.Escape.InvalidHex;
+ return hi << 4 | lo;
+ }
+ // UCS-2/Unicode escapes
+ case 117 /* LowerU */:
+ {
+ let ch = parser.lastValue = readNext(parser);
+ if (ch === 123 /* LeftBrace */) {
+ ch = parser.lastValue = readNext(parser);
+ let code = toHex(ch);
+ if (code < 0)
+ return exports.Escape.InvalidHex;
+ ch = parser.lastValue = readNext(parser);
+ while (ch !== 125 /* RightBrace */) {
+ const digit = toHex(ch);
+ if (digit < 0)
+ return exports.Escape.InvalidHex;
+ code = code * 16 + digit;
+ // Code point out of bounds
+ if (code > 1114111 /* NonBMPMax */)
+ return exports.Escape.OutOfRange;
+ ch = parser.lastValue = readNext(parser);
+ }
+ return code;
+ }
+ else {
+ // \uNNNN
+ let codePoint = toHex(ch);
+ if (codePoint < 0)
+ return exports.Escape.InvalidHex;
+ for (let i = 0; i < 3; i++) {
+ ch = parser.lastValue = readNext(parser);
+ const digit = toHex(ch);
+ if (digit < 0)
+ return exports.Escape.InvalidHex;
+ codePoint = codePoint * 16 + digit;
+ }
+ return codePoint;
+ }
+ }
+ default:
+ return parser.source.charCodeAt(parser.index);
+ }
+ }
+ /**
+ * Throws a string error for either string or template literal
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function throwStringError(parser, context, code) {
+ switch (code) {
+ case exports.Escape.Empty:
+ return;
+ case exports.Escape.StrictOctal:
+ report(parser, context & exports.Context.TaggedTemplate ?
+ 76 /* TemplateOctalLiteral */ :
+ 11 /* StrictOctalEscape */);
+ case exports.Escape.EightOrNine:
+ report(parser, 13 /* InvalidEightAndNine */);
+ case exports.Escape.InvalidHex:
+ report(parser, 75 /* MalformedEscape */, 'hexadecimal');
+ case exports.Escape.OutOfRange:
+ report(parser, 14 /* UnicodeOutOfRange */);
+ /* istanbul ignore next */
+ default:
+ // ignore
+ }
+ }
+ /**
+ * Scan a string literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote codepoint
+ */
+ function scanString(parser, context, quote) {
+ const { index: start, lastValue } = parser;
+ let ret = '';
+ parser.index++;
+ parser.column++; // consume quote
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ switch (ch) {
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ report(parser, 6 /* UnterminatedString */);
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch > 128 /* MaxAsciiCharacter */) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ const code = scanEscapeSequence(parser, context, ch);
+ if (code >= 0)
+ ret += fromCodePoint(code);
+ else
+ throwStringError(parser, context, code);
+ ch = parser.lastValue;
+ }
+ break;
+ default:
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++; // consume quote
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ return 33554435 /* StringLiteral */;
+ } + + /**
+ * Consumes template brace
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeTemplateBrace(parser, context) {
+ if (parser.index >= parser.length)
+ report(parser, 9 /* UnterminatedTemplate */);
+ // Upon reaching a '}', consume it and rewind the scanner state
+ parser.index--;
+ parser.column--;
+ return scanTemplate(parser, context);
+ }
+ /**
+ * Scan template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param first Codepoint
+ */
+ function scanTemplate(parser, context) {
+ const { index: start, lastValue } = parser;
+ let tail = true;
+ let ret = '';
+ let ch = readNext(parser);
+ loop: while (ch !== 96 /* Backtick */) {
+ switch (ch) {
+ // Break after a literal `${` (thus the dedicated code path).
+ case 36 /* Dollar */:
+ {
+ const index = parser.index + 1;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 123 /* LeftBrace */) {
+ parser.index = index;
+ parser.column++;
+ tail = false;
+ break loop;
+ }
+ ret += '$';
+ break;
+ }
+ case 92 /* Backslash */:
+ ch = readNext(parser);
+ if (ch >= 128) {
+ ret += fromCodePoint(ch);
+ }
+ else {
+ parser.lastValue = ch;
+ // Because octals are forbidden in escaped template sequences and the fact that
+ // both string and template scanning uses the same method - 'scanEscapeSequence',
+ // we set the strict context mask.
+ const code = scanEscapeSequence(parser, context | exports.Context.Strict, ch);
+ if (code >= 0) {
+ ret += fromCodePoint(code);
+ }
+ else if (code !== exports.Escape.Empty && context & exports.Context.TaggedTemplate) {
+ ret = undefined;
+ ch = scanLooserTemplateSegment(parser, parser.lastValue);
+ if (ch < 0) {
+ tail = false;
+ }
+ break loop;
+ }
+ else {
+ throwStringError(parser, context | exports.Context.TaggedTemplate, code);
+ }
+ ch = parser.lastValue;
+ }
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ parser.column = -1;
+ parser.line++;
+ // falls through
+ default:
+ if (ret != null)
+ ret += fromCodePoint(ch);
+ }
+ ch = readNext(parser);
+ }
+ parser.index++;
+ parser.column++;
+ parser.tokenValue = ret;
+ parser.lastValue = lastValue;
+ if (tail) {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 1);
+ return 33554441 /* TemplateTail */;
+ }
+ else {
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - 2);
+ return 33554440 /* TemplateCont */;
+ }
+ }
+ /**
+ * Scan looser template segment
+ *
+ * @param parser Parser object
+ * @param ch codepoint
+ */
+ function scanLooserTemplateSegment(parser, ch) {
+ while (ch !== 96 /* Backtick */) {
+ if (ch === 36 /* Dollar */ && parser.source.charCodeAt(parser.index + 1) === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return -ch;
+ }
+ // Skip '\' and continue to scan the template token to search
+ // for the end, without validating any escape sequences
+ ch = readNext(parser);
+ }
+ return ch;
+ } + + // 11.8.3 Numeric Literals
+ /**
+ * Scans hex integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HexIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanHexIntegerLiteral(parser, context) {
+ parser.index++;
+ parser.column++;
+ let state = exports.NumericState.None;
+ let value = toHex(parser.source.charCodeAt(parser.index));
+ if (value < 0)
+ report(parser, 0 /* Unexpected */);
+ parser.index++;
+ parser.column++;
+ while (parser.index < parser.length) {
+ const next = parser.source.charCodeAt(parser.index);
+ if (context & exports.Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~exports.NumericState.SeenSeparator;
+ const digit = toHex(next);
+ if (digit < 0)
+ break;
+ value = value * 16 + digit;
+ parser.index++;
+ parser.column++;
+ }
+ if (state & exports.NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+ }
+ /**
+ * Scans binary and octal integer literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalIntegerLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BinaryIntegerLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanOctalOrBinary(parser, context, base) {
+ parser.index++;
+ parser.column++;
+ let digits = 0;
+ let ch;
+ let value = 0;
+ let state = exports.NumericState.None;
+ while (parser.index < parser.length) {
+ ch = parser.source.charCodeAt(parser.index);
+ if (context & exports.Context.OptionsNext && ch === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ continue;
+ }
+ state &= ~exports.NumericState.SeenSeparator;
+ const converted = ch - 48 /* Zero */;
+ if (!(ch >= 48 /* Zero */ && ch <= 57 /* Nine */) || converted >= base)
+ break;
+ value = value * base + converted;
+ parser.index++;
+ parser.column++;
+ digits++;
+ }
+ if (digits === 0)
+ report(parser, 0 /* Unexpected */);
+ if (state & exports.NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return assembleNumericLiteral(parser, context, value, consumeOpt(parser, 110 /* LowerN */));
+ }
+ /**
+ * Scans implicit octal digits
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-OctalDigits)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanImplicitOctalDigits(parser, context) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ {
+ if (context & exports.Context.Strict)
+ report(parser, 0 /* Unexpected */);
+ let index = parser.index;
+ let column = parser.column;
+ let code = 0;
+ parser.flags |= exports.Flags.HasOctal;
+ // Implicit octal, unless there is a non-octal digit.
+ // (Annex B.1.1 on Numeric Literals)
+ while (index < parser.length) {
+ const next = parser.source.charCodeAt(index);
+ if (next === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ else if (next < 48 /* Zero */ || next > 55 /* Seven */) {
+ return scanNumericLiteral(parser, context);
+ }
+ else {
+ code = code * 8 + (next - 48 /* Zero */);
+ index++;
+ column++;
+ }
+ }
+ parser.index = index;
+ parser.column = column;
+ return assembleNumericLiteral(parser, context, code, consumeOpt(parser, 110 /* LowerN */));
+ }
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ parser.flags |= exports.Flags.HasOctal;
+ default:
+ if (context & exports.Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ return scanNumericLiteral(parser, context);
+ }
+ }
+ /**
+ * Scans signed integer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SignedInteger)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanSignedInteger(parser, end) {
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 43 /* Plus */ || next === 45 /* Hyphen */) {
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (!(next >= 48 /* Zero */ && next <= 57 /* Nine */)) {
+ report(parser, 0 /* Unexpected */);
+ }
+ const preNumericPart = parser.index;
+ const finalFragment = scanDecimalDigitsOrSeparator(parser);
+ return parser.source.substring(end, preNumericPart) + finalFragment;
+ }
+ /**
+ * Scans numeric literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanNumericLiteral(parser, context, state = exports.NumericState.None) {
+ let value = state & exports.NumericState.Float ?
+ 0 :
+ scanDecimalAsSmi(parser, context);
+ const next = parser.source.charCodeAt(parser.index);
+ // I know I'm causing a bug here. The question is - will anyone figure this out?
+ if (next !== 46 /* Period */ && next !== 95 /* Underscore */ && !isValidIdentifierStart(next)) {
+ return assembleNumericLiteral(parser, context, value);
+ }
+ if (consumeOpt(parser, 46 /* Period */)) {
+ if (context & exports.Context.OptionsNext && parser.source.charCodeAt(parser.index) === 95 /* Underscore */) {
+ report(parser, 60 /* ZeroDigitNumericSeparator */);
+ }
+ state |= exports.NumericState.Float;
+ value = `${value}.${scanDecimalDigitsOrSeparator(parser)}`;
+ }
+ const end = parser.index;
+ if (consumeOpt(parser, 110 /* LowerN */)) {
+ if (state & exports.NumericState.Float)
+ report(parser, 0 /* Unexpected */);
+ state |= exports.NumericState.BigInt;
+ }
+ if (consumeOpt(parser, 101 /* LowerE */) || consumeOpt(parser, 69 /* UpperE */)) {
+ state |= exports.NumericState.Float;
+ value += scanSignedInteger(parser, end);
+ }
+ if (isValidIdentifierStart(parser.source.charCodeAt(parser.index))) {
+ report(parser, 0 /* Unexpected */);
+ }
+ return assembleNumericLiteral(parser, context, state & exports.NumericState.Float ? parseFloat(value) : parseInt(value, 10), !!(state & exports.NumericState.BigInt));
+ }
+ /**
+ * Internal helper function for scanning numeric separators.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state NumericState state
+ */
+ function scanNumericSeparator(parser, state) {
+ parser.index++;
+ parser.column++;
+ if (state & exports.NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ state |= exports.NumericState.SeenSeparator;
+ return state;
+ }
+ /**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanDecimalDigitsOrSeparator(parser) {
+ let start = parser.index;
+ let state = exports.NumericState.None;
+ let ret = '';
+ loop: while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 95 /* Underscore */:
+ const preUnderscoreIndex = parser.index;
+ state = scanNumericSeparator(parser, state);
+ ret += parser.source.substring(start, preUnderscoreIndex);
+ start = parser.index;
+ continue;
+ case 48 /* Zero */:
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ state = state & ~exports.NumericState.SeenSeparator;
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ break loop;
+ }
+ }
+ if (state & exports.NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return ret + parser.source.substring(start, parser.index);
+ }
+ /**
+ * Internal helper function that scans numeric values
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanDecimalAsSmi(parser, context) {
+ let state = exports.NumericState.None;
+ let value = 0;
+ let next = parser.source.charCodeAt(parser.index);
+ while (next >= 48 /* Zero */ && next <= 57 /* Nine */ || next === 95 /* Underscore */) {
+ if (context & exports.Context.OptionsNext && next === 95 /* Underscore */) {
+ state = scanNumericSeparator(parser, state);
+ next = parser.source.charCodeAt(parser.index);
+ continue;
+ }
+ state &= ~exports.NumericState.SeenSeparator;
+ value = value * 10 + (next - 48 /* Zero */);
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ }
+ if (state & exports.NumericState.SeenSeparator)
+ report(parser, 59 /* TrailingNumericSeparator */);
+ return value;
+ }
+ /**
+ * Internal helper function that assamble the number scanning parts and return
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param value The numeric value
+ */
+ function assembleNumericLiteral(parser, context, value, isBigInt = false) {
+ parser.tokenValue = value;
+ if (context & exports.Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ return isBigInt ? 33554551 /* BigIntLiteral */ : 33554434 /* NumericLiteral */;
+ } + + /**
+ * Scan identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-string-literals)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanIdentifier(parser, context, first) {
+ let start = parser.index;
+ let ret = '';
+ let isEscaped = false;
+ if (first)
+ advanceOnMaybeAstral(parser, first);
+ loop: while (parser.index < parser.length) {
+ const index = parser.index;
+ let ch = parser.source.charCodeAt(index);
+ switch (ch) {
+ case 92 /* Backslash */:
+ ret += parser.source.slice(start, index);
+ ret += scanUnicodeCodePointEscape(parser);
+ start = parser.index;
+ isEscaped = true;
+ break;
+ default:
+ if (ch >= 0xD800 && ch <= 0xDBFF) {
+ const lo = parser.source.charCodeAt(index + 1);
+ ch = (ch & 0x3FF) << 10 | lo & 0x3FF | 0x10000;
+ }
+ if (!isIdentifierPart(ch))
+ break loop;
+ advanceOnMaybeAstral(parser, ch);
+ }
+ }
+ if (start < parser.index)
+ ret += parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ const len = ret.length;
+ // Keywords are between 2 and 11 characters long and start with a lowercase letter
+ // https://tc39.github.io/ecma262/#sec-keywords
+ if (len >= 2 && len <= 11) {
+ const token = descKeyword(ret);
+ if (token > 0) {
+ if (isEscaped) {
+ if (context & exports.Context.DisallowEscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ // Here we fall back to a mutual parser flag if the escaped keyword isn't disallowed through
+ // context masks. This is similiar to how V8 does it - they are using an
+ // 'escaped_keyword' token.
+ // - J.K. Thomas
+ parser.flags |= exports.Flags.EscapedKeyword;
+ }
+ return token;
+ }
+ }
+ if (context & exports.Context.OptionsRawidentifiers)
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ return 33685505 /* Identifier */;
+ }
+ /**
+ * Scanning chars in the range 0...127, and treat them as an possible
+ * identifier. This allows subsequent checking to be faster.
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param first Code point
+ */
+ function scanMaybeIdentifier(parser, context, first) {
+ first = nextUnicodeChar(parser);
+ if (!isValidIdentifierStart(first)) {
+ report(parser, 10 /* UnexpectedChar */, escapeInvalidCharacters(first));
+ }
+ return scanIdentifier(parser, context, first);
+ }
+ /**
+ * Scan unicode codepoint escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanUnicodeCodePointEscape(parser) {
+ const { index } = parser;
+ if (index + 5 < parser.length) {
+ if (parser.source.charCodeAt(index + 1) !== 117 /* LowerU */) {
+ report(parser, 0 /* Unexpected */);
+ }
+ parser.index += 2;
+ parser.column += 2;
+ const code = scanIdentifierUnicodeEscape(parser);
+ if (code >= 55296 /* LeadSurrogateMin */ && code <= 56319 /* LeadSurrogateMax */) {
+ report(parser, 74 /* UnexpectedSurrogate */);
+ }
+ if (!isIdentifierPart(code)) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ return fromCodePoint(code);
+ }
+ report(parser, 0 /* Unexpected */);
+ }
+ /**
+ * Scan identifier unicode escape
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function scanIdentifierUnicodeEscape(parser) {
+ // Accept both \uxxxx and \u{xxxxxx}. In the latter case, the number of
+ // hex digits between { } is arbitrary. \ and u have already been read.
+ let ch = parser.source.charCodeAt(parser.index);
+ let codePoint = 0;
+ // '\u{DDDDDDDD}'
+ if (ch === 123 /* LeftBrace */) { // {
+ ch = readNext(parser);
+ let digit = toHex(ch);
+ while (digit >= 0) {
+ codePoint = (codePoint << 4) | digit;
+ if (codePoint > 1114111 /* NonBMPMax */) {
+ report(parser, 89 /* UndefinedUnicodeCodePoint */);
+ }
+ parser.index++;
+ parser.column++;
+ digit = toHex(parser.source.charCodeAt(parser.index));
+ }
+ if (parser.source.charCodeAt(parser.index) !== 125 /* RightBrace */) {
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ }
+ consumeOpt(parser, 125 /* RightBrace */);
+ // '\uDDDD'
+ }
+ else {
+ for (let i = 0; i < 4; i++) {
+ ch = parser.source.charCodeAt(parser.index);
+ const digit = toHex(ch);
+ if (digit < 0)
+ report(parser, 75 /* MalformedEscape */, 'unicode');
+ codePoint = (codePoint << 4) | digit;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ return codePoint;
+ } + + // 11.4 Comments
+ /**
+ * Skips single HTML comments. Same behavior as in V8.
+ *
+ * @param parser Parser Object
+ * @param context Context masks.
+ * @param state Scanner state
+ * @param type Comment type
+ */
+ function skipSingleHTMLComment(parser, context, state, type) {
+ if (context & exports.Context.Module)
+ report(parser, 90 /* HtmlCommentInModule */);
+ return skipSingleLineComment(parser, context, state, type);
+ }
+ /**
+ * Skips SingleLineComment, SingleLineHTMLCloseComment and SingleLineHTMLOpenComment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SingleLineComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLOpenComment)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-SingleLineHTMLCloseComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ * @param type Comment type
+ */
+ function skipSingleLineComment(parser, context, state, type) {
+ const start = parser.index;
+ const collectable = !!(context & exports.Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 13 /* CarriageReturn */:
+ advanceNewline(parser);
+ if ((parser.index < parser.length) && parser.source.charCodeAt(parser.index) === 10 /* LineFeed */)
+ parser.index++;
+ return state | exports.ScannerState.NewLine;
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ advanceNewline(parser);
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state | exports.ScannerState.NewLine;
+ default:
+ parser.index++;
+ parser.column++;
+ }
+ }
+ if (collectable)
+ addComment(parser, context, type, start);
+ return state;
+ }
+ /**
+ * Skips multiline comment
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-annexB-MultiLineComment)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Scanner state
+ */
+ function skipMultiLineComment(parser, context, state) {
+ const start = parser.index;
+ const collectable = !!(context & exports.Context.OptionsComments);
+ while (parser.index < parser.length) {
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 42 /* Asterisk */:
+ parser.index++;
+ parser.column++;
+ state &= ~exports.ScannerState.LastIsCR;
+ if (consumeOpt(parser, 47 /* Slash */)) {
+ if (collectable)
+ addComment(parser, context, 'MultiLine', start);
+ return state;
+ }
+ break;
+ // Mark multiline comments containing linebreaks as new lines
+ // so we can perfectly handle edge cases like: '1/*\n*/--> a comment'
+ case 13 /* CarriageReturn */:
+ state |= exports.ScannerState.NewLine | exports.ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine;
+ break;
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ default:
+ state &= ~exports.ScannerState.LastIsCR;
+ parser.index++;
+ parser.column++;
+ }
+ }
+ // Unterminated multi-line comment.
+ tolerant(parser, context, 8 /* UnterminatedComment */);
+ }
+ /**
+ * Add comments
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param type Comment type
+ * @param commentStart Start position of comment
+ */
+ function addComment(parser, context, type, commentStart) {
+ const { index, startIndex: start, startLine, startColumn, lastLine, lastColumn } = parser;
+ const comment = {
+ type,
+ value: parser.source.slice(commentStart, type === 'MultiLine' ? index - 2 : index),
+ start,
+ end: index,
+ };
+ if (context & exports.Context.OptionsLoc) {
+ comment.loc = {
+ start: { line: startLine, column: startColumn },
+ end: { line: lastLine, column: lastColumn },
+ };
+ }
+ parser.comments.push(comment);
+ } + + /**
+ * Scan
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-punctuatorss)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-names-and-keywords)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scan(parser, context) {
+ parser.flags &= ~exports.Flags.NewLine | exports.Flags.EscapedKeyword;
+ const lineStart = parser.index === 0;
+ let state = exports.ScannerState.None;
+ while (parser.index < parser.length) {
+ if (!lineStart) {
+ parser.startIndex = parser.index;
+ parser.startColumn = parser.column;
+ parser.startLine = parser.line;
+ }
+ const first = parser.source.charCodeAt(parser.index);
+ if (first > 128 /* MaxAsciiCharacter */) {
+ switch (first) {
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine;
+ advanceNewline(parser);
+ break;
+ case 65519 /* ByteOrderMark */:
+ case 160 /* NonBreakingSpace */:
+ case 5760 /* Ogham */:
+ case 8192 /* EnQuad */:
+ case 8193 /* EmQuad */:
+ case 8194 /* EnSpace */:
+ case 8195 /* EmSpace */:
+ case 8196 /* ThreePerEmSpace */:
+ case 8197 /* FourPerEmSpace */:
+ case 8198 /* SixPerEmSpace */:
+ case 8199 /* FigureSpace */:
+ case 8200 /* PunctuationSpace */:
+ case 8201 /* ThinSpace */:
+ case 8202 /* HairSpace */:
+ case 8239 /* NarrowNoBreakSpace */:
+ case 8287 /* MathematicalSpace */:
+ case 12288 /* IdeographicSpace */:
+ case 65279 /* Zwnbs */:
+ case 8205 /* Zwj */:
+ parser.index++;
+ parser.column++;
+ break;
+ default:
+ return scanMaybeIdentifier(parser, context, first);
+ }
+ }
+ else {
+ // Note: Here we first get rid of LT and WS, then we make sure that the lookup time
+ // for the single punctuator char is short as possible. A single punctuator
+ // char is a valid token that cannot also be a prefix of a combination
+ // of long tokens - e.g. '(', ')' and '=' is valid. '==' is not.
+ switch (first) {
+ case 13 /* CarriageReturn */:
+ state |= exports.ScannerState.NewLine | exports.ScannerState.LastIsCR;
+ advanceNewline(parser);
+ break;
+ case 10 /* LineFeed */:
+ consumeLineFeed(parser, state);
+ state = state & ~exports.ScannerState.LastIsCR | exports.ScannerState.NewLine;
+ break;
+ case 9 /* Tab */:
+ case 11 /* VerticalTab */:
+ case 12 /* FormFeed */:
+ case 32 /* Space */:
+ parser.index++;
+ parser.column++;
+ break;
+ // `(`
+ case 40 /* LeftParen */:
+ parser.index++;
+ parser.column++;
+ return 50331659 /* LeftParen */;
+ // `)`
+ case 41 /* RightParen */:
+ parser.index++;
+ parser.column++;
+ return 16 /* RightParen */;
+ // `,`
+ case 44 /* Comma */:
+ parser.index++;
+ parser.column++;
+ return 16777234 /* Comma */;
+ // `:`
+ case 58 /* Colon */:
+ parser.index++;
+ parser.column++;
+ return 16777237 /* Colon */;
+ // `;`
+ case 59 /* Semicolon */:
+ parser.index++;
+ parser.column++;
+ return 17825809 /* Semicolon */;
+ // `?`
+ case 63 /* QuestionMark */:
+ parser.index++;
+ parser.column++;
+ return 22 /* QuestionMark */;
+ // `]`
+ case 93 /* RightBracket */:
+ parser.index++;
+ parser.column++;
+ return 20 /* RightBracket */;
+ // `{`
+ case 123 /* LeftBrace */:
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ // `}`
+ case 125 /* RightBrace */:
+ parser.index++;
+ parser.column++;
+ return 17825807 /* RightBrace */;
+ // `~`
+ case 126 /* Tilde */:
+ parser.index++;
+ parser.column++;
+ return 301989934 /* Complement */;
+ // `[`
+ case 91 /* LeftBracket */:
+ parser.index++;
+ parser.column++;
+ return 41943059 /* LeftBracket */;
+ // `@`
+ case 64 /* At */:
+ parser.index++;
+ parser.column++;
+ return 120 /* At */;
+ // `/`, `/=`, `/>`
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ if (parser.index >= parser.length)
+ return 167774773 /* Divide */;
+ switch (parser.source.charCodeAt(parser.index)) {
+ case 47 /* Slash */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipSingleLineComment(parser, context, state, 'SingleLine');
+ continue;
+ }
+ case 42 /* Asterisk */:
+ {
+ parser.index++;
+ parser.column++;
+ state = skipMultiLineComment(parser, context, state);
+ continue;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 100663333 /* DivideAssign */;
+ }
+ default:
+ return 167774773 /* Divide */;
+ }
+ }
+ // `-`, `--`, `-=`
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++; // skip `-`
+ const next = parser.source.charCodeAt(parser.index);
+ switch (next) {
+ case 45 /* Hyphen */:
+ {
+ parser.index++;
+ parser.column++;
+ if ((state & exports.ScannerState.NewLine || lineStart) &&
+ consumeOpt(parser, 62 /* GreaterThan */)) {
+ state = skipSingleHTMLComment(parser, context, state, 'HTMLClose');
+ continue;
+ }
+ return 570425372 /* Decrement */;
+ }
+ case 61 /* EqualSign */:
+ {
+ parser.index++;
+ parser.column++;
+ return 67108899 /* SubtractAssign */;
+ }
+ default:
+ return 436209968 /* Subtract */;
+ }
+ }
+ // `<`, `<=`, `<<`, `<<=`, `</`, <!--
+ 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 & exports.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 & exports.Context.InJSXChild)
+ return 167774016 /* GreaterThan */;
+ let next = parser.source.charCodeAt(parser.index);
+ if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 167774014 /* GreaterThanOrEqual */;
+ }
+ if (next !== 62 /* GreaterThan */)
+ return 167774016 /* GreaterThan */;
+ parser.index++;
+ parser.column++;
+ next = parser.source.charCodeAt(parser.index);
+ if (next === 62 /* GreaterThan */) {
+ parser.index++;
+ parser.column++;
+ if (consumeOpt(parser, 61 /* EqualSign */)) {
+ return 67108896 /* LogicalShiftRightAssign */;
+ }
+ else {
+ return 167774275 /* LogicalShiftRight */;
+ }
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108895 /* ShiftRightAssign */;
+ }
+ return 167774274 /* ShiftRight */;
+ }
+ // `^`, `^=`
+ case 94 /* Caret */:
+ parser.index++;
+ parser.column++;
+ if (!consumeOpt(parser, 61 /* EqualSign */))
+ return 167773254 /* BitwiseXor */;
+ return 67108903 /* BitwiseXorAssign */;
+ // ``string``
+ case 96 /* Backtick */:
+ return scanTemplate(parser, context);
+ // `|`, `||`, `|=`
+ case 124 /* VerticalBar */:
+ {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 124 /* VerticalBar */) {
+ parser.index++;
+ parser.column++;
+ return 169869624 /* LogicalOr */;
+ }
+ else if (next === 61 /* EqualSign */) {
+ parser.index++;
+ parser.column++;
+ return 67108904 /* BitwiseOrAssign */;
+ }
+ return 167772997 /* BitwiseOr */;
+ }
+ // `.`, `...`, `.123` (numeric literal)
+ case 46 /* Period */:
+ {
+ let index = parser.index + 1;
+ const next = parser.source.charCodeAt(index);
+ if (next >= 48 /* Zero */ && next <= 57 /* Nine */) {
+ scanNumericLiteral(parser, context, exports.NumericState.Float);
+ return 33554434 /* NumericLiteral */;
+ }
+ else if (next === 46 /* Period */) {
+ index++;
+ if (index < parser.length &&
+ parser.source.charCodeAt(index) === 46 /* Period */) {
+ parser.index = index + 1;
+ parser.column += 3;
+ return 14 /* Ellipsis */;
+ }
+ }
+ parser.index++;
+ parser.column++;
+ return 16777229 /* Period */;
+ }
+ // `#`
+ case 35 /* Hash */:
+ {
+ parser.index++;
+ parser.column++;
+ const index = parser.index;
+ const next = parser.source.charCodeAt(index);
+ if (context & exports.Context.OptionsShebang &&
+ lineStart &&
+ next === 33 /* Exclamation */) {
+ parser.index = index + 1;
+ skipSingleLineComment(parser, context, exports.ScannerState.None, 'SheBang');
+ continue;
+ }
+ return scanPrivateName(parser, context);
+ }
+ // `0`...`9`
+ case 48 /* Zero */:
+ {
+ parser.index++;
+ parser.column++;
+ switch (parser.source.charCodeAt(parser.index)) {
+ // Hex number - '0x', '0X'
+ case 88 /* UpperX */:
+ case 120 /* LowerX */:
+ return scanHexIntegerLiteral(parser, context);
+ // Binary number - '0b', '0B'
+ case 66 /* UpperB */:
+ case 98 /* LowerB */:
+ return scanOctalOrBinary(parser, context, 2);
+ // Octal number - '0o', '0O'
+ case 79 /* UpperO */:
+ case 111 /* LowerO */:
+ return scanOctalOrBinary(parser, context, 8);
+ default:
+ // Implicit octal digits startign with '0'
+ return scanImplicitOctalDigits(parser, context);
+ }
+ }
+ case 49 /* One */:
+ case 50 /* Two */:
+ case 51 /* Three */:
+ case 52 /* Four */:
+ case 53 /* Five */:
+ case 54 /* Six */:
+ case 55 /* Seven */:
+ case 56 /* Eight */:
+ case 57 /* Nine */:
+ return scanNumericLiteral(parser, context);
+ // `a`...`z`, `A`...`Z`, `_var`, `$var`
+ case 65 /* UpperA */:
+ case 66 /* UpperB */:
+ case 67 /* UpperC */:
+ case 68 /* UpperD */:
+ case 69 /* UpperE */:
+ case 70 /* UpperF */:
+ case 71 /* UpperG */:
+ case 72 /* UpperH */:
+ case 73 /* UpperI */:
+ case 74 /* UpperJ */:
+ case 75 /* UpperK */:
+ case 76 /* UpperL */:
+ case 77 /* UpperM */:
+ case 78 /* UpperN */:
+ case 79 /* UpperO */:
+ case 80 /* UpperP */:
+ case 81 /* UpperQ */:
+ case 82 /* UpperR */:
+ case 83 /* UpperS */:
+ case 84 /* UpperT */:
+ case 85 /* UpperU */:
+ case 86 /* UpperV */:
+ case 87 /* UpperW */:
+ case 88 /* UpperX */:
+ case 89 /* UpperY */:
+ case 90 /* UpperZ */:
+ case 36 /* Dollar */:
+ case 95 /* Underscore */:
+ case 97 /* LowerA */:
+ case 98 /* LowerB */:
+ case 99 /* LowerC */:
+ case 100 /* LowerD */:
+ case 101 /* LowerE */:
+ case 102 /* LowerF */:
+ case 103 /* LowerG */:
+ case 104 /* LowerH */:
+ case 105 /* LowerI */:
+ case 106 /* LowerJ */:
+ case 107 /* LowerK */:
+ case 108 /* LowerL */:
+ case 109 /* LowerM */:
+ case 110 /* LowerN */:
+ case 111 /* LowerO */:
+ case 112 /* LowerP */:
+ case 113 /* LowerQ */:
+ case 114 /* LowerR */:
+ case 115 /* LowerS */:
+ case 116 /* LowerT */:
+ case 117 /* LowerU */:
+ case 118 /* LowerV */:
+ case 119 /* LowerW */:
+ case 120 /* LowerX */:
+ case 121 /* LowerY */:
+ case 122 /* LowerZ */:
+ default:
+ return scanIdentifier(parser, context, first);
+ }
+ }
+ }
+ return 1048576 /* EndOfSource */;
+ } + + /**
+ * Scans regular expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanRegularExpression(parser, context) {
+ const bodyStart = parser.index;
+ let preparseState = exports.RegexState.Empty;
+ loop: while (true) {
+ const ch = parser.source.charCodeAt(parser.index);
+ parser.index++;
+ parser.column++;
+ if (preparseState & exports.RegexState.Escape) {
+ preparseState &= ~exports.RegexState.Escape;
+ }
+ else {
+ switch (ch) {
+ case 47 /* Slash */:
+ if (!preparseState)
+ break loop;
+ else
+ break;
+ case 92 /* Backslash */:
+ preparseState |= exports.RegexState.Escape;
+ break;
+ case 91 /* LeftBracket */:
+ preparseState |= exports.RegexState.Class;
+ break;
+ case 93 /* RightBracket */:
+ preparseState &= exports.RegexState.Escape;
+ break;
+ case 13 /* CarriageReturn */:
+ case 10 /* LineFeed */:
+ case 8232 /* LineSeparator */:
+ case 8233 /* ParagraphSeparator */:
+ report(parser, 7 /* UnterminatedRegExp */);
+ default: // ignore
+ }
+ }
+ if (parser.index >= parser.source.length) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ const bodyEnd = parser.index - 1;
+ let mask = exports.RegexFlags.Empty;
+ const { index: flagStart } = parser;
+ loop: while (parser.index < parser.source.length) {
+ const code = parser.source.charCodeAt(parser.index);
+ switch (code) {
+ case 103 /* LowerG */:
+ if (mask & exports.RegexFlags.Global)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'g');
+ mask |= exports.RegexFlags.Global;
+ break;
+ case 105 /* LowerI */:
+ if (mask & exports.RegexFlags.IgnoreCase)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'i');
+ mask |= exports.RegexFlags.IgnoreCase;
+ break;
+ case 109 /* LowerM */:
+ if (mask & exports.RegexFlags.Multiline)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'm');
+ mask |= exports.RegexFlags.Multiline;
+ break;
+ case 117 /* LowerU */:
+ if (mask & exports.RegexFlags.Unicode)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'u');
+ mask |= exports.RegexFlags.Unicode;
+ break;
+ case 121 /* LowerY */:
+ if (mask & exports.RegexFlags.Sticky)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 'y');
+ mask |= exports.RegexFlags.Sticky;
+ break;
+ case 115 /* LowerS */:
+ if (mask & exports.RegexFlags.DotAll)
+ tolerant(parser, context, 15 /* DuplicateRegExpFlag */, 's');
+ mask |= exports.RegexFlags.DotAll;
+ break;
+ default:
+ if (!isIdentifierPart(code))
+ break loop;
+ report(parser, 16 /* UnexpectedTokenRegExpFlag */, fromCodePoint(code));
+ }
+ parser.index++;
+ parser.column++;
+ }
+ const flags = parser.source.slice(flagStart, parser.index);
+ const pattern = parser.source.slice(bodyStart, bodyEnd);
+ parser.tokenRegExp = { pattern, flags };
+ if (context & exports.Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(parser.startIndex, parser.index);
+ parser.tokenValue = validate(parser, context, pattern, flags);
+ return 33554436 /* RegularExpression */;
+ }
+ /**
+ * Validates regular expressions
+ *
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param pattern Regexp body
+ * @param flags Regexp flags
+ */
+ function validate(parser, context, pattern, flags) {
+ if (!(context & exports.Context.OptionsNode)) {
+ try {
+ }
+ catch (e) {
+ report(parser, 7 /* UnterminatedRegExp */);
+ }
+ }
+ try {
+ return new RegExp(pattern, flags);
+ }
+ catch (e) {
+ return null;
+ }
+ } + + // 12.15.5 Destructuring Assignment
+ /**
+ * Parses either a binding identifier or binding pattern
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingIdentifierOrPattern(parser, context, args = []) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ return token === 41943052 /* LeftBrace */ ?
+ parserObjectAssignmentPattern(parser, context) :
+ parseArrayAssignmentPattern(parser, context, args);
+ }
+ else if (token & (262144 /* IsAwait */ | 1073741824 /* IsYield */)) {
+ if (token & 262144 /* IsAwait */ && (context & (exports.Context.Async | exports.Context.Module))) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ else if (token & 1073741824 /* IsYield */ && (context & (exports.Context.Yield | exports.Context.Strict))) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ }
+ args.push(parser.tokenValue);
+ return parseBindingIdentifier(parser, context);
+ }
+ /**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BindingIdentifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingIdentifier(parser, context) {
+ const { token } = parser;
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ else if (context & exports.Context.BlockScope && token === 33574984 /* LetKeyword */) {
+ // let is disallowed as a lexically bound name
+ tolerant(parser, context, 27 /* LetInLexicalBinding */);
+ }
+ else if (hasBit(token, 20480 /* FutureReserved */)) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ parser.flags |= exports.Flags.StrictFunctionName;
+ }
+ else if (!isValidIdentifier(context, token)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ }
+ /**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentRestElement(parser, context, args) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * Parse rest property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ // tslint:disable-next-line:function-name
+ function AssignmentRestProperty(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const { token } = parser;
+ const argument = parseBindingIdentifierOrPattern(parser, context);
+ if (hasBit(token, 8388608 /* IsBindingPattern */))
+ tolerant(parser, context, 94 /* InvalidRestBindingPattern */);
+ if (parser.token === 16777234 /* Comma */)
+ tolerant(parser, context, 88 /* RestWithComma */);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * ArrayAssignmentPattern[Yield] :
+ * [ Elisionopt AssignmentRestElement[?Yield]opt ]
+ * [ AssignmentElementList[?Yield] ]
+ * [ AssignmentElementList[?Yield] , Elisionopt AssignmentRestElement[?Yield]opt ]
+ *
+ * AssignmentRestElement[Yield] :
+ * ... DestructuringAssignmentTarget[?Yield]
+ *
+ * AssignmentElementList[Yield] :
+ * AssignmentElisionElement[?Yield]
+ * AssignmentElementList[?Yield] , AssignmentElisionElement[?Yield]
+ *
+ * AssignmentElisionElement[Yield] :
+ * Elisionopt AssignmentElement[?Yield]
+ *
+ * AssignmentElement[Yield] :
+ * DestructuringAssignmentTarget[?Yield] Initializer[In,?Yield]opt
+ *
+ * DestructuringAssignmentTarget[Yield] :
+ * LeftHandSideExpression[?Yield]
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param Parser object
+ * @param Context masks
+ */
+ function parseArrayAssignmentPattern(parser, context, args) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else {
+ if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseAssignmentRestElement(parser, context, args));
+ break;
+ }
+ else {
+ elements.push(parseExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseBindingInitializer));
+ }
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ // tslint:disable-next-line:no-object-literal-type-assertion
+ return finishNode(context, parser, pos, {
+ type: 'ArrayPattern',
+ elements,
+ });
+ }
+ /**
+ * Parse object assignment pattern
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parserObjectAssignmentPattern(parser, context) {
+ const pos = getLocation(parser);
+ const properties = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ properties.push(AssignmentRestProperty(parser, context));
+ break;
+ }
+ properties.push(parseAssignmentProperty(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ObjectPattern',
+ properties,
+ });
+ }
+ /** Parse assignment pattern
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param left LHS of assignment pattern
+ * @param pos Location
+ */
+ function parseAssignmentPattern(parser, context, left, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse binding initializer
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentPattern)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayAssignmentPattern)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBindingInitializer(parser, context) {
+ const pos = getLocation(parser);
+ const left = parseBindingIdentifierOrPattern(parser, context);
+ return !consume(parser, context, 83886109 /* Assign */) ?
+ left :
+ finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseAssignmentExpression(parser, context | exports.Context.AllowIn),
+ });
+ }
+ /**
+ * Parse assignment property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentProperty(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ let key;
+ let value;
+ let computed = false;
+ let shorthand = false;
+ // single name binding
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ key = parseIdentifier(parser, context);
+ shorthand = !consume(parser, context, 16777237 /* Colon */);
+ if (shorthand) {
+ const hasInitializer = consume(parser, context, 83886109 /* Assign */);
+ if (context & exports.Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (!isValidIdentifier(context, token))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ value = hasInitializer ? parseAssignmentPattern(parser, context, key, pos) : key;
+ }
+ else
+ value = parseBindingInitializer(parser, context);
+ }
+ else {
+ computed = token === 41943059 /* LeftBracket */;
+ key = parsePropertyName(parser, context);
+ expect(parser, context, 16777237 /* Colon */);
+ value = parseExpressionCoverGrammar(parser, context, parseBindingInitializer);
+ }
+ // Note! The specs specifically state that this is "assignment property", but
+ // nothing in ESTree specs explains the difference between this "property" and the "property" for object literals.
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ kind: 'init',
+ key,
+ computed,
+ value,
+ method: false,
+ shorthand,
+ });
+ } + + // JSX Specification
+ // https://facebook.github.io/jsx/
+ /**
+ * Parses JSX element or JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXRootElement(parser, context) {
+ const pos = getLocation(parser);
+ let children = [];
+ let closingElement = null;
+ let selfClosing = false;
+ let openingElement;
+ expect(parser, context, 167774015 /* LessThan */);
+ const isFragment = parser.token === 167774016 /* GreaterThan */;
+ if (isFragment) {
+ openingElement = parseJSXOpeningFragment(parser, context, pos);
+ }
+ else {
+ const name = parseJSXElementName(parser, context);
+ const attributes = parseJSXAttributes(parser, context);
+ selfClosing = consume(parser, context, 167774773 /* Divide */);
+ openingElement = parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos);
+ }
+ if (isFragment)
+ return parseJSXFragment(parser, context, openingElement, pos);
+ if (!selfClosing) {
+ children = parseJSXChildren(parser, context);
+ closingElement = parseJSXClosingElement(parser, context);
+ const open = isEqualTagNames(openingElement.name);
+ const close = isEqualTagNames(closingElement.name);
+ if (open !== close)
+ report(parser, 85 /* ExpectedJSXClosingTag */, close);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'JSXElement',
+ children,
+ openingElement,
+ closingElement,
+ });
+ }
+ /**
+ * Parses JSX opening element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param name Element name
+ * @param attributes Element attributes
+ * @param selfClosing True if this is a selfclosing JSX Element
+ * @param pos Line / Column tracking
+ */
+ function parseJSXOpeningElement(parser, context, name, attributes, selfClosing, pos) {
+ if (context & exports.Context.InJSXChild && selfClosing)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningElement',
+ name,
+ attributes,
+ selfClosing,
+ });
+ }
+ /**
+ * Parse JSX fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param openingElement Opening fragment
+ * @param pos Line / Column location
+ */
+ function parseJSXFragment(parser, context, openingElement, pos) {
+ const children = parseJSXChildren(parser, context);
+ const closingFragment = parseJSXClosingFragment(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXFragment',
+ children,
+ openingElement,
+ closingFragment,
+ });
+ }
+ /**
+ * Parse JSX opening fragmentD
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXOpeningFragment(parser, context, pos) {
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXOpeningFragment',
+ });
+ }
+ /**
+ * Prime the scanner and advance to the next JSX token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextJSXToken(parser) {
+ return parser.token = scanJSXToken(parser);
+ }
+ /**
+ * Mini scanner
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanJSXToken(parser) {
+ if (parser.index >= parser.source.length)
+ return 1048576 /* EndOfSource */;
+ parser.lastIndex = parser.startIndex = parser.index;
+ const char = parser.source.charCodeAt(parser.index);
+ if (char === 60 /* LessThan */) {
+ parser.index++;
+ parser.column++;
+ return consumeOpt(parser, 47 /* Slash */) ? 25 /* JSXClose */ : 167774015 /* LessThan */;
+ }
+ else if (char === 123 /* LeftBrace */) {
+ parser.index++;
+ parser.column++;
+ return 41943052 /* LeftBrace */;
+ }
+ while (parser.index < parser.source.length) {
+ parser.index++;
+ parser.column++;
+ const next = parser.source.charCodeAt(parser.index);
+ if (next === 123 /* LeftBrace */ || next === 60 /* LessThan */)
+ break;
+ }
+ return 121 /* JSXText */;
+ }
+ /**
+ * Parses JSX children
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXChildren(parser, context) {
+ const children = [];
+ while (parser.token !== 25 /* JSXClose */) {
+ children.push(parseJSXChild(parser, context));
+ }
+ return children;
+ }
+ /**
+ * Parses JSX Text
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXText(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.source.slice(parser.startIndex, parser.index);
+ parser.token = scanJSXToken(parser);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXText',
+ value,
+ });
+ if (context & exports.Context.OptionsRaw)
+ node.raw = value;
+ return node;
+ }
+ /**
+ * Parses JSX Child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXChild(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ case 121 /* JSXText */:
+ return parseJSXText(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpression(parser, context & ~exports.Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context & ~exports.Context.InJSXChild);
+ default:
+ report(parser, 0 /* Unexpected */);
+ }
+ return undefined; // note: get rid of this
+ }
+ /**
+ * Parses JSX attributes
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributes(parser, context) {
+ const attributes = [];
+ while (parser.index < parser.source.length) {
+ if (parser.token === 167774773 /* Divide */ || parser.token === 167774016 /* GreaterThan */)
+ break;
+ attributes.push(parseJSXAttribute(parser, context));
+ }
+ return attributes;
+ }
+ /**
+ * Parses JSX spread attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXSpreadAttribute(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~exports.Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadAttribute',
+ argument: expression,
+ });
+ }
+ /**
+ * Parses JSX namespace name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param namespace Identifier
+ * @param pos Line / Column location
+ */
+ function parseJSXNamespacedName(parser, context, namespace, pos) {
+ expect(parser, context, 16777237 /* Colon */);
+ const name = parseJSXIdentifier(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'JSXNamespacedName',
+ namespace,
+ name,
+ });
+ }
+ /**
+ * Parses JSX attribute name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributeName(parser, context) {
+ const pos = getLocation(parser);
+ const identifier = parseJSXIdentifier(parser, context);
+ return parser.token === 16777237 /* Colon */ ?
+ parseJSXNamespacedName(parser, context, identifier, pos) :
+ identifier;
+ }
+ /**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttributeValue(parser, context) {
+ switch (scanJSXAttributeValue(parser, context)) {
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseJSXExpressionContainer(parser, context | exports.Context.InJSXChild);
+ case 167774015 /* LessThan */:
+ return parseJSXRootElement(parser, context | exports.Context.InJSXChild);
+ default:
+ tolerant(parser, context, 87 /* InvalidJSXAttributeValue */);
+ return undefined; // note: get rid of this
+ }
+ }
+ /**
+ * Parses JSX Attribute
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXAttribute(parser, context) {
+ const pos = getLocation(parser);
+ if (parser.token === 41943052 /* LeftBrace */)
+ return parseJSXSpreadAttribute(parser, context);
+ scanJSXIdentifier(parser);
+ const attrName = parseJSXAttributeName(parser, context);
+ const value = parser.token === 83886109 /* Assign */ ? parseJSXAttributeValue(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'JSXAttribute',
+ value: value,
+ name: attrName,
+ });
+ }
+ /**
+ * Parses JSX Attribute value
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function scanJSXAttributeValue(parser, context) {
+ parser.lastIndex = parser.index;
+ const ch = parser.source.charCodeAt(parser.index);
+ switch (ch) {
+ case 34 /* DoubleQuote */:
+ case 39 /* SingleQuote */:
+ return scanJSXString(parser, context, ch);
+ default:
+ return nextToken(parser, context);
+ }
+ }
+ /**
+ * Parses JSX String
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param quote Code point
+ */
+ function scanJSXString(parser, context, quote) {
+ const rawStart = parser.index;
+ parser.index++;
+ parser.column++;
+ let ret = '';
+ let ch = parser.source.charCodeAt(parser.index);
+ while (ch !== quote) {
+ ret += fromCodePoint(ch);
+ parser.index++;
+ parser.column++;
+ ch = parser.source.charCodeAt(parser.index);
+ if (parser.index >= parser.source.length)
+ report(parser, 6 /* UnterminatedString */);
+ }
+ parser.index++;
+ parser.column++; // skip the quote
+ // raw
+ if (context & exports.Context.OptionsRaw)
+ parser.tokenRaw = parser.source.slice(rawStart, parser.index);
+ parser.tokenValue = ret;
+ return 33554435 /* StringLiteral */;
+ }
+ /**
+ * Parses JJSX Empty Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXEmptyExpression(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXEmptyExpression',
+ });
+ }
+ /**
+ * Parses JSX Spread child
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXSpreadChild(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const expression = parseExpression(parser, context);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXSpreadChild',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Expression container
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXExpressionContainer(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ // Note: JSX Expressions can't be empty
+ if (parser.token === 17825807 /* RightBrace */)
+ tolerant(parser, context, 84 /* NonEmptyJSXExpression */);
+ const expression = parseExpressionCoverGrammar(parser, context & ~exports.Context.InJSXChild, parseAssignmentExpression);
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ if (parser.token === 14 /* Ellipsis */)
+ return parseJSXSpreadChild(parser, context);
+ const expression = parser.token === 17825807 /* RightBrace */ ?
+ parseJSXEmptyExpression(parser, context) :
+ parseExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXExpressionContainer',
+ expression,
+ });
+ }
+ /**
+ * Parses JSX Closing fragment
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXClosingFragment(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ expect(parser, context, 167774016 /* GreaterThan */);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingFragment',
+ });
+ }
+ /**
+ * Parses JSX Closing Element
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXClosingElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 25 /* JSXClose */);
+ const name = parseJSXElementName(parser, context);
+ if (context & exports.Context.InJSXChild)
+ expect(parser, context, 167774016 /* GreaterThan */);
+ else
+ nextJSXToken(parser);
+ return finishNode(context, parser, pos, {
+ type: 'JSXClosingElement',
+ name,
+ });
+ }
+ /**
+ * Parses JSX Identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseJSXIdentifier(parser, context) {
+ const { token, tokenValue: name, tokenRaw: raw } = parser;
+ if (!(token & (131072 /* IsIdentifier */ | 4096 /* Keyword */))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'JSXIdentifier',
+ name,
+ });
+ if (context & exports.Context.OptionsRawidentifiers)
+ node.raw = raw;
+ return node;
+ }
+ /**
+ * Parses JSX Member expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Line / Column location
+ */
+ function parseJSXMemberExpression(parser, context, expr, pos) {
+ // Note: In order to be able to parse cases like ''<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 & exports.Context.InParameter)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ expect(parser, context, 1107316842 /* YieldKeyword */);
+ let argument = null;
+ let delegate = false;
+ if (!(parser.flags & exports.Flags.NewLine)) {
+ delegate = consume(parser, context, 167774771 /* Multiply */);
+ // 'Token.IsExpressionStart' bitmask contains the complete set of
+ // tokens that can appear after an AssignmentExpression, and none of them
+ // can start an AssignmentExpression.
+ if (delegate || parser.token & 33554432 /* IsExpressionStart */) {
+ argument = parseAssignmentExpression(parser, context);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'YieldExpression',
+ argument,
+ delegate,
+ });
+ }
+ /**
+ * AssignmentExpression :
+ * ConditionalExpression
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpression
+ * LeftHandSideExpression AssignmentOperator AssignmentExpression
+ *
+ * AssignmentExpressionNoIn :
+ * ConditionalExpressionNoIn
+ * YieldExpression
+ * ArrowFunction
+ * AsyncArrowFunction
+ * LeftHandSideExpression = AssignmentExpressionNoIn
+ * LeftHandSideExpression AssignmentOperator AssignmentExpressionNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAssignmentExpression(parser, context) {
+ const pos = getLocation(parser);
+ let { token } = parser;
+ if (context & exports.Context.Yield && token & 1073741824 /* IsYield */)
+ return parseYieldExpression(parser, context, pos);
+ let expr = token & 524288 /* IsAsync */ && lookahead(parser, context, nextTokenisIdentifierOrParen)
+ ? parserCoverCallExpressionAndAsyncArrowHead(parser, context)
+ : parseConditionalExpression(parser, context, pos);
+ if (parser.token === 10 /* Arrow */) {
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & (20480 /* FutureReserved */ | 4194304 /* IsEvalOrArguments */)) {
+ // Invalid: ' yield => { 'use strict'; 0 };'
+ if (token & 20480 /* FutureReserved */) {
+ parser.flags |= exports.Flags.HasStrictReserved;
+ }
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ }
+ expr = [expr];
+ }
+ return parseArrowFunction(parser, context &= ~exports.Context.Async, pos, expr);
+ }
+ if (hasBit(parser.token, 67108864 /* IsAssignOp */)) {
+ token = parser.token;
+ if (context & exports.Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 17 /* StrictLHSAssignment */);
+ }
+ else if (consume(parser, context, 83886109 /* Assign */)) {
+ if (!(parser.flags & exports.Flags.AllowDestructuring)) {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ // Only re-interpret if not inside a formal parameter list
+ if (!(context & exports.Context.InParameter))
+ reinterpret(parser, context, expr);
+ if (context & exports.Context.InParen)
+ parser.flags |= exports.Flags.SimpleParameterList;
+ if (parser.token & 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= exports.Flags.HasAwait;
+ }
+ else if (context & exports.Context.InParen &&
+ context & (exports.Context.Strict | exports.Context.Yield) &&
+ parser.token & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= exports.Flags.HasYield;
+ }
+ }
+ else {
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ nextToken(parser, context);
+ }
+ const right = parseExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression);
+ parser.pendingExpressionError = null;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentExpression',
+ left: expr,
+ operator: tokenDesc(token),
+ right,
+ });
+ }
+ return expr;
+ }
+ /**
+ * Parse conditional expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ConditionalExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseConditionalExpression(parser, context, pos) {
+ const test = parseBinaryExpression(parser, context, 0, pos);
+ if (!consume(parser, context, 22 /* QuestionMark */))
+ return test;
+ const consequent = parseExpressionCoverGrammar(parser, context & ~exports.Context.AllowDecorator | exports.Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16777237 /* Colon */);
+ return finishNode(context, parser, pos, {
+ type: 'ConditionalExpression',
+ test,
+ consequent,
+ alternate: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse binary expression.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-exp-operator)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-additive-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-bitwise-shift-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-equality-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-binary-logical-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-relational-operators)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-multiplicative-operators)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param minPrec Minimum precedence value
+ * @param pos Line / Column info
+ * @param Left Left hand side of the binary expression
+ */
+ function parseBinaryExpression(parser, context, minPrec, pos, left = parseUnaryExpression(parser, context)) {
+ // Shift-reduce parser for the binary operator part of the JS expression
+ // syntax.
+ const bit = context & exports.Context.AllowIn ^ exports.Context.AllowIn;
+ while (hasBit(parser.token, 167772160 /* IsBinaryOp */)) {
+ const t = parser.token;
+ const prec = t & 3840 /* Precedence */;
+ const delta = (t === 167775030 /* Exponentiate */) << 8 /* PrecStart */;
+ if (bit && t === 167786289 /* InKeyword */)
+ break;
+ // When the next token is no longer a binary operator, it's potentially the
+ // start of an expression, so we break the loop
+ if (prec + delta <= minPrec)
+ break;
+ nextToken(parser, context);
+ left = finishNode(context, parser, pos, {
+ type: t & 2097152 /* IsLogical */ ? 'LogicalExpression' : 'BinaryExpression',
+ left,
+ right: parseBinaryExpression(parser, context & ~exports.Context.AllowIn, prec, getLocation(parser)),
+ operator: tokenDesc(t),
+ });
+ }
+ return left;
+ }
+ /**
+ * Parse await expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AwaitExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ */
+ function parseAwaitExpression(parser, context, pos) {
+ if (context & exports.Context.InParameter)
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ expect(parser, context, 34017389 /* AwaitKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'AwaitExpression',
+ argument: parseUnaryExpression(parser, context),
+ });
+ }
+ /**
+ * Parses unary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UnaryExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseUnaryExpression(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ if (hasBit(token, 301989888 /* IsUnaryOp */)) {
+ nextToken(parser, context);
+ if (parser.flags & exports.Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ const argument = parseExpressionCoverGrammar(parser, context, parseUnaryExpression);
+ if (parser.token === 167775030 /* Exponentiate */) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & exports.Context.Strict && token === 302002219 /* DeleteKeyword */) {
+ if (argument.type === 'Identifier') {
+ tolerant(parser, context, 43 /* StrictDelete */);
+ }
+ else if (isPropertyWithPrivateFieldKey(argument)) {
+ tolerant(parser, context, 44 /* DeletePrivateField */);
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'UnaryExpression',
+ operator: tokenDesc(token),
+ argument,
+ prefix: true,
+ });
+ }
+ return context & exports.Context.Async && token & 262144 /* IsAwait */
+ ? parseAwaitExpression(parser, context, pos)
+ : parseUpdateExpression(parser, context, pos);
+ }
+ /**
+ * Parses update expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-UpdateExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseUpdateExpression(parser, context, pos) {
+ const { token } = parser;
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */)) {
+ nextToken(parser, context);
+ const expr = parseLeftHandSideExpression(parser, context, pos);
+ validateUpdateExpression(parser, context, expr, 'Prefix');
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expr,
+ operator: tokenDesc(token),
+ prefix: true,
+ });
+ }
+ else if (context & exports.Context.OptionsJSX && token === 167774015 /* LessThan */) {
+ return parseJSXRootElement(parser, context | exports.Context.InJSXChild);
+ }
+ const expression = parseLeftHandSideExpression(parser, context, pos);
+ if (hasBit(parser.token, 570425344 /* IsUpdateOp */) && !(parser.flags & exports.Flags.NewLine)) {
+ validateUpdateExpression(parser, context, expression, 'Postfix');
+ const operator = parser.token;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'UpdateExpression',
+ argument: expression,
+ operator: tokenDesc(operator),
+ prefix: false,
+ });
+ }
+ return expression;
+ }
+ /**
+ * Parse assignment rest element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentRestElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseRestElement(parser, context, args = []) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (context & exports.Context.InParen && parser.token & 262144 /* IsAwait */)
+ parser.flags |= exports.Flags.HasAwait;
+ const argument = parseBindingIdentifierOrPattern(parser, context, args);
+ return finishNode(context, parser, pos, {
+ type: 'RestElement',
+ argument,
+ });
+ }
+ /**
+ * Parse spread element
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SpreadElement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSpreadElement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ const argument = restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+ }
+ /**
+ * Parse left hand side expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LeftHandSideExpression)
+ *
+ * @param Parser Parer instance
+ * @param Context Contextmasks
+ * @param pos Location info
+ */
+ function parseLeftHandSideExpression(parser, context, pos) {
+ const expr = context & exports.Context.OptionsNext && parser.token === 33566810 /* ImportKeyword */
+ ? parseCallImportOrMetaProperty(parser, context | exports.Context.AllowIn)
+ : parseMemberExpression(parser, context | exports.Context.AllowIn, pos);
+ return parseCallExpression(parser, context | exports.Context.AllowIn, pos, expr);
+ }
+ /**
+ * Parse member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location info
+ * @param expr Expression
+ */
+ function parseMemberExpression(parser, context, pos, expr = parsePrimaryExpression(parser, context)) {
+ while (true) {
+ switch (parser.token) {
+ case 16777229 /* Period */: {
+ consume(parser, context, 16777229 /* Period */);
+ parser.flags = parser.flags & ~exports.Flags.AllowBinding | exports.Flags.AllowDestructuring;
+ const property = parseIdentifierNameOrPrivateName(parser, context);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ property,
+ });
+ continue;
+ }
+ case 41943059 /* LeftBracket */: {
+ consume(parser, context, 41943059 /* LeftBracket */);
+ parser.flags = parser.flags & ~exports.Flags.AllowBinding | exports.Flags.AllowDestructuring;
+ const property = parseExpression(parser, context);
+ expect(parser, context, 20 /* RightBracket */);
+ expr = finishNode(context, parser, pos, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ property,
+ });
+ continue;
+ }
+ case 33554441 /* TemplateTail */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplateLiteral(parser, context),
+ });
+ continue;
+ }
+ case 33554440 /* TemplateCont */: {
+ expr = finishNode(context, parser, pos, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parseTemplate(parser, context | exports.Context.TaggedTemplate),
+ });
+ continue;
+ }
+ default:
+ return expr;
+ }
+ }
+ }
+ /**
+ * Parse call expression
+ *
+ * @param parser Parer instance
+ * @param context Context masks
+ * @param pos Line / Colum info
+ * @param expr Expression
+ */
+ function parseCallExpression(parser, context, pos, expr) {
+ while (true) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ if (parser.token !== 50331659 /* LeftParen */)
+ return expr;
+ const args = parseArgumentList(parser, context & ~exports.Context.AllowDecorator);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+ }
+ /**
+ * Parse cover call expression and async arrow head
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CoverCallExpressionAndAsyncArrowHead)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parserCoverCallExpressionAndAsyncArrowHead(parser, context) {
+ const pos = getLocation(parser);
+ let expr = parseMemberExpression(parser, context | exports.Context.AllowIn, pos);
+ // Here we jump right into it and parse a simple, faster sub-grammar for
+ // async arrow / async identifier + call expression. This could have been done different
+ // but ESTree sucks!
+ //
+ // - J.K. Thomas
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (parser.token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */);
+ return parseAsyncArrowFunction(parser, context, exports.ModifierState.Await, pos, [parseAndClassifyIdentifier(parser, context)]);
+ }
+ if (parser.flags & exports.Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ while (parser.token === 50331659 /* LeftParen */) {
+ expr = parseMemberExpression(parser, context, pos, expr);
+ const args = parseAsyncArgumentList(parser, context);
+ if (parser.token === 10 /* Arrow */) {
+ expr = parseAsyncArrowFunction(parser, context, exports.ModifierState.Await, pos, args);
+ break;
+ }
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ });
+ }
+ return expr;
+ }
+ /**
+ * Parse argument list
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parseArgumentList(parser, context) {
+ // ArgumentList :
+ // AssignmentOrSpreadExpression
+ // ArgumentList , AssignmentOrSpreadExpression
+ //
+ // AssignmentOrSpreadExpression :
+ // ... AssignmentExpression
+ // AssignmentExpression
+ expect(parser, context, 50331659 /* LeftParen */);
+ const expressions = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ expressions.push(parseSpreadElement(parser, context));
+ }
+ else {
+ if (context & exports.Context.Yield && hasBit(parser.token, 1073741824 /* IsYield */)) {
+ parser.flags |= exports.Flags.HasYield;
+ setPendingError(parser);
+ }
+ expressions.push(parseExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression));
+ }
+ if (parser.token !== 16 /* RightParen */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return expressions;
+ }
+ /**
+ * Parse argument list for async arrow / async call expression
+ *
+ * @see [https://tc39.github.io/ecma262/#prod-ArgumentList)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parseAsyncArgumentList(parser, context) {
+ // Here we are parsing an "extended" argument list tweaked to handle async arrows. This is
+ // done here to avoid overhead and possible performance loss if we only
+ // parse out a simple call expression - E.g 'async(foo, bar)' or 'async(foo, bar)()';
+ //
+ // - J.K. Thomas
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = [];
+ let { token } = parser;
+ let state = exports.CoverCallState.Empty;
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ parser.flags |= exports.Flags.SimpleParameterList;
+ args.push(parseSpreadElement(parser, context));
+ state = exports.CoverCallState.HasSpread;
+ }
+ else {
+ token = parser.token;
+ state = validateAsyncArgumentList(parser, context, state);
+ args.push(restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression));
+ }
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ parser.flags &= ~exports.Flags.AllowDestructuring;
+ if (state & exports.CoverCallState.HasSpread)
+ state = exports.CoverCallState.SeenSpread;
+ }
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & exports.CoverCallState.SeenSpread) {
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ }
+ else if (state & exports.CoverCallState.EvalOrArguments) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ else if (state & exports.CoverCallState.Yield) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ parser.flags |= exports.Flags.HasStrictReserved;
+ }
+ else if (parser.flags & exports.Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (state & exports.CoverCallState.Await || parser.flags & exports.Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ }
+ return args;
+ }
+ /**
+ * Parse primary expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PrimaryExpression)
+ *
+ * @param Parser Parser object
+ * @param Context Context masks
+ */
+ function parsePrimaryExpression(parser, context) {
+ switch (parser.token) {
+ case 33685505 /* Identifier */:
+ return parseIdentifier(parser, context);
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionOrIdentifier(parser, context);
+ case 50331659 /* LeftParen */:
+ return parseParenthesizedExpression(parser, context | exports.Context.InParen);
+ case 41943059 /* LeftBracket */:
+ return restoreExpressionCoverGrammar(parser, context, parseArrayLiteral);
+ case 41943052 /* LeftBrace */:
+ return restoreExpressionCoverGrammar(parser, context, parseObjectLiteral);
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionExpression(parser, context);
+ case 33566727 /* NullKeyword */:
+ case 33566726 /* TrueKeyword */:
+ case 33566725 /* FalseKeyword */:
+ return parseNullOrTrueOrFalseLiteral(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassExpression(parser, context);
+ case 33566811 /* NewKeyword */:
+ return parseNewExpressionOrMetaProperty(parser, context);
+ case 33566813 /* SuperKeyword */:
+ return parseSuperProperty(parser, context);
+ case 33554551 /* BigIntLiteral */:
+ return parseBigIntLiteral(parser, context);
+ case 33566815 /* ThisKeyword */:
+ return parseThisExpression(parser, context);
+ case 115 /* Hash */:
+ return parseIdentifierNameOrPrivateName(parser, context);
+ case 167774773 /* Divide */:
+ case 100663333 /* DivideAssign */:
+ scanRegularExpression(parser, context);
+ return parseRegularExpressionLiteral(parser, context);
+ case 33554441 /* TemplateTail */:
+ return parseTemplateLiteral(parser, context);
+ case 33554440 /* TemplateCont */:
+ return parseTemplate(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetAsIdentifier(parser, context);
+ case 12369 /* DoKeyword */:
+ if (context & exports.Context.OptionsExperimental)
+ return parseDoExpression(parser, context);
+ default:
+ return parseAndClassifyIdentifier(parser, context);
+ }
+ }
+ /**
+ * Parse do expression (*experimental*)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDoExpression(parser, context) {
+ // AssignmentExpression ::
+ // do '{' StatementList '}'
+ const pos = getLocation(parser);
+ expect(parser, context, 12369 /* DoKeyword */);
+ return finishNode(context, parser, pos, {
+ type: 'DoExpression',
+ body: parseBlockStatement(parser, context)
+ });
+ }
+ /**
+ * Parse 'let' as identifier in 'sloppy mode', and throws
+ * in 'strict mode' / 'module code'. We also avoid a lookahead on the
+ * ASI restictions while checking this after parsing out the 'let' keyword
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+ function parseLetAsIdentifier(parser, context) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ if (parser.flags & exports.Flags.NewLine) {
+ if (parser.token === 41943059 /* LeftBracket */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, 'let');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ }
+ /**
+ * Parse either async function expression or identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context context mask
+ */
+ function parseAsyncFunctionOrIdentifier(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) :
+ parseIdentifier(parser, context);
+ }
+ /**
+ * Parses identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Identifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIdentifier(parser, context) {
+ const pos = getLocation(parser);
+ const name = parser.tokenValue;
+ nextToken(parser, context | exports.Context.TaggedTemplate);
+ const node = finishNode(context, parser, pos, {
+ type: 'Identifier',
+ name,
+ });
+ if (context & exports.Context.OptionsRawidentifiers)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parse regular expression literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-literals-regular-expression-literals)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseRegularExpressionLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenRegExp, tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ regex: tokenRegExp,
+ });
+ if (context & exports.Context.OptionsRaw)
+ node.raw = tokenRaw;
+ return node;
+ }
+ /**
+ * Parses string and number literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NumericLiteral)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StringLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const value = parser.tokenValue;
+ if (context & exports.Context.Strict && parser.flags & exports.Flags.HasOctal) {
+ tolerant(parser, context, 61 /* StrictOctalLiteral */);
+ }
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value,
+ });
+ if (context & exports.Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parses BigInt literal (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/proposal-bigint/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBigIntLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: tokenValue,
+ bigint: tokenRaw,
+ });
+ if (context & exports.Context.OptionsRaw)
+ node.raw = parser.tokenRaw;
+ return node;
+ }
+ /**
+ * Parses either null or boolean literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BooleanLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNullOrTrueOrFalseLiteral(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const raw = tokenDesc(token);
+ if (parser.flags & exports.Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const node = finishNode(context, parser, pos, {
+ type: 'Literal',
+ value: token === 33566727 /* NullKeyword */ ? null : raw === 'true',
+ });
+ if (context & exports.Context.OptionsRaw)
+ node.raw = raw;
+ return node;
+ }
+ /**
+ * Parse this expression
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseThisExpression(parser, context) {
+ if (parser.flags & exports.Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ const pos = getLocation(parser);
+ nextToken(parser, context | exports.Context.DisallowEscapedKeyword);
+ return finishNode(context, parser, pos, {
+ type: 'ThisExpression',
+ });
+ }
+ /**
+ * Parse identifier name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-IdentifierName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t token
+ */
+ function parseIdentifierName(parser, context, t) {
+ if (!(t & (131072 /* IsIdentifier */ | 4096 /* Keyword */)))
+ tolerant(parser, context, 4 /* UnexpectedKeyword */, tokenDesc(t));
+ return parseIdentifier(parser, context);
+ }
+ /**
+ * Parse identifier name or private name (stage 3 proposal)
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIdentifierNameOrPrivateName(parser, context) {
+ if (!consume(parser, context, 115 /* Hash */))
+ return parseIdentifierName(parser, context, parser.token);
+ const { tokenValue } = parser;
+ const pos = getLocation(parser);
+ const name = tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+ }
+ /**
+ * Parse array literal
+ *
+ * ArrayLiteral :
+ * [ Elisionopt ]
+ * [ ElementList ]
+ * [ ElementList , Elisionopt ]
+ *
+ * ElementList :
+ * Elisionopt AssignmentExpression
+ * Elisionopt ... AssignmentExpression
+ * ElementList , Elisionopt AssignmentExpression
+ * ElementList , Elisionopt SpreadElement
+ *
+ * Elision :
+ * ,
+ * Elision ,
+ *
+ * SpreadElement :
+ * ... AssignmentExpression
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrayLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseArrayLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const elements = [];
+ while (parser.token !== 20 /* RightBracket */) {
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ elements.push(null);
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ elements.push(parseSpreadElement(parser, context));
+ if (parser.token !== 20 /* RightBracket */) {
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ else {
+ elements.push(restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression));
+ if (parser.token !== 20 /* RightBracket */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ }
+ expect(parser, context, 20 /* RightBracket */);
+ return finishNode(context, parser, pos, {
+ type: 'ArrayExpression',
+ elements,
+ });
+ }
+ /**
+ * Parses cover parenthesized expression and arrow parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-parseCoverParenthesizedExpressionAndArrowParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseParenthesizedExpression(parser, context) {
+ expect(parser, context, 50331659 /* LeftParen */);
+ if (consume(parser, context, 16 /* RightParen */)) {
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ if (parser.token === 10 /* Arrow */)
+ return [];
+ }
+ else if (parser.token === 14 /* Ellipsis */) {
+ const restExpr = [parseRestElement(parser, context)];
+ expect(parser, context, 16 /* RightParen */);
+ parser.flags = parser.flags & ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding) | exports.Flags.SimpleParameterList;
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return restExpr;
+ }
+ // Record the sequence position
+ const sequencepos = getLocation(parser);
+ let state = validateCoverParenthesizedExpression(parser, exports.CoverParenthesizedState.None);
+ let expr = restoreExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression);
+ // Sequence expression
+ if (parser.token === 16777234 /* Comma */) {
+ state |= exports.CoverParenthesizedState.SequenceExpression;
+ const expressions = [expr];
+ while (consume(parser, context | exports.Context.DisallowEscapedKeyword, 16777234 /* Comma */)) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (!(parser.flags & exports.Flags.AllowBinding))
+ tolerant(parser, context, 77 /* NotBindable */);
+ parser.flags |= exports.Flags.SimpleParameterList;
+ const restElement = parseRestElement(parser, context);
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 78 /* ParamAfterRest */);
+ expressions.push(restElement);
+ return expressions;
+ }
+ else if (consume(parser, context, 16 /* RightParen */)) {
+ if (parser.token !== 10 /* Arrow */)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return expressions;
+ }
+ else {
+ state = validateCoverParenthesizedExpression(parser, state);
+ expressions.push(restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression));
+ }
+ }
+ expr = finishNode(context, parser, sequencepos, {
+ type: 'SequenceExpression',
+ expressions,
+ });
+ }
+ expect(parser, context, 16 /* RightParen */);
+ if (parser.token === 10 /* Arrow */) {
+ if (state & exports.CoverParenthesizedState.HasEvalOrArguments) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ else if (state & exports.CoverParenthesizedState.HasReservedWords) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= exports.Flags.HasStrictReserved;
+ }
+ else if (!(parser.flags & exports.Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (parser.flags & exports.Flags.HasYield) {
+ tolerant(parser, context, 51 /* YieldInParameter */);
+ }
+ else if (context & exports.Context.Async && parser.flags & exports.Flags.HasAwait) {
+ tolerant(parser, context, 52 /* AwaitInParameter */);
+ }
+ parser.flags &= ~(exports.Flags.AllowBinding | exports.Flags.HasAwait | exports.Flags.HasYield);
+ return (state & exports.CoverParenthesizedState.SequenceExpression ? expr.expressions : [expr]);
+ }
+ parser.flags &= ~(exports.Flags.HasAwait | exports.Flags.HasYield | exports.Flags.AllowBinding);
+ if (!isValidSimpleAssignmentTarget(expr))
+ parser.flags &= ~exports.Flags.AllowDestructuring;
+ return expr;
+ }
+ /**
+ * Parses function expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? exports.ModifierState.Generator : exports.ModifierState.None;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & exports.ModifierState.Generator) {
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty), isGenerator, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: false,
+ generator: !!(isGenerator & exports.ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parses async function or async generator expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAsyncGeneratorExpression(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? exports.ModifierState.Generator : exports.ModifierState.None;
+ const isAwait = exports.ModifierState.Await;
+ let id = null;
+ const { token } = parser;
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (token & 4194304 /* IsEvalOrArguments */) {
+ if (context & exports.Context.Strict || isAwait & exports.ModifierState.Await)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictFunctionName;
+ }
+ if (token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (parser.token & 1073741824 /* IsYield */ && isGenerator & exports.ModifierState.Generator)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ id = parseBindingIdentifier(parser, context);
+ }
+ const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty), isGenerator | isAwait, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: true,
+ generator: !!(isGenerator & exports.ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parse computed property names
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ComputedPropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseComputedPropertyName(parser, context) {
+ expect(parser, context, 41943059 /* LeftBracket */);
+ const key = parseAssignmentExpression(parser, context | exports.Context.AllowIn);
+ expect(parser, context, 20 /* RightBracket */);
+ return key;
+ }
+ /**
+ * Parse property name
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyName)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePropertyName(parser, context) {
+ switch (parser.token) {
+ case 33554434 /* NumericLiteral */:
+ case 33554435 /* StringLiteral */:
+ return parseLiteral(parser, context);
+ case 41943059 /* LeftBracket */:
+ return parseComputedPropertyName(parser, context);
+ default:
+ return parseIdentifier(parser, context);
+ }
+ }
+ /**
+ * Parse object spread properties
+ *
+ * @see [Link](https://tc39.github.io/proposal-object-rest-spread/#Spread)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSpreadProperties(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 14 /* Ellipsis */);
+ if (parser.token & 8388608 /* IsBindingPattern */)
+ parser.flags &= ~exports.Flags.AllowDestructuring;
+ const argument = parseAssignmentExpression(parser, context | exports.Context.AllowIn);
+ return finishNode(context, parser, pos, {
+ type: 'SpreadElement',
+ argument,
+ });
+ }
+ /**
+ * Parses object literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ObjectLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseObjectLiteral(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const properties = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ properties.push(parser.token === 14 /* Ellipsis */ ?
+ parseSpreadProperties(parser, context) :
+ parsePropertyDefinition(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ parser.flags &= ~exports.Flags.HasProtoField;
+ return finishNode(context, parser, pos, {
+ type: 'ObjectExpression',
+ properties,
+ });
+ }
+ /**
+ * Parse property definition
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-PropertyDefinition)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePropertyDefinition(parser, context) {
+ const pos = getLocation(parser);
+ const flags = parser.flags;
+ let value;
+ let state = consume(parser, context, 167774771 /* Multiply */) ? exports.ObjectState.Generator | exports.ObjectState.Method : exports.ObjectState.Method;
+ const t = parser.token;
+ let key = parsePropertyName(parser, context);
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & exports.Flags.EscapedKeyword) {
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ }
+ else if (!(state & exports.ObjectState.Generator) && t & 524288 /* IsAsync */ && !(parser.flags & exports.Flags.NewLine)) {
+ state |= consume(parser, context, 167774771 /* Multiply */) ? exports.ObjectState.Generator | exports.ObjectState.Async : exports.ObjectState.Async;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69743 /* GetKeyword */) {
+ state = state & ~exports.ObjectState.Method | exports.ObjectState.Getter;
+ key = parsePropertyName(parser, context);
+ }
+ else if (t === 69744 /* SetKeyword */) {
+ state = state & ~exports.ObjectState.Method | exports.ObjectState.Setter;
+ key = parsePropertyName(parser, context);
+ }
+ if (state & (exports.ObjectState.Getter | exports.ObjectState.Setter)) {
+ if (state & exports.ObjectState.Generator)
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ state &= ~exports.ObjectState.Method;
+ if (parser.token === 16777237 /* Colon */) {
+ if ((state & (exports.ObjectState.Async | exports.ObjectState.Generator))) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ else if (t !== 41943059 /* LeftBracket */ && parser.tokenValue === '__proto__') {
+ if (parser.flags & exports.Flags.HasProtoField) {
+ // Record the error and put it on hold until we've determined
+ // whether or not we're destructuring
+ setPendingExpressionError(parser, 63 /* DuplicateProto */);
+ }
+ else
+ parser.flags |= exports.Flags.HasProtoField;
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ // Invalid: 'async ({a: await}) => 1'
+ if (parser.token & 262144 /* IsAwait */)
+ parser.flags |= exports.Flags.HasAwait;
+ value = restoreExpressionCoverGrammar(parser, context, parseAssignmentExpression);
+ }
+ else {
+ if ((state & (exports.ObjectState.Generator | exports.ObjectState.Async)) || !isValidIdentifier(context, t)) {
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(t));
+ }
+ else if (context & (exports.Context.Strict | exports.Context.Yield) && t & 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ parser.flags |= exports.Flags.HasYield;
+ }
+ state |= exports.ObjectState.Shorthand;
+ if (parser.token === 83886109 /* Assign */) {
+ if (context & exports.Context.Strict && t & 4194304 /* IsEvalOrArguments */) {
+ report(parser, 47 /* StrictEvalArguments */);
+ }
+ else
+ setPendingExpressionError(parser, 91 /* InvalidCoverInitializedName */);
+ expect(parser, context, 83886109 /* Assign */);
+ if (context & (exports.Context.Strict | exports.Context.Yield | exports.Context.Async) && parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */)) {
+ setPendingError(parser);
+ parser.flags |= parser.token & 1073741824 /* IsYield */ ? exports.Flags.HasYield : exports.Flags.HasAwait;
+ }
+ value = parseAssignmentPattern(parser, context, key, pos);
+ }
+ else {
+ if (t & 262144 /* IsAwait */) {
+ if (context & exports.Context.Async)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ setPendingError(parser);
+ parser.flags |= exports.Flags.HasAwait;
+ }
+ value = key;
+ }
+ }
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Property',
+ key,
+ value,
+ kind: !(state & exports.ObjectState.Getter | state & exports.ObjectState.Setter) ? 'init' : (state & exports.ObjectState.Setter) ? 'set' : 'get',
+ computed: t === 41943059 /* LeftBracket */,
+ method: !!(state & exports.ObjectState.Method),
+ shorthand: !!(state & exports.ObjectState.Shorthand),
+ });
+ }
+ /**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseMethodDeclaration(parser, context, state) {
+ const pos = getLocation(parser);
+ const isGenerator = state & exports.ObjectState.Generator ? exports.ModifierState.Generator : exports.ModifierState.None;
+ const isAsync = state & exports.ObjectState.Async ? exports.ModifierState.Await : exports.ModifierState.None;
+ const { params, body } = swapContext(parser, context | exports.Context.Method, isGenerator | isAsync, parseFormalListAndBody, state);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: !!(state & exports.ObjectState.Async),
+ generator: !!(state & exports.ObjectState.Generator),
+ expression: false,
+ id: null,
+ });
+ }
+ /**
+ * Parse arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseArrowFunction(parser, context, pos, params) {
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ if (parser.flags & exports.Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, '=>');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context & ~exports.Context.Async, params, pos, exports.ModifierState.None);
+ }
+ /**
+ * Parse async arrow function
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncArrowFunction(parser, context, state, pos, params) {
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ if (parser.flags & exports.Flags.NewLine)
+ tolerant(parser, context, 36 /* InvalidLineBreak */, 'async');
+ expect(parser, context, 10 /* Arrow */);
+ return parseArrowBody(parser, context | exports.Context.Async, params, pos, state);
+ }
+ /**
+ * Shared helper function for both async arrow and arrows
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ArrowFunction)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncArrowFunction)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ // https://tc39.github.io/ecma262/#prod-AsyncArrowFunction
+ function parseArrowBody(parser, context, params, pos, state) {
+ parser.pendingExpressionError = null;
+ for (const i in params)
+ reinterpret(parser, context | exports.Context.InParameter, params[i]);
+ const expression = parser.token !== 41943052 /* LeftBrace */;
+ const body = expression ? parseExpressionCoverGrammar(parser, context & ~(exports.Context.Yield | exports.Context.InParameter), parseAssignmentExpression) :
+ swapContext(parser, context & ~(exports.Context.Yield | exports.Context.AllowDecorator) | exports.Context.InFunctionBody, state, parseFunctionBody);
+ return finishNode(context, parser, pos, {
+ type: 'ArrowFunctionExpression',
+ body,
+ params,
+ id: null,
+ async: !!(state & exports.ModifierState.Await),
+ generator: false,
+ expression,
+ });
+ }
+ /**
+ * Parses formal parameters and function body.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFormalListAndBody(parser, context, state) {
+ const paramList = parseFormalParameters(parser, context | exports.Context.InParameter, state);
+ const args = paramList.args;
+ const params = paramList.params;
+ const body = parseFunctionBody(parser, context & ~exports.Context.AllowDecorator | exports.Context.InFunctionBody, args);
+ return { params, body };
+ }
+ /**
+ * Parse funciton body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionBody)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionBody(parser, context, params) {
+ // Note! The 'params' has an 'any' type now because it's really shouldn't be there. This should have been
+ // on the parser object instead. So for now the 'params' arg are only used within the
+ // 'parseFormalListAndBody' method, and not within the arrow function body.
+ const pos = getLocation(parser);
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const body = [];
+ while (parser.token === 33554435 /* StringLiteral */) {
+ const { tokenRaw, tokenValue } = parser;
+ body.push(parseDirective(parser, context));
+ if (tokenRaw.length === /* length of prologue*/ 12 && tokenValue === 'use strict') {
+ if (parser.flags & exports.Flags.SimpleParameterList) {
+ tolerant(parser, context, 64 /* IllegalUseStrict */);
+ }
+ else if (parser.flags & (exports.Flags.HasStrictReserved | exports.Flags.StrictFunctionName)) {
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ }
+ else if (parser.flags & exports.Flags.StrictEvalArguments) {
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ }
+ context |= exports.Context.Strict;
+ }
+ }
+ if (context & exports.Context.Strict) {
+ validateParams(parser, context, params);
+ }
+ const { labelSet } = parser;
+ parser.labelSet = {};
+ const savedFlags = parser.flags;
+ parser.flags = parser.flags & ~(exports.Flags.StrictFunctionName | exports.Flags.StrictEvalArguments | exports.Flags.InSwitchStatement | exports.Flags.InIterationStatement) | exports.Flags.AllowDestructuring;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ if (savedFlags & exports.Flags.InIterationStatement)
+ parser.flags |= exports.Flags.InIterationStatement;
+ if (savedFlags & exports.Flags.InSwitchStatement)
+ parser.flags |= exports.Flags.InSwitchStatement;
+ parser.labelSet = labelSet;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body,
+ });
+ }
+ /**
+ * Parse formal parameters
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameters)
+ *
+ * @param Parser object
+ * @param Context masks
+ * @param Optional objectstate. Default to none
+ */
+ function parseFormalParameters(parser, context, state) {
+ // FormalParameterList :
+ // [empty]
+ // FunctionRestParameter
+ // FormalsList
+ // FormalsList , FunctionRestParameter
+ //
+ // FunctionRestParameter :
+ // ... BindingIdentifier
+ //
+ // FormalsList :
+ // FormalParameter
+ // FormalsList , FormalParameter
+ //
+ // FormalParameter :
+ // BindingElement
+ //
+ // BindingElement :
+ // SingleNameBinding
+ // BindingPattern Initializeropt
+ expect(parser, context, 50331659 /* LeftParen */);
+ parser.flags &= ~(exports.Flags.SimpleParameterList | exports.Flags.HasStrictReserved);
+ const args = [];
+ const params = [];
+ while (parser.token !== 16 /* RightParen */) {
+ if (parser.token === 14 /* Ellipsis */) {
+ if (state & exports.ObjectState.Setter)
+ tolerant(parser, context, 67 /* BadSetterRestParameter */);
+ parser.flags |= exports.Flags.SimpleParameterList;
+ params.push(parseRestElement(parser, context, args));
+ break;
+ }
+ params.push(parseFormalParameterList(parser, context, args));
+ if (!consume(parser, context, 16777234 /* Comma */))
+ break;
+ if (parser.token === 16 /* RightParen */)
+ break;
+ }
+ if (state & exports.ObjectState.Setter && params.length !== 1) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Setter', 'one', '');
+ }
+ if (state & exports.ObjectState.Getter && params.length > 0) {
+ tolerant(parser, context, 66 /* AccessorWrongArgs */, 'Getter', 'no', 's');
+ }
+ expect(parser, context, 16 /* RightParen */);
+ return { params, args };
+ }
+ /**
+ * Parse formal parameter list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FormalParameterList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFormalParameterList(parser, context, args) {
+ const pos = getLocation(parser);
+ if (parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ if (hasBit(parser.token, 20480 /* FutureReserved */)) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 50 /* UnexpectedStrictReserved */);
+ parser.flags |= exports.Flags.StrictFunctionName;
+ }
+ if (hasBit(parser.token, 4194304 /* IsEvalOrArguments */)) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ parser.flags |= exports.Flags.StrictEvalArguments;
+ }
+ }
+ else {
+ parser.flags |= exports.Flags.SimpleParameterList;
+ }
+ const left = parseBindingIdentifierOrPattern(parser, context, args);
+ if (!consume(parser, context, 83886109 /* Assign */))
+ return left;
+ if (parser.token & (1073741824 /* IsYield */ | 262144 /* IsAwait */) && context & (exports.Context.Yield | exports.Context.Async)) {
+ tolerant(parser, context, parser.token & 262144 /* IsAwait */ ? 52 /* AwaitInParameter */ : 51 /* YieldInParameter */);
+ }
+ parser.flags |= exports.Flags.SimpleParameterList;
+ return finishNode(context, parser, pos, {
+ type: 'AssignmentPattern',
+ left,
+ right: parseExpressionCoverGrammar(parser, context, parseAssignmentExpression),
+ });
+ }
+ /**
+ * Parse class expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassExpression(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & exports.Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const { token } = parser;
+ let state = exports.ObjectState.None;
+ let id = null;
+ let superClass = null;
+ if ((token !== 41943052 /* LeftBrace */ && token !== 12372 /* ExtendsKeyword */)) {
+ if (context & exports.Context.Async && token & 262144 /* IsAwait */) {
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ }
+ id = parseBindingIdentifier(parser, context | exports.Context.Strict);
+ }
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | exports.Context.Strict, pos);
+ state |= exports.ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context | exports.Context.Strict, state);
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body,
+ });
+ }
+ /**
+ * Parse class body and element list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassBody)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElementList)
+ *
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassBodyAndElementList(parser, context, state) {
+ const pos = getLocation(parser);
+ expect(parser, context, 41943052 /* LeftBrace */);
+ const body = [];
+ let decorators = [];
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (!consume(parser, context, 17825809 /* Semicolon */)) {
+ if (context & exports.Context.OptionsExperimental) {
+ decorators = parseDecorators(parser, context);
+ if (parser.token === 17825807 /* RightBrace */)
+ report(parser, 92 /* TrailingDecorators */);
+ if (decorators.length !== 0 && parser.tokenValue === 'constructor') {
+ report(parser, 93 /* GeneratorConstructor */);
+ }
+ }
+ body.push(context & exports.Context.OptionsNext && parser.token === 115 /* Hash */
+ ? parsePrivateFields(parser, context, decorators)
+ : parseClassElement(parser, context, state, decorators));
+ }
+ }
+ parser.flags &= ~exports.Flags.HasConstructor;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'ClassBody',
+ body,
+ });
+ }
+ /**
+ * Parse class element and class public instance fields & private instance fields
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassElement)
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassElement(parser, context, state, decorators) {
+ const pos = getLocation(parser);
+ let { tokenValue, token } = parser;
+ const flags = parser.flags;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ state |= exports.ObjectState.Generator;
+ }
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= exports.ObjectState.Computed;
+ if (parser.tokenValue === 'constructor') {
+ if (state & exports.ObjectState.Generator)
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'generator');
+ else if (state & exports.ObjectState.Heritage)
+ context |= exports.Context.AllowSuperProperty;
+ state |= exports.ObjectState.Constructor;
+ }
+ let key = parsePropertyName(parser, context);
+ let value;
+ if (!(parser.token & 16777216 /* IsShorthandProperty */)) {
+ if (flags & exports.Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ if (token === 20585 /* StaticKeyword */) {
+ token = parser.token;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= exports.ObjectState.Generator;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= exports.ObjectState.Computed;
+ if (parser.tokenValue === 'prototype')
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ state |= exports.ObjectState.Static;
+ key = parsePropertyName(parser, context);
+ if (context & exports.Context.OptionsNext && isInstanceField(parser)) {
+ if (tokenValue === 'constructor')
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ }
+ }
+ if (parser.token !== 50331659 /* LeftParen */) {
+ if (token & 524288 /* IsAsync */ && !(state & exports.ObjectState.Generator) && !(parser.flags & exports.Flags.NewLine)) {
+ token = parser.token;
+ tokenValue = parser.tokenValue;
+ state |= exports.ObjectState.Async;
+ if (consume(parser, context, 167774771 /* Multiply */))
+ state |= exports.ObjectState.Generator;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= exports.ObjectState.Computed;
+ key = parsePropertyName(parser, context);
+ }
+ else if ((token === 69743 /* GetKeyword */ || token === 69744 /* SetKeyword */)) {
+ state |= token === 69743 /* GetKeyword */ ? exports.ObjectState.Getter : exports.ObjectState.Setter;
+ tokenValue = parser.tokenValue;
+ if (parser.token === 41943059 /* LeftBracket */)
+ state |= exports.ObjectState.Computed;
+ key = parsePropertyName(parser, context & ~exports.Context.Strict);
+ }
+ if (tokenValue === 'prototype') {
+ tolerant(parser, context, 65 /* StaticPrototype */);
+ }
+ else if (!(state & exports.ObjectState.Static) && tokenValue === 'constructor') {
+ tolerant(parser, context, 45 /* InvalidConstructor */, 'accessor');
+ }
+ }
+ }
+ if (parser.token === 50331659 /* LeftParen */) {
+ if (!(state & exports.ObjectState.Computed) && state & exports.ObjectState.Constructor) {
+ if (parser.flags & exports.Flags.HasConstructor)
+ report(parser, 12 /* DuplicateConstructor */);
+ else
+ parser.flags |= exports.Flags.HasConstructor;
+ }
+ value = parseMethodDeclaration(parser, context, state);
+ }
+ else {
+ if (context & exports.Context.OptionsNext)
+ return parseFieldDefinition(parser, context, key, state, pos, decorators);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ }
+ const kind = (state & exports.ObjectState.Constructor) ? 'constructor' : (state & exports.ObjectState.Getter) ? 'get' :
+ (state & exports.ObjectState.Setter) ? 'set' : 'method';
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & exports.ObjectState.Static),
+ computed: !!(state & exports.ObjectState.Computed),
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind,
+ static: !!(state & exports.ObjectState.Static),
+ computed: !!(state & exports.ObjectState.Computed),
+ key,
+ value,
+ });
+ }
+ /**
+ * Parses field definition.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFieldDefinition(parser, context, key, state, pos, decorators) {
+ if (state & exports.ObjectState.Constructor)
+ tolerant(parser, context, 0 /* Unexpected */);
+ let value = null;
+ if (state & (exports.ObjectState.Async | exports.ObjectState.Generator))
+ tolerant(parser, context, 0 /* Unexpected */);
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & exports.ObjectState.Computed),
+ static: !!(state & exports.ObjectState.Static),
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: !!(state & exports.ObjectState.Computed),
+ static: !!(state & exports.ObjectState.Static),
+ });
+ }
+ /**
+ * Parse private name
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePrivateName(parser, context, pos) {
+ const name = parser.tokenValue;
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'PrivateName',
+ name,
+ });
+ }
+ /**
+ * Parses private instance fields
+ *
+ * @see [Link](https://tc39.github.io/proposal-class-public-fields/)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parsePrivateFields(parser, context, decorators) {
+ const pos = getLocation(parser);
+ expect(parser, context | exports.Context.InClass, 115 /* Hash */);
+ if (parser.tokenValue === 'constructor')
+ tolerant(parser, context, 41 /* PrivateFieldConstructor */);
+ const key = parsePrivateName(parser, context, pos);
+ if (parser.token === 50331659 /* LeftParen */)
+ return parsePrivateMethod(parser, context, key, pos, decorators);
+ let value = null;
+ if (consume(parser, context, 83886109 /* Assign */)) {
+ if (parser.token & 4194304 /* IsEvalOrArguments */)
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ value = parseAssignmentExpression(parser, context);
+ }
+ consume(parser, context, 16777234 /* Comma */);
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ decorators
+ } : {
+ type: 'FieldDefinition',
+ key,
+ value,
+ computed: false,
+ static: false,
+ });
+ }
+ function parsePrivateMethod(parser, context, key, pos, decorators) {
+ const value = parseMethodDeclaration(parser, context | exports.Context.Strict, exports.ObjectState.None);
+ parser.flags &= ~(exports.Flags.AllowDestructuring | exports.Flags.AllowBinding);
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ decorators
+ } : {
+ type: 'MethodDefinition',
+ kind: 'method',
+ static: false,
+ computed: false,
+ key,
+ value,
+ });
+ }
+ /**
+ * Parse either call expression or import expressions
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCallImportOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ // Import.meta - Stage 3 proposal
+ if (consume(parser, context, 16777229 /* Period */)) {
+ if (context & exports.Context.Module && parser.tokenValue === 'meta')
+ return parseMetaProperty(parser, context, id, pos);
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ let expr = parseImportExpression(parser, context, pos);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const args = parseExpressionCoverGrammar(parser, context | exports.Context.AllowIn, parseAssignmentExpression);
+ expect(parser, context, 16 /* RightParen */);
+ expr = finishNode(context, parser, pos, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: [args],
+ });
+ return expr;
+ }
+ /**
+ * Parse Import() expression. (Stage 3 proposal)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+ function parseImportExpression(parser, context, pos) {
+ return finishNode(context, parser, pos, {
+ type: 'Import',
+ });
+ }
+ /**
+ * Parse meta property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Identifier
+ * @param pos Location
+ */
+ function parseMetaProperty(parser, context, meta, pos) {
+ return finishNode(context, parser, pos, {
+ meta,
+ type: 'MetaProperty',
+ property: parseIdentifier(parser, context),
+ });
+ }
+ /**
+ * Parse new expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NewExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNewExpressionOrMetaProperty(parser, context) {
+ const pos = getLocation(parser);
+ const id = parseIdentifier(parser, context);
+ if (consume(parser, context | exports.Context.DisallowEscapedKeyword, 16777229 /* Period */)) {
+ if (parser.tokenValue !== 'target' ||
+ !(context & (exports.Context.InParameter | exports.Context.InFunctionBody)))
+ tolerant(parser, context, 53 /* MetaNotInFunctionBody */);
+ return parseMetaProperty(parser, context, id, pos);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'NewExpression',
+ callee: parseImportOrMemberExpression(parser, context, pos),
+ arguments: parser.token === 50331659 /* LeftParen */ ? parseArgumentList(parser, context) : [],
+ });
+ }
+ /**
+ * Parse either import or member expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-MemberExpression)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportOrMemberExpression(parser, context, pos) {
+ const { token } = parser;
+ if (context & exports.Context.OptionsNext && token === 33566810 /* ImportKeyword */) {
+ // Invalid: '"new import(x)"'
+ if (lookahead(parser, context, nextTokenIsLeftParen))
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(token));
+ // Fixes cases like ''new import.meta','
+ return parseCallImportOrMetaProperty(parser, context);
+ }
+ return parseMemberExpression(parser, context, pos);
+ }
+ /**
+ * Parse super property
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SuperProperty)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSuperProperty(parser, context) {
+ // SuperProperty[Yield, Await]:
+ // super[Expression[+In, ?Yield, ?Await]]
+ // super.IdentifierName
+ const pos = getLocation(parser);
+ expect(parser, context, 33566813 /* SuperKeyword */);
+ switch (parser.token) {
+ case 50331659 /* LeftParen */:
+ // The super property has to be within a class constructor
+ if (!(context & exports.Context.AllowSuperProperty))
+ tolerant(parser, context, 54 /* BadSuperCall */);
+ break;
+ case 41943059 /* LeftBracket */:
+ case 16777229 /* Period */:
+ if (!(context & exports.Context.Method))
+ tolerant(parser, context, 55 /* UnexpectedSuper */);
+ break;
+ default:
+ tolerant(parser, context, 56 /* LoneSuper */);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'Super',
+ });
+ }
+ /**
+ * Parse template literal
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateLiteral)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseTemplateLiteral(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions: [],
+ quasis: [parseTemplateSpans(parser, context)],
+ });
+ }
+ /**
+ * Parse template head
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param cooked Cooked template value
+ * @param raw Raw template value
+ * @param pos Current location
+ */
+ function parseTemplateHead(parser, context, cooked = null, raw, pos) {
+ parser.token = consumeTemplateBrace(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked,
+ raw,
+ },
+ tail: false,
+ });
+ }
+ /**
+ * Parse template
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expression Expression AST node
+ * @param quasis Array of Template elements
+ */
+ function parseTemplate(parser, context, expressions = [], quasis = []) {
+ const pos = getLocation(parser);
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554440 /* TemplateCont */);
+ expressions.push(parseExpression(parser, context));
+ const t = getLocation(parser);
+ quasis.push(parseTemplateHead(parser, context, tokenValue, tokenRaw, pos));
+ if (parser.token === 33554441 /* TemplateTail */) {
+ quasis.push(parseTemplateSpans(parser, context, t));
+ }
+ else {
+ parseTemplate(parser, context, expressions, quasis);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'TemplateLiteral',
+ expressions,
+ quasis,
+ });
+ }
+ /**
+ * Parse template spans
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TemplateSpans)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param loc Current AST node location
+ */
+ function parseTemplateSpans(parser, context, pos = getLocation(parser)) {
+ const { tokenValue, tokenRaw } = parser;
+ expect(parser, context, 33554441 /* TemplateTail */);
+ return finishNode(context, parser, pos, {
+ type: 'TemplateElement',
+ value: {
+ cooked: tokenValue,
+ raw: tokenRaw,
+ },
+ tail: true,
+ });
+ }
+ /**
+ * Parses decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDecoratorList(parser, context) {
+ const pos = getLocation(parser);
+ return finishNode(context, parser, pos, {
+ type: 'Decorator',
+ expression: parseLeftHandSideExpression(parser, context, pos)
+ });
+ }
+ /**
+ * Parses a list of decorators
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDecorators(parser, context) {
+ const decoratorList = [];
+ while (consume(parser, context, 120 /* At */)) {
+ decoratorList.push(parseDecoratorList(parser, context | exports.Context.AllowDecorator));
+ }
+ return decoratorList;
+ } + + (function (Context) {
+ Context[Context["Empty"] = 0] = "Empty";
+ Context[Context["OptionsNext"] = 1] = "OptionsNext";
+ Context[Context["OptionsRanges"] = 2] = "OptionsRanges";
+ Context[Context["OptionsJSX"] = 4] = "OptionsJSX";
+ Context[Context["OptionsRaw"] = 8] = "OptionsRaw";
+ Context[Context["OptionsLoc"] = 16] = "OptionsLoc";
+ Context[Context["OptionsGlobalReturn"] = 32] = "OptionsGlobalReturn";
+ Context[Context["OptionsComments"] = 64] = "OptionsComments";
+ Context[Context["OptionsShebang"] = 128] = "OptionsShebang";
+ Context[Context["OptionsRawidentifiers"] = 256] = "OptionsRawidentifiers";
+ Context[Context["OptionsTolerant"] = 512] = "OptionsTolerant";
+ Context[Context["OptionsNode"] = 1024] = "OptionsNode";
+ Context[Context["OptionsExperimental"] = 2048] = "OptionsExperimental";
+ Context[Context["Strict"] = 4096] = "Strict";
+ Context[Context["Module"] = 8192] = "Module";
+ Context[Context["TaggedTemplate"] = 16384] = "TaggedTemplate";
+ Context[Context["InClass"] = 32768] = "InClass";
+ Context[Context["AllowIn"] = 65536] = "AllowIn";
+ Context[Context["Async"] = 131072] = "Async";
+ Context[Context["Yield"] = 262144] = "Yield";
+ Context[Context["InParameter"] = 524288] = "InParameter";
+ Context[Context["InFunctionBody"] = 1048576] = "InFunctionBody";
+ Context[Context["AllowSingleStatement"] = 2097152] = "AllowSingleStatement";
+ Context[Context["BlockScope"] = 4194304] = "BlockScope";
+ Context[Context["ForStatement"] = 8388608] = "ForStatement";
+ Context[Context["RequireIdentifier"] = 16777216] = "RequireIdentifier";
+ Context[Context["Method"] = 33554432] = "Method";
+ Context[Context["AllowSuperProperty"] = 67108864] = "AllowSuperProperty";
+ Context[Context["InParen"] = 134217728] = "InParen";
+ Context[Context["InJSXChild"] = 268435456] = "InJSXChild";
+ Context[Context["DisallowEscapedKeyword"] = 536870912] = "DisallowEscapedKeyword";
+ Context[Context["AllowDecorator"] = 1073741824] = "AllowDecorator";
+ Context[Context["LocationTracker"] = 18] = "LocationTracker";
+ })(exports.Context || (exports.Context = {}));
+ (function (Flags) {
+ Flags[Flags["None"] = 0] = "None";
+ Flags[Flags["NewLine"] = 1] = "NewLine";
+ Flags[Flags["AllowBinding"] = 2] = "AllowBinding";
+ Flags[Flags["AllowDestructuring"] = 4] = "AllowDestructuring";
+ Flags[Flags["SimpleParameterList"] = 8] = "SimpleParameterList";
+ Flags[Flags["InSwitchStatement"] = 16] = "InSwitchStatement";
+ Flags[Flags["InIterationStatement"] = 32] = "InIterationStatement";
+ Flags[Flags["HasStrictReserved"] = 64] = "HasStrictReserved";
+ Flags[Flags["HasOctal"] = 128] = "HasOctal";
+ Flags[Flags["SimpleAssignmentTarget"] = 256] = "SimpleAssignmentTarget";
+ Flags[Flags["HasProtoField"] = 512] = "HasProtoField";
+ Flags[Flags["StrictFunctionName"] = 1024] = "StrictFunctionName";
+ Flags[Flags["StrictEvalArguments"] = 2048] = "StrictEvalArguments";
+ Flags[Flags["InFunctionBody"] = 4096] = "InFunctionBody";
+ Flags[Flags["HasAwait"] = 8192] = "HasAwait";
+ Flags[Flags["HasYield"] = 16384] = "HasYield";
+ Flags[Flags["EscapedKeyword"] = 32768] = "EscapedKeyword";
+ Flags[Flags["HasConstructor"] = 65536] = "HasConstructor";
+ })(exports.Flags || (exports.Flags = {}));
+ (function (Labels) {
+ Labels[Labels["None"] = 0] = "None";
+ Labels[Labels["NotNested"] = 1] = "NotNested";
+ Labels[Labels["Nested"] = 2] = "Nested";
+ })(exports.Labels || (exports.Labels = {}));
+ (function (NumericState) {
+ NumericState[NumericState["None"] = 0] = "None";
+ NumericState[NumericState["SeenSeparator"] = 1] = "SeenSeparator";
+ NumericState[NumericState["EigthOrNine"] = 2] = "EigthOrNine";
+ NumericState[NumericState["Float"] = 4] = "Float";
+ NumericState[NumericState["BigInt"] = 8] = "BigInt";
+ })(exports.NumericState || (exports.NumericState = {}));
+ (function (ScannerState) {
+ ScannerState[ScannerState["None"] = 0] = "None";
+ ScannerState[ScannerState["NewLine"] = 1] = "NewLine";
+ ScannerState[ScannerState["LastIsCR"] = 2] = "LastIsCR";
+ })(exports.ScannerState || (exports.ScannerState = {}));
+ (function (ModifierState) {
+ ModifierState[ModifierState["None"] = 0] = "None";
+ ModifierState[ModifierState["Generator"] = 1] = "Generator";
+ ModifierState[ModifierState["Await"] = 2] = "Await";
+ })(exports.ModifierState || (exports.ModifierState = {}));
+ (function (CoverParenthesizedState) {
+ CoverParenthesizedState[CoverParenthesizedState["None"] = 0] = "None";
+ CoverParenthesizedState[CoverParenthesizedState["SequenceExpression"] = 1] = "SequenceExpression";
+ CoverParenthesizedState[CoverParenthesizedState["HasEvalOrArguments"] = 2] = "HasEvalOrArguments";
+ CoverParenthesizedState[CoverParenthesizedState["HasReservedWords"] = 4] = "HasReservedWords";
+ CoverParenthesizedState[CoverParenthesizedState["HasYield"] = 8] = "HasYield";
+ CoverParenthesizedState[CoverParenthesizedState["HasBinding"] = 16] = "HasBinding";
+ })(exports.CoverParenthesizedState || (exports.CoverParenthesizedState = {}));
+ (function (Escape) {
+ Escape[Escape["Empty"] = -1] = "Empty";
+ Escape[Escape["StrictOctal"] = -2] = "StrictOctal";
+ Escape[Escape["EightOrNine"] = -3] = "EightOrNine";
+ Escape[Escape["InvalidHex"] = -4] = "InvalidHex";
+ Escape[Escape["OutOfRange"] = -5] = "OutOfRange";
+ })(exports.Escape || (exports.Escape = {}));
+ (function (RegexFlags) {
+ RegexFlags[RegexFlags["Empty"] = 0] = "Empty";
+ RegexFlags[RegexFlags["IgnoreCase"] = 1] = "IgnoreCase";
+ RegexFlags[RegexFlags["Global"] = 2] = "Global";
+ RegexFlags[RegexFlags["Multiline"] = 4] = "Multiline";
+ RegexFlags[RegexFlags["Unicode"] = 8] = "Unicode";
+ RegexFlags[RegexFlags["Sticky"] = 16] = "Sticky";
+ RegexFlags[RegexFlags["DotAll"] = 32] = "DotAll";
+ })(exports.RegexFlags || (exports.RegexFlags = {}));
+ (function (CoverCallState) {
+ CoverCallState[CoverCallState["Empty"] = 0] = "Empty";
+ CoverCallState[CoverCallState["SeenSpread"] = 1] = "SeenSpread";
+ CoverCallState[CoverCallState["HasSpread"] = 2] = "HasSpread";
+ CoverCallState[CoverCallState["SimpleParameter"] = 4] = "SimpleParameter";
+ CoverCallState[CoverCallState["EvalOrArguments"] = 8] = "EvalOrArguments";
+ CoverCallState[CoverCallState["Yield"] = 16] = "Yield";
+ CoverCallState[CoverCallState["Await"] = 32] = "Await";
+ })(exports.CoverCallState || (exports.CoverCallState = {}));
+ (function (RegexState) {
+ RegexState[RegexState["Empty"] = 0] = "Empty";
+ RegexState[RegexState["Escape"] = 1] = "Escape";
+ RegexState[RegexState["Class"] = 2] = "Class";
+ })(exports.RegexState || (exports.RegexState = {}));
+ (function (ObjectState) {
+ ObjectState[ObjectState["None"] = 0] = "None";
+ ObjectState[ObjectState["Async"] = 1] = "Async";
+ ObjectState[ObjectState["Generator"] = 2] = "Generator";
+ ObjectState[ObjectState["Getter"] = 4] = "Getter";
+ ObjectState[ObjectState["Setter"] = 8] = "Setter";
+ ObjectState[ObjectState["Computed"] = 16] = "Computed";
+ ObjectState[ObjectState["Method"] = 32] = "Method";
+ ObjectState[ObjectState["Shorthand"] = 64] = "Shorthand";
+ ObjectState[ObjectState["Static"] = 128] = "Static";
+ ObjectState[ObjectState["Constructor"] = 256] = "Constructor";
+ ObjectState[ObjectState["Heritage"] = 512] = "Heritage";
+ })(exports.ObjectState || (exports.ObjectState = {}));
+ /**
+ * Validate break and continue statement
+ *
+ * @param parser Parser object
+ * @param label label
+ * @param isContinue true if validation continue statement
+ */
+ function validateBreakOrContinueLabel(parser, context, label, isContinue) {
+ const state = hasLabel(parser, label);
+ if (!state)
+ tolerant(parser, context, 32 /* UnknownLabel */, label);
+ if (isContinue && !(state & exports.Labels.Nested))
+ tolerant(parser, context, 31 /* IllegalContinue */, label);
+ }
+ /**
+ * Add label to the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+ function addLabel(parser, label) {
+ if (parser.labelSet === undefined)
+ parser.labelSet = {};
+ parser.labelSet[`$${label}`] = isIterationStatement(parser.token) ? exports.Labels.Nested : exports.Labels.NotNested;
+ }
+ /**
+ * Remove label from the stack
+ *
+ * @param parser Parser object
+ * @param label label
+ */
+ function popLabel(parser, label) {
+ parser.labelSet[`$${label}`] = exports.Labels.None;
+ }
+ /**
+ * Returns either true or false. Depends if the label exist.
+ *
+ * @param parser Parser object
+ * @param label Label
+ */
+ function hasLabel(parser, label) {
+ return !parser.labelSet ? exports.Labels.None : parser.labelSet[`$${label}`];
+ }
+ /**
+ * Finish each the node for each parse. Set line / and column on the node if the
+ * options are set for it
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param meta Line / column
+ * @param node AST node
+ */
+ function finishNode(context, parser, meta, node) {
+ const { lastIndex, lastLine, lastColumn, sourceFile, index } = parser;
+ if (context & exports.Context.LocationTracker) {
+ if (context & exports.Context.OptionsRanges) {
+ node.start = meta.index;
+ node.end = lastIndex;
+ }
+ if (context & exports.Context.OptionsLoc) {
+ node.loc = {
+ start: { line: meta.line, column: meta.column },
+ end: { line: lastLine, column: lastColumn }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ return node;
+ }
+ /**
+ * Consumes the next token. If the consumed token is not of the expected type
+ * then report an error and return null. Otherwise return true.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ * @param Err Optionally error message to be thrown
+ */
+ function expect(parser, context, token, err = 1 /* UnexpectedToken */) {
+ if (parser.token !== token)
+ report(parser, err, tokenDesc(parser.token));
+ nextToken(parser, context);
+ return true;
+ }
+ /**
+ * If the next token matches the given token, this consumes the token
+ * and returns true. Otherwise return false.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param t Token
+ */
+ function consume(parser, context, token) {
+ if (parser.token !== token)
+ return false;
+ nextToken(parser, context);
+ return true;
+ }
+ /**
+ * Advance and return the next token in the stream
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextToken(parser, context) {
+ parser.lastIndex = parser.index;
+ parser.lastLine = parser.line;
+ parser.lastColumn = parser.column;
+ return (parser.token = scan(parser, context));
+ }
+ const hasBit = (mask, flags) => (mask & flags) === flags;
+ /**
+ * Automatic Semicolon Insertion
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function consumeSemicolon(parser, context) {
+ return parser.token & 1048576 /* ASI */ || parser.flags & exports.Flags.NewLine
+ ? consume(parser, context, 17825809 /* Semicolon */)
+ : report(parser, !(context & exports.Context.Async) && parser.token & 262144 /* IsAwait */ ? 38 /* AwaitOutsideAsync */ : 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ /**
+ * Bit fiddle current grammar state and keep track of the state during the parse and restore
+ * it back to original state after finish parsing or throw.
+ *
+ * Ideas for this is basicly from V8 and SM, but also the Esprima parser does this in a similar way.
+ *
+ * However this implementation is an major improvement over similiar implementations, and
+ * does not require additonal bitmasks to be set / unset during the parsing outside this function.
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ * @param errMsg Optional error message
+ */
+ function parseExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= exports.Flags.AllowBinding | exports.Flags.AllowDestructuring;
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // If there exist an pending expression error, we throw an error at
+ // the same location it was recorded
+ if (!!parser.pendingExpressionError) {
+ const { error, line, column, index } = parser.pendingExpressionError;
+ constructError(parser, context, index, line, column, error);
+ }
+ // Here we - just in case - disallow both binding and destructuring
+ // and only set the bitmaks if the previous flags (before the callback)
+ // is positive.
+ // Note that this bitmasks may have been turned off during parsing
+ // the callback
+ parser.flags &= ~(exports.Flags.AllowBinding | exports.Flags.AllowDestructuring);
+ if (flags & exports.Flags.AllowBinding)
+ parser.flags |= exports.Flags.AllowBinding;
+ if (flags & exports.Flags.AllowDestructuring)
+ parser.flags |= exports.Flags.AllowDestructuring;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+ }
+ /**
+ * Restor current grammar to previous state, or unset necessary bitmasks
+ *
+ * @param parser Parser state
+ * @param context Context mask
+ * @param callback Callback function
+ */
+ function restoreExpressionCoverGrammar(parser, context, callback) {
+ const { flags, pendingExpressionError } = parser;
+ parser.flags |= exports.Flags.AllowBinding | exports.Flags.AllowDestructuring;
+ // Clear pending expression error
+ parser.pendingExpressionError = undefined;
+ const res = callback(parser, context);
+ // Both the previous bitmasks and bitmasks set during parsing the callback
+ // has to be positive for us to allow further binding or destructuring.
+ // Note that we allow both before the callback, so this is the only thing
+ // we need to check for.
+ if (!(parser.flags & exports.Flags.AllowBinding) || !(flags & exports.Flags.AllowBinding)) {
+ parser.flags &= ~exports.Flags.AllowBinding;
+ }
+ if (!(parser.flags & exports.Flags.AllowDestructuring) || !(flags & exports.Flags.AllowDestructuring)) {
+ parser.flags &= ~exports.Flags.AllowDestructuring;
+ }
+ // Here we either
+ // 1) restore to previous pending expression error
+ // or
+ // 2) if a pending expression error have been set during the parse (*only in object literal*)
+ // we overwrite previous error, and keep the new one
+ parser.pendingExpressionError = pendingExpressionError || parser.pendingExpressionError;
+ return res;
+ }
+ /**
+ * Set / unset yield / await context masks based on the
+ * ModifierState masks before invoking the callback and
+ * returning it's content
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param state Modifier state
+ * @param callback Callback function to be invoked
+ * @param methodState Optional Objectstate.
+ */
+ function swapContext(parser, context, state, callback, methodState = exports.ObjectState.None) {
+ context &= ~(exports.Context.Async | exports.Context.Yield | exports.Context.InParameter);
+ if (state & exports.ModifierState.Generator)
+ context |= exports.Context.Yield;
+ if (state & exports.ModifierState.Await)
+ context |= exports.Context.Async;
+ return callback(parser, context, methodState);
+ }
+ /**
+ * Validates function params
+ *
+ * Note! In case anyone want to enable full scoping, replace 'paramSet' with an similiar
+ * object on the parser object itself. Then push / set the tokenValue to
+ * it an use an bitmask to mark it as an 'variable' not 'blockscope'. Then when
+ * implementing lexical scoping, you can use that for validation.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param params Array of token values
+ */
+ function validateParams(parser, context, params) {
+ const paramSet = new Map();
+ for (let i = 0; i < params.length; i++) {
+ const key = `@${params[i]}`;
+ if (paramSet.get(key)) {
+ tolerant(parser, context, 81 /* ParamDupe */);
+ }
+ else
+ paramSet.set(key, true);
+ }
+ }
+ /**
+ * Reinterpret various expressions as pattern
+ * This is only used for assignment and arrow parameter list
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param node AST node
+ */
+ const reinterpret = (parser, context, node) => {
+ switch (node.type) {
+ case 'Identifier':
+ if (context & exports.Context.Strict && nameIsArgumentsOrEval(node.name))
+ report(parser, 3 /* InvalidEscapedReservedWord */);
+ case 'ArrayPattern':
+ case 'AssignmentPattern':
+ case 'ObjectPattern':
+ case 'RestElement':
+ case 'MetaProperty':
+ return;
+ case 'ArrayExpression':
+ node.type = 'ArrayPattern';
+ for (let i = 0; i < node.elements.length; ++i) {
+ // skip holes in pattern
+ if (node.elements[i] !== null) {
+ reinterpret(parser, context, node.elements[i]);
+ }
+ }
+ return;
+ case 'ObjectExpression':
+ node.type = 'ObjectPattern';
+ for (let i = 0; i < node.properties.length; i++) {
+ reinterpret(parser, context, node.properties[i]);
+ }
+ return;
+ case 'Property':
+ reinterpret(parser, context, node.value);
+ return;
+ case 'SpreadElement':
+ node.type = 'RestElement';
+ if (node.argument.type !== 'ArrayExpression' &&
+ node.argument.type !== 'ObjectExpression' &&
+ !isValidSimpleAssignmentTarget(node.argument)) {
+ tolerant(parser, context, 71 /* RestDefaultInitializer */);
+ }
+ reinterpret(parser, context, node.argument);
+ break;
+ case 'AssignmentExpression':
+ node.type = 'AssignmentPattern';
+ delete node.operator; // operator is not relevant for assignment pattern
+ reinterpret(parser, context, node.left); // recursive descent
+ return;
+ case 'MemberExpression':
+ if (!(context & exports.Context.InParameter))
+ return;
+ // Fall through
+ default:
+ tolerant(parser, context, context & exports.Context.InParameter ? 77 /* NotBindable */ : 73 /* InvalidDestructuringTarget */, node.type);
+ }
+ };
+ /**
+ * Does a lookahead.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param callback Callback function to be invoked
+ */
+ function lookahead(parser, context, callback) {
+ const { tokenValue, flags, line, column, startColumn, index, lastColumn, startLine, lastLine, lastIndex, startIndex, tokenRaw, token, lastValue, tokenRegExp, labelSet, errors, errorLocation, pendingExpressionError } = parser;
+ const res = callback(parser, context);
+ parser.index = index;
+ parser.token = token;
+ parser.tokenValue = tokenValue;
+ parser.tokenValue = tokenValue;
+ parser.flags = flags;
+ parser.line = line;
+ parser.column = column;
+ parser.tokenRaw = tokenRaw;
+ parser.lastValue = lastValue;
+ parser.startColumn = startColumn;
+ parser.lastColumn = lastColumn;
+ parser.startLine = startLine;
+ parser.lastLine = lastLine;
+ parser.lastIndex = lastIndex;
+ parser.startIndex = startIndex;
+ parser.tokenRegExp = tokenRegExp;
+ parser.labelSet = labelSet;
+ parser.errors = errors;
+ parser.errorLocation = errorLocation;
+ parser.tokenRegExp = tokenRegExp;
+ parser.pendingExpressionError = pendingExpressionError;
+ return res;
+ }
+ /**
+ * Returns true if this an valid simple assignment target
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isValidSimpleAssignmentTarget(node) {
+ return node.type === 'Identifier' || node.type === 'MemberExpression' ? true : false;
+ }
+ /**
+ * Get current node location
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function getLocation(parser) {
+ return {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+ }
+ /**
+ * Returns true if this is an valid identifier
+ *
+ * @param context Context masks
+ * @param t Token
+ */
+ function isValidIdentifier(context, t) {
+ if (context & exports.Context.Strict) {
+ if (context & exports.Context.Module && t & 262144 /* IsAwait */)
+ return false;
+ if (t & 1073741824 /* IsYield */)
+ return false;
+ return (t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (t & 69632 /* Contextual */) === 69632 /* Contextual */;
+ }
+ return ((t & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (t & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (t & 20480 /* FutureReserved */) === 20480 /* FutureReserved */);
+ }
+ /**
+ * Returns true if this an valid lexical binding and not an identifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isLexical(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return !!(token & (131072 /* IsIdentifier */ | 8388608 /* IsBindingPattern */ | 1073741824 /* IsYield */ | 262144 /* IsAwait */) ||
+ token === 33574984 /* LetKeyword */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */);
+ }
+ /**
+ * Returns true if this is end of case or default clauses
+ *
+ * @param parser Parser object
+ */
+ function isEndOfCaseOrDefaultClauses(parser) {
+ return (parser.token === 12368 /* DefaultKeyword */ || parser.token === 17825807 /* RightBrace */ || parser.token === 12363 /* CaseKeyword */);
+ }
+ /**
+ * Validates if the next token in the stream is a left paren or a period
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsLeftParenOrPeriod(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */ || parser.token === 16777229 /* Period */;
+ }
+ /**
+ * Validates if the next token in the stream is a identifier or left paren
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenisIdentifierOrParen(parser, context) {
+ nextToken(parser, context);
+ const { token } = parser;
+ return token & (131072 /* IsIdentifier */ | 1073741824 /* IsYield */) || token === 50331659 /* LeftParen */;
+ }
+ /**
+ * Validates if the next token in the stream is left parenthesis.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsLeftParen(parser, context) {
+ nextToken(parser, context);
+ return parser.token === 50331659 /* LeftParen */;
+ }
+ /**
+ * Validates if the next token in the stream is a function keyword on the same line.
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function nextTokenIsFuncKeywordOnSameLine(parser, context) {
+ nextToken(parser, context);
+ return !(parser.flags & exports.Flags.NewLine) && parser.token === 33566808 /* FunctionKeyword */;
+ }
+ /**
+ * Checks if the property has any private field key
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function isPropertyWithPrivateFieldKey(expr) {
+ return !expr.property ? false : expr.property.type === 'PrivateName';
+ }
+ /**
+ * Parse and classify itendifier - similar method as in V8
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAndClassifyIdentifier(parser, context) {
+ const { token, tokenValue: name } = parser;
+ if (context & exports.Context.Strict) {
+ if (context & exports.Context.Module && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ || (token & 69632 /* Contextual */) === 69632 /* Contextual */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ if (context & exports.Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if (context & exports.Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 40 /* DisallowedInContext */, tokenDesc(parser.token));
+ if ((token & 131072 /* IsIdentifier */) === 131072 /* IsIdentifier */ ||
+ (token & 69632 /* Contextual */) === 69632 /* Contextual */ ||
+ (token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ return parseIdentifier(parser, context);
+ }
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ function nameIsArgumentsOrEval(value) {
+ return value === 'eval' || value === 'arguments';
+ }
+ /**
+ * Records an error from current position. If we report an error later, we'll do it from
+ * this position.
+ *
+ * @param parser Parser object
+ */
+ function setPendingError(parser) {
+ parser.errorLocation = {
+ line: parser.startLine,
+ column: parser.startColumn,
+ index: parser.startIndex
+ };
+ }
+ /**
+ * Returns tagName for JSX element
+ *
+ * @param elementName JSX Element name
+ */
+ function isEqualTagNames(elementName) {
+ // tslint:disable-next-line:switch-default | this switch is exhaustive
+ switch (elementName.type) {
+ case 'JSXIdentifier':
+ return elementName.name;
+ case 'JSXNamespacedName':
+ return `${isEqualTagNames(elementName.namespace)}:${isEqualTagNames(elementName.name)}`;
+ case 'JSXMemberExpression':
+ return `${isEqualTagNames(elementName.object)}.${isEqualTagNames(elementName.property)}`;
+ }
+ }
+ /**
+ * Returns true if this is an instance field ( stage 3 proposal)
+ *
+ * @param parser Parser object
+ */
+ function isInstanceField(parser) {
+ const { token } = parser;
+ return token === 17825807 /* RightBrace */ || token === 17825809 /* Semicolon */ || token === 83886109 /* Assign */;
+ }
+ /**
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param expr AST expressions
+ * @param prefix prefix
+ */
+ function validateUpdateExpression(parser, context, expr, prefix) {
+ if (context & exports.Context.Strict && nameIsArgumentsOrEval(expr.name)) {
+ tolerant(parser, context, 68 /* StrictLHSPrefixPostFix */, prefix);
+ }
+ if (!isValidSimpleAssignmentTarget(expr)) {
+ tolerant(parser, context, 5 /* InvalidLHSInAssignment */);
+ }
+ }
+ /**
+ * Record expression error
+ *
+ * @param parser Parser object
+ * @param error Error message
+ */
+ function setPendingExpressionError(parser, type) {
+ parser.pendingExpressionError = {
+ error: errorMessages[type],
+ line: parser.line,
+ column: parser.column,
+ index: parser.index
+ };
+ }
+ /**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+ function validateCoverParenthesizedExpression(parser, state) {
+ const { token } = parser;
+ if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= exports.Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= exports.CoverParenthesizedState.HasEvalOrArguments;
+ }
+ else if ((token & 20480 /* FutureReserved */) === 20480 /* FutureReserved */) {
+ setPendingError(parser);
+ state |= exports.CoverParenthesizedState.HasReservedWords;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ parser.flags |= exports.Flags.HasAwait;
+ }
+ }
+ return state;
+ }
+ /**
+ * Validate coer parenthesized expression
+ *
+ * @param parser Parser object
+ * @param state CoverParenthesizedState
+ */
+ function validateAsyncArgumentList(parser, context, state) {
+ const { token } = parser;
+ if (!(parser.flags & exports.Flags.AllowBinding)) {
+ tolerant(parser, context, 77 /* NotBindable */);
+ }
+ else if (token & 8388608 /* IsBindingPattern */) {
+ parser.flags |= exports.Flags.SimpleParameterList;
+ }
+ else {
+ if ((token & 4194304 /* IsEvalOrArguments */) === 4194304 /* IsEvalOrArguments */) {
+ setPendingError(parser);
+ state |= exports.CoverCallState.EvalOrArguments;
+ }
+ else if ((token & 262144 /* IsAwait */) === 262144 /* IsAwait */) {
+ setPendingError(parser);
+ state |= exports.CoverCallState.Await;
+ }
+ else if ((token & 1073741824 /* IsYield */) === 1073741824 /* IsYield */) {
+ setPendingError(parser);
+ state |= exports.CoverCallState.Yield;
+ }
+ }
+ return state;
+ }
+ /**
+ * Returns true if iteration statement. Otherwise return false,
+ *
+ * @param t Token
+ */
+ function isIterationStatement(t) {
+ return t === 12369 /* DoKeyword */ || t === 12386 /* WhileKeyword */ || t === 12374 /* ForKeyword */;
+ }
+ /**
+ * Returns true if in or of token. Otherwise return false,
+ *
+ * @param t Token
+ */
+ function isInOrOf(t) {
+ return t === 69746 /* OfKeyword */ || t === 167786289 /* InKeyword */;
+ } + + /*@internal*/
+ const errorMessages = {
+ [0 /* Unexpected */]: 'Unexpected token',
+ [1 /* UnexpectedToken */]: 'Unexpected token \'%0\'',
+ [2 /* ExpectedToken */]: 'Expected token \'%0\'',
+ [3 /* InvalidEscapedReservedWord */]: 'Keyword must not contain escaped characters',
+ [4 /* UnexpectedKeyword */]: 'Keyword \'%0\' is reserved',
+ [5 /* InvalidLHSInAssignment */]: 'Invalid left-hand side in assignment',
+ [6 /* UnterminatedString */]: 'Unterminated string literal',
+ [7 /* UnterminatedRegExp */]: 'Unterminated regular expression literal',
+ [8 /* UnterminatedComment */]: 'Unterminated MultiLineComment',
+ [9 /* UnterminatedTemplate */]: 'Unterminated template literal',
+ [10 /* UnexpectedChar */]: 'Invalid character \'%0\'',
+ [11 /* StrictOctalEscape */]: 'Octal escapes are not allowed in strict mode',
+ [13 /* InvalidEightAndNine */]: 'Escapes \\8 or \\9 are not syntactically valid escapes',
+ [14 /* UnicodeOutOfRange */]: 'Unicode escape code point out of range',
+ [15 /* DuplicateRegExpFlag */]: 'Duplicate regular expression flag \'%0\'',
+ [16 /* UnexpectedTokenRegExpFlag */]: 'Unexpected regular expression flag \'%0\'',
+ [17 /* StrictLHSAssignment */]: 'Eval or arguments can\'t be assigned to in strict mode code',
+ [18 /* IllegalReturn */]: 'Illegal return statement',
+ [19 /* StrictFunction */]: 'In strict mode code, functions can only be declared at top level or inside a block',
+ [20 /* SloppyFunction */]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+ [21 /* ForbiddenAsStatement */]: '%0 can\'t appear in single-statement context',
+ [22 /* GeneratorInSingleStatementContext */]: 'Generators can only be declared at the top level or inside a block',
+ [23 /* ForAwaitNotOf */]: '\'for await\' loop should be used with \'of\'',
+ [24 /* DeclarationMissingInitializer */]: 'Missing initializer in %0 declaration',
+ [25 /* ForInOfLoopInitializer */]: '\'for-%0\' loop variable declaration may not have an initializer',
+ [26 /* ForInOfLoopMultiBindings */]: 'Invalid left-hand side in for-%0 loop: Must have a single binding.',
+ [27 /* LetInLexicalBinding */]: 'let is disallowed as a lexically bound name',
+ [28 /* UnexpectedLexicalDeclaration */]: 'Lexical declaration cannot appear in a single-statement context',
+ [29 /* LabelRedeclaration */]: 'Label \'%0\' has already been declared',
+ [30 /* InvalidNestedStatement */]: '%0 statement must be nested within an iteration statement',
+ [31 /* IllegalContinue */]: 'Illegal continue statement: \'%0\' does not denote an iteration statement',
+ [32 /* UnknownLabel */]: 'Undefined label \'%0\'',
+ [33 /* MultipleDefaultsInSwitch */]: 'More than one default clause in switch statement',
+ [34 /* ImportExportDeclAtTopLevel */]: '%0 declarations may only appear at top level of a module',
+ [35 /* AsyncFunctionInSingleStatementContext */]: 'Async functions can only be declared at the top level or inside a block',
+ [36 /* InvalidLineBreak */]: 'No line break is allowed after \'%0\'',
+ [37 /* StrictModeWith */]: 'Strict mode code may not include a with statement',
+ [38 /* AwaitOutsideAsync */]: 'Await is only valid in async functions',
+ [39 /* UnNamedFunctionDecl */]: 'Function declaration must have a name in this context',
+ [12 /* DuplicateConstructor */]: 'Duplicate constructor method in class',
+ [40 /* DisallowedInContext */]: '\'%0\' may not be used as an identifier in this context',
+ [43 /* StrictDelete */]: 'Delete of an unqualified identifier in strict mode',
+ [44 /* DeletePrivateField */]: 'Private fields can not be deleted',
+ [41 /* PrivateFieldConstructor */]: 'Classes may not have a private field named \'#constructor\'',
+ [42 /* PublicFieldConstructor */]: 'Classes may not have a field named \'constructor\'',
+ [45 /* InvalidConstructor */]: 'Class constructor may not be a \'%0\'',
+ [46 /* UnexpectedReserved */]: 'Unexpected reserved word',
+ [47 /* StrictEvalArguments */]: 'Unexpected eval or arguments in strict mode',
+ [48 /* AwaitBindingIdentifier */]: '\'await\' is not a valid identifier inside an async function',
+ [49 /* YieldBindingIdentifier */]: '\'yield\' is not a valid identifier inside an generator function',
+ [50 /* UnexpectedStrictReserved */]: 'Unexpected strict mode reserved word',
+ [52 /* AwaitInParameter */]: 'Await expression not allowed in formal parameter',
+ [51 /* YieldInParameter */]: 'Yield expression not allowed in formal parameter',
+ [53 /* MetaNotInFunctionBody */]: 'new.target only allowed within functions',
+ [54 /* BadSuperCall */]: 'super() is not allowed in this context',
+ [55 /* UnexpectedSuper */]: 'Member access from super not allowed in this context',
+ [56 /* LoneSuper */]: 'Only "(" or "." or "[" are allowed after \'super\'',
+ [57 /* YieldReservedKeyword */]: '\'yield\' is a reserved keyword within generator function bodies',
+ [58 /* ContinuousNumericSeparator */]: 'Only one underscore is allowed as numeric separator',
+ [59 /* TrailingNumericSeparator */]: 'Numeric separators are not allowed at the end of numeric literals',
+ [60 /* ZeroDigitNumericSeparator */]: 'Numeric separator can not be used after leading 0.',
+ [61 /* StrictOctalLiteral */]: 'Legacy octal literals are not allowed in strict mode',
+ [62 /* InvalidLhsInAssignment */]: 'Invalid left-hand side in assignment',
+ [63 /* DuplicateProto */]: 'Property name __proto__ appears more than once in object literal',
+ [64 /* IllegalUseStrict */]: 'Illegal \'use strict\' directive in function with non-simple parameter list',
+ [65 /* StaticPrototype */]: 'Classes may not have a static property named \'prototype\'',
+ [66 /* AccessorWrongArgs */]: '%0 functions must have %1 argument%2',
+ [67 /* BadSetterRestParameter */]: 'Setter function argument must not be a rest parameter',
+ [68 /* StrictLHSPrefixPostFix */]: '%0 increment/decrement may not have eval or arguments operand in strict mode',
+ [69 /* InvalidElisonInObjPropList */]: 'Elision not allowed in object property list',
+ [70 /* ElementAfterRest */]: 'Rest element must be last element',
+ [72 /* ElementAfterSpread */]: 'Spread element must be last element',
+ [71 /* RestDefaultInitializer */]: 'Rest parameter may not have a default initializer',
+ [73 /* InvalidDestructuringTarget */]: 'Invalid destructuring assignment target',
+ [74 /* UnexpectedSurrogate */]: 'Unexpected surrogate pair',
+ [75 /* MalformedEscape */]: 'Malformed %0 character escape sequence',
+ [76 /* TemplateOctalLiteral */]: 'Template literals may not contain octal escape sequences',
+ [77 /* NotBindable */]: 'Invalid binding pattern',
+ [78 /* ParamAfterRest */]: 'Rest parameter must be last formal parameter',
+ [79 /* NoCatchOrFinally */]: 'Missing catch or finally after try',
+ [80 /* NewlineAfterThrow */]: 'Illegal newline after throw',
+ [81 /* ParamDupe */]: 'Duplicate parameter name not allowed in this context',
+ [82 /* AsAfterImportStart */]: 'Missing keyword \'as\' after import *',
+ [83 /* LabelNoColon */]: 'Labels must be followed by a \':\'',
+ [84 /* NonEmptyJSXExpression */]: 'JSX attributes must only be assigned a non-empty \'expression\'',
+ [85 /* ExpectedJSXClosingTag */]: 'Expected corresponding JSX closing tag for %0',
+ [86 /* AdjacentJSXElements */]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+ [87 /* InvalidJSXAttributeValue */]: 'Invalid JSX attribute value',
+ [88 /* RestWithComma */]: 'Rest element may not have a trailing comma',
+ [89 /* UndefinedUnicodeCodePoint */]: 'Undefined Unicode code-point',
+ [90 /* HtmlCommentInModule */]: 'HTML comments are not allowed in modules',
+ [91 /* InvalidCoverInitializedName */]: 'Invalid shorthand property initializer',
+ [92 /* TrailingDecorators */]: 'Trailing decorator may be followed by method',
+ [93 /* GeneratorConstructor */]: 'Decorators can\'t be used with a constructor',
+ [94 /* InvalidRestBindingPattern */]: '`...` must be followed by an identifier in declaration contexts',
+ };
+ /**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param index The 0-based end index of the error.
+ * @param line The 0-based line position of the error.
+ * @param column The 0-based column position of the error.
+ * @param parser The 0-based end index of the current node.
+ * @param description Error description
+ */
+ /*@internal*/
+ function constructError(parser, context, index, line, column, description) {
+ const error = new SyntaxError(`Line ${line}, column ${column}: ${description}`);
+ error.index = index;
+ error.line = line;
+ error.column = column;
+ error.description = description;
+ if (context & exports.Context.OptionsTolerant) {
+ parser.errors.push(error);
+ }
+ else
+ throw error;
+ }
+ /**
+ * Collect line, index, and colum from either the recorded error
+ * or directly from the parser and returns it
+ *
+ * @param parser Parser instance
+ */
+ function getErrorLocation(parser) {
+ let { index, startLine: line, startColumn: column } = parser;
+ const errorLoc = parser.errorLocation;
+ if (!!errorLoc) {
+ index = errorLoc.index;
+ line = errorLoc.line;
+ column = errorLoc.column;
+ }
+ return { index, line, column };
+ }
+ /**
+ * Throws an error
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+ /*@internal*/
+ function report(parser, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, exports.Context.Empty, index, line, column, errorMessage);
+ }
+ /**
+ * If in tolerant mode, all errors are pushed to a top-level error array containing
+ * otherwise throws
+ *
+ * @param parser Parser instance
+ * @param context Context masks
+ * @param type Error type
+ * @param params Error params
+ */
+ /*@internal*/
+ function tolerant(parser, context, type, ...params) {
+ const { index, line, column } = getErrorLocation(parser);
+ const errorMessage = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ constructError(parser, context, index, line, column, errorMessage);
+ } + + // Declarations
+ /**
+ * Parses class declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseClassDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ let decorators = [];
+ if (context & exports.Context.OptionsExperimental)
+ decorators = parseDecorators(parser, context);
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 33566797 /* ClassKeyword */);
+ const id = (context & exports.Context.RequireIdentifier && (parser.token !== 33685505 /* Identifier */))
+ ? null :
+ parseBindingIdentifier(parser, context | exports.Context.Strict | exports.Context.DisallowEscapedKeyword);
+ let state = exports.ObjectState.None;
+ let superClass = null;
+ if (consume(parser, context, 12372 /* ExtendsKeyword */)) {
+ superClass = parseLeftHandSideExpression(parser, context | exports.Context.Strict, pos);
+ state |= exports.ObjectState.Heritage;
+ }
+ const body = parseClassBodyAndElementList(parser, context & ~exports.Context.RequireIdentifier | exports.Context.Strict | exports.Context.InClass, state);
+ return finishNode(context, parser, pos, context & exports.Context.OptionsExperimental ? {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body,
+ decorators
+ } : {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body
+ });
+ }
+ /**
+ * Parses function declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-FunctionDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseFunctionDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ let isGenerator = exports.ModifierState.None;
+ if (consume(parser, context, 167774771 /* Multiply */)) {
+ if (context & exports.Context.AllowSingleStatement && !(context & exports.Context.InFunctionBody)) {
+ tolerant(parser, context, 22 /* GeneratorInSingleStatementContext */);
+ }
+ isGenerator = exports.ModifierState.Generator;
+ }
+ return parseFunctionDeclarationBody(parser, context, isGenerator, pos);
+ }
+ /**
+ * Parses out a function declartion body
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context mask
+ * @param state Modifier state
+ * @param pos Current location
+ */
+ function parseFunctionDeclarationBody(parser, context, state, pos) {
+ const { token } = parser;
+ let id = null;
+ if (context & exports.Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 49 /* YieldBindingIdentifier */);
+ if (context & exports.Context.Async && token & 262144 /* IsAwait */)
+ tolerant(parser, context, 48 /* AwaitBindingIdentifier */);
+ if (token !== 50331659 /* LeftParen */) {
+ id = parseBindingIdentifier(parser, context);
+ // Unnamed functions are forbidden in statement context.
+ }
+ else if (!(context & exports.Context.RequireIdentifier))
+ tolerant(parser, context, 39 /* UnNamedFunctionDecl */);
+ const { params, body } = swapContext(parser, context & ~(exports.Context.Method | exports.Context.AllowSuperProperty | exports.Context.RequireIdentifier), state, parseFormalListAndBody);
+ return finishNode(context, parser, pos, {
+ type: 'FunctionDeclaration',
+ params,
+ body,
+ async: !!(state & exports.ModifierState.Await),
+ generator: !!(state & exports.ModifierState.Generator),
+ expression: false,
+ id,
+ });
+ }
+ /**
+ * Parses async function or async generator declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 594028 /* AsyncKeyword */);
+ expect(parser, context, 33566808 /* FunctionKeyword */);
+ const isAwait = exports.ModifierState.Await;
+ const isGenerator = consume(parser, context, 167774771 /* Multiply */) ? exports.ModifierState.Generator : exports.ModifierState.None;
+ return parseFunctionDeclarationBody(parser, context, isGenerator | isAwait, pos);
+ }
+ /**
+ * VariableDeclaration :
+ * BindingIdentifier Initializeropt
+ * BindingPattern Initializer
+ *
+ * VariableDeclarationNoIn :
+ * BindingIdentifier InitializerNoInopt
+ * BindingPattern InitializerNoIn
+ *
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableDeclaration(parser, context, isConst) {
+ const pos = getLocation(parser);
+ const isBindingPattern = (parser.token & 8388608 /* IsBindingPattern */) !== 0;
+ const id = parseBindingIdentifierOrPattern(parser, context);
+ let init = null;
+ if (consume(parser, context | exports.Context.DisallowEscapedKeyword, 83886109 /* Assign */)) {
+ init = parseExpressionCoverGrammar(parser, context & ~(exports.Context.BlockScope | exports.Context.ForStatement), parseAssignmentExpression);
+ if (isInOrOf(parser.token) && (context & exports.Context.ForStatement || isBindingPattern)) {
+ if (parser.token === 167786289 /* InKeyword */) {
+ // https://github.com/tc39/test262/blob/master/test/annexB/language/statements/for-in/strict-initializer.js
+ if (context & (exports.Context.BlockScope | exports.Context.Strict | exports.Context.Async) || isBindingPattern) {
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ }
+ else
+ tolerant(parser, context, 25 /* ForInOfLoopInitializer */, tokenDesc(parser.token));
+ }
+ // Note: Initializers are required for 'const' and binding patterns
+ }
+ else if (!isInOrOf(parser.token) && (isConst || isBindingPattern)) {
+ tolerant(parser, context, 24 /* DeclarationMissingInitializer */, isConst ? 'const' : 'destructuring');
+ }
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclarator',
+ init,
+ id,
+ });
+ }
+ /**
+ * Parses variable declaration list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableDeclarationList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableDeclarationList(parser, context, isConst) {
+ const list = [parseVariableDeclaration(parser, context, isConst)];
+ while (consume(parser, context, 16777234 /* Comma */))
+ list.push(parseVariableDeclaration(parser, context, isConst));
+ if (context & exports.Context.ForStatement && isInOrOf(parser.token) && list.length !== 1) {
+ tolerant(parser, context, 26 /* ForInOfLoopMultiBindings */, tokenDesc(parser.token));
+ }
+ return list;
+ } + + // Statements
+ /**
+ * Parses statement list items
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementListItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseStatementListItem(parser, context) {
+ switch (parser.token) {
+ case 33566808 /* FunctionKeyword */:
+ return parseFunctionDeclaration(parser, context);
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ return parseClassDeclaration(parser, context);
+ case 33574984 /* LetKeyword */:
+ return parseLetOrExpressionStatement(parser, context | exports.Context.AllowIn);
+ case 33566793 /* ConstKeyword */:
+ return parseVariableStatement(parser, context | exports.Context.BlockScope | exports.Context.AllowIn);
+ case 594028 /* AsyncKeyword */:
+ return parseAsyncFunctionDeclarationOrStatement(parser, context);
+ case 33566810 /* ImportKeyword */: {
+ if (context & exports.Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod)) {
+ return parseExpressionStatement(parser, context | exports.Context.AllowIn);
+ }
+ }
+ case 12371 /* ExportKeyword */:
+ if (context & exports.Context.Module) {
+ tolerant(parser, context, 34 /* ImportExportDeclAtTopLevel */, tokenDesc(parser.token));
+ }
+ default:
+ return parseStatement(parser, context | exports.Context.AllowSingleStatement);
+ }
+ }
+ /**
+ * Parses statements
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseStatement(parser, context) {
+ switch (parser.token) {
+ case 33566791 /* VarKeyword */:
+ return parseVariableStatement(parser, context | exports.Context.AllowIn);
+ case 17825809 /* Semicolon */:
+ return parseEmptyStatement(parser, context);
+ case 33566814 /* SwitchKeyword */:
+ return parseSwitchStatement(parser, context);
+ case 41943052 /* LeftBrace */:
+ return parseBlockStatement(parser, context);
+ case 12380 /* ReturnKeyword */:
+ return parseReturnStatement(parser, context);
+ case 12377 /* IfKeyword */:
+ return parseIfStatement(parser, context);
+ case 12369 /* DoKeyword */:
+ return parseDoWhileStatement(parser, context);
+ case 12386 /* WhileKeyword */:
+ return parseWhileStatement(parser, context);
+ case 12387 /* WithKeyword */:
+ return parseWithStatement(parser, context);
+ case 12362 /* BreakKeyword */:
+ return parseBreakStatement(parser, context);
+ case 12366 /* ContinueKeyword */:
+ return parseContinueStatement(parser, context);
+ case 12367 /* DebuggerKeyword */:
+ return parseDebuggerStatement(parser, context);
+ case 302002272 /* ThrowKeyword */:
+ return parseThrowStatement(parser, context);
+ case 12385 /* TryKeyword */:
+ return parseTryStatement(parser, context | exports.Context.DisallowEscapedKeyword);
+ case 12374 /* ForKeyword */:
+ return parseForStatement(parser, context | exports.Context.ForStatement);
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ tolerant(parser, context, 35 /* AsyncFunctionInSingleStatementContext */);
+ }
+ return parseExpressionOrLabelledStatement(parser, context | exports.Context.AllowSingleStatement);
+ case 33566808 /* FunctionKeyword */:
+ // V8
+ tolerant(parser, context, context & exports.Context.Strict ? 19 /* StrictFunction */ : 20 /* SloppyFunction */);
+ case 33566797 /* ClassKeyword */:
+ tolerant(parser, context, 21 /* ForbiddenAsStatement */, tokenDesc(parser.token));
+ default:
+ return parseExpressionOrLabelledStatement(parser, context);
+ }
+ }
+ /**
+ * Parses empty statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-EmptyStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseEmptyStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'EmptyStatement'
+ });
+ }
+ /**
+ * Parses the continue statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ContinueStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseContinueStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ // Appearing of continue without an IterationStatement leads to syntax error
+ if (!(parser.flags & (exports.Flags.InSwitchStatement | exports.Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, tokenDesc(parser.token));
+ }
+ let label = null;
+ if (!(parser.flags & exports.Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, true);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ContinueStatement',
+ label
+ });
+ }
+ /**
+ * Parses the break statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BreakStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBreakStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let label = null;
+ if (!(parser.flags & exports.Flags.NewLine) && parser.token & (131072 /* IsIdentifier */ | 4096 /* Keyword */)) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context);
+ validateBreakOrContinueLabel(parser, context, tokenValue, false);
+ }
+ else if (!(parser.flags & (exports.Flags.InSwitchStatement | exports.Flags.InIterationStatement))) {
+ tolerant(parser, context, 30 /* InvalidNestedStatement */, 'break');
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'BreakStatement',
+ label
+ });
+ }
+ /**
+ * Parses the if statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-if-statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIfStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const consequent = parseConsequentOrAlternate(parser, context | exports.Context.DisallowEscapedKeyword);
+ const alternate = consume(parser, context, 12370 /* ElseKeyword */) ? parseConsequentOrAlternate(parser, context) : null;
+ return finishNode(context, parser, pos, {
+ type: 'IfStatement',
+ test,
+ consequent,
+ alternate
+ });
+ }
+ /**
+ * Parse either consequent or alternate. Supports AnnexB.
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseConsequentOrAlternate(parser, context) {
+ return context & exports.Context.Strict || parser.token !== 33566808 /* FunctionKeyword */
+ ? parseStatement(parser, context & ~exports.Context.AllowSingleStatement)
+ : parseFunctionDeclaration(parser, context);
+ }
+ /**
+ * Parses the debugger statement production
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DebuggerStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDebuggerStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'DebuggerStatement'
+ });
+ }
+ /**
+ * Parses try statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-TryStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseTryStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const block = parseBlockStatement(parser, context);
+ const handler = parser.token === 12364 /* CatchKeyword */ ? parseCatchBlock(parser, context) : null;
+ const finalizer = consume(parser, context, 12373 /* FinallyKeyword */) ? parseBlockStatement(parser, context) : null;
+ if (!handler && !finalizer)
+ tolerant(parser, context, 79 /* NoCatchOrFinally */);
+ return finishNode(context, parser, pos, {
+ type: 'TryStatement',
+ block,
+ handler,
+ finalizer
+ });
+ }
+ /**
+ * Parses catch block
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Catch)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCatchBlock(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ let param = null;
+ if (consume(parser, context, 50331659 /* LeftParen */)) {
+ const params = [];
+ param = parseBindingIdentifierOrPattern(parser, context, params);
+ validateParams(parser, context, params);
+ expect(parser, context, 16 /* RightParen */);
+ }
+ const body = parseBlockStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'CatchClause',
+ param,
+ body
+ });
+ }
+ /**
+ * Parses throw statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ThrowStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseThrowStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ if (parser.flags & exports.Flags.NewLine)
+ tolerant(parser, context, 80 /* NewlineAfterThrow */);
+ const argument = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ThrowStatement',
+ argument
+ });
+ }
+ /**
+ * Parses expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExpressionStatement(parser, context) {
+ const pos = getLocation(parser);
+ const expr = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+ }
+ /**
+ * Parse directive node
+ *
+ * * @see [Link](https://tc39.github.io/ecma262/#sec-directive-prologues-and-the-use-strict-directive)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDirective(parser, context) {
+ const pos = getLocation(parser);
+ const directive = parser.tokenRaw.slice(1, -1);
+ const expr = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr,
+ directive
+ });
+ }
+ /**
+ * Parses either expression or labelled statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-LabelledStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExpressionOrLabelledStatement(parser, context) {
+ const pos = getLocation(parser);
+ const { tokenValue, token } = parser;
+ const expr = parseExpression(parser, (context & ~(exports.Context.AllowSingleStatement | exports.Context.AllowDecorator)) | exports.Context.AllowIn);
+ if (token & (131072 /* IsIdentifier */ | 4096 /* Keyword */) && parser.token === 16777237 /* Colon */) {
+ // If within generator function bodies, we do it like this so we can throw an nice error message
+ if (context & exports.Context.Yield && token & 1073741824 /* IsYield */)
+ tolerant(parser, context, 57 /* YieldReservedKeyword */);
+ expect(parser, context, 16777237 /* Colon */, 83 /* LabelNoColon */);
+ if (hasLabel(parser, tokenValue))
+ tolerant(parser, context, 29 /* LabelRedeclaration */, tokenValue);
+ addLabel(parser, tokenValue);
+ const body = !(context & exports.Context.Strict) &&
+ context & exports.Context.AllowSingleStatement &&
+ parser.token === 33566808 /* FunctionKeyword */
+ ? parseFunctionDeclaration(parser, context)
+ : parseStatement(parser, context);
+ popLabel(parser, tokenValue);
+ return finishNode(context, parser, pos, {
+ type: 'LabeledStatement',
+ label: expr,
+ body
+ });
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExpressionStatement',
+ expression: expr
+ });
+ }
+ /**
+ * Parses do while statement
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseDoWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ const body = parseIterationStatement(parser, context);
+ expect(parser, context, 12386 /* WhileKeyword */);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ consume(parser, context, 17825809 /* Semicolon */);
+ return finishNode(context, parser, pos, {
+ type: 'DoWhileStatement',
+ body,
+ test
+ });
+ }
+ /**
+ * Parses while statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-WhileStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseWhileStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const test = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'WhileStatement',
+ test,
+ body
+ });
+ }
+ /**
+ * Parses block statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-BlockStatement)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Block)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseBlockStatement(parser, context) {
+ const pos = getLocation(parser);
+ const body = [];
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ body.push(parseStatementListItem(parser, context));
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'BlockStatement',
+ body
+ });
+ }
+ /**
+ * Parses return statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ReturnStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseReturnStatement(parser, context) {
+ const pos = getLocation(parser);
+ if (!(context & (exports.Context.OptionsGlobalReturn | exports.Context.InFunctionBody))) {
+ tolerant(parser, context, 18 /* IllegalReturn */);
+ }
+ if (parser.flags & exports.Flags.EscapedKeyword)
+ tolerant(parser, context, 3 /* InvalidEscapedReservedWord */);
+ nextToken(parser, context);
+ const argument = !(parser.token & 1048576 /* ASI */) && !(parser.flags & exports.Flags.NewLine)
+ ? parseExpression(parser, (context & ~(exports.Context.InFunctionBody | exports.Context.AllowDecorator)) | exports.Context.AllowIn)
+ : null;
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ReturnStatement',
+ argument
+ });
+ }
+ /**
+ * Sets the necessary mutable parser flags. The parser flags will
+ * be unset after done parsing out the statements.
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-grammar-notation-IterationStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseIterationStatement(parser, context) {
+ // Note: We are deviating from the original grammar here beauce the original grammar says that the
+ // 'iterationStatement' should return either'for', 'do' or 'while' statements. We are doing some
+ // bitfiddling before and after to modify the parser state before we let the 'parseStatement'
+ // return the mentioned statements (to match the original grammar).
+ const savedFlags = parser.flags;
+ parser.flags |= exports.Flags.InIterationStatement | exports.Flags.AllowDestructuring;
+ const body = parseStatement(parser, (context & ~exports.Context.AllowSingleStatement) | exports.Context.DisallowEscapedKeyword);
+ parser.flags = savedFlags;
+ return body;
+ }
+ /**
+ * Parses with statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-WithStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseWithStatement(parser, context) {
+ if (context & exports.Context.Strict)
+ tolerant(parser, context, 37 /* StrictModeWith */);
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const object = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseStatement(parser, context & ~exports.Context.AllowSingleStatement);
+ return finishNode(context, parser, pos, {
+ type: 'WithStatement',
+ object,
+ body
+ });
+ }
+ /**
+ * Parses switch statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-SwitchStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseSwitchStatement(parser, context) {
+ const pos = getLocation(parser);
+ nextToken(parser, context);
+ expect(parser, context, 50331659 /* LeftParen */);
+ const discriminant = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ expect(parser, context, 16 /* RightParen */);
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 41943052 /* LeftBrace */);
+ const cases = [];
+ const savedFlags = parser.flags;
+ parser.flags |= exports.Flags.InSwitchStatement;
+ let seenDefault = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ const clause = parseCaseOrDefaultClauses(parser, context);
+ cases.push(clause);
+ if (clause.test === null) {
+ if (seenDefault)
+ tolerant(parser, context, 33 /* MultipleDefaultsInSwitch */);
+ seenDefault = true;
+ }
+ }
+ parser.flags = savedFlags;
+ expect(parser, context, 17825807 /* RightBrace */);
+ return finishNode(context, parser, pos, {
+ type: 'SwitchStatement',
+ discriminant,
+ cases
+ });
+ }
+ /**
+ * Parses either default clause or case clauses
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-CaseClauses)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-DefaultClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseCaseOrDefaultClauses(parser, context) {
+ const pos = getLocation(parser);
+ let test = null;
+ if (consume(parser, context, 12363 /* CaseKeyword */)) {
+ test = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ }
+ else {
+ expect(parser, context, 12368 /* DefaultKeyword */);
+ }
+ expect(parser, context, 16777237 /* Colon */);
+ const consequent = [];
+ while (!isEndOfCaseOrDefaultClauses(parser)) {
+ consequent.push(parseStatementListItem(parser, context | exports.Context.AllowIn));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'SwitchCase',
+ test,
+ consequent
+ });
+ }
+ /**
+ * Parses variable statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-VariableStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseVariableStatement(parser, context, shouldConsume = true) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const isConst = token === 33566793 /* ConstKeyword */;
+ nextToken(parser, context);
+ const declarations = parseVariableDeclarationList(parser, context, isConst);
+ // Only consume semicolons if not inside the 'ForStatement' production
+ if (shouldConsume)
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'VariableDeclaration',
+ kind: tokenDesc(token),
+ declarations
+ });
+ }
+ /**
+ * Parses either an lexical declaration (let) or an expression statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-let-and-const-declarations)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExpressionStatement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseLetOrExpressionStatement(parser, context, shouldConsume = true) {
+ return lookahead(parser, context, isLexical)
+ ? parseVariableStatement(parser, context | exports.Context.BlockScope, shouldConsume)
+ : parseExpressionOrLabelledStatement(parser, context);
+ }
+ /**
+ * Parses either async function declaration or statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-Statement)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionDeclarationOrStatement(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)
+ ? parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context)
+ : parseStatement(parser, context);
+ }
+ /**
+ * Parses either For, ForIn or ForOf statement
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-statement)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-for-in-and-for-of-statements)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseForStatement(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 12374 /* ForKeyword */);
+ const awaitToken = !!(context & exports.Context.Async && consume(parser, context, 34017389 /* AwaitKeyword */));
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 50331659 /* LeftParen */);
+ const { token } = parser;
+ let init = null;
+ let sequencePos = null;
+ let variableStatement = null;
+ let type = 'ForStatement';
+ let test = null;
+ let update = null;
+ let right;
+ if (token === 33566793 /* ConstKeyword */ || (token === 33574984 /* LetKeyword */ && lookahead(parser, context, isLexical))) {
+ variableStatement = parseVariableStatement(parser, (context & ~exports.Context.AllowIn) | exports.Context.BlockScope, false);
+ }
+ else if (token === 33566791 /* VarKeyword */) {
+ variableStatement = parseVariableStatement(parser, context & ~exports.Context.AllowIn, false);
+ }
+ else if (token !== 17825809 /* Semicolon */) {
+ sequencePos = getLocation(parser);
+ init = restoreExpressionCoverGrammar(parser, (context & ~exports.Context.AllowIn) | exports.Context.DisallowEscapedKeyword, parseAssignmentExpression);
+ }
+ if (consume(parser, context, 69746 /* OfKeyword */)) {
+ type = 'ForOfStatement';
+ if (init) {
+ if (!(parser.flags & exports.Flags.AllowDestructuring) || init.type === 'AssignmentExpression') {
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ }
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ right = parseAssignmentExpression(parser, context | exports.Context.AllowIn);
+ }
+ else if (consume(parser, context, 167786289 /* InKeyword */)) {
+ if (init) {
+ if (!(parser.flags & exports.Flags.AllowDestructuring))
+ tolerant(parser, context, 73 /* InvalidDestructuringTarget */);
+ reinterpret(parser, context, init);
+ }
+ else
+ init = variableStatement;
+ type = 'ForInStatement';
+ right = parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn);
+ }
+ else {
+ if (parser.token === 16777234 /* Comma */)
+ init = parseSequenceExpression(parser, context, init, sequencePos);
+ if (variableStatement)
+ init = variableStatement;
+ expect(parser, context, 17825809 /* Semicolon */);
+ test = parser.token !== 17825809 /* Semicolon */
+ ? parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn)
+ : null;
+ expect(parser, context, 17825809 /* Semicolon */);
+ update = parser.token !== 16 /* RightParen */
+ ? parseExpression(parser, (context & ~exports.Context.AllowDecorator) | exports.Context.AllowIn)
+ : null;
+ }
+ expect(parser, context, 16 /* RightParen */);
+ const body = parseIterationStatement(parser, context);
+ return finishNode(context, parser, pos, type === 'ForOfStatement'
+ ? {
+ type,
+ body,
+ left: init,
+ right,
+ await: awaitToken
+ }
+ : right
+ ? {
+ type: type,
+ body,
+ left: init,
+ right
+ }
+ : {
+ type: type,
+ body,
+ init,
+ test,
+ update
+ });
+ } + + // 15.2 Modules
+ /**
+ * Parse module item list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItemList)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleItemList(parser, context) {
+ // Prime the scanner
+ nextToken(parser, context);
+ const statements = [];
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ statements.push(parser.token === 33554435 /* StringLiteral */ ?
+ parseDirective(parser, context) :
+ parseModuleItem(parser, context | exports.Context.AllowIn));
+ }
+ return statements;
+ }
+ /**
+ * Parse module item
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleItem)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleItem(parser, context) {
+ switch (parser.token) {
+ // @decorator
+ case 120 /* At */:
+ return parseDecorators(parser, context);
+ // ExportDeclaration
+ case 12371 /* ExportKeyword */:
+ return parseExportDeclaration(parser, context);
+ // ImportDeclaration
+ case 33566810 /* ImportKeyword */:
+ // 'Dynamic Import' or meta property disallowed here
+ if (!(context & exports.Context.OptionsNext && lookahead(parser, context, nextTokenIsLeftParenOrPeriod))) {
+ return parseImportDeclaration(parser, context);
+ }
+ // falls through
+ default:
+ return parseStatementListItem(parser, context);
+ }
+ }
+ /**
+ * Parse export declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ExportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ const specifiers = [];
+ let source = null;
+ let declaration = null;
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 12371 /* ExportKeyword */);
+ switch (parser.token) {
+ // export * FromClause ;
+ case 167774771 /* Multiply */:
+ return parseExportAllDeclaration(parser, context, pos);
+ case 12368 /* DefaultKeyword */:
+ return parseExportDefault(parser, context, pos);
+ case 41943052 /* LeftBrace */:
+ {
+ // export ExportClause FromClause ;
+ // export ExportClause ;
+ expect(parser, context, 41943052 /* LeftBrace */);
+ let hasReservedWord = false;
+ while (parser.token !== 17825807 /* RightBrace */) {
+ if (parser.token !== 69743 /* GetKeyword */ && parser.token & 12288 /* Reserved */) {
+ hasReservedWord = true;
+ setPendingError(parser);
+ }
+ specifiers.push(parseNamedExportDeclaration(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 17825807 /* RightBrace */);
+ if (parser.token === 69745 /* FromKeyword */) {
+ source = parseModuleSpecifier(parser, context);
+ // The left hand side can't be a keyword where there is no
+ // 'from' keyword since it references a local binding.
+ }
+ else if (hasReservedWord)
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ consumeSemicolon(parser, context);
+ break;
+ }
+ // export ClassDeclaration
+ case 33566797 /* ClassKeyword */:
+ declaration = (parseClassDeclaration(parser, context));
+ break;
+ // export LexicalDeclaration
+ case 33574984 /* LetKeyword */:
+ case 33566793 /* ConstKeyword */:
+ declaration = parseVariableStatement(parser, context | exports.Context.BlockScope);
+ break;
+ // export VariableDeclaration
+ case 33566791 /* VarKeyword */:
+ declaration = parseVariableStatement(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context);
+ break;
+ // export HoistableDeclaration
+ case 594028 /* AsyncKeyword */:
+ if (lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine)) {
+ declaration = parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context);
+ break;
+ }
+ // Falls through
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportNamedDeclaration',
+ source,
+ specifiers,
+ declaration,
+ });
+ }
+ /**
+ * Parse export all declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseExportAllDeclaration(parser, context, pos) {
+ expect(parser, context, 167774771 /* Multiply */);
+ const source = parseModuleSpecifier(parser, context);
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ExportAllDeclaration',
+ source,
+ });
+ }
+ /**
+ * Parse named export declaration
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNamedExportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ // ExportSpecifier :
+ // IdentifierName
+ // IdentifierName as IdentifierName
+ const local = parseIdentifierName(parser, context | exports.Context.DisallowEscapedKeyword, parser.token);
+ const exported = consume(parser, context, 167843947 /* AsKeyword */)
+ ? parseIdentifierName(parser, context, parser.token)
+ : local;
+ return finishNode(context, parser, pos, {
+ type: 'ExportSpecifier',
+ local,
+ exported,
+ });
+ }
+ /**
+ * Parse export default
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ClassDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-HoistableDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ * @param pos Location
+ */
+ function parseExportDefault(parser, context, pos) {
+ expect(parser, context | exports.Context.DisallowEscapedKeyword, 12368 /* DefaultKeyword */);
+ let declaration;
+ switch (parser.token) {
+ // export default HoistableDeclaration[Default]
+ case 33566808 /* FunctionKeyword */:
+ declaration = parseFunctionDeclaration(parser, context | exports.Context.RequireIdentifier);
+ break;
+ // export default ClassDeclaration[Default]
+ // export default @decl ClassDeclaration[Default]
+ case 120 /* At */:
+ case 33566797 /* ClassKeyword */:
+ declaration = parseClassDeclaration(parser, context & ~exports.Context.AllowIn | exports.Context.RequireIdentifier);
+ break;
+ // export default HoistableDeclaration[Default]
+ case 594028 /* AsyncKeyword */:
+ declaration = parseAsyncFunctionOrAssignmentExpression(parser, context | exports.Context.RequireIdentifier);
+ break;
+ default:
+ // export default [lookahead ∉ {function, class}] AssignmentExpression[In] ;
+ declaration = parseAssignmentExpression(parser, context | exports.Context.AllowIn);
+ consumeSemicolon(parser, context);
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ExportDefaultDeclaration',
+ declaration,
+ });
+ }
+ /**
+ * Parse import declaration
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportDeclaration(parser, context) {
+ const pos = getLocation(parser);
+ expect(parser, context, 33566810 /* ImportKeyword */);
+ let source;
+ let specifiers = [];
+ // 'import' ModuleSpecifier ';'
+ if (parser.token === 33554435 /* StringLiteral */) {
+ source = parseLiteral(parser, context);
+ }
+ else {
+ specifiers = parseImportClause(parser, context | exports.Context.DisallowEscapedKeyword);
+ source = parseModuleSpecifier(parser, context);
+ }
+ consumeSemicolon(parser, context);
+ return finishNode(context, parser, pos, {
+ type: 'ImportDeclaration',
+ specifiers,
+ source,
+ });
+ }
+ /**
+ * Parse import clause
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportClause)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportClause(parser, context) {
+ const specifiers = [];
+ switch (parser.token) {
+ // 'import' ModuleSpecifier ';'
+ case 33685505 /* Identifier */:
+ {
+ specifiers.push(parseImportDefaultSpecifier(parser, context));
+ if (consume(parser, context, 16777234 /* Comma */)) {
+ switch (parser.token) {
+ // import a, * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ // import a, {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ default:
+ tolerant(parser, context, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ }
+ break;
+ }
+ // import {bar}
+ case 41943052 /* LeftBrace */:
+ parseNamedImports(parser, context, specifiers);
+ break;
+ // import * as foo
+ case 167774771 /* Multiply */:
+ parseNameSpaceImport(parser, context, specifiers);
+ break;
+ default:
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ }
+ return specifiers;
+ }
+ /**
+ * Parse named imports
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NamedImports)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNamedImports(parser, context, specifiers) {
+ expect(parser, context, 41943052 /* LeftBrace */);
+ while (parser.token !== 17825807 /* RightBrace */) {
+ specifiers.push(parseImportSpecifier(parser, context));
+ if (parser.token !== 17825807 /* RightBrace */)
+ expect(parser, context, 16777234 /* Comma */);
+ }
+ expect(parser, context, 17825807 /* RightBrace */);
+ }
+ /**
+ * Parse import specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ImportSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportSpecifier(parser, context) {
+ const pos = getLocation(parser);
+ const { token } = parser;
+ const imported = parseIdentifierName(parser, context | exports.Context.DisallowEscapedKeyword, token);
+ let local;
+ if (consume(parser, context, 167843947 /* AsKeyword */)) {
+ local = parseBindingIdentifier(parser, context);
+ }
+ else {
+ // An import name that is a keyword is a syntax error if it is not followed
+ // by the keyword 'as'.
+ if (hasBit(token, 12288 /* Reserved */))
+ tolerant(parser, context, 46 /* UnexpectedReserved */);
+ if (hasBit(token, 4194304 /* IsEvalOrArguments */))
+ tolerant(parser, context, 47 /* StrictEvalArguments */);
+ local = imported;
+ }
+ return finishNode(context, parser, pos, {
+ type: 'ImportSpecifier',
+ local,
+ imported,
+ });
+ }
+ /**
+ * Parse binding identifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-NameSpaceImport)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseNameSpaceImport(parser, context, specifiers) {
+ // NameSpaceImport:
+ // * as ImportedBinding
+ const pos = getLocation(parser);
+ expect(parser, context, 167774771 /* Multiply */);
+ expect(parser, context, 167843947 /* AsKeyword */, 82 /* AsAfterImportStart */);
+ const local = parseBindingIdentifier(parser, context);
+ specifiers.push(finishNode(context, parser, pos, {
+ type: 'ImportNamespaceSpecifier',
+ local,
+ }));
+ }
+ /**
+ * Parse module specifier
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-ModuleSpecifier)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseModuleSpecifier(parser, context) {
+ // ModuleSpecifier :
+ // StringLiteral
+ expect(parser, context, 69745 /* FromKeyword */);
+ if (parser.token !== 33554435 /* StringLiteral */)
+ report(parser, 1 /* UnexpectedToken */, tokenDesc(parser.token));
+ return parseLiteral(parser, context);
+ }
+ /**
+ * Parse import default specifier
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseImportDefaultSpecifier(parser, context) {
+ return finishNode(context, parser, getLocation(parser), {
+ type: 'ImportDefaultSpecifier',
+ local: parseIdentifier(parser, context),
+ });
+ }
+ /**
+ * Parses either async function or assignment expression
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AssignmentExpression)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncFunctionDeclaration)
+ * @see [Link](https://tc39.github.io/ecma262/#prod-AsyncGeneratorDeclaration)
+ *
+ * @param parser Parser object
+ * @param context Context masks
+ */
+ function parseAsyncFunctionOrAssignmentExpression(parser, context) {
+ return lookahead(parser, context, nextTokenIsFuncKeywordOnSameLine) ?
+ parseAsyncFunctionOrAsyncGeneratorDeclaration(parser, context | exports.Context.RequireIdentifier) :
+ parseAssignmentExpression(parser, context | exports.Context.AllowIn);
+ } + + /**
+ * Creates the parser object
+ *
+ * @param source The source coode to parser
+ * @param sourceFile Optional source file info to be attached in every node
+ */
+ function createParser(source, sourceFile) {
+ return {
+ // The source code to parse
+ source,
+ // Source length
+ length: source.length,
+ // Current position
+ index: 0,
+ // Current line
+ line: 1,
+ // Current column
+ column: 0,
+ // Start position before current token
+ startIndex: 0,
+ // Start position column before current token
+ startColumn: 0,
+ // Start position line before current token
+ startLine: 1,
+ // End position after parsing after current token
+ lastIndex: 0,
+ // End column position after current token
+ lastColumn: 0,
+ // End line position after current token
+ lastLine: 0,
+ // Pending cover grammar errors
+ pendingExpressionError: undefined,
+ // Mutable parser flags. Allows destructuring by default.
+ flags: exports.Flags.AllowDestructuring,
+ // The tokens
+ token: 1048576 /* EndOfSource */,
+ // Misc
+ tokenRaw: '',
+ lastValue: 0,
+ comments: [],
+ sourceFile,
+ tokenRegExp: undefined,
+ tokenValue: undefined,
+ labelSet: undefined,
+ errorLocation: undefined,
+ errors: [],
+ };
+ }
+ /**
+ * Creating the parser
+ *
+ * @param source The source coode to parser
+ * @param options The parser options
+ * @param context Context masks
+ */
+ function parseSource(source, options, /*@internal*/ context) {
+ let sourceFile = '';
+ if (!!options) {
+ // The flag to enable module syntax support
+ if (options.module)
+ context |= exports.Context.Module;
+ // The flag to enable stage 3 support (ESNext)
+ if (options.next)
+ context |= exports.Context.OptionsNext;
+ // The flag to enable React JSX parsing
+ if (options.jsx)
+ context |= exports.Context.OptionsJSX;
+ // The flag to enable start and end offsets to each node
+ if (options.ranges)
+ context |= exports.Context.OptionsRanges;
+ // The flag to enable line/column location information to each node
+ if (options.loc)
+ context |= exports.Context.OptionsLoc;
+ // The flag to attach raw property to each literal node
+ if (options.raw)
+ context |= exports.Context.OptionsRaw;
+ // Attach raw property to each identifier node
+ if (options.rawIdentifier)
+ context |= exports.Context.OptionsRawidentifiers;
+ // The flag to allow return in the global scope
+ if (options.globalReturn)
+ context |= exports.Context.OptionsGlobalReturn;
+ // The flag to allow to skip shebang - '#'
+ if (options.skipShebang)
+ context |= exports.Context.OptionsShebang;
+ // Enable tolerant mode
+ if (options.tolerant)
+ context |= exports.Context.OptionsTolerant;
+ // Set to true to record the source file in every node's loc object when the loc option is set.
+ if (!!options.source)
+ sourceFile = options.source;
+ // Create a top-level comments array containing all comments
+ if (!!options.comments)
+ context |= exports.Context.OptionsComments;
+ // The flag to enable implied strict mode
+ if (options.impliedStrict)
+ context |= exports.Context.Strict;
+ // The flag to enable experimental features
+ if (options.experimental)
+ context |= exports.Context.OptionsExperimental;
+ // The flag to set to bypass methods in Node
+ if (options.node)
+ context |= exports.Context.OptionsNode;
+ // Accepts a callback function to be invoked for each syntax node (as the node is constructed)
+ }
+ const parser = createParser(source, sourceFile);
+ const body = context & exports.Context.Module ?
+ parseModuleItemList(parser, context) :
+ parseStatementList(parser, context);
+ const node = {
+ type: 'Program',
+ sourceType: context & exports.Context.Module ? 'module' : 'script',
+ body: body,
+ };
+ if (context & exports.Context.LocationTracker) {
+ if (context & exports.Context.OptionsRanges) {
+ node.start = 0;
+ node.end = source.length;
+ }
+ if (context & exports.Context.OptionsLoc) {
+ node.loc = {
+ start: { line: 1, column: 0 },
+ end: { line: parser.line, column: parser.column
+ }
+ };
+ if (sourceFile)
+ node.loc.source = sourceFile;
+ }
+ }
+ if (context & exports.Context.OptionsComments)
+ node.comments = parser.comments;
+ if (context & exports.Context.OptionsTolerant)
+ node.errors = parser.errors;
+ return node;
+ }
+ /**
+ * Parse statement list
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#prod-StatementList)
+ *
+ * @param Parser instance
+ * @param Context masks
+ */
+ function parseStatementList(parser, context) {
+ const statements = [];
+ let hasProlog = true; // Parsing directive prologue.
+ // prime the scanner
+ nextToken(parser, context | exports.Context.DisallowEscapedKeyword);
+ while (parser.token !== 1048576 /* EndOfSource */) {
+ if (hasProlog && parser.token !== 33554435 /* StringLiteral */)
+ hasProlog = false;
+ if (hasProlog) {
+ if (!(context & exports.Context.Strict) && parser.tokenRaw.length === 12 && parser.tokenValue === 'use strict') {
+ context |= exports.Context.Strict;
+ }
+ statements.push(parseDirective(parser, context));
+ }
+ else {
+ statements.push(parseStatementListItem(parser, context));
+ }
+ }
+ return statements;
+ }
+ /**
+ * Parse either script code or module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parse(source, options) {
+ return options && options.module
+ ? parseModule(source, options)
+ : parseScript(source, options);
+ }
+ /**
+ * Parse script code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-scripts)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parseScript(source, options) {
+ return parseSource(source, options, exports.Context.Empty);
+ }
+ /**
+ * Parse module code
+ *
+ * @see [Link](https://tc39.github.io/ecma262/#sec-modules)
+ *
+ * @param source source code to parse
+ * @param options parser options
+ */
+ function parseModule(source, options) {
+ return parseSource(source, options, exports.Context.Strict | exports.Context.Module);
+ } + + + + var estree = /*#__PURE__*/Object.freeze({ + + }); + + + + var index = /*#__PURE__*/Object.freeze({ + scanIdentifier: scanIdentifier, + scanMaybeIdentifier: scanMaybeIdentifier, + scanHexIntegerLiteral: scanHexIntegerLiteral, + scanOctalOrBinary: scanOctalOrBinary, + scanImplicitOctalDigits: scanImplicitOctalDigits, + scanSignedInteger: scanSignedInteger, + scanNumericLiteral: scanNumericLiteral, + scanNumericSeparator: scanNumericSeparator, + scanDecimalDigitsOrSeparator: scanDecimalDigitsOrSeparator, + scanDecimalAsSmi: scanDecimalAsSmi, + scanRegularExpression: scanRegularExpression, + scan: scan, + scanEscapeSequence: scanEscapeSequence, + throwStringError: throwStringError, + scanString: scanString, + consumeTemplateBrace: consumeTemplateBrace, + scanTemplate: scanTemplate, + skipSingleHTMLComment: skipSingleHTMLComment, + skipSingleLineComment: skipSingleLineComment, + skipMultiLineComment: skipMultiLineComment, + addComment: addComment, + nextUnicodeChar: nextUnicodeChar, + isIdentifierPart: isIdentifierPart, + escapeInvalidCharacters: escapeInvalidCharacters, + consumeOpt: consumeOpt, + consumeLineFeed: consumeLineFeed, + scanPrivateName: scanPrivateName, + advanceNewline: advanceNewline, + fromCodePoint: fromCodePoint, + readNext: readNext, + toHex: toHex, + advanceOnMaybeAstral: advanceOnMaybeAstral + }); + + + + var parser = /*#__PURE__*/Object.freeze({ + parseClassDeclaration: parseClassDeclaration, + parseFunctionDeclaration: parseFunctionDeclaration, + parseAsyncFunctionOrAsyncGeneratorDeclaration: parseAsyncFunctionOrAsyncGeneratorDeclaration, + parseVariableDeclarationList: parseVariableDeclarationList, + parseExpression: parseExpression, + parseSequenceExpression: parseSequenceExpression, + parseAssignmentExpression: parseAssignmentExpression, + parseRestElement: parseRestElement, + parseLeftHandSideExpression: parseLeftHandSideExpression, + parsePrimaryExpression: parsePrimaryExpression, + parseIdentifier: parseIdentifier, + parseLiteral: parseLiteral, + parseBigIntLiteral: parseBigIntLiteral, + parseIdentifierName: parseIdentifierName, + parseFunctionExpression: parseFunctionExpression, + parseAsyncFunctionOrAsyncGeneratorExpression: parseAsyncFunctionOrAsyncGeneratorExpression, + parsePropertyName: parsePropertyName, + parseObjectLiteral: parseObjectLiteral, + parseFormalListAndBody: parseFormalListAndBody, + parseFunctionBody: parseFunctionBody, + parseFormalParameters: parseFormalParameters, + parseFormalParameterList: parseFormalParameterList, + parseClassBodyAndElementList: parseClassBodyAndElementList, + parseClassElement: parseClassElement, + parseDecorators: parseDecorators, + parseModuleItemList: parseModuleItemList, + parseModuleItem: parseModuleItem, + parseExportDeclaration: parseExportDeclaration, + parseImportDeclaration: parseImportDeclaration, + createParser: createParser, + parseSource: parseSource, + parseStatementList: parseStatementList, + parse: parse, + parseScript: parseScript, + parseModule: parseModule, + parseBindingIdentifierOrPattern: parseBindingIdentifierOrPattern, + parseBindingIdentifier: parseBindingIdentifier, + parseAssignmentRestElement: parseAssignmentRestElement, + parseAssignmentPattern: parseAssignmentPattern, + parseBindingInitializer: parseBindingInitializer, + parseStatementListItem: parseStatementListItem, + parseStatement: parseStatement, + parseEmptyStatement: parseEmptyStatement, + parseContinueStatement: parseContinueStatement, + parseBreakStatement: parseBreakStatement, + parseIfStatement: parseIfStatement, + parseDebuggerStatement: parseDebuggerStatement, + parseTryStatement: parseTryStatement, + parseCatchBlock: parseCatchBlock, + parseThrowStatement: parseThrowStatement, + parseExpressionStatement: parseExpressionStatement, + parseDirective: parseDirective, + parseExpressionOrLabelledStatement: parseExpressionOrLabelledStatement, + parseDoWhileStatement: parseDoWhileStatement, + parseWhileStatement: parseWhileStatement, + parseBlockStatement: parseBlockStatement, + parseReturnStatement: parseReturnStatement, + parseIterationStatement: parseIterationStatement, + parseWithStatement: parseWithStatement, + parseSwitchStatement: parseSwitchStatement, + parseCaseOrDefaultClauses: parseCaseOrDefaultClauses, + parseVariableStatement: parseVariableStatement, + parseJSXRootElement: parseJSXRootElement, + parseJSXOpeningElement: parseJSXOpeningElement, + nextJSXToken: nextJSXToken, + scanJSXToken: scanJSXToken, + parseJSXText: parseJSXText, + parseJSXAttributes: parseJSXAttributes, + parseJSXSpreadAttribute: parseJSXSpreadAttribute, + parseJSXNamespacedName: parseJSXNamespacedName, + parseJSXAttributeName: parseJSXAttributeName, + parseJSXAttribute: parseJSXAttribute, + parseJSXEmptyExpression: parseJSXEmptyExpression, + parseJSXSpreadChild: parseJSXSpreadChild, + parseJSXExpressionContainer: parseJSXExpressionContainer, + parseJSXExpression: parseJSXExpression, + parseJSXClosingFragment: parseJSXClosingFragment, + parseJSXClosingElement: parseJSXClosingElement, + parseJSXIdentifier: parseJSXIdentifier, + parseJSXMemberExpression: parseJSXMemberExpression, + parseJSXElementName: parseJSXElementName, + scanJSXIdentifier: scanJSXIdentifier + }); + + // tslint:disable-next-line:variable-name
+ const Parser = parser; + + const version = '1.6.9'; + + exports.version = version; + exports.ESTree = estree; + exports.Scanner = index; + exports.parse = parse; + exports.parseSource = parseSource; + exports.parseModule = parseModule; + exports.parseScript = parseScript; + exports.characterType = characterType; + exports.errorMessages = errorMessages; + exports.constructError = constructError; + exports.report = report; + exports.tolerant = tolerant; + exports.tokenDesc = tokenDesc; + exports.descKeyword = descKeyword; + exports.Parser = Parser; + exports.isValidIdentifierPart = isValidIdentifierPart; + exports.isValidIdentifierStart = isValidIdentifierStart; + exports.mustEscape = mustEscape; + exports.validateBreakOrContinueLabel = validateBreakOrContinueLabel; + exports.addLabel = addLabel; + exports.popLabel = popLabel; + exports.hasLabel = hasLabel; + exports.finishNode = finishNode; + exports.expect = expect; + exports.consume = consume; + exports.nextToken = nextToken; + exports.hasBit = hasBit; + exports.consumeSemicolon = consumeSemicolon; + exports.parseExpressionCoverGrammar = parseExpressionCoverGrammar; + exports.restoreExpressionCoverGrammar = restoreExpressionCoverGrammar; + exports.swapContext = swapContext; + exports.validateParams = validateParams; + exports.reinterpret = reinterpret; + exports.lookahead = lookahead; + exports.isValidSimpleAssignmentTarget = isValidSimpleAssignmentTarget; + exports.getLocation = getLocation; + exports.isValidIdentifier = isValidIdentifier; + exports.isLexical = isLexical; + exports.isEndOfCaseOrDefaultClauses = isEndOfCaseOrDefaultClauses; + exports.nextTokenIsLeftParenOrPeriod = nextTokenIsLeftParenOrPeriod; + exports.nextTokenisIdentifierOrParen = nextTokenisIdentifierOrParen; + exports.nextTokenIsLeftParen = nextTokenIsLeftParen; + exports.nextTokenIsFuncKeywordOnSameLine = nextTokenIsFuncKeywordOnSameLine; + exports.isPropertyWithPrivateFieldKey = isPropertyWithPrivateFieldKey; + exports.parseAndClassifyIdentifier = parseAndClassifyIdentifier; + exports.nameIsArgumentsOrEval = nameIsArgumentsOrEval; + exports.setPendingError = setPendingError; + exports.isEqualTagNames = isEqualTagNames; + exports.isInstanceField = isInstanceField; + exports.validateUpdateExpression = validateUpdateExpression; + exports.setPendingExpressionError = setPendingExpressionError; + exports.validateCoverParenthesizedExpression = validateCoverParenthesizedExpression; + exports.validateAsyncArgumentList = validateAsyncArgumentList; + exports.isInOrOf = isInOrOf; + + Object.defineProperty(exports, '__esModule', { value: true }); + +}); |