meriyah 4.3.1 → 4.3.3

package/dist/meriyah.amd.js

@@ -12,7 +12,7 @@ define(['exports'], (function (exports) { 'use strict';
       [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',
+      [146]: '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',
@@ -33,9 +33,9 @@ define(['exports'], (function (exports) { 'use strict';
       [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'",
+      [93]: "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',
+      [120]: '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'",
@@ -45,125 +45,126 @@ define(['exports'], (function (exports) { 'use strict';
       [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'
+      [41]: 'A setter cannot be a generator',
+      [42]: 'A computed property name must be followed by a colon or paren',
+      [131]: 'Object literal keys that are strings or numbers must be a method or have a colon',
+      [44]: 'Found `* async x(){}` but this should be `async * x(){}`',
+      [43]: 'Getters and setters can not be generators',
+      [45]: "'%0' can not be generator method",
+      [46]: "No line break is allowed after '=>'",
+      [47]: 'The left-hand side of the arrow can only be destructed through assignment',
+      [48]: 'The binding declaration is not destructible',
+      [49]: 'Async arrow can not be followed by new expression',
+      [50]: "Classes may not have a static property named 'prototype'",
+      [51]: 'Class constructor may not be a %0',
+      [52]: 'Duplicate constructor method in class',
+      [53]: 'Invalid increment/decrement operand',
+      [54]: 'Invalid use of `new` keyword on an increment/decrement expression',
+      [55]: '`=>` is an invalid assignment target',
+      [56]: 'Rest element may not have a trailing comma',
+      [57]: 'Missing initializer in %0 declaration',
+      [58]: "'for-%0' loop head declarations can not have an initializer",
+      [59]: 'Invalid left-hand side in for-%0 loop: Must have a single binding',
+      [60]: 'Invalid shorthand property initializer',
+      [61]: 'Property name __proto__ appears more than once in object literal',
+      [62]: 'Let is disallowed as a lexically bound name',
+      [63]: "Invalid use of '%0' inside new expression",
+      [64]: "Illegal 'use strict' directive in function with non-simple parameter list",
+      [65]: 'Identifier "let" disallowed as left-hand side expression in strict mode',
+      [66]: 'Illegal continue statement',
+      [67]: 'Illegal break statement',
+      [68]: 'Cannot have `let[...]` as a var name in strict mode',
+      [69]: 'Invalid destructuring assignment target',
+      [70]: 'Rest parameter may not have a default initializer',
+      [71]: 'The rest argument must the be last parameter',
+      [72]: 'Invalid rest argument',
+      [74]: 'In strict mode code, functions can only be declared at top level or inside a block',
+      [75]: 'In non-strict mode code, functions can only be declared at top level, inside a block, or as the body of an if statement',
+      [76]: 'Without web compatibility enabled functions can not be declared at top level, inside a block, or as the body of an if statement',
+      [77]: "Class declaration can't appear in single-statement context",
+      [78]: 'Invalid left-hand side in for-%0',
+      [79]: 'Invalid assignment in for-%0',
+      [80]: 'for await (... of ...) is only valid in async functions and async generators',
+      [81]: 'The first token after the template expression should be a continuation of the template',
+      [83]: '`let` declaration not allowed here and `let` cannot be a regular var name in strict mode',
+      [82]: '`let \n [` is a restricted production at the start of a statement',
+      [84]: 'Catch clause requires exactly one parameter, not more (and no trailing comma)',
+      [85]: 'Catch clause parameter does not support default values',
+      [86]: 'Missing catch or finally after try',
+      [87]: 'More than one default clause in switch statement',
+      [88]: 'Illegal newline after throw',
+      [89]: 'Strict mode code may not include a with statement',
+      [90]: 'Illegal return statement',
+      [91]: 'The left hand side of the for-header binding declaration is not destructible',
+      [92]: 'new.target only allowed within functions',
+      [94]: "'#' not followed by identifier",
+      [100]: 'Invalid keyword',
+      [99]: "Can not use 'let' as a class name",
+      [98]: "'A lexical declaration can't define a 'let' binding",
+      [97]: 'Can not use `let` as variable name in strict mode',
+      [95]: "'%0' may not be used as an identifier in this context",
+      [96]: 'Await is only valid in async functions',
+      [101]: 'The %0 keyword can only be used with the module goal',
+      [102]: 'Unicode codepoint must not be greater than 0x10FFFF',
+      [103]: '%0 source must be string',
+      [104]: 'Only a identifier can be used to indicate alias',
+      [105]: "Only '*' or '{...}' can be imported after default",
+      [106]: 'Trailing decorator may be followed by method',
+      [107]: "Decorators can't be used with a constructor",
+      [109]: 'HTML comments are only allowed with web compatibility (Annex B)',
+      [110]: "The identifier 'let' must not be in expression position in strict mode",
+      [111]: 'Cannot assign to `eval` and `arguments` in strict mode',
+      [112]: "The left-hand side of a for-of loop may not start with 'let'",
+      [113]: 'Block body arrows can not be immediately invoked without a group',
+      [114]: 'Block body arrows can not be immediately accessed without a group',
+      [115]: 'Unexpected strict mode reserved word',
+      [116]: 'Unexpected eval or arguments in strict mode',
+      [117]: 'Decorators must not be followed by a semicolon',
+      [118]: 'Calling delete on expression not allowed in strict mode',
+      [119]: 'Pattern can not have a tail',
+      [121]: 'Can not have a `yield` expression on the left side of a ternary',
+      [122]: 'An arrow function can not have a postfix update operator',
+      [123]: 'Invalid object literal key character after generator star',
+      [124]: 'Private fields can not be deleted',
+      [126]: 'Classes may not have a field called constructor',
+      [125]: 'Classes may not have a private element named constructor',
+      [127]: 'A class field initializer may not contain arguments',
+      [128]: 'Generators can only be declared at the top level or inside a block',
+      [129]: 'Async methods are a restricted production and cannot have a newline following it',
+      [130]: 'Unexpected character after object literal property name',
+      [132]: 'Invalid key token',
+      [133]: "Label '%0' has already been declared",
+      [134]: 'continue statement must be nested within an iteration statement',
+      [135]: "Undefined label '%0'",
+      [136]: 'Trailing comma is disallowed inside import(...) arguments',
+      [137]: 'import() requires exactly one argument',
+      [138]: 'Cannot use new with import(...)',
+      [139]: '... is not allowed in import()',
+      [140]: "Expected '=>'",
+      [141]: "Duplicate binding '%0'",
+      [142]: "Cannot export a duplicate name '%0'",
+      [145]: 'Duplicate %0 for-binding',
+      [143]: "Exported binding '%0' needs to refer to a top-level declared variable",
+      [144]: 'Unexpected private field',
+      [148]: 'Numeric separators are not allowed at the end of numeric literals',
+      [147]: 'Only one underscore is allowed as numeric separator',
+      [149]: 'JSX value should be either an expression or a quoted JSX text',
+      [150]: 'Expected corresponding JSX closing tag for %0',
+      [151]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+      [152]: "JSX attributes must only be assigned a non-empty 'expression'",
+      [153]: "'%0' has already been declared",
+      [154]: "'%0' shadowed a catch clause binding",
+      [155]: 'Dot property must be an identifier',
+      [156]: 'Encountered invalid input after spread/rest argument',
+      [157]: 'Catch without try',
+      [158]: 'Finally without try',
+      [159]: 'Expected corresponding closing tag for JSX fragment',
+      [160]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
+      [161]: 'Invalid tagged template on optional chain',
+      [162]: 'Invalid optional chain from super property',
+      [163]: 'Invalid optional chain from new expression',
+      [164]: 'Cannot use "import.meta" outside a module',
+      [165]: 'Leading decorators must be attached to a class declaration'
   };
   class ParseError extends SyntaxError {
       constructor(startindex, line, column, type, ...params) {
@@ -1095,7 +1096,7 @@ define(['exports'], (function (exports) { 'use strict';
           case -4:
               report(state, 6);
           case -5:
-              report(state, 101);
+              report(state, 102);
       }
   }
 
@@ -1208,7 +1209,7 @@ define(['exports'], (function (exports) { 'use strict';
                   while (CharTypes[char] & (64 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator)
-                              report(parser, 146);
+                              report(parser, 147);
                           allowSeparator = 0;
                           char = advanceChar(parser);
                           continue;
@@ -1219,7 +1220,7 @@ define(['exports'], (function (exports) { 'use strict';
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      report(parser, digits === 0 ? 19 : 147);
+                      report(parser, digits === 0 ? 19 : 148);
                   }
               }
               else if ((char | 32) === 111) {
@@ -1228,7 +1229,7 @@ define(['exports'], (function (exports) { 'use strict';
                   while (CharTypes[char] & (32 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              report(parser, 146);
+                              report(parser, 147);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1240,7 +1241,7 @@ define(['exports'], (function (exports) { 'use strict';
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      report(parser, digits === 0 ? 0 : 147);
+                      report(parser, digits === 0 ? 0 : 148);
                   }
               }
               else if ((char | 32) === 98) {
@@ -1249,7 +1250,7 @@ define(['exports'], (function (exports) { 'use strict';
                   while (CharTypes[char] & (128 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              report(parser, 146);
+                              report(parser, 147);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1261,7 +1262,7 @@ define(['exports'], (function (exports) { 'use strict';
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      report(parser, digits === 0 ? 0 : 147);
+                      report(parser, digits === 0 ? 0 : 148);
                   }
               }
               else if (CharTypes[char] & 32) {
@@ -1294,7 +1295,7 @@ define(['exports'], (function (exports) { 'use strict';
                       if (char === 95) {
                           char = advanceChar(parser);
                           if (char === 95 || kind & 32) {
-                              reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+                              reportScannerError(parser.index, parser.line, parser.index + 1, 147);
                           }
                           allowSeparator = 1;
                           continue;
@@ -1305,7 +1306,7 @@ define(['exports'], (function (exports) { 'use strict';
                       --digit;
                   }
                   if (allowSeparator) {
-                      reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+                      reportScannerError(parser.index, parser.line, parser.index + 1, 148);
                   }
                   if (digit >= 0 && !isIdentifierStart(char) && char !== 46) {
                       parser.tokenValue = value;
@@ -1370,7 +1371,7 @@ define(['exports'], (function (exports) { 'use strict';
               const { index } = parser;
               char = advanceChar(parser);
               if (char === 95) {
-                  reportScannerError(parser.index, parser.line, parser.index + 1, 146);
+                  reportScannerError(parser.index, parser.line, parser.index + 1, 147);
               }
               allowSeparator = 1;
               ret += parser.source.substring(start, index);
@@ -1381,7 +1382,7 @@ define(['exports'], (function (exports) { 'use strict';
           char = advanceChar(parser);
       }
       if (allowSeparator) {
-          reportScannerError(parser.index, parser.line, parser.index + 1, 147);
+          reportScannerError(parser.index, parser.line, parser.index + 1, 148);
       }
       return ret + parser.source.substring(start, parser.index);
   }
@@ -1470,7 +1471,7 @@ define(['exports'], (function (exports) { 'use strict';
   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
+      return parser.currentChar !== 92 && parser.currentChar <= 0x7e
           ? descKeywordTable[parser.tokenValue] || 208897
           : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
   }
@@ -1557,7 +1558,7 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function scanPrivateIdentifier(parser) {
       if (!isIdentifierStart(advanceChar(parser)))
-          report(parser, 93);
+          report(parser, 94);
       return 131;
   }
   function scanIdentifierUnicodeEscape(parser) {
@@ -1575,7 +1576,7 @@ define(['exports'], (function (exports) { 'use strict';
           while (CharTypes[advanceChar(parser)] & 64) {
               codePoint = (codePoint << 4) | toHex(parser.currentChar);
               if (codePoint > 1114111)
-                  reportScannerError(begin, parser.line, parser.index + 1, 101);
+                  reportScannerError(begin, parser.line, parser.index + 1, 102);
           }
           if (parser.currentChar !== 125) {
               reportScannerError(begin, parser.line, parser.index - 1, 6);
@@ -1916,7 +1917,7 @@ define(['exports'], (function (exports) { 'use strict';
                           advanceChar(parser);
                           if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
                               if ((context & 256) === 0)
-                                  report(parser, 108);
+                                  report(parser, 109);
                               advanceChar(parser);
                               state = skipSingleHTMLComment(parser, source, state, context, 3, startPos, startLine, startColumn);
                               startPos = parser.tokenPos;
@@ -4412,7 +4413,7 @@ define(['exports'], (function (exports) { 'use strict';
           case 'AssignmentExpression':
               node.type = 'AssignmentPattern';
               if (node.operator !== '=')
-                  report(state, 68);
+                  report(state, 69);
               delete node.operator;
               reinterpretToPattern(state, node.left);
               return;
@@ -4427,58 +4428,58 @@ define(['exports'], (function (exports) { 'use strict';
   function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
       if (context & 1024) {
           if ((t & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
       }
       if ((t & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (kind & (8 | 16) && t === 241739) {
-          report(parser, 97);
+          report(parser, 98);
       }
       if (context & (4194304 | 2048) && t === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       if (context & (2097152 | 1024) && t === 241773) {
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       }
   }
   function validateFunctionName(parser, context, t) {
       if (context & 1024) {
           if ((t & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if ((t & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
           if (t === 122) {
-              report(parser, 92);
+              report(parser, 93);
           }
           if (t === 121) {
-              report(parser, 92);
+              report(parser, 93);
           }
       }
       if ((t & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (context & (4194304 | 2048) && t === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       if (context & (2097152 | 1024) && t === 241773) {
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       }
   }
   function isStrictReservedWord(parser, context, t) {
       if (t === 209008) {
           if (context & (4194304 | 2048))
-              report(parser, 95);
+              report(parser, 96);
           parser.destructible |= 128;
       }
       if (t === 241773 && context & 2097152)
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       return ((t & 20480) === 20480 ||
           (t & 36864) === 36864 ||
           t == 122);
@@ -4490,7 +4491,7 @@ define(['exports'], (function (exports) { 'use strict';
       while (labels) {
           if (labels['$' + name]) {
               if (isIterationStatement)
-                  report(parser, 133);
+                  report(parser, 134);
               return 1;
           }
           if (isIterationStatement && labels.loop)
@@ -4503,7 +4504,7 @@ define(['exports'], (function (exports) { 'use strict';
       let set = labels;
       while (set) {
           if (set['$' + name])
-              report(parser, 132, name);
+              report(parser, 133, name);
           set = set['$'];
       }
       labels['$' + name] = 1;
@@ -4584,27 +4585,27 @@ define(['exports'], (function (exports) { 'use strict';
       const value = scope['#' + name];
       if (value && (value & 2) === 0) {
           if (kind & 1) {
-              scope.scopeError = recordScopeError(parser, 140, name);
+              scope.scopeError = recordScopeError(parser, 141, name);
           }
           else if (context & 256 &&
               value & 64 &&
               origin & 2) ;
           else {
-              report(parser, 140, name);
+              report(parser, 141, name);
           }
       }
       if (scope.type & 128 &&
           (scope.parent['#' + name] && (scope.parent['#' + name] & 2) === 0)) {
-          report(parser, 140, name);
+          report(parser, 141, name);
       }
       if (scope.type & 1024 && value && (value & 2) === 0) {
           if (kind & 1) {
-              scope.scopeError = recordScopeError(parser, 140, name);
+              scope.scopeError = recordScopeError(parser, 141, name);
           }
       }
       if (scope.type & 64) {
           if (scope.parent['#' + name] & 768)
-              report(parser, 153, name);
+              report(parser, 154, name);
       }
       scope['#' + name] = kind;
   }
@@ -4618,19 +4619,19 @@ define(['exports'], (function (exports) { 'use strict';
                   ((kind & 128 && value & 68) ||
                       (value & 128 && kind & 68))) ;
               else {
-                  report(parser, 140, name);
+                  report(parser, 141, name);
               }
           }
           if (currentScope === scope) {
               if (value & 1 && kind & 1) {
-                  currentScope.scopeError = recordScopeError(parser, 140, name);
+                  currentScope.scopeError = recordScopeError(parser, 141, name);
               }
           }
           if (value & (512 | 256)) {
               if ((value & 512) === 0 ||
                   (context & 256) === 0 ||
                   context & 1024) {
-                  report(parser, 140, name);
+                  report(parser, 141, name);
               }
           }
           currentScope['#' + name] = kind;
@@ -4640,7 +4641,7 @@ define(['exports'], (function (exports) { 'use strict';
   function declareUnboundVariable(parser, name) {
       if (parser.exportedNames !== void 0 && name !== '') {
           if (parser.exportedNames['#' + name]) {
-              report(parser, 141, name);
+              report(parser, 142, name);
           }
           parser.exportedNames['#' + name] = 1;
       }
@@ -4698,7 +4699,7 @@ define(['exports'], (function (exports) { 'use strict';
   function classifyIdentifier(parser, context, t, isArrow) {
       if ((t & 537079808) === 537079808) {
           if (context & 1024)
-              report(parser, 115);
+              report(parser, 116);
           if (isArrow)
               parser.flags |= 512;
       }
@@ -4791,7 +4792,7 @@ define(['exports'], (function (exports) { 'use strict';
           if (scope) {
               for (const key in parser.exportedBindings) {
                   if (key[0] === '#' && !scope[key])
-                      report(parser, 142, key.slice(1));
+                      report(parser, 143, key.slice(1));
               }
           }
       }
@@ -4861,7 +4862,7 @@ define(['exports'], (function (exports) { 'use strict';
               moduleItem = parseStatementListItem(parser, context, scope, 4, {});
       }
       if (parser.leadingDecorators.length) {
-          report(parser, 164);
+          report(parser, 165);
       }
       return moduleItem;
   }
@@ -4880,7 +4881,7 @@ define(['exports'], (function (exports) { 'use strict';
           case 241739:
               return parseLetIdentOrVarDeclarationStatement(parser, context, scope, origin, start, line, column);
           case 20566:
-              report(parser, 100, 'export');
+              report(parser, 101, 'export');
           case 86108:
               nextToken(parser, context);
               switch (parser.token) {
@@ -4889,7 +4890,7 @@ define(['exports'], (function (exports) { 'use strict';
                   case 67108877:
                       return parseImportMetaDeclaration(parser, context, start, line, column);
                   default:
-                      report(parser, 100, 'import');
+                      report(parser, 101, 'import');
               }
           case 209007:
               return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 1, start, line, column);
@@ -4932,17 +4933,17 @@ define(['exports'], (function (exports) { 'use strict';
           case 209007:
               return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origin, labels, 0, start, line, column);
           case 20559:
-              report(parser, 156);
-          case 20568:
               report(parser, 157);
+          case 20568:
+              report(parser, 158);
           case 86106:
               report(parser, context & 1024
-                  ? 73
+                  ? 74
                   : (context & 256) === 0
-                      ? 75
-                      : 74);
+                      ? 76
+                      : 75);
           case 86096:
-              report(parser, 76);
+              report(parser, 77);
           default:
               return parseExpressionOrLabelledStatement(parser, context, scope, origin, labels, allowFuncDecl, start, line, column);
       }
@@ -4954,9 +4955,9 @@ define(['exports'], (function (exports) { 'use strict';
           case 241739:
               expr = parseIdentifier(parser, context, 0);
               if (context & 1024)
-                  report(parser, 82);
+                  report(parser, 83);
               if (parser.token === 69271571)
-                  report(parser, 81);
+                  report(parser, 82);
               break;
           default:
               expr = parsePrimaryExpression(parser, context, 2, 0, 1, 0, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
@@ -4985,7 +4986,7 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseReturnStatement(parser, context, start, line, column) {
       if ((context & 32) === 0 && context & 8192)
-          report(parser, 89);
+          report(parser, 90);
       nextToken(parser, context | 32768);
       const argument = parser.flags & 1 || parser.token & 1048576
           ? null
@@ -5029,7 +5030,7 @@ define(['exports'], (function (exports) { 'use strict';
       if (!asyncNewLine) {
           if (parser.token === 86106) {
               if (!allowFuncDecl)
-                  report(parser, 119);
+                  report(parser, 120);
               return parseFunctionDeclaration(parser, context, scope, origin, 1, 0, 1, start, line, column);
           }
           if ((parser.token & 143360) === 143360) {
@@ -5088,7 +5089,7 @@ define(['exports'], (function (exports) { 'use strict';
   function parseThrowStatement(parser, context, start, line, column) {
       nextToken(parser, context | 32768);
       if (parser.flags & 1)
-          report(parser, 87);
+          report(parser, 88);
       const argument = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5142,7 +5143,7 @@ define(['exports'], (function (exports) { 'use strict';
           else {
               consume(parser, context | 32768, 20563);
               if (seenDefault)
-                  report(parser, 86);
+                  report(parser, 87);
               seenDefault = 1;
           }
           consume(parser, context | 32768, 21);
@@ -5183,14 +5184,14 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseContinueStatement(parser, context, labels, start, line, column) {
       if ((context & 131072) === 0)
-          report(parser, 65);
+          report(parser, 66);
       nextToken(parser, context);
       let label = null;
       if ((parser.flags & 1) === 0 && parser.token & 143360) {
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32768, 0);
           if (!isValidLabel(parser, labels, tokenValue, 1))
-              report(parser, 134, tokenValue);
+              report(parser, 135, tokenValue);
       }
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5205,10 +5206,10 @@ define(['exports'], (function (exports) { 'use strict';
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32768, 0);
           if (!isValidLabel(parser, labels, tokenValue, 0))
-              report(parser, 134, tokenValue);
+              report(parser, 135, tokenValue);
       }
       else if ((context & (4096 | 131072)) === 0) {
-          report(parser, 66);
+          report(parser, 67);
       }
       matchOrInsertSemicolon(parser, context | 32768);
       return finishNode(parser, context, start, line, column, {
@@ -5219,7 +5220,7 @@ define(['exports'], (function (exports) { 'use strict';
   function parseWithStatement(parser, context, scope, labels, start, line, column) {
       nextToken(parser, context);
       if (context & 1024)
-          report(parser, 88);
+          report(parser, 89);
       consume(parser, context | 32768, 67174411);
       const object = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
       consume(parser, context | 32768, 16);
@@ -5252,7 +5253,7 @@ define(['exports'], (function (exports) { 'use strict';
           finalizer = parseBlock(parser, context, finalizerScope, { $: labels }, parser.tokenPos, parser.linePos, parser.colPos);
       }
       if (!handler && !finalizer) {
-          report(parser, 85);
+          report(parser, 86);
       }
       return finishNode(parser, context, start, line, column, {
           type: 'TryStatement',
@@ -5271,10 +5272,10 @@ define(['exports'], (function (exports) { 'use strict';
               ? 256
               : 512, 0, parser.tokenPos, parser.linePos, parser.colPos);
           if (parser.token === 18) {
-              report(parser, 83);
+              report(parser, 84);
           }
           else if (parser.token === 1077936157) {
-              report(parser, 84);
+              report(parser, 85);
           }
           consume(parser, context | 32768, 16);
           if (scope)
@@ -5326,7 +5327,7 @@ define(['exports'], (function (exports) { 'use strict';
       }
       parser.assignable = 1;
       if (context & 1024)
-          report(parser, 82);
+          report(parser, 83);
       if (parser.token === 21) {
           return parseLabelledStatement(parser, context, scope, origin, {}, tokenValue, expr, token, 0, start, line, column);
       }
@@ -5374,7 +5375,7 @@ define(['exports'], (function (exports) { 'use strict';
           list.push(parseVariableDeclaration(parser, context, scope, kind, origin));
       }
       if (bindingCount > 1 && origin & 32 && parser.token & 262144) {
-          report(parser, 58, KeywordDescTable[parser.token & 255]);
+          report(parser, 59, KeywordDescTable[parser.token & 255]);
       }
       return list;
   }
@@ -5389,13 +5390,13 @@ define(['exports'], (function (exports) { 'use strict';
               if (parser.token === 274549 ||
                   (parser.token === 8738868 &&
                       (token & 2097152 || (kind & 4) === 0 || context & 1024))) {
-                  reportMessageAt(tokenPos, parser.line, parser.index - 3, 57, parser.token === 274549 ? 'of' : 'in');
+                  reportMessageAt(tokenPos, parser.line, parser.index - 3, 58, parser.token === 274549 ? 'of' : 'in');
               }
           }
       }
       else if ((kind & 16 || (token & 2097152) > 0) &&
           (parser.token & 262144) !== 262144) {
-          report(parser, 56, kind & 16 ? 'const' : 'destructuring');
+          report(parser, 57, kind & 16 ? 'const' : 'destructuring');
       }
       return finishNode(parser, context, tokenPos, linePos, colPos, {
           type: 'VariableDeclarator',
@@ -5423,7 +5424,7 @@ define(['exports'], (function (exports) { 'use strict';
               if (parser.token & (143360 | 2097152)) {
                   if (parser.token === 8738868) {
                       if (context & 1024)
-                          report(parser, 64);
+                          report(parser, 65);
                   }
                   else {
                       init = finishNode(parser, context, tokenPos, linePos, colPos, {
@@ -5435,14 +5436,14 @@ define(['exports'], (function (exports) { 'use strict';
                   parser.assignable = 1;
               }
               else if (context & 1024) {
-                  report(parser, 64);
+                  report(parser, 65);
               }
               else {
                   isVarDecl = false;
                   parser.assignable = 1;
                   init = parseMemberOrUpdateExpression(parser, context, init, 0, 0, tokenPos, linePos, colPos);
                   if (parser.token === 274549)
-                      report(parser, 111);
+                      report(parser, 112);
               }
           }
           else {
@@ -5463,7 +5464,7 @@ define(['exports'], (function (exports) { 'use strict';
       }
       else if (token === 1074790417) {
           if (forAwait)
-              report(parser, 79);
+              report(parser, 80);
       }
       else if ((token & 2097152) === 2097152) {
           init =
@@ -5472,7 +5473,7 @@ define(['exports'], (function (exports) { 'use strict';
                   : parseArrayExpressionOrPattern(parser, context, void 0, 1, 0, 0, 2, 32, tokenPos, linePos, colPos);
           destructible = parser.destructible;
           if (context & 256 && destructible & 64) {
-              report(parser, 60);
+              report(parser, 61);
           }
           parser.assignable =
               destructible & 16 ? 2 : 1;
@@ -5484,7 +5485,7 @@ define(['exports'], (function (exports) { 'use strict';
       if ((parser.token & 262144) === 262144) {
           if (parser.token === 274549) {
               if (parser.assignable & 2)
-                  report(parser, 77, forAwait ? 'await' : 'of');
+                  report(parser, 78, forAwait ? 'await' : 'of');
               reinterpretToPattern(parser, init);
               nextToken(parser, context | 32768);
               right = parseExpression(parser, context, 1, 0, 0, parser.tokenPos, parser.linePos, parser.colPos);
@@ -5499,11 +5500,11 @@ define(['exports'], (function (exports) { 'use strict';
               });
           }
           if (parser.assignable & 2)
-              report(parser, 77, 'in');
+              report(parser, 78, 'in');
           reinterpretToPattern(parser, init);
           nextToken(parser, context | 32768);
           if (forAwait)
-              report(parser, 79);
+              report(parser, 80);
           right = parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos);
           consume(parser, context | 32768, 16);
           const body = parseIterationStatementBody(parser, context, scope, labels);
@@ -5515,10 +5516,10 @@ define(['exports'], (function (exports) { 'use strict';
           });
       }
       if (forAwait)
-          report(parser, 79);
+          report(parser, 80);
       if (!isVarDecl) {
           if (destructible & 8 && parser.token !== 1077936157) {
-              report(parser, 77, 'loop');
+              report(parser, 78, 'loop');
           }
           init = parseAssignmentExpression(parser, context | 134217728, 0, 0, tokenPos, linePos, colPos, init);
       }
@@ -5542,9 +5543,9 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseRestrictedIdentifier(parser, context, scope) {
       if (!isValidIdentifier(context, parser.token))
-          report(parser, 114);
-      if ((parser.token & 537079808) === 537079808)
           report(parser, 115);
+      if ((parser.token & 537079808) === 537079808)
+          report(parser, 116);
       if (scope)
           addBlockName(parser, context, scope, parser.tokenValue, 8, 0);
       return parseIdentifier(parser, context, 0);
@@ -5578,7 +5579,7 @@ define(['exports'], (function (exports) { 'use strict';
                           parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
                           break;
                       default:
-                          report(parser, 104);
+                          report(parser, 105);
                   }
               }
           }
@@ -5622,7 +5623,7 @@ define(['exports'], (function (exports) { 'use strict';
   function parseModuleSpecifier(parser, context) {
       consumeOpt(parser, context, 12404);
       if (parser.token !== 134283267)
-          report(parser, 102, 'Import');
+          report(parser, 103, 'Import');
       return parseLiteral(parser, context);
   }
   function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
@@ -5633,7 +5634,7 @@ define(['exports'], (function (exports) { 'use strict';
           let local;
           if (consumeOpt(parser, context, 77934)) {
               if ((parser.token & 134217728) === 134217728 || parser.token === 18) {
-                  report(parser, 103);
+                  report(parser, 104);
               }
               else {
                   validateBindingIdentifier(parser, context, 16, parser.token, 0);
@@ -5737,7 +5738,7 @@ define(['exports'], (function (exports) { 'use strict';
               }
               consume(parser, context, 12404);
               if (parser.token !== 134283267)
-                  report(parser, 102, 'Export');
+                  report(parser, 103, 'Export');
               source = parseLiteral(parser, context);
               matchOrInsertSemicolon(parser, context | 32768);
               return finishNode(parser, context, start, line, column, {
@@ -5757,7 +5758,7 @@ define(['exports'], (function (exports) { 'use strict';
                   if (parser.token === 77934) {
                       nextToken(parser, context);
                       if ((parser.token & 134217728) === 134217728) {
-                          report(parser, 103);
+                          report(parser, 104);
                       }
                       if (scope) {
                           tmpExportedNames.push(parser.tokenValue);
@@ -5783,7 +5784,7 @@ define(['exports'], (function (exports) { 'use strict';
               consume(parser, context, 1074790415);
               if (consumeOpt(parser, context, 12404)) {
                   if (parser.token !== 134283267)
-                      report(parser, 102, 'Export');
+                      report(parser, 103, 'Export');
                   source = parseLiteral(parser, context);
               }
               else if (scope) {
@@ -5932,7 +5933,7 @@ define(['exports'], (function (exports) { 'use strict';
           t = parser.token;
           prec = t & 3840;
           if ((t & 524288 && operator & 268435456) || (operator & 524288 && t & 268435456)) {
-              report(parser, 159);
+              report(parser, 160);
           }
           if (prec + ((t === 8457273) << 8) - ((bit === t) << 12) <= minPrec)
               break;
@@ -5958,10 +5959,10 @@ define(['exports'], (function (exports) { 'use strict';
           report(parser, 31);
       if (context & 1024 && unaryOperator === 16863278) {
           if (arg.type === 'Identifier') {
-              report(parser, 117);
+              report(parser, 118);
           }
           else if (isPropertyWithPrivateFieldKey(arg)) {
-              report(parser, 123);
+              report(parser, 124);
           }
       }
       parser.assignable = 2;
@@ -5992,7 +5993,7 @@ define(['exports'], (function (exports) { 'use strict';
       if (parser.token === 10) {
           classifyIdentifier(parser, context, token, 1);
           if (inNew)
-              report(parser, 48);
+              report(parser, 49);
           return parseArrowFromIdentifier(parser, context, parser.tokenValue, expr, inNew, canAssign, 0, start, line, column);
       }
       return expr;
@@ -6007,7 +6008,7 @@ define(['exports'], (function (exports) { 'use strict';
           if (!canAssign)
               report(parser, 24);
           if (parser.token === 22)
-              report(parser, 120);
+              report(parser, 121);
           let argument = null;
           let delegate = false;
           if ((parser.flags & 1) === 0) {
@@ -6024,7 +6025,7 @@ define(['exports'], (function (exports) { 'use strict';
           });
       }
       if (context & 1024)
-          report(parser, 94, 'yield');
+          report(parser, 95, 'yield');
       return parseIdentifierOrArrow(parser, context, start, line, column);
   }
   function parseAwaitExpression(parser, context, inNew, inGroup, start, line, column) {
@@ -6047,7 +6048,7 @@ define(['exports'], (function (exports) { 'use strict';
           });
       }
       if (context & 2048)
-          report(parser, 95);
+          report(parser, 96);
       return parseIdentifierOrArrow(parser, context, start, line, column);
   }
   function parseFunctionBody(parser, context, scope, origin, firstRestricted, scopeError) {
@@ -6062,7 +6063,7 @@ define(['exports'], (function (exports) { 'use strict';
               if (isValidStrictMode(parser, index, tokenPos, tokenValue)) {
                   context |= 1024;
                   if (parser.flags & 128) {
-                      reportMessageAt(parser.index, parser.line, parser.tokenPos, 63);
+                      reportMessageAt(parser.index, parser.line, parser.tokenPos, 64);
                   }
                   if (parser.flags & 64) {
                       reportMessageAt(parser.index, parser.line, parser.tokenPos, 8);
@@ -6073,16 +6074,16 @@ define(['exports'], (function (exports) { 'use strict';
           if (context & 1024) {
               if (firstRestricted) {
                   if ((firstRestricted & 537079808) === 537079808) {
-                      report(parser, 115);
+                      report(parser, 116);
                   }
                   if ((firstRestricted & 36864) === 36864) {
                       report(parser, 38);
                   }
               }
               if (parser.flags & 512)
-                  report(parser, 115);
+                  report(parser, 116);
               if (parser.flags & 256)
-                  report(parser, 114);
+                  report(parser, 115);
           }
           if (context & 64 &&
               scope &&
@@ -6112,7 +6113,7 @@ define(['exports'], (function (exports) { 'use strict';
       nextToken(parser, context);
       switch (parser.token) {
           case 67108991:
-              report(parser, 161);
+              report(parser, 162);
           case 67174411: {
               if ((context & 524288) === 0)
                   report(parser, 26);
@@ -6141,7 +6142,7 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseUpdateExpression(parser, context, expr, start, line, column) {
       if (parser.assignable & 2)
-          report(parser, 52);
+          report(parser, 53);
       const { token } = parser;
       nextToken(parser, context);
       parser.assignable = 2;
@@ -6224,7 +6225,7 @@ define(['exports'], (function (exports) { 'use strict';
               }
               default:
                   if ((parser.flags & 2048) === 2048) {
-                      report(parser, 160);
+                      report(parser, 161);
                   }
                   parser.assignable = 2;
                   expr = finishNode(parser, context, start, line, column, {
@@ -6281,7 +6282,7 @@ define(['exports'], (function (exports) { 'use strict';
       }
       else {
           if ((parser.token & (143360 | 4096)) === 0)
-              report(parser, 154);
+              report(parser, 155);
           const property = parseIdentifier(parser, context, 0);
           parser.assignable = 2;
           node = finishNode(parser, context, start, line, column, {
@@ -6299,7 +6300,7 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parsePropertyOrPrivatePropertyName(parser, context) {
       if ((parser.token & (143360 | 4096)) === 0 && parser.token !== 131) {
-          report(parser, 154);
+          report(parser, 155);
       }
       return context & 1 && parser.token === 131
           ? parsePrivateIdentifier(parser, context, parser.tokenPos, parser.linePos, parser.colPos)
@@ -6307,14 +6308,14 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseUpdateExpressionPrefixed(parser, context, inNew, isLHS, start, line, column) {
       if (inNew)
-          report(parser, 53);
+          report(parser, 54);
       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);
+          report(parser, 53);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -6343,12 +6344,12 @@ define(['exports'], (function (exports) { 'use strict';
               return parseArrowFromIdentifier(parser, context, tokenValue, expr, inNew, canAssign, 0, start, line, column);
           }
           if (context & 16384 && token === 537079928)
-              report(parser, 126);
+              report(parser, 127);
           if (token === 241739) {
               if (context & 1024)
-                  report(parser, 109);
+                  report(parser, 110);
               if (kind & (8 | 16))
-                  report(parser, 97);
+                  report(parser, 98);
           }
           parser.assignable =
               context & 1024 && (token & 537079808) === 537079808
@@ -6419,14 +6420,14 @@ define(['exports'], (function (exports) { 'use strict';
           return parseImportMetaExpression(parser, context, expr, start, line, column);
       }
       if (inNew)
-          report(parser, 137);
+          report(parser, 138);
       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);
+          report(parser, 164);
       nextToken(parser, context);
       if (parser.token !== 143495 && parser.tokenValue !== 'meta')
           report(parser, 28, KeywordDescTable[parser.token & 255]);
@@ -6440,7 +6441,7 @@ define(['exports'], (function (exports) { 'use strict';
   function parseImportExpression(parser, context, inGroup, start, line, column) {
       consume(parser, context | 32768, 67174411);
       if (parser.token === 14)
-          report(parser, 138);
+          report(parser, 139);
       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, {
@@ -6485,14 +6486,14 @@ define(['exports'], (function (exports) { 'use strict';
       ];
       const expressions = [parseExpressions(parser, context, 0, 1, parser.tokenPos, parser.linePos, parser.colPos)];
       if (parser.token !== 1074790415)
-          report(parser, 80);
+          report(parser, 81);
       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);
+              report(parser, 81);
       }
       {
           const { tokenValue, tokenRaw, tokenPos, linePos, colPos } = parser;
@@ -6708,10 +6709,10 @@ define(['exports'], (function (exports) { 'use strict';
   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);
+          report(parser, 61);
       }
       if (parser.destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       return expr;
   }
@@ -6806,7 +6807,7 @@ define(['exports'], (function (exports) { 'use strict';
                       }
                   }
                   else if (parser.destructible & 8) {
-                      report(parser, 68);
+                      report(parser, 69);
                   }
                   else {
                       left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
@@ -6905,7 +6906,7 @@ define(['exports'], (function (exports) { 'use strict';
           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);
+                  report(parser, 69);
               destructible |= 16;
               argument = parseAssignmentExpression(parser, context, inGroup, isPattern, tokenPos, linePos, colPos, argument);
           }
@@ -6932,7 +6933,7 @@ define(['exports'], (function (exports) { 'use strict';
           token = parser.token;
           if (token !== 1077936157 && token !== closingToken && token !== 18) {
               if (parser.destructible & 8)
-                  report(parser, 68);
+                  report(parser, 69);
               argument = parseMemberOrUpdateExpression(parser, context, argument, inGroup, 0, tokenPos, linePos, colPos);
               destructible |= parser.assignable & 2 ? 16 : 0;
               if ((parser.token & 4194304) === 4194304) {
@@ -6982,7 +6983,7 @@ define(['exports'], (function (exports) { 'use strict';
           }
           parser.destructible = destructible;
           if (parser.token !== closingToken && parser.token !== 18)
-              report(parser, 155);
+              report(parser, 156);
           return finishNode(parser, context, start, line, column, {
               type: isPattern ? 'RestElement' : 'SpreadElement',
               argument: argument
@@ -7043,10 +7044,10 @@ define(['exports'], (function (exports) { 'use strict';
   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);
+          report(parser, 61);
       }
       if (parser.destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       return expr;
   }
@@ -7163,7 +7164,7 @@ define(['exports'], (function (exports) { 'use strict';
                                   destructible |= 16;
                           }
                           else if (parser.destructible & 8) {
-                              report(parser, 68);
+                              report(parser, 69);
                           }
                           else {
                               value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7223,10 +7224,10 @@ define(['exports'], (function (exports) { 'use strict';
                   else if (parser.token & (143360 | 4096)) {
                       destructible |= 16;
                       if (token === 121)
-                          report(parser, 92);
+                          report(parser, 93);
                       if (token === 209007) {
                           if (parser.flags & 1)
-                              report(parser, 128);
+                              report(parser, 129);
                           state |= 16;
                       }
                       key = parseIdentifier(parser, context, 0);
@@ -7245,11 +7246,14 @@ define(['exports'], (function (exports) { 'use strict';
                   }
                   else if (parser.token === 8457014) {
                       destructible |= 16;
-                      if (token === 12402 || token === 12403) {
+                      if (token === 12402) {
                           report(parser, 40);
                       }
+                      else if (token === 12403) {
+                          report(parser, 41);
+                      }
                       else if (token === 143483) {
-                          report(parser, 92);
+                          report(parser, 93);
                       }
                       nextToken(parser, context);
                       state |=
@@ -7284,7 +7288,7 @@ define(['exports'], (function (exports) { 'use strict';
                       value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                   }
                   else {
-                      report(parser, 129);
+                      report(parser, 130);
                   }
               }
               else if ((parser.token & 134217728) === 134217728) {
@@ -7385,7 +7389,7 @@ define(['exports'], (function (exports) { 'use strict';
                       destructible = parser.assignable | 16;
                   }
                   else {
-                      report(parser, 130);
+                      report(parser, 131);
                   }
               }
               else if (parser.token === 69271571) {
@@ -7442,7 +7446,7 @@ define(['exports'], (function (exports) { 'use strict';
                                   destructible |= 16;
                           }
                           else if (destructible & 8) {
-                              report(parser, 59);
+                              report(parser, 60);
                           }
                           else {
                               value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7494,7 +7498,7 @@ define(['exports'], (function (exports) { 'use strict';
                       destructible = 16;
                   }
                   else {
-                      report(parser, 41);
+                      report(parser, 42);
                   }
               }
               else if (token === 8457014) {
@@ -7510,10 +7514,10 @@ define(['exports'], (function (exports) { 'use strict';
                       }
                       else {
                           reportMessageAt(index, line, index, token === 209007
-                              ? 43
+                              ? 44
                               : token === 12402 || parser.token === 12403
-                                  ? 42
-                                  : 44, KeywordDescTable[token & 255]);
+                                  ? 43
+                                  : 45, KeywordDescTable[token & 255]);
                       }
                   }
                   else if ((parser.token & 134217728) === 134217728) {
@@ -7529,7 +7533,7 @@ define(['exports'], (function (exports) { 'use strict';
                       value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                   }
                   else {
-                      report(parser, 122);
+                      report(parser, 123);
                   }
               }
               else {
@@ -7611,7 +7615,7 @@ define(['exports'], (function (exports) { 'use strict';
               }
               isSimpleParameterList = 1;
               if (parser.destructible & (32 | 16))
-                  report(parser, 47);
+                  report(parser, 48);
           }
           if (parser.token === 1077936157) {
               nextToken(parser, context | 32768);
@@ -7703,7 +7707,7 @@ define(['exports'], (function (exports) { 'use strict';
               parser.assignable = 2;
               if (parser.token !== 16 && parser.token !== 18) {
                   if (destructible & 8)
-                      report(parser, 118);
+                      report(parser, 119);
                   expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
                   destructible |= 16;
                   if (parser.token !== 16 && parser.token !== 18) {
@@ -7714,7 +7718,7 @@ define(['exports'], (function (exports) { 'use strict';
           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);
+                  report(parser, 72);
               isSimpleParameterList = 1;
               if (isSequence && (parser.token === 16 || parser.token === 18)) {
                   expressions.push(expr);
@@ -7771,7 +7775,7 @@ define(['exports'], (function (exports) { 'use strict';
       }
       consume(parser, context, 16);
       if (destructible & 16 && destructible & 8)
-          report(parser, 145);
+          report(parser, 146);
       destructible |=
           parser.destructible & 256
               ? 256
@@ -7780,7 +7784,7 @@ define(['exports'], (function (exports) { 'use strict';
                   : 0;
       if (parser.token === 10) {
           if (destructible & (32 | 16))
-              report(parser, 46);
+              report(parser, 47);
           if (context & (4194304 | 2048) && destructible & 128)
               report(parser, 29);
           if (context & (1024 | 2097152) && destructible & 256) {
@@ -7791,7 +7795,7 @@ define(['exports'], (function (exports) { 'use strict';
           return parseParenthesizedArrow(parser, context, scope, isSequence ? expressions : [expr], canAssign, 0, start, line, column);
       }
       else if (destructible & 8) {
-          report(parser, 139);
+          report(parser, 140);
       }
       parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
       return context & 128
@@ -7816,23 +7820,23 @@ define(['exports'], (function (exports) { 'use strict';
   }
   function parseArrowFromIdentifier(parser, context, value, expr, inNew, canAssign, isAsync, start, line, column) {
       if (!canAssign)
-          report(parser, 54);
+          report(parser, 55);
       if (inNew)
-          report(parser, 48);
+          report(parser, 49);
       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);
+          report(parser, 55);
       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);
+          report(parser, 46);
       consume(parser, context | 32768, 10);
       context = ((context | 15728640) ^ 15728640) | (isAsync << 22);
       const expression = parser.token !== 2162700;
@@ -7851,16 +7855,16 @@ define(['exports'], (function (exports) { 'use strict';
           switch (parser.token) {
               case 69271571:
                   if ((parser.flags & 1) === 0) {
-                      report(parser, 112);
+                      report(parser, 113);
                   }
                   break;
               case 67108877:
               case 67174409:
               case 22:
-                  report(parser, 113);
+                  report(parser, 114);
               case 67174411:
                   if ((parser.flags & 1) === 0) {
-                      report(parser, 112);
+                      report(parser, 113);
                   }
                   parser.flags |= 1024;
                   break;
@@ -7868,7 +7872,7 @@ define(['exports'], (function (exports) { 'use strict';
           if ((parser.token & 8454144) === 8454144 && (parser.flags & 1) === 0)
               report(parser, 28, KeywordDescTable[parser.token & 255]);
           if ((parser.token & 33619968) === 33619968)
-              report(parser, 121);
+              report(parser, 122);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -7916,7 +7920,7 @@ define(['exports'], (function (exports) { 'use strict';
               }
               isSimpleParameterList = 1;
               if (parser.destructible & (32 | 16)) {
-                  report(parser, 47);
+                  report(parser, 48);
               }
           }
           if (parser.token === 1077936157) {
@@ -7992,16 +7996,16 @@ define(['exports'], (function (exports) { 'use strict';
               parser.assignable = 2;
               return parseMetaProperty(parser, context, id, start, line, column);
           }
-          report(parser, 91);
+          report(parser, 92);
       }
       parser.assignable = 2;
       if ((parser.token & 16842752) === 16842752) {
-          report(parser, 62, KeywordDescTable[parser.token & 255]);
+          report(parser, 63, 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);
+          report(parser, 163);
       const callee = parseMembeExpressionNoCall(parser, context, expr, inGroup, tokenPos, linePos, colPos);
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -8036,7 +8040,7 @@ define(['exports'], (function (exports) { 'use strict';
       if (consumeOpt(parser, context, 16)) {
           if (parser.token === 10) {
               if (flags & 1)
-                  report(parser, 45);
+                  report(parser, 46);
               return parseParenthesizedArrow(parser, context, scope, [], canAssign, 1, start, line, column);
           }
           return finishNode(parser, context, start, line, column, {
@@ -8092,7 +8096,7 @@ define(['exports'], (function (exports) { 'use strict';
               isSimpleParameterList = 1;
               if (parser.token !== 16 && parser.token !== 18) {
                   if (destructible & 8)
-                      report(parser, 118);
+                      report(parser, 119);
                   expr = parseMemberOrUpdateExpression(parser, context, expr, 0, 0, tokenPos, linePos, colPos);
                   destructible |= 16;
                   if ((parser.token & 8454144) === 8454144) {
@@ -8140,7 +8144,7 @@ define(['exports'], (function (exports) { 'use strict';
           if (destructible & (32 | 16))
               report(parser, 25);
           if (parser.flags & 1 || flags & 1)
-              report(parser, 45);
+              report(parser, 46);
           if (destructible & 128)
               report(parser, 29);
           if (context & (1024 | 2097152) && destructible & 256)
@@ -8150,7 +8154,7 @@ define(['exports'], (function (exports) { 'use strict';
           return parseParenthesizedArrow(parser, context, scope, params, canAssign, 1, start, line, column);
       }
       else if (destructible & 8) {
-          report(parser, 59);
+          report(parser, 60);
       }
       parser.assignable = 2;
       return finishNode(parser, context, start, line, column, {
@@ -8195,10 +8199,10 @@ define(['exports'], (function (exports) { 'use strict';
       const { tokenValue } = parser;
       if (parser.token & 4096 && parser.token !== 20567) {
           if (isStrictReservedWord(parser, context, parser.token)) {
-              report(parser, 114);
+              report(parser, 115);
           }
           if ((parser.token & 537079808) === 537079808) {
-              report(parser, 115);
+              report(parser, 116);
           }
           if (scope) {
               addBlockName(parser, context, scope, tokenValue, 32, 0);
@@ -8251,9 +8255,9 @@ define(['exports'], (function (exports) { 'use strict';
       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);
+          if ((parser.token & 537079808) === 537079808) {
+              report(parser, 116);
           }
           id = parseIdentifier(parser, context, 0);
       }
@@ -8312,13 +8316,13 @@ define(['exports'], (function (exports) { 'use strict';
           decorators = parseDecorators(parser, context);
           length = decorators.length;
           if (length > 0 && parser.tokenValue === 'constructor') {
-              report(parser, 106);
+              report(parser, 107);
           }
           if (parser.token === 1074790415)
-              report(parser, 105);
+              report(parser, 106);
           if (consumeOpt(parser, context, 1074790417)) {
               if (length > 0)
-                  report(parser, 116);
+                  report(parser, 117);
               continue;
           }
           body.push(parseClassElementList(parser, context, scope, inheritedContext, kind, decorators, 0, inGroup, parser.tokenPos, parser.linePos, parser.colPos));
@@ -8415,20 +8419,20 @@ define(['exports'], (function (exports) { 'use strict';
               key = parsePrivateIdentifier(parser, context, tokenPos, linePos, colPos);
           }
           else
-              report(parser, 131);
+              report(parser, 132);
       }
       if ((kind & 2) === 0) {
           if (parser.tokenValue === 'constructor') {
               if ((parser.token & 1073741824) === 1073741824) {
-                  report(parser, 125);
+                  report(parser, 126);
               }
               else if ((kind & 32) === 0 && parser.token === 67174411) {
                   if (kind & (768 | 16 | 128 | 8)) {
-                      report(parser, 50, 'accessor');
+                      report(parser, 51, 'accessor');
                   }
                   else if ((context & 524288) === 0) {
                       if (parser.flags & 32)
-                          report(parser, 51);
+                          report(parser, 52);
                       else
                           parser.flags |= 32;
                   }
@@ -8438,7 +8442,7 @@ define(['exports'], (function (exports) { 'use strict';
           else if ((kind & 4096) === 0 &&
               kind & (32 | 768 | 8 | 16) &&
               parser.tokenValue === 'prototype') {
-              report(parser, 49);
+              report(parser, 50);
           }
       }
       if (context & 1 && parser.token !== 67174411) {
@@ -8480,7 +8484,7 @@ define(['exports'], (function (exports) { 'use strict';
       nextToken(parser, context);
       const { tokenValue } = parser;
       if (tokenValue === 'constructor')
-          report(parser, 124);
+          report(parser, 125);
       nextToken(parser, context);
       return finishNode(parser, context, start, line, column, {
           type: 'PrivateIdentifier',
@@ -8495,7 +8499,7 @@ define(['exports'], (function (exports) { 'use strict';
           nextToken(parser, context | 32768);
           const { tokenPos, linePos, colPos } = parser;
           if (parser.token === 537079928)
-              report(parser, 115);
+              report(parser, 116);
           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);
@@ -8523,33 +8527,33 @@ define(['exports'], (function (exports) { 'use strict';
           ? 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);
+          report(parser, 48);
       if (parser.destructible & 32)
-          report(parser, 47);
+          report(parser, 48);
       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);
+              report(parser, 116);
           }
           else if ((token & 36864) === 36864) {
-              report(parser, 114);
+              report(parser, 115);
           }
       }
       if ((token & 20480) === 20480) {
-          report(parser, 99);
+          report(parser, 100);
       }
       if (context & (2048 | 2097152) && token === 241773) {
           report(parser, 30);
       }
       if (token === 241739) {
           if (kind & (8 | 16))
-              report(parser, 97);
+              report(parser, 98);
       }
       if (context & (4194304 | 2048) && token === 209008) {
-          report(parser, 95);
+          report(parser, 96);
       }
       nextToken(parser, context);
       if (scope)
@@ -8577,7 +8581,7 @@ define(['exports'], (function (exports) { 'use strict';
           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);
+              report(parser, 150, close);
       }
       return finishNode(parser, context, start, line, column, {
           type: 'JSXElement',
@@ -8733,7 +8737,7 @@ define(['exports'], (function (exports) { 'use strict';
                   value = parseJSXExpressionContainer(parser, context, 1, 1, tokenPos, linePos, colPos);
                   break;
               default:
-                  report(parser, 148);
+                  report(parser, 149);
           }
       }
       return finishNode(parser, context, start, line, column, {
@@ -8759,7 +8763,7 @@ define(['exports'], (function (exports) { 'use strict';
       let expression = null;
       if (parser.token === 1074790415) {
           if (isAttr)
-              report(parser, 151);
+              report(parser, 152);
           expression = parseJSXEmptyExpression(parser, context, parser.startPos, parser.startLine, parser.startColumn);
       }
       else {
@@ -8806,7 +8810,7 @@ define(['exports'], (function (exports) { 'use strict';
     __proto__: null
   });
 
-  var version$1 = "4.3.1";
+  var version$1 = "4.3.3";
 
   const version = version$1;
   function parseScript(source, options) {