meriyah 4.3.1 → 4.3.3

package/dist/meriyah.system.js

@@ -21,7 +21,7 @@ System.register('meriyah', [], (function (exports) {
           [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',
@@ -42,9 +42,9 @@ System.register('meriyah', [], (function (exports) {
           [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'",
@@ -54,125 +54,126 @@ System.register('meriyah', [], (function (exports) {
           [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) {
@@ -1104,7 +1105,7 @@ System.register('meriyah', [], (function (exports) {
               case -4:
                   report(state, 6);
               case -5:
-                  report(state, 101);
+                  report(state, 102);
           }
       }
 
@@ -1217,7 +1218,7 @@ System.register('meriyah', [], (function (exports) {
                       while (CharTypes[char] & (64 | 4096)) {
                           if (char === 95) {
                               if (!allowSeparator)
-                                  report(parser, 146);
+                                  report(parser, 147);
                               allowSeparator = 0;
                               char = advanceChar(parser);
                               continue;
@@ -1228,7 +1229,7 @@ System.register('meriyah', [], (function (exports) {
                           char = advanceChar(parser);
                       }
                       if (digits === 0 || !allowSeparator) {
-                          report(parser, digits === 0 ? 19 : 147);
+                          report(parser, digits === 0 ? 19 : 148);
                       }
                   }
                   else if ((char | 32) === 111) {
@@ -1237,7 +1238,7 @@ System.register('meriyah', [], (function (exports) {
                       while (CharTypes[char] & (32 | 4096)) {
                           if (char === 95) {
                               if (!allowSeparator) {
-                                  report(parser, 146);
+                                  report(parser, 147);
                               }
                               allowSeparator = 0;
                               char = advanceChar(parser);
@@ -1249,7 +1250,7 @@ System.register('meriyah', [], (function (exports) {
                           char = advanceChar(parser);
                       }
                       if (digits === 0 || !allowSeparator) {
-                          report(parser, digits === 0 ? 0 : 147);
+                          report(parser, digits === 0 ? 0 : 148);
                       }
                   }
                   else if ((char | 32) === 98) {
@@ -1258,7 +1259,7 @@ System.register('meriyah', [], (function (exports) {
                       while (CharTypes[char] & (128 | 4096)) {
                           if (char === 95) {
                               if (!allowSeparator) {
-                                  report(parser, 146);
+                                  report(parser, 147);
                               }
                               allowSeparator = 0;
                               char = advanceChar(parser);
@@ -1270,7 +1271,7 @@ System.register('meriyah', [], (function (exports) {
                           char = advanceChar(parser);
                       }
                       if (digits === 0 || !allowSeparator) {
-                          report(parser, digits === 0 ? 0 : 147);
+                          report(parser, digits === 0 ? 0 : 148);
                       }
                   }
                   else if (CharTypes[char] & 32) {
@@ -1303,7 +1304,7 @@ System.register('meriyah', [], (function (exports) {
                           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;
@@ -1314,7 +1315,7 @@ System.register('meriyah', [], (function (exports) {
                           --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;
@@ -1379,7 +1380,7 @@ System.register('meriyah', [], (function (exports) {
                   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);
@@ -1390,7 +1391,7 @@ System.register('meriyah', [], (function (exports) {
               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);
       }
@@ -1479,7 +1480,7 @@ System.register('meriyah', [], (function (exports) {
       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);
       }
@@ -1566,7 +1567,7 @@ System.register('meriyah', [], (function (exports) {
       }
       function scanPrivateIdentifier(parser) {
           if (!isIdentifierStart(advanceChar(parser)))
-              report(parser, 93);
+              report(parser, 94);
           return 131;
       }
       function scanIdentifierUnicodeEscape(parser) {
@@ -1584,7 +1585,7 @@ System.register('meriyah', [], (function (exports) {
               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);
@@ -1925,7 +1926,7 @@ System.register('meriyah', [], (function (exports) {
                               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;
@@ -4421,7 +4422,7 @@ System.register('meriyah', [], (function (exports) {
               case 'AssignmentExpression':
                   node.type = 'AssignmentPattern';
                   if (node.operator !== '=')
-                      report(state, 68);
+                      report(state, 69);
                   delete node.operator;
                   reinterpretToPattern(state, node.left);
                   return;
@@ -4436,58 +4437,58 @@ System.register('meriyah', [], (function (exports) {
       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);
@@ -4499,7 +4500,7 @@ System.register('meriyah', [], (function (exports) {
           while (labels) {
               if (labels['$' + name]) {
                   if (isIterationStatement)
-                      report(parser, 133);
+                      report(parser, 134);
                   return 1;
               }
               if (isIterationStatement && labels.loop)
@@ -4512,7 +4513,7 @@ System.register('meriyah', [], (function (exports) {
           let set = labels;
           while (set) {
               if (set['$' + name])
-                  report(parser, 132, name);
+                  report(parser, 133, name);
               set = set['$'];
           }
           labels['$' + name] = 1;
@@ -4593,27 +4594,27 @@ System.register('meriyah', [], (function (exports) {
           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;
       }
@@ -4627,19 +4628,19 @@ System.register('meriyah', [], (function (exports) {
                       ((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;
@@ -4649,7 +4650,7 @@ System.register('meriyah', [], (function (exports) {
       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;
           }
@@ -4707,7 +4708,7 @@ System.register('meriyah', [], (function (exports) {
       function classifyIdentifier(parser, context, t, isArrow) {
           if ((t & 537079808) === 537079808) {
               if (context & 1024)
-                  report(parser, 115);
+                  report(parser, 116);
               if (isArrow)
                   parser.flags |= 512;
           }
@@ -4800,7 +4801,7 @@ System.register('meriyah', [], (function (exports) {
               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));
                   }
               }
           }
@@ -4870,7 +4871,7 @@ System.register('meriyah', [], (function (exports) {
                   moduleItem = parseStatementListItem(parser, context, scope, 4, {});
           }
           if (parser.leadingDecorators.length) {
-              report(parser, 164);
+              report(parser, 165);
           }
           return moduleItem;
       }
@@ -4889,7 +4890,7 @@ System.register('meriyah', [], (function (exports) {
               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) {
@@ -4898,7 +4899,7 @@ System.register('meriyah', [], (function (exports) {
                       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);
@@ -4941,17 +4942,17 @@ System.register('meriyah', [], (function (exports) {
               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);
           }
@@ -4963,9 +4964,9 @@ System.register('meriyah', [], (function (exports) {
               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);
@@ -4994,7 +4995,7 @@ System.register('meriyah', [], (function (exports) {
       }
       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
@@ -5038,7 +5039,7 @@ System.register('meriyah', [], (function (exports) {
           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) {
@@ -5097,7 +5098,7 @@ System.register('meriyah', [], (function (exports) {
       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, {
@@ -5151,7 +5152,7 @@ System.register('meriyah', [], (function (exports) {
               else {
                   consume(parser, context | 32768, 20563);
                   if (seenDefault)
-                      report(parser, 86);
+                      report(parser, 87);
                   seenDefault = 1;
               }
               consume(parser, context | 32768, 21);
@@ -5192,14 +5193,14 @@ System.register('meriyah', [], (function (exports) {
       }
       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, {
@@ -5214,10 +5215,10 @@ System.register('meriyah', [], (function (exports) {
               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, {
@@ -5228,7 +5229,7 @@ System.register('meriyah', [], (function (exports) {
       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);
@@ -5261,7 +5262,7 @@ System.register('meriyah', [], (function (exports) {
               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',
@@ -5280,10 +5281,10 @@ System.register('meriyah', [], (function (exports) {
                   ? 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)
@@ -5335,7 +5336,7 @@ System.register('meriyah', [], (function (exports) {
           }
           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);
           }
@@ -5383,7 +5384,7 @@ System.register('meriyah', [], (function (exports) {
               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;
       }
@@ -5398,13 +5399,13 @@ System.register('meriyah', [], (function (exports) {
                   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',
@@ -5432,7 +5433,7 @@ System.register('meriyah', [], (function (exports) {
                   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, {
@@ -5444,14 +5445,14 @@ System.register('meriyah', [], (function (exports) {
                       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 {
@@ -5472,7 +5473,7 @@ System.register('meriyah', [], (function (exports) {
           }
           else if (token === 1074790417) {
               if (forAwait)
-                  report(parser, 79);
+                  report(parser, 80);
           }
           else if ((token & 2097152) === 2097152) {
               init =
@@ -5481,7 +5482,7 @@ System.register('meriyah', [], (function (exports) {
                       : 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;
@@ -5493,7 +5494,7 @@ System.register('meriyah', [], (function (exports) {
           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);
@@ -5508,11 +5509,11 @@ System.register('meriyah', [], (function (exports) {
                   });
               }
               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);
@@ -5524,10 +5525,10 @@ System.register('meriyah', [], (function (exports) {
               });
           }
           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);
           }
@@ -5551,9 +5552,9 @@ System.register('meriyah', [], (function (exports) {
       }
       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);
@@ -5587,7 +5588,7 @@ System.register('meriyah', [], (function (exports) {
                               parseImportSpecifierOrNamedImports(parser, context, scope, specifiers);
                               break;
                           default:
-                              report(parser, 104);
+                              report(parser, 105);
                       }
                   }
               }
@@ -5631,7 +5632,7 @@ System.register('meriyah', [], (function (exports) {
       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) {
@@ -5642,7 +5643,7 @@ System.register('meriyah', [], (function (exports) {
               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);
@@ -5746,7 +5747,7 @@ System.register('meriyah', [], (function (exports) {
                   }
                   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, {
@@ -5766,7 +5767,7 @@ System.register('meriyah', [], (function (exports) {
                       if (parser.token === 77934) {
                           nextToken(parser, context);
                           if ((parser.token & 134217728) === 134217728) {
-                              report(parser, 103);
+                              report(parser, 104);
                           }
                           if (scope) {
                               tmpExportedNames.push(parser.tokenValue);
@@ -5792,7 +5793,7 @@ System.register('meriyah', [], (function (exports) {
                   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) {
@@ -5941,7 +5942,7 @@ System.register('meriyah', [], (function (exports) {
               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;
@@ -5967,10 +5968,10 @@ System.register('meriyah', [], (function (exports) {
               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;
@@ -6001,7 +6002,7 @@ System.register('meriyah', [], (function (exports) {
           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;
@@ -6016,7 +6017,7 @@ System.register('meriyah', [], (function (exports) {
               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) {
@@ -6033,7 +6034,7 @@ System.register('meriyah', [], (function (exports) {
               });
           }
           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) {
@@ -6056,7 +6057,7 @@ System.register('meriyah', [], (function (exports) {
               });
           }
           if (context & 2048)
-              report(parser, 95);
+              report(parser, 96);
           return parseIdentifierOrArrow(parser, context, start, line, column);
       }
       function parseFunctionBody(parser, context, scope, origin, firstRestricted, scopeError) {
@@ -6071,7 +6072,7 @@ System.register('meriyah', [], (function (exports) {
                   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);
@@ -6082,16 +6083,16 @@ System.register('meriyah', [], (function (exports) {
               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 &&
@@ -6121,7 +6122,7 @@ System.register('meriyah', [], (function (exports) {
           nextToken(parser, context);
           switch (parser.token) {
               case 67108991:
-                  report(parser, 161);
+                  report(parser, 162);
               case 67174411: {
                   if ((context & 524288) === 0)
                       report(parser, 26);
@@ -6150,7 +6151,7 @@ System.register('meriyah', [], (function (exports) {
       }
       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;
@@ -6233,7 +6234,7 @@ System.register('meriyah', [], (function (exports) {
                   }
                   default:
                       if ((parser.flags & 2048) === 2048) {
-                          report(parser, 160);
+                          report(parser, 161);
                       }
                       parser.assignable = 2;
                       expr = finishNode(parser, context, start, line, column, {
@@ -6290,7 +6291,7 @@ System.register('meriyah', [], (function (exports) {
           }
           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, {
@@ -6308,7 +6309,7 @@ System.register('meriyah', [], (function (exports) {
       }
       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)
@@ -6316,14 +6317,14 @@ System.register('meriyah', [], (function (exports) {
       }
       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, {
@@ -6352,12 +6353,12 @@ System.register('meriyah', [], (function (exports) {
                   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
@@ -6428,14 +6429,14 @@ System.register('meriyah', [], (function (exports) {
               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]);
@@ -6449,7 +6450,7 @@ System.register('meriyah', [], (function (exports) {
       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, {
@@ -6494,14 +6495,14 @@ System.register('meriyah', [], (function (exports) {
           ];
           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;
@@ -6717,10 +6718,10 @@ System.register('meriyah', [], (function (exports) {
       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;
       }
@@ -6815,7 +6816,7 @@ System.register('meriyah', [], (function (exports) {
                           }
                       }
                       else if (parser.destructible & 8) {
-                          report(parser, 68);
+                          report(parser, 69);
                       }
                       else {
                           left = parseMemberOrUpdateExpression(parser, context, left, inGroup, 0, tokenPos, linePos, colPos);
@@ -6914,7 +6915,7 @@ System.register('meriyah', [], (function (exports) {
               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);
               }
@@ -6941,7 +6942,7 @@ System.register('meriyah', [], (function (exports) {
               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) {
@@ -6991,7 +6992,7 @@ System.register('meriyah', [], (function (exports) {
               }
               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
@@ -7052,10 +7053,10 @@ System.register('meriyah', [], (function (exports) {
       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;
       }
@@ -7172,7 +7173,7 @@ System.register('meriyah', [], (function (exports) {
                                       destructible |= 16;
                               }
                               else if (parser.destructible & 8) {
-                                  report(parser, 68);
+                                  report(parser, 69);
                               }
                               else {
                                   value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7232,10 +7233,10 @@ System.register('meriyah', [], (function (exports) {
                       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);
@@ -7254,11 +7255,14 @@ System.register('meriyah', [], (function (exports) {
                       }
                       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 |=
@@ -7293,7 +7297,7 @@ System.register('meriyah', [], (function (exports) {
                           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) {
@@ -7394,7 +7398,7 @@ System.register('meriyah', [], (function (exports) {
                           destructible = parser.assignable | 16;
                       }
                       else {
-                          report(parser, 130);
+                          report(parser, 131);
                       }
                   }
                   else if (parser.token === 69271571) {
@@ -7451,7 +7455,7 @@ System.register('meriyah', [], (function (exports) {
                                       destructible |= 16;
                               }
                               else if (destructible & 8) {
-                                  report(parser, 59);
+                                  report(parser, 60);
                               }
                               else {
                                   value = parseMemberOrUpdateExpression(parser, context, value, inGroup, 0, tokenPos, linePos, colPos);
@@ -7503,7 +7507,7 @@ System.register('meriyah', [], (function (exports) {
                           destructible = 16;
                       }
                       else {
-                          report(parser, 41);
+                          report(parser, 42);
                       }
                   }
                   else if (token === 8457014) {
@@ -7519,10 +7523,10 @@ System.register('meriyah', [], (function (exports) {
                           }
                           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) {
@@ -7538,7 +7542,7 @@ System.register('meriyah', [], (function (exports) {
                           value = parseMethodDefinition(parser, context, state, inGroup, parser.tokenPos, parser.linePos, parser.colPos);
                       }
                       else {
-                          report(parser, 122);
+                          report(parser, 123);
                       }
                   }
                   else {
@@ -7620,7 +7624,7 @@ System.register('meriyah', [], (function (exports) {
                   }
                   isSimpleParameterList = 1;
                   if (parser.destructible & (32 | 16))
-                      report(parser, 47);
+                      report(parser, 48);
               }
               if (parser.token === 1077936157) {
                   nextToken(parser, context | 32768);
@@ -7712,7 +7716,7 @@ System.register('meriyah', [], (function (exports) {
                   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) {
@@ -7723,7 +7727,7 @@ System.register('meriyah', [], (function (exports) {
               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);
@@ -7780,7 +7784,7 @@ System.register('meriyah', [], (function (exports) {
           }
           consume(parser, context, 16);
           if (destructible & 16 && destructible & 8)
-              report(parser, 145);
+              report(parser, 146);
           destructible |=
               parser.destructible & 256
                   ? 256
@@ -7789,7 +7793,7 @@ System.register('meriyah', [], (function (exports) {
                       : 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) {
@@ -7800,7 +7804,7 @@ System.register('meriyah', [], (function (exports) {
               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
@@ -7825,23 +7829,23 @@ System.register('meriyah', [], (function (exports) {
       }
       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;
@@ -7860,16 +7864,16 @@ System.register('meriyah', [], (function (exports) {
               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;
@@ -7877,7 +7881,7 @@ System.register('meriyah', [], (function (exports) {
               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, {
@@ -7925,7 +7929,7 @@ System.register('meriyah', [], (function (exports) {
                   }
                   isSimpleParameterList = 1;
                   if (parser.destructible & (32 | 16)) {
-                      report(parser, 47);
+                      report(parser, 48);
                   }
               }
               if (parser.token === 1077936157) {
@@ -8001,16 +8005,16 @@ System.register('meriyah', [], (function (exports) {
                   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, {
@@ -8045,7 +8049,7 @@ System.register('meriyah', [], (function (exports) {
           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, {
@@ -8101,7 +8105,7 @@ System.register('meriyah', [], (function (exports) {
                   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) {
@@ -8149,7 +8153,7 @@ System.register('meriyah', [], (function (exports) {
               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)
@@ -8159,7 +8163,7 @@ System.register('meriyah', [], (function (exports) {
               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, {
@@ -8204,10 +8208,10 @@ System.register('meriyah', [], (function (exports) {
           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);
@@ -8260,9 +8264,9 @@ System.register('meriyah', [], (function (exports) {
           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);
           }
@@ -8321,13 +8325,13 @@ System.register('meriyah', [], (function (exports) {
               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));
@@ -8424,20 +8428,20 @@ System.register('meriyah', [], (function (exports) {
                   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;
                       }
@@ -8447,7 +8451,7 @@ System.register('meriyah', [], (function (exports) {
               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) {
@@ -8489,7 +8493,7 @@ System.register('meriyah', [], (function (exports) {
           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',
@@ -8504,7 +8508,7 @@ System.register('meriyah', [], (function (exports) {
               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);
@@ -8532,33 +8536,33 @@ System.register('meriyah', [], (function (exports) {
               ? 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)
@@ -8586,7 +8590,7 @@ System.register('meriyah', [], (function (exports) {
               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',
@@ -8742,7 +8746,7 @@ System.register('meriyah', [], (function (exports) {
                       value = parseJSXExpressionContainer(parser, context, 1, 1, tokenPos, linePos, colPos);
                       break;
                   default:
-                      report(parser, 148);
+                      report(parser, 149);
               }
           }
           return finishNode(parser, context, start, line, column, {
@@ -8768,7 +8772,7 @@ System.register('meriyah', [], (function (exports) {
           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 {
@@ -8816,7 +8820,7 @@ System.register('meriyah', [], (function (exports) {
       });
       exports('ESTree', estree);
 
-      var version$1 = "4.3.1";
+      var version$1 = "4.3.3";
 
       const version = exports('version', version$1);
       function parseScript(source, options) {