diff options
Diffstat (limited to 'node_modules/meriyah/dist/meriyah.esm.js')
| -rw-r--r-- | node_modules/meriyah/dist/meriyah.esm.js | 8782 |
1 files changed, 8782 insertions, 0 deletions
diff --git a/node_modules/meriyah/dist/meriyah.esm.js b/node_modules/meriyah/dist/meriyah.esm.js new file mode 100644 index 0000000..a6ff1de --- /dev/null +++ b/node_modules/meriyah/dist/meriyah.esm.js @@ -0,0 +1,8782 @@ +const errorMessages = {
+ [0]: 'Unexpected token',
+ [28]: "Unexpected token: '%0'",
+ [1]: 'Octal escape sequences are not allowed in strict mode',
+ [2]: 'Octal escape sequences are not allowed in template strings',
+ [3]: 'Unexpected token `#`',
+ [4]: 'Illegal Unicode escape sequence',
+ [5]: 'Invalid code point %0',
+ [6]: 'Invalid hexadecimal escape sequence',
+ [8]: 'Octal literals are not allowed in strict mode',
+ [7]: 'Decimal integer literals with a leading zero are forbidden in strict mode',
+ [9]: 'Expected number in radix %0',
+ [145]: 'Invalid left-hand side assignment to a destructible right-hand side',
+ [10]: 'Non-number found after exponent indicator',
+ [11]: 'Invalid BigIntLiteral',
+ [12]: 'No identifiers allowed directly after numeric literal',
+ [13]: 'Escapes \\8 or \\9 are not syntactically valid escapes',
+ [14]: 'Unterminated string literal',
+ [15]: 'Unterminated template literal',
+ [16]: 'Multiline comment was not closed properly',
+ [17]: 'The identifier contained dynamic unicode escape that was not closed',
+ [18]: "Illegal character '%0'",
+ [19]: 'Missing hexadecimal digits',
+ [20]: 'Invalid implicit octal',
+ [21]: 'Invalid line break in string literal',
+ [22]: 'Only unicode escapes are legal in identifier names',
+ [23]: "Expected '%0'",
+ [24]: 'Invalid left-hand side in assignment',
+ [25]: 'Invalid left-hand side in async arrow',
+ [26]: 'Calls to super must be in the "constructor" method of a class expression or class declaration that has a superclass',
+ [27]: 'Member access on super must be in a method',
+ [29]: 'Await expression not allowed in formal parameter',
+ [30]: 'Yield expression not allowed in formal parameter',
+ [92]: "Unexpected token: 'escaped keyword'",
+ [31]: 'Unary expressions as the left operand of an exponentiation expression must be disambiguated with parentheses',
+ [119]: 'Async functions can only be declared at the top level or inside a block',
+ [32]: 'Unterminated regular expression',
+ [33]: 'Unexpected regular expression flag',
+ [34]: "Duplicate regular expression flag '%0'",
+ [35]: '%0 functions must have exactly %1 argument%2',
+ [36]: 'Setter function argument must not be a rest parameter',
+ [37]: '%0 declaration must have a name in this context',
+ [38]: 'Function name may not contain any reserved words or be eval or arguments in strict mode',
+ [39]: 'The rest operator is missing an argument',
+ [40]: 'A getter cannot be a generator',
+ [41]: 'A computed property name must be followed by a colon or paren',
+ [130]: 'Object literal keys that are strings or numbers must be a method or have a colon',
+ [43]: 'Found `* async x(){}` but this should be `async * x(){}`',
+ [42]: 'Getters and setters can not be generators',
+ [44]: "'%0' can not be generator method",
+ [45]: "No line break is allowed after '=>'",
+ [46]: 'The left-hand side of the arrow can only be destructed through assignment',
+ [47]: 'The binding declaration is not destructible',
+ [48]: 'Async arrow can not be followed by new expression',
+ [49]: "Classes may not have a static property named 'prototype'",
+ [50]: 'Class constructor may not be a %0',
+ [51]: 'Duplicate constructor method in class',
+ [52]: 'Invalid increment/decrement operand',
+ [53]: 'Invalid use of `new` keyword on an increment/decrement expression',
+ [54]: '`=>` is an invalid assignment target',
+ [55]: 'Rest element may not have a trailing comma',
+ [56]: 'Missing initializer in %0 declaration',
+ [57]: "'for-%0' loop head declarations can not have an initializer",
+ [58]: 'Invalid left-hand side in for-%0 loop: Must have a single binding',
+ [59]: 'Invalid shorthand property initializer',
+ [60]: 'Property name __proto__ appears more than once in object literal',
+ [61]: 'Let is disallowed as a lexically bound name',
+ [62]: "Invalid use of '%0' inside new expression",
+ [63]: "Illegal 'use strict' directive in function with non-simple parameter list",
+ [64]: 'Identifier "let" disallowed as left-hand side expression in strict mode',
+ [65]: 'Illegal continue statement',
+ [66]: 'Illegal break statement',
+ [67]: 'Cannot have `let[...]` as a var name in strict mode',
+ [68]: 'Invalid destructuring assignment target',
+ [69]: 'Rest parameter may not have a default initializer',
+ [70]: 'The rest argument must the be last parameter',
+ [71]: 'Invalid rest argument',
+ [73]: 'In strict mode code, functions can only be declared at top level or inside a block',
+ [74]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+ [75]: 'Without web compatibility enabled functions can not be declared at top level, inside a block, or as the body of an if statement',
+ [76]: "Class declaration can't appear in single-statement context",
+ [77]: 'Invalid left-hand side in for-%0',
+ [78]: 'Invalid assignment in for-%0',
+ [79]: 'for await (... of ...) is only valid in async functions and async generators',
+ [80]: 'The first token after the template expression should be a continuation of the template',
+ [82]: '`let` declaration not allowed here and `let` cannot be a regular var name in strict mode',
+ [81]: '`let \n [` is a restricted production at the start of a statement',
+ [83]: 'Catch clause requires exactly one parameter, not more (and no trailing comma)',
+ [84]: 'Catch clause parameter does not support default values',
+ [85]: 'Missing catch or finally after try',
+ [86]: 'More than one default clause in switch statement',
+ [87]: 'Illegal newline after throw',
+ [88]: 'Strict mode code may not include a with statement',
+ [89]: 'Illegal return statement',
+ [90]: 'The left hand side of the for-header binding declaration is not destructible',
+ [91]: 'new.target only allowed within functions',
+ [93]: "'#' not followed by identifier",
+ [99]: 'Invalid keyword',
+ [98]: "Can not use 'let' as a class name",
+ [97]: "'A lexical declaration can't define a 'let' binding",
+ [96]: 'Can not use `let` as variable name in strict mode',
+ [94]: "'%0' may not be used as an identifier in this context",
+ [95]: 'Await is only valid in async functions',
+ [100]: 'The %0 keyword can only be used with the module goal',
+ [101]: 'Unicode codepoint must not be greater than 0x10FFFF',
+ [102]: '%0 source must be string',
+ [103]: 'Only a identifier can be used to indicate alias',
+ [104]: "Only '*' or '{...}' can be imported after default",
+ [105]: 'Trailing decorator may be followed by method',
+ [106]: "Decorators can't be used with a constructor",
+ [108]: 'HTML comments are only allowed with web compatibility (Annex B)',
+ [109]: "The identifier 'let' must not be in expression position in strict mode",
+ [110]: 'Cannot assign to `eval` and `arguments` in strict mode',
+ [111]: "The left-hand side of a for-of loop may not start with 'let'",
+ [112]: 'Block body arrows can not be immediately invoked without a group',
+ [113]: 'Block body arrows can not be immediately accessed without a group',
+ [114]: 'Unexpected strict mode reserved word',
+ [115]: 'Unexpected eval or arguments in strict mode',
+ [116]: 'Decorators must not be followed by a semicolon',
+ [117]: 'Calling delete on expression not allowed in strict mode',
+ [118]: 'Pattern can not have a tail',
+ [120]: 'Can not have a `yield` expression on the left side of a ternary',
+ [121]: 'An arrow function can not have a postfix update operator',
+ [122]: 'Invalid object literal key character after generator star',
+ [123]: 'Private fields can not be deleted',
+ [125]: 'Classes may not have a field called constructor',
+ [124]: 'Classes may not have a private element named constructor',
+ [126]: 'A class field initializer may not contain arguments',
+ [127]: 'Generators can only be declared at the top level or inside a block',
+ [128]: 'Async methods are a restricted production and cannot have a newline following it',
+ [129]: 'Unexpected character after object literal property name',
+ [131]: 'Invalid key token',
+ [132]: "Label '%0' has already been declared",
+ [133]: 'continue statement must be nested within an iteration statement',
+ [134]: "Undefined label '%0'",
+ [135]: 'Trailing comma is disallowed inside import(...) arguments',
+ [136]: 'import() requires exactly one argument',
+ [137]: 'Cannot use new with import(...)',
+ [138]: '... is not allowed in import()',
+ [139]: "Expected '=>'",
+ [140]: "Duplicate binding '%0'",
+ [141]: "Cannot export a duplicate name '%0'",
+ [144]: 'Duplicate %0 for-binding',
+ [142]: "Exported binding '%0' needs to refer to a top-level declared variable",
+ [143]: 'Unexpected private field',
+ [147]: 'Numeric separators are not allowed at the end of numeric literals',
+ [146]: 'Only one underscore is allowed as numeric separator',
+ [148]: 'JSX value should be either an expression or a quoted JSX text',
+ [149]: 'Expected corresponding JSX closing tag for %0',
+ [150]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+ [151]: "JSX attributes must only be assigned a non-empty 'expression'",
+ [152]: "'%0' has already been declared",
+ [153]: "'%0' shadowed a catch clause binding",
+ [154]: 'Dot property must be an identifier',
+ [155]: 'Encountered invalid input after spread/rest argument',
+ [156]: 'Catch without try',
+ [157]: 'Finally without try',
+ [158]: 'Expected corresponding closing tag for JSX fragment',
+ [159]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
+ [160]: 'Invalid tagged template on optional chain',
+ [161]: 'Invalid optional chain from super property',
+ [162]: 'Invalid optional chain from new expression',
+ [163]: 'Cannot use "import.meta" outside a module',
+ [164]: 'Leading decorators must be attached to a class declaration'
+};
+class ParseError extends SyntaxError {
+ constructor(startindex, line, column, type, ...params) {
+ const message = '[' + line + ':' + column + ']: ' + errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+ super(`${message}`);
+ this.index = startindex;
+ this.line = line;
+ this.column = column;
+ this.description = message;
+ this.loc = {
+ line,
+ column
+ };
+ }
+}
+function report(parser, type, ...params) {
+ throw new ParseError(parser.index, parser.line, parser.column, type, ...params);
+}
+function reportScopeError(scope) {
+ throw new ParseError(scope.index, scope.line, scope.column, scope.type, scope.params);
+}
+function reportMessageAt(index, line, column, type, ...params) {
+ throw new ParseError(index, line, column, type, ...params);
+}
+function reportScannerError(index, line, column, type) {
+ throw new ParseError(index, line, column, type);
+} + +const unicodeLookup = ((compressed, lookup) => {
+ const result = new Uint32Array(104448);
+ let index = 0;
+ let subIndex = 0;
+ while (index < 3540) {
+ 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, 24, 2, 25, 2, 5, -1, 0, 77595648, 3, 44, 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, 16, 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, 19, 2, 0, 0, 608174079, 2, 0, 2, 131, 2, 6, 2, 56, -1, 2, 37, 0, 4294443263, 2, 1, 3, 0, 3, 0, 4294901711, 2, 39, 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, 2967484831, 0, 196559, 0, 3594373100, 0, 3288319768, 0, 8469959, 2, 194, 2, 3, 0, 3825204735, 0, 123747807, 0, 65487, 0, 4294828015, 0, 4092591615, 0, 1080049119, 0, 458703, 2, 3, 2, 0, 0, 2163244511, 0, 4227923919, 0, 4236247022, 2, 66, 0, 4284449919, 0, 851904, 2, 4, 2, 11, 0, 67076095, -1, 2, 67, 0, 1073741743, 0, 4093591391, -1, 0, 50331649, 0, 3265266687, 2, 32, 0, 4294844415, 0, 4278190047, 2, 18, 2, 129, -1, 3, 0, 2, 2, 21, 2, 0, 2, 9, 2, 0, 2, 14, 2, 15, 3, 0, 10, 2, 69, 2, 0, 2, 70, 2, 71, 2, 72, 2, 0, 2, 73, 2, 0, 2, 10, 0, 261632, 2, 23, 3, 0, 2, 2, 12, 2, 4, 3, 0, 18, 2, 74, 2, 5, 3, 0, 2, 2, 75, 0, 2088959, 2, 27, 2, 8, 0, 909311, 3, 0, 2, 0, 814743551, 2, 41, 0, 67057664, 3, 0, 2, 2, 40, 2, 0, 2, 28, 2, 0, 2, 29, 2, 7, 0, 268374015, 2, 26, 2, 49, 2, 0, 2, 76, 0, 134153215, -1, 2, 6, 2, 0, 2, 7, 0, 2684354559, 0, 67044351, 0, 3221160064, 0, 1, -1, 3, 0, 2, 2, 42, 0, 1046528, 3, 0, 3, 2, 8, 2, 0, 2, 51, 0, 4294960127, 2, 9, 2, 38, 2, 10, 0, 4294377472, 2, 11, 3, 0, 7, 0, 4227858431, 3, 0, 8, 2, 12, 2, 0, 2, 78, 2, 9, 2, 0, 2, 79, 2, 80, 2, 81, -1, 2, 124, 0, 1048577, 2, 82, 2, 13, -1, 2, 13, 0, 131042, 2, 83, 2, 84, 2, 85, 2, 0, 2, 33, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 1046559, 2, 0, 2, 14, 2, 0, 0, 2147516671, 2, 20, 3, 86, 2, 2, 0, -16, 2, 87, 0, 524222462, 2, 4, 2, 0, 0, 4269801471, 2, 4, 2, 0, 2, 15, 2, 77, 2, 16, 3, 0, 2, 2, 47, 2, 0, -1, 2, 17, -16, 3, 0, 206, -2, 3, 0, 655, 2, 18, 3, 0, 36, 2, 68, -1, 2, 17, 2, 9, 3, 0, 8, 2, 89, 2, 121, 2, 0, 0, 3220242431, 3, 0, 3, 2, 19, 2, 90, 2, 91, 3, 0, 2, 2, 92, 2, 0, 2, 93, 2, 94, 2, 0, 0, 4351, 2, 0, 2, 8, 3, 0, 2, 0, 67043391, 0, 3909091327, 2, 0, 2, 22, 2, 8, 2, 18, 3, 0, 2, 0, 67076097, 2, 7, 2, 0, 2, 20, 0, 67059711, 0, 4236247039, 3, 0, 2, 0, 939524103, 0, 8191999, 2, 97, 2, 98, 2, 15, 2, 21, 3, 0, 3, 0, 67057663, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 22, 3, 0, 2, 2, 31, -1, 0, 3774349439, 2, 101, 2, 102, 3, 0, 2, 2, 19, 2, 103, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 45, 2, 0, 2, 30, 2, 104, 2, 23, 0, 1638399, 2, 172, 2, 105, 3, 0, 3, 2, 18, 2, 24, 2, 25, 2, 5, 2, 26, 2, 0, 2, 7, 2, 106, -1, 2, 107, 2, 108, 2, 109, -1, 3, 0, 3, 2, 11, -2, 2, 0, 2, 27, -3, 2, 150, -4, 2, 18, 2, 0, 2, 35, 0, 1, 2, 0, 2, 62, 2, 28, 2, 11, 2, 9, 2, 0, 2, 110, -1, 3, 0, 4, 2, 9, 2, 21, 2, 111, 2, 6, 2, 0, 2, 112, 2, 0, 2, 48, -4, 3, 0, 9, 2, 20, 2, 29, 2, 30, -4, 2, 113, 2, 114, 2, 29, 2, 20, 2, 7, -2, 2, 115, 2, 29, 2, 31, -2, 2, 0, 2, 116, -2, 0, 4277137519, 0, 2269118463, -1, 3, 18, 2, -1, 2, 32, 2, 36, 2, 0, 3, 29, 2, 2, 34, 2, 19, -3, 3, 0, 2, 2, 33, -1, 2, 0, 2, 34, 2, 0, 2, 34, 2, 0, 2, 46, -10, 2, 0, 0, 203775, -2, 2, 18, 2, 43, 2, 35, -2, 2, 17, 2, 117, 2, 20, 3, 0, 2, 2, 36, 0, 2147549120, 2, 0, 2, 11, 2, 17, 2, 135, 2, 0, 2, 37, 2, 52, 0, 5242879, 3, 0, 2, 0, 402644511, -1, 2, 120, 0, 1090519039, -2, 2, 122, 2, 38, 2, 0, 0, 67045375, 2, 39, 0, 4226678271, 0, 3766565279, 0, 2039759, -4, 3, 0, 2, 0, 3288270847, 0, 3, 3, 0, 2, 0, 67043519, -5, 2, 0, 0, 4282384383, 0, 1056964609, -1, 3, 0, 2, 0, 67043345, -1, 2, 0, 2, 40, 2, 41, -1, 2, 10, 2, 42, -6, 2, 0, 2, 11, -3, 3, 0, 2, 0, 2147484671, 2, 125, 0, 4190109695, 2, 50, -2, 2, 126, 0, 4244635647, 0, 27, 2, 0, 2, 7, 2, 43, 2, 0, 2, 63, -1, 2, 0, 2, 40, -8, 2, 54, 2, 44, 0, 67043329, 2, 127, 2, 45, 0, 8388351, -2, 2, 128, 0, 3028287487, 2, 46, 2, 130, 0, 33259519, 2, 41, -9, 2, 20, -5, 2, 64, -2, 3, 0, 28, 2, 31, -3, 3, 0, 3, 2, 47, 3, 0, 6, 2, 48, -85, 3, 0, 33, 2, 47, -126, 3, 0, 18, 2, 36, -269, 3, 0, 17, 2, 40, 2, 7, 2, 41, -2, 2, 17, 2, 49, 2, 0, 2, 20, 2, 50, 2, 132, 2, 23, -21, 3, 0, 2, -4, 3, 0, 2, 0, 4294936575, 2, 0, 0, 4294934783, -2, 0, 196635, 3, 0, 191, 2, 51, 3, 0, 38, 2, 29, -1, 2, 33, -279, 3, 0, 8, 2, 7, -1, 2, 133, 2, 52, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 134, 0, 1677656575, -166, 0, 4161266656, 0, 4071, 0, 15360, -4, 0, 28, -13, 3, 0, 2, 2, 37, 2, 0, 2, 136, 2, 137, 2, 55, 2, 0, 2, 138, 2, 139, 2, 140, 3, 0, 10, 2, 141, 2, 142, 2, 15, 3, 37, 2, 3, 53, 2, 3, 54, 2, 0, 4294954999, 2, 0, -16, 2, 0, 2, 88, 2, 0, 0, 2105343, 0, 4160749584, 0, 65534, -42, 0, 4194303871, 0, 2011, -6, 2, 0, 0, 1073684479, 0, 17407, -11, 2, 0, 2, 31, -40, 3, 0, 6, 0, 8323103, -1, 3, 0, 2, 2, 42, -37, 2, 55, 2, 144, 2, 145, 2, 146, 2, 147, 2, 148, -105, 2, 24, -32, 3, 0, 1334, 2, 9, -1, 3, 0, 129, 2, 27, 3, 0, 6, 2, 9, 3, 0, 180, 2, 149, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -47, 3, 0, 154, 2, 56, -22381, 3, 0, 7, 2, 23, -6130, 3, 5, 2, -1, 0, 69207040, 3, 44, 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, 16, 2, 60, 2, 0, 2, 33, -1, 2, 17, 2, 61, -1, 2, 0, 2, 56, 0, 4294885376, 3, 0, 2, 0, 3145727, 0, 2617294944, 0, 4294770688, 2, 23, 2, 62, 3, 0, 2, 0, 131135, 2, 95, 0, 70256639, 0, 71303167, 0, 272, 2, 40, 2, 56, -1, 2, 37, 2, 30, -1, 2, 96, 2, 63, 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, 64, 0, 33554435, 2, 123, 2, 65, 2, 151, 0, 131075, 0, 3594373096, 0, 67094296, 2, 64, -1, 0, 4294828000, 0, 603979263, 2, 160, 0, 3, 0, 4294828001, 0, 602930687, 2, 183, 0, 393219, 0, 4294828016, 0, 671088639, 0, 2154840064, 0, 4227858435, 0, 4236247008, 2, 66, 2, 36, -1, 2, 4, 0, 917503, 2, 36, -1, 2, 67, 0, 537788335, 0, 4026531935, -1, 0, 1, -1, 2, 32, 2, 68, 0, 7936, -3, 2, 0, 0, 2147485695, 0, 1010761728, 0, 4292984930, 0, 16387, 2, 0, 2, 14, 2, 15, 3, 0, 10, 2, 69, 2, 0, 2, 70, 2, 71, 2, 72, 2, 0, 2, 73, 2, 0, 2, 11, -1, 2, 23, 3, 0, 2, 2, 12, 2, 4, 3, 0, 18, 2, 74, 2, 5, 3, 0, 2, 2, 75, 0, 253951, 3, 19, 2, 0, 122879, 2, 0, 2, 8, 0, 276824064, -2, 3, 0, 2, 2, 40, 2, 0, 0, 4294903295, 2, 0, 2, 29, 2, 7, -1, 2, 17, 2, 49, 2, 0, 2, 76, 2, 41, -1, 2, 20, 2, 0, 2, 27, -2, 0, 128, -2, 2, 77, 2, 8, 0, 4064, -1, 2, 119, 0, 4227907585, 2, 0, 2, 118, 2, 0, 2, 48, 2, 173, 2, 9, 2, 38, 2, 10, -1, 0, 74440192, 3, 0, 6, -2, 3, 0, 8, 2, 12, 2, 0, 2, 78, 2, 9, 2, 0, 2, 79, 2, 80, 2, 81, -3, 2, 82, 2, 13, -3, 2, 83, 2, 84, 2, 85, 2, 0, 2, 33, -83, 2, 0, 2, 53, 2, 7, 3, 0, 4, 0, 817183, 2, 0, 2, 14, 2, 0, 0, 33023, 2, 20, 3, 86, 2, -17, 2, 87, 0, 524157950, 2, 4, 2, 0, 2, 88, 2, 4, 2, 0, 2, 15, 2, 77, 2, 16, 3, 0, 2, 2, 47, 2, 0, -1, 2, 17, -16, 3, 0, 206, -2, 3, 0, 655, 2, 18, 3, 0, 36, 2, 68, -1, 2, 17, 2, 9, 3, 0, 8, 2, 89, 0, 3072, 2, 0, 0, 2147516415, 2, 9, 3, 0, 2, 2, 23, 2, 90, 2, 91, 3, 0, 2, 2, 92, 2, 0, 2, 93, 2, 94, 0, 4294965179, 0, 7, 2, 0, 2, 8, 2, 91, 2, 8, -1, 0, 1761345536, 2, 95, 0, 4294901823, 2, 36, 2, 18, 2, 96, 2, 34, 2, 166, 0, 2080440287, 2, 0, 2, 33, 2, 143, 0, 3296722943, 2, 0, 0, 1046675455, 0, 939524101, 0, 1837055, 2, 97, 2, 98, 2, 15, 2, 21, 3, 0, 3, 0, 7, 3, 0, 349, 2, 99, 2, 100, 2, 6, -264, 3, 0, 11, 2, 22, 3, 0, 2, 2, 31, -1, 0, 2700607615, 2, 101, 2, 102, 3, 0, 2, 2, 19, 2, 103, 3, 0, 10, 2, 9, 2, 17, 2, 0, 2, 45, 2, 0, 2, 30, 2, 104, -3, 2, 105, 3, 0, 3, 2, 18, -1, 3, 5, 2, 2, 26, 2, 0, 2, 7, 2, 106, -1, 2, 107, 2, 108, 2, 109, -1, 3, 0, 3, 2, 11, -2, 2, 0, 2, 27, -8, 2, 18, 2, 0, 2, 35, -1, 2, 0, 2, 62, 2, 28, 2, 29, 2, 9, 2, 0, 2, 110, -1, 3, 0, 4, 2, 9, 2, 17, 2, 111, 2, 6, 2, 0, 2, 112, 2, 0, 2, 48, -4, 3, 0, 9, 2, 20, 2, 29, 2, 30, -4, 2, 113, 2, 114, 2, 29, 2, 20, 2, 7, -2, 2, 115, 2, 29, 2, 31, -2, 2, 0, 2, 116, -2, 0, 4277075969, 2, 29, -1, 3, 18, 2, -1, 2, 32, 2, 117, 2, 0, 3, 29, 2, 2, 34, 2, 19, -3, 3, 0, 2, 2, 33, -1, 2, 0, 2, 34, 2, 0, 2, 34, 2, 0, 2, 48, -10, 2, 0, 0, 197631, -2, 2, 18, 2, 43, 2, 118, -2, 2, 17, 2, 117, 2, 20, 2, 119, 2, 51, -2, 2, 119, 2, 23, 2, 17, 2, 33, 2, 119, 2, 36, 0, 4294901904, 0, 4718591, 2, 119, 2, 34, 0, 335544350, -1, 2, 120, 2, 121, -2, 2, 122, 2, 38, 2, 7, -1, 2, 123, 2, 65, 0, 3758161920, 0, 3, -4, 2, 0, 2, 27, 0, 2147485568, 0, 3, 2, 0, 2, 23, 0, 176, -5, 2, 0, 2, 47, 2, 186, -1, 2, 0, 2, 23, 2, 197, -1, 2, 0, 0, 16779263, -2, 2, 11, -7, 2, 0, 2, 121, -3, 3, 0, 2, 2, 124, 2, 125, 0, 2147549183, 0, 2, -2, 2, 126, 2, 35, 0, 10, 0, 4294965249, 0, 67633151, 0, 4026597376, 2, 0, 0, 536871935, -1, 2, 0, 2, 40, -8, 2, 54, 2, 47, 0, 1, 2, 127, 2, 23, -3, 2, 128, 2, 35, 2, 129, 2, 130, 0, 16778239, -10, 2, 34, -5, 2, 64, -2, 3, 0, 28, 2, 31, -3, 3, 0, 3, 2, 47, 3, 0, 6, 2, 48, -85, 3, 0, 33, 2, 47, -126, 3, 0, 18, 2, 36, -269, 3, 0, 17, 2, 40, 2, 7, -3, 2, 17, 2, 131, 2, 0, 2, 23, 2, 48, 2, 132, 2, 23, -21, 3, 0, 2, -4, 3, 0, 2, 0, 67583, -1, 2, 103, -2, 0, 11, 3, 0, 191, 2, 51, 3, 0, 38, 2, 29, -1, 2, 33, -279, 3, 0, 8, 2, 7, -1, 2, 133, 2, 52, 3, 0, 11, 2, 6, -72, 3, 0, 3, 2, 134, 2, 135, -187, 3, 0, 2, 2, 37, 2, 0, 2, 136, 2, 137, 2, 55, 2, 0, 2, 138, 2, 139, 2, 140, 3, 0, 10, 2, 141, 2, 142, 2, 15, 3, 37, 2, 3, 53, 2, 3, 54, 2, 2, 143, -73, 2, 0, 0, 1065361407, 0, 16384, -11, 2, 0, 2, 121, -40, 3, 0, 6, 2, 117, -1, 3, 0, 2, 0, 2063, -37, 2, 55, 2, 144, 2, 145, 2, 146, 2, 147, 2, 148, -138, 3, 0, 1334, 2, 9, -1, 3, 0, 129, 2, 27, 3, 0, 6, 2, 9, 3, 0, 180, 2, 149, 3, 0, 233, 0, 1, -96, 3, 0, 16, 2, 9, -47, 3, 0, 154, 2, 56, -28517, 2, 0, 0, 1, -1, 2, 124, 2, 0, 0, 8193, -21, 2, 193, 0, 10255, 0, 4, -11, 2, 64, 2, 171, -1, 0, 71680, -1, 2, 161, 0, 4292900864, 0, 805306431, -5, 2, 150, -1, 2, 157, -1, 0, 6144, -2, 2, 127, -1, 2, 154, -1, 0, 2147532800, 2, 151, 2, 165, 2, 0, 2, 164, 0, 524032, 0, 4, -4, 2, 190, 0, 205128192, 0, 1333757536, 0, 2147483696, 0, 423953, 0, 747766272, 0, 2717763192, 0, 4286578751, 0, 278545, 2, 152, 0, 4294886464, 0, 33292336, 0, 417809, 2, 152, 0, 1327482464, 0, 4278190128, 0, 700594195, 0, 1006647527, 0, 4286497336, 0, 4160749631, 2, 153, 0, 469762560, 0, 4171219488, 0, 8323120, 2, 153, 0, 202375680, 0, 3214918176, 0, 4294508592, 2, 153, -1, 0, 983584, 0, 48, 0, 58720273, 0, 3489923072, 0, 10517376, 0, 4293066815, 0, 1, 0, 2013265920, 2, 177, 2, 0, 0, 2089, 0, 3221225552, 0, 201375904, 2, 0, -2, 0, 256, 0, 122880, 0, 16777216, 2, 150, 0, 4160757760, 2, 0, -6, 2, 167, -11, 0, 3263218176, -1, 0, 49664, 0, 2160197632, 0, 8388802, -1, 0, 12713984, -1, 2, 154, 2, 159, 2, 178, -2, 2, 162, -20, 0, 3758096385, -2, 2, 155, 0, 4292878336, 2, 90, 2, 169, 0, 4294057984, -2, 2, 163, 2, 156, 2, 175, -2, 2, 155, -1, 2, 182, -1, 2, 170, 2, 124, 0, 4026593280, 0, 14, 0, 4292919296, -1, 2, 158, 0, 939588608, -1, 0, 805306368, -1, 2, 124, 0, 1610612736, 2, 156, 2, 157, 2, 4, 2, 0, -2, 2, 158, 2, 159, -3, 0, 267386880, -1, 2, 160, 0, 7168, -1, 0, 65024, 2, 154, 2, 161, 2, 179, -7, 2, 168, -8, 2, 162, -1, 0, 1426112704, 2, 163, -1, 2, 164, 0, 271581216, 0, 2149777408, 2, 23, 2, 161, 2, 124, 0, 851967, 2, 180, -1, 2, 23, 2, 181, -4, 2, 158, -20, 2, 195, 2, 165, -56, 0, 3145728, 2, 185, -4, 2, 166, 2, 124, -4, 0, 32505856, -1, 2, 167, -1, 0, 2147385088, 2, 90, 1, 2155905152, 2, -3, 2, 103, 2, 0, 2, 168, -2, 2, 169, -6, 2, 170, 0, 4026597375, 0, 1, -1, 0, 1, -1, 2, 171, -3, 2, 117, 2, 64, -2, 2, 166, -2, 2, 176, 2, 124, -878, 2, 159, -36, 2, 172, -1, 2, 201, -10, 2, 188, -5, 2, 174, -6, 0, 4294965251, 2, 27, -1, 2, 173, -1, 2, 174, -2, 0, 4227874752, -3, 0, 2146435072, 2, 159, -2, 0, 1006649344, 2, 124, -1, 2, 90, 0, 201375744, -3, 0, 134217720, 2, 90, 0, 4286677377, 0, 32896, -1, 2, 158, -3, 2, 175, -349, 2, 176, 0, 1920, 2, 177, 3, 0, 264, -11, 2, 157, -2, 2, 178, 2, 0, 0, 520617856, 0, 2692743168, 0, 36, -3, 0, 524284, -11, 2, 23, -1, 2, 187, -1, 2, 184, 0, 3221291007, 2, 178, -1, 2, 202, 0, 2158720, -3, 2, 159, 0, 1, -4, 2, 124, 0, 3808625411, 0, 3489628288, 2, 200, 0, 1207959680, 0, 3221274624, 2, 0, -3, 2, 179, 0, 120, 0, 7340032, -2, 2, 180, 2, 4, 2, 23, 2, 163, 3, 0, 4, 2, 159, -1, 2, 181, 2, 177, -1, 0, 8176, 2, 182, 2, 179, 2, 183, -1, 0, 4290773232, 2, 0, -4, 2, 163, 2, 189, 0, 15728640, 2, 177, -1, 2, 161, -1, 0, 4294934512, 3, 0, 4, -9, 2, 90, 2, 170, 2, 184, 3, 0, 4, 0, 704, 0, 1849688064, 2, 185, -1, 2, 124, 0, 4294901887, 2, 0, 0, 130547712, 0, 1879048192, 2, 199, 3, 0, 2, -1, 2, 186, 2, 187, -1, 0, 17829776, 0, 2025848832, 0, 4261477888, -2, 2, 0, -1, 0, 4286580608, -1, 0, 29360128, 2, 192, 0, 16252928, 0, 3791388672, 2, 38, 3, 0, 2, -2, 2, 196, 2, 0, -1, 2, 103, -1, 0, 66584576, -1, 2, 191, 3, 0, 9, 2, 124, -1, 0, 4294755328, 3, 0, 2, -1, 2, 161, 2, 178, 3, 0, 2, 2, 23, 2, 188, 2, 90, -2, 0, 245760, 0, 2147418112, -1, 2, 150, 2, 203, 0, 4227923456, -1, 2, 164, 2, 161, 2, 90, -3, 0, 4292870145, 0, 262144, 2, 124, 3, 0, 2, 0, 1073758848, 2, 189, -1, 0, 4227921920, 2, 190, 0, 68289024, 0, 528402016, 0, 4292927536, 3, 0, 4, -2, 0, 268435456, 2, 91, -2, 2, 191, 3, 0, 5, -1, 2, 192, 2, 163, 2, 0, -2, 0, 4227923936, 2, 62, -1, 2, 155, 2, 95, 2, 0, 2, 154, 2, 158, 3, 0, 6, -1, 2, 177, 3, 0, 3, -2, 0, 2146959360, 0, 9440640, 0, 104857600, 0, 4227923840, 3, 0, 2, 0, 768, 2, 193, 2, 77, -2, 2, 161, -2, 2, 119, -1, 2, 155, 3, 0, 8, 0, 512, 0, 8388608, 2, 194, 2, 172, 2, 187, 0, 4286578944, 3, 0, 2, 0, 1152, 0, 1266679808, 2, 191, 0, 576, 0, 4261707776, 2, 95, 3, 0, 9, 2, 155, 3, 0, 5, 2, 16, -1, 0, 2147221504, -28, 2, 178, 3, 0, 3, -3, 0, 4292902912, -6, 2, 96, 3, 0, 85, -33, 0, 4294934528, 3, 0, 126, -18, 2, 195, 3, 0, 269, -17, 2, 155, 2, 124, 2, 198, 3, 0, 2, 2, 23, 0, 4290822144, -2, 0, 67174336, 0, 520093700, 2, 17, 3, 0, 21, -2, 2, 179, 3, 0, 3, -2, 0, 30720, -1, 0, 32512, 3, 0, 2, 0, 4294770656, -191, 2, 174, -38, 2, 170, 2, 0, 2, 196, 3, 0, 279, -8, 2, 124, 2, 0, 0, 4294508543, 0, 65295, -11, 2, 177, 3, 0, 72, -3, 0, 3758159872, 0, 201391616, 3, 0, 155, -7, 2, 170, -1, 0, 384, -1, 0, 133693440, -3, 2, 196, -2, 2, 26, 3, 0, 4, 2, 169, -2, 2, 90, 2, 155, 3, 0, 4, -2, 2, 164, -1, 2, 150, 0, 335552923, 2, 197, -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, 6, -1, 0, 3221282816, 2, 198, 3, 0, 11, -1, 2, 199, 3, 0, 40, -6, 0, 4286578784, 2, 0, -2, 0, 1006694400, 3, 0, 24, 2, 35, -1, 2, 94, 3, 0, 2, 0, 1, 2, 163, 3, 0, 6, 2, 197, 0, 4110942569, 0, 1432950139, 0, 2701658217, 0, 4026532864, 0, 4026532881, 2, 0, 2, 45, 3, 0, 8, -1, 2, 158, -2, 2, 169, 0, 98304, 0, 65537, 2, 170, -5, 0, 4294950912, 2, 0, 2, 118, 0, 65528, 2, 177, 0, 4294770176, 2, 26, 3, 0, 4, -30, 2, 174, 0, 3758153728, -3, 2, 169, -2, 2, 155, 2, 188, 2, 158, -1, 2, 191, -1, 2, 161, 0, 4294754304, 3, 0, 2, -3, 0, 33554432, -2, 2, 200, -3, 2, 169, 0, 4175478784, 2, 201, 0, 4286643712, 0, 4286644216, 2, 0, -4, 2, 202, -1, 2, 165, 0, 4227923967, 3, 0, 32, -1334, 2, 163, 2, 0, -129, 2, 94, -6, 2, 163, -180, 2, 203, -233, 2, 4, 3, 0, 96, -16, 2, 163, 3, 0, 47, -154, 2, 165, 3, 0, 22381, -7, 2, 17, 3, 0, 6128], [4294967295, 4294967291, 4092460543, 4294828031, 4294967294, 134217726, 268435455, 2147483647, 1048575, 1073741823, 3892314111, 134217727, 1061158911, 536805376, 4294910143, 4160749567, 4294901759, 4294901760, 536870911, 262143, 8388607, 4294902783, 4294918143, 65535, 67043328, 2281701374, 4294967232, 2097151, 4294903807, 4194303, 255, 67108863, 4294967039, 511, 524287, 131071, 127, 4292870143, 4294902271, 4294549487, 33554431, 1023, 67047423, 4294901888, 4286578687, 4294770687, 67043583, 32767, 15, 2047999, 67043343, 16777215, 4294902000, 4294934527, 4294966783, 4294967279, 2047, 262083, 20511, 4290772991, 41943039, 493567, 4294959104, 603979775, 65536, 602799615, 805044223, 4294965206, 8191, 1031749119, 4294917631, 2134769663, 4286578493, 4282253311, 4294942719, 33540095, 4294905855, 4294967264, 2868854591, 1608515583, 265232348, 534519807, 2147614720, 1060109444, 4093640016, 17376, 2139062143, 224, 4169138175, 4294909951, 4286578688, 4294967292, 4294965759, 2044, 4292870144, 4294966272, 4294967280, 8289918, 4294934399, 4294901775, 4294965375, 1602223615, 4294967259, 4294443008, 268369920, 4292804608, 486341884, 4294963199, 3087007615, 1073692671, 4128527, 4279238655, 4294902015, 4294966591, 2445279231, 3670015, 3238002687, 31, 63, 4294967288, 4294705151, 4095, 3221208447, 4294549472, 2147483648, 4285526655, 4294966527, 4294705152, 4294966143, 64, 4294966719, 16383, 3774873592, 458752, 536807423, 67043839, 3758096383, 3959414372, 3755993023, 2080374783, 4294835295, 4294967103, 4160749565, 4087, 184024726, 2862017156, 1593309078, 268434431, 268434414, 4294901763, 536870912, 2952790016, 202506752, 139264, 402653184, 4261412864, 4227922944, 49152, 61440, 3758096384, 117440512, 65280, 3233808384, 3221225472, 2097152, 4294965248, 32768, 57152, 67108864, 4293918720, 4290772992, 25165824, 57344, 4227915776, 4278190080, 4227907584, 65520, 4026531840, 4227858432, 4160749568, 3758129152, 4294836224, 63488, 1073741824, 4294967040, 4194304, 251658240, 196608, 4294963200, 64512, 417808, 4227923712, 12582912, 50331648, 65472, 4294967168, 4294966784, 16, 4294917120, 2080374784, 4096, 65408, 524288, 65532]); + +function advanceChar(parser) {
+ parser.column++;
+ return (parser.currentChar = parser.source.charCodeAt(++parser.index));
+}
+function consumeMultiUnitCodePoint(parser, hi) {
+ if ((hi & 0xfc00) !== 55296)
+ return 0;
+ const lo = parser.source.charCodeAt(parser.index + 1);
+ if ((lo & 0xfc00) !== 0xdc00)
+ return 0;
+ hi = parser.currentChar = 65536 + ((hi & 0x3ff) << 10) + (lo & 0x3ff);
+ if (((unicodeLookup[(hi >>> 5) + 0] >>> hi) & 31 & 1) === 0) {
+ report(parser, 18, fromCodePoint(hi));
+ }
+ parser.index++;
+ parser.column++;
+ return 1;
+}
+function consumeLineFeed(parser, state) {
+ parser.currentChar = parser.source.charCodeAt(++parser.index);
+ parser.flags |= 1;
+ if ((state & 4) === 0) {
+ parser.column = 0;
+ parser.line++;
+ }
+}
+function scanNewLine(parser) {
+ parser.flags |= 1;
+ parser.currentChar = parser.source.charCodeAt(++parser.index);
+ parser.column = 0;
+ parser.line++;
+}
+function isExoticECMAScriptWhitespace(ch) {
+ return (ch === 160 ||
+ ch === 65279 ||
+ ch === 133 ||
+ ch === 5760 ||
+ (ch >= 8192 && ch <= 8203) ||
+ ch === 8239 ||
+ ch === 8287 ||
+ ch === 12288 ||
+ ch === 8201 ||
+ ch === 65519);
+}
+function fromCodePoint(codePoint) {
+ return codePoint <= 65535
+ ? String.fromCharCode(codePoint)
+ : String.fromCharCode(codePoint >>> 10) + String.fromCharCode(codePoint & 0x3ff);
+}
+function toHex(code) {
+ return code < 65 ? code - 48 : (code - 65 + 10) & 0xf;
+}
+function convertTokenType(t) {
+ switch (t) {
+ case 134283266:
+ return 'NumericLiteral';
+ case 134283267:
+ return 'StringLiteral';
+ case 86021:
+ case 86022:
+ return 'BooleanLiteral';
+ case 86023:
+ return 'NullLiteral';
+ case 65540:
+ return 'RegularExpression';
+ case 67174408:
+ case 67174409:
+ case 132:
+ return 'TemplateLiteral';
+ default:
+ if ((t & 143360) === 143360)
+ return 'Identifier';
+ if ((t & 4096) === 4096)
+ return 'Keyword';
+ return 'Punctuator';
+ }
+} + +const CharTypes = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 8 | 1024,
+ 0,
+ 0,
+ 8 | 2048,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 8192,
+ 0,
+ 1 | 2,
+ 0,
+ 0,
+ 8192,
+ 0,
+ 0,
+ 0,
+ 256,
+ 0,
+ 256 | 32768,
+ 0,
+ 0,
+ 2 | 16 | 128 | 32 | 64,
+ 2 | 16 | 128 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 32 | 64,
+ 2 | 16 | 512 | 64,
+ 2 | 16 | 512 | 64,
+ 0,
+ 0,
+ 16384,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1 | 2 | 64,
+ 1 | 2 | 64,
+ 1 | 2 | 64,
+ 1 | 2 | 64,
+ 1 | 2 | 64,
+ 1 | 2 | 64,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 1 | 2,
+ 0,
+ 1,
+ 0,
+ 0,
+ 1 | 2 | 4096,
+ 0,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4 | 64,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 1 | 2 | 4,
+ 16384,
+ 0,
+ 0,
+ 0,
+ 0
+];
+const isIdStart = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+];
+const isIdPart = [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+];
+function isIdentifierStart(code) {
+ return code <= 0x7F
+ ? isIdStart[code]
+ : (unicodeLookup[(code >>> 5) + 34816] >>> code) & 31 & 1;
+}
+function isIdentifierPart(code) {
+ return code <= 0x7F
+ ? isIdPart[code]
+ : (unicodeLookup[(code >>> 5) + 0] >>> code) & 31 & 1 || (code === 8204 || code === 8205);
+} + +const CommentTypes = ['SingleLine', 'MultiLine', 'HTMLOpen', 'HTMLClose', 'HashbangComment'];
+function skipHashBang(parser) {
+ const source = parser.source;
+ if (parser.currentChar === 35 && source.charCodeAt(parser.index + 1) === 33) {
+ advanceChar(parser);
+ advanceChar(parser);
+ skipSingleLineComment(parser, source, 0, 4, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+}
+function skipSingleHTMLComment(parser, source, state, context, type, start, line, column) {
+ if (context & 2048)
+ report(parser, 0);
+ return skipSingleLineComment(parser, source, state, type, start, line, column);
+}
+function skipSingleLineComment(parser, source, state, type, start, line, column) {
+ const { index } = parser;
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ while (parser.index < parser.end) {
+ if (CharTypes[parser.currentChar] & 8) {
+ const isCR = parser.currentChar === 13;
+ scanNewLine(parser);
+ if (isCR && parser.index < parser.end && parser.currentChar === 10)
+ parser.currentChar = source.charCodeAt(++parser.index);
+ break;
+ }
+ else if ((parser.currentChar ^ 8232) <= 1) {
+ scanNewLine(parser);
+ break;
+ }
+ advanceChar(parser);
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ }
+ if (parser.onComment) {
+ const loc = {
+ start: {
+ line,
+ column
+ },
+ end: {
+ line: parser.linePos,
+ column: parser.colPos
+ }
+ };
+ parser.onComment(CommentTypes[type & 0xff], source.slice(index, parser.tokenPos), start, parser.tokenPos, loc);
+ }
+ return state | 1;
+}
+function skipMultiLineComment(parser, source, state) {
+ const { index } = parser;
+ while (parser.index < parser.end) {
+ if (parser.currentChar < 0x2b) {
+ let skippedOneAsterisk = false;
+ while (parser.currentChar === 42) {
+ if (!skippedOneAsterisk) {
+ state &= ~4;
+ skippedOneAsterisk = true;
+ }
+ if (advanceChar(parser) === 47) {
+ advanceChar(parser);
+ if (parser.onComment) {
+ const loc = {
+ start: {
+ line: parser.linePos,
+ column: parser.colPos
+ },
+ end: {
+ line: parser.line,
+ column: parser.column
+ }
+ };
+ parser.onComment(CommentTypes[1 & 0xff], source.slice(index, parser.index - 2), index - 2, parser.index, loc);
+ }
+ parser.tokenPos = parser.index;
+ parser.linePos = parser.line;
+ parser.colPos = parser.column;
+ return state;
+ }
+ }
+ if (skippedOneAsterisk) {
+ continue;
+ }
+ if (CharTypes[parser.currentChar] & 8) {
+ if (parser.currentChar === 13) {
+ state |= 1 | 4;
+ scanNewLine(parser);
+ }
+ else {
+ consumeLineFeed(parser, state);
+ state = (state & ~4) | 1;
+ }
+ }
+ else {
+ advanceChar(parser);
+ }
+ }
+ else if ((parser.currentChar ^ 8232) <= 1) {
+ state = (state & ~4) | 1;
+ scanNewLine(parser);
+ }
+ else {
+ state &= ~4;
+ advanceChar(parser);
+ }
+ }
+ report(parser, 16);
+} + +function scanRegularExpression(parser, context) {
+ const bodyStart = parser.index;
+ let preparseState = 0;
+ loop: while (true) {
+ const ch = parser.currentChar;
+ advanceChar(parser);
+ if (preparseState & 1) {
+ preparseState &= ~1;
+ }
+ else {
+ switch (ch) {
+ case 47:
+ if (!preparseState)
+ break loop;
+ else
+ break;
+ case 92:
+ preparseState |= 1;
+ break;
+ case 91:
+ preparseState |= 2;
+ break;
+ case 93:
+ preparseState &= 1;
+ break;
+ case 13:
+ case 10:
+ case 8232:
+ case 8233:
+ report(parser, 32);
+ }
+ }
+ if (parser.index >= parser.source.length) {
+ return report(parser, 32);
+ }
+ }
+ const bodyEnd = parser.index - 1;
+ let mask = 0;
+ let char = parser.currentChar;
+ const { index: flagStart } = parser;
+ while (isIdentifierPart(char)) {
+ switch (char) {
+ case 103:
+ if (mask & 2)
+ report(parser, 34, 'g');
+ mask |= 2;
+ break;
+ case 105:
+ if (mask & 1)
+ report(parser, 34, 'i');
+ mask |= 1;
+ break;
+ case 109:
+ if (mask & 4)
+ report(parser, 34, 'm');
+ mask |= 4;
+ break;
+ case 117:
+ if (mask & 16)
+ report(parser, 34, 'g');
+ mask |= 16;
+ break;
+ case 121:
+ if (mask & 8)
+ report(parser, 34, 'y');
+ mask |= 8;
+ break;
+ case 115:
+ if (mask & 12)
+ report(parser, 34, 's');
+ mask |= 12;
+ break;
+ default:
+ report(parser, 33);
+ }
+ char = advanceChar(parser);
+ }
+ const flags = parser.source.slice(flagStart, parser.index);
+ const pattern = parser.source.slice(bodyStart, bodyEnd);
+ parser.tokenRegExp = { pattern, flags };
+ if (context & 512)
+ parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+ parser.tokenValue = validate(parser, pattern, flags);
+ return 65540;
+}
+function validate(parser, pattern, flags) {
+ try {
+ return new RegExp(pattern, flags);
+ }
+ catch (e) {
+ report(parser, 32);
+ }
+} + +function scanString(parser, context, quote) {
+ const { index: start } = parser;
+ let ret = '';
+ let char = advanceChar(parser);
+ let marker = parser.index;
+ while ((CharTypes[char] & 8) === 0) {
+ if (char === quote) {
+ ret += parser.source.slice(marker, parser.index);
+ advanceChar(parser);
+ if (context & 512)
+ parser.tokenRaw = parser.source.slice(start, parser.index);
+ parser.tokenValue = ret;
+ return 134283267;
+ }
+ if ((char & 8) === 8 && char === 92) {
+ ret += parser.source.slice(marker, parser.index);
+ char = advanceChar(parser);
+ if (char < 0x7f || char === 8232 || char === 8233) {
+ const code = parseEscape(parser, context, char);
+ if (code >= 0)
+ ret += fromCodePoint(code);
+ else
+ handleStringError(parser, code, 0);
+ }
+ else {
+ ret += fromCodePoint(char);
+ }
+ marker = parser.index + 1;
+ }
+ if (parser.index >= parser.end)
+ report(parser, 14);
+ char = advanceChar(parser);
+ }
+ report(parser, 14);
+}
+function parseEscape(parser, context, first) {
+ switch (first) {
+ case 98:
+ return 8;
+ case 102:
+ return 12;
+ case 114:
+ return 13;
+ case 110:
+ return 10;
+ case 116:
+ return 9;
+ case 118:
+ return 11;
+ case 13: {
+ if (parser.index < parser.end) {
+ const nextChar = parser.source.charCodeAt(parser.index + 1);
+ if (nextChar === 10) {
+ parser.index = parser.index + 1;
+ parser.currentChar = nextChar;
+ }
+ }
+ }
+ case 10:
+ case 8232:
+ case 8233:
+ parser.column = -1;
+ parser.line++;
+ return -1;
+ case 48:
+ case 49:
+ case 50:
+ case 51: {
+ let code = first - 48;
+ let index = parser.index + 1;
+ let column = parser.column + 1;
+ if (index < parser.end) {
+ const next = parser.source.charCodeAt(index);
+ if ((CharTypes[next] & 32) === 0) {
+ if ((code !== 0 || CharTypes[next] & 512) && context & 1024)
+ return -2;
+ }
+ else if (context & 1024) {
+ return -2;
+ }
+ else {
+ parser.currentChar = next;
+ code = (code << 3) | (next - 48);
+ index++;
+ column++;
+ if (index < parser.end) {
+ const next = parser.source.charCodeAt(index);
+ if (CharTypes[next] & 32) {
+ parser.currentChar = next;
+ code = (code << 3) | (next - 48);
+ index++;
+ column++;
+ }
+ }
+ parser.flags |= 64;
+ parser.index = index - 1;
+ parser.column = column - 1;
+ }
+ }
+ return code;
+ }
+ case 52:
+ case 53:
+ case 54:
+ case 55: {
+ if (context & 1024)
+ return -2;
+ let code = first - 48;
+ const index = parser.index + 1;
+ const column = parser.column + 1;
+ if (index < parser.end) {
+ const next = parser.source.charCodeAt(index);
+ if (CharTypes[next] & 32) {
+ code = (code << 3) | (next - 48);
+ parser.currentChar = next;
+ parser.index = index;
+ parser.column = column;
+ }
+ }
+ parser.flags |= 64;
+ return code;
+ }
+ case 120: {
+ const ch1 = advanceChar(parser);
+ if ((CharTypes[ch1] & 64) === 0)
+ return -4;
+ const hi = toHex(ch1);
+ const ch2 = advanceChar(parser);
+ if ((CharTypes[ch2] & 64) === 0)
+ return -4;
+ const lo = toHex(ch2);
+ return (hi << 4) | lo;
+ }
+ case 117: {
+ const ch = advanceChar(parser);
+ if (parser.currentChar === 123) {
+ let code = 0;
+ while ((CharTypes[advanceChar(parser)] & 64) !== 0) {
+ code = (code << 4) | toHex(parser.currentChar);
+ if (code > 1114111)
+ return -5;
+ }
+ if (parser.currentChar < 1 || parser.currentChar !== 125) {
+ return -4;
+ }
+ return code;
+ }
+ else {
+ if ((CharTypes[ch] & 64) === 0)
+ return -4;
+ const ch2 = parser.source.charCodeAt(parser.index + 1);
+ if ((CharTypes[ch2] & 64) === 0)
+ return -4;
+ const ch3 = parser.source.charCodeAt(parser.index + 2);
+ if ((CharTypes[ch3] & 64) === 0)
+ return -4;
+ const ch4 = parser.source.charCodeAt(parser.index + 3);
+ if ((CharTypes[ch4] & 64) === 0)
+ return -4;
+ parser.index += 3;
+ parser.column += 3;
+ parser.currentChar = parser.source.charCodeAt(parser.index);
+ return (toHex(ch) << 12) | (toHex(ch2) << 8) | (toHex(ch3) << 4) | toHex(ch4);
+ }
+ }
+ case 56:
+ case 57:
+ if ((context & 256) === 0)
+ return -3;
+ default:
+ return first;
+ }
+}
+function handleStringError(state, code, isTemplate) {
+ switch (code) {
+ case -1:
+ return;
+ case -2:
+ report(state, isTemplate ? 2 : 1);
+ case -3:
+ report(state, 13);
+ case -4:
+ report(state, 6);
+ case -5:
+ report(state, 101);
+ }
+} + +function scanTemplate(parser, context) {
+ const { index: start } = parser;
+ let token = 67174409;
+ let ret = '';
+ let char = advanceChar(parser);
+ while (char !== 96) {
+ if (char === 36 && parser.source.charCodeAt(parser.index + 1) === 123) {
+ advanceChar(parser);
+ token = 67174408;
+ break;
+ }
+ else if ((char & 8) === 8 && char === 92) {
+ char = advanceChar(parser);
+ if (char > 0x7e) {
+ ret += fromCodePoint(char);
+ }
+ else {
+ const code = parseEscape(parser, context | 1024, char);
+ if (code >= 0) {
+ ret += fromCodePoint(code);
+ }
+ else if (code !== -1 && context & 65536) {
+ ret = undefined;
+ char = scanBadTemplate(parser, char);
+ if (char < 0)
+ token = 67174408;
+ break;
+ }
+ else {
+ handleStringError(parser, code, 1);
+ }
+ }
+ }
+ else {
+ if (parser.index < parser.end &&
+ char === 13 &&
+ parser.source.charCodeAt(parser.index) === 10) {
+ ret += fromCodePoint(char);
+ parser.currentChar = parser.source.charCodeAt(++parser.index);
+ }
+ if (((char & 83) < 3 && char === 10) || (char ^ 8232) <= 1) {
+ parser.column = -1;
+ parser.line++;
+ }
+ ret += fromCodePoint(char);
+ }
+ if (parser.index >= parser.end)
+ report(parser, 15);
+ char = advanceChar(parser);
+ }
+ advanceChar(parser);
+ parser.tokenValue = ret;
+ parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+ return token;
+}
+function scanBadTemplate(parser, ch) {
+ while (ch !== 96) {
+ switch (ch) {
+ case 36: {
+ const index = parser.index + 1;
+ if (index < parser.end && parser.source.charCodeAt(index) === 123) {
+ parser.index = index;
+ parser.column++;
+ return -ch;
+ }
+ break;
+ }
+ case 10:
+ case 8232:
+ case 8233:
+ parser.column = -1;
+ parser.line++;
+ }
+ if (parser.index >= parser.end)
+ report(parser, 15);
+ ch = advanceChar(parser);
+ }
+ return ch;
+}
+function scanTemplateTail(parser, context) {
+ if (parser.index >= parser.end)
+ report(parser, 0);
+ parser.index--;
+ parser.column--;
+ return scanTemplate(parser, context);
+} + +function scanNumber(parser, context, kind) {
+ let char = parser.currentChar;
+ let value = 0;
+ let digit = 9;
+ let atStart = kind & 64 ? 0 : 1;
+ let digits = 0;
+ let allowSeparator = 0;
+ if (kind & 64) {
+ value = '.' + scanDecimalDigitsOrSeparator(parser, char);
+ char = parser.currentChar;
+ if (char === 110)
+ report(parser, 11);
+ }
+ else {
+ if (char === 48) {
+ char = advanceChar(parser);
+ if ((char | 32) === 120) {
+ kind = 8 | 128;
+ char = advanceChar(parser);
+ while (CharTypes[char] & (64 | 4096)) {
+ if (char === 95) {
+ if (!allowSeparator)
+ report(parser, 146);
+ allowSeparator = 0;
+ char = advanceChar(parser);
+ continue;
+ }
+ allowSeparator = 1;
+ value = value * 0x10 + toHex(char);
+ digits++;
+ char = advanceChar(parser);
+ }
+ if (digits < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 19 : 147);
+ }
+ }
+ else if ((char | 32) === 111) {
+ kind = 4 | 128;
+ char = advanceChar(parser);
+ while (CharTypes[char] & (32 | 4096)) {
+ if (char === 95) {
+ if (!allowSeparator) {
+ report(parser, 146);
+ }
+ allowSeparator = 0;
+ char = advanceChar(parser);
+ continue;
+ }
+ allowSeparator = 1;
+ value = value * 8 + (char - 48);
+ digits++;
+ char = advanceChar(parser);
+ }
+ if (digits < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 0 : 147);
+ }
+ }
+ else if ((char | 32) === 98) {
+ kind = 2 | 128;
+ char = advanceChar(parser);
+ while (CharTypes[char] & (128 | 4096)) {
+ if (char === 95) {
+ if (!allowSeparator) {
+ report(parser, 146);
+ }
+ allowSeparator = 0;
+ char = advanceChar(parser);
+ continue;
+ }
+ allowSeparator = 1;
+ value = value * 2 + (char - 48);
+ digits++;
+ char = advanceChar(parser);
+ }
+ if (digits < 1 || !allowSeparator) {
+ report(parser, digits < 1 ? 0 : 147);
+ }
+ }
+ else if (CharTypes[char] & 32) {
+ if (context & 1024)
+ report(parser, 1);
+ kind = 1;
+ while (CharTypes[char] & 16) {
+ if (CharTypes[char] & 512) {
+ kind = 32;
+ atStart = 0;
+ break;
+ }
+ value = value * 8 + (char - 48);
+ char = advanceChar(parser);
+ }
+ }
+ else if (CharTypes[char] & 512) {
+ if (context & 1024)
+ report(parser, 1);
+ parser.flags |= 64;
+ kind = 32;
+ }
+ else if (char === 95) {
+ report(parser, 0);
+ }
+ }
+ if (kind & 48) {
+ if (atStart) {
+ while (digit >= 0 && CharTypes[char] & (16 | 4096)) {
+ if (char === 95) {
+ char = advanceChar(parser);
+ if (char === 95 || kind & 32) {
+ reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+ }
+ allowSeparator = 1;
+ continue;
+ }
+ allowSeparator = 0;
+ value = 10 * value + (char - 48);
+ char = advanceChar(parser);
+ --digit;
+ }
+ if (allowSeparator) {
+ reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+ }
+ if (digit >= 0 && !isIdentifierStart(char) && char !== 46) {
+ parser.tokenValue = value;
+ if (context & 512)
+ parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+ return 134283266;
+ }
+ }
+ value += scanDecimalDigitsOrSeparator(parser, char);
+ char = parser.currentChar;
+ if (char === 46) {
+ if (advanceChar(parser) === 95)
+ report(parser, 0);
+ kind = 64;
+ value += '.' + scanDecimalDigitsOrSeparator(parser, parser.currentChar);
+ char = parser.currentChar;
+ }
+ }
+ }
+ const end = parser.index;
+ let isBigInt = 0;
+ if (char === 110 && kind & 128) {
+ isBigInt = 1;
+ char = advanceChar(parser);
+ }
+ else {
+ if ((char | 32) === 101) {
+ char = advanceChar(parser);
+ if (CharTypes[char] & 256)
+ char = advanceChar(parser);
+ const { index } = parser;
+ if ((CharTypes[char] & 16) < 1)
+ report(parser, 10);
+ value += parser.source.substring(end, index) + scanDecimalDigitsOrSeparator(parser, char);
+ char = parser.currentChar;
+ }
+ }
+ if ((parser.index < parser.end && CharTypes[char] & 16) || isIdentifierStart(char)) {
+ report(parser, 12);
+ }
+ if (isBigInt) {
+ parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+ parser.tokenValue = BigInt(value);
+ return 134283389;
+ }
+ parser.tokenValue =
+ kind & (1 | 2 | 8 | 4)
+ ? value
+ : kind & 32
+ ? parseFloat(parser.source.substring(parser.tokenPos, parser.index))
+ : +value;
+ if (context & 512)
+ parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+ return 134283266;
+}
+function scanDecimalDigitsOrSeparator(parser, char) {
+ let allowSeparator = 0;
+ let start = parser.index;
+ let ret = '';
+ while (CharTypes[char] & (16 | 4096)) {
+ if (char === 95) {
+ const { index } = parser;
+ char = advanceChar(parser);
+ if (char === 95) {
+ reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+ }
+ allowSeparator = 1;
+ ret += parser.source.substring(start, index);
+ start = parser.index;
+ continue;
+ }
+ allowSeparator = 0;
+ char = advanceChar(parser);
+ }
+ if (allowSeparator) {
+ reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+ }
+ return ret + parser.source.substring(start, parser.index);
+} + +const KeywordDescTable = [
+ 'end of source',
+ 'identifier', 'number', 'string', 'regular expression',
+ 'false', 'true', 'null',
+ 'template continuation', 'template tail',
+ '=>', '(', '{', '.', '...', '}', ')', ';', ',', '[', ']', ':', '?', '\'', '"', '</', '/>',
+ '++', '--',
+ '=', '<<=', '>>=', '>>>=', '**=', '+=', '-=', '*=', '/=', '%=', '^=', '|=',
+ '&=', '||=', '&&=', '??=',
+ 'typeof', 'delete', 'void', '!', '~', '+', '-', 'in', 'instanceof', '*', '%', '/', '**', '&&',
+ '||', '===', '!==', '==', '!=', '<=', '>=', '<', '>', '<<', '>>', '>>>', '&', '|', '^',
+ 'var', 'let', 'const',
+ 'break', 'case', 'catch', 'class', 'continue', 'debugger', 'default', 'do', 'else', 'export',
+ 'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
+ 'this', 'throw', 'try', 'while', 'with',
+ 'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
+ 'as', 'async', 'await', 'constructor', 'get', 'set', 'from', 'of',
+ 'enum', 'eval', 'arguments', 'escaped keyword', 'escaped future reserved keyword', 'reserved if strict', '#',
+ 'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
+ 'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
+];
+const descKeywordTable = Object.create(null, {
+ this: { value: 86113 },
+ function: { value: 86106 },
+ if: { value: 20571 },
+ return: { value: 20574 },
+ var: { value: 86090 },
+ else: { value: 20565 },
+ for: { value: 20569 },
+ new: { value: 86109 },
+ in: { value: 8738868 },
+ typeof: { value: 16863277 },
+ while: { value: 20580 },
+ case: { value: 20558 },
+ break: { value: 20557 },
+ try: { value: 20579 },
+ catch: { value: 20559 },
+ delete: { value: 16863278 },
+ throw: { value: 86114 },
+ switch: { value: 86112 },
+ continue: { value: 20561 },
+ default: { value: 20563 },
+ instanceof: { value: 8476725 },
+ do: { value: 20564 },
+ void: { value: 16863279 },
+ finally: { value: 20568 },
+ async: { value: 209007 },
+ await: { value: 209008 },
+ class: { value: 86096 },
+ const: { value: 86092 },
+ constructor: { value: 12401 },
+ debugger: { value: 20562 },
+ export: { value: 20566 },
+ extends: { value: 20567 },
+ false: { value: 86021 },
+ from: { value: 12404 },
+ get: { value: 12402 },
+ implements: { value: 36966 },
+ import: { value: 86108 },
+ interface: { value: 36967 },
+ let: { value: 241739 },
+ null: { value: 86023 },
+ of: { value: 274549 },
+ package: { value: 36968 },
+ private: { value: 36969 },
+ protected: { value: 36970 },
+ public: { value: 36971 },
+ set: { value: 12403 },
+ static: { value: 36972 },
+ super: { value: 86111 },
+ true: { value: 86022 },
+ with: { value: 20581 },
+ yield: { value: 241773 },
+ enum: { value: 86134 },
+ eval: { value: 537079927 },
+ as: { value: 77934 },
+ arguments: { value: 537079928 },
+ target: { value: 143494 },
+ meta: { value: 143495 },
+}); + +function scanIdentifier(parser, context, isValidAsKeyword) {
+ while (isIdPart[advanceChar(parser)]) { }
+ parser.tokenValue = parser.source.slice(parser.tokenPos, parser.index);
+ return parser.currentChar !== 92 && parser.currentChar < 0x7e
+ ? descKeywordTable[parser.tokenValue] || 208897
+ : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+}
+function scanUnicodeIdentifier(parser, context) {
+ const cookedChar = scanIdentifierUnicodeEscape(parser);
+ if (!isIdentifierPart(cookedChar))
+ report(parser, 4);
+ parser.tokenValue = fromCodePoint(cookedChar);
+ return scanIdentifierSlowCase(parser, context, 1, CharTypes[cookedChar] & 4);
+}
+function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
+ let start = parser.index;
+ while (parser.index < parser.end) {
+ if (parser.currentChar === 92) {
+ parser.tokenValue += parser.source.slice(start, parser.index);
+ hasEscape = 1;
+ const code = scanIdentifierUnicodeEscape(parser);
+ if (!isIdentifierPart(code))
+ report(parser, 4);
+ isValidAsKeyword = isValidAsKeyword && CharTypes[code] & 4;
+ parser.tokenValue += fromCodePoint(code);
+ start = parser.index;
+ }
+ else if (isIdentifierPart(parser.currentChar) || consumeMultiUnitCodePoint(parser, parser.currentChar)) {
+ advanceChar(parser);
+ }
+ else {
+ break;
+ }
+ }
+ if (parser.index <= parser.end) {
+ parser.tokenValue += parser.source.slice(start, parser.index);
+ }
+ const length = parser.tokenValue.length;
+ if (isValidAsKeyword && length >= 2 && length <= 11) {
+ const token = descKeywordTable[parser.tokenValue];
+ if (token === void 0)
+ return 208897;
+ if (!hasEscape)
+ return token;
+ if (context & 1024) {
+ return token === 209008 && (context & (2048 | 4194304)) === 0
+ ? token
+ : token === 36972
+ ? 122
+ : (token & 36864) === 36864
+ ? 122
+ : 121;
+ }
+ if (context & 1073741824 &&
+ (context & 8192) === 0 &&
+ (token & 20480) === 20480)
+ return token;
+ if (token === 241773) {
+ return context & 1073741824
+ ? 143483
+ : context & 2097152
+ ? 121
+ : token;
+ }
+ return token === 209007 && context & 1073741824
+ ? 143483
+ : (token & 36864) === 36864
+ ? token
+ : token === 209008 && (context & 4194304) === 0
+ ? token
+ : 121;
+ }
+ return 208897;
+}
+function scanPrivateIdentifier(parser) {
+ if (!isIdentifierStart(advanceChar(parser)))
+ report(parser, 93);
+ return 131;
+}
+function scanIdentifierUnicodeEscape(parser) {
+ if (parser.source.charCodeAt(parser.index + 1) !== 117) {
+ report(parser, 4);
+ }
+ parser.currentChar = parser.source.charCodeAt((parser.index += 2));
+ return scanUnicodeEscape(parser);
+}
+function scanUnicodeEscape(parser) {
+ let codePoint = 0;
+ const char = parser.currentChar;
+ if (char === 123) {
+ const begin = parser.index - 2;
+ while (CharTypes[advanceChar(parser)] & 64) {
+ codePoint = (codePoint << 4) | toHex(parser.currentChar);
+ if (codePoint > 1114111)
+ reportScannerError(begin, parser.line, parser.index + 1, 101);
+ }
+ if (parser.currentChar !== 125) {
+ reportScannerError(begin, parser.line, parser.index - 1, 6);
+ }
+ advanceChar(parser);
+ return codePoint;
+ }
+ if ((CharTypes[char] & 64) === 0)
+ report(parser, 6);
+ const char2 = parser.source.charCodeAt(parser.index + 1);
+ if ((CharTypes[char2] & 64) === 0)
+ report(parser, 6);
+ const char3 = parser.source.charCodeAt(parser.index + 2);
+ if ((CharTypes[char3] & 64) === 0)
+ report(parser, 6);
+ const char4 = parser.source.charCodeAt(parser.index + 3);
+ if ((CharTypes[char4] & 64) === 0)
+ report(parser, 6);
+ codePoint = (toHex(char) << 12) | (toHex(char2) << 8) | (toHex(char3) << 4) | toHex(char4);
+ parser.currentChar = parser.source.charCodeAt((parser.index += 4));
+ return codePoint;
+} + +const TokenLookup = [
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 128,
+ 136,
+ 128,
+ 128,
+ 130,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 129,
+ 128,
+ 16842800,
+ 134283267,
+ 131,
+ 208897,
+ 8457015,
+ 8455751,
+ 134283267,
+ 67174411,
+ 16,
+ 8457014,
+ 25233970,
+ 18,
+ 25233971,
+ 67108877,
+ 8457016,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 134283266,
+ 21,
+ 1074790417,
+ 8456258,
+ 1077936157,
+ 8456259,
+ 22,
+ 133,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 208897,
+ 69271571,
+ 137,
+ 20,
+ 8455497,
+ 208897,
+ 132,
+ 4096,
+ 4096,
+ 4096,
+ 4096,
+ 4096,
+ 4096,
+ 4096,
+ 208897,
+ 4096,
+ 208897,
+ 208897,
+ 4096,
+ 208897,
+ 4096,
+ 208897,
+ 4096,
+ 208897,
+ 4096,
+ 4096,
+ 4096,
+ 208897,
+ 4096,
+ 4096,
+ 208897,
+ 4096,
+ 4096,
+ 2162700,
+ 8455240,
+ 1074790415,
+ 16842801,
+ 129
+];
+function nextToken(parser, context) {
+ parser.flags = (parser.flags | 1) ^ 1;
+ parser.startPos = parser.index;
+ parser.startColumn = parser.column;
+ parser.startLine = parser.line;
+ parser.token = scanSingleToken(parser, context, 0);
+ if (parser.onToken && parser.token !== 1048576) {
+ const loc = {
+ start: {
+ line: parser.linePos,
+ column: parser.colPos
+ },
+ end: {
+ line: parser.line,
+ column: parser.column
+ }
+ };
+ parser.onToken(convertTokenType(parser.token), parser.tokenPos, parser.index, loc);
+ }
+}
+function scanSingleToken(parser, context, state) {
+ const isStartOfLine = parser.index === 0;
+ const source = parser.source;
+ let startPos = parser.index;
+ let startLine = parser.line;
+ let startColumn = parser.column;
+ while (parser.index < parser.end) {
+ parser.tokenPos = parser.index;
+ parser.colPos = parser.column;
+ parser.linePos = parser.line;
+ let char = parser.currentChar;
+ if (char <= 0x7e) {
+ const token = TokenLookup[char];
+ switch (token) {
+ case 67174411:
+ case 16:
+ case 2162700:
+ case 1074790415:
+ case 69271571:
+ case 20:
+ case 21:
+ case 1074790417:
+ case 18:
+ case 16842801:
+ case 133:
+ case 129:
+ advanceChar(parser);
+ return token;
+ case 208897:
+ return scanIdentifier(parser, context, 0);
+ case 4096:
+ return scanIdentifier(parser, context, 1);
+ case 134283266:
+ return scanNumber(parser, context, 16 | 128);
+ case 134283267:
+ return scanString(parser, context, char);
+ case 132:
+ return scanTemplate(parser, context);
+ case 137:
+ return scanUnicodeIdentifier(parser, context);
+ case 131:
+ return scanPrivateIdentifier(parser);
+ case 128:
+ advanceChar(parser);
+ break;
+ case 130:
+ state |= 1 | 4;
+ scanNewLine(parser);
+ break;
+ case 136:
+ consumeLineFeed(parser, state);
+ state = (state & ~4) | 1;
+ break;
+ case 8456258:
+ let ch = advanceChar(parser);
+ if (parser.index < parser.end) {
+ if (ch === 60) {
+ if (parser.index < parser.end && advanceChar(parser) === 61) {
+ advanceChar(parser);
+ return 4194334;
+ }
+ return 8456516;
+ }
+ else if (ch === 61) {
+ advanceChar(parser);
+ return 8456000;
+ }
+ if (ch === 33) {
+ const index = parser.index + 1;
+ if (index + 1 < parser.end &&
+ source.charCodeAt(index) === 45 &&
+ source.charCodeAt(index + 1) == 45) {
+ parser.column += 3;
+ parser.currentChar = source.charCodeAt((parser.index += 3));
+ state = skipSingleHTMLComment(parser, source, state, context, 2, parser.tokenPos, parser.linePos, parser.colPos);
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ return 8456258;
+ }
+ if (ch === 47) {
+ if ((context & 16) < 1)
+ return 8456258;
+ const index = parser.index + 1;
+ if (index < parser.end) {
+ ch = source.charCodeAt(index);
+ if (ch === 42 || ch === 47)
+ break;
+ }
+ advanceChar(parser);
+ return 25;
+ }
+ }
+ return 8456258;
+ case 1077936157: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 61) {
+ if (advanceChar(parser) === 61) {
+ advanceChar(parser);
+ return 8455996;
+ }
+ return 8455998;
+ }
+ if (ch === 62) {
+ advanceChar(parser);
+ return 10;
+ }
+ return 1077936157;
+ }
+ case 16842800:
+ if (advanceChar(parser) !== 61) {
+ return 16842800;
+ }
+ if (advanceChar(parser) !== 61) {
+ return 8455999;
+ }
+ advanceChar(parser);
+ return 8455997;
+ case 8457015:
+ if (advanceChar(parser) !== 61)
+ return 8457015;
+ advanceChar(parser);
+ return 4194342;
+ case 8457014: {
+ advanceChar(parser);
+ if (parser.index >= parser.end)
+ return 8457014;
+ const ch = parser.currentChar;
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194340;
+ }
+ if (ch !== 42)
+ return 8457014;
+ if (advanceChar(parser) !== 61)
+ return 8457273;
+ advanceChar(parser);
+ return 4194337;
+ }
+ case 8455497:
+ if (advanceChar(parser) !== 61)
+ return 8455497;
+ advanceChar(parser);
+ return 4194343;
+ case 25233970: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 43) {
+ advanceChar(parser);
+ return 33619995;
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194338;
+ }
+ return 25233970;
+ }
+ case 25233971: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 45) {
+ advanceChar(parser);
+ if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
+ if ((context & 256) === 0)
+ report(parser, 108);
+ advanceChar(parser);
+ state = skipSingleHTMLComment(parser, source, state, context, 3, startPos, startLine, startColumn);
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ return 33619996;
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194339;
+ }
+ return 25233971;
+ }
+ case 8457016: {
+ advanceChar(parser);
+ if (parser.index < parser.end) {
+ const ch = parser.currentChar;
+ if (ch === 47) {
+ advanceChar(parser);
+ state = skipSingleLineComment(parser, source, state, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ if (ch === 42) {
+ advanceChar(parser);
+ state = skipMultiLineComment(parser, source, state);
+ startPos = parser.tokenPos;
+ startLine = parser.linePos;
+ startColumn = parser.colPos;
+ continue;
+ }
+ if (context & 32768) {
+ return scanRegularExpression(parser, context);
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4259877;
+ }
+ }
+ return 8457016;
+ }
+ case 67108877:
+ const next = advanceChar(parser);
+ if (next >= 48 && next <= 57)
+ return scanNumber(parser, context, 64 | 16);
+ if (next === 46) {
+ const index = parser.index + 1;
+ if (index < parser.end && source.charCodeAt(index) === 46) {
+ parser.column += 2;
+ parser.currentChar = source.charCodeAt((parser.index += 2));
+ return 14;
+ }
+ }
+ return 67108877;
+ case 8455240: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 124) {
+ advanceChar(parser);
+ if (parser.currentChar === 61) {
+ advanceChar(parser);
+ return 4194346;
+ }
+ return 8979003;
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194344;
+ }
+ return 8455240;
+ }
+ case 8456259: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 61) {
+ advanceChar(parser);
+ return 8456001;
+ }
+ if (ch !== 62)
+ return 8456259;
+ advanceChar(parser);
+ if (parser.index < parser.end) {
+ const ch = parser.currentChar;
+ if (ch === 62) {
+ if (advanceChar(parser) === 61) {
+ advanceChar(parser);
+ return 4194336;
+ }
+ return 8456518;
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194335;
+ }
+ }
+ return 8456517;
+ }
+ case 8455751: {
+ advanceChar(parser);
+ const ch = parser.currentChar;
+ if (ch === 38) {
+ advanceChar(parser);
+ if (parser.currentChar === 61) {
+ advanceChar(parser);
+ return 4194347;
+ }
+ return 8979258;
+ }
+ if (ch === 61) {
+ advanceChar(parser);
+ return 4194345;
+ }
+ return 8455751;
+ }
+ case 22: {
+ let ch = advanceChar(parser);
+ if (ch === 63) {
+ advanceChar(parser);
+ if (parser.currentChar === 61) {
+ advanceChar(parser);
+ return 4194348;
+ }
+ return 276889982;
+ }
+ if (ch === 46) {
+ const index = parser.index + 1;
+ if (index < parser.end) {
+ ch = source.charCodeAt(index);
+ if (!(ch >= 48 && ch <= 57)) {
+ advanceChar(parser);
+ return 67108991;
+ }
+ }
+ }
+ return 22;
+ }
+ }
+ }
+ else {
+ if ((char ^ 8232) <= 1) {
+ state = (state & ~4) | 1;
+ scanNewLine(parser);
+ continue;
+ }
+ if ((char & 0xfc00) === 0xd800 || ((unicodeLookup[(char >>> 5) + 34816] >>> char) & 31 & 1) !== 0) {
+ if ((char & 0xfc00) === 0xdc00) {
+ char = ((char & 0x3ff) << 10) | (char & 0x3ff) | 0x10000;
+ if (((unicodeLookup[(char >>> 5) + 0] >>> char) & 31 & 1) === 0) {
+ report(parser, 18, fromCodePoint(char));
+ }
+ parser.index++;
+ parser.currentChar = char;
+ }
+ parser.column++;
+ parser.tokenValue = '';
+ return scanIdentifierSlowCase(parser, context, 0, 0);
+ }
+ if (isExoticECMAScriptWhitespace(char)) {
+ advanceChar(parser);
+ continue;
+ }
+ report(parser, 18, fromCodePoint(char));
+ }
+ }
+ return 1048576;
+} + +const entities = {
+ AElig: '\u00C6',
+ AMP: '\u0026',
+ Aacute: '\u00C1',
+ Abreve: '\u0102',
+ Acirc: '\u00C2',
+ Acy: '\u0410',
+ Afr: '\uD835\uDD04',
+ Agrave: '\u00C0',
+ Alpha: '\u0391',
+ Amacr: '\u0100',
+ And: '\u2A53',
+ Aogon: '\u0104',
+ Aopf: '\uD835\uDD38',
+ ApplyFunction: '\u2061',
+ Aring: '\u00C5',
+ Ascr: '\uD835\uDC9C',
+ Assign: '\u2254',
+ Atilde: '\u00C3',
+ Auml: '\u00C4',
+ Backslash: '\u2216',
+ Barv: '\u2AE7',
+ Barwed: '\u2306',
+ Bcy: '\u0411',
+ Because: '\u2235',
+ Bernoullis: '\u212C',
+ Beta: '\u0392',
+ Bfr: '\uD835\uDD05',
+ Bopf: '\uD835\uDD39',
+ Breve: '\u02D8',
+ Bscr: '\u212C',
+ Bumpeq: '\u224E',
+ CHcy: '\u0427',
+ COPY: '\u00A9',
+ Cacute: '\u0106',
+ Cap: '\u22D2',
+ CapitalDifferentialD: '\u2145',
+ Cayleys: '\u212D',
+ Ccaron: '\u010C',
+ Ccedil: '\u00C7',
+ Ccirc: '\u0108',
+ Cconint: '\u2230',
+ Cdot: '\u010A',
+ Cedilla: '\u00B8',
+ CenterDot: '\u00B7',
+ Cfr: '\u212D',
+ Chi: '\u03A7',
+ CircleDot: '\u2299',
+ CircleMinus: '\u2296',
+ CirclePlus: '\u2295',
+ CircleTimes: '\u2297',
+ ClockwiseContourIntegral: '\u2232',
+ CloseCurlyDoubleQuote: '\u201D',
+ CloseCurlyQuote: '\u2019',
+ Colon: '\u2237',
+ Colone: '\u2A74',
+ Congruent: '\u2261',
+ Conint: '\u222F',
+ ContourIntegral: '\u222E',
+ Copf: '\u2102',
+ Coproduct: '\u2210',
+ CounterClockwiseContourIntegral: '\u2233',
+ Cross: '\u2A2F',
+ Cscr: '\uD835\uDC9E',
+ Cup: '\u22D3',
+ CupCap: '\u224D',
+ DD: '\u2145',
+ DDotrahd: '\u2911',
+ DJcy: '\u0402',
+ DScy: '\u0405',
+ DZcy: '\u040F',
+ Dagger: '\u2021',
+ Darr: '\u21A1',
+ Dashv: '\u2AE4',
+ Dcaron: '\u010E',
+ Dcy: '\u0414',
+ Del: '\u2207',
+ Delta: '\u0394',
+ Dfr: '\uD835\uDD07',
+ DiacriticalAcute: '\u00B4',
+ DiacriticalDot: '\u02D9',
+ DiacriticalDoubleAcute: '\u02DD',
+ DiacriticalGrave: '\u0060',
+ DiacriticalTilde: '\u02DC',
+ Diamond: '\u22C4',
+ DifferentialD: '\u2146',
+ Dopf: '\uD835\uDD3B',
+ Dot: '\u00A8',
+ DotDot: '\u20DC',
+ DotEqual: '\u2250',
+ DoubleContourIntegral: '\u222F',
+ DoubleDot: '\u00A8',
+ DoubleDownArrow: '\u21D3',
+ DoubleLeftArrow: '\u21D0',
+ DoubleLeftRightArrow: '\u21D4',
+ DoubleLeftTee: '\u2AE4',
+ DoubleLongLeftArrow: '\u27F8',
+ DoubleLongLeftRightArrow: '\u27FA',
+ DoubleLongRightArrow: '\u27F9',
+ DoubleRightArrow: '\u21D2',
+ DoubleRightTee: '\u22A8',
+ DoubleUpArrow: '\u21D1',
+ DoubleUpDownArrow: '\u21D5',
+ DoubleVerticalBar: '\u2225',
+ DownArrow: '\u2193',
+ DownArrowBar: '\u2913',
+ DownArrowUpArrow: '\u21F5',
+ DownBreve: '\u0311',
+ DownLeftRightVector: '\u2950',
+ DownLeftTeeVector: '\u295E',
+ DownLeftVector: '\u21BD',
+ DownLeftVectorBar: '\u2956',
+ DownRightTeeVector: '\u295F',
+ DownRightVector: '\u21C1',
+ DownRightVectorBar: '\u2957',
+ DownTee: '\u22A4',
+ DownTeeArrow: '\u21A7',
+ Downarrow: '\u21D3',
+ Dscr: '\uD835\uDC9F',
+ Dstrok: '\u0110',
+ ENG: '\u014A',
+ ETH: '\u00D0',
+ Eacute: '\u00C9',
+ Ecaron: '\u011A',
+ Ecirc: '\u00CA',
+ Ecy: '\u042D',
+ Edot: '\u0116',
+ Efr: '\uD835\uDD08',
+ Egrave: '\u00C8',
+ Element: '\u2208',
+ Emacr: '\u0112',
+ EmptySmallSquare: '\u25FB',
+ EmptyVerySmallSquare: '\u25AB',
+ Eogon: '\u0118',
+ Eopf: '\uD835\uDD3C',
+ Epsilon: '\u0395',
+ Equal: '\u2A75',
+ EqualTilde: '\u2242',
+ Equilibrium: '\u21CC',
+ Escr: '\u2130',
+ Esim: '\u2A73',
+ Eta: '\u0397',
+ Euml: '\u00CB',
+ Exists: '\u2203',
+ ExponentialE: '\u2147',
+ Fcy: '\u0424',
+ Ffr: '\uD835\uDD09',
+ FilledSmallSquare: '\u25FC',
+ FilledVerySmallSquare: '\u25AA',
+ Fopf: '\uD835\uDD3D',
+ ForAll: '\u2200',
+ Fouriertrf: '\u2131',
+ Fscr: '\u2131',
+ GJcy: '\u0403',
+ GT: '\u003E',
+ Gamma: '\u0393',
+ Gammad: '\u03DC',
+ Gbreve: '\u011E',
+ Gcedil: '\u0122',
+ Gcirc: '\u011C',
+ Gcy: '\u0413',
+ Gdot: '\u0120',
+ Gfr: '\uD835\uDD0A',
+ Gg: '\u22D9',
+ Gopf: '\uD835\uDD3E',
+ GreaterEqual: '\u2265',
+ GreaterEqualLess: '\u22DB',
+ GreaterFullEqual: '\u2267',
+ GreaterGreater: '\u2AA2',
+ GreaterLess: '\u2277',
+ GreaterSlantEqual: '\u2A7E',
+ GreaterTilde: '\u2273',
+ Gscr: '\uD835\uDCA2',
+ Gt: '\u226B',
+ HARDcy: '\u042A',
+ Hacek: '\u02C7',
+ Hat: '\u005E',
+ Hcirc: '\u0124',
+ Hfr: '\u210C',
+ HilbertSpace: '\u210B',
+ Hopf: '\u210D',
+ HorizontalLine: '\u2500',
+ Hscr: '\u210B',
+ Hstrok: '\u0126',
+ HumpDownHump: '\u224E',
+ HumpEqual: '\u224F',
+ IEcy: '\u0415',
+ IJlig: '\u0132',
+ IOcy: '\u0401',
+ Iacute: '\u00CD',
+ Icirc: '\u00CE',
+ Icy: '\u0418',
+ Idot: '\u0130',
+ Ifr: '\u2111',
+ Igrave: '\u00CC',
+ Im: '\u2111',
+ Imacr: '\u012A',
+ ImaginaryI: '\u2148',
+ Implies: '\u21D2',
+ Int: '\u222C',
+ Integral: '\u222B',
+ Intersection: '\u22C2',
+ InvisibleComma: '\u2063',
+ InvisibleTimes: '\u2062',
+ Iogon: '\u012E',
+ Iopf: '\uD835\uDD40',
+ Iota: '\u0399',
+ Iscr: '\u2110',
+ Itilde: '\u0128',
+ Iukcy: '\u0406',
+ Iuml: '\u00CF',
+ Jcirc: '\u0134',
+ Jcy: '\u0419',
+ Jfr: '\uD835\uDD0D',
+ Jopf: '\uD835\uDD41',
+ Jscr: '\uD835\uDCA5',
+ Jsercy: '\u0408',
+ Jukcy: '\u0404',
+ KHcy: '\u0425',
+ KJcy: '\u040C',
+ Kappa: '\u039A',
+ Kcedil: '\u0136',
+ Kcy: '\u041A',
+ Kfr: '\uD835\uDD0E',
+ Kopf: '\uD835\uDD42',
+ Kscr: '\uD835\uDCA6',
+ LJcy: '\u0409',
+ LT: '\u003C',
+ Lacute: '\u0139',
+ Lambda: '\u039B',
+ Lang: '\u27EA',
+ Laplacetrf: '\u2112',
+ Larr: '\u219E',
+ Lcaron: '\u013D',
+ Lcedil: '\u013B',
+ Lcy: '\u041B',
+ LeftAngleBracket: '\u27E8',
+ LeftArrow: '\u2190',
+ LeftArrowBar: '\u21E4',
+ LeftArrowRightArrow: '\u21C6',
+ LeftCeiling: '\u2308',
+ LeftDoubleBracket: '\u27E6',
+ LeftDownTeeVector: '\u2961',
+ LeftDownVector: '\u21C3',
+ LeftDownVectorBar: '\u2959',
+ LeftFloor: '\u230A',
+ LeftRightArrow: '\u2194',
+ LeftRightVector: '\u294E',
+ LeftTee: '\u22A3',
+ LeftTeeArrow: '\u21A4',
+ LeftTeeVector: '\u295A',
+ LeftTriangle: '\u22B2',
+ LeftTriangleBar: '\u29CF',
+ LeftTriangleEqual: '\u22B4',
+ LeftUpDownVector: '\u2951',
+ LeftUpTeeVector: '\u2960',
+ LeftUpVector: '\u21BF',
+ LeftUpVectorBar: '\u2958',
+ LeftVector: '\u21BC',
+ LeftVectorBar: '\u2952',
+ Leftarrow: '\u21D0',
+ Leftrightarrow: '\u21D4',
+ LessEqualGreater: '\u22DA',
+ LessFullEqual: '\u2266',
+ LessGreater: '\u2276',
+ LessLess: '\u2AA1',
+ LessSlantEqual: '\u2A7D',
+ LessTilde: '\u2272',
+ Lfr: '\uD835\uDD0F',
+ Ll: '\u22D8',
+ Lleftarrow: '\u21DA',
+ Lmidot: '\u013F',
+ LongLeftArrow: '\u27F5',
+ LongLeftRightArrow: '\u27F7',
+ LongRightArrow: '\u27F6',
+ Longleftarrow: '\u27F8',
+ Longleftrightarrow: '\u27FA',
+ Longrightarrow: '\u27F9',
+ Lopf: '\uD835\uDD43',
+ LowerLeftArrow: '\u2199',
+ LowerRightArrow: '\u2198',
+ Lscr: '\u2112',
+ Lsh: '\u21B0',
+ Lstrok: '\u0141',
+ Lt: '\u226A',
+ Map: '\u2905',
+ Mcy: '\u041C',
+ MediumSpace: '\u205F',
+ Mellintrf: '\u2133',
+ Mfr: '\uD835\uDD10',
+ MinusPlus: '\u2213',
+ Mopf: '\uD835\uDD44',
+ Mscr: '\u2133',
+ Mu: '\u039C',
+ NJcy: '\u040A',
+ Nacute: '\u0143',
+ Ncaron: '\u0147',
+ Ncedil: '\u0145',
+ Ncy: '\u041D',
+ NegativeMediumSpace: '\u200B',
+ NegativeThickSpace: '\u200B',
+ NegativeThinSpace: '\u200B',
+ NegativeVeryThinSpace: '\u200B',
+ NestedGreaterGreater: '\u226B',
+ NestedLessLess: '\u226A',
+ NewLine: '\u000A',
+ Nfr: '\uD835\uDD11',
+ NoBreak: '\u2060',
+ NonBreakingSpace: '\u00A0',
+ Nopf: '\u2115',
+ Not: '\u2AEC',
+ NotCongruent: '\u2262',
+ NotCupCap: '\u226D',
+ NotDoubleVerticalBar: '\u2226',
+ NotElement: '\u2209',
+ NotEqual: '\u2260',
+ NotEqualTilde: '\u2242\u0338',
+ NotExists: '\u2204',
+ NotGreater: '\u226F',
+ NotGreaterEqual: '\u2271',
+ NotGreaterFullEqual: '\u2267\u0338',
+ NotGreaterGreater: '\u226B\u0338',
+ NotGreaterLess: '\u2279',
+ NotGreaterSlantEqual: '\u2A7E\u0338',
+ NotGreaterTilde: '\u2275',
+ NotHumpDownHump: '\u224E\u0338',
+ NotHumpEqual: '\u224F\u0338',
+ NotLeftTriangle: '\u22EA',
+ NotLeftTriangleBar: '\u29CF\u0338',
+ NotLeftTriangleEqual: '\u22EC',
+ NotLess: '\u226E',
+ NotLessEqual: '\u2270',
+ NotLessGreater: '\u2278',
+ NotLessLess: '\u226A\u0338',
+ NotLessSlantEqual: '\u2A7D\u0338',
+ NotLessTilde: '\u2274',
+ NotNestedGreaterGreater: '\u2AA2\u0338',
+ NotNestedLessLess: '\u2AA1\u0338',
+ NotPrecedes: '\u2280',
+ NotPrecedesEqual: '\u2AAF\u0338',
+ NotPrecedesSlantEqual: '\u22E0',
+ NotReverseElement: '\u220C',
+ NotRightTriangle: '\u22EB',
+ NotRightTriangleBar: '\u29D0\u0338',
+ NotRightTriangleEqual: '\u22ED',
+ NotSquareSubset: '\u228F\u0338',
+ NotSquareSubsetEqual: '\u22E2',
+ NotSquareSuperset: '\u2290\u0338',
+ NotSquareSupersetEqual: '\u22E3',
+ NotSubset: '\u2282\u20D2',
+ NotSubsetEqual: '\u2288',
+ NotSucceeds: '\u2281',
+ NotSucceedsEqual: '\u2AB0\u0338',
+ NotSucceedsSlantEqual: '\u22E1',
+ NotSucceedsTilde: '\u227F\u0338',
+ NotSuperset: '\u2283\u20D2',
+ NotSupersetEqual: '\u2289',
+ NotTilde: '\u2241',
+ NotTildeEqual: '\u2244',
+ NotTildeFullEqual: '\u2247',
+ NotTildeTilde: '\u2249',
+ NotVerticalBar: '\u2224',
+ Nscr: '\uD835\uDCA9',
+ Ntilde: '\u00D1',
+ Nu: '\u039D',
+ OElig: '\u0152',
+ Oacute: '\u00D3',
+ Ocirc: '\u00D4',
+ Ocy: '\u041E',
+ Odblac: '\u0150',
+ Ofr: '\uD835\uDD12',
+ Ograve: '\u00D2',
+ Omacr: '\u014C',
+ Omega: '\u03A9',
+ Omicron: '\u039F',
+ Oopf: '\uD835\uDD46',
+ OpenCurlyDoubleQuote: '\u201C',
+ OpenCurlyQuote: '\u2018',
+ Or: '\u2A54',
+ Oscr: '\uD835\uDCAA',
+ Oslash: '\u00D8',
+ Otilde: '\u00D5',
+ Otimes: '\u2A37',
+ Ouml: '\u00D6',
+ OverBar: '\u203E',
+ OverBrace: '\u23DE',
+ OverBracket: '\u23B4',
+ OverParenthesis: '\u23DC',
+ PartialD: '\u2202',
+ Pcy: '\u041F',
+ Pfr: '\uD835\uDD13',
+ Phi: '\u03A6',
+ Pi: '\u03A0',
+ PlusMinus: '\u00B1',
+ Poincareplane: '\u210C',
+ Popf: '\u2119',
+ Pr: '\u2ABB',
+ Precedes: '\u227A',
+ PrecedesEqual: '\u2AAF',
+ PrecedesSlantEqual: '\u227C',
+ PrecedesTilde: '\u227E',
+ Prime: '\u2033',
+ Product: '\u220F',
+ Proportion: '\u2237',
+ Proportional: '\u221D',
+ Pscr: '\uD835\uDCAB',
+ Psi: '\u03A8',
+ QUOT: '\u0022',
+ Qfr: '\uD835\uDD14',
+ Qopf: '\u211A',
+ Qscr: '\uD835\uDCAC',
+ RBarr: '\u2910',
+ REG: '\u00AE',
+ Racute: '\u0154',
+ Rang: '\u27EB',
+ Rarr: '\u21A0',
+ Rarrtl: '\u2916',
+ Rcaron: '\u0158',
+ Rcedil: '\u0156',
+ Rcy: '\u0420',
+ Re: '\u211C',
+ ReverseElement: '\u220B',
+ ReverseEquilibrium: '\u21CB',
+ ReverseUpEquilibrium: '\u296F',
+ Rfr: '\u211C',
+ Rho: '\u03A1',
+ RightAngleBracket: '\u27E9',
+ RightArrow: '\u2192',
+ RightArrowBar: '\u21E5',
+ RightArrowLeftArrow: '\u21C4',
+ RightCeiling: '\u2309',
+ RightDoubleBracket: '\u27E7',
+ RightDownTeeVector: '\u295D',
+ RightDownVector: '\u21C2',
+ RightDownVectorBar: '\u2955',
+ RightFloor: '\u230B',
+ RightTee: '\u22A2',
+ RightTeeArrow: '\u21A6',
+ RightTeeVector: '\u295B',
+ RightTriangle: '\u22B3',
+ RightTriangleBar: '\u29D0',
+ RightTriangleEqual: '\u22B5',
+ RightUpDownVector: '\u294F',
+ RightUpTeeVector: '\u295C',
+ RightUpVector: '\u21BE',
+ RightUpVectorBar: '\u2954',
+ RightVector: '\u21C0',
+ RightVectorBar: '\u2953',
+ Rightarrow: '\u21D2',
+ Ropf: '\u211D',
+ RoundImplies: '\u2970',
+ Rrightarrow: '\u21DB',
+ Rscr: '\u211B',
+ Rsh: '\u21B1',
+ RuleDelayed: '\u29F4',
+ SHCHcy: '\u0429',
+ SHcy: '\u0428',
+ SOFTcy: '\u042C',
+ Sacute: '\u015A',
+ Sc: '\u2ABC',
+ Scaron: '\u0160',
+ Scedil: '\u015E',
+ Scirc: '\u015C',
+ Scy: '\u0421',
+ Sfr: '\uD835\uDD16',
+ ShortDownArrow: '\u2193',
+ ShortLeftArrow: '\u2190',
+ ShortRightArrow: '\u2192',
+ ShortUpArrow: '\u2191',
+ Sigma: '\u03A3',
+ SmallCircle: '\u2218',
+ Sopf: '\uD835\uDD4A',
+ Sqrt: '\u221A',
+ Square: '\u25A1',
+ SquareIntersection: '\u2293',
+ SquareSubset: '\u228F',
+ SquareSubsetEqual: '\u2291',
+ SquareSuperset: '\u2290',
+ SquareSupersetEqual: '\u2292',
+ SquareUnion: '\u2294',
+ Sscr: '\uD835\uDCAE',
+ Star: '\u22C6',
+ Sub: '\u22D0',
+ Subset: '\u22D0',
+ SubsetEqual: '\u2286',
+ Succeeds: '\u227B',
+ SucceedsEqual: '\u2AB0',
+ SucceedsSlantEqual: '\u227D',
+ SucceedsTilde: '\u227F',
+ SuchThat: '\u220B',
+ Sum: '\u2211',
+ Sup: '\u22D1',
+ Superset: '\u2283',
+ SupersetEqual: '\u2287',
+ Supset: '\u22D1',
+ THORN: '\u00DE',
+ TRADE: '\u2122',
+ TSHcy: '\u040B',
+ TScy: '\u0426',
+ Tab: '\u0009',
+ Tau: '\u03A4',
+ Tcaron: '\u0164',
+ Tcedil: '\u0162',
+ Tcy: '\u0422',
+ Tfr: '\uD835\uDD17',
+ Therefore: '\u2234',
+ Theta: '\u0398',
+ ThickSpace: '\u205F\u200A',
+ ThinSpace: '\u2009',
+ Tilde: '\u223C',
+ TildeEqual: '\u2243',
+ TildeFullEqual: '\u2245',
+ TildeTilde: '\u2248',
+ Topf: '\uD835\uDD4B',
+ TripleDot: '\u20DB',
+ Tscr: '\uD835\uDCAF',
+ Tstrok: '\u0166',
+ Uacute: '\u00DA',
+ Uarr: '\u219F',
+ Uarrocir: '\u2949',
+ Ubrcy: '\u040E',
+ Ubreve: '\u016C',
+ Ucirc: '\u00DB',
+ Ucy: '\u0423',
+ Udblac: '\u0170',
+ Ufr: '\uD835\uDD18',
+ Ugrave: '\u00D9',
+ Umacr: '\u016A',
+ UnderBar: '\u005F',
+ UnderBrace: '\u23DF',
+ UnderBracket: '\u23B5',
+ UnderParenthesis: '\u23DD',
+ Union: '\u22C3',
+ UnionPlus: '\u228E',
+ Uogon: '\u0172',
+ Uopf: '\uD835\uDD4C',
+ UpArrow: '\u2191',
+ UpArrowBar: '\u2912',
+ UpArrowDownArrow: '\u21C5',
+ UpDownArrow: '\u2195',
+ UpEquilibrium: '\u296E',
+ UpTee: '\u22A5',
+ UpTeeArrow: '\u21A5',
+ Uparrow: '\u21D1',
+ Updownarrow: '\u21D5',
+ UpperLeftArrow: '\u2196',
+ UpperRightArrow: '\u2197',
+ Upsi: '\u03D2',
+ Upsilon: '\u03A5',
+ Uring: '\u016E',
+ Uscr: '\uD835\uDCB0',
+ Utilde: '\u0168',
+ Uuml: '\u00DC',
+ VDash: '\u22AB',
+ Vbar: '\u2AEB',
+ Vcy: '\u0412',
+ Vdash: '\u22A9',
+ Vdashl: '\u2AE6',
+ Vee: '\u22C1',
+ Verbar: '\u2016',
+ Vert: '\u2016',
+ VerticalBar: '\u2223',
+ VerticalLine: '\u007C',
+ VerticalSeparator: '\u2758',
+ VerticalTilde: '\u2240',
+ VeryThinSpace: '\u200A',
+ Vfr: '\uD835\uDD19',
+ Vopf: '\uD835\uDD4D',
+ Vscr: '\uD835\uDCB1',
+ Vvdash: '\u22AA',
+ Wcirc: '\u0174',
+ Wedge: '\u22C0',
+ Wfr: '\uD835\uDD1A',
+ Wopf: '\uD835\uDD4E',
+ Wscr: '\uD835\uDCB2',
+ Xfr: '\uD835\uDD1B',
+ Xi: '\u039E',
+ Xopf: '\uD835\uDD4F',
+ Xscr: '\uD835\uDCB3',
+ YAcy: '\u042F',
+ YIcy: '\u0407',
+ YUcy: '\u042E',
+ Yacute: '\u00DD',
+ Ycirc: '\u0176',
+ Ycy: '\u042B',
+ Yfr: '\uD835\uDD1C',
+ Yopf: '\uD835\uDD50',
+ Yscr: '\uD835\uDCB4',
+ Yuml: '\u0178',
+ ZHcy: '\u0416',
+ Zacute: '\u0179',
+ Zcaron: '\u017D',
+ Zcy: '\u0417',
+ Zdot: '\u017B',
+ ZeroWidthSpace: '\u200B',
+ Zeta: '\u0396',
+ Zfr: '\u2128',
+ Zopf: '\u2124',
+ Zscr: '\uD835\uDCB5',
+ aacute: '\u00E1',
+ abreve: '\u0103',
+ ac: '\u223E',
+ acE: '\u223E\u0333',
+ acd: '\u223F',
+ acirc: '\u00E2',
+ acute: '\u00B4',
+ acy: '\u0430',
+ aelig: '\u00E6',
+ af: '\u2061',
+ afr: '\uD835\uDD1E',
+ agrave: '\u00E0',
+ alefsym: '\u2135',
+ aleph: '\u2135',
+ alpha: '\u03B1',
+ amacr: '\u0101',
+ amalg: '\u2A3F',
+ amp: '\u0026',
+ and: '\u2227',
+ andand: '\u2A55',
+ andd: '\u2A5C',
+ andslope: '\u2A58',
+ andv: '\u2A5A',
+ ang: '\u2220',
+ ange: '\u29A4',
+ angle: '\u2220',
+ angmsd: '\u2221',
+ angmsdaa: '\u29A8',
+ angmsdab: '\u29A9',
+ angmsdac: '\u29AA',
+ angmsdad: '\u29AB',
+ angmsdae: '\u29AC',
+ angmsdaf: '\u29AD',
+ angmsdag: '\u29AE',
+ angmsdah: '\u29AF',
+ angrt: '\u221F',
+ angrtvb: '\u22BE',
+ angrtvbd: '\u299D',
+ angsph: '\u2222',
+ angst: '\u00C5',
+ angzarr: '\u237C',
+ aogon: '\u0105',
+ aopf: '\uD835\uDD52',
+ ap: '\u2248',
+ apE: '\u2A70',
+ apacir: '\u2A6F',
+ ape: '\u224A',
+ apid: '\u224B',
+ apos: '\u0027',
+ approx: '\u2248',
+ approxeq: '\u224A',
+ aring: '\u00E5',
+ ascr: '\uD835\uDCB6',
+ ast: '\u002A',
+ asymp: '\u2248',
+ asympeq: '\u224D',
+ atilde: '\u00E3',
+ auml: '\u00E4',
+ awconint: '\u2233',
+ awint: '\u2A11',
+ bNot: '\u2AED',
+ backcong: '\u224C',
+ backepsilon: '\u03F6',
+ backprime: '\u2035',
+ backsim: '\u223D',
+ backsimeq: '\u22CD',
+ barvee: '\u22BD',
+ barwed: '\u2305',
+ barwedge: '\u2305',
+ bbrk: '\u23B5',
+ bbrktbrk: '\u23B6',
+ bcong: '\u224C',
+ bcy: '\u0431',
+ bdquo: '\u201E',
+ becaus: '\u2235',
+ because: '\u2235',
+ bemptyv: '\u29B0',
+ bepsi: '\u03F6',
+ bernou: '\u212C',
+ beta: '\u03B2',
+ beth: '\u2136',
+ between: '\u226C',
+ bfr: '\uD835\uDD1F',
+ bigcap: '\u22C2',
+ bigcirc: '\u25EF',
+ bigcup: '\u22C3',
+ bigodot: '\u2A00',
+ bigoplus: '\u2A01',
+ bigotimes: '\u2A02',
+ bigsqcup: '\u2A06',
+ bigstar: '\u2605',
+ bigtriangledown: '\u25BD',
+ bigtriangleup: '\u25B3',
+ biguplus: '\u2A04',
+ bigvee: '\u22C1',
+ bigwedge: '\u22C0',
+ bkarow: '\u290D',
+ blacklozenge: '\u29EB',
+ blacksquare: '\u25AA',
+ blacktriangle: '\u25B4',
+ blacktriangledown: '\u25BE',
+ blacktriangleleft: '\u25C2',
+ blacktriangleright: '\u25B8',
+ blank: '\u2423',
+ blk12: '\u2592',
+ blk14: '\u2591',
+ blk34: '\u2593',
+ block: '\u2588',
+ bne: '\u003D\u20E5',
+ bnequiv: '\u2261\u20E5',
+ bnot: '\u2310',
+ bopf: '\uD835\uDD53',
+ bot: '\u22A5',
+ bottom: '\u22A5',
+ bowtie: '\u22C8',
+ boxDL: '\u2557',
+ boxDR: '\u2554',
+ boxDl: '\u2556',
+ boxDr: '\u2553',
+ boxH: '\u2550',
+ boxHD: '\u2566',
+ boxHU: '\u2569',
+ boxHd: '\u2564',
+ boxHu: '\u2567',
+ boxUL: '\u255D',
+ boxUR: '\u255A',
+ boxUl: '\u255C',
+ boxUr: '\u2559',
+ boxV: '\u2551',
+ boxVH: '\u256C',
+ boxVL: '\u2563',
+ boxVR: '\u2560',
+ boxVh: '\u256B',
+ boxVl: '\u2562',
+ boxVr: '\u255F',
+ boxbox: '\u29C9',
+ boxdL: '\u2555',
+ boxdR: '\u2552',
+ boxdl: '\u2510',
+ boxdr: '\u250C',
+ boxh: '\u2500',
+ boxhD: '\u2565',
+ boxhU: '\u2568',
+ boxhd: '\u252C',
+ boxhu: '\u2534',
+ boxminus: '\u229F',
+ boxplus: '\u229E',
+ boxtimes: '\u22A0',
+ boxuL: '\u255B',
+ boxuR: '\u2558',
+ boxul: '\u2518',
+ boxur: '\u2514',
+ boxv: '\u2502',
+ boxvH: '\u256A',
+ boxvL: '\u2561',
+ boxvR: '\u255E',
+ boxvh: '\u253C',
+ boxvl: '\u2524',
+ boxvr: '\u251C',
+ bprime: '\u2035',
+ breve: '\u02D8',
+ brvbar: '\u00A6',
+ bscr: '\uD835\uDCB7',
+ bsemi: '\u204F',
+ bsim: '\u223D',
+ bsime: '\u22CD',
+ bsol: '\u005C',
+ bsolb: '\u29C5',
+ bsolhsub: '\u27C8',
+ bull: '\u2022',
+ bullet: '\u2022',
+ bump: '\u224E',
+ bumpE: '\u2AAE',
+ bumpe: '\u224F',
+ bumpeq: '\u224F',
+ cacute: '\u0107',
+ cap: '\u2229',
+ capand: '\u2A44',
+ capbrcup: '\u2A49',
+ capcap: '\u2A4B',
+ capcup: '\u2A47',
+ capdot: '\u2A40',
+ caps: '\u2229\uFE00',
+ caret: '\u2041',
+ caron: '\u02C7',
+ ccaps: '\u2A4D',
+ ccaron: '\u010D',
+ ccedil: '\u00E7',
+ ccirc: '\u0109',
+ ccups: '\u2A4C',
+ ccupssm: '\u2A50',
+ cdot: '\u010B',
+ cedil: '\u00B8',
+ cemptyv: '\u29B2',
+ cent: '\u00A2',
+ centerdot: '\u00B7',
+ cfr: '\uD835\uDD20',
+ chcy: '\u0447',
+ check: '\u2713',
+ checkmark: '\u2713',
+ chi: '\u03C7',
+ cir: '\u25CB',
+ cirE: '\u29C3',
+ circ: '\u02C6',
+ circeq: '\u2257',
+ circlearrowleft: '\u21BA',
+ circlearrowright: '\u21BB',
+ circledR: '\u00AE',
+ circledS: '\u24C8',
+ circledast: '\u229B',
+ circledcirc: '\u229A',
+ circleddash: '\u229D',
+ cire: '\u2257',
+ cirfnint: '\u2A10',
+ cirmid: '\u2AEF',
+ cirscir: '\u29C2',
+ clubs: '\u2663',
+ clubsuit: '\u2663',
+ colon: '\u003A',
+ colone: '\u2254',
+ coloneq: '\u2254',
+ comma: '\u002C',
+ commat: '\u0040',
+ comp: '\u2201',
+ compfn: '\u2218',
+ complement: '\u2201',
+ complexes: '\u2102',
+ cong: '\u2245',
+ congdot: '\u2A6D',
+ conint: '\u222E',
+ copf: '\uD835\uDD54',
+ coprod: '\u2210',
+ copy: '\u00A9',
+ copysr: '\u2117',
+ crarr: '\u21B5',
+ cross: '\u2717',
+ cscr: '\uD835\uDCB8',
+ csub: '\u2ACF',
+ csube: '\u2AD1',
+ csup: '\u2AD0',
+ csupe: '\u2AD2',
+ ctdot: '\u22EF',
+ cudarrl: '\u2938',
+ cudarrr: '\u2935',
+ cuepr: '\u22DE',
+ cuesc: '\u22DF',
+ cularr: '\u21B6',
+ cularrp: '\u293D',
+ cup: '\u222A',
+ cupbrcap: '\u2A48',
+ cupcap: '\u2A46',
+ cupcup: '\u2A4A',
+ cupdot: '\u228D',
+ cupor: '\u2A45',
+ cups: '\u222A\uFE00',
+ curarr: '\u21B7',
+ curarrm: '\u293C',
+ curlyeqprec: '\u22DE',
+ curlyeqsucc: '\u22DF',
+ curlyvee: '\u22CE',
+ curlywedge: '\u22CF',
+ curren: '\u00A4',
+ curvearrowleft: '\u21B6',
+ curvearrowright: '\u21B7',
+ cuvee: '\u22CE',
+ cuwed: '\u22CF',
+ cwconint: '\u2232',
+ cwint: '\u2231',
+ cylcty: '\u232D',
+ dArr: '\u21D3',
+ dHar: '\u2965',
+ dagger: '\u2020',
+ daleth: '\u2138',
+ darr: '\u2193',
+ dash: '\u2010',
+ dashv: '\u22A3',
+ dbkarow: '\u290F',
+ dblac: '\u02DD',
+ dcaron: '\u010F',
+ dcy: '\u0434',
+ dd: '\u2146',
+ ddagger: '\u2021',
+ ddarr: '\u21CA',
+ ddotseq: '\u2A77',
+ deg: '\u00B0',
+ delta: '\u03B4',
+ demptyv: '\u29B1',
+ dfisht: '\u297F',
+ dfr: '\uD835\uDD21',
+ dharl: '\u21C3',
+ dharr: '\u21C2',
+ diam: '\u22C4',
+ diamond: '\u22C4',
+ diamondsuit: '\u2666',
+ diams: '\u2666',
+ die: '\u00A8',
+ digamma: '\u03DD',
+ disin: '\u22F2',
+ div: '\u00F7',
+ divide: '\u00F7',
+ divideontimes: '\u22C7',
+ divonx: '\u22C7',
+ djcy: '\u0452',
+ dlcorn: '\u231E',
+ dlcrop: '\u230D',
+ dollar: '\u0024',
+ dopf: '\uD835\uDD55',
+ dot: '\u02D9',
+ doteq: '\u2250',
+ doteqdot: '\u2251',
+ dotminus: '\u2238',
+ dotplus: '\u2214',
+ dotsquare: '\u22A1',
+ doublebarwedge: '\u2306',
+ downarrow: '\u2193',
+ downdownarrows: '\u21CA',
+ downharpoonleft: '\u21C3',
+ downharpoonright: '\u21C2',
+ drbkarow: '\u2910',
+ drcorn: '\u231F',
+ drcrop: '\u230C',
+ dscr: '\uD835\uDCB9',
+ dscy: '\u0455',
+ dsol: '\u29F6',
+ dstrok: '\u0111',
+ dtdot: '\u22F1',
+ dtri: '\u25BF',
+ dtrif: '\u25BE',
+ duarr: '\u21F5',
+ duhar: '\u296F',
+ dwangle: '\u29A6',
+ dzcy: '\u045F',
+ dzigrarr: '\u27FF',
+ eDDot: '\u2A77',
+ eDot: '\u2251',
+ eacute: '\u00E9',
+ easter: '\u2A6E',
+ ecaron: '\u011B',
+ ecir: '\u2256',
+ ecirc: '\u00EA',
+ ecolon: '\u2255',
+ ecy: '\u044D',
+ edot: '\u0117',
+ ee: '\u2147',
+ efDot: '\u2252',
+ efr: '\uD835\uDD22',
+ eg: '\u2A9A',
+ egrave: '\u00E8',
+ egs: '\u2A96',
+ egsdot: '\u2A98',
+ el: '\u2A99',
+ elinters: '\u23E7',
+ ell: '\u2113',
+ els: '\u2A95',
+ elsdot: '\u2A97',
+ emacr: '\u0113',
+ empty: '\u2205',
+ emptyset: '\u2205',
+ emptyv: '\u2205',
+ emsp13: '\u2004',
+ emsp14: '\u2005',
+ emsp: '\u2003',
+ eng: '\u014B',
+ ensp: '\u2002',
+ eogon: '\u0119',
+ eopf: '\uD835\uDD56',
+ epar: '\u22D5',
+ eparsl: '\u29E3',
+ eplus: '\u2A71',
+ epsi: '\u03B5',
+ epsilon: '\u03B5',
+ epsiv: '\u03F5',
+ eqcirc: '\u2256',
+ eqcolon: '\u2255',
+ eqsim: '\u2242',
+ eqslantgtr: '\u2A96',
+ eqslantless: '\u2A95',
+ equals: '\u003D',
+ equest: '\u225F',
+ equiv: '\u2261',
+ equivDD: '\u2A78',
+ eqvparsl: '\u29E5',
+ erDot: '\u2253',
+ erarr: '\u2971',
+ escr: '\u212F',
+ esdot: '\u2250',
+ esim: '\u2242',
+ eta: '\u03B7',
+ eth: '\u00F0',
+ euml: '\u00EB',
+ euro: '\u20AC',
+ excl: '\u0021',
+ exist: '\u2203',
+ expectation: '\u2130',
+ exponentiale: '\u2147',
+ fallingdotseq: '\u2252',
+ fcy: '\u0444',
+ female: '\u2640',
+ ffilig: '\uFB03',
+ fflig: '\uFB00',
+ ffllig: '\uFB04',
+ ffr: '\uD835\uDD23',
+ filig: '\uFB01',
+ fjlig: '\u0066\u006A',
+ flat: '\u266D',
+ fllig: '\uFB02',
+ fltns: '\u25B1',
+ fnof: '\u0192',
+ fopf: '\uD835\uDD57',
+ forall: '\u2200',
+ fork: '\u22D4',
+ forkv: '\u2AD9',
+ fpartint: '\u2A0D',
+ frac12: '\u00BD',
+ frac13: '\u2153',
+ frac14: '\u00BC',
+ frac15: '\u2155',
+ frac16: '\u2159',
+ frac18: '\u215B',
+ frac23: '\u2154',
+ frac25: '\u2156',
+ frac34: '\u00BE',
+ frac35: '\u2157',
+ frac38: '\u215C',
+ frac45: '\u2158',
+ frac56: '\u215A',
+ frac58: '\u215D',
+ frac78: '\u215E',
+ frasl: '\u2044',
+ frown: '\u2322',
+ fscr: '\uD835\uDCBB',
+ gE: '\u2267',
+ gEl: '\u2A8C',
+ gacute: '\u01F5',
+ gamma: '\u03B3',
+ gammad: '\u03DD',
+ gap: '\u2A86',
+ gbreve: '\u011F',
+ gcirc: '\u011D',
+ gcy: '\u0433',
+ gdot: '\u0121',
+ ge: '\u2265',
+ gel: '\u22DB',
+ geq: '\u2265',
+ geqq: '\u2267',
+ geqslant: '\u2A7E',
+ ges: '\u2A7E',
+ gescc: '\u2AA9',
+ gesdot: '\u2A80',
+ gesdoto: '\u2A82',
+ gesdotol: '\u2A84',
+ gesl: '\u22DB\uFE00',
+ gesles: '\u2A94',
+ gfr: '\uD835\uDD24',
+ gg: '\u226B',
+ ggg: '\u22D9',
+ gimel: '\u2137',
+ gjcy: '\u0453',
+ gl: '\u2277',
+ glE: '\u2A92',
+ gla: '\u2AA5',
+ glj: '\u2AA4',
+ gnE: '\u2269',
+ gnap: '\u2A8A',
+ gnapprox: '\u2A8A',
+ gne: '\u2A88',
+ gneq: '\u2A88',
+ gneqq: '\u2269',
+ gnsim: '\u22E7',
+ gopf: '\uD835\uDD58',
+ grave: '\u0060',
+ gscr: '\u210A',
+ gsim: '\u2273',
+ gsime: '\u2A8E',
+ gsiml: '\u2A90',
+ gt: '\u003E',
+ gtcc: '\u2AA7',
+ gtcir: '\u2A7A',
+ gtdot: '\u22D7',
+ gtlPar: '\u2995',
+ gtquest: '\u2A7C',
+ gtrapprox: '\u2A86',
+ gtrarr: '\u2978',
+ gtrdot: '\u22D7',
+ gtreqless: '\u22DB',
+ gtreqqless: '\u2A8C',
+ gtrless: '\u2277',
+ gtrsim: '\u2273',
+ gvertneqq: '\u2269\uFE00',
+ gvnE: '\u2269\uFE00',
+ hArr: '\u21D4',
+ hairsp: '\u200A',
+ half: '\u00BD',
+ hamilt: '\u210B',
+ hardcy: '\u044A',
+ harr: '\u2194',
+ harrcir: '\u2948',
+ harrw: '\u21AD',
+ hbar: '\u210F',
+ hcirc: '\u0125',
+ hearts: '\u2665',
+ heartsuit: '\u2665',
+ hellip: '\u2026',
+ hercon: '\u22B9',
+ hfr: '\uD835\uDD25',
+ hksearow: '\u2925',
+ hkswarow: '\u2926',
+ hoarr: '\u21FF',
+ homtht: '\u223B',
+ hookleftarrow: '\u21A9',
+ hookrightarrow: '\u21AA',
+ hopf: '\uD835\uDD59',
+ horbar: '\u2015',
+ hscr: '\uD835\uDCBD',
+ hslash: '\u210F',
+ hstrok: '\u0127',
+ hybull: '\u2043',
+ hyphen: '\u2010',
+ iacute: '\u00ED',
+ ic: '\u2063',
+ icirc: '\u00EE',
+ icy: '\u0438',
+ iecy: '\u0435',
+ iexcl: '\u00A1',
+ iff: '\u21D4',
+ ifr: '\uD835\uDD26',
+ igrave: '\u00EC',
+ ii: '\u2148',
+ iiiint: '\u2A0C',
+ iiint: '\u222D',
+ iinfin: '\u29DC',
+ iiota: '\u2129',
+ ijlig: '\u0133',
+ imacr: '\u012B',
+ image: '\u2111',
+ imagline: '\u2110',
+ imagpart: '\u2111',
+ imath: '\u0131',
+ imof: '\u22B7',
+ imped: '\u01B5',
+ in: '\u2208',
+ incare: '\u2105',
+ infin: '\u221E',
+ infintie: '\u29DD',
+ inodot: '\u0131',
+ int: '\u222B',
+ intcal: '\u22BA',
+ integers: '\u2124',
+ intercal: '\u22BA',
+ intlarhk: '\u2A17',
+ intprod: '\u2A3C',
+ iocy: '\u0451',
+ iogon: '\u012F',
+ iopf: '\uD835\uDD5A',
+ iota: '\u03B9',
+ iprod: '\u2A3C',
+ iquest: '\u00BF',
+ iscr: '\uD835\uDCBE',
+ isin: '\u2208',
+ isinE: '\u22F9',
+ isindot: '\u22F5',
+ isins: '\u22F4',
+ isinsv: '\u22F3',
+ isinv: '\u2208',
+ it: '\u2062',
+ itilde: '\u0129',
+ iukcy: '\u0456',
+ iuml: '\u00EF',
+ jcirc: '\u0135',
+ jcy: '\u0439',
+ jfr: '\uD835\uDD27',
+ jmath: '\u0237',
+ jopf: '\uD835\uDD5B',
+ jscr: '\uD835\uDCBF',
+ jsercy: '\u0458',
+ jukcy: '\u0454',
+ kappa: '\u03BA',
+ kappav: '\u03F0',
+ kcedil: '\u0137',
+ kcy: '\u043A',
+ kfr: '\uD835\uDD28',
+ kgreen: '\u0138',
+ khcy: '\u0445',
+ kjcy: '\u045C',
+ kopf: '\uD835\uDD5C',
+ kscr: '\uD835\uDCC0',
+ lAarr: '\u21DA',
+ lArr: '\u21D0',
+ lAtail: '\u291B',
+ lBarr: '\u290E',
+ lE: '\u2266',
+ lEg: '\u2A8B',
+ lHar: '\u2962',
+ lacute: '\u013A',
+ laemptyv: '\u29B4',
+ lagran: '\u2112',
+ lambda: '\u03BB',
+ lang: '\u27E8',
+ langd: '\u2991',
+ langle: '\u27E8',
+ lap: '\u2A85',
+ laquo: '\u00AB',
+ larr: '\u2190',
+ larrb: '\u21E4',
+ larrbfs: '\u291F',
+ larrfs: '\u291D',
+ larrhk: '\u21A9',
+ larrlp: '\u21AB',
+ larrpl: '\u2939',
+ larrsim: '\u2973',
+ larrtl: '\u21A2',
+ lat: '\u2AAB',
+ latail: '\u2919',
+ late: '\u2AAD',
+ lates: '\u2AAD\uFE00',
+ lbarr: '\u290C',
+ lbbrk: '\u2772',
+ lbrace: '\u007B',
+ lbrack: '\u005B',
+ lbrke: '\u298B',
+ lbrksld: '\u298F',
+ lbrkslu: '\u298D',
+ lcaron: '\u013E',
+ lcedil: '\u013C',
+ lceil: '\u2308',
+ lcub: '\u007B',
+ lcy: '\u043B',
+ ldca: '\u2936',
+ ldquo: '\u201C',
+ ldquor: '\u201E',
+ ldrdhar: '\u2967',
+ ldrushar: '\u294B',
+ ldsh: '\u21B2',
+ le: '\u2264',
+ leftarrow: '\u2190',
+ leftarrowtail: '\u21A2',
+ leftharpoondown: '\u21BD',
+ leftharpoonup: '\u21BC',
+ leftleftarrows: '\u21C7',
+ leftrightarrow: '\u2194',
+ leftrightarrows: '\u21C6',
+ leftrightharpoons: '\u21CB',
+ leftrightsquigarrow: '\u21AD',
+ leftthreetimes: '\u22CB',
+ leg: '\u22DA',
+ leq: '\u2264',
+ leqq: '\u2266',
+ leqslant: '\u2A7D',
+ les: '\u2A7D',
+ lescc: '\u2AA8',
+ lesdot: '\u2A7F',
+ lesdoto: '\u2A81',
+ lesdotor: '\u2A83',
+ lesg: '\u22DA\uFE00',
+ lesges: '\u2A93',
+ lessapprox: '\u2A85',
+ lessdot: '\u22D6',
+ lesseqgtr: '\u22DA',
+ lesseqqgtr: '\u2A8B',
+ lessgtr: '\u2276',
+ lesssim: '\u2272',
+ lfisht: '\u297C',
+ lfloor: '\u230A',
+ lfr: '\uD835\uDD29',
+ lg: '\u2276',
+ lgE: '\u2A91',
+ lhard: '\u21BD',
+ lharu: '\u21BC',
+ lharul: '\u296A',
+ lhblk: '\u2584',
+ ljcy: '\u0459',
+ ll: '\u226A',
+ llarr: '\u21C7',
+ llcorner: '\u231E',
+ llhard: '\u296B',
+ lltri: '\u25FA',
+ lmidot: '\u0140',
+ lmoust: '\u23B0',
+ lmoustache: '\u23B0',
+ lnE: '\u2268',
+ lnap: '\u2A89',
+ lnapprox: '\u2A89',
+ lne: '\u2A87',
+ lneq: '\u2A87',
+ lneqq: '\u2268',
+ lnsim: '\u22E6',
+ loang: '\u27EC',
+ loarr: '\u21FD',
+ lobrk: '\u27E6',
+ longleftarrow: '\u27F5',
+ longleftrightarrow: '\u27F7',
+ longmapsto: '\u27FC',
+ longrightarrow: '\u27F6',
+ looparrowleft: '\u21AB',
+ looparrowright: '\u21AC',
+ lopar: '\u2985',
+ lopf: '\uD835\uDD5D',
+ loplus: '\u2A2D',
+ lotimes: '\u2A34',
+ lowast: '\u2217',
+ lowbar: '\u005F',
+ loz: '\u25CA',
+ lozenge: '\u25CA',
+ lozf: '\u29EB',
+ lpar: '\u0028',
+ lparlt: '\u2993',
+ lrarr: '\u21C6',
+ lrcorner: '\u231F',
+ lrhar: '\u21CB',
+ lrhard: '\u296D',
+ lrm: '\u200E',
+ lrtri: '\u22BF',
+ lsaquo: '\u2039',
+ lscr: '\uD835\uDCC1',
+ lsh: '\u21B0',
+ lsim: '\u2272',
+ lsime: '\u2A8D',
+ lsimg: '\u2A8F',
+ lsqb: '\u005B',
+ lsquo: '\u2018',
+ lsquor: '\u201A',
+ lstrok: '\u0142',
+ lt: '\u003C',
+ ltcc: '\u2AA6',
+ ltcir: '\u2A79',
+ ltdot: '\u22D6',
+ lthree: '\u22CB',
+ ltimes: '\u22C9',
+ ltlarr: '\u2976',
+ ltquest: '\u2A7B',
+ ltrPar: '\u2996',
+ ltri: '\u25C3',
+ ltrie: '\u22B4',
+ ltrif: '\u25C2',
+ lurdshar: '\u294A',
+ luruhar: '\u2966',
+ lvertneqq: '\u2268\uFE00',
+ lvnE: '\u2268\uFE00',
+ mDDot: '\u223A',
+ macr: '\u00AF',
+ male: '\u2642',
+ malt: '\u2720',
+ maltese: '\u2720',
+ map: '\u21A6',
+ mapsto: '\u21A6',
+ mapstodown: '\u21A7',
+ mapstoleft: '\u21A4',
+ mapstoup: '\u21A5',
+ marker: '\u25AE',
+ mcomma: '\u2A29',
+ mcy: '\u043C',
+ mdash: '\u2014',
+ measuredangle: '\u2221',
+ mfr: '\uD835\uDD2A',
+ mho: '\u2127',
+ micro: '\u00B5',
+ mid: '\u2223',
+ midast: '\u002A',
+ midcir: '\u2AF0',
+ middot: '\u00B7',
+ minus: '\u2212',
+ minusb: '\u229F',
+ minusd: '\u2238',
+ minusdu: '\u2A2A',
+ mlcp: '\u2ADB',
+ mldr: '\u2026',
+ mnplus: '\u2213',
+ models: '\u22A7',
+ mopf: '\uD835\uDD5E',
+ mp: '\u2213',
+ mscr: '\uD835\uDCC2',
+ mstpos: '\u223E',
+ mu: '\u03BC',
+ multimap: '\u22B8',
+ mumap: '\u22B8',
+ nGg: '\u22D9\u0338',
+ nGt: '\u226B\u20D2',
+ nGtv: '\u226B\u0338',
+ nLeftarrow: '\u21CD',
+ nLeftrightarrow: '\u21CE',
+ nLl: '\u22D8\u0338',
+ nLt: '\u226A\u20D2',
+ nLtv: '\u226A\u0338',
+ nRightarrow: '\u21CF',
+ nVDash: '\u22AF',
+ nVdash: '\u22AE',
+ nabla: '\u2207',
+ nacute: '\u0144',
+ nang: '\u2220\u20D2',
+ nap: '\u2249',
+ napE: '\u2A70\u0338',
+ napid: '\u224B\u0338',
+ napos: '\u0149',
+ napprox: '\u2249',
+ natur: '\u266E',
+ natural: '\u266E',
+ naturals: '\u2115',
+ nbsp: '\u00A0',
+ nbump: '\u224E\u0338',
+ nbumpe: '\u224F\u0338',
+ ncap: '\u2A43',
+ ncaron: '\u0148',
+ ncedil: '\u0146',
+ ncong: '\u2247',
+ ncongdot: '\u2A6D\u0338',
+ ncup: '\u2A42',
+ ncy: '\u043D',
+ ndash: '\u2013',
+ ne: '\u2260',
+ neArr: '\u21D7',
+ nearhk: '\u2924',
+ nearr: '\u2197',
+ nearrow: '\u2197',
+ nedot: '\u2250\u0338',
+ nequiv: '\u2262',
+ nesear: '\u2928',
+ nesim: '\u2242\u0338',
+ nexist: '\u2204',
+ nexists: '\u2204',
+ nfr: '\uD835\uDD2B',
+ ngE: '\u2267\u0338',
+ nge: '\u2271',
+ ngeq: '\u2271',
+ ngeqq: '\u2267\u0338',
+ ngeqslant: '\u2A7E\u0338',
+ nges: '\u2A7E\u0338',
+ ngsim: '\u2275',
+ ngt: '\u226F',
+ ngtr: '\u226F',
+ nhArr: '\u21CE',
+ nharr: '\u21AE',
+ nhpar: '\u2AF2',
+ ni: '\u220B',
+ nis: '\u22FC',
+ nisd: '\u22FA',
+ niv: '\u220B',
+ njcy: '\u045A',
+ nlArr: '\u21CD',
+ nlE: '\u2266\u0338',
+ nlarr: '\u219A',
+ nldr: '\u2025',
+ nle: '\u2270',
+ nleftarrow: '\u219A',
+ nleftrightarrow: '\u21AE',
+ nleq: '\u2270',
+ nleqq: '\u2266\u0338',
+ nleqslant: '\u2A7D\u0338',
+ nles: '\u2A7D\u0338',
+ nless: '\u226E',
+ nlsim: '\u2274',
+ nlt: '\u226E',
+ nltri: '\u22EA',
+ nltrie: '\u22EC',
+ nmid: '\u2224',
+ nopf: '\uD835\uDD5F',
+ not: '\u00AC',
+ notin: '\u2209',
+ notinE: '\u22F9\u0338',
+ notindot: '\u22F5\u0338',
+ notinva: '\u2209',
+ notinvb: '\u22F7',
+ notinvc: '\u22F6',
+ notni: '\u220C',
+ notniva: '\u220C',
+ notnivb: '\u22FE',
+ notnivc: '\u22FD',
+ npar: '\u2226',
+ nparallel: '\u2226',
+ nparsl: '\u2AFD\u20E5',
+ npart: '\u2202\u0338',
+ npolint: '\u2A14',
+ npr: '\u2280',
+ nprcue: '\u22E0',
+ npre: '\u2AAF\u0338',
+ nprec: '\u2280',
+ npreceq: '\u2AAF\u0338',
+ nrArr: '\u21CF',
+ nrarr: '\u219B',
+ nrarrc: '\u2933\u0338',
+ nrarrw: '\u219D\u0338',
+ nrightarrow: '\u219B',
+ nrtri: '\u22EB',
+ nrtrie: '\u22ED',
+ nsc: '\u2281',
+ nsccue: '\u22E1',
+ nsce: '\u2AB0\u0338',
+ nscr: '\uD835\uDCC3',
+ nshortmid: '\u2224',
+ nshortparallel: '\u2226',
+ nsim: '\u2241',
+ nsime: '\u2244',
+ nsimeq: '\u2244',
+ nsmid: '\u2224',
+ nspar: '\u2226',
+ nsqsube: '\u22E2',
+ nsqsupe: '\u22E3',
+ nsub: '\u2284',
+ nsubE: '\u2AC5\u0338',
+ nsube: '\u2288',
+ nsubset: '\u2282\u20D2',
+ nsubseteq: '\u2288',
+ nsubseteqq: '\u2AC5\u0338',
+ nsucc: '\u2281',
+ nsucceq: '\u2AB0\u0338',
+ nsup: '\u2285',
+ nsupE: '\u2AC6\u0338',
+ nsupe: '\u2289',
+ nsupset: '\u2283\u20D2',
+ nsupseteq: '\u2289',
+ nsupseteqq: '\u2AC6\u0338',
+ ntgl: '\u2279',
+ ntilde: '\u00F1',
+ ntlg: '\u2278',
+ ntriangleleft: '\u22EA',
+ ntrianglelefteq: '\u22EC',
+ ntriangleright: '\u22EB',
+ ntrianglerighteq: '\u22ED',
+ nu: '\u03BD',
+ num: '\u0023',
+ numero: '\u2116',
+ numsp: '\u2007',
+ nvDash: '\u22AD',
+ nvHarr: '\u2904',
+ nvap: '\u224D\u20D2',
+ nvdash: '\u22AC',
+ nvge: '\u2265\u20D2',
+ nvgt: '\u003E\u20D2',
+ nvinfin: '\u29DE',
+ nvlArr: '\u2902',
+ nvle: '\u2264\u20D2',
+ nvlt: '\u003C\u20D2',
+ nvltrie: '\u22B4\u20D2',
+ nvrArr: '\u2903',
+ nvrtrie: '\u22B5\u20D2',
+ nvsim: '\u223C\u20D2',
+ nwArr: '\u21D6',
+ nwarhk: '\u2923',
+ nwarr: '\u2196',
+ nwarrow: '\u2196',
+ nwnear: '\u2927',
+ oS: '\u24C8',
+ oacute: '\u00F3',
+ oast: '\u229B',
+ ocir: '\u229A',
+ ocirc: '\u00F4',
+ ocy: '\u043E',
+ odash: '\u229D',
+ odblac: '\u0151',
+ odiv: '\u2A38',
+ odot: '\u2299',
+ odsold: '\u29BC',
+ oelig: '\u0153',
+ ofcir: '\u29BF',
+ ofr: '\uD835\uDD2C',
+ ogon: '\u02DB',
+ ograve: '\u00F2',
+ ogt: '\u29C1',
+ ohbar: '\u29B5',
+ ohm: '\u03A9',
+ oint: '\u222E',
+ olarr: '\u21BA',
+ olcir: '\u29BE',
+ olcross: '\u29BB',
+ oline: '\u203E',
+ olt: '\u29C0',
+ omacr: '\u014D',
+ omega: '\u03C9',
+ omicron: '\u03BF',
+ omid: '\u29B6',
+ ominus: '\u2296',
+ oopf: '\uD835\uDD60',
+ opar: '\u29B7',
+ operp: '\u29B9',
+ oplus: '\u2295',
+ or: '\u2228',
+ orarr: '\u21BB',
+ ord: '\u2A5D',
+ order: '\u2134',
+ orderof: '\u2134',
+ ordf: '\u00AA',
+ ordm: '\u00BA',
+ origof: '\u22B6',
+ oror: '\u2A56',
+ orslope: '\u2A57',
+ orv: '\u2A5B',
+ oscr: '\u2134',
+ oslash: '\u00F8',
+ osol: '\u2298',
+ otilde: '\u00F5',
+ otimes: '\u2297',
+ otimesas: '\u2A36',
+ ouml: '\u00F6',
+ ovbar: '\u233D',
+ par: '\u2225',
+ para: '\u00B6',
+ parallel: '\u2225',
+ parsim: '\u2AF3',
+ parsl: '\u2AFD',
+ part: '\u2202',
+ pcy: '\u043F',
+ percnt: '\u0025',
+ period: '\u002E',
+ permil: '\u2030',
+ perp: '\u22A5',
+ pertenk: '\u2031',
+ pfr: '\uD835\uDD2D',
+ phi: '\u03C6',
+ phiv: '\u03D5',
+ phmmat: '\u2133',
+ phone: '\u260E',
+ pi: '\u03C0',
+ pitchfork: '\u22D4',
+ piv: '\u03D6',
+ planck: '\u210F',
+ planckh: '\u210E',
+ plankv: '\u210F',
+ plus: '\u002B',
+ plusacir: '\u2A23',
+ plusb: '\u229E',
+ pluscir: '\u2A22',
+ plusdo: '\u2214',
+ plusdu: '\u2A25',
+ pluse: '\u2A72',
+ plusmn: '\u00B1',
+ plussim: '\u2A26',
+ plustwo: '\u2A27',
+ pm: '\u00B1',
+ pointint: '\u2A15',
+ popf: '\uD835\uDD61',
+ pound: '\u00A3',
+ pr: '\u227A',
+ prE: '\u2AB3',
+ prap: '\u2AB7',
+ prcue: '\u227C',
+ pre: '\u2AAF',
+ prec: '\u227A',
+ precapprox: '\u2AB7',
+ preccurlyeq: '\u227C',
+ preceq: '\u2AAF',
+ precnapprox: '\u2AB9',
+ precneqq: '\u2AB5',
+ precnsim: '\u22E8',
+ precsim: '\u227E',
+ prime: '\u2032',
+ primes: '\u2119',
+ prnE: '\u2AB5',
+ prnap: '\u2AB9',
+ prnsim: '\u22E8',
+ prod: '\u220F',
+ profalar: '\u232E',
+ profline: '\u2312',
+ profsurf: '\u2313',
+ prop: '\u221D',
+ propto: '\u221D',
+ prsim: '\u227E',
+ prurel: '\u22B0',
+ pscr: '\uD835\uDCC5',
+ psi: '\u03C8',
+ puncsp: '\u2008',
+ qfr: '\uD835\uDD2E',
+ qint: '\u2A0C',
+ qopf: '\uD835\uDD62',
+ qprime: '\u2057',
+ qscr: '\uD835\uDCC6',
+ quaternions: '\u210D',
+ quatint: '\u2A16',
+ quest: '\u003F',
+ questeq: '\u225F',
+ quot: '\u0022',
+ rAarr: '\u21DB',
+ rArr: '\u21D2',
+ rAtail: '\u291C',
+ rBarr: '\u290F',
+ rHar: '\u2964',
+ race: '\u223D\u0331',
+ racute: '\u0155',
+ radic: '\u221A',
+ raemptyv: '\u29B3',
+ rang: '\u27E9',
+ rangd: '\u2992',
+ range: '\u29A5',
+ rangle: '\u27E9',
+ raquo: '\u00BB',
+ rarr: '\u2192',
+ rarrap: '\u2975',
+ rarrb: '\u21E5',
+ rarrbfs: '\u2920',
+ rarrc: '\u2933',
+ rarrfs: '\u291E',
+ rarrhk: '\u21AA',
+ rarrlp: '\u21AC',
+ rarrpl: '\u2945',
+ rarrsim: '\u2974',
+ rarrtl: '\u21A3',
+ rarrw: '\u219D',
+ ratail: '\u291A',
+ ratio: '\u2236',
+ rationals: '\u211A',
+ rbarr: '\u290D',
+ rbbrk: '\u2773',
+ rbrace: '\u007D',
+ rbrack: '\u005D',
+ rbrke: '\u298C',
+ rbrksld: '\u298E',
+ rbrkslu: '\u2990',
+ rcaron: '\u0159',
+ rcedil: '\u0157',
+ rceil: '\u2309',
+ rcub: '\u007D',
+ rcy: '\u0440',
+ rdca: '\u2937',
+ rdldhar: '\u2969',
+ rdquo: '\u201D',
+ rdquor: '\u201D',
+ rdsh: '\u21B3',
+ real: '\u211C',
+ realine: '\u211B',
+ realpart: '\u211C',
+ reals: '\u211D',
+ rect: '\u25AD',
+ reg: '\u00AE',
+ rfisht: '\u297D',
+ rfloor: '\u230B',
+ rfr: '\uD835\uDD2F',
+ rhard: '\u21C1',
+ rharu: '\u21C0',
+ rharul: '\u296C',
+ rho: '\u03C1',
+ rhov: '\u03F1',
+ rightarrow: '\u2192',
+ rightarrowtail: '\u21A3',
+ rightharpoondown: '\u21C1',
+ rightharpoonup: '\u21C0',
+ rightleftarrows: '\u21C4',
+ rightleftharpoons: '\u21CC',
+ rightrightarrows: '\u21C9',
+ rightsquigarrow: '\u219D',
+ rightthreetimes: '\u22CC',
+ ring: '\u02DA',
+ risingdotseq: '\u2253',
+ rlarr: '\u21C4',
+ rlhar: '\u21CC',
+ rlm: '\u200F',
+ rmoust: '\u23B1',
+ rmoustache: '\u23B1',
+ rnmid: '\u2AEE',
+ roang: '\u27ED',
+ roarr: '\u21FE',
+ robrk: '\u27E7',
+ ropar: '\u2986',
+ ropf: '\uD835\uDD63',
+ roplus: '\u2A2E',
+ rotimes: '\u2A35',
+ rpar: '\u0029',
+ rpargt: '\u2994',
+ rppolint: '\u2A12',
+ rrarr: '\u21C9',
+ rsaquo: '\u203A',
+ rscr: '\uD835\uDCC7',
+ rsh: '\u21B1',
+ rsqb: '\u005D',
+ rsquo: '\u2019',
+ rsquor: '\u2019',
+ rthree: '\u22CC',
+ rtimes: '\u22CA',
+ rtri: '\u25B9',
+ rtrie: '\u22B5',
+ rtrif: '\u25B8',
+ rtriltri: '\u29CE',
+ ruluhar: '\u2968',
+ rx: '\u211E',
+ sacute: '\u015B',
+ sbquo: '\u201A',
+ sc: '\u227B',
+ scE: '\u2AB4',
+ scap: '\u2AB8',
+ scaron: '\u0161',
+ sccue: '\u227D',
+ sce: '\u2AB0',
+ scedil: '\u015F',
+ scirc: '\u015D',
+ scnE: '\u2AB6',
+ scnap: '\u2ABA',
+ scnsim: '\u22E9',
+ scpolint: '\u2A13',
+ scsim: '\u227F',
+ scy: '\u0441',
+ sdot: '\u22C5',
+ sdotb: '\u22A1',
+ sdote: '\u2A66',
+ seArr: '\u21D8',
+ searhk: '\u2925',
+ searr: '\u2198',
+ searrow: '\u2198',
+ sect: '\u00A7',
+ semi: '\u003B',
+ seswar: '\u2929',
+ setminus: '\u2216',
+ setmn: '\u2216',
+ sext: '\u2736',
+ sfr: '\uD835\uDD30',
+ sfrown: '\u2322',
+ sharp: '\u266F',
+ shchcy: '\u0449',
+ shcy: '\u0448',
+ shortmid: '\u2223',
+ shortparallel: '\u2225',
+ shy: '\u00AD',
+ sigma: '\u03C3',
+ sigmaf: '\u03C2',
+ sigmav: '\u03C2',
+ sim: '\u223C',
+ simdot: '\u2A6A',
+ sime: '\u2243',
+ simeq: '\u2243',
+ simg: '\u2A9E',
+ simgE: '\u2AA0',
+ siml: '\u2A9D',
+ simlE: '\u2A9F',
+ simne: '\u2246',
+ simplus: '\u2A24',
+ simrarr: '\u2972',
+ slarr: '\u2190',
+ smallsetminus: '\u2216',
+ smashp: '\u2A33',
+ smeparsl: '\u29E4',
+ smid: '\u2223',
+ smile: '\u2323',
+ smt: '\u2AAA',
+ smte: '\u2AAC',
+ smtes: '\u2AAC\uFE00',
+ softcy: '\u044C',
+ sol: '\u002F',
+ solb: '\u29C4',
+ solbar: '\u233F',
+ sopf: '\uD835\uDD64',
+ spades: '\u2660',
+ spadesuit: '\u2660',
+ spar: '\u2225',
+ sqcap: '\u2293',
+ sqcaps: '\u2293\uFE00',
+ sqcup: '\u2294',
+ sqcups: '\u2294\uFE00',
+ sqsub: '\u228F',
+ sqsube: '\u2291',
+ sqsubset: '\u228F',
+ sqsubseteq: '\u2291',
+ sqsup: '\u2290',
+ sqsupe: '\u2292',
+ sqsupset: '\u2290',
+ sqsupseteq: '\u2292',
+ squ: '\u25A1',
+ square: '\u25A1',
+ squarf: '\u25AA',
+ squf: '\u25AA',
+ srarr: '\u2192',
+ sscr: '\uD835\uDCC8',
+ ssetmn: '\u2216',
+ ssmile: '\u2323',
+ sstarf: '\u22C6',
+ star: '\u2606',
+ starf: '\u2605',
+ straightepsilon: '\u03F5',
+ straightphi: '\u03D5',
+ strns: '\u00AF',
+ sub: '\u2282',
+ subE: '\u2AC5',
+ subdot: '\u2ABD',
+ sube: '\u2286',
+ subedot: '\u2AC3',
+ submult: '\u2AC1',
+ subnE: '\u2ACB',
+ subne: '\u228A',
+ subplus: '\u2ABF',
+ subrarr: '\u2979',
+ subset: '\u2282',
+ subseteq: '\u2286',
+ subseteqq: '\u2AC5',
+ subsetneq: '\u228A',
+ subsetneqq: '\u2ACB',
+ subsim: '\u2AC7',
+ subsub: '\u2AD5',
+ subsup: '\u2AD3',
+ succ: '\u227B',
+ succapprox: '\u2AB8',
+ succcurlyeq: '\u227D',
+ succeq: '\u2AB0',
+ succnapprox: '\u2ABA',
+ succneqq: '\u2AB6',
+ succnsim: '\u22E9',
+ succsim: '\u227F',
+ sum: '\u2211',
+ sung: '\u266A',
+ sup1: '\u00B9',
+ sup2: '\u00B2',
+ sup3: '\u00B3',
+ sup: '\u2283',
+ supE: '\u2AC6',
+ supdot: '\u2ABE',
+ supdsub: '\u2AD8',
+ supe: '\u2287',
+ supedot: '\u2AC4',
+ suphsol: '\u27C9',
+ suphsub: '\u2AD7',
+ suplarr: '\u297B',
+ supmult: '\u2AC2',
+ supnE: '\u2ACC',
+ supne: '\u228B',
+ supplus: '\u2AC0',
+ supset: '\u2283',
+ supseteq: '\u2287',
+ supseteqq: '\u2AC6',
+ supsetneq: '\u228B',
+ supsetneqq: '\u2ACC',
+ supsim: '\u2AC8',
+ supsub: '\u2AD4',
+ supsup: '\u2AD6',
+ swArr: '\u21D9',
+ swarhk: '\u2926',
+ swarr: '\u2199',
+ swarrow: '\u2199',
+ swnwar: '\u292A',
+ szlig: '\u00DF',
+ target: '\u2316',
+ tau: '\u03C4',
+ tbrk: '\u23B4',
+ tcaron: '\u0165',
+ tcedil: '\u0163',
+ tcy: '\u0442',
+ tdot: '\u20DB',
+ telrec: '\u2315',
+ tfr: '\uD835\uDD31',
+ there4: '\u2234',
+ therefore: '\u2234',
+ theta: '\u03B8',
+ thetasym: '\u03D1',
+ thetav: '\u03D1',
+ thickapprox: '\u2248',
+ thicksim: '\u223C',
+ thinsp: '\u2009',
+ thkap: '\u2248',
+ thksim: '\u223C',
+ thorn: '\u00FE',
+ tilde: '\u02DC',
+ times: '\u00D7',
+ timesb: '\u22A0',
+ timesbar: '\u2A31',
+ timesd: '\u2A30',
+ tint: '\u222D',
+ toea: '\u2928',
+ top: '\u22A4',
+ topbot: '\u2336',
+ topcir: '\u2AF1',
+ topf: '\uD835\uDD65',
+ topfork: '\u2ADA',
+ tosa: '\u2929',
+ tprime: '\u2034',
+ trade: '\u2122',
+ triangle: '\u25B5',
+ triangledown: '\u25BF',
+ triangleleft: '\u25C3',
+ trianglelefteq: '\u22B4',
+ triangleq: '\u225C',
+ triangleright: '\u25B9',
+ trianglerighteq: '\u22B5',
+ tridot: '\u25EC',
+ trie: '\u225C',
+ triminus: '\u2A3A',
+ triplus: '\u2A39',
+ trisb: '\u29CD',
+ tritime: '\u2A3B',
+ trpezium: '\u23E2',
+ tscr: '\uD835\uDCC9',
+ tscy: '\u0446',
+ tshcy: '\u045B',
+ tstrok: '\u0167',
+ twixt: '\u226C',
+ twoheadleftarrow: '\u219E',
+ twoheadrightarrow: '\u21A0',
+ uArr: '\u21D1',
+ uHar: '\u2963',
+ uacute: '\u00FA',
+ uarr: '\u2191',
+ ubrcy: '\u045E',
+ ubreve: '\u016D',
+ ucirc: '\u00FB',
+ ucy: '\u0443',
+ udarr: '\u21C5',
+ udblac: '\u0171',
+ udhar: '\u296E',
+ ufisht: '\u297E',
+ ufr: '\uD835\uDD32',
+ ugrave: '\u00F9',
+ uharl: '\u21BF',
+ uharr: '\u21BE',
+ uhblk: '\u2580',
+ ulcorn: '\u231C',
+ ulcorner: '\u231C',
+ ulcrop: '\u230F',
+ ultri: '\u25F8',
+ umacr: '\u016B',
+ uml: '\u00A8',
+ uogon: '\u0173',
+ uopf: '\uD835\uDD66',
+ uparrow: '\u2191',
+ updownarrow: '\u2195',
+ upharpoonleft: '\u21BF',
+ upharpoonright: '\u21BE',
+ uplus: '\u228E',
+ upsi: '\u03C5',
+ upsih: '\u03D2',
+ upsilon: '\u03C5',
+ upuparrows: '\u21C8',
+ urcorn: '\u231D',
+ urcorner: '\u231D',
+ urcrop: '\u230E',
+ uring: '\u016F',
+ urtri: '\u25F9',
+ uscr: '\uD835\uDCCA',
+ utdot: '\u22F0',
+ utilde: '\u0169',
+ utri: '\u25B5',
+ utrif: '\u25B4',
+ uuarr: '\u21C8',
+ uuml: '\u00FC',
+ uwangle: '\u29A7',
+ vArr: '\u21D5',
+ vBar: '\u2AE8',
+ vBarv: '\u2AE9',
+ vDash: '\u22A8',
+ vangrt: '\u299C',
+ varepsilon: '\u03F5',
+ varkappa: '\u03F0',
+ varnothing: '\u2205',
+ varphi: '\u03D5',
+ varpi: '\u03D6',
+ varpropto: '\u221D',
+ varr: '\u2195',
+ varrho: '\u03F1',
+ varsigma: '\u03C2',
+ varsubsetneq: '\u228A\uFE00',
+ varsubsetneqq: '\u2ACB\uFE00',
+ varsupsetneq: '\u228B\uFE00',
+ varsupsetneqq: '\u2ACC\uFE00',
+ vartheta: '\u03D1',
+ vartriangleleft: '\u22B2',
+ vartriangleright: '\u22B3',
+ vcy: '\u0432',
+ vdash: '\u22A2',
+ vee: '\u2228',
+ veebar: '\u22BB',
+ veeeq: '\u225A',
+ vellip: '\u22EE',
+ verbar: '\u007C',
+ vert: '\u007C',
+ vfr: '\uD835\uDD33',
+ vltri: '\u22B2',
+ vnsub: '\u2282\u20D2',
+ vnsup: '\u2283\u20D2',
+ vopf: '\uD835\uDD67',
+ vprop: '\u221D',
+ vrtri: '\u22B3',
+ vscr: '\uD835\uDCCB',
+ vsubnE: '\u2ACB\uFE00',
+ vsubne: '\u228A\uFE00',
+ vsupnE: '\u2ACC\uFE00',
+ vsupne: '\u228B\uFE00',
+ vzigzag: '\u299A',
+ wcirc: '\u0175',
+ wedbar: '\u2A5F',
+ wedge: '\u2227',
+ wedgeq: '\u2259',
+ weierp: '\u2118',
+ wfr: '\uD835\uDD34',
+ wopf: '\uD835\uDD68',
+ wp: '\u2118',
+ wr: '\u2240',
+ wreath: '\u2240',
+ wscr: '\uD835\uDCCC',
+ xcap: '\u22C2',
+ xcirc: '\u25EF',
+ xcup: '\u22C3',
+ xdtri: '\u25BD',
+ xfr: '\uD835\uDD35',
+ xhArr: '\u27FA',
+ xharr: '\u27F7',
+ xi: '\u03BE',
+ xlArr: '\u27F8',
+ xlarr: '\u27F5',
+ xmap: '\u27FC',
+ xnis: '\u22FB',
+ xodot: '\u2A00',
+ xopf: '\uD835\uDD69',
+ xoplus: '\u2A01',
+ xotime: '\u2A02',
+ xrArr: '\u27F9',
+ xrarr: '\u27F6',
+ xscr: '\uD835\uDCCD',
+ xsqcup: '\u2A06',
+ xuplus: '\u2A04',
+ xutri: '\u25B3',
+ xvee: '\u22C1',
+ xwedge: '\u22C0',
+ yacute: '\u00FD',
+ yacy: '\u044F',
+ ycirc: '\u0177',
+ ycy: '\u044B',
+ yen: '\u00A5',
+ yfr: '\uD835\uDD36',
+ yicy: '\u0457',
+ yopf: '\uD835\uDD6A',
+ yscr: '\uD835\uDCCE',
+ yucy: '\u044E',
+ yuml: '\u00FF',
+ zacute: '\u017A',
+ zcaron: '\u017E',
+ zcy: '\u0437',
+ zdot: '\u017C',
+ zeetrf: '\u2128',
+ zeta: '\u03B6',
+ zfr: '\uD835\uDD37',
+ zhcy: '\u0436',
+ zigrarr: '\u21DD',
+ zopf: '\uD835\uDD6B',
+ zscr: '\uD835\uDCCF',
+ zwj: '\u200D',
+ zwnj: '\u200C'
+};
+const decodeMap = {
+ '0': 65533,
+ '128': 8364,
+ '130': 8218,
+ '131': 402,
+ '132': 8222,
+ '133': 8230,
+ '134': 8224,
+ '135': 8225,
+ '136': 710,
+ '137': 8240,
+ '138': 352,
+ '139': 8249,
+ '140': 338,
+ '142': 381,
+ '145': 8216,
+ '146': 8217,
+ '147': 8220,
+ '148': 8221,
+ '149': 8226,
+ '150': 8211,
+ '151': 8212,
+ '152': 732,
+ '153': 8482,
+ '154': 353,
+ '155': 8250,
+ '156': 339,
+ '158': 382,
+ '159': 376
+};
+function decodeHTMLStrict(text) {
+ return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
+ if (key.charAt(1) === '#') {
+ const secondChar = key.charAt(2);
+ const codePoint = secondChar === 'X' || secondChar === 'x'
+ ? parseInt(key.slice(3), 16)
+ : parseInt(key.slice(2), 10);
+ return decodeCodePoint(codePoint);
+ }
+ return entities[key.slice(1, -1)] || key;
+ });
+}
+function decodeCodePoint(codePoint) {
+ if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+ return '\uFFFD';
+ }
+ if (codePoint in decodeMap) {
+ codePoint = decodeMap[codePoint];
+ }
+ return String.fromCodePoint(codePoint);
+} + +function scanJSXAttributeValue(parser, context) {
+ parser.startPos = parser.tokenPos = parser.index;
+ parser.startColumn = parser.colPos = parser.column;
+ parser.startLine = parser.linePos = parser.line;
+ parser.token =
+ CharTypes[parser.currentChar] & 8192
+ ? scanJSXString(parser, context)
+ : scanSingleToken(parser, context, 0);
+ return parser.token;
+}
+function scanJSXString(parser, context) {
+ const quote = parser.currentChar;
+ let char = advanceChar(parser);
+ const start = parser.index;
+ while (char !== quote) {
+ if (parser.index >= parser.end)
+ report(parser, 14);
+ char = advanceChar(parser);
+ }
+ if (char !== quote)
+ report(parser, 14);
+ parser.tokenValue = parser.source.slice(start, parser.index);
+ advanceChar(parser);
+ if (context & 512)
+ parser.tokenRaw = parser.source.slice(parser.tokenPos, parser.index);
+ return 134283267;
+}
+function scanJSXToken(parser, context) {
+ parser.startPos = parser.tokenPos = parser.index;
+ parser.startColumn = parser.colPos = parser.column;
+ parser.startLine = parser.linePos = parser.line;
+ if (parser.index >= parser.end)
+ return (parser.token = 1048576);
+ const token = TokenLookup[parser.source.charCodeAt(parser.index)];
+ switch (token) {
+ case 8456258: {
+ advanceChar(parser);
+ if (parser.currentChar === 47) {
+ advanceChar(parser);
+ parser.token = 25;
+ }
+ else {
+ parser.token = 8456258;
+ }
+ break;
+ }
+ case 2162700: {
+ advanceChar(parser);
+ parser.token = 2162700;
+ break;
+ }
+ default: {
+ let state = 0;
+ while (parser.index < parser.end) {
+ const type = CharTypes[parser.source.charCodeAt(parser.index)];
+ if (type & 1024) {
+ state |= 1 | 4;
+ scanNewLine(parser);
+ }
+ else if (type & 2048) {
+ consumeLineFeed(parser, state);
+ state = (state & ~4) | 1;
+ }
+ else {
+ advanceChar(parser);
+ }
+ if (CharTypes[parser.currentChar] & 16384)
+ break;
+ }
+ const raw = parser.source.slice(parser.tokenPos, parser.index);
+ if (context & 512)
+ parser.tokenRaw = raw;
+ parser.tokenValue = decodeHTMLStrict(raw);
+ parser.token = 138;
+ }
+ }
+ return parser.token;
+}
+function scanJSXIdentifier(parser) {
+ if ((parser.token & 143360) === 143360) {
+ const { index } = parser;
+ let char = parser.currentChar;
+ while (CharTypes[char] & (32768 | 2)) {
+ char = advanceChar(parser);
+ }
+ parser.tokenValue += parser.source.slice(index, parser.index);
+ }
+ parser.token = 208897;
+ return parser.token;
+} + +function matchOrInsertSemicolon(parser, context, specDeviation) {
+ if ((parser.flags & 1) === 0 &&
+ (parser.token & 1048576) !== 1048576 &&
+ !specDeviation) {
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ consumeOpt(parser, context, 1074790417);
+}
+function isValidStrictMode(parser, index, tokenPos, tokenValue) {
+ if (index - tokenPos < 13 && tokenValue === 'use strict') {
+ if ((parser.token & 1048576) === 1048576 || parser.flags & 1) {
+ return 1;
+ }
+ }
+ return 0;
+}
+function optionalBit(parser, context, t) {
+ if (parser.token !== t)
+ return 0;
+ nextToken(parser, context);
+ return 1;
+}
+function consumeOpt(parser, context, t) {
+ if (parser.token !== t)
+ return false;
+ nextToken(parser, context);
+ return true;
+}
+function consume(parser, context, t) {
+ if (parser.token !== t)
+ report(parser, 23, KeywordDescTable[t & 255]);
+ nextToken(parser, context);
+}
+function reinterpretToPattern(state, node) {
+ switch (node.type) {
+ case 'ArrayExpression':
+ node.type = 'ArrayPattern';
+ const elements = node.elements;
+ for (let i = 0, n = elements.length; i < n; ++i) {
+ const element = elements[i];
+ if (element)
+ reinterpretToPattern(state, element);
+ }
+ return;
+ case 'ObjectExpression':
+ node.type = 'ObjectPattern';
+ const properties = node.properties;
+ for (let i = 0, n = properties.length; i < n; ++i) {
+ reinterpretToPattern(state, properties[i]);
+ }
+ return;
+ case 'AssignmentExpression':
+ node.type = 'AssignmentPattern';
+ if (node.operator !== '=')
+ report(state, 68);
+ delete node.operator;
+ reinterpretToPattern(state, node.left);
+ return;
+ case 'Property':
+ reinterpretToPattern(state, node.value);
+ return;
+ case 'SpreadElement':
+ node.type = 'RestElement';
+ reinterpretToPattern(state, node.argument);
+ }
+}
+function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
+ if (context & 1024) {
+ if ((t & 36864) === 36864) {
+ report(parser, 114);
+ }
+ if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ }
+ if ((t & 20480) === 20480) {
+ report(parser, 99);
+ }
+ if (kind & (8 | 16) && t === 241739) {
+ report(parser, 97);
+ }
+ if (context & (4194304 | 2048) && t === 209008) {
+ report(parser, 95);
+ }
+ if (context & (2097152 | 1024) && t === 241773) {
+ report(parser, 94, 'yield');
+ }
+}
+function validateFunctionName(parser, context, t) {
+ if (context & 1024) {
+ if ((t & 36864) === 36864) {
+ report(parser, 114);
+ }
+ if ((t & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ if (t === 122) {
+ report(parser, 92);
+ }
+ if (t === 121) {
+ report(parser, 92);
+ }
+ }
+ if ((t & 20480) === 20480) {
+ report(parser, 99);
+ }
+ if (context & (4194304 | 2048) && t === 209008) {
+ report(parser, 95);
+ }
+ if (context & (2097152 | 1024) && t === 241773) {
+ report(parser, 94, 'yield');
+ }
+}
+function isStrictReservedWord(parser, context, t) {
+ if (t === 209008) {
+ if (context & (4194304 | 2048))
+ report(parser, 95);
+ parser.destructible |= 128;
+ }
+ if (t === 241773 && context & 2097152)
+ report(parser, 94, 'yield');
+ return ((t & 20480) === 20480 ||
+ (t & 36864) === 36864 ||
+ t == 122);
+}
+function isPropertyWithPrivateFieldKey(expr) {
+ return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
+}
+function isValidLabel(parser, labels, name, isIterationStatement) {
+ while (labels) {
+ if (labels['$' + name]) {
+ if (isIterationStatement)
+ report(parser, 133);
+ return 1;
+ }
+ if (isIterationStatement && labels.loop)
+ isIterationStatement = 0;
+ labels = labels['$'];
+ }
+ return 0;
+}
+function validateAndDeclareLabel(parser, labels, name) {
+ let set = labels;
+ while (set) {
+ if (set['$' + name])
+ report(parser, 132, name);
+ set = set['$'];
+ }
+ labels['$' + name] = 1;
+}
+function finishNode(parser, context, start, line, column, node) {
+ if (context & 2) {
+ node.start = start;
+ node.end = parser.startPos;
+ node.range = [start, parser.startPos];
+ }
+ if (context & 4) {
+ node.loc = {
+ start: {
+ line,
+ column
+ },
+ end: {
+ line: parser.startLine,
+ column: parser.startColumn
+ }
+ };
+ if (parser.sourceFile) {
+ node.loc.source = parser.sourceFile;
+ }
+ }
+ return node;
+}
+function isEqualTagName(elementName) {
+ switch (elementName.type) {
+ case 'JSXIdentifier':
+ return elementName.name;
+ case 'JSXNamespacedName':
+ return elementName.namespace + ':' + elementName.name;
+ case 'JSXMemberExpression':
+ return isEqualTagName(elementName.object) + '.' + isEqualTagName(elementName.property);
+ }
+}
+function createArrowHeadParsingScope(parser, context, value) {
+ const scope = addChildScope(createScope(), 1024);
+ addBlockName(parser, context, scope, value, 1, 0);
+ return scope;
+}
+function recordScopeError(parser, type, ...params) {
+ const { index, line, column } = parser;
+ return {
+ type,
+ params,
+ index,
+ line,
+ column
+ };
+}
+function createScope() {
+ return {
+ parent: void 0,
+ type: 2
+ };
+}
+function addChildScope(parent, type) {
+ return {
+ parent,
+ type,
+ scopeError: void 0
+ };
+}
+function addVarOrBlock(parser, context, scope, name, kind, origin) {
+ if (kind & 4) {
+ addVarName(parser, context, scope, name, kind);
+ }
+ else {
+ addBlockName(parser, context, scope, name, kind, origin);
+ }
+ if (origin & 64) {
+ declareUnboundVariable(parser, name);
+ }
+}
+function addBlockName(parser, context, scope, name, kind, origin) {
+ const value = scope['#' + name];
+ if (value && (value & 2) === 0) {
+ if (kind & 1) {
+ scope.scopeError = recordScopeError(parser, 140, name);
+ }
+ else if (context & 256 &&
+ value & 64 &&
+ origin & 2) ;
+ else {
+ report(parser, 140, name);
+ }
+ }
+ if (scope.type & 128 &&
+ (scope.parent['#' + name] && (scope.parent['#' + name] & 2) === 0)) {
+ report(parser, 140, name);
+ }
+ if (scope.type & 1024 && value && (value & 2) === 0) {
+ if (kind & 1) {
+ scope.scopeError = recordScopeError(parser, 140, name);
+ }
+ }
+ if (scope.type & 64) {
+ if (scope.parent['#' + name] & 768)
+ report(parser, 153, name);
+ }
+ scope['#' + name] = kind;
+}
+function addVarName(parser, context, scope, name, kind) {
+ let currentScope = scope;
+ while (currentScope && (currentScope.type & 256) === 0) {
+ const value = currentScope['#' + name];
+ if (value & 248) {
+ if (context & 256 &&
+ (context & 1024) === 0 &&
+ ((kind & 128 && value & 68) ||
+ (value & 128 && kind & 68))) ;
+ else {
+ report(parser, 140, name);
+ }
+ }
+ if (currentScope === scope) {
+ if (value & 1 && kind & 1) {
+ currentScope.scopeError = recordScopeError(parser, 140, name);
+ }
+ }
+ if (value & (512 | 256)) {
+ if ((value & 512) === 0 ||
+ (context & 256) === 0 ||
+ context & 1024) {
+ report(parser, 140, name);
+ }
+ }
+ currentScope['#' + name] = kind;
+ currentScope = currentScope.parent;
+ }
+}
+function declareUnboundVariable(parser, name) {
+ if (parser.exportedNames !== void 0 && name !== '') {
+ if (parser.exportedNames['#' + name]) {
+ report(parser, 141, name);
+ }
+ parser.exportedNames['#' + name] = 1;
+ }
+}
+function addBindingToExports(parser, name) {
+ if (parser.exportedBindings !== void 0 && name !== '') {
+ parser.exportedBindings['#' + name] = 1;
+ }
+}
+function pushComment(context, array) {
+ return function (type, value, start, end, loc) {
+ const comment = {
+ type,
+ value
+ };
+ if (context & 2) {
+ comment.start = start;
+ comment.end = end;
+ comment.range = [start, end];
+ }
+ if (context & 4) {
+ comment.loc = loc;
+ }
+ array.push(comment);
+ };
+}
+function pushToken(context, array) {
+ return function (token, start, end, loc) {
+ const tokens = {
+ token
+ };
+ if (context & 2) {
+ tokens.start = start;
+ tokens.end = end;
+ tokens.range = [start, end];
+ }
+ if (context & 4) {
+ tokens.loc = loc;
+ }
+ array.push(tokens);
+ };
+}
+function isValidIdentifier(context, t) {
+ if (context & (1024 | 2097152)) {
+ if (context & 2048 && t === 209008)
+ return false;
+ if (context & 2097152 && t === 241773)
+ return false;
+ return (t & 143360) === 143360 || (t & 12288) === 12288;
+ }
+ return ((t & 143360) === 143360 ||
+ (t & 12288) === 12288 ||
+ (t & 36864) === 36864);
+}
+function classifyIdentifier(parser, context, t, isArrow) {
+ if ((t & 537079808) === 537079808) {
+ if (context & 1024)
+ report(parser, 115);
+ if (isArrow)
+ parser.flags |= 512;
+ }
+ if (!isValidIdentifier(context, t))
+ report(parser, 0);
+} + +function create(source, sourceFile, onComment, onToken) {
+ return {
+ source,
+ flags: 0,
+ index: 0,
+ line: 1,
+ column: 0,
+ startPos: 0,
+ end: source.length,
+ tokenPos: 0,
+ startColumn: 0,
+ colPos: 0,
+ linePos: 1,
+ startLine: 1,
+ sourceFile,
+ tokenValue: '',
+ token: 1048576,
+ tokenRaw: '',
+ tokenRegExp: void 0,
+ currentChar: source.charCodeAt(0),
+ exportedNames: [],
+ exportedBindings: [],
+ assignable: 1,
+ destructible: 0,
+ onComment,
+ onToken,
+ leadingDecorators: []
+ };
+}
+function parseSource(source, options, context) {
+ let sourceFile = '';
+ let onComment;
+ let onToken;
+ if (options != null) {
+ if (options.module)
+ context |= 2048 | 1024;
+ if (options.next)
+ context |= 1;
+ if (options.loc)
+ context |= 4;
+ if (options.ranges)
+ context |= 2;
+ if (options.uniqueKeyInPattern)
+ context |= -2147483648;
+ if (options.lexical)
+ context |= 64;
+ if (options.webcompat)
+ context |= 256;
+ if (options.directives)
+ context |= 8 | 512;
+ if (options.globalReturn)
+ context |= 32;
+ if (options.raw)
+ context |= 512;
+ if (options.preserveParens)
+ context |= 128;
+ if (options.impliedStrict)
+ context |= 1024;
+ if (options.jsx)
+ context |= 16;
+ if (options.identifierPattern)
+ context |= 268435456;
+ if (options.specDeviation)
+ context |= 536870912;
+ if (options.source)
+ sourceFile = options.source;
+ if (options.onComment != null) {
+ onComment = Array.isArray(options.onComment) ? pushComment(context, options.onComment) : options.onComment;
+ }
+ if (options.onToken != null) {
+ onToken = Array.isArray(options.onToken) ? pushToken(context, options.onToken) : options.onToken;
+ }
+ }
+ const parser = create(source, sourceFile, onComment, onToken);
+ if (context & 1)
+ skipHashBang(parser);
+ const scope = context & 64 ? createScope() : void 0;
+ let body = [];
+ let sourceType = 'script';
+ if (context & 2048) {
+ sourceType = 'module';
+ body = parseModuleItemList(parser, context | 8192, scope);
+ if (scope) {
+ for (const key in parser.exportedBindings) {
+ if (key[0] === '#' && !scope[key])
+ report(parser, 142, key.slice(1));
+ }
+ }
+ }
+ else {
+ body = parseStatementList(parser, context | 8192, scope);
+ }
+ const node = {
+ type: 'Program',
+ sourceType,
+ body
+ };
+ if (context & 2) {
+ node.start = 0;
+ node.end = source.length;
+ node.range = [0, source.length];
+ }
+ if (context & 4) {
+ node.loc = {
+ start: { line: 1, column: 0 },
+ end: { line: parser.line, column: parser.column }
+ };
+ if (parser.sourceFile)
+ node.loc.source = sourceFile;
+ }
+ return node;
+}
+function parseStatementList(parser, context, scope) {
+ nextToken(parser, context | 32768 | 1073741824);
+ const statements = [];
+ while (parser.token === 134283267) {
+ const { index, tokenPos, tokenValue, linePos, colPos, token } = parser;
+ const expr = parseLiteral(parser, context);
+ if (isValidStrictMode(parser, index, tokenPos, tokenValue))
+ context |= 1024;
+ statements.push(parseDirective(parser, context, expr, token, tokenPos, linePos, colPos));
+ }
+ while (parser.token !== 1048576) {
+ statements.push(parseStatementListItem(parser, context, scope, 4, {}));
+ }
+ return statements;
+}
+function parseModuleItemList(parser, context, scope) {
+ nextToken(parser, context | 32768);
+ const statements = [];
+ if (context & 8) {
+ while (parser.token === 134283267) {
+ const { tokenPos, linePos, colPos, token } = parser;
+ statements.push(parseDirective(parser, context, parseLiteral(parser, context), token, tokenPos, linePos, colPos));
+ }
+ }
+ while (parser.token !== 1048576) {
+ statements.push(parseModuleItem(parser, context, scope));
+ }
+ return statements;
+}
+function parseModuleItem(parser, context, scope) {
+ parser.leadingDecorators = parseDecorators(parser, context);
+ let moduleItem;
+ switch (parser.token) {
+ case 20566:
+ moduleItem = parseExportDeclaration(parser, context, scope);
+ break;
+ case 86108:
+ moduleItem = parseImportDeclaration(parser, context, scope);
+ break;
+ default:
+ moduleItem = parseStatementListItem(parser, context, scope, 4, {});
+ }
+ if (parser.leadingDecorators.length) {
+ report(parser, 164);
+ }
+ return moduleItem;
+}
+function parseStatementListItem(parser, context, scope, origin, labels) {
+ const start = parser.tokenPos;
+ const line = parser.linePos;
+ const column = parser.colPos;
+ switch (parser.token) {
+ case 86106:
+ return parseFunctionDeclaration(parser, context, scope, origin, 1, 0, 0, start, line, column);
+ case 133:
+ case 86096:
+ return parseClassDeclaration(parser, context, scope, 0, start, line, column);
+ case 86092:
+ return parseLexicalDeclaration(parser, context, scope, 16, 0, start, line, column);
+ case 241739:
+ return parseLetIdentOrVarDeclarationStatement(parser, context, scope, origin, start, line, column);
+ case 20566:
+ report(parser, 100, 'export');
+ case 86108:
+ nextToken(parser, context);
+ switch (parser.token) {
+ case 67174411:
+ return parseImportCallDeclaration(parser, context, start, line, column);
+ case 67108877:
+ return parseImportMetaDeclaration(parser, context, start, line, column);
+ default:
+ report(parser, 100, 'import');
+ }
+ case 209007:
+ return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 1, start, line, column);
+ default:
+ return parseStatement(parser, context, scope, origin, labels, 1, start, line, column);
+ }
+}
+function parseStatement(parser, context, scope, origin, labels, allowFuncDecl, start, line, column) {
+ switch (parser.token) {
+ case 86090:
+ return parseVariableStatement(parser, context, scope, 0, start, line, column);
+ case 20574:
+ return parseReturnStatement(parser, context, start, line, column);
+ case 20571:
+ return parseIfStatement(parser, context, scope, labels, start, line, column);
+ case 20569:
+ return parseForStatement(parser, context, scope, labels, start, line, column);
+ case 20564:
+ return parseDoWhileStatement(parser, context, scope, labels, start, line, column);
+ case 20580:
+ return parseWhileStatement(parser, context, scope, labels, start, line, column);
+ case 86112:
+ return parseSwitchStatement(parser, context, scope, labels, start, line, column);
+ case 1074790417:
+ return parseEmptyStatement(parser, context, start, line, column);
+ case 2162700:
+ return parseBlock(parser, context, scope ? addChildScope(scope, 2) : scope, labels, start, line, column);
+ case 86114:
+ return parseThrowStatement(parser, context, start, line, column);
+ case 20557:
+ return parseBreakStatement(parser, context, labels, start, line, column);
+ case 20561:
+ return parseContinueStatement(parser, context, labels, start, line, column);
+ case 20579:
+ return parseTryStatement(parser, context, scope, labels, start, line, column);
+ case 20581:
+ return parseWithStatement(parser, context, scope, labels, start, line, column);
+ case 20562:
+ return parseDebuggerStatement(parser, context, start, line, column);
+ case 209007:
+ return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 0, start, line, column);
+ case 20559:
+ report(parser, 156);
+ case 20568:
+ report(parser, 157);
+ case 86106:
+ report(parser, context & 1024
+ ? 73
+ : (context & 256) < 1
+ ? 75
+ : 74);
+ case 86096:
+ report(parser, 76);
+ default:
+ return parseExpressionOrLabelledStatement(parser, context, scope, origin, labels, allowFuncDecl, start, line, column);
+ }
+}
+function parseExpressionOrLabelledStatement(parser, context, scope, origin, labels, allowFuncDecl, start, line, column) {
+ const { tokenValue, token } = parser;
+ let expr;
+ switch (token) {
+ case 241739:
+ expr = parseIdentifier(parser, context, 0);
+ if (context & 1024)
+ report(parser, 82);
+ if (parser.token === 69271571)
+ report(parser, 81);
+ break;
+ default:
+ expr = parsePrimaryExpression(parser, context, 2, 0, 1, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ if (token & 143360 && parser.token === 21) {
+ return parseLabelledStatement(parser, context, scope, origin, labels, tokenValue, expr, token, allowFuncDecl, start, line, column);
+ }
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+ expr = parseAssignmentExpression(parser, context, 0, 0, start, line, column, expr);
+ if (parser.token === 18) {
+ expr = parseSequenceExpression(parser, context, 0, start, line, column, expr);
+ }
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+}
+function parseBlock(parser, context, scope, labels, start, line, column) {
+ const body = [];
+ consume(parser, context | 32768, 2162700);
+ while (parser.token !== 1074790415) {
+ body.push(parseStatementListItem(parser, context, scope, 2, { $: labels }));
+ }
+ consume(parser, context | 32768, 1074790415);
+ return finishNode(parser, context, start, line, column, {
+ type: 'BlockStatement',
+ body
+ });
+}
+function parseReturnStatement(parser, context, start, line, column) {
+ if ((context & 32) < 1 && context & 8192)
+ report(parser, 89);
+ nextToken(parser, context | 32768);
+ const argument = parser.flags & 1 || parser.token & 1048576
+ ? null
+ : parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.line, parser.column);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ReturnStatement',
+ argument
+ });
+}
+function parseExpressionStatement(parser, context, expression, start, line, column) {
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ExpressionStatement',
+ expression
+ });
+}
+function parseLabelledStatement(parser, context, scope, origin, labels, value, expr, token, allowFuncDecl, start, line, column) {
+ validateBindingIdentifier(parser, context, 0, token, 1);
+ validateAndDeclareLabel(parser, labels, value);
+ nextToken(parser, context | 32768);
+ const body = allowFuncDecl &&
+ (context & 1024) < 1 &&
+ context & 256 &&
+ parser.token === 86106
+ ? parseFunctionDeclaration(parser, context, addChildScope(scope, 2), origin, 0, 0, 0, parser.tokenPos, parser.linePos, parser.colPos)
+ : parseStatement(parser, context, scope, origin, labels, allowFuncDecl, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, {
+ type: 'LabeledStatement',
+ label: expr,
+ body
+ });
+}
+function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, allowFuncDecl, start, line, column) {
+ const { token, tokenValue } = parser;
+ let expr = parseIdentifier(parser, context, 0);
+ if (parser.token === 21) {
+ return parseLabelledStatement(parser, context, scope, origin, labels, tokenValue, expr, token, 1, start, line, column);
+ }
+ const asyncNewLine = parser.flags & 1;
+ if (!asyncNewLine) {
+ if (parser.token === 86106) {
+ if (!allowFuncDecl)
+ report(parser, 119);
+ return parseFunctionDeclaration(parser, context, scope, origin, 1, 0, 1, start, line, column);
+ }
+ if ((parser.token & 143360) === 143360) {
+ expr = parseAsyncArrowAfterIdent(parser, context, 1, start, line, column);
+ if (parser.token === 18)
+ expr = parseSequenceExpression(parser, context, 0, start, line, column, expr);
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+ }
+ }
+ if (parser.token === 67174411) {
+ expr = parseAsyncArrowOrCallExpression(parser, context, expr, 1, 1, 0, asyncNewLine, start, line, column);
+ }
+ else {
+ if (parser.token === 10) {
+ classifyIdentifier(parser, context, token, 1);
+ expr = parseArrowFromIdentifier(parser, context, parser.tokenValue, expr, 0, 1, 0, start, line, column);
+ }
+ parser.assignable = 1;
+ }
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+ if (parser.token === 18)
+ expr = parseSequenceExpression(parser, context, 0, start, line, column, expr);
+ expr = parseAssignmentExpression(parser, context, 0, 0, start, line, column, expr);
+ parser.assignable = 1;
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+}
+function parseDirective(parser, context, expression, token, start, line, column) {
+ if (token !== 1074790417) {
+ parser.assignable = 2;
+ expression = parseMemberOrUpdateExpression(parser, context, expression, 0, 0, start, line, column);
+ if (parser.token !== 1074790417) {
+ expression = parseAssignmentExpression(parser, context, 0, 0, start, line, column, expression);
+ if (parser.token === 18) {
+ expression = parseSequenceExpression(parser, context, 0, start, line, column, expression);
+ }
+ }
+ matchOrInsertSemicolon(parser, context | 32768);
+ }
+ return context & 8 && expression.type === 'Literal' && typeof expression.value === 'string'
+ ? finishNode(parser, context, start, line, column, {
+ type: 'ExpressionStatement',
+ expression,
+ directive: expression.raw.slice(1, -1)
+ })
+ : finishNode(parser, context, start, line, column, {
+ type: 'ExpressionStatement',
+ expression
+ });
+}
+function parseEmptyStatement(parser, context, start, line, column) {
+ nextToken(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'EmptyStatement'
+ });
+}
+function parseThrowStatement(parser, context, start, line, column) {
+ nextToken(parser, context | 32768);
+ if (parser.flags & 1)
+ report(parser, 87);
+ const argument = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ThrowStatement',
+ argument
+ });
+}
+function parseIfStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context);
+ consume(parser, context | 32768, 67174411);
+ parser.assignable = 1;
+ const test = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.line, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const consequent = parseConsequentOrAlternative(parser, context, scope, labels, parser.tokenPos, parser.linePos, parser.colPos);
+ let alternate = null;
+ if (parser.token === 20565) {
+ nextToken(parser, context | 32768);
+ alternate = parseConsequentOrAlternative(parser, context, scope, labels, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'IfStatement',
+ test,
+ consequent,
+ alternate
+ });
+}
+function parseConsequentOrAlternative(parser, context, scope, labels, start, line, column) {
+ return context & 1024 ||
+ (context & 256) < 1 ||
+ parser.token !== 86106
+ ? parseStatement(parser, context, scope, 0, { $: labels }, 0, parser.tokenPos, parser.linePos, parser.colPos)
+ : parseFunctionDeclaration(parser, context, addChildScope(scope, 2), 0, 0, 0, 0, start, line, column);
+}
+function parseSwitchStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context);
+ consume(parser, context | 32768, 67174411);
+ const discriminant = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context, 16);
+ consume(parser, context, 2162700);
+ const cases = [];
+ let seenDefault = 0;
+ if (scope)
+ scope = addChildScope(scope, 8);
+ while (parser.token !== 1074790415) {
+ const { tokenPos, linePos, colPos } = parser;
+ let test = null;
+ const consequent = [];
+ if (consumeOpt(parser, context | 32768, 20558)) {
+ test = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ consume(parser, context | 32768, 20563);
+ if (seenDefault)
+ report(parser, 86);
+ seenDefault = 1;
+ }
+ consume(parser, context | 32768, 21);
+ while (parser.token !== 20558 &&
+ parser.token !== 1074790415 &&
+ parser.token !== 20563) {
+ consequent.push(parseStatementListItem(parser, context | 4096, scope, 2, {
+ $: labels
+ }));
+ }
+ cases.push(finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'SwitchCase',
+ test,
+ consequent
+ }));
+ }
+ consume(parser, context | 32768, 1074790415);
+ return finishNode(parser, context, start, line, column, {
+ type: 'SwitchStatement',
+ discriminant,
+ cases
+ });
+}
+function parseWhileStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context);
+ consume(parser, context | 32768, 67174411);
+ const test = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const body = parseIterationStatementBody(parser, context, scope, labels);
+ return finishNode(parser, context, start, line, column, {
+ type: 'WhileStatement',
+ test,
+ body
+ });
+}
+function parseIterationStatementBody(parser, context, scope, labels) {
+ return parseStatement(parser, ((context | 134217728) ^ 134217728) | 131072, scope, 0, { loop: 1, $: labels }, 0, parser.tokenPos, parser.linePos, parser.colPos);
+}
+function parseContinueStatement(parser, context, labels, start, line, column) {
+ if ((context & 131072) < 1)
+ report(parser, 65);
+ nextToken(parser, context);
+ let label = null;
+ if ((parser.flags & 1) < 1 && parser.token & 143360) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context | 32768, 0);
+ if (!isValidLabel(parser, labels, tokenValue, 1))
+ report(parser, 134, tokenValue);
+ }
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ContinueStatement',
+ label
+ });
+}
+function parseBreakStatement(parser, context, labels, start, line, column) {
+ nextToken(parser, context | 32768);
+ let label = null;
+ if ((parser.flags & 1) < 1 && parser.token & 143360) {
+ const { tokenValue } = parser;
+ label = parseIdentifier(parser, context | 32768, 0);
+ if (!isValidLabel(parser, labels, tokenValue, 0))
+ report(parser, 134, tokenValue);
+ }
+ else if ((context & (4096 | 131072)) < 1) {
+ report(parser, 66);
+ }
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'BreakStatement',
+ label
+ });
+}
+function parseWithStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context);
+ if (context & 1024)
+ report(parser, 88);
+ consume(parser, context | 32768, 67174411);
+ const object = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const body = parseStatement(parser, context, scope, 2, labels, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, {
+ type: 'WithStatement',
+ object,
+ body
+ });
+}
+function parseDebuggerStatement(parser, context, start, line, column) {
+ nextToken(parser, context | 32768);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'DebuggerStatement'
+ });
+}
+function parseTryStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context | 32768);
+ const firstScope = scope ? addChildScope(scope, 32) : void 0;
+ const block = parseBlock(parser, context, firstScope, { $: labels }, parser.tokenPos, parser.linePos, parser.colPos);
+ const { tokenPos, linePos, colPos } = parser;
+ const handler = consumeOpt(parser, context | 32768, 20559)
+ ? parseCatchBlock(parser, context, scope, labels, tokenPos, linePos, colPos)
+ : null;
+ let finalizer = null;
+ if (parser.token === 20568) {
+ nextToken(parser, context | 32768);
+ const finalizerScope = firstScope ? addChildScope(scope, 4) : void 0;
+ finalizer = parseBlock(parser, context, finalizerScope, { $: labels }, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ if (!handler && !finalizer) {
+ report(parser, 85);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'TryStatement',
+ block,
+ handler,
+ finalizer
+ });
+}
+function parseCatchBlock(parser, context, scope, labels, start, line, column) {
+ let param = null;
+ let additionalScope = scope;
+ if (consumeOpt(parser, context, 67174411)) {
+ if (scope)
+ scope = addChildScope(scope, 4);
+ param = parseBindingPattern(parser, context, scope, (parser.token & 2097152) === 2097152
+ ? 256
+ : 512, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ if (parser.token === 18) {
+ report(parser, 83);
+ }
+ else if (parser.token === 1077936157) {
+ report(parser, 84);
+ }
+ consume(parser, context | 32768, 16);
+ if (scope)
+ additionalScope = addChildScope(scope, 64);
+ }
+ const body = parseBlock(parser, context, additionalScope, { $: labels }, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, {
+ type: 'CatchClause',
+ param,
+ body
+ });
+}
+function parseDoWhileStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context | 32768);
+ const body = parseIterationStatementBody(parser, context, scope, labels);
+ consume(parser, context, 20580);
+ consume(parser, context | 32768, 67174411);
+ const test = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ consumeOpt(parser, context, 1074790417);
+ return finishNode(parser, context, start, line, column, {
+ type: 'DoWhileStatement',
+ body,
+ test
+ });
+}
+function parseLetIdentOrVarDeclarationStatement(parser, context, scope, origin, start, line, column) {
+ const { token, tokenValue } = parser;
+ let expr = parseIdentifier(parser, context, 0);
+ if (parser.token & (143360 | 2097152)) {
+ const declarations = parseVariableDeclarationList(parser, context, scope, 8, 0);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'VariableDeclaration',
+ kind: 'let',
+ declarations
+ });
+ }
+ parser.assignable = 1;
+ if (context & 1024)
+ report(parser, 82);
+ if (parser.token === 21) {
+ return parseLabelledStatement(parser, context, scope, origin, {}, tokenValue, expr, token, 0, start, line, column);
+ }
+ if (parser.token === 10) {
+ let scope = void 0;
+ if (context & 64)
+ scope = createArrowHeadParsingScope(parser, context, tokenValue);
+ parser.flags = (parser.flags | 128) ^ 128;
+ expr = parseArrowFunctionExpression(parser, context, scope, [expr], 0, start, line, column);
+ }
+ else {
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+ expr = parseAssignmentExpression(parser, context, 0, 0, start, line, column, expr);
+ }
+ if (parser.token === 18) {
+ expr = parseSequenceExpression(parser, context, 0, start, line, column, expr);
+ }
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+}
+function parseLexicalDeclaration(parser, context, scope, kind, origin, start, line, column) {
+ nextToken(parser, context);
+ const declarations = parseVariableDeclarationList(parser, context, scope, kind, origin);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'VariableDeclaration',
+ kind: kind & 8 ? 'let' : 'const',
+ declarations
+ });
+}
+function parseVariableStatement(parser, context, scope, origin, start, line, column) {
+ nextToken(parser, context);
+ const declarations = parseVariableDeclarationList(parser, context, scope, 4, origin);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'VariableDeclaration',
+ kind: 'var',
+ declarations
+ });
+}
+function parseVariableDeclarationList(parser, context, scope, kind, origin) {
+ let bindingCount = 1;
+ const list = [parseVariableDeclaration(parser, context, scope, kind, origin)];
+ while (consumeOpt(parser, context, 18)) {
+ bindingCount++;
+ list.push(parseVariableDeclaration(parser, context, scope, kind, origin));
+ }
+ if (bindingCount > 1 && origin & 32 && parser.token & 262144) {
+ report(parser, 58, KeywordDescTable[parser.token & 255]);
+ }
+ return list;
+}
+function parseVariableDeclaration(parser, context, scope, kind, origin) {
+ const { token, tokenPos, linePos, colPos } = parser;
+ let init = null;
+ const id = parseBindingPattern(parser, context, scope, kind, origin, tokenPos, linePos, colPos);
+ if (parser.token === 1077936157) {
+ nextToken(parser, context | 32768);
+ init = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ if (origin & 32 || (token & 2097152) < 1) {
+ if (parser.token === 274549 ||
+ (parser.token === 8738868 &&
+ (token & 2097152 || (kind & 4) < 1 || context & 1024))) {
+ reportMessageAt(tokenPos, parser.line, parser.index - 3, 57, parser.token === 274549 ? 'of' : 'in');
+ }
+ }
+ }
+ else if ((kind & 16 || (token & 2097152) > 0) &&
+ (parser.token & 262144) !== 262144) {
+ report(parser, 56, kind & 16 ? 'const' : 'destructuring');
+ }
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'VariableDeclarator',
+ id,
+ init
+ });
+}
+function parseForStatement(parser, context, scope, labels, start, line, column) {
+ nextToken(parser, context);
+ const forAwait = (context & 4194304) > 0 && consumeOpt(parser, context, 209008);
+ consume(parser, context | 32768, 67174411);
+ if (scope)
+ scope = addChildScope(scope, 1);
+ let test = null;
+ let update = null;
+ let destructible = 0;
+ let init = null;
+ let isVarDecl = parser.token === 86090 || parser.token === 241739 || parser.token === 86092;
+ let right;
+ const { token, tokenPos, linePos, colPos } = parser;
+ if (isVarDecl) {
+ if (token === 241739) {
+ init = parseIdentifier(parser, context, 0);
+ if (parser.token & (143360 | 2097152)) {
+ if (parser.token === 8738868) {
+ if (context & 1024)
+ report(parser, 64);
+ }
+ else {
+ init = finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'VariableDeclaration',
+ kind: 'let',
+ declarations: parseVariableDeclarationList(parser, context | 134217728, scope, 8, 32)
+ });
+ }
+ parser.assignable = 1;
+ }
+ else if (context & 1024) {
+ report(parser, 64);
+ }
+ else {
+ isVarDecl = false;
+ parser.assignable = 1;
+ init = parseMemberOrUpdateExpression(parser, context, init, 0, 0, tokenPos, linePos, colPos);
+ if (parser.token === 274549)
+ report(parser, 111);
+ }
+ }
+ else {
+ nextToken(parser, context);
+ init = finishNode(parser, context, tokenPos, linePos, colPos, token === 86090
+ ? {
+ type: 'VariableDeclaration',
+ kind: 'var',
+ declarations: parseVariableDeclarationList(parser, context | 134217728, scope, 4, 32)
+ }
+ : {
+ type: 'VariableDeclaration',
+ kind: 'const',
+ declarations: parseVariableDeclarationList(parser, context | 134217728, scope, 16, 32)
+ });
+ parser.assignable = 1;
+ }
+ }
+ else if (token === 1074790417) {
+ if (forAwait)
+ report(parser, 79);
+ }
+ else if ((token & 2097152) === 2097152) {
+ init =
+ token === 2162700
+ ? parseObjectLiteralOrPattern(parser, context, void 0, 1, 0, 0, 2, 32, tokenPos, linePos, colPos)
+ : parseArrayExpressionOrPattern(parser, context, void 0, 1, 0, 0, 2, 32, tokenPos, linePos, colPos);
+ destructible = parser.destructible;
+ if (context & 256 && destructible & 64) {
+ report(parser, 60);
+ }
+ parser.assignable =
+ destructible & 16 ? 2 : 1;
+ init = parseMemberOrUpdateExpression(parser, context | 134217728, init, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ init = parseLeftHandSideExpression(parser, context | 134217728, 1, 0, 1, tokenPos, linePos, colPos);
+ }
+ if ((parser.token & 262144) === 262144) {
+ if (parser.token === 274549) {
+ if (parser.assignable & 2)
+ report(parser, 77, forAwait ? 'await' : 'of');
+ reinterpretToPattern(parser, init);
+ nextToken(parser, context | 32768);
+ right = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const body = parseIterationStatementBody(parser, context, scope, labels);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ForOfStatement',
+ left: init,
+ right,
+ body,
+ await: forAwait
+ });
+ }
+ if (parser.assignable & 2)
+ report(parser, 77, 'in');
+ reinterpretToPattern(parser, init);
+ nextToken(parser, context | 32768);
+ if (forAwait)
+ report(parser, 79);
+ right = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const body = parseIterationStatementBody(parser, context, scope, labels);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ForInStatement',
+ body,
+ left: init,
+ right
+ });
+ }
+ if (forAwait)
+ report(parser, 79);
+ if (!isVarDecl) {
+ if (destructible & 8 && parser.token !== 1077936157) {
+ report(parser, 77, 'loop');
+ }
+ init = parseAssignmentExpression(parser, context | 134217728, 0, 0, tokenPos, linePos, colPos, init);
+ }
+ if (parser.token === 18)
+ init = parseSequenceExpression(parser, context, 0, parser.tokenPos, parser.linePos, parser.colPos, init);
+ consume(parser, context | 32768, 1074790417);
+ if (parser.token !== 1074790417)
+ test = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 1074790417);
+ if (parser.token !== 16)
+ update = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 16);
+ const body = parseIterationStatementBody(parser, context, scope, labels);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ForStatement',
+ init,
+ test,
+ update,
+ body
+ });
+}
+function parseRestrictedIdentifier(parser, context, scope) {
+ if (!isValidIdentifier(context, parser.token))
+ report(parser, 114);
+ if ((parser.token & 537079808) === 537079808)
+ report(parser, 115);
+ if (scope)
+ addBlockName(parser, context, scope, parser.tokenValue, 8, 0);
+ return parseIdentifier(parser, context, 0);
+}
+function parseImportDeclaration(parser, context, scope) {
+ const start = parser.tokenPos;
+ const line = parser.linePos;
+ const column = parser.colPos;
+ nextToken(parser, context);
+ let source = null;
+ const { tokenPos, linePos, colPos } = parser;
+ let specifiers = [];
+ if (parser.token === 134283267) {
+ source = parseLiteral(parser, context);
+ }
+ else {
+ if (parser.token & 143360) {
+ const local = parseRestrictedIdentifier(parser, context, scope);
+ specifiers = [
+ finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ImportDefaultSpecifier',
+ local
+ })
+ ];
+ if (consumeOpt(parser, context, 18)) {
+ switch (parser.token) {
+ case 8457014:
+ specifiers.push(parseImportNamespaceSpecifier(parser, context, scope));
+ break;
+ case 2162700:
+ parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
+ break;
+ default:
+ report(parser, 104);
+ }
+ }
+ }
+ else {
+ switch (parser.token) {
+ case 8457014:
+ specifiers = [parseImportNamespaceSpecifier(parser, context, scope)];
+ break;
+ case 2162700:
+ parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
+ break;
+ case 67174411:
+ return parseImportCallDeclaration(parser, context, start, line, column);
+ case 67108877:
+ return parseImportMetaDeclaration(parser, context, start, line, column);
+ default:
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ }
+ source = parseModuleSpecifier(parser, context);
+ }
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ImportDeclaration',
+ specifiers,
+ source
+ });
+}
+function parseImportNamespaceSpecifier(parser, context, scope) {
+ const { tokenPos, linePos, colPos } = parser;
+ nextToken(parser, context);
+ consume(parser, context, 77934);
+ if ((parser.token & 134217728) === 134217728) {
+ reportMessageAt(tokenPos, parser.line, parser.index, 28, KeywordDescTable[parser.token & 255]);
+ }
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ImportNamespaceSpecifier',
+ local: parseRestrictedIdentifier(parser, context, scope)
+ });
+}
+function parseModuleSpecifier(parser, context) {
+ consumeOpt(parser, context, 12404);
+ if (parser.token !== 134283267)
+ report(parser, 102, 'Import');
+ return parseLiteral(parser, context);
+}
+function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
+ nextToken(parser, context);
+ while (parser.token & 143360) {
+ let { token, tokenValue, tokenPos, linePos, colPos } = parser;
+ const imported = parseIdentifier(parser, context, 0);
+ let local;
+ if (consumeOpt(parser, context, 77934)) {
+ if ((parser.token & 134217728) === 134217728 || parser.token === 18) {
+ report(parser, 103);
+ }
+ else {
+ validateBindingIdentifier(parser, context, 16, parser.token, 0);
+ }
+ tokenValue = parser.tokenValue;
+ local = parseIdentifier(parser, context, 0);
+ }
+ else {
+ validateBindingIdentifier(parser, context, 16, token, 0);
+ local = imported;
+ }
+ if (scope)
+ addBlockName(parser, context, scope, tokenValue, 8, 0);
+ specifiers.push(finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ImportSpecifier',
+ local,
+ imported
+ }));
+ if (parser.token !== 1074790415)
+ consume(parser, context, 18);
+ }
+ consume(parser, context, 1074790415);
+ return specifiers;
+}
+function parseImportMetaDeclaration(parser, context, start, line, column) {
+ let expr = parseImportMetaExpression(parser, context, finishNode(parser, context, start, line, column, {
+ type: 'Identifier',
+ name: 'import'
+ }), start, line, column);
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+ expr = parseAssignmentExpression(parser, context, 0, 0, start, line, column, expr);
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+}
+function parseImportCallDeclaration(parser, context, start, line, column) {
+ let expr = parseImportExpression(parser, context, 0, start, line, column);
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, start, line, column);
+ return parseExpressionStatement(parser, context, expr, start, line, column);
+}
+function parseExportDeclaration(parser, context, scope) {
+ const start = parser.tokenPos;
+ const line = parser.linePos;
+ const column = parser.colPos;
+ nextToken(parser, context | 32768);
+ const specifiers = [];
+ let declaration = null;
+ let source = null;
+ let key;
+ if (consumeOpt(parser, context | 32768, 20563)) {
+ switch (parser.token) {
+ case 86106: {
+ declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 1, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ }
+ case 133:
+ case 86096:
+ declaration = parseClassDeclaration(parser, context, scope, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 209007:
+ const { tokenPos, linePos, colPos } = parser;
+ declaration = parseIdentifier(parser, context, 0);
+ const { flags } = parser;
+ if ((flags & 1) < 1) {
+ if (parser.token === 86106) {
+ declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 1, 1, tokenPos, linePos, colPos);
+ }
+ else {
+ if (parser.token === 67174411) {
+ declaration = parseAsyncArrowOrCallExpression(parser, context, declaration, 1, 1, 0, flags, tokenPos, linePos, colPos);
+ declaration = parseMemberOrUpdateExpression(parser, context, declaration, 0, 0, tokenPos, linePos, colPos);
+ declaration = parseAssignmentExpression(parser, context, 0, 0, tokenPos, linePos, colPos, declaration);
+ }
+ else if (parser.token & 143360) {
+ if (scope)
+ scope = createArrowHeadParsingScope(parser, context, parser.tokenValue);
+ declaration = parseIdentifier(parser, context, 0);
+ declaration = parseArrowFunctionExpression(parser, context, scope, [declaration], 1, tokenPos, linePos, colPos);
+ }
+ }
+ }
+ break;
+ default:
+ declaration = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ matchOrInsertSemicolon(parser, context | 32768);
+ }
+ if (scope)
+ declareUnboundVariable(parser, 'default');
+ return finishNode(parser, context, start, line, column, {
+ type: 'ExportDefaultDeclaration',
+ declaration
+ });
+ }
+ switch (parser.token) {
+ case 8457014: {
+ nextToken(parser, context);
+ let exported = null;
+ const isNamedDeclaration = consumeOpt(parser, context, 77934);
+ if (isNamedDeclaration) {
+ if (scope)
+ declareUnboundVariable(parser, parser.tokenValue);
+ exported = parseIdentifier(parser, context, 0);
+ }
+ consume(parser, context, 12404);
+ if (parser.token !== 134283267)
+ report(parser, 102, 'Export');
+ source = parseLiteral(parser, context);
+ matchOrInsertSemicolon(parser, context | 32768);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ExportAllDeclaration',
+ source,
+ exported
+ });
+ }
+ case 2162700: {
+ nextToken(parser, context);
+ const tmpExportedNames = [];
+ const tmpExportedBindings = [];
+ while (parser.token & 143360) {
+ const { tokenPos, tokenValue, linePos, colPos } = parser;
+ const local = parseIdentifier(parser, context, 0);
+ let exported;
+ if (parser.token === 77934) {
+ nextToken(parser, context);
+ if ((parser.token & 134217728) === 134217728) {
+ report(parser, 103);
+ }
+ if (scope) {
+ tmpExportedNames.push(parser.tokenValue);
+ tmpExportedBindings.push(tokenValue);
+ }
+ exported = parseIdentifier(parser, context, 0);
+ }
+ else {
+ if (scope) {
+ tmpExportedNames.push(parser.tokenValue);
+ tmpExportedBindings.push(parser.tokenValue);
+ }
+ exported = local;
+ }
+ specifiers.push(finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ExportSpecifier',
+ local,
+ exported
+ }));
+ if (parser.token !== 1074790415)
+ consume(parser, context, 18);
+ }
+ consume(parser, context, 1074790415);
+ if (consumeOpt(parser, context, 12404)) {
+ if (parser.token !== 134283267)
+ report(parser, 102, 'Export');
+ source = parseLiteral(parser, context);
+ }
+ else if (scope) {
+ let i = 0;
+ let iMax = tmpExportedNames.length;
+ for (; i < iMax; i++) {
+ declareUnboundVariable(parser, tmpExportedNames[i]);
+ }
+ i = 0;
+ iMax = tmpExportedBindings.length;
+ for (; i < iMax; i++) {
+ addBindingToExports(parser, tmpExportedBindings[i]);
+ }
+ }
+ matchOrInsertSemicolon(parser, context | 32768);
+ break;
+ }
+ case 86096:
+ declaration = parseClassDeclaration(parser, context, scope, 2, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 86106:
+ declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 2, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 241739:
+ declaration = parseLexicalDeclaration(parser, context, scope, 8, 64, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 86092:
+ declaration = parseLexicalDeclaration(parser, context, scope, 16, 64, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 86090:
+ declaration = parseVariableStatement(parser, context, scope, 64, parser.tokenPos, parser.linePos, parser.colPos);
+ break;
+ case 209007:
+ const { tokenPos, linePos, colPos } = parser;
+ nextToken(parser, context);
+ if ((parser.flags & 1) < 1 && parser.token === 86106) {
+ declaration = parseFunctionDeclaration(parser, context, scope, 4, 1, 2, 1, tokenPos, linePos, colPos);
+ if (scope) {
+ key = declaration.id ? declaration.id.name : '';
+ declareUnboundVariable(parser, key);
+ }
+ break;
+ }
+ default:
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'ExportNamedDeclaration',
+ declaration,
+ specifiers,
+ source
+ });
+}
+function parseExpression(parser, context, canAssign, isPattern, inGroup, start, line, column) {
+ let expr = parsePrimaryExpression(parser, context, 2, 0, canAssign, isPattern, inGroup, 1, start, line, column);
+ expr = parseMemberOrUpdateExpression(parser, context, expr, inGroup, 0, start, line, column);
+ return parseAssignmentExpression(parser, context, inGroup, 0, start, line, column, expr);
+}
+function parseSequenceExpression(parser, context, inGroup, start, line, column, expr) {
+ const expressions = [expr];
+ while (consumeOpt(parser, context | 32768, 18)) {
+ expressions.push(parseExpression(parser, context, 1, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'SequenceExpression',
+ expressions
+ });
+}
+function parseExpressions(parser, context, inGroup, canAssign, start, line, column) {
+ const expr = parseExpression(parser, context, canAssign, 0, inGroup, start, line, column);
+ return parser.token === 18
+ ? parseSequenceExpression(parser, context, inGroup, start, line, column, expr)
+ : expr;
+}
+function parseAssignmentExpression(parser, context, inGroup, isPattern, start, line, column, left) {
+ const { token } = parser;
+ if ((token & 4194304) === 4194304) {
+ if (parser.assignable & 2)
+ report(parser, 24);
+ if ((!isPattern && token === 1077936157 && left.type === 'ArrayExpression') ||
+ left.type === 'ObjectExpression') {
+ reinterpretToPattern(parser, left);
+ }
+ nextToken(parser, context | 32768);
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, isPattern
+ ? {
+ type: 'AssignmentPattern',
+ left,
+ right
+ }
+ : {
+ type: 'AssignmentExpression',
+ left,
+ operator: KeywordDescTable[token & 255],
+ right
+ });
+ }
+ if ((token & 8454144) === 8454144) {
+ left = parseBinaryExpression(parser, context, inGroup, start, line, column, 4, token, left);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ left = parseConditionalExpression(parser, context, left, start, line, column);
+ }
+ return left;
+}
+function parseAssignmentExpressionOrPattern(parser, context, inGroup, isPattern, start, line, column, left) {
+ const { token } = parser;
+ nextToken(parser, context | 32768);
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ left = finishNode(parser, context, start, line, column, isPattern
+ ? {
+ type: 'AssignmentPattern',
+ left,
+ right
+ }
+ : {
+ type: 'AssignmentExpression',
+ left,
+ operator: KeywordDescTable[token & 255],
+ right
+ });
+ parser.assignable = 2;
+ return left;
+}
+function parseConditionalExpression(parser, context, test, start, line, column) {
+ const consequent = parseExpression(parser, (context | 134217728) ^ 134217728, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context | 32768, 21);
+ parser.assignable = 1;
+ const alternate = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'ConditionalExpression',
+ test,
+ consequent,
+ alternate
+ });
+}
+function parseBinaryExpression(parser, context, inGroup, start, line, column, minPrec, operator, left) {
+ const bit = -((context & 134217728) > 0) & 8738868;
+ let t;
+ let prec;
+ parser.assignable = 2;
+ while (parser.token & 8454144) {
+ t = parser.token;
+ prec = t & 3840;
+ if ((t & 524288 && operator & 268435456) || (operator & 524288 && t & 268435456)) {
+ report(parser, 159);
+ }
+ if (prec + ((t === 8457273) << 8) - ((bit === t) << 12) <= minPrec)
+ break;
+ nextToken(parser, context | 32768);
+ left = finishNode(parser, context, start, line, column, {
+ type: t & 524288 || t & 268435456 ? 'LogicalExpression' : 'BinaryExpression',
+ left,
+ right: parseBinaryExpression(parser, context, inGroup, parser.tokenPos, parser.linePos, parser.colPos, prec, t, parseLeftHandSideExpression(parser, context, 0, inGroup, 1, parser.tokenPos, parser.linePos, parser.colPos)),
+ operator: KeywordDescTable[t & 255]
+ });
+ }
+ if (parser.token === 1077936157)
+ report(parser, 24);
+ return left;
+}
+function parseUnaryExpression(parser, context, isLHS, start, line, column, inGroup) {
+ if (!isLHS)
+ report(parser, 0);
+ const unaryOperator = parser.token;
+ nextToken(parser, context | 32768);
+ const arg = parseLeftHandSideExpression(parser, context, 0, inGroup, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ if (parser.token === 8457273)
+ report(parser, 31);
+ if (context & 1024 && unaryOperator === 16863278) {
+ if (arg.type === 'Identifier') {
+ report(parser, 117);
+ }
+ else if (isPropertyWithPrivateFieldKey(arg)) {
+ report(parser, 123);
+ }
+ }
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'UnaryExpression',
+ operator: KeywordDescTable[unaryOperator & 255],
+ argument: arg,
+ prefix: true
+ });
+}
+function parseAsyncExpression(parser, context, inGroup, isLHS, canAssign, isPattern, inNew, start, line, column) {
+ const { token } = parser;
+ const expr = parseIdentifier(parser, context, isPattern);
+ const { flags } = parser;
+ if ((flags & 1) < 1) {
+ if (parser.token === 86106) {
+ return parseFunctionExpression(parser, context, 1, inGroup, start, line, column);
+ }
+ if ((parser.token & 143360) === 143360) {
+ if (!isLHS)
+ report(parser, 0);
+ return parseAsyncArrowAfterIdent(parser, context, canAssign, start, line, column);
+ }
+ }
+ if (!inNew && parser.token === 67174411) {
+ return parseAsyncArrowOrCallExpression(parser, context, expr, canAssign, 1, 0, flags, start, line, column);
+ }
+ if (parser.token === 10) {
+ classifyIdentifier(parser, context, token, 1);
+ if (inNew)
+ report(parser, 48);
+ return parseArrowFromIdentifier(parser, context, parser.tokenValue, expr, inNew, canAssign, 0, start, line, column);
+ }
+ return expr;
+}
+function parseYieldExpression(parser, context, inGroup, canAssign, start, line, column) {
+ if (inGroup)
+ parser.destructible |= 256;
+ if (context & 2097152) {
+ nextToken(parser, context | 32768);
+ if (context & 8388608)
+ report(parser, 30);
+ if (!canAssign)
+ report(parser, 24);
+ if (parser.token === 22)
+ report(parser, 120);
+ let argument = null;
+ let delegate = false;
+ if ((parser.flags & 1) < 1) {
+ delegate = consumeOpt(parser, context | 32768, 8457014);
+ if (parser.token & (12288 | 65536) || delegate) {
+ argument = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ }
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'YieldExpression',
+ argument,
+ delegate
+ });
+ }
+ if (context & 1024)
+ report(parser, 94, 'yield');
+ return parseIdentifierOrArrow(parser, context, start, line, column);
+}
+function parseAwaitExpression(parser, context, inNew, inGroup, start, line, column) {
+ if (inGroup)
+ parser.destructible |= 128;
+ if (context & 4194304 || (context & 2048 && context & 8192)) {
+ if (inNew)
+ report(parser, 0);
+ if (context & 8388608) {
+ reportMessageAt(parser.index, parser.line, parser.index, 29);
+ }
+ nextToken(parser, context | 32768);
+ const argument = parseLeftHandSideExpression(parser, context, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ if (parser.token === 8457273)
+ report(parser, 31);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'AwaitExpression',
+ argument
+ });
+ }
+ if (context & 2048)
+ report(parser, 95);
+ return parseIdentifierOrArrow(parser, context, start, line, column);
+}
+function parseFunctionBody(parser, context, scope, origin, firstRestricted, scopeError) {
+ const { tokenPos, linePos, colPos } = parser;
+ consume(parser, context | 32768, 2162700);
+ const body = [];
+ const prevContext = context;
+ if (parser.token !== 1074790415) {
+ while (parser.token === 134283267) {
+ const { index, tokenPos, tokenValue, token } = parser;
+ const expr = parseLiteral(parser, context);
+ if (isValidStrictMode(parser, index, tokenPos, tokenValue)) {
+ context |= 1024;
+ if (parser.flags & 128) {
+ reportMessageAt(parser.index, parser.line, parser.tokenPos, 63);
+ }
+ if (parser.flags & 64) {
+ reportMessageAt(parser.index, parser.line, parser.tokenPos, 8);
+ }
+ }
+ body.push(parseDirective(parser, context, expr, token, tokenPos, parser.linePos, parser.colPos));
+ }
+ if (context & 1024) {
+ if (firstRestricted) {
+ if ((firstRestricted & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ if ((firstRestricted & 36864) === 36864) {
+ report(parser, 38);
+ }
+ }
+ if (parser.flags & 512)
+ report(parser, 115);
+ if (parser.flags & 256)
+ report(parser, 114);
+ }
+ if (context & 64 &&
+ scope &&
+ scopeError !== void 0 &&
+ (prevContext & 1024) < 1 &&
+ (context & 8192) < 1) {
+ reportScopeError(scopeError);
+ }
+ }
+ parser.flags =
+ (parser.flags | 512 | 256 | 64) ^
+ (512 | 256 | 64);
+ parser.destructible = (parser.destructible | 256) ^ 256;
+ while (parser.token !== 1074790415) {
+ body.push(parseStatementListItem(parser, context, scope, 4, {}));
+ }
+ consume(parser, origin & (16 | 8) ? context | 32768 : context, 1074790415);
+ parser.flags &= ~(128 | 64);
+ if (parser.token === 1077936157)
+ report(parser, 24);
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'BlockStatement',
+ body
+ });
+}
+function parseSuperExpression(parser, context, start, line, column) {
+ nextToken(parser, context);
+ switch (parser.token) {
+ case 67108991:
+ report(parser, 161);
+ case 67174411: {
+ if ((context & 524288) < 1)
+ report(parser, 26);
+ if (context & 16384)
+ report(parser, 143);
+ parser.assignable = 2;
+ break;
+ }
+ case 69271571:
+ case 67108877: {
+ if ((context & 262144) < 1)
+ report(parser, 27);
+ if (context & 16384)
+ report(parser, 143);
+ parser.assignable = 1;
+ break;
+ }
+ default:
+ report(parser, 28, 'super');
+ }
+ return finishNode(parser, context, start, line, column, { type: 'Super' });
+}
+function parseLeftHandSideExpression(parser, context, canAssign, inGroup, isLHS, start, line, column) {
+ const expression = parsePrimaryExpression(parser, context, 2, 0, canAssign, 0, inGroup, isLHS, start, line, column);
+ return parseMemberOrUpdateExpression(parser, context, expression, inGroup, 0, start, line, column);
+}
+function parseUpdateExpression(parser, context, expr, start, line, column) {
+ if (parser.assignable & 2)
+ report(parser, 52);
+ const { token } = parser;
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'UpdateExpression',
+ argument: expr,
+ operator: KeywordDescTable[token & 255],
+ prefix: false
+ });
+}
+function parseMemberOrUpdateExpression(parser, context, expr, inGroup, inChain, start, line, column) {
+ if ((parser.token & 33619968) === 33619968 && (parser.flags & 1) < 1) {
+ expr = parseUpdateExpression(parser, context, expr, start, line, column);
+ }
+ else if ((parser.token & 67108864) === 67108864) {
+ context = (context | 134217728 | 8192) ^ (134217728 | 8192);
+ switch (parser.token) {
+ case 67108877: {
+ nextToken(parser, context | 1073741824);
+ parser.assignable = 1;
+ const property = parsePropertyOrPrivatePropertyName(parser, context);
+ expr = finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ property
+ });
+ break;
+ }
+ case 69271571: {
+ let restoreHasOptionalChaining = false;
+ if ((parser.flags & 2048) === 2048) {
+ restoreHasOptionalChaining = true;
+ parser.flags = (parser.flags | 2048) ^ 2048;
+ }
+ nextToken(parser, context | 32768);
+ const { tokenPos, linePos, colPos } = parser;
+ const property = parseExpressions(parser, context, inGroup, 1, tokenPos, linePos, colPos);
+ consume(parser, context, 20);
+ parser.assignable = 1;
+ expr = finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ property
+ });
+ if (restoreHasOptionalChaining) {
+ parser.flags |= 2048;
+ }
+ break;
+ }
+ case 67174411: {
+ if ((parser.flags & 1024) === 1024) {
+ parser.flags = (parser.flags | 1024) ^ 1024;
+ return expr;
+ }
+ let restoreHasOptionalChaining = false;
+ if ((parser.flags & 2048) === 2048) {
+ restoreHasOptionalChaining = true;
+ parser.flags = (parser.flags | 2048) ^ 2048;
+ }
+ const args = parseArguments(parser, context, inGroup);
+ parser.assignable = 2;
+ expr = finishNode(parser, context, start, line, column, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args
+ });
+ if (restoreHasOptionalChaining) {
+ parser.flags |= 2048;
+ }
+ break;
+ }
+ case 67108991: {
+ nextToken(parser, context);
+ parser.flags |= 2048;
+ parser.assignable = 2;
+ expr = parseOptionalChain(parser, context, expr, start, line, column);
+ break;
+ }
+ default:
+ if ((parser.flags & 2048) === 2048) {
+ report(parser, 160);
+ }
+ parser.assignable = 2;
+ expr = finishNode(parser, context, start, line, column, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parser.token === 67174408
+ ? parseTemplate(parser, context | 65536)
+ : parseTemplateLiteral(parser, context, parser.tokenPos, parser.linePos, parser.colPos)
+ });
+ }
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 1, start, line, column);
+ }
+ if (inChain === 0 && (parser.flags & 2048) === 2048) {
+ parser.flags = (parser.flags | 2048) ^ 2048;
+ expr = finishNode(parser, context, start, line, column, {
+ type: 'ChainExpression',
+ expression: expr
+ });
+ }
+ return expr;
+}
+function parseOptionalChain(parser, context, expr, start, line, column) {
+ let restoreHasOptionalChaining = false;
+ let node;
+ if (parser.token === 69271571 || parser.token === 67174411) {
+ if ((parser.flags & 2048) === 2048) {
+ restoreHasOptionalChaining = true;
+ parser.flags = (parser.flags | 2048) ^ 2048;
+ }
+ }
+ if (parser.token === 69271571) {
+ nextToken(parser, context | 32768);
+ const { tokenPos, linePos, colPos } = parser;
+ const property = parseExpressions(parser, context, 0, 1, tokenPos, linePos, colPos);
+ consume(parser, context, 20);
+ parser.assignable = 2;
+ node = finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ optional: true,
+ property
+ });
+ }
+ else if (parser.token === 67174411) {
+ const args = parseArguments(parser, context, 0);
+ parser.assignable = 2;
+ node = finishNode(parser, context, start, line, column, {
+ type: 'CallExpression',
+ callee: expr,
+ arguments: args,
+ optional: true
+ });
+ }
+ else {
+ if ((parser.token & (143360 | 4096)) < 1)
+ report(parser, 154);
+ const property = parseIdentifier(parser, context, 0);
+ parser.assignable = 2;
+ node = finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ optional: true,
+ property
+ });
+ }
+ if (restoreHasOptionalChaining) {
+ parser.flags |= 2048;
+ }
+ return node;
+}
+function parsePropertyOrPrivatePropertyName(parser, context) {
+ if ((parser.token & (143360 | 4096)) < 1 && parser.token !== 131) {
+ report(parser, 154);
+ }
+ return context & 1 && parser.token === 131
+ ? parsePrivateIdentifier(parser, context, parser.tokenPos, parser.linePos, parser.colPos)
+ : parseIdentifier(parser, context, 0);
+}
+function parseUpdateExpressionPrefixed(parser, context, inNew, isLHS, start, line, column) {
+ if (inNew)
+ report(parser, 53);
+ if (!isLHS)
+ report(parser, 0);
+ const { token } = parser;
+ nextToken(parser, context | 32768);
+ const arg = parseLeftHandSideExpression(parser, context, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ if (parser.assignable & 2) {
+ report(parser, 52);
+ }
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'UpdateExpression',
+ argument: arg,
+ operator: KeywordDescTable[token & 255],
+ prefix: true
+ });
+}
+function parsePrimaryExpression(parser, context, kind, inNew, canAssign, isPattern, inGroup, isLHS, start, line, column) {
+ if ((parser.token & 143360) === 143360) {
+ switch (parser.token) {
+ case 209008:
+ return parseAwaitExpression(parser, context, inNew, inGroup, start, line, column);
+ case 241773:
+ return parseYieldExpression(parser, context, inGroup, canAssign, start, line, column);
+ case 209007:
+ return parseAsyncExpression(parser, context, inGroup, isLHS, canAssign, isPattern, inNew, start, line, column);
+ }
+ const { token, tokenValue } = parser;
+ const expr = parseIdentifier(parser, context | 65536, isPattern);
+ if (parser.token === 10) {
+ if (!isLHS)
+ report(parser, 0);
+ classifyIdentifier(parser, context, token, 1);
+ return parseArrowFromIdentifier(parser, context, tokenValue, expr, inNew, canAssign, 0, start, line, column);
+ }
+ if (context & 16384 && token === 537079928)
+ report(parser, 126);
+ if (token === 241739) {
+ if (context & 1024)
+ report(parser, 109);
+ if (kind & (8 | 16))
+ report(parser, 97);
+ }
+ parser.assignable =
+ context & 1024 && (token & 537079808) === 537079808
+ ? 2
+ : 1;
+ return expr;
+ }
+ if ((parser.token & 134217728) === 134217728) {
+ return parseLiteral(parser, context);
+ }
+ switch (parser.token) {
+ case 33619995:
+ case 33619996:
+ return parseUpdateExpressionPrefixed(parser, context, inNew, isLHS, start, line, column);
+ case 16863278:
+ case 16842800:
+ case 16842801:
+ case 25233970:
+ case 25233971:
+ case 16863277:
+ case 16863279:
+ return parseUnaryExpression(parser, context, isLHS, start, line, column, inGroup);
+ case 86106:
+ return parseFunctionExpression(parser, context, 0, inGroup, start, line, column);
+ case 2162700:
+ return parseObjectLiteral(parser, context, canAssign ? 0 : 1, inGroup, start, line, column);
+ case 69271571:
+ return parseArrayLiteral(parser, context, canAssign ? 0 : 1, inGroup, start, line, column);
+ case 67174411:
+ return parseParenthesizedExpression(parser, context, canAssign, 1, 0, start, line, column);
+ case 86021:
+ case 86022:
+ case 86023:
+ return parseNullOrTrueOrFalseLiteral(parser, context, start, line, column);
+ case 86113:
+ return parseThisExpression(parser, context);
+ case 65540:
+ return parseRegExpLiteral(parser, context, start, line, column);
+ case 133:
+ case 86096:
+ return parseClassExpression(parser, context, inGroup, start, line, column);
+ case 86111:
+ return parseSuperExpression(parser, context, start, line, column);
+ case 67174409:
+ return parseTemplateLiteral(parser, context, start, line, column);
+ case 67174408:
+ return parseTemplate(parser, context);
+ case 86109:
+ return parseNewExpression(parser, context, inGroup, start, line, column);
+ case 134283389:
+ return parseBigIntLiteral(parser, context, start, line, column);
+ case 131:
+ return parsePrivateIdentifier(parser, context, start, line, column);
+ case 86108:
+ return parseImportCallOrMetaExpression(parser, context, inNew, inGroup, start, line, column);
+ case 8456258:
+ if (context & 16)
+ return parseJSXRootElementOrFragment(parser, context, 1, start, line, column);
+ default:
+ if (isValidIdentifier(context, parser.token))
+ return parseIdentifierOrArrow(parser, context, start, line, column);
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+}
+function parseImportCallOrMetaExpression(parser, context, inNew, inGroup, start, line, column) {
+ let expr = parseIdentifier(parser, context, 0);
+ if (parser.token === 67108877) {
+ return parseImportMetaExpression(parser, context, expr, start, line, column);
+ }
+ if (inNew)
+ report(parser, 137);
+ expr = parseImportExpression(parser, context, inGroup, start, line, column);
+ parser.assignable = 2;
+ return parseMemberOrUpdateExpression(parser, context, expr, inGroup, 0, start, line, column);
+}
+function parseImportMetaExpression(parser, context, meta, start, line, column) {
+ if ((context & 2048) === 0)
+ report(parser, 163);
+ nextToken(parser, context);
+ if (parser.token !== 143495 && parser.tokenValue !== 'meta')
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'MetaProperty',
+ meta,
+ property: parseIdentifier(parser, context, 0)
+ });
+}
+function parseImportExpression(parser, context, inGroup, start, line, column) {
+ consume(parser, context | 32768, 67174411);
+ if (parser.token === 14)
+ report(parser, 138);
+ const source = parseExpression(parser, context, 1, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context, 16);
+ return finishNode(parser, context, start, line, column, {
+ type: 'ImportExpression',
+ source
+ });
+}
+function parseBigIntLiteral(parser, context, start, line, column) {
+ const { tokenRaw, tokenValue } = parser;
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, context & 512
+ ? {
+ type: 'Literal',
+ value: tokenValue,
+ bigint: tokenRaw.slice(0, -1),
+ raw: tokenRaw
+ }
+ : {
+ type: 'Literal',
+ value: tokenValue,
+ bigint: tokenRaw.slice(0, -1)
+ });
+}
+function parseTemplateLiteral(parser, context, start, line, column) {
+ parser.assignable = 2;
+ const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
+ consume(parser, context, 67174409);
+ const quasis = [parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenPos, linePos, colPos, true)];
+ return finishNode(parser, context, start, line, column, {
+ type: 'TemplateLiteral',
+ expressions: [],
+ quasis
+ });
+}
+function parseTemplate(parser, context) {
+ context = (context | 134217728) ^ 134217728;
+ const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
+ consume(parser, context | 32768, 67174408);
+ const quasis = [
+ parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenPos, linePos, colPos, false)
+ ];
+ const expressions = [parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos)];
+ if (parser.token !== 1074790415)
+ report(parser, 80);
+ while ((parser.token = scanTemplateTail(parser, context)) !== 67174409) {
+ const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
+ consume(parser, context | 32768, 67174408);
+ quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenPos, linePos, colPos, false));
+ expressions.push(parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos));
+ if (parser.token !== 1074790415)
+ report(parser, 80);
+ }
+ {
+ const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
+ consume(parser, context, 67174409);
+ quasis.push(parseTemplateElement(parser, context, tokenValue, tokenRaw, tokenPos, linePos, colPos, true));
+ }
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'TemplateLiteral',
+ expressions,
+ quasis
+ });
+}
+function parseTemplateElement(parser, context, cooked, raw, start, line, col, tail) {
+ const node = finishNode(parser, context, start, line, col, {
+ type: 'TemplateElement',
+ value: {
+ cooked,
+ raw
+ },
+ tail
+ });
+ const tailSize = tail ? 1 : 2;
+ if (context & 2) {
+ node.start += 1;
+ node.range[0] += 1;
+ node.end -= tailSize;
+ node.range[1] -= tailSize;
+ }
+ if (context & 4) {
+ node.loc.start.column += 1;
+ node.loc.end.column -= tailSize;
+ }
+ return node;
+}
+function parseSpreadElement(parser, context, start, line, column) {
+ context = (context | 134217728) ^ 134217728;
+ consume(parser, context | 32768, 14);
+ const argument = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ parser.assignable = 1;
+ return finishNode(parser, context, start, line, column, {
+ type: 'SpreadElement',
+ argument
+ });
+}
+function parseArguments(parser, context, inGroup) {
+ nextToken(parser, context | 32768);
+ const args = [];
+ if (parser.token === 16) {
+ nextToken(parser, context);
+ return args;
+ }
+ while (parser.token !== 16) {
+ if (parser.token === 14) {
+ args.push(parseSpreadElement(parser, context, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ else {
+ args.push(parseExpression(parser, context, 1, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ if (parser.token !== 18)
+ break;
+ nextToken(parser, context | 32768);
+ if (parser.token === 16)
+ break;
+ }
+ consume(parser, context, 16);
+ return args;
+}
+function parseIdentifier(parser, context, isPattern) {
+ const { tokenValue, tokenPos, linePos, colPos } = parser;
+ nextToken(parser, context);
+ return finishNode(parser, context, tokenPos, linePos, colPos, context & 268435456
+ ? {
+ type: 'Identifier',
+ name: tokenValue,
+ pattern: isPattern === 1
+ }
+ : {
+ type: 'Identifier',
+ name: tokenValue
+ });
+}
+function parseLiteral(parser, context) {
+ const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
+ if (parser.token === 134283389) {
+ return parseBigIntLiteral(parser, context, tokenPos, linePos, colPos);
+ }
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return finishNode(parser, context, tokenPos, linePos, colPos, context & 512
+ ? {
+ type: 'Literal',
+ value: tokenValue,
+ raw: tokenRaw
+ }
+ : {
+ type: 'Literal',
+ value: tokenValue
+ });
+}
+function parseNullOrTrueOrFalseLiteral(parser, context, start, line, column) {
+ const raw = KeywordDescTable[parser.token & 255];
+ const value = parser.token === 86023 ? null : raw === 'true';
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, context & 512
+ ? {
+ type: 'Literal',
+ value,
+ raw
+ }
+ : {
+ type: 'Literal',
+ value
+ });
+}
+function parseThisExpression(parser, context) {
+ const { tokenPos, linePos, colPos } = parser;
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ThisExpression'
+ });
+}
+function parseFunctionDeclaration(parser, context, scope, origin, allowGen, flags, isAsync, start, line, column) {
+ nextToken(parser, context | 32768);
+ const isGenerator = allowGen ? optionalBit(parser, context, 8457014) : 0;
+ let id = null;
+ let firstRestricted;
+ let functionScope = scope ? createScope() : void 0;
+ if (parser.token === 67174411) {
+ if ((flags & 1) < 1)
+ report(parser, 37, 'Function');
+ }
+ else {
+ const kind = origin & 4 && ((context & 8192) < 1 || (context & 2048) < 1)
+ ? 4
+ : 64;
+ validateFunctionName(parser, context | ((context & 3072) << 11), parser.token);
+ if (scope) {
+ if (kind & 4) {
+ addVarName(parser, context, scope, parser.tokenValue, kind);
+ }
+ else {
+ addBlockName(parser, context, scope, parser.tokenValue, kind, origin);
+ }
+ functionScope = addChildScope(functionScope, 256);
+ if (flags) {
+ if (flags & 2) {
+ declareUnboundVariable(parser, parser.tokenValue);
+ }
+ }
+ }
+ firstRestricted = parser.token;
+ if (parser.token & 143360) {
+ id = parseIdentifier(parser, context, 0);
+ }
+ else {
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ }
+ context =
+ ((context | 32243712) ^ 32243712) |
+ 67108864 |
+ ((isAsync * 2 + isGenerator) << 21) |
+ (isGenerator ? 0 : 1073741824);
+ if (scope)
+ functionScope = addChildScope(functionScope, 512);
+ const params = parseFormalParametersOrFormalList(parser, context | 8388608, functionScope, 0, 1);
+ const body = parseFunctionBody(parser, (context | 8192 | 4096 | 131072) ^
+ (8192 | 4096 | 131072), scope ? addChildScope(functionScope, 128) : functionScope, 8, firstRestricted, scope ? functionScope.scopeError : void 0);
+ return finishNode(parser, context, start, line, column, {
+ type: 'FunctionDeclaration',
+ id,
+ params,
+ body,
+ async: isAsync === 1,
+ generator: isGenerator === 1
+ });
+}
+function parseFunctionExpression(parser, context, isAsync, inGroup, start, line, column) {
+ nextToken(parser, context | 32768);
+ const isGenerator = optionalBit(parser, context, 8457014);
+ const generatorAndAsyncFlags = (isAsync * 2 + isGenerator) << 21;
+ let id = null;
+ let firstRestricted;
+ let scope = context & 64 ? createScope() : void 0;
+ if ((parser.token & (143360 | 4096 | 36864)) > 0) {
+ validateFunctionName(parser, ((context | 0x1ec0000) ^ 0x1ec0000) | generatorAndAsyncFlags, parser.token);
+ if (scope)
+ scope = addChildScope(scope, 256);
+ firstRestricted = parser.token;
+ id = parseIdentifier(parser, context, 0);
+ }
+ context =
+ ((context | 32243712) ^ 32243712) |
+ 67108864 |
+ generatorAndAsyncFlags |
+ (isGenerator ? 0 : 1073741824);
+ if (scope)
+ scope = addChildScope(scope, 512);
+ const params = parseFormalParametersOrFormalList(parser, context | 8388608, scope, inGroup, 1);
+ const body = parseFunctionBody(parser, context & ~(0x8001000 | 8192 | 4096 | 131072 | 16384), scope ? addChildScope(scope, 128) : scope, 0, firstRestricted, void 0);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'FunctionExpression',
+ id,
+ params,
+ body,
+ async: isAsync === 1,
+ generator: isGenerator === 1
+ });
+}
+function parseArrayLiteral(parser, context, skipInitializer, inGroup, start, line, column) {
+ const expr = parseArrayExpressionOrPattern(parser, context, void 0, skipInitializer, inGroup, 0, 2, 0, start, line, column);
+ if (context & 256 && parser.destructible & 64) {
+ report(parser, 60);
+ }
+ if (parser.destructible & 8) {
+ report(parser, 59);
+ }
+ return expr;
+}
+function parseArrayExpressionOrPattern(parser, context, scope, skipInitializer, inGroup, isPattern, kind, origin, start, line, column) {
+ nextToken(parser, context | 32768);
+ const elements = [];
+ let destructible = 0;
+ context = (context | 134217728) ^ 134217728;
+ while (parser.token !== 20) {
+ if (consumeOpt(parser, context | 32768, 18)) {
+ elements.push(null);
+ }
+ else {
+ let left;
+ const { token, tokenPos, linePos, colPos, tokenValue } = parser;
+ if (token & 143360) {
+ left = parsePrimaryExpression(parser, context, kind, 0, 1, 0, inGroup, 1, tokenPos, linePos, colPos);
+ if (parser.token === 1077936157) {
+ if (parser.assignable & 2)
+ report(parser, 24);
+ nextToken(parser, context | 32768);
+ if (scope)
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ left = finishNode(parser, context, tokenPos, linePos, colPos, isPattern
+ ? {
+ type: 'AssignmentPattern',
+ left,
+ right
+ }
+ : {
+ type: 'AssignmentExpression',
+ operator: '=',
+ left,
+ right
+ });
+ destructible |=
+ parser.destructible & 256
+ ? 256
+ : 0 | (parser.destructible & 128)
+ ? 128
+ : 0;
+ }
+ else if (parser.token === 18 || parser.token === 20) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (scope) {
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ }
+ destructible |=
+ parser.destructible & 256
+ ? 256
+ : 0 | (parser.destructible & 128)
+ ? 128
+ : 0;
+ }
+ else {
+ destructible |=
+ kind & 1
+ ? 32
+ : (kind & 2) < 1
+ ? 16
+ : 0;
+ left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
+ if (parser.token !== 18 && parser.token !== 20) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ left = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, left);
+ }
+ else if (parser.token !== 1077936157) {
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ }
+ else if (token & 2097152) {
+ left =
+ parser.token === 2162700
+ ? parseObjectLiteralOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos)
+ : parseArrayExpressionOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos);
+ destructible |= parser.destructible;
+ parser.assignable =
+ parser.destructible & 16
+ ? 2
+ : 1;
+ if (parser.token === 18 || parser.token === 20) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ }
+ else if (parser.destructible & 8) {
+ report(parser, 68);
+ }
+ else {
+ left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 2 ? 16 : 0;
+ if (parser.token !== 18 && parser.token !== 20) {
+ left = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, left);
+ }
+ else if (parser.token !== 1077936157) {
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ }
+ else if (token === 14) {
+ left = parseSpreadOrRestElement(parser, context, scope, 20, kind, origin, 0, inGroup, isPattern, tokenPos, linePos, colPos);
+ destructible |= parser.destructible;
+ if (parser.token !== 18 && parser.token !== 20)
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ else {
+ left = parseLeftHandSideExpression(parser, context, 1, 0, 1, tokenPos, linePos, colPos);
+ if (parser.token !== 18 && parser.token !== 20) {
+ left = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, left);
+ if ((kind & (2 | 1)) < 1 && token === 67174411)
+ destructible |= 16;
+ }
+ else if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (token === 67174411) {
+ destructible |=
+ parser.assignable & 1 && kind & (2 | 1)
+ ? 32
+ : 16;
+ }
+ }
+ elements.push(left);
+ if (consumeOpt(parser, context | 32768, 18)) {
+ if (parser.token === 20)
+ break;
+ }
+ else
+ break;
+ }
+ }
+ consume(parser, context, 20);
+ const node = finishNode(parser, context, start, line, column, {
+ type: isPattern ? 'ArrayPattern' : 'ArrayExpression',
+ elements
+ });
+ if (!skipInitializer && parser.token & 4194304) {
+ return parseArrayOrObjectAssignmentPattern(parser, context, destructible, inGroup, isPattern, start, line, column, node);
+ }
+ parser.destructible = destructible;
+ return node;
+}
+function parseArrayOrObjectAssignmentPattern(parser, context, destructible, inGroup, isPattern, start, line, column, node) {
+ if (parser.token !== 1077936157)
+ report(parser, 24);
+ nextToken(parser, context | 32768);
+ if (destructible & 16)
+ report(parser, 24);
+ if (!isPattern)
+ reinterpretToPattern(parser, node);
+ const { tokenPos, linePos, colPos } = parser;
+ const right = parseExpression(parser, context, 1, 1, inGroup, tokenPos, linePos, colPos);
+ parser.destructible =
+ ((destructible | 64 | 8) ^
+ (8 | 64)) |
+ (parser.destructible & 128 ? 128 : 0) |
+ (parser.destructible & 256 ? 256 : 0);
+ return finishNode(parser, context, start, line, column, isPattern
+ ? {
+ type: 'AssignmentPattern',
+ left: node,
+ right
+ }
+ : {
+ type: 'AssignmentExpression',
+ left: node,
+ operator: '=',
+ right
+ });
+}
+function parseSpreadOrRestElement(parser, context, scope, closingToken, kind, origin, isAsync, inGroup, isPattern, start, line, column) {
+ nextToken(parser, context | 32768);
+ let argument = null;
+ let destructible = 0;
+ let { token, tokenValue, tokenPos, linePos, colPos } = parser;
+ if (token & (4096 | 143360)) {
+ parser.assignable = 1;
+ argument = parsePrimaryExpression(parser, context, kind, 0, 1, 0, inGroup, 1, tokenPos, linePos, colPos);
+ token = parser.token;
+ argument = parseMemberOrUpdateExpression(parser, context, argument, inGroup, 0, tokenPos, linePos, colPos);
+ if (parser.token !== 18 && parser.token !== closingToken) {
+ if (parser.assignable & 2 && parser.token === 1077936157)
+ report(parser, 68);
+ destructible |= 16;
+ argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
+ }
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (token === closingToken || token === 18) {
+ if (scope)
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ }
+ else {
+ destructible |= 32;
+ }
+ destructible |= parser.destructible & 128 ? 128 : 0;
+ }
+ else if (token === closingToken) {
+ report(parser, 39);
+ }
+ else if (token & 2097152) {
+ argument =
+ parser.token === 2162700
+ ? parseObjectLiteralOrPattern(parser, context, scope, 1, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos)
+ : parseArrayExpressionOrPattern(parser, context, scope, 1, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos);
+ token = parser.token;
+ if (token !== 1077936157 && token !== closingToken && token !== 18) {
+ if (parser.destructible & 8)
+ report(parser, 68);
+ argument = parseMemberOrUpdateExpression(parser, context, argument, inGroup, 0, tokenPos, linePos, colPos);
+ destructible |= parser.assignable & 2 ? 16 : 0;
+ if ((parser.token & 4194304) === 4194304) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
+ }
+ else {
+ if ((parser.token & 8454144) === 8454144) {
+ argument = parseBinaryExpression(parser, context, 1, tokenPos, linePos, colPos, 4, token, argument);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ argument = parseConditionalExpression(parser, context, argument, tokenPos, linePos, colPos);
+ }
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ else {
+ destructible |=
+ closingToken === 1074790415 && token !== 1077936157
+ ? 16
+ : parser.destructible;
+ }
+ }
+ else {
+ destructible |= 32;
+ argument = parseLeftHandSideExpression(parser, context, 1, inGroup, 1, parser.tokenPos, parser.linePos, parser.colPos);
+ const { token, tokenPos, linePos, colPos } = parser;
+ if (token === 1077936157 && token !== closingToken && token !== 18) {
+ if (parser.assignable & 2)
+ report(parser, 24);
+ argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
+ destructible |= 16;
+ }
+ else {
+ if (token === 18) {
+ destructible |= 16;
+ }
+ else if (token !== closingToken) {
+ argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
+ }
+ destructible |=
+ parser.assignable & 1 ? 32 : 16;
+ }
+ parser.destructible = destructible;
+ if (parser.token !== closingToken && parser.token !== 18)
+ report(parser, 155);
+ return finishNode(parser, context, start, line, column, {
+ type: isPattern ? 'RestElement' : 'SpreadElement',
+ argument: argument
+ });
+ }
+ if (parser.token !== closingToken) {
+ if (kind & 1)
+ destructible |= isAsync ? 16 : 32;
+ if (consumeOpt(parser, context | 32768, 1077936157)) {
+ if (destructible & 16)
+ report(parser, 24);
+ reinterpretToPattern(parser, argument);
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ argument = finishNode(parser, context, tokenPos, linePos, colPos, isPattern
+ ? {
+ type: 'AssignmentPattern',
+ left: argument,
+ right
+ }
+ : {
+ type: 'AssignmentExpression',
+ left: argument,
+ operator: '=',
+ right
+ });
+ destructible = 16;
+ }
+ else {
+ destructible |= 16;
+ }
+ }
+ parser.destructible = destructible;
+ return finishNode(parser, context, start, line, column, {
+ type: isPattern ? 'RestElement' : 'SpreadElement',
+ argument: argument
+ });
+}
+function parseMethodDefinition(parser, context, kind, inGroup, start, line, column) {
+ const modifierFlags = (kind & 64) < 1 ? 31981568 : 14680064;
+ context =
+ ((context | modifierFlags) ^ modifierFlags) |
+ ((kind & 88) << 18) |
+ 100925440;
+ let scope = context & 64 ? addChildScope(createScope(), 512) : void 0;
+ const params = parseMethodFormals(parser, context | 8388608, scope, kind, 1, inGroup);
+ if (scope)
+ scope = addChildScope(scope, 128);
+ const body = parseFunctionBody(parser, context & ~(0x8001000 | 8192), scope, 0, void 0, void 0);
+ return finishNode(parser, context, start, line, column, {
+ type: 'FunctionExpression',
+ params,
+ body,
+ async: (kind & 16) > 0,
+ generator: (kind & 8) > 0,
+ id: null
+ });
+}
+function parseObjectLiteral(parser, context, skipInitializer, inGroup, start, line, column) {
+ const expr = parseObjectLiteralOrPattern(parser, context, void 0, skipInitializer, inGroup, 0, 2, 0, start, line, column);
+ if (context & 256 && parser.destructible & 64) {
+ report(parser, 60);
+ }
+ if (parser.destructible & 8) {
+ report(parser, 59);
+ }
+ return expr;
+}
+function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, inGroup, isPattern, kind, origin, start, line, column) {
+ nextToken(parser, context);
+ const properties = [];
+ let destructible = 0;
+ let prototypeCount = 0;
+ context = (context | 134217728) ^ 134217728;
+ while (parser.token !== 1074790415) {
+ const { token, tokenValue, linePos, colPos, tokenPos } = parser;
+ if (token === 14) {
+ properties.push(parseSpreadOrRestElement(parser, context, scope, 1074790415, kind, origin, 0, inGroup, isPattern, tokenPos, linePos, colPos));
+ }
+ else {
+ let state = 0;
+ let key = null;
+ let value;
+ const t = parser.token;
+ if (parser.token & (143360 | 4096) || parser.token === 121) {
+ key = parseIdentifier(parser, context, 0);
+ if (parser.token === 18 || parser.token === 1074790415 || parser.token === 1077936157) {
+ state |= 4;
+ if (context & 1024 && (token & 537079808) === 537079808) {
+ destructible |= 16;
+ }
+ else {
+ validateBindingIdentifier(parser, context, kind, token, 0);
+ }
+ if (scope)
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ if (consumeOpt(parser, context | 32768, 1077936157)) {
+ destructible |= 8;
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ destructible |=
+ parser.destructible & 256
+ ? 256
+ : 0 | (parser.destructible & 128)
+ ? 128
+ : 0;
+ value = finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'AssignmentPattern',
+ left: context & -2147483648 ? Object.assign({}, key) : key,
+ right
+ });
+ }
+ else {
+ destructible |=
+ (token === 209008 ? 128 : 0) |
+ (token === 121 ? 16 : 0);
+ value = context & -2147483648 ? Object.assign({}, key) : key;
+ }
+ }
+ else if (consumeOpt(parser, context | 32768, 21)) {
+ const { tokenPos, linePos, colPos } = parser;
+ if (tokenValue === '__proto__')
+ prototypeCount++;
+ if (parser.token & 143360) {
+ const tokenAfterColon = parser.token;
+ const valueAfterColon = parser.tokenValue;
+ destructible |= t === 121 ? 16 : 0;
+ value = parsePrimaryExpression(parser, context, kind, 0, 1, 0, inGroup, 1, tokenPos, linePos, colPos);
+ const { token } = parser;
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (token === 1077936157 || token === 1074790415 || token === 18) {
+ destructible |= parser.destructible & 128 ? 128 : 0;
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (scope && (tokenAfterColon & 143360) === 143360) {
+ addVarOrBlock(parser, context, scope, valueAfterColon, kind, origin);
+ }
+ }
+ else {
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ }
+ }
+ else if ((parser.token & 4194304) === 4194304) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (token !== 1077936157) {
+ destructible |= 32;
+ }
+ else if (scope) {
+ addVarOrBlock(parser, context, scope, valueAfterColon, kind, origin);
+ }
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else {
+ destructible |= 16;
+ if ((parser.token & 8454144) === 8454144) {
+ value = parseBinaryExpression(parser, context, 1, tokenPos, linePos, colPos, 4, token, value);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ value = parseConditionalExpression(parser, context, value, tokenPos, linePos, colPos);
+ }
+ }
+ }
+ else if ((parser.token & 2097152) === 2097152) {
+ value =
+ parser.token === 69271571
+ ? parseArrayExpressionOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos)
+ : parseObjectLiteralOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos);
+ destructible = parser.destructible;
+ parser.assignable =
+ destructible & 16 ? 2 : 1;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2)
+ destructible |= 16;
+ }
+ else if (parser.destructible & 8) {
+ report(parser, 68);
+ }
+ else {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 2 ? 16 : 0;
+ if ((parser.token & 4194304) === 4194304) {
+ value = parseAssignmentExpressionOrPattern(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else {
+ if ((parser.token & 8454144) === 8454144) {
+ value = parseBinaryExpression(parser, context, 1, tokenPos, linePos, colPos, 4, token, value);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ value = parseConditionalExpression(parser, context, value, tokenPos, linePos, colPos);
+ }
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ }
+ else {
+ value = parseLeftHandSideExpression(parser, context, 1, inGroup, 1, tokenPos, linePos, colPos);
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2)
+ destructible |= 16;
+ }
+ else {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 2 ? 16 : 0;
+ if (parser.token !== 18 && token !== 1074790415) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ }
+ }
+ }
+ else if (parser.token === 69271571) {
+ destructible |= 16;
+ if (token === 209007)
+ state |= 16;
+ state |=
+ (token === 12402
+ ? 256
+ : token === 12403
+ ? 512
+ : 1) | 2;
+ key = parseComputedPropertyName(parser, context, inGroup);
+ destructible |= parser.assignable;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else if (parser.token & (143360 | 4096)) {
+ destructible |= 16;
+ if (token === 121)
+ report(parser, 92);
+ if (token === 209007) {
+ if (parser.flags & 1)
+ report(parser, 128);
+ state |= 16;
+ }
+ key = parseIdentifier(parser, context, 0);
+ state |=
+ token === 12402
+ ? 256
+ : token === 12403
+ ? 512
+ : 1;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else if (parser.token === 67174411) {
+ destructible |= 16;
+ state |= 1;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else if (parser.token === 8457014) {
+ destructible |= 16;
+ if (token === 12402 || token === 12403) {
+ report(parser, 40);
+ }
+ else if (token === 143483) {
+ report(parser, 92);
+ }
+ nextToken(parser, context);
+ state |=
+ 8 | 1 | (token === 209007 ? 16 : 0);
+ if (parser.token & 143360) {
+ key = parseIdentifier(parser, context, 0);
+ }
+ else if ((parser.token & 134217728) === 134217728) {
+ key = parseLiteral(parser, context);
+ }
+ else if (parser.token === 69271571) {
+ state |= 2;
+ key = parseComputedPropertyName(parser, context, inGroup);
+ destructible |= parser.assignable;
+ }
+ else {
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else if ((parser.token & 134217728) === 134217728) {
+ if (token === 209007)
+ state |= 16;
+ state |=
+ token === 12402
+ ? 256
+ : token === 12403
+ ? 512
+ : 1;
+ destructible |= 16;
+ key = parseLiteral(parser, context);
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ report(parser, 129);
+ }
+ }
+ else if ((parser.token & 134217728) === 134217728) {
+ key = parseLiteral(parser, context);
+ if (parser.token === 21) {
+ consume(parser, context | 32768, 21);
+ const { tokenPos, linePos, colPos } = parser;
+ if (tokenValue === '__proto__')
+ prototypeCount++;
+ if (parser.token & 143360) {
+ value = parsePrimaryExpression(parser, context, kind, 0, 1, 0, inGroup, 1, tokenPos, linePos, colPos);
+ const { token, tokenValue: valueAfterColon } = parser;
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (token === 1077936157 || token === 1074790415 || token === 18) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (scope) {
+ addVarOrBlock(parser, context, scope, valueAfterColon, kind, origin);
+ }
+ }
+ else {
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ }
+ }
+ else if (parser.token === 1077936157) {
+ if (parser.assignable & 2)
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else {
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ }
+ else if ((parser.token & 2097152) === 2097152) {
+ value =
+ parser.token === 69271571
+ ? parseArrayExpressionOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos)
+ : parseObjectLiteralOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos);
+ destructible = parser.destructible;
+ parser.assignable =
+ destructible & 16 ? 2 : 1;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ }
+ else if ((parser.destructible & 8) !== 8) {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 2 ? 16 : 0;
+ if ((parser.token & 4194304) === 4194304) {
+ value = parseAssignmentExpressionOrPattern(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else {
+ if ((parser.token & 8454144) === 8454144) {
+ value = parseBinaryExpression(parser, context, 1, tokenPos, linePos, colPos, 4, token, value);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ value = parseConditionalExpression(parser, context, value, tokenPos, linePos, colPos);
+ }
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ }
+ else {
+ value = parseLeftHandSideExpression(parser, context, 1, 0, 1, tokenPos, linePos, colPos);
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ }
+ else {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 1 ? 0 : 16;
+ if (parser.token !== 18 && parser.token !== 1074790415) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ }
+ }
+ }
+ else if (parser.token === 67174411) {
+ state |= 1;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ destructible = parser.assignable | 16;
+ }
+ else {
+ report(parser, 130);
+ }
+ }
+ else if (parser.token === 69271571) {
+ key = parseComputedPropertyName(parser, context, inGroup);
+ destructible |= parser.destructible & 256 ? 256 : 0;
+ state |= 2;
+ if (parser.token === 21) {
+ nextToken(parser, context | 32768);
+ const { tokenPos, linePos, colPos, tokenValue, token: tokenAfterColon } = parser;
+ if (parser.token & 143360) {
+ value = parsePrimaryExpression(parser, context, kind, 0, 1, 0, inGroup, 1, tokenPos, linePos, colPos);
+ const { token } = parser;
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ if ((parser.token & 4194304) === 4194304) {
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : token === 1077936157
+ ? 0
+ : 32;
+ value = parseAssignmentExpressionOrPattern(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else if (parser.token === 18 || parser.token === 1074790415) {
+ if (token === 1077936157 || token === 1074790415 || token === 18) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ }
+ else if (scope && (tokenAfterColon & 143360) === 143360) {
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ }
+ }
+ else {
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ }
+ }
+ else {
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ }
+ else if ((parser.token & 2097152) === 2097152) {
+ value =
+ parser.token === 69271571
+ ? parseArrayExpressionOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos)
+ : parseObjectLiteralOrPattern(parser, context, scope, 0, inGroup, isPattern, kind, origin, tokenPos, linePos, colPos);
+ destructible = parser.destructible;
+ parser.assignable =
+ destructible & 16 ? 2 : 1;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2)
+ destructible |= 16;
+ }
+ else if (destructible & 8) {
+ report(parser, 59);
+ }
+ else {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible =
+ parser.assignable & 2 ? destructible | 16 : 0;
+ if ((parser.token & 4194304) === 4194304) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ value = parseAssignmentExpressionOrPattern(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ else {
+ if ((parser.token & 8454144) === 8454144) {
+ value = parseBinaryExpression(parser, context, 1, tokenPos, linePos, colPos, 4, token, value);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ value = parseConditionalExpression(parser, context, value, tokenPos, linePos, colPos);
+ }
+ destructible |=
+ parser.assignable & 2
+ ? 16
+ : 32;
+ }
+ }
+ }
+ else {
+ value = parseLeftHandSideExpression(parser, context, 1, 0, 1, tokenPos, linePos, colPos);
+ destructible |=
+ parser.assignable & 1
+ ? 32
+ : 16;
+ if (parser.token === 18 || parser.token === 1074790415) {
+ if (parser.assignable & 2)
+ destructible |= 16;
+ }
+ else {
+ value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable & 1 ? 0 : 16;
+ if (parser.token !== 18 && parser.token !== 1074790415) {
+ if (parser.token !== 1077936157)
+ destructible |= 16;
+ value = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, value);
+ }
+ }
+ }
+ }
+ else if (parser.token === 67174411) {
+ state |= 1;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, linePos, colPos);
+ destructible = 16;
+ }
+ else {
+ report(parser, 41);
+ }
+ }
+ else if (token === 8457014) {
+ consume(parser, context | 32768, 8457014);
+ state |= 8;
+ if (parser.token & 143360) {
+ const { token, line, index } = parser;
+ key = parseIdentifier(parser, context, 0);
+ state |= 1;
+ if (parser.token === 67174411) {
+ destructible |= 16;
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ reportMessageAt(index, line, index, token === 209007
+ ? 43
+ : token === 12402 || parser.token === 12403
+ ? 42
+ : 44, KeywordDescTable[token & 255]);
+ }
+ }
+ else if ((parser.token & 134217728) === 134217728) {
+ destructible |= 16;
+ key = parseLiteral(parser, context);
+ state |= 1;
+ value = parseMethodDefinition(parser, context, state, inGroup, tokenPos, linePos, colPos);
+ }
+ else if (parser.token === 69271571) {
+ destructible |= 16;
+ state |= 2 | 1;
+ key = parseComputedPropertyName(parser, context, inGroup);
+ value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ report(parser, 122);
+ }
+ }
+ else {
+ report(parser, 28, KeywordDescTable[token & 255]);
+ }
+ destructible |= parser.destructible & 128 ? 128 : 0;
+ parser.destructible = destructible;
+ properties.push(finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'Property',
+ key: key,
+ value,
+ kind: !(state & 768) ? 'init' : state & 512 ? 'set' : 'get',
+ computed: (state & 2) > 0,
+ method: (state & 1) > 0,
+ shorthand: (state & 4) > 0
+ }));
+ }
+ destructible |= parser.destructible;
+ if (parser.token !== 18)
+ break;
+ nextToken(parser, context);
+ }
+ consume(parser, context, 1074790415);
+ if (prototypeCount > 1)
+ destructible |= 64;
+ const node = finishNode(parser, context, start, line, column, {
+ type: isPattern ? 'ObjectPattern' : 'ObjectExpression',
+ properties
+ });
+ if (!skipInitializer && parser.token & 4194304) {
+ return parseArrayOrObjectAssignmentPattern(parser, context, destructible, inGroup, isPattern, start, line, column, node);
+ }
+ parser.destructible = destructible;
+ return node;
+}
+function parseMethodFormals(parser, context, scope, kind, type, inGroup) {
+ consume(parser, context, 67174411);
+ const params = [];
+ parser.flags = (parser.flags | 128) ^ 128;
+ if (parser.token === 16) {
+ if (kind & 512) {
+ report(parser, 35, 'Setter', 'one', '');
+ }
+ nextToken(parser, context);
+ return params;
+ }
+ if (kind & 256) {
+ report(parser, 35, 'Getter', 'no', 's');
+ }
+ if (kind & 512 && parser.token === 14) {
+ report(parser, 36);
+ }
+ context = (context | 134217728) ^ 134217728;
+ let setterArgs = 0;
+ let isSimpleParameterList = 0;
+ while (parser.token !== 18) {
+ let left = null;
+ const { tokenPos, linePos, colPos } = parser;
+ if (parser.token & 143360) {
+ if ((context & 1024) < 1) {
+ if ((parser.token & 36864) === 36864) {
+ parser.flags |= 256;
+ }
+ if ((parser.token & 537079808) === 537079808) {
+ parser.flags |= 512;
+ }
+ }
+ left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0, tokenPos, linePos, colPos);
+ }
+ else {
+ if (parser.token === 2162700) {
+ left = parseObjectLiteralOrPattern(parser, context, scope, 1, inGroup, 1, type, 0, tokenPos, linePos, colPos);
+ }
+ else if (parser.token === 69271571) {
+ left = parseArrayExpressionOrPattern(parser, context, scope, 1, inGroup, 1, type, 0, tokenPos, linePos, colPos);
+ }
+ else if (parser.token === 14) {
+ left = parseSpreadOrRestElement(parser, context, scope, 16, type, 0, 0, inGroup, 1, tokenPos, linePos, colPos);
+ }
+ isSimpleParameterList = 1;
+ if (parser.destructible & (32 | 16))
+ report(parser, 47);
+ }
+ if (parser.token === 1077936157) {
+ nextToken(parser, context | 32768);
+ isSimpleParameterList = 1;
+ const right = parseExpression(parser, context, 1, 1, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ left = finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'AssignmentPattern',
+ left: left,
+ right
+ });
+ }
+ setterArgs++;
+ params.push(left);
+ if (!consumeOpt(parser, context, 18))
+ break;
+ if (parser.token === 16) {
+ break;
+ }
+ }
+ if (kind & 512 && setterArgs !== 1) {
+ report(parser, 35, 'Setter', 'one', '');
+ }
+ if (scope && scope.scopeError !== void 0)
+ reportScopeError(scope.scopeError);
+ if (isSimpleParameterList)
+ parser.flags |= 128;
+ consume(parser, context, 16);
+ return params;
+}
+function parseComputedPropertyName(parser, context, inGroup) {
+ nextToken(parser, context | 32768);
+ const key = parseExpression(parser, (context | 134217728) ^ 134217728, 1, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context, 20);
+ return key;
+}
+function parseParenthesizedExpression(parser, context, canAssign, kind, origin, start, line, column) {
+ parser.flags = (parser.flags | 128) ^ 128;
+ const { tokenPos: piStart, linePos: plStart, colPos: pcStart } = parser;
+ nextToken(parser, context | 32768 | 1073741824);
+ const scope = context & 64 ? addChildScope(createScope(), 1024) : void 0;
+ context = (context | 134217728) ^ 134217728;
+ if (consumeOpt(parser, context, 16)) {
+ return parseParenthesizedArrow(parser, context, scope, [], canAssign, 0, start, line, column);
+ }
+ let destructible = 0;
+ parser.destructible &= ~(256 | 128);
+ let expr;
+ let expressions = [];
+ let isSequence = 0;
+ let isSimpleParameterList = 0;
+ const { tokenPos: iStart, linePos: lStart, colPos: cStart } = parser;
+ parser.assignable = 1;
+ while (parser.token !== 16) {
+ const { token, tokenPos, linePos, colPos } = parser;
+ if (token & (143360 | 4096)) {
+ if (scope)
+ addBlockName(parser, context, scope, parser.tokenValue, 1, 0);
+ expr = parsePrimaryExpression(parser, context, kind, 0, 1, 0, 1, 1, tokenPos, linePos, colPos);
+ if (parser.token === 16 || parser.token === 18) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ isSimpleParameterList = 1;
+ }
+ else if ((token & 537079808) === 537079808 ||
+ (token & 36864) === 36864) {
+ isSimpleParameterList = 1;
+ }
+ }
+ else {
+ if (parser.token === 1077936157) {
+ isSimpleParameterList = 1;
+ }
+ else {
+ destructible |= 16;
+ }
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 1, 0, tokenPos, linePos, colPos);
+ if (parser.token !== 16 && parser.token !== 18) {
+ expr = parseAssignmentExpression(parser, context, 1, 0, tokenPos, linePos, colPos, expr);
+ }
+ }
+ }
+ else if ((token & 2097152) === 2097152) {
+ expr =
+ token === 2162700
+ ? parseObjectLiteralOrPattern(parser, context | 1073741824, scope, 0, 1, 0, kind, origin, tokenPos, linePos, colPos)
+ : parseArrayExpressionOrPattern(parser, context | 1073741824, scope, 0, 1, 0, kind, origin, tokenPos, linePos, colPos);
+ destructible |= parser.destructible;
+ isSimpleParameterList = 1;
+ parser.assignable = 2;
+ if (parser.token !== 16 && parser.token !== 18) {
+ if (destructible & 8)
+ report(parser, 118);
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
+ destructible |= 16;
+ if (parser.token !== 16 && parser.token !== 18) {
+ expr = parseAssignmentExpression(parser, context, 0, 0, tokenPos, linePos, colPos, expr);
+ }
+ }
+ }
+ else if (token === 14) {
+ expr = parseSpreadOrRestElement(parser, context, scope, 16, kind, origin, 0, 1, 0, tokenPos, linePos, colPos);
+ if (parser.destructible & 16)
+ report(parser, 71);
+ isSimpleParameterList = 1;
+ if (isSequence && (parser.token === 16 || parser.token === 18)) {
+ expressions.push(expr);
+ }
+ destructible |= 8;
+ break;
+ }
+ else {
+ destructible |= 16;
+ expr = parseExpression(parser, context, 1, 0, 1, tokenPos, linePos, colPos);
+ if (isSequence && (parser.token === 16 || parser.token === 18)) {
+ expressions.push(expr);
+ }
+ if (parser.token === 18) {
+ if (!isSequence) {
+ isSequence = 1;
+ expressions = [expr];
+ }
+ }
+ if (isSequence) {
+ while (consumeOpt(parser, context | 32768, 18)) {
+ expressions.push(parseExpression(parser, context, 1, 0, 1, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ parser.assignable = 2;
+ expr = finishNode(parser, context, iStart, lStart, cStart, {
+ type: 'SequenceExpression',
+ expressions
+ });
+ }
+ consume(parser, context, 16);
+ parser.destructible = destructible;
+ return expr;
+ }
+ if (isSequence && (parser.token === 16 || parser.token === 18)) {
+ expressions.push(expr);
+ }
+ if (!consumeOpt(parser, context | 32768, 18))
+ break;
+ if (!isSequence) {
+ isSequence = 1;
+ expressions = [expr];
+ }
+ if (parser.token === 16) {
+ destructible |= 8;
+ break;
+ }
+ }
+ if (isSequence) {
+ parser.assignable = 2;
+ expr = finishNode(parser, context, iStart, lStart, cStart, {
+ type: 'SequenceExpression',
+ expressions
+ });
+ }
+ consume(parser, context, 16);
+ if (destructible & 16 && destructible & 8)
+ report(parser, 145);
+ destructible |=
+ parser.destructible & 256
+ ? 256
+ : 0 | (parser.destructible & 128)
+ ? 128
+ : 0;
+ if (parser.token === 10) {
+ if (destructible & (32 | 16))
+ report(parser, 46);
+ if (context & (4194304 | 2048) && destructible & 128)
+ report(parser, 29);
+ if (context & (1024 | 2097152) && destructible & 256) {
+ report(parser, 30);
+ }
+ if (isSimpleParameterList)
+ parser.flags |= 128;
+ return parseParenthesizedArrow(parser, context, scope, isSequence ? expressions : [expr], canAssign, 0, start, line, column);
+ }
+ else if (destructible & 8) {
+ report(parser, 139);
+ }
+ parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
+ return context & 128
+ ? finishNode(parser, context, piStart, plStart, pcStart, {
+ type: 'ParenthesizedExpression',
+ expression: expr
+ })
+ : expr;
+}
+function parseIdentifierOrArrow(parser, context, start, line, column) {
+ const { tokenValue } = parser;
+ const expr = parseIdentifier(parser, context, 0);
+ parser.assignable = 1;
+ if (parser.token === 10) {
+ let scope = void 0;
+ if (context & 64)
+ scope = createArrowHeadParsingScope(parser, context, tokenValue);
+ parser.flags = (parser.flags | 128) ^ 128;
+ return parseArrowFunctionExpression(parser, context, scope, [expr], 0, start, line, column);
+ }
+ return expr;
+}
+function parseArrowFromIdentifier(parser, context, value, expr, inNew, canAssign, isAsync, start, line, column) {
+ if (!canAssign)
+ report(parser, 54);
+ if (inNew)
+ report(parser, 48);
+ parser.flags &= ~128;
+ const scope = context & 64 ? createArrowHeadParsingScope(parser, context, value) : void 0;
+ return parseArrowFunctionExpression(parser, context, scope, [expr], isAsync, start, line, column);
+}
+function parseParenthesizedArrow(parser, context, scope, params, canAssign, isAsync, start, line, column) {
+ if (!canAssign)
+ report(parser, 54);
+ for (let i = 0; i < params.length; ++i)
+ reinterpretToPattern(parser, params[i]);
+ return parseArrowFunctionExpression(parser, context, scope, params, isAsync, start, line, column);
+}
+function parseArrowFunctionExpression(parser, context, scope, params, isAsync, start, line, column) {
+ if (parser.flags & 1)
+ report(parser, 45);
+ consume(parser, context | 32768, 10);
+ context = ((context | 15728640) ^ 15728640) | (isAsync << 22);
+ const expression = parser.token !== 2162700;
+ let body;
+ if (scope && scope.scopeError !== void 0) {
+ reportScopeError(scope.scopeError);
+ }
+ if (expression) {
+ body = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ }
+ else {
+ if (scope)
+ scope = addChildScope(scope, 128);
+ body = parseFunctionBody(parser, (context | 134221824 | 8192 | 16384) ^
+ (134221824 | 8192 | 16384), scope, 16, void 0, void 0);
+ switch (parser.token) {
+ case 69271571:
+ if ((parser.flags & 1) < 1) {
+ report(parser, 112);
+ }
+ break;
+ case 67108877:
+ case 67174409:
+ case 22:
+ report(parser, 113);
+ case 67174411:
+ if ((parser.flags & 1) < 1) {
+ report(parser, 112);
+ }
+ parser.flags |= 1024;
+ break;
+ }
+ if ((parser.token & 8454144) === 8454144 && (parser.flags & 1) < 1)
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ if ((parser.token & 33619968) === 33619968)
+ report(parser, 121);
+ }
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'ArrowFunctionExpression',
+ params,
+ body,
+ async: isAsync === 1,
+ expression
+ });
+}
+function parseFormalParametersOrFormalList(parser, context, scope, inGroup, kind) {
+ consume(parser, context, 67174411);
+ parser.flags = (parser.flags | 128) ^ 128;
+ const params = [];
+ if (consumeOpt(parser, context, 16))
+ return params;
+ context = (context | 134217728) ^ 134217728;
+ let isSimpleParameterList = 0;
+ while (parser.token !== 18) {
+ let left;
+ const { tokenPos, linePos, colPos } = parser;
+ if (parser.token & 143360) {
+ if ((context & 1024) < 1) {
+ if ((parser.token & 36864) === 36864) {
+ parser.flags |= 256;
+ }
+ if ((parser.token & 537079808) === 537079808) {
+ parser.flags |= 512;
+ }
+ }
+ left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0, tokenPos, linePos, colPos);
+ }
+ else {
+ if (parser.token === 2162700) {
+ left = parseObjectLiteralOrPattern(parser, context, scope, 1, inGroup, 1, kind, 0, tokenPos, linePos, colPos);
+ }
+ else if (parser.token === 69271571) {
+ left = parseArrayExpressionOrPattern(parser, context, scope, 1, inGroup, 1, kind, 0, tokenPos, linePos, colPos);
+ }
+ else if (parser.token === 14) {
+ left = parseSpreadOrRestElement(parser, context, scope, 16, kind, 0, 0, inGroup, 1, tokenPos, linePos, colPos);
+ }
+ else {
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ isSimpleParameterList = 1;
+ if (parser.destructible & (32 | 16)) {
+ report(parser, 47);
+ }
+ }
+ if (parser.token === 1077936157) {
+ nextToken(parser, context | 32768);
+ isSimpleParameterList = 1;
+ const right = parseExpression(parser, context, 1, 1, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ left = finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'AssignmentPattern',
+ left,
+ right
+ });
+ }
+ params.push(left);
+ if (!consumeOpt(parser, context, 18))
+ break;
+ if (parser.token === 16) {
+ break;
+ }
+ }
+ if (isSimpleParameterList)
+ parser.flags |= 128;
+ if (scope && (isSimpleParameterList || context & 1024) && scope.scopeError !== void 0) {
+ reportScopeError(scope.scopeError);
+ }
+ consume(parser, context, 16);
+ return params;
+}
+function parseMembeExpressionNoCall(parser, context, expr, inGroup, start, line, column) {
+ const { token } = parser;
+ if (token & 67108864) {
+ if (token === 67108877) {
+ nextToken(parser, context | 1073741824);
+ parser.assignable = 1;
+ const property = parsePropertyOrPrivatePropertyName(parser, context);
+ return parseMembeExpressionNoCall(parser, context, finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: false,
+ property
+ }), 0, start, line, column);
+ }
+ else if (token === 69271571) {
+ nextToken(parser, context | 32768);
+ const { tokenPos, linePos, colPos } = parser;
+ const property = parseExpressions(parser, context, inGroup, 1, tokenPos, linePos, colPos);
+ consume(parser, context, 20);
+ parser.assignable = 1;
+ return parseMembeExpressionNoCall(parser, context, finishNode(parser, context, start, line, column, {
+ type: 'MemberExpression',
+ object: expr,
+ computed: true,
+ property
+ }), 0, start, line, column);
+ }
+ else if (token === 67174408 || token === 67174409) {
+ parser.assignable = 2;
+ return parseMembeExpressionNoCall(parser, context, finishNode(parser, context, start, line, column, {
+ type: 'TaggedTemplateExpression',
+ tag: expr,
+ quasi: parser.token === 67174408
+ ? parseTemplate(parser, context | 65536)
+ : parseTemplateLiteral(parser, context, parser.tokenPos, parser.linePos, parser.colPos)
+ }), 0, start, line, column);
+ }
+ }
+ return expr;
+}
+function parseNewExpression(parser, context, inGroup, start, line, column) {
+ const id = parseIdentifier(parser, context | 32768, 0);
+ const { tokenPos, linePos, colPos } = parser;
+ if (consumeOpt(parser, context, 67108877)) {
+ if (context & 67108864 && parser.token === 143494) {
+ parser.assignable = 2;
+ return parseMetaProperty(parser, context, id, start, line, column);
+ }
+ report(parser, 91);
+ }
+ parser.assignable = 2;
+ if ((parser.token & 16842752) === 16842752) {
+ report(parser, 62, KeywordDescTable[parser.token & 255]);
+ }
+ const expr = parsePrimaryExpression(parser, context, 2, 1, 0, 0, inGroup, 1, tokenPos, linePos, colPos);
+ context = (context | 134217728) ^ 134217728;
+ if (parser.token === 67108991)
+ report(parser, 162);
+ const callee = parseMembeExpressionNoCall(parser, context, expr, inGroup, tokenPos, linePos, colPos);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'NewExpression',
+ callee,
+ arguments: parser.token === 67174411 ? parseArguments(parser, context, inGroup) : []
+ });
+}
+function parseMetaProperty(parser, context, meta, start, line, column) {
+ const property = parseIdentifier(parser, context, 0);
+ return finishNode(parser, context, start, line, column, {
+ type: 'MetaProperty',
+ meta,
+ property
+ });
+}
+function parseAsyncArrowAfterIdent(parser, context, canAssign, start, line, column) {
+ if (parser.token === 209008)
+ report(parser, 29);
+ if (context & (1024 | 2097152) && parser.token === 241773) {
+ report(parser, 30);
+ }
+ if ((parser.token & 537079808) === 537079808) {
+ parser.flags |= 512;
+ }
+ return parseArrowFromIdentifier(parser, context, parser.tokenValue, parseIdentifier(parser, context, 0), 0, canAssign, 1, start, line, column);
+}
+function parseAsyncArrowOrCallExpression(parser, context, callee, canAssign, kind, origin, flags, start, line, column) {
+ nextToken(parser, context | 32768);
+ const scope = context & 64 ? addChildScope(createScope(), 1024) : void 0;
+ context = (context | 134217728) ^ 134217728;
+ if (consumeOpt(parser, context, 16)) {
+ if (parser.token === 10) {
+ if (flags & 1)
+ report(parser, 45);
+ return parseParenthesizedArrow(parser, context, scope, [], canAssign, 1, start, line, column);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'CallExpression',
+ callee,
+ arguments: []
+ });
+ }
+ let destructible = 0;
+ let expr = null;
+ let isSimpleParameterList = 0;
+ parser.destructible =
+ (parser.destructible | 256 | 128) ^
+ (256 | 128);
+ const params = [];
+ while (parser.token !== 16) {
+ const { token, tokenPos, linePos, colPos } = parser;
+ if (token & (143360 | 4096)) {
+ if (scope)
+ addBlockName(parser, context, scope, parser.tokenValue, kind, 0);
+ expr = parsePrimaryExpression(parser, context, kind, 0, 1, 0, 1, 1, tokenPos, linePos, colPos);
+ if (parser.token === 16 || parser.token === 18) {
+ if (parser.assignable & 2) {
+ destructible |= 16;
+ isSimpleParameterList = 1;
+ }
+ else if ((token & 537079808) === 537079808) {
+ parser.flags |= 512;
+ }
+ else if ((token & 36864) === 36864) {
+ parser.flags |= 256;
+ }
+ }
+ else {
+ if (parser.token === 1077936157) {
+ isSimpleParameterList = 1;
+ }
+ else {
+ destructible |= 16;
+ }
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 1, 0, tokenPos, linePos, colPos);
+ if (parser.token !== 16 && parser.token !== 18) {
+ expr = parseAssignmentExpression(parser, context, 1, 0, tokenPos, linePos, colPos, expr);
+ }
+ }
+ }
+ else if (token & 2097152) {
+ expr =
+ token === 2162700
+ ? parseObjectLiteralOrPattern(parser, context, scope, 0, 1, 0, kind, origin, tokenPos, linePos, colPos)
+ : parseArrayExpressionOrPattern(parser, context, scope, 0, 1, 0, kind, origin, tokenPos, linePos, colPos);
+ destructible |= parser.destructible;
+ isSimpleParameterList = 1;
+ if (parser.token !== 16 && parser.token !== 18) {
+ if (destructible & 8)
+ report(parser, 118);
+ expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
+ destructible |= 16;
+ if ((parser.token & 8454144) === 8454144) {
+ expr = parseBinaryExpression(parser, context, 1, start, line, column, 4, token, expr);
+ }
+ if (consumeOpt(parser, context | 32768, 22)) {
+ expr = parseConditionalExpression(parser, context, expr, start, line, column);
+ }
+ }
+ }
+ else if (token === 14) {
+ expr = parseSpreadOrRestElement(parser, context, scope, 16, kind, origin, 1, 1, 0, tokenPos, linePos, colPos);
+ destructible |= (parser.token === 16 ? 0 : 16) | parser.destructible;
+ isSimpleParameterList = 1;
+ }
+ else {
+ expr = parseExpression(parser, context, 1, 0, 0, tokenPos, linePos, colPos);
+ destructible = parser.assignable;
+ params.push(expr);
+ while (consumeOpt(parser, context | 32768, 18)) {
+ params.push(parseExpression(parser, context, 1, 0, 0, tokenPos, linePos, colPos));
+ }
+ destructible |= parser.assignable;
+ consume(parser, context, 16);
+ parser.destructible = destructible | 16;
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'CallExpression',
+ callee,
+ arguments: params
+ });
+ }
+ params.push(expr);
+ if (!consumeOpt(parser, context | 32768, 18))
+ break;
+ }
+ consume(parser, context, 16);
+ destructible |=
+ parser.destructible & 256
+ ? 256
+ : 0 | (parser.destructible & 128)
+ ? 128
+ : 0;
+ if (parser.token === 10) {
+ if (destructible & (32 | 16))
+ report(parser, 25);
+ if (parser.flags & 1 || flags & 1)
+ report(parser, 45);
+ if (destructible & 128)
+ report(parser, 29);
+ if (context & (1024 | 2097152) && destructible & 256)
+ report(parser, 30);
+ if (isSimpleParameterList)
+ parser.flags |= 128;
+ return parseParenthesizedArrow(parser, context, scope, params, canAssign, 1, start, line, column);
+ }
+ else if (destructible & 8) {
+ report(parser, 59);
+ }
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, {
+ type: 'CallExpression',
+ callee,
+ arguments: params
+ });
+}
+function parseRegExpLiteral(parser, context, start, line, column) {
+ const { tokenRaw, tokenRegExp, tokenValue } = parser;
+ nextToken(parser, context);
+ parser.assignable = 2;
+ return context & 512
+ ? finishNode(parser, context, start, line, column, {
+ type: 'Literal',
+ value: tokenValue,
+ regex: tokenRegExp,
+ raw: tokenRaw
+ })
+ : finishNode(parser, context, start, line, column, {
+ type: 'Literal',
+ value: tokenValue,
+ regex: tokenRegExp
+ });
+}
+function parseClassDeclaration(parser, context, scope, flags, start, line, column) {
+ context = (context | 16777216 | 1024) ^ 16777216;
+ let decorators = parseDecorators(parser, context);
+ if (decorators.length) {
+ start = parser.tokenPos;
+ line = parser.linePos;
+ column = parser.colPos;
+ }
+ if (parser.leadingDecorators.length) {
+ parser.leadingDecorators.push(...decorators);
+ decorators = parser.leadingDecorators;
+ parser.leadingDecorators = [];
+ }
+ nextToken(parser, context);
+ let id = null;
+ let superClass = null;
+ const { tokenValue } = parser;
+ if (parser.token & 4096 && parser.token !== 20567) {
+ if (isStrictReservedWord(parser, context, parser.token)) {
+ report(parser, 114);
+ }
+ if ((parser.token & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ if (scope) {
+ addBlockName(parser, context, scope, tokenValue, 32, 0);
+ if (flags) {
+ if (flags & 2) {
+ declareUnboundVariable(parser, tokenValue);
+ }
+ }
+ }
+ id = parseIdentifier(parser, context, 0);
+ }
+ else {
+ if ((flags & 1) < 1)
+ report(parser, 37, 'Class');
+ }
+ let inheritedContext = context;
+ if (consumeOpt(parser, context | 32768, 20567)) {
+ superClass = parseLeftHandSideExpression(parser, context, 0, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ inheritedContext |= 524288;
+ }
+ else {
+ inheritedContext = (inheritedContext | 524288) ^ 524288;
+ }
+ const body = parseClassBody(parser, inheritedContext, context, scope, 2, 8, 0);
+ return finishNode(parser, context, start, line, column, context & 1
+ ? {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ decorators,
+ body
+ }
+ : {
+ type: 'ClassDeclaration',
+ id,
+ superClass,
+ body
+ });
+}
+function parseClassExpression(parser, context, inGroup, start, line, column) {
+ let id = null;
+ let superClass = null;
+ context = (context | 1024 | 16777216) ^ 16777216;
+ const decorators = parseDecorators(parser, context);
+ if (decorators.length) {
+ start = parser.tokenPos;
+ line = parser.linePos;
+ column = parser.colPos;
+ }
+ nextToken(parser, context);
+ if (parser.token & 4096 && parser.token !== 20567) {
+ if (isStrictReservedWord(parser, context, parser.token))
+ report(parser, 114);
+ if ((parser.token & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ id = parseIdentifier(parser, context, 0);
+ }
+ let inheritedContext = context;
+ if (consumeOpt(parser, context | 32768, 20567)) {
+ superClass = parseLeftHandSideExpression(parser, context, 0, inGroup, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ inheritedContext |= 524288;
+ }
+ else {
+ inheritedContext = (inheritedContext | 524288) ^ 524288;
+ }
+ const body = parseClassBody(parser, inheritedContext, context, void 0, 2, 0, inGroup);
+ parser.assignable = 2;
+ return finishNode(parser, context, start, line, column, context & 1
+ ? {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ decorators,
+ body
+ }
+ : {
+ type: 'ClassExpression',
+ id,
+ superClass,
+ body
+ });
+}
+function parseDecorators(parser, context) {
+ const list = [];
+ if (context & 1) {
+ while (parser.token === 133) {
+ list.push(parseDecoratorList(parser, context, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ }
+ return list;
+}
+function parseDecoratorList(parser, context, start, line, column) {
+ nextToken(parser, context | 32768);
+ let expression = parsePrimaryExpression(parser, context, 2, 0, 1, 0, 0, 1, start, line, column);
+ expression = parseMemberOrUpdateExpression(parser, context, expression, 0, 0, start, line, column);
+ return finishNode(parser, context, start, line, column, {
+ type: 'Decorator',
+ expression
+ });
+}
+function parseClassBody(parser, context, inheritedContext, scope, kind, origin, inGroup) {
+ const { tokenPos, linePos, colPos } = parser;
+ consume(parser, context | 32768, 2162700);
+ context = (context | 134217728) ^ 134217728;
+ parser.flags = (parser.flags | 32) ^ 32;
+ const body = [];
+ let decorators;
+ while (parser.token !== 1074790415) {
+ let length = 0;
+ decorators = parseDecorators(parser, context);
+ length = decorators.length;
+ if (length > 0 && parser.tokenValue === 'constructor') {
+ report(parser, 106);
+ }
+ if (parser.token === 1074790415)
+ report(parser, 105);
+ if (consumeOpt(parser, context, 1074790417)) {
+ if (length > 0)
+ report(parser, 116);
+ continue;
+ }
+ body.push(parseClassElementList(parser, context, scope, inheritedContext, kind, decorators, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ consume(parser, origin & 8 ? context | 32768 : context, 1074790415);
+ return finishNode(parser, context, tokenPos, linePos, colPos, {
+ type: 'ClassBody',
+ body
+ });
+}
+function parseClassElementList(parser, context, scope, inheritedContext, type, decorators, isStatic, inGroup, start, line, column) {
+ let kind = isStatic ? 32 : 0;
+ let key = null;
+ const { token, tokenPos, linePos, colPos } = parser;
+ if (token & (143360 | 36864)) {
+ key = parseIdentifier(parser, context, 0);
+ switch (token) {
+ case 36972:
+ if (!isStatic && parser.token !== 67174411) {
+ return parseClassElementList(parser, context, scope, inheritedContext, type, decorators, 1, inGroup, start, line, column);
+ }
+ break;
+ case 209007:
+ if (parser.token !== 67174411 && (parser.flags & 1) < 1) {
+ if (context & 1 && (parser.token & 1073741824) === 1073741824) {
+ return parsePropertyDefinition(parser, context, key, kind, decorators, tokenPos, linePos, colPos);
+ }
+ kind |= 16 | (optionalBit(parser, context, 8457014) ? 8 : 0);
+ }
+ break;
+ case 12402:
+ if (parser.token !== 67174411) {
+ if (context & 1 && (parser.token & 1073741824) === 1073741824) {
+ return parsePropertyDefinition(parser, context, key, kind, decorators, tokenPos, linePos, colPos);
+ }
+ kind |= 256;
+ }
+ break;
+ case 12403:
+ if (parser.token !== 67174411) {
+ if (context & 1 && (parser.token & 1073741824) === 1073741824) {
+ return parsePropertyDefinition(parser, context, key, kind, decorators, tokenPos, linePos, colPos);
+ }
+ kind |= 512;
+ }
+ break;
+ }
+ }
+ else if (token === 69271571) {
+ kind |= 2;
+ key = parseComputedPropertyName(parser, inheritedContext, inGroup);
+ }
+ else if ((token & 134217728) === 134217728) {
+ key = parseLiteral(parser, context);
+ }
+ else if (token === 8457014) {
+ kind |= 8;
+ nextToken(parser, context);
+ }
+ else if (context & 1 && parser.token === 131) {
+ kind |= 4096;
+ key = parsePrivateIdentifier(parser, context, tokenPos, linePos, colPos);
+ context = context | 16384;
+ }
+ else if (context & 1 && (parser.token & 1073741824) === 1073741824) {
+ kind |= 128;
+ context = context | 16384;
+ }
+ else if (token === 122) {
+ key = parseIdentifier(parser, context, 0);
+ if (parser.token !== 67174411)
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ else {
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ }
+ if (kind & (8 | 16 | 768)) {
+ if (parser.token & 143360) {
+ key = parseIdentifier(parser, context, 0);
+ }
+ else if ((parser.token & 134217728) === 134217728) {
+ key = parseLiteral(parser, context);
+ }
+ else if (parser.token === 69271571) {
+ kind |= 2;
+ key = parseComputedPropertyName(parser, context, 0);
+ }
+ else if (parser.token === 122) {
+ key = parseIdentifier(parser, context, 0);
+ }
+ else if (context & 1 && parser.token === 131) {
+ kind |= 4096;
+ key = parsePrivateIdentifier(parser, context, tokenPos, linePos, colPos);
+ }
+ else
+ report(parser, 131);
+ }
+ if ((kind & 2) < 1) {
+ if (parser.tokenValue === 'constructor') {
+ if ((parser.token & 1073741824) === 1073741824) {
+ report(parser, 125);
+ }
+ else if ((kind & 32) < 1 && parser.token === 67174411) {
+ if (kind & (768 | 16 | 128 | 8)) {
+ report(parser, 50, 'accessor');
+ }
+ else if ((context & 524288) < 1) {
+ if (parser.flags & 32)
+ report(parser, 51);
+ else
+ parser.flags |= 32;
+ }
+ }
+ kind |= 64;
+ }
+ else if ((kind & 4096) < 1 &&
+ kind & (32 | 768 | 8 | 16) &&
+ parser.tokenValue === 'prototype') {
+ report(parser, 49);
+ }
+ }
+ if (context & 1 && parser.token !== 67174411) {
+ return parsePropertyDefinition(parser, context, key, kind, decorators, tokenPos, linePos, colPos);
+ }
+ const value = parseMethodDefinition(parser, context, kind, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, context & 1
+ ? {
+ type: 'MethodDefinition',
+ kind: (kind & 32) < 1 && kind & 64
+ ? 'constructor'
+ : kind & 256
+ ? 'get'
+ : kind & 512
+ ? 'set'
+ : 'method',
+ static: (kind & 32) > 0,
+ computed: (kind & 2) > 0,
+ key,
+ decorators,
+ value
+ }
+ : {
+ type: 'MethodDefinition',
+ kind: (kind & 32) < 1 && kind & 64
+ ? 'constructor'
+ : kind & 256
+ ? 'get'
+ : kind & 512
+ ? 'set'
+ : 'method',
+ static: (kind & 32) > 0,
+ computed: (kind & 2) > 0,
+ key,
+ value
+ });
+}
+function parsePrivateIdentifier(parser, context, start, line, column) {
+ nextToken(parser, context);
+ const { tokenValue } = parser;
+ if (tokenValue === 'constructor')
+ report(parser, 124);
+ nextToken(parser, context);
+ return finishNode(parser, context, start, line, column, {
+ type: 'PrivateIdentifier',
+ name: tokenValue
+ });
+}
+function parsePropertyDefinition(parser, context, key, state, decorators, start, line, column) {
+ let value = null;
+ if (state & 8)
+ report(parser, 0);
+ if (parser.token === 1077936157) {
+ nextToken(parser, context | 32768);
+ const { tokenPos, linePos, colPos } = parser;
+ if (parser.token === 537079928)
+ report(parser, 115);
+ value = parsePrimaryExpression(parser, context | 16384, 2, 0, 1, 0, 0, 1, tokenPos, linePos, colPos);
+ if ((parser.token & 1073741824) !== 1073741824) {
+ value = parseMemberOrUpdateExpression(parser, context | 16384, value, 0, 0, tokenPos, linePos, colPos);
+ value = parseAssignmentExpression(parser, context | 16384, 0, 0, tokenPos, linePos, colPos, value);
+ if (parser.token === 18) {
+ value = parseSequenceExpression(parser, context, 0, start, line, column, value);
+ }
+ }
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'PropertyDefinition',
+ key,
+ value,
+ static: (state & 32) > 0,
+ computed: (state & 2) > 0,
+ decorators
+ });
+}
+function parseBindingPattern(parser, context, scope, type, origin, start, line, column) {
+ if (parser.token & 143360)
+ return parseAndClassifyIdentifier(parser, context, scope, type, origin, start, line, column);
+ if ((parser.token & 2097152) !== 2097152)
+ report(parser, 28, KeywordDescTable[parser.token & 255]);
+ const left = parser.token === 69271571
+ ? parseArrayExpressionOrPattern(parser, context, scope, 1, 0, 1, type, origin, start, line, column)
+ : parseObjectLiteralOrPattern(parser, context, scope, 1, 0, 1, type, origin, start, line, column);
+ if (parser.destructible & 16)
+ report(parser, 47);
+ if (parser.destructible & 32)
+ report(parser, 47);
+ return left;
+}
+function parseAndClassifyIdentifier(parser, context, scope, kind, origin, start, line, column) {
+ const { tokenValue, token } = parser;
+ if (context & 1024) {
+ if ((token & 537079808) === 537079808) {
+ report(parser, 115);
+ }
+ else if ((token & 36864) === 36864) {
+ report(parser, 114);
+ }
+ }
+ if ((token & 20480) === 20480) {
+ report(parser, 99);
+ }
+ if (context & (2048 | 2097152) && token === 241773) {
+ report(parser, 30);
+ }
+ if (token === 241739) {
+ if (kind & (8 | 16))
+ report(parser, 97);
+ }
+ if (context & (4194304 | 2048) && token === 209008) {
+ report(parser, 95);
+ }
+ nextToken(parser, context);
+ if (scope)
+ addVarOrBlock(parser, context, scope, tokenValue, kind, origin);
+ return finishNode(parser, context, start, line, column, {
+ type: 'Identifier',
+ name: tokenValue
+ });
+}
+function parseJSXRootElementOrFragment(parser, context, inJSXChild, start, line, column) {
+ nextToken(parser, context);
+ if (parser.token === 8456259) {
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXFragment',
+ openingFragment: parseOpeningFragment(parser, context, start, line, column),
+ children: parseJSXChildren(parser, context),
+ closingFragment: parseJSXClosingFragment(parser, context, inJSXChild, parser.tokenPos, parser.linePos, parser.colPos)
+ });
+ }
+ let closingElement = null;
+ let children = [];
+ const openingElement = parseJSXOpeningFragmentOrSelfCloseElement(parser, context, inJSXChild, start, line, column);
+ if (!openingElement.selfClosing) {
+ children = parseJSXChildren(parser, context);
+ closingElement = parseJSXClosingElement(parser, context, inJSXChild, parser.tokenPos, parser.linePos, parser.colPos);
+ const close = isEqualTagName(closingElement.name);
+ if (isEqualTagName(openingElement.name) !== close)
+ report(parser, 149, close);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXElement',
+ children,
+ openingElement,
+ closingElement
+ });
+}
+function parseOpeningFragment(parser, context, start, line, column) {
+ scanJSXToken(parser, context);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXOpeningFragment'
+ });
+}
+function parseJSXClosingElement(parser, context, inJSXChild, start, line, column) {
+ consume(parser, context, 25);
+ const name = parseJSXElementName(parser, context, parser.tokenPos, parser.linePos, parser.colPos);
+ if (inJSXChild) {
+ consume(parser, context, 8456259);
+ }
+ else {
+ parser.token = scanJSXToken(parser, context);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXClosingElement',
+ name
+ });
+}
+function parseJSXClosingFragment(parser, context, inJSXChild, start, line, column) {
+ consume(parser, context, 25);
+ if (inJSXChild) {
+ consume(parser, context, 8456259);
+ }
+ else {
+ consume(parser, context, 8456259);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXClosingFragment'
+ });
+}
+function parseJSXChildren(parser, context) {
+ const children = [];
+ while (parser.token !== 25) {
+ parser.index = parser.tokenPos = parser.startPos;
+ parser.column = parser.colPos = parser.startColumn;
+ parser.line = parser.linePos = parser.startLine;
+ scanJSXToken(parser, context);
+ children.push(parseJSXChild(parser, context, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ return children;
+}
+function parseJSXChild(parser, context, start, line, column) {
+ if (parser.token === 138)
+ return parseJSXText(parser, context, start, line, column);
+ if (parser.token === 2162700)
+ return parseJSXExpressionContainer(parser, context, 0, 0, start, line, column);
+ if (parser.token === 8456258)
+ return parseJSXRootElementOrFragment(parser, context, 0, start, line, column);
+ report(parser, 0);
+}
+function parseJSXText(parser, context, start, line, column) {
+ scanJSXToken(parser, context);
+ const node = {
+ type: 'JSXText',
+ value: parser.tokenValue
+ };
+ if (context & 512) {
+ node.raw = parser.tokenRaw;
+ }
+ return finishNode(parser, context, start, line, column, node);
+}
+function parseJSXOpeningFragmentOrSelfCloseElement(parser, context, inJSXChild, start, line, column) {
+ if ((parser.token & 143360) !== 143360 && (parser.token & 4096) !== 4096)
+ report(parser, 0);
+ const tagName = parseJSXElementName(parser, context, parser.tokenPos, parser.linePos, parser.colPos);
+ const attributes = parseJSXAttributes(parser, context);
+ const selfClosing = parser.token === 8457016;
+ if (parser.token === 8456259) {
+ scanJSXToken(parser, context);
+ }
+ else {
+ consume(parser, context, 8457016);
+ if (inJSXChild) {
+ consume(parser, context, 8456259);
+ }
+ else {
+ scanJSXToken(parser, context);
+ }
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXOpeningElement',
+ name: tagName,
+ attributes,
+ selfClosing
+ });
+}
+function parseJSXElementName(parser, context, start, line, column) {
+ scanJSXIdentifier(parser);
+ let key = parseJSXIdentifier(parser, context, start, line, column);
+ if (parser.token === 21)
+ return parseJSXNamespacedName(parser, context, key, start, line, column);
+ while (consumeOpt(parser, context, 67108877)) {
+ scanJSXIdentifier(parser);
+ key = parseJSXMemberExpression(parser, context, key, start, line, column);
+ }
+ return key;
+}
+function parseJSXMemberExpression(parser, context, object, start, line, column) {
+ const property = parseJSXIdentifier(parser, context, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXMemberExpression',
+ object,
+ property
+ });
+}
+function parseJSXAttributes(parser, context) {
+ const attributes = [];
+ while (parser.token !== 8457016 && parser.token !== 8456259 && parser.token !== 1048576) {
+ attributes.push(parseJsxAttribute(parser, context, parser.tokenPos, parser.linePos, parser.colPos));
+ }
+ return attributes;
+}
+function parseJSXSpreadAttribute(parser, context, start, line, column) {
+ nextToken(parser, context);
+ consume(parser, context, 14);
+ const expression = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context, 1074790415);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXSpreadAttribute',
+ argument: expression
+ });
+}
+function parseJsxAttribute(parser, context, start, line, column) {
+ if (parser.token === 2162700)
+ return parseJSXSpreadAttribute(parser, context, start, line, column);
+ scanJSXIdentifier(parser);
+ let value = null;
+ let name = parseJSXIdentifier(parser, context, start, line, column);
+ if (parser.token === 21) {
+ name = parseJSXNamespacedName(parser, context, name, start, line, column);
+ }
+ if (parser.token === 1077936157) {
+ const token = scanJSXAttributeValue(parser, context);
+ const { tokenPos, linePos, colPos } = parser;
+ switch (token) {
+ case 134283267:
+ value = parseLiteral(parser, context);
+ break;
+ case 8456258:
+ value = parseJSXRootElementOrFragment(parser, context, 1, tokenPos, linePos, colPos);
+ break;
+ case 2162700:
+ value = parseJSXExpressionContainer(parser, context, 1, 1, tokenPos, linePos, colPos);
+ break;
+ default:
+ report(parser, 148);
+ }
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXAttribute',
+ value,
+ name
+ });
+}
+function parseJSXNamespacedName(parser, context, namespace, start, line, column) {
+ consume(parser, context, 21);
+ const name = parseJSXIdentifier(parser, context, parser.tokenPos, parser.linePos, parser.colPos);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXNamespacedName',
+ namespace,
+ name
+ });
+}
+function parseJSXExpressionContainer(parser, context, inJSXChild, isAttr, start, line, column) {
+ nextToken(parser, context);
+ const { tokenPos, linePos, colPos } = parser;
+ if (parser.token === 14)
+ return parseJSXSpreadChild(parser, context, tokenPos, linePos, colPos);
+ let expression = null;
+ if (parser.token === 1074790415) {
+ if (isAttr)
+ report(parser, 151);
+ expression = parseJSXEmptyExpression(parser, context, parser.startPos, parser.startLine, parser.startColumn);
+ }
+ else {
+ expression = parseExpression(parser, context, 1, 0, 0, tokenPos, linePos, colPos);
+ }
+ if (inJSXChild) {
+ consume(parser, context, 1074790415);
+ }
+ else {
+ scanJSXToken(parser, context);
+ }
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXExpressionContainer',
+ expression
+ });
+}
+function parseJSXSpreadChild(parser, context, start, line, column) {
+ consume(parser, context, 14);
+ const expression = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
+ consume(parser, context, 1074790415);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXSpreadChild',
+ expression
+ });
+}
+function parseJSXEmptyExpression(parser, context, start, line, column) {
+ parser.startPos = parser.tokenPos;
+ parser.startLine = parser.linePos;
+ parser.startColumn = parser.colPos;
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXEmptyExpression'
+ });
+}
+function parseJSXIdentifier(parser, context, start, line, column) {
+ const { tokenValue } = parser;
+ nextToken(parser, context);
+ return finishNode(parser, context, start, line, column, {
+ type: 'JSXIdentifier',
+ name: tokenValue
+ });
+} + +var estree = /*#__PURE__*/Object.freeze({ + __proto__: null +}); + +var version$1 = "4.2.0"; + +const version = version$1;
+function parseScript(source, options) {
+ return parseSource(source, options, 0);
+}
+function parseModule(source, options) {
+ return parseSource(source, options, 1024 | 2048);
+}
+function parse(source, options) {
+ return parseSource(source, options, 0);
+} + +export { estree as ESTree, parse, parseModule, parseScript, version }; |