meriyah 4.3.1 → 4.3.3

package/dist/meriyah.esm.mjs

@@ -10,7 +10,7 @@ const errorMessages = {
     [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',
@@ -31,9 +31,9 @@ const errorMessages = {
     [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'",
@@ -43,125 +43,126 @@ const errorMessages = {
     [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) {
@@ -1093,7 +1094,7 @@ function handleStringError(state, code, isTemplate) {
         case -4:
             report(state, 6);
         case -5:
-            report(state, 101);
+            report(state, 102);
     }
 }
 
@@ -1206,7 +1207,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (64 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator)
-                            report(parser, 146);
+                            report(parser, 147);
                         allowSeparator = 0;
                         char = advanceChar(parser);
                         continue;
@@ -1217,7 +1218,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    report(parser, digits === 0 ? 19 : 147);
+                    report(parser, digits === 0 ? 19 : 148);
                 }
             }
             else if ((char | 32) === 111) {
@@ -1226,7 +1227,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (32 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator) {
-                            report(parser, 146);
+                            report(parser, 147);
                         }
                         allowSeparator = 0;
                         char = advanceChar(parser);
@@ -1238,7 +1239,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    report(parser, digits === 0 ? 0 : 147);
+                    report(parser, digits === 0 ? 0 : 148);
                 }
             }
             else if ((char | 32) === 98) {
@@ -1247,7 +1248,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (128 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator) {
-                            report(parser, 146);
+                            report(parser, 147);
                         }
                         allowSeparator = 0;
                         char = advanceChar(parser);
@@ -1259,7 +1260,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    report(parser, digits === 0 ? 0 : 147);
+                    report(parser, digits === 0 ? 0 : 148);
                 }
             }
             else if (CharTypes[char] & 32) {
@@ -1292,7 +1293,7 @@ function scanNumber(parser, context, kind) {
                     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;
@@ -1303,7 +1304,7 @@ function scanNumber(parser, context, kind) {
                     --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;
@@ -1368,7 +1369,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
             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);
@@ -1379,7 +1380,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
         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);
 }
@@ -1468,7 +1469,7 @@ const descKeywordTable = Object.create(null, {
 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);
 }
@@ -1555,7 +1556,7 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
 }
 function scanPrivateIdentifier(parser) {
     if (!isIdentifierStart(advanceChar(parser)))
-        report(parser, 93);
+        report(parser, 94);
     return 131;
 }
 function scanIdentifierUnicodeEscape(parser) {
@@ -1573,7 +1574,7 @@ function scanUnicodeEscape(parser) {
         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);
@@ -1914,7 +1915,7 @@ function scanSingleToken(parser, context, state) {
                         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;
@@ -4410,7 +4411,7 @@ function reinterpretToPattern(state, node) {
         case 'AssignmentExpression':
             node.type = 'AssignmentPattern';
             if (node.operator !== '=')
-                report(state, 68);
+                report(state, 69);
             delete node.operator;
             reinterpretToPattern(state, node.left);
             return;
@@ -4425,58 +4426,58 @@ function reinterpretToPattern(state, node) {
 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);
@@ -4488,7 +4489,7 @@ function isValidLabel(parser, labels, name, isIterationStatement) {
     while (labels) {
         if (labels['$' + name]) {
             if (isIterationStatement)
-                report(parser, 133);
+                report(parser, 134);
             return 1;
         }
         if (isIterationStatement && labels.loop)
@@ -4501,7 +4502,7 @@ function validateAndDeclareLabel(parser, labels, name) {
     let set = labels;
     while (set) {
         if (set['$' + name])
-            report(parser, 132, name);
+            report(parser, 133, name);
         set = set['$'];
     }
     labels['$' + name] = 1;
@@ -4582,27 +4583,27 @@ 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);
+            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;
 }
@@ -4616,19 +4617,19 @@ function addVarName(parser, context, scope, name, kind) {
                 ((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;
@@ -4638,7 +4639,7 @@ function addVarName(parser, context, scope, name, kind) {
 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;
     }
@@ -4696,7 +4697,7 @@ function isValidIdentifier(context, t) {
 function classifyIdentifier(parser, context, t, isArrow) {
     if ((t & 537079808) === 537079808) {
         if (context & 1024)
-            report(parser, 115);
+            report(parser, 116);
         if (isArrow)
             parser.flags |= 512;
     }
@@ -4789,7 +4790,7 @@ function parseSource(source, options, context) {
         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));
             }
         }
     }
@@ -4859,7 +4860,7 @@ function parseModuleItem(parser, context, scope) {
             moduleItem = parseStatementListItem(parser, context, scope, 4, {});
     }
     if (parser.leadingDecorators.length) {
-        report(parser, 164);
+        report(parser, 165);
     }
     return moduleItem;
 }
@@ -4878,7 +4879,7 @@ function parseStatementListItem(parser, context, scope, origin, labels) {
         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) {
@@ -4887,7 +4888,7 @@ function parseStatementListItem(parser, context, scope, origin, labels) {
                 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);
@@ -4930,17 +4931,17 @@ function parseStatement(parser, context, scope, origin, labels, allowFuncDecl, s
         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);
     }
@@ -4952,9 +4953,9 @@ function parseExpressionOrLabelledStatement(parser, context, scope, origin, labe
         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);
@@ -4983,7 +4984,7 @@ function parseBlock(parser, context, scope, labels, start, line, column) {
 }
 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
@@ -5027,7 +5028,7 @@ function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, origi
     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) {
@@ -5086,7 +5087,7 @@ function parseEmptyStatement(parser, context, start, line, column) {
 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, {
@@ -5140,7 +5141,7 @@ function parseSwitchStatement(parser, context, scope, labels, start, line, colum
         else {
             consume(parser, context | 32768, 20563);
             if (seenDefault)
-                report(parser, 86);
+                report(parser, 87);
             seenDefault = 1;
         }
         consume(parser, context | 32768, 21);
@@ -5181,14 +5182,14 @@ function parseIterationStatementBody(parser, context, scope, labels) {
 }
 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, {
@@ -5203,10 +5204,10 @@ function parseBreakStatement(parser, context, labels, start, line, column) {
         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, {
@@ -5217,7 +5218,7 @@ function parseBreakStatement(parser, context, labels, start, line, column) {
 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);
@@ -5250,7 +5251,7 @@ function parseTryStatement(parser, context, scope, labels, start, line, column)
         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',
@@ -5269,10 +5270,10 @@ function parseCatchBlock(parser, context, scope, labels, start, line, column) {
             ? 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)
@@ -5324,7 +5325,7 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, origin,
     }
     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);
     }
@@ -5372,7 +5373,7 @@ function parseVariableDeclarationList(parser, context, scope, kind, origin) {
         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;
 }
@@ -5387,13 +5388,13 @@ function parseVariableDeclaration(parser, context, scope, kind, origin) {
             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',
@@ -5421,7 +5422,7 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
             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, {
@@ -5433,14 +5434,14 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
                 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 {
@@ -5461,7 +5462,7 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
     }
     else if (token === 1074790417) {
         if (forAwait)
-            report(parser, 79);
+            report(parser, 80);
     }
     else if ((token & 2097152) === 2097152) {
         init =
@@ -5470,7 +5471,7 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
                 : 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;
@@ -5482,7 +5483,7 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
     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);
@@ -5497,11 +5498,11 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
             });
         }
         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);
@@ -5513,10 +5514,10 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
         });
     }
     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);
     }
@@ -5540,9 +5541,9 @@ function parseForStatement(parser, context, scope, labels, start, line, column)
 }
 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);
@@ -5576,7 +5577,7 @@ function parseImportDeclaration(parser, context, scope) {
                         parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
                         break;
                     default:
-                        report(parser, 104);
+                        report(parser, 105);
                 }
             }
         }
@@ -5620,7 +5621,7 @@ function parseImportNamespaceSpecifier(parser, context, scope) {
 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) {
@@ -5631,7 +5632,7 @@ function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers)
         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);
@@ -5735,7 +5736,7 @@ function parseExportDeclaration(parser, context, scope) {
             }
             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, {
@@ -5755,7 +5756,7 @@ function parseExportDeclaration(parser, context, scope) {
                 if (parser.token === 77934) {
                     nextToken(parser, context);
                     if ((parser.token & 134217728) === 134217728) {
-                        report(parser, 103);
+                        report(parser, 104);
                     }
                     if (scope) {
                         tmpExportedNames.push(parser.tokenValue);
@@ -5781,7 +5782,7 @@ function parseExportDeclaration(parser, context, scope) {
             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) {
@@ -5930,7 +5931,7 @@ function parseBinaryExpression(parser, context, inGroup, start, line, column, mi
         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;
@@ -5956,10 +5957,10 @@ function parseUnaryExpression(parser, context, isLHS, start, line, column, inGro
         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;
@@ -5990,7 +5991,7 @@ function parseAsyncExpression(parser, context, inGroup, isLHS, canAssign, isPatt
     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;
@@ -6005,7 +6006,7 @@ function parseYieldExpression(parser, context, inGroup, canAssign, start, line,
         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) {
@@ -6022,7 +6023,7 @@ function parseYieldExpression(parser, context, inGroup, canAssign, start, line,
         });
     }
     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) {
@@ -6045,7 +6046,7 @@ function parseAwaitExpression(parser, context, inNew, inGroup, start, line, colu
         });
     }
     if (context & 2048)
-        report(parser, 95);
+        report(parser, 96);
     return parseIdentifierOrArrow(parser, context, start, line, column);
 }
 function parseFunctionBody(parser, context, scope, origin, firstRestricted, scopeError) {
@@ -6060,7 +6061,7 @@ function parseFunctionBody(parser, context, scope, origin, firstRestricted, scop
             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);
@@ -6071,16 +6072,16 @@ function parseFunctionBody(parser, context, scope, origin, firstRestricted, scop
         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 &&
@@ -6110,7 +6111,7 @@ function parseSuperExpression(parser, context, start, line, column) {
     nextToken(parser, context);
     switch (parser.token) {
         case 67108991:
-            report(parser, 161);
+            report(parser, 162);
         case 67174411: {
             if ((context & 524288) === 0)
                 report(parser, 26);
@@ -6139,7 +6140,7 @@ function parseLeftHandSideExpression(parser, context, canAssign, inGroup, isLHS,
 }
 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;
@@ -6222,7 +6223,7 @@ function parseMemberOrUpdateExpression(parser, context, expr, inGroup, inChain,
             }
             default:
                 if ((parser.flags & 2048) === 2048) {
-                    report(parser, 160);
+                    report(parser, 161);
                 }
                 parser.assignable = 2;
                 expr = finishNode(parser, context, start, line, column, {
@@ -6279,7 +6280,7 @@ function parseOptionalChain(parser, context, expr, start, line, column) {
     }
     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, {
@@ -6297,7 +6298,7 @@ function parseOptionalChain(parser, context, expr, start, line, column) {
 }
 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)
@@ -6305,14 +6306,14 @@ function parsePropertyOrPrivatePropertyName(parser, context) {
 }
 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, {
@@ -6341,12 +6342,12 @@ function parsePrimaryExpression(parser, context, kind, inNew, canAssign, isPatte
             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
@@ -6417,14 +6418,14 @@ function parseImportCallOrMetaExpression(parser, context, inNew, inGroup, start,
         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]);
@@ -6438,7 +6439,7 @@ function parseImportMetaExpression(parser, context, meta, start, line, column) {
 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, {
@@ -6483,14 +6484,14 @@ function parseTemplate(parser, context) {
     ];
     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;
@@ -6706,10 +6707,10 @@ function parseFunctionExpression(parser, context, isAsync, inGroup, start, line,
 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;
 }
@@ -6804,7 +6805,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, skipInitializer,
                     }
                 }
                 else if (parser.destructible & 8) {
-                    report(parser, 68);
+                    report(parser, 69);
                 }
                 else {
                     left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
@@ -6903,7 +6904,7 @@ function parseSpreadOrRestElement(parser, context, scope, closingToken, kind, or
         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);
         }
@@ -6930,7 +6931,7 @@ function parseSpreadOrRestElement(parser, context, scope, closingToken, kind, or
         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) {
@@ -6980,7 +6981,7 @@ function parseSpreadOrRestElement(parser, context, scope, closingToken, kind, or
         }
         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
@@ -7041,10 +7042,10 @@ function parseMethodDefinition(parser, context, kind, inGroup, start, line, colu
 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;
 }
@@ -7161,7 +7162,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                                 destructible |= 16;
                         }
                         else if (parser.destructible & 8) {
-                            report(parser, 68);
+                            report(parser, 69);
                         }
                         else {
                             value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7221,10 +7222,10 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                 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);
@@ -7243,11 +7244,14 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                 }
                 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 |=
@@ -7282,7 +7286,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                     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) {
@@ -7383,7 +7387,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                     destructible = parser.assignable | 16;
                 }
                 else {
-                    report(parser, 130);
+                    report(parser, 131);
                 }
             }
             else if (parser.token === 69271571) {
@@ -7440,7 +7444,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                                 destructible |= 16;
                         }
                         else if (destructible & 8) {
-                            report(parser, 59);
+                            report(parser, 60);
                         }
                         else {
                             value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7492,7 +7496,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                     destructible = 16;
                 }
                 else {
-                    report(parser, 41);
+                    report(parser, 42);
                 }
             }
             else if (token === 8457014) {
@@ -7508,10 +7512,10 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                     }
                     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) {
@@ -7527,7 +7531,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, skipInitializer, in
                     value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                 }
                 else {
-                    report(parser, 122);
+                    report(parser, 123);
                 }
             }
             else {
@@ -7609,7 +7613,7 @@ function parseMethodFormals(parser, context, scope, kind, type, inGroup) {
             }
             isSimpleParameterList = 1;
             if (parser.destructible & (32 | 16))
-                report(parser, 47);
+                report(parser, 48);
         }
         if (parser.token === 1077936157) {
             nextToken(parser, context | 32768);
@@ -7701,7 +7705,7 @@ function parseParenthesizedExpression(parser, context, canAssign, kind, origin,
             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) {
@@ -7712,7 +7716,7 @@ function parseParenthesizedExpression(parser, context, canAssign, kind, origin,
         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);
@@ -7769,7 +7773,7 @@ function parseParenthesizedExpression(parser, context, canAssign, kind, origin,
     }
     consume(parser, context, 16);
     if (destructible & 16 && destructible & 8)
-        report(parser, 145);
+        report(parser, 146);
     destructible |=
         parser.destructible & 256
             ? 256
@@ -7778,7 +7782,7 @@ function parseParenthesizedExpression(parser, context, canAssign, kind, origin,
                 : 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) {
@@ -7789,7 +7793,7 @@ function parseParenthesizedExpression(parser, context, canAssign, kind, origin,
         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
@@ -7814,23 +7818,23 @@ function parseIdentifierOrArrow(parser, context, start, line, column) {
 }
 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;
@@ -7849,16 +7853,16 @@ function parseArrowFunctionExpression(parser, context, scope, params, isAsync, s
         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;
@@ -7866,7 +7870,7 @@ function parseArrowFunctionExpression(parser, context, scope, params, isAsync, s
         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, {
@@ -7914,7 +7918,7 @@ function parseFormalParametersOrFormalList(parser, context, scope, inGroup, kind
             }
             isSimpleParameterList = 1;
             if (parser.destructible & (32 | 16)) {
-                report(parser, 47);
+                report(parser, 48);
             }
         }
         if (parser.token === 1077936157) {
@@ -7990,16 +7994,16 @@ function parseNewExpression(parser, context, inGroup, start, line, column) {
             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, {
@@ -8034,7 +8038,7 @@ function parseAsyncArrowOrCallExpression(parser, context, callee, canAssign, kin
     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, {
@@ -8090,7 +8094,7 @@ function parseAsyncArrowOrCallExpression(parser, context, callee, canAssign, kin
             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) {
@@ -8138,7 +8142,7 @@ function parseAsyncArrowOrCallExpression(parser, context, callee, canAssign, kin
         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)
@@ -8148,7 +8152,7 @@ function parseAsyncArrowOrCallExpression(parser, context, callee, canAssign, kin
         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, {
@@ -8193,10 +8197,10 @@ function parseClassDeclaration(parser, context, scope, flags, start, line, colum
     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);
@@ -8249,9 +8253,9 @@ function parseClassExpression(parser, context, inGroup, start, line, column) {
     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);
     }
@@ -8310,13 +8314,13 @@ function parseClassBody(parser, context, inheritedContext, scope, kind, origin,
         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));
@@ -8413,20 +8417,20 @@ function parseClassElementList(parser, context, scope, inheritedContext, type, d
             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;
                 }
@@ -8436,7 +8440,7 @@ function parseClassElementList(parser, context, scope, inheritedContext, type, d
         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) {
@@ -8478,7 +8482,7 @@ function parsePrivateIdentifier(parser, context, start, line, column) {
     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',
@@ -8493,7 +8497,7 @@ function parsePropertyDefinition(parser, context, key, state, decorators, start,
         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);
@@ -8521,33 +8525,33 @@ function parseBindingPattern(parser, context, scope, type, origin, start, line,
         ? 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)
@@ -8575,7 +8579,7 @@ function parseJSXRootElementOrFragment(parser, context, inJSXChild, start, line,
         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',
@@ -8731,7 +8735,7 @@ function parseJsxAttribute(parser, context, start, line, column) {
                 value = parseJSXExpressionContainer(parser, context, 1, 1, tokenPos, linePos, colPos);
                 break;
             default:
-                report(parser, 148);
+                report(parser, 149);
         }
     }
     return finishNode(parser, context, start, line, column, {
@@ -8757,7 +8761,7 @@ function parseJSXExpressionContainer(parser, context, inJSXChild, isAttr, start,
     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 {
@@ -8804,7 +8808,7 @@ var estree = /*#__PURE__*/Object.freeze({
   __proto__: null
 });
 
-var version$1 = "4.3.1";
+var version$1 = "4.3.3";
 
 const version = version$1;
 function parseScript(source, options) {