meriyah 7.2.0 → 7.3.1

package/dist/meriyah.umd.js

@@ -4,7 +4,7 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.meriyah = {}));
 })(this, (function (exports) { 'use strict';
 
-  var version$1 = "7.2.0";
+  var version$1 = "7.3.1";
   var packageJson = {
   	version: version$1};
 
@@ -97,7 +97,7 @@
       0,
       16384,
       0,
-      0,
+      16384,
       0,
       0,
       1 | 2 | 64,
@@ -160,7 +160,7 @@
       1 | 2 | 4,
       16384,
       0,
-      0,
+      16384,
       0,
       0
   ];
@@ -627,7 +627,7 @@
       [9]: 'Octal literals are not allowed in strict mode',
       [8]: 'Decimal integer literals with a leading zero are forbidden in strict mode',
       [10]: 'Expected number in radix %0',
-      [151]: 'Invalid left-hand side assignment to a destructible right-hand side',
+      [153]: 'Invalid left-hand side assignment to a destructible right-hand side',
       [11]: 'Non-number found after exponent indicator',
       [12]: 'Invalid BigIntLiteral',
       [13]: 'No identifiers allowed directly after numeric literal',
@@ -651,7 +651,7 @@
       [32]: 'Yield expression not allowed in formal parameter',
       [95]: "Unexpected token: 'escaped keyword'",
       [33]: 'Unary expressions as the left operand of an exponentiation expression must be disambiguated with parentheses',
-      [123]: 'Async functions can only be declared at the top level or inside a block',
+      [125]: 'Async functions can only be declared at the top level or inside a block',
       [34]: 'Unterminated regular expression',
       [35]: 'Unexpected regular expression flag',
       [36]: "Duplicate regular expression flag '%0'",
@@ -663,7 +663,7 @@
       [42]: 'A getter cannot be a generator',
       [43]: 'A setter cannot be a generator',
       [44]: 'A computed property name must be followed by a colon or paren',
-      [134]: 'Object literal keys that are strings or numbers must be a method or have a colon',
+      [136]: 'Object literal keys that are strings or numbers must be a method or have a colon',
       [46]: 'Found `* async x(){}` but this should be `async * x(){}`',
       [45]: 'Getters and setters can not be generators',
       [47]: "'%0' can not be generator method",
@@ -725,73 +725,77 @@
       [105]: '%0 source must be string',
       [106]: 'Only a identifier or string can be used to indicate alias',
       [107]: "Only '*' or '{...}' can be imported after default",
-      [108]: 'Trailing decorator may be followed by method',
-      [109]: "Decorators can't be used with a constructor",
-      [110]: 'Can not use `await` as identifier in module or async func',
-      [111]: 'Can not use `await` as identifier in module',
-      [112]: 'HTML comments are only allowed with web compatibility (Annex B)',
-      [113]: "The identifier 'let' must not be in expression position in strict mode",
-      [114]: 'Cannot assign to `eval` and `arguments` in strict mode',
-      [115]: "The left-hand side of a for-of loop may not start with 'let'",
-      [116]: 'Block body arrows can not be immediately invoked without a group',
-      [117]: 'Block body arrows can not be immediately accessed without a group',
-      [118]: 'Unexpected strict mode reserved word',
-      [119]: 'Unexpected eval or arguments in strict mode',
-      [120]: 'Decorators must not be followed by a semicolon',
-      [121]: 'Calling delete on expression not allowed in strict mode',
-      [122]: 'Pattern can not have a tail',
-      [124]: 'Can not have a `yield` expression on the left side of a ternary',
-      [125]: 'An arrow function can not have a postfix update operator',
-      [126]: 'Invalid object literal key character after generator star',
-      [127]: 'Private fields can not be deleted',
-      [129]: 'Classes may not have a field called constructor',
-      [128]: 'Classes may not have a private element named constructor',
-      [130]: 'A class field initializer or static block may not contain arguments',
-      [131]: 'Generators can only be declared at the top level or inside a block',
-      [132]: 'Async methods are a restricted production and cannot have a newline following it',
-      [133]: 'Unexpected character after object literal property name',
-      [135]: 'Invalid key token',
-      [136]: "Label '%0' has already been declared",
-      [137]: 'continue statement must be nested within an iteration statement',
-      [138]: "Undefined label '%0'",
-      [139]: 'Trailing comma is disallowed inside import(...) arguments',
-      [140]: 'Invalid binding in JSON import',
-      [141]: 'import() requires exactly one argument',
-      [142]: 'Cannot use new with import(...)',
-      [143]: '... is not allowed in import()',
-      [144]: "Expected '=>'",
-      [145]: "Duplicate binding '%0'",
-      [146]: 'Duplicate private identifier #%0',
-      [147]: "Cannot export a duplicate name '%0'",
-      [150]: 'Duplicate %0 for-binding',
-      [148]: "Exported binding '%0' needs to refer to a top-level declared variable",
-      [149]: 'Unexpected private field',
-      [153]: 'Numeric separators are not allowed at the end of numeric literals',
-      [152]: 'Only one underscore is allowed as numeric separator',
-      [154]: 'JSX value should be either an expression or a quoted JSX text',
-      [155]: 'Expected corresponding JSX closing tag for %0',
-      [156]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
-      [157]: "JSX attributes must only be assigned a non-empty 'expression'",
-      [158]: "'%0' has already been declared",
-      [159]: "'%0' shadowed a catch clause binding",
-      [160]: 'Dot property must be an identifier',
-      [161]: 'Encountered invalid input after spread/rest argument',
-      [162]: 'Catch without try',
-      [163]: 'Finally without try',
-      [164]: 'Expected corresponding closing tag for JSX fragment',
-      [165]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
-      [166]: 'Invalid tagged template on optional chain',
-      [167]: 'Invalid optional chain from super property',
-      [168]: 'Invalid optional chain from new expression',
-      [169]: 'Cannot use "import.meta" outside a module',
-      [170]: 'Leading decorators must be attached to a class declaration',
-      [171]: 'An export name cannot include a lone surrogate',
-      [172]: 'A string literal cannot be used as an exported binding without `from`',
-      [173]: "Private fields can't be accessed on super",
-      [174]: "The only valid meta property for import is 'import.meta'",
-      [175]: "'import.meta' must not contain escaped characters",
-      [176]: 'cannot use "await" as identifier inside an async function',
-      [177]: 'cannot use "await" in static blocks',
+      [108]: "'import defer' must be followed by a namespace import",
+      [109]: "'import source' must be followed by a default import",
+      [110]: 'Trailing decorator may be followed by method',
+      [111]: "Decorators can't be used with a constructor",
+      [112]: 'Can not use `await` as identifier in module or async func',
+      [113]: 'Can not use `await` as identifier in module',
+      [114]: 'HTML comments are only allowed with web compatibility (Annex B)',
+      [115]: "The identifier 'let' must not be in expression position in strict mode",
+      [116]: 'Cannot assign to `eval` and `arguments` in strict mode',
+      [117]: "The left-hand side of a for-of loop may not start with 'let'",
+      [118]: 'Block body arrows can not be immediately invoked without a group',
+      [119]: 'Block body arrows can not be immediately accessed without a group',
+      [120]: 'Unexpected strict mode reserved word',
+      [121]: 'Unexpected eval or arguments in strict mode',
+      [122]: 'Decorators must not be followed by a semicolon',
+      [123]: 'Calling delete on expression not allowed in strict mode',
+      [124]: 'Pattern can not have a tail',
+      [126]: 'Can not have a `yield` expression on the left side of a ternary',
+      [127]: 'An arrow function can not have a postfix update operator',
+      [128]: 'Invalid object literal key character after generator star',
+      [129]: 'Private fields can not be deleted',
+      [131]: 'Classes may not have a field called constructor',
+      [130]: 'Classes may not have a private element named constructor',
+      [132]: 'A class field initializer or static block may not contain arguments',
+      [133]: 'Generators can only be declared at the top level or inside a block',
+      [134]: 'Async methods are a restricted production and cannot have a newline following it',
+      [135]: 'Unexpected character after object literal property name',
+      [137]: 'Invalid key token',
+      [138]: "Label '%0' has already been declared",
+      [139]: 'continue statement must be nested within an iteration statement',
+      [140]: "Undefined label '%0'",
+      [141]: 'Trailing comma is disallowed inside import(...) arguments',
+      [142]: 'Invalid binding in JSON import',
+      [143]: 'import() requires exactly one argument',
+      [144]: 'Cannot use new with import(...)',
+      [145]: '... is not allowed in import()',
+      [146]: "Expected '=>'",
+      [147]: "Duplicate binding '%0'",
+      [148]: 'Duplicate private identifier #%0',
+      [149]: "Cannot export a duplicate name '%0'",
+      [152]: 'Duplicate %0 for-binding',
+      [150]: "Exported binding '%0' needs to refer to a top-level declared variable",
+      [151]: 'Unexpected private field',
+      [155]: 'Numeric separators are not allowed at the end of numeric literals',
+      [154]: 'Only one underscore is allowed as numeric separator',
+      [156]: 'JSX value should be either an expression or a quoted JSX text',
+      [157]: 'Expected corresponding JSX closing tag for %0',
+      [158]: 'Adjacent JSX elements must be wrapped in an enclosing tag',
+      [159]: "JSX attributes must only be assigned a non-empty 'expression'",
+      [160]: "'%0' has already been declared",
+      [161]: "'%0' shadowed a catch clause binding",
+      [162]: 'Dot property must be an identifier',
+      [163]: 'Encountered invalid input after spread/rest argument',
+      [164]: 'Catch without try',
+      [165]: 'Finally without try',
+      [166]: 'Expected corresponding closing tag for JSX fragment',
+      [167]: 'Coalescing and logical operators used together in the same expression must be disambiguated with parentheses',
+      [168]: 'Invalid tagged template on optional chain',
+      [169]: 'Invalid optional chain from super property',
+      [170]: 'Invalid optional chain from new expression',
+      [171]: 'Cannot use "import.meta" outside a module',
+      [172]: 'Leading decorators must be attached to a class declaration',
+      [173]: 'An export name cannot include a lone surrogate',
+      [174]: 'A string literal cannot be used as an exported binding without `from`',
+      [175]: "Private fields can't be accessed on super",
+      [176]: "The only valid meta property for import is 'import.meta'",
+      [177]: "'import.meta' must not contain escaped characters",
+      [178]: 'cannot use "await" as identifier inside an async function',
+      [179]: 'cannot use "await" in static blocks',
+      [180]: "Unexpected token `}`. Did you mean `}` or `{'}'}`?",
+      [181]: "Unexpected token `>`. Did you mean `>` or `{'>'}`?",
   };
   class ParseError extends SyntaxError {
       start;
@@ -815,10 +819,6 @@
   }
   const isParseError = (error) => error instanceof ParseError;
 
-  function getOwnProperty(object, key) {
-      return Object.hasOwn(object, key) ? object[key] : undefined;
-  }
-
   const KeywordDescTable = [
       'end of source',
       'identifier', 'number', 'string', 'regular expression',
@@ -840,75 +840,82 @@
       'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
       'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
   ];
-  const descKeywordTable = {
-      this: 86111,
-      function: 86104,
-      if: 20569,
-      return: 20572,
-      var: 86088,
-      else: 20563,
-      for: 20567,
-      new: 86107,
-      in: 8673330,
-      typeof: 16863275,
-      while: 20578,
-      case: 20556,
-      break: 20555,
-      try: 20577,
-      catch: 20557,
-      delete: 16863276,
-      throw: 86112,
-      switch: 86110,
-      continue: 20559,
-      default: 20561,
-      instanceof: 8411187,
-      do: 20562,
-      void: 16863277,
-      finally: 20566,
-      async: 209005,
-      await: 209006,
-      class: 86094,
-      const: 86090,
-      constructor: 12399,
-      debugger: 20560,
-      export: 20564,
-      extends: 20565,
-      false: 86021,
-      from: 209011,
-      get: 209008,
-      implements: 36964,
-      import: 86106,
-      interface: 36965,
-      let: 241737,
-      null: 86023,
-      of: 471156,
-      using: 209013,
-      package: 36966,
-      private: 36967,
-      protected: 36968,
-      public: 36969,
-      set: 209009,
-      static: 36970,
-      super: 86109,
-      true: 86022,
-      with: 20579,
-      yield: 241771,
-      enum: 86134,
-      eval: 537079927,
-      as: 77932,
-      arguments: 537079928,
-      target: 209030,
-      meta: 209031,
-      accessor: 12402,
-  };
+  const descKeywordTable = new Map([
+      ['this', 86111],
+      ['function', 86104],
+      ['if', 20569],
+      ['return', 20572],
+      ['var', 86088],
+      ['else', 20563],
+      ['for', 20567],
+      ['new', 86107],
+      ['in', 8673330],
+      ['typeof', 16863275],
+      ['while', 20578],
+      ['case', 20556],
+      ['break', 20555],
+      ['try', 20577],
+      ['catch', 20557],
+      ['delete', 16863276],
+      ['throw', 86112],
+      ['switch', 86110],
+      ['continue', 20559],
+      ['default', 20561],
+      ['instanceof', 8411187],
+      ['do', 20562],
+      ['void', 16863277],
+      ['finally', 20566],
+      ['async', 209005],
+      ['await', 209006],
+      ['class', 86094],
+      ['const', 86090],
+      ['constructor', 12399],
+      ['debugger', 20560],
+      ['export', 20564],
+      ['extends', 20565],
+      ['false', 86021],
+      ['from', 209011],
+      ['get', 209008],
+      ['implements', 36964],
+      ['import', 86106],
+      ['interface', 36965],
+      ['let', 241737],
+      ['null', 86023],
+      ['of', 471156],
+      ['using', 209013],
+      ['package', 36966],
+      ['private', 36967],
+      ['protected', 36968],
+      ['public', 36969],
+      ['set', 209009],
+      ['static', 36970],
+      ['super', 86109],
+      ['true', 86022],
+      ['with', 20579],
+      ['yield', 241771],
+      ['enum', 86134],
+      ['eval', 537079927],
+      ['as', 77932],
+      ['arguments', 537079928],
+      ['target', 209030],
+      ['meta', 209031],
+      ['accessor', 12402],
+  ]);
+  const keywordLengths = [...descKeywordTable.keys()].map((keyword) => keyword.length);
+  const minKeywordLength = Math.min(...keywordLengths);
+  const maxKeywordLength = Math.max(...keywordLengths);
 
   function scanIdentifier(parser, context, isValidAsKeyword) {
       while (isIdPart[advanceChar(parser)])
           ;
       parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
-      return parser.currentChar !== 92 && parser.currentChar <= 0x7e
-          ? (getOwnProperty(descKeywordTable, parser.tokenValue) ?? 208897)
-          : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+      if (parser.currentChar === 92 || parser.currentChar > 0x7e) {
+          return scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+      }
+      const length = parser.index - parser.tokenIndex;
+      if (length < minKeywordLength || length > maxKeywordLength)
+          return 208897;
+      return descKeywordTable.get(parser.tokenValue) ?? 208897;
   }
   function scanUnicodeIdentifier(parser, context) {
       const cookedChar = scanIdentifierUnicodeEscape(parser);
@@ -950,8 +957,8 @@
           parser.tokenValue += parser.source.slice(start, parser.index);
       }
       const { length } = parser.tokenValue;
-      if (isValidAsKeyword && length >= 2 && length <= 11) {
-          const token = getOwnProperty(descKeywordTable, parser.tokenValue);
+      if (isValidAsKeyword && length >= minKeywordLength && length <= maxKeywordLength) {
+          const token = descKeywordTable.get(parser.tokenValue);
           if (token === void 0)
               return 208897 | (hasEscape ? -2147483648 : 0);
           if (!hasEscape)
@@ -1075,7 +1082,7 @@
                   while (CharTypes[char] & (64 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator)
-                              parser.report(152);
+                              parser.report(154);
                           allowSeparator = 0;
                           char = advanceChar(parser);
                           continue;
@@ -1086,7 +1093,7 @@
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      parser.report(digits === 0 ? 21 : 153);
+                      parser.report(digits === 0 ? 21 : 155);
                   }
               }
               else if ((char | 32) === 111) {
@@ -1095,7 +1102,7 @@
                   while (CharTypes[char] & (32 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1107,7 +1114,7 @@
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      parser.report(digits === 0 ? 0 : 153);
+                      parser.report(digits === 0 ? 0 : 155);
                   }
               }
               else if ((char | 32) === 98) {
@@ -1116,7 +1123,7 @@
                   while (CharTypes[char] & (128 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1128,7 +1135,7 @@
                       char = advanceChar(parser);
                   }
                   if (digits === 0 || !allowSeparator) {
-                      parser.report(digits === 0 ? 0 : 153);
+                      parser.report(digits === 0 ? 0 : 155);
                   }
               }
               else if (CharTypes[char] & 32) {
@@ -1161,7 +1168,7 @@
                       if (char === 95) {
                           char = advanceChar(parser);
                           if (char === 95 || kind & 32) {
-                              throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
+                              throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 154);
                           }
                           allowSeparator = 1;
                           continue;
@@ -1172,7 +1179,7 @@
                       --digit;
                   }
                   if (allowSeparator) {
-                      throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
+                      throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 155);
                   }
                   if (digit >= 0 && !isIdentifierStart(char) && char !== 46) {
                       parser.tokenValue = value;
@@ -1237,7 +1244,7 @@
               const { index } = parser;
               char = advanceChar(parser);
               if (char === 95) {
-                  throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 152);
+                  throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 154);
               }
               allowSeparator = 1;
               ret += parser.source.substring(start, index);
@@ -1248,7 +1255,7 @@
           char = advanceChar(parser);
       }
       if (allowSeparator) {
-          throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 153);
+          throw new ParseError(parser.currentLocation, { index: parser.index + 1, line: parser.line, column: parser.column }, 155);
       }
       return ret + parser.source.substring(start, parser.index);
   }
@@ -1969,7 +1976,7 @@
                           advanceChar(parser);
                           if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
                               if (!parser.options.webcompat)
-                                  parser.report(112);
+                                  parser.report(114);
                               advanceChar(parser);
                               state = skipSingleHTMLComment(parser, source, state, context, 3, parser.tokenStart);
                               continue;
@@ -2198,10 +2205,10 @@
   function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
       if (context & 1) {
           if ((t & 36864) === 36864) {
-              parser.report(118);
+              parser.report(120);
           }
           if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
       }
       if ((t & 20480) === 20480 || t === -2147483527) {
@@ -2211,7 +2218,7 @@
           parser.report(100);
       }
       if (context & (2048 | 2) && t === 209006) {
-          parser.report(110);
+          parser.report(112);
       }
       if (context & (1024 | 1) && t === 241771) {
           parser.report(97, 'yield');
@@ -2220,10 +2227,10 @@
   function validateFunctionName(parser, context, t) {
       if (context & 1) {
           if ((t & 36864) === 36864) {
-              parser.report(118);
+              parser.report(120);
           }
           if ((t & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
           if (t === -2147483526) {
               parser.report(95);
@@ -2236,7 +2243,7 @@
           parser.report(102);
       }
       if (context & (2048 | 2) && t === 209006) {
-          parser.report(110);
+          parser.report(112);
       }
       if (context & (1024 | 1) && t === 241771) {
           parser.report(97, 'yield');
@@ -2245,7 +2252,10 @@
   function isStrictReservedWord(parser, context, t) {
       if (t === 209006) {
           if (context & (2048 | 2))
-              parser.report(110);
+              parser.report(112);
+          if ((parser.destructible & 128) === 0) {
+              parser.firstAwaitLocation ??= { start: parser.tokenStart, end: parser.currentLocation };
+          }
           parser.destructible |= 128;
       }
       if (t === 241771 && context & 1024)
@@ -2261,7 +2271,7 @@
       while (labels) {
           if (labels['$' + name]) {
               if (isIterationStatement)
-                  parser.report(137);
+                  parser.report(139);
               return 1;
           }
           if (isIterationStatement && labels.loop)
@@ -2274,7 +2284,7 @@
       let set = labels;
       while (set) {
           if (set['$' + name])
-              parser.report(136, name);
+              parser.report(138, name);
           set = set['$'];
       }
       labels['$' + name] = 1;
@@ -2302,14 +2312,14 @@
   function classifyIdentifier(parser, context, t) {
       if ((t & 537079808) === 537079808) {
           if (context & 1)
-              parser.report(119);
+              parser.report(121);
           parser.flags |= 512;
       }
       if (!isValidIdentifier(context, t))
           parser.report(0);
   }
 
-  const entities = {
+  const entities = new Map(Object.entries({
       AElig: '\u00C6',
       AMP: '\u0026',
       Aacute: '\u00C1',
@@ -4435,8 +4445,8 @@
       zscr: '\uD835\uDCCF',
       zwj: '\u200D',
       zwnj: '\u200C',
-  };
-  const decodeMap = {
+  }));
+  const decodeMap = new Map(Object.entries({
       '0': 65533,
       '128': 8364,
       '130': 8218,
@@ -4465,7 +4475,7 @@
       '156': 339,
       '158': 382,
       '159': 376,
-  };
+  }).map(([key, value]) => [Number(key), value]));
   function decodeHTMLStrict(text) {
       return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
           if (key.charAt(1) === '#') {
@@ -4473,14 +4483,14 @@
               const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
               return decodeCodePoint(codePoint);
           }
-          return getOwnProperty(entities, key.slice(1, -1)) ?? key;
+          return entities.get(key.slice(1, -1)) ?? key;
       });
   }
   function decodeCodePoint(codePoint) {
       if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
           return '\uFFFD';
       }
-      return String.fromCodePoint(getOwnProperty(decodeMap, codePoint) ?? codePoint);
+      return String.fromCodePoint(decodeMap.get(codePoint) ?? codePoint);
   }
 
   function scanJSXAttributeValue(parser, context) {
@@ -4527,6 +4537,12 @@
           parser.setToken(2162700);
           return;
       }
+      if (parser.currentChar === 125) {
+          parser.report(180);
+      }
+      if (parser.currentChar === 62) {
+          parser.report(181);
+      }
       let state = 0;
       while (parser.index < parser.end) {
           const type = CharTypes[parser.source.charCodeAt(parser.index)];
@@ -4565,6 +4581,8 @@
       return parser.getToken();
   }
 
+  const nextFeatures = 1 | 2 | 4;
+
   function normalizeRanges(ranges) {
       if (!ranges)
           return undefined;
@@ -4577,17 +4595,27 @@
       };
   }
   function normalizeOptions(rawOptions) {
-      const options = {
+      let { features, next, ranges, module, sourceType, globalReturn, ...restOptions } = {
           validateRegex: true,
+          features: 0,
           ...rawOptions,
-          ranges: normalizeRanges(rawOptions.ranges),
       };
-      if (options.module && !options.sourceType) {
-          options.sourceType = 'module';
+      if (next) {
+          features |= nextFeatures;
       }
-      if (options.globalReturn && (!options.sourceType || options.sourceType === 'script')) {
-          options.sourceType = 'commonjs';
+      ranges = normalizeRanges(ranges);
+      if (module && !sourceType) {
+          sourceType = 'module';
       }
+      if (globalReturn && (!sourceType || sourceType === 'script')) {
+          sourceType = 'commonjs';
+      }
+      const options = {
+          ...restOptions,
+          ranges,
+          features,
+          sourceType,
+      };
       return options;
   }
 
@@ -4608,7 +4636,7 @@
           const value = privateIdentifiers.get(name);
           if (this.hasPrivateIdentifier(name) &&
               ((value & 32) !== (focusKind & 32) || value & focusKind & 768)) {
-              this.parser.report(146, name);
+              this.parser.report(148, name);
           }
           privateIdentifiers.set(name, this.hasPrivateIdentifier(name) ? value | focusKind : focusKind);
       }
@@ -4669,17 +4697,17 @@
                       ((kind & 128 && value & 68) ||
                           (value & 128 && kind & 68))) ;
                   else {
-                      parser.report(145, name);
+                      parser.report(147, name);
                   }
               }
               if (currentScope === this) {
                   if (value && value & 1 && kind & 1) {
-                      currentScope.recordScopeError(145, name);
+                      currentScope.recordScopeError(147, name);
                   }
               }
               if (value &&
                   (value & 256 || (value & 512 && !parser.options.webcompat))) {
-                  parser.report(145, name);
+                  parser.report(147, name);
               }
               currentScope.variableBindings.set(name, kind);
               currentScope = currentScope.parent;
@@ -4688,12 +4716,12 @@
       hasVariable(name) {
           return this.variableBindings.has(name);
       }
-      addBlockName(context, name, kind, origin) {
+      addBlockName(context, name, kind, origin = 0) {
           const { parser } = this;
           const value = this.variableBindings.get(name);
           if (value && (value & 2) === 0) {
               if (kind & 1) {
-                  this.recordScopeError(145, name);
+                  this.recordScopeError(147, name);
               }
               else if (parser.options.webcompat &&
                   (context & 1) === 0 &&
@@ -4701,22 +4729,22 @@
                   value === 64 &&
                   kind === 64) ;
               else {
-                  parser.report(145, name);
+                  parser.report(147, name);
               }
           }
           if (this.type & 64 &&
               this.parent?.hasVariable(name) &&
               (this.parent.variableBindings.get(name) & 2) === 0) {
-              parser.report(145, name);
+              parser.report(147, name);
           }
           if (this.type & 512 && value && (value & 2) === 0) {
               if (kind & 1) {
-                  this.recordScopeError(145, name);
+                  this.recordScopeError(147, name);
               }
           }
           if (this.type & 32) {
               if (this.parent.variableBindings.get(name) & 768)
-                  parser.report(159, name);
+                  parser.report(161, name);
           }
           this.variableBindings.set(name, kind);
       }
@@ -4738,7 +4766,7 @@
   }
   function createArrowHeadParsingScope(parser, context, value) {
       const scope = parser.createScope().createChildScope(512);
-      scope.addBlockName(context, value, 1, 0);
+      scope.addBlockName(context, value, 1);
       return scope;
   }
 
@@ -4748,6 +4776,7 @@
       options;
       token = 1048576;
       flags = 0;
+      features = 0;
       index = 0;
       line = 1;
       column = 0;
@@ -4767,12 +4796,14 @@
       assignable = 0;
       destructible = 0;
       strictReservedRange = null;
+      firstAwaitLocation = null;
       leadingDecorators = { decorators: [] };
       constructor(source, rawOptions = {}) {
           this.source = source;
           this.end = source.length;
           this.currentChar = source.charCodeAt(0);
           this.options = normalizeOptions(rawOptions);
+          this.features = this.options.features;
           if (Array.isArray(this.options.onComment)) {
               this.options.onComment = pushComment(this.options.onComment, this.options);
           }
@@ -4853,7 +4884,7 @@
       declareUnboundVariable(name) {
           const { exportedNames } = this;
           if (exportedNames.has(name)) {
-              this.report(147, name);
+              this.report(149, name);
           }
           exportedNames.add(name);
       }
@@ -4876,29 +4907,10 @@
           return undefined;
       }
       cloneIdentifier(original) {
-          return this.cloneLocationInformation({ ...original }, original);
+          return structuredClone(original);
       }
       cloneStringLiteral(original) {
-          return this.cloneLocationInformation({ ...original }, original);
-      }
-      cloneLocationInformation(node, original) {
-          const { ranges } = this.options;
-          if (ranges) {
-              if (ranges.start)
-                  node.start = original.start;
-              if (ranges.end)
-                  node.end = original.end;
-              if (ranges.range)
-                  node.range = [...original.range];
-          }
-          if (this.options.loc) {
-              node.loc = {
-                  ...original.loc,
-                  start: { ...original.loc.start },
-                  end: { ...original.loc.end },
-              };
-          }
-          return node;
+          return structuredClone(original);
       }
   }
   function pushComment(comments, options) {
@@ -4961,7 +4973,7 @@
           if (scope) {
               for (const name of parser.exportedBindings) {
                   if (!scope.hasVariable(name))
-                      parser.report(148, name);
+                      parser.report(150, name);
               }
           }
       }
@@ -4993,7 +5005,7 @@
           statements.push(parseDirective(parser, context, expr, token, tokenStart));
       }
       while (parser.getToken() !== 1048576) {
-          statements.push(parseStatementListItem(parser, context, scope, undefined, 4, {}));
+          statements.push(parseStatementListItem(parser, context, scope, undefined, {}, 4));
       }
       return statements;
   }
@@ -5023,36 +5035,42 @@
               moduleItem = parseExportDeclaration(parser, context, scope);
               break;
           case 86106:
+              if (parser.leadingDecorators.decorators.length) {
+                  parser.report(172);
+              }
               moduleItem = parseImportDeclaration(parser, context, scope);
               break;
           default:
-              moduleItem = parseStatementListItem(parser, context, scope, undefined, 4, {});
-      }
-      if (parser.leadingDecorators?.decorators.length) {
-          parser.report(170);
+              moduleItem = parseStatementListItem(parser, context, scope, undefined, {}, 4);
       }
       return moduleItem;
   }
-  function parseStatementListItem(parser, context, scope, privateScope, origin, labels) {
+  function parseStatementListItem(parser, context, scope, privateScope, labels, origin = 2) {
       const start = parser.tokenStart;
+      if (parser.leadingDecorators.decorators.length && parser.getToken() !== 86094) {
+          parser.report(172);
+      }
       switch (parser.getToken()) {
           case 86104:
-              return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start);
+              return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 0, start, origin);
           case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               return parseClassDeclaration(parser, context, scope, privateScope, 0);
           case 86090:
-              return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
+              return parseLexicalDeclaration(parser, context, scope, privateScope, 16);
           case 241737:
               return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
           case 209013:
-              return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+              return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin);
           case 209006:
               if ((context & 2048 || (context & 2 && context & 8)) &&
                   nextTokenIsUsingOnSameLine(parser)) {
-                  return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+                  return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin);
               }
-              return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
+              return parseStatement(parser, context, scope, privateScope, labels, 1, origin);
           case 20564:
               parser.report(103, 'export');
           case 86106:
@@ -5066,15 +5084,15 @@
                       parser.report(103, 'import');
               }
           case 209005:
-              return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1);
+              return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 1, origin);
           default:
-              return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
+              return parseStatement(parser, context, scope, privateScope, labels, 1, origin);
       }
   }
-  function parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+  function parseStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin = 0) {
       switch (parser.getToken()) {
           case 86088:
-              return parseVariableStatement(parser, context, scope, privateScope, 0);
+              return parseVariableStatement(parser, context, scope, privateScope);
           case 20572:
               return parseReturnStatement(parser, context, privateScope);
           case 20569:
@@ -5104,11 +5122,11 @@
           case 20560:
               return parseDebuggerStatement(parser, context);
           case 209005:
-              return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
+              return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 0, origin);
           case 20557:
-              parser.report(162);
+              parser.report(164);
           case 20566:
-              parser.report(163);
+              parser.report(165);
           case 86104:
               parser.report(context & 1
                   ? 76
@@ -5118,10 +5136,10 @@
           case 86094:
               parser.report(79);
           default:
-              return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
+              return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin);
       }
   }
-  function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+  function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin) {
       const { tokenValue, tokenStart } = parser;
       const token = parser.getToken();
       let expr;
@@ -5136,11 +5154,11 @@
           default:
               expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart);
       }
-      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, expr, token, tokenValue, tokenStart);
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, expr, token, tokenValue, tokenStart, origin);
   }
-  function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart) {
+  function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart, origin) {
       if (token & 143360 && parser.getToken() === 21) {
-          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart);
+          return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart, origin);
       }
       let expression = parseMemberOrUpdateExpression(parser, context, privateScope, initialExpression, 0, 0, tokenStart);
       expression = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expression);
@@ -5153,7 +5171,7 @@
       const body = [];
       consume(parser, context | 32, 2162700);
       while (parser.getToken() !== 1074790415) {
-          body.push(parseStatementListItem(parser, context, scope, privateScope, 2, { $: labels }));
+          body.push(parseStatementListItem(parser, context, scope, privateScope, { $: labels }));
       }
       consume(parser, context | 32, 1074790415);
       return parser.finishNode({
@@ -5182,7 +5200,7 @@
           expression,
       }, start);
   }
-  function parseLabelledStatement(parser, context, scope, privateScope, origin, labels, value, expr, token, allowFuncDecl, start) {
+  function parseLabelledStatement(parser, context, scope, privateScope, labels, value, expr, token, allowFuncDecl, start, origin) {
       validateBindingIdentifier(parser, context, 0, token, 1);
       validateAndDeclareLabel(parser, labels, value);
       nextToken(parser, context | 32);
@@ -5190,27 +5208,27 @@
           (context & 1) === 0 &&
           parser.options.webcompat &&
           parser.getToken() === 86104
-          ? parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, origin, 0, 0, 0, parser.tokenStart)
-          : parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
+          ? parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, parser.tokenStart, origin)
+          : parseStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin);
       return parser.finishNode({
           type: 'LabeledStatement',
           label: expr,
           body,
       }, start);
   }
-  function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+  function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, allowFuncDecl, origin) {
       const { tokenValue, tokenStart: start } = parser;
       const token = parser.getToken();
       let expr = parseIdentifier(parser, context);
       if (parser.getToken() === 21) {
-          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, 1, start);
+          return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, expr, token, 1, start, origin);
       }
       const asyncNewLine = parser.flags & 1;
       if (!asyncNewLine) {
           if (parser.getToken() === 86104) {
               if (!allowFuncDecl)
-                  parser.report(123);
-              return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
+                  parser.report(125);
+              return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 1, start, origin);
           }
           if (isValidIdentifier(context, parser.getToken())) {
               expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start);
@@ -5220,7 +5238,7 @@
           }
       }
       if (parser.getToken() === 67174411) {
-          expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, 0, asyncNewLine, start);
+          expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, asyncNewLine, start);
       }
       else {
           if (parser.getToken() === 10) {
@@ -5306,8 +5324,8 @@
       return context & 1 ||
           !parser.options.webcompat ||
           parser.getToken() !== 86104
-          ? parseStatement(parser, context, scope, privateScope, 0, { $: labels }, 0)
-          : parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, 0, tokenStart);
+          ? parseStatement(parser, context, scope, privateScope, { $: labels }, 0)
+          : parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, tokenStart);
   }
   function parseSwitchStatement(parser, context, scope, privateScope, labels) {
       const start = parser.tokenStart;
@@ -5336,7 +5354,7 @@
           while (parser.getToken() !== 20556 &&
               parser.getToken() !== 1074790415 &&
               parser.getToken() !== 20561) {
-              const statement = parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
+              const statement = parseStatementListItem(parser, context | 4, scope, privateScope, {
                   $: labels,
               });
               if (statement.type === 'VariableDeclaration' &&
@@ -5372,7 +5390,7 @@
       }, start);
   }
   function parseIterationStatementBody(parser, context, scope, privateScope, labels) {
-      return parseStatement(parser, ((context | 131072) ^ 131072) | 128, scope, privateScope, 0, { loop: 1, $: labels }, 0);
+      return parseStatement(parser, ((context | 131072) ^ 131072) | 128, scope, privateScope, { loop: 1, $: labels }, 0);
   }
   function parseContinueStatement(parser, context, labels) {
       if ((context & 128) === 0)
@@ -5384,7 +5402,7 @@
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32);
           if (!isValidLabel(parser, labels, tokenValue, 1))
-              parser.report(138, tokenValue);
+              parser.report(140, tokenValue);
       }
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode({
@@ -5400,7 +5418,7 @@
           const { tokenValue } = parser;
           label = parseIdentifier(parser, context | 32);
           if (!isValidLabel(parser, labels, tokenValue, 0))
-              parser.report(138, tokenValue);
+              parser.report(140, tokenValue);
       }
       else if ((context & (4 | 128)) === 0) {
           parser.report(69);
@@ -5419,7 +5437,7 @@
       consume(parser, context | 32, 67174411);
       const object = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
       consume(parser, context | 32, 16);
-      const body = parseStatement(parser, context, scope, privateScope, 2, labels, 0);
+      const body = parseStatement(parser, context, scope, privateScope, labels, 0, 2);
       return parser.finishNode({
           type: 'WithStatement',
           object,
@@ -5466,7 +5484,7 @@
           scope = scope?.createChildScope(4);
           param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
               ? 256
-              : 512, 0);
+              : 512);
           if (parser.getToken() === 18) {
               parser.report(86);
           }
@@ -5515,7 +5533,7 @@
       let expr = parseIdentifier(parser, context);
       if (parser.getToken() & (143360 | 2097152) &&
           (parser.getToken() & 20480) !== 20480) {
-          const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
+          const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8);
           matchOrInsertSemicolon(parser, context | 32);
           return parser.finishNode({
               type: 'VariableDeclaration',
@@ -5527,7 +5545,7 @@
       if (context & 1)
           parser.report(85);
       if (parser.getToken() === 21) {
-          return parseLabelledStatement(parser, context, scope, privateScope, origin, {}, tokenValue, expr, token, 0, tokenStart);
+          return parseLabelledStatement(parser, context, scope, privateScope, {}, tokenValue, expr, token, 0, tokenStart, origin);
       }
       if (parser.getToken() === 10) {
           let scope = void 0;
@@ -5581,23 +5599,26 @@
   function isResourceBindingStart(token) {
       return (token & 143360) === 143360 && (token & 20480) !== 20480;
   }
-  function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+  function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin) {
       const { tokenStart, tokenValue } = parser;
       const token = parser.getToken();
       const expression = parseIdentifier(parser, context);
       if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
-          if (origin & 4 && context & 8 && (context & 2) === 0) {
+          if (origin & 4 &&
+              context & 8 &&
+              (context & 2) === 0 &&
+              (context & 4096) === 0) {
               parser.report(30, KeywordDescTable[parser.getToken() & 255]);
           }
           return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'using', tokenStart, 1);
       }
       parser.assignable = 1;
-      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 1, expression, token, tokenValue, tokenStart);
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, 1, expression, token, tokenValue, tokenStart, origin);
   }
-  function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+  function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin) {
       const start = parser.tokenStart;
       if (context & 524288)
-          parser.report(177);
+          parser.report(179);
       nextToken(parser, context | 32);
       let argument;
       if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5618,9 +5639,9 @@
           type: 'AwaitExpression',
           argument,
       }, start);
-      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 0, expression, 1048576, '', start);
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, 0, expression, 1048576, '', start, origin);
   }
-  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
+  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin = 0, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
       const start = declarationStart;
       if (!keywordConsumed)
           nextToken(parser, context);
@@ -5632,7 +5653,7 @@
           declarations,
       }, start);
   }
-  function parseVariableStatement(parser, context, scope, privateScope, origin) {
+  function parseVariableStatement(parser, context, scope, privateScope, origin = 0) {
       const start = parser.tokenStart;
       nextToken(parser, context);
       const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 4, origin);
@@ -5643,7 +5664,7 @@
           declarations,
       }, start);
   }
-  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind) {
+  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin = 0, declarationKind) {
       let bindingCount = 1;
       const firstDeclaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
       const list = [firstDeclaration];
@@ -5654,7 +5675,7 @@
           if (resourceNames) {
               const { name } = declaration.id;
               if (resourceNames.has(name))
-                  parser.report(145, name);
+                  parser.report(147, name);
               resourceNames.add(name);
           }
           list.push(declaration);
@@ -5674,11 +5695,14 @@
       const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
       if (parser.getToken() === 1077936155) {
           nextToken(parser, context | 32);
-          init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
+          init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart, origin);
           if (origin & 32) {
               if (parser.getToken() === 471156 ||
                   (parser.getToken() === 8673330 &&
-                      (token & 2097152 || (kind & 4) === 0 || context & 1))) {
+                      (token & 2097152 ||
+                          (kind & 4) === 0 ||
+                          context & 1 ||
+                          !parser.options.webcompat))) {
                   throw new ParseError(tokenStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
               }
           }
@@ -5733,7 +5757,7 @@
                   parser.assignable = 1;
                   init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
                   if (parser.getToken() === 471156)
-                      parser.report(115);
+                      parser.report(117);
               }
           }
           else if (token === 209013) {
@@ -5785,7 +5809,7 @@
                           if (resourceNames) {
                               const { name } = declaration.id;
                               if (resourceNames.has(name))
-                                  parser.report(145, name);
+                                  parser.report(147, name);
                               resourceNames.add(name);
                           }
                           declarations.push(declaration);
@@ -5830,7 +5854,7 @@
       else if (token === 209006 &&
           (context & 2048 || (context & 2 && context & 8))) {
           if (context & 524288)
-              parser.report(177);
+              parser.report(179);
           nextToken(parser, context | 32);
           let awaitArgument;
           if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5948,16 +5972,18 @@
   }
   function parseRestrictedIdentifier(parser, context, scope) {
       if (!isValidIdentifier(context, parser.getToken()))
-          parser.report(118);
+          parser.report(120);
       if ((parser.getToken() & 537079808) === 537079808)
-          parser.report(119);
-      scope?.addBlockName(context, parser.tokenValue, 8, 0);
+          parser.report(121);
+      scope?.addBlockName(context, parser.tokenValue, 8);
       return parseIdentifier(parser, context);
   }
   function parseImportDeclaration(parser, context, scope) {
       const start = parser.tokenStart;
       nextToken(parser, context);
       let source;
+      let sourceParsed = false;
+      let phase = null;
       const { tokenStart } = parser;
       let specifiers = [];
       if (parser.getToken() === 134283267) {
@@ -5965,14 +5991,93 @@
       }
       else {
           if (parser.getToken() & 143360) {
-              const local = parseRestrictedIdentifier(parser, context, scope);
-              specifiers = [
-                  parser.finishNode({
-                      type: 'ImportDefaultSpecifier',
-                      local,
-                  }, tokenStart),
-              ];
-              if (consumeOpt(parser, context, 18)) {
+              const token = parser.getToken();
+              const { tokenValue } = parser;
+              const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && tokenValue == 'defer';
+              const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && tokenValue == 'source';
+              if (isPhaseDefer || isPhaseSource) {
+                  const phaseOrLocal = parseIdentifier(parser, context);
+                  if (tokenValue === 'defer') {
+                      if (parser.getToken() === 8391476) {
+                          phase = 'defer';
+                          specifiers = [parseImportNamespaceSpecifier(parser, context, scope)];
+                      }
+                      else if (parser.getToken() === 209011 || parser.getToken() === 18) {
+                          scope?.addBlockName(context, tokenValue, 8);
+                          specifiers = [
+                              parser.finishNode({
+                                  type: 'ImportDefaultSpecifier',
+                                  local: phaseOrLocal,
+                              }, tokenStart),
+                          ];
+                      }
+                      else {
+                          parser.report(108);
+                      }
+                  }
+                  else if (parser.getToken() === 209011) {
+                      const fromToken = parser.getToken();
+                      const fromStart = parser.tokenStart;
+                      const fromLocal = parseIdentifier(parser, context);
+                      if (parser.getToken() === 209011) {
+                          validateBindingIdentifier(parser, context, 16, fromToken, 0);
+                          scope?.addBlockName(context, fromLocal.name, 8);
+                          phase = 'source';
+                          specifiers = [
+                              parser.finishNode({
+                                  type: 'ImportDefaultSpecifier',
+                                  local: fromLocal,
+                              }, fromStart),
+                          ];
+                      }
+                      else {
+                          scope?.addBlockName(context, tokenValue, 8);
+                          specifiers = [
+                              parser.finishNode({
+                                  type: 'ImportDefaultSpecifier',
+                                  local: phaseOrLocal,
+                              }, tokenStart),
+                          ];
+                          if (parser.getToken() !== 134283267)
+                              parser.report(105, 'Import');
+                          source = parseLiteral(parser, context);
+                          sourceParsed = true;
+                      }
+                  }
+                  else if (parser.getToken() & 143360) {
+                      phase = 'source';
+                      const localStart = parser.tokenStart;
+                      const local = parseRestrictedIdentifier(parser, context, scope);
+                      specifiers = [
+                          parser.finishNode({
+                              type: 'ImportDefaultSpecifier',
+                              local,
+                          }, localStart),
+                      ];
+                  }
+                  else if (parser.getToken() === 18) {
+                      scope?.addBlockName(context, tokenValue, 8);
+                      specifiers = [
+                          parser.finishNode({
+                              type: 'ImportDefaultSpecifier',
+                              local: phaseOrLocal,
+                          }, tokenStart),
+                      ];
+                  }
+                  else {
+                      parser.report(109);
+                  }
+              }
+              else {
+                  const local = parseRestrictedIdentifier(parser, context, scope);
+                  specifiers = [
+                      parser.finishNode({
+                          type: 'ImportDefaultSpecifier',
+                          local,
+                      }, tokenStart),
+                  ];
+              }
+              if (phase === null && !sourceParsed && consumeOpt(parser, context, 18)) {
                   switch (parser.getToken()) {
                       case 8391476:
                           specifiers.push(parseImportNamespaceSpecifier(parser, context, scope));
@@ -6001,7 +6106,8 @@
                       parser.report(30, KeywordDescTable[parser.getToken() & 255]);
               }
           }
-          source = parseModuleSpecifier(parser, context);
+          if (!sourceParsed)
+              source = parseModuleSpecifier(parser, context);
       }
       const attributes = parseImportAttributes(parser, context);
       const node = {
@@ -6009,6 +6115,7 @@
           specifiers,
           source,
           attributes,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode(node, start);
@@ -6056,7 +6163,7 @@
           else {
               parser.report(25, KeywordDescTable[77932 & 255]);
           }
-          scope?.addBlockName(context, tokenValue, 8, 0);
+          scope?.addBlockName(context, tokenValue, 8);
           specifiers.push(parser.finishNode({
               type: 'ImportSpecifier',
               local,
@@ -6091,17 +6198,24 @@
   function parseExportDeclaration(parser, context, scope) {
       const start = parser.leadingDecorators.decorators.length ? parser.leadingDecorators.start : parser.tokenStart;
       nextToken(parser, context | 32);
+      const isDefaultExport = consumeOpt(parser, context | 32, 20561);
+      if (parser.leadingDecorators.decorators.length && parser.getToken() !== 86094) {
+          parser.report(172);
+      }
       const specifiers = [];
       let declaration = null;
       let source = null;
       let attributes = [];
-      if (consumeOpt(parser, context | 32, 20561)) {
+      if (isDefaultExport) {
           switch (parser.getToken()) {
               case 86104: {
-                  declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 0, parser.tokenStart);
+                  declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 1, 0, parser.tokenStart, 4);
                   break;
               }
               case 133:
+                  if (!(parser.features & 1)) {
+                      parser.report(30, '@');
+                  }
               case 86094:
                   declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                   break;
@@ -6111,11 +6225,11 @@
                   const { flags } = parser;
                   if ((flags & 1) === 0) {
                       if (parser.getToken() === 86104) {
-                          declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 1, tokenStart);
+                          declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 1, 1, tokenStart, 4);
                       }
                       else {
                           if (parser.getToken() === 67174411) {
-                              declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, 0, flags, tokenStart);
+                              declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, flags, tokenStart);
                               declaration = parseMemberOrUpdateExpression(parser, context, undefined, declaration, 0, 0, tokenStart);
                               declaration = parseAssignmentExpression(parser, context, undefined, 0, 0, tokenStart, declaration);
                           }
@@ -6214,7 +6328,7 @@
               }
               else {
                   if (hasLiteralLocal) {
-                      parser.report(172);
+                      parser.report(174);
                   }
                   if (scope) {
                       tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -6225,11 +6339,14 @@
               break;
           }
           case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
               break;
           case 86104:
-              declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 0, parser.tokenStart);
+              declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 2, 0, parser.tokenStart, 4);
               break;
           case 241737:
               declaration = parseLexicalDeclaration(parser, context, scope, undefined, 8, 64);
@@ -6244,7 +6361,7 @@
               const { tokenStart } = parser;
               nextToken(parser, context);
               if ((parser.flags & 1) === 0 && parser.getToken() === 86104) {
-                  declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 1, tokenStart);
+                  declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 2, 1, tokenStart, 4);
                   break;
               }
           }
@@ -6260,8 +6377,8 @@
       };
       return parser.finishNode(node, start);
   }
-  function parseExpression(parser, context, privateScope, canAssign, inGroup, start) {
-      let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start);
+  function parseExpression(parser, context, privateScope, canAssign, inGroup, start, origin = 0) {
+      let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start, origin);
       expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
       return parseAssignmentExpression(parser, context, privateScope, inGroup, 0, start, expr);
   }
@@ -6357,7 +6474,7 @@
           t = parser.getToken();
           precedence = t & 3840;
           if ((t & 524288 && operator & 268435456) || (operator & 524288 && t & 268435456)) {
-              parser.report(165);
+              parser.report(167);
           }
           if (precedence + ((t === 8391735) << 8) - ((bit === t) << 12) <= minPrecedence)
               break;
@@ -6384,10 +6501,10 @@
           parser.report(33);
       if (context & 1 && unaryOperator === 16863276) {
           if (arg.type === 'Identifier') {
-              parser.report(121);
+              parser.report(123);
           }
           else if (isPropertyWithPrivateFieldKey(arg)) {
-              parser.report(127);
+              parser.report(129);
           }
       }
       parser.assignable = 2;
@@ -6416,7 +6533,7 @@
           }
       }
       if (!inNew && parser.getToken() === 67174411) {
-          return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, 0, flags, start);
+          return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, flags, start);
       }
       if (parser.getToken() === 10) {
           classifyIdentifier(parser, context, token);
@@ -6440,7 +6557,7 @@
           if (!canAssign)
               parser.report(26);
           if (parser.getToken() === 22)
-              parser.report(124);
+              parser.report(126);
           let argument = null;
           let delegate = false;
           if ((parser.flags & 1) === 0) {
@@ -6464,20 +6581,24 @@
       return parseIdentifierOrArrow(parser, context, privateScope);
   }
   function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start) {
-      if (inGroup)
+      if (inGroup) {
+          if ((parser.destructible & 128) === 0) {
+              parser.firstAwaitLocation ??= { start, end: parser.currentLocation };
+          }
           parser.destructible |= 128;
+      }
       if (context & 524288)
-          parser.report(177);
+          parser.report(179);
       const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope);
       const isIdentifier = possibleIdentifierOrArrowFunc.type === 'ArrowFunctionExpression' ||
           (parser.getToken() & 65536) === 0;
       if (isIdentifier) {
           if (context & 2048)
-              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 176);
+              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 178);
           if (context & 2)
-              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
+              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 112);
           if (context & 8192 && context & 2048)
-              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
+              throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 112);
           return possibleIdentifierOrArrowFunc;
       }
       if (context & 8192) {
@@ -6499,8 +6620,9 @@
           throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 98);
       return possibleIdentifierOrArrowFunc;
   }
-  function parseFunctionBody(parser, context, scope, privateScope, origin, funcNameToken, functionScope) {
+  function parseFunctionBody(parser, context, scope, privateScope, funcNameToken, functionScope, origin = 0) {
       const { tokenStart } = parser;
+      parser.flags &= -4161;
       consume(parser, context | 32, 2162700);
       const body = [];
       if (parser.getToken() !== 1074790415) {
@@ -6526,19 +6648,19 @@
           if (context & 1) {
               if (funcNameToken) {
                   if ((funcNameToken & 537079808) === 537079808) {
-                      parser.report(119);
+                      parser.report(121);
                   }
                   if ((funcNameToken & 36864) === 36864) {
                       parser.report(40);
                   }
               }
               if (parser.flags & 512)
-                  parser.report(119);
+                  parser.report(121);
               if (parser.flags & 256) {
                   if (parser.strictReservedRange) {
-                      throw new ParseError(parser.strictReservedRange[0], parser.strictReservedRange[1], 118);
+                      throw new ParseError(parser.strictReservedRange[0], parser.strictReservedRange[1], 120);
                   }
-                  parser.report(118);
+                  parser.report(120);
               }
           }
       }
@@ -6547,7 +6669,7 @@
               (512 | 256 | 64 | 4096);
       parser.destructible = (parser.destructible | 256) ^ 256;
       while (parser.getToken() !== 1074790415) {
-          body.push(parseStatementListItem(parser, context, scope, privateScope, 4, {}));
+          body.push(parseStatementListItem(parser, context, scope, privateScope, {}, 4));
       }
       consume(parser, origin & (16 | 8) ? context | 32 : context, 1074790415);
       parser.flags &= -4289;
@@ -6563,7 +6685,7 @@
       nextToken(parser, context);
       switch (parser.getToken()) {
           case 67108991:
-              parser.report(167);
+              parser.report(169);
           case 67174411: {
               if ((context & 512) === 0)
                   parser.report(28);
@@ -6610,7 +6732,7 @@
               case 67108877: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
                   if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
-                      parser.report(173);
+                      parser.report(175);
                   }
                   parser.assignable =
                       (parser.flags & 2048) === 2048
@@ -6690,7 +6812,7 @@
               }
               default:
                   if ((parser.flags & 2048) === 2048) {
-                      parser.report(166);
+                      parser.report(168);
                   }
                   parser.assignable = 2;
                   expr = parser.finishNode({
@@ -6771,7 +6893,7 @@
           parser.getToken() !== -2147483527 &&
           parser.getToken() !== -2147483526 &&
           parser.getToken() !== 131) {
-          parser.report(160);
+          parser.report(162);
       }
       return parser.getToken() === 131
           ? parsePrivateIdentifier(parser, context, privateScope, 0)
@@ -6796,7 +6918,7 @@
           prefix: true,
       }, start);
   }
-  function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start) {
+  function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start, origin = 0) {
       if ((parser.getToken() & 143360) === 143360) {
           switch (parser.getToken()) {
               case 209006:
@@ -6816,16 +6938,16 @@
               if ((token & 36864) === 36864) {
                   parser.flags |= 256;
               }
-              return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start);
+              return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start, origin);
           }
           if (context & 16 &&
               !(context & 32768) &&
               !(context & 8192) &&
               parser.tokenValue === 'arguments')
-              parser.report(130);
+              parser.report(132);
           if ((token & 255) === (241737 & 255)) {
               if (context & 1)
-                  parser.report(113);
+                  parser.report(115);
               if (kind & (8 | 16))
                   parser.report(100);
           }
@@ -6857,7 +6979,7 @@
           case 69271571:
               return parseArrayLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
           case 67174411:
-              return parseParenthesizedExpression(parser, context | 64, privateScope, canAssign, 1, 0, start);
+              return parseParenthesizedExpression(parser, context | 64, privateScope, canAssign, 1, start, origin);
           case 86021:
           case 86022:
           case 86023:
@@ -6867,6 +6989,9 @@
           case 65540:
               return parseRegExpLiteral(parser, context);
           case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               return parseClassExpression(parser, context, privateScope, inGroup, start);
           case 86109:
@@ -6895,24 +7020,37 @@
   function parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start) {
       let expr = parseIdentifier(parser, context);
       if (parser.getToken() === 67108877) {
-          return parseImportMetaExpression(parser, context, expr, start);
+          return parseImportMetaExpression(parser, context, expr, start, privateScope, inGroup, inNew);
       }
       if (inNew)
-          parser.report(142);
+          parser.report(144);
       expr = parseImportExpression(parser, context, privateScope, inGroup, start);
       parser.assignable = 2;
       return parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
   }
-  function parseImportMetaExpression(parser, context, meta, start) {
-      if ((context & 2) === 0)
-          parser.report(169);
+  function parseImportMetaExpression(parser, context, meta, start, privateScope, inGroup = 0, inNew = 0) {
+      const propertyStart = parser.tokenStart;
+      const propertyEnd = parser.currentLocation;
       nextToken(parser, context);
       const token = parser.getToken();
+      const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && parser.tokenValue === 'defer';
+      const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && parser.tokenValue === 'source';
+      if (isPhaseDefer || isPhaseSource) {
+          if (inNew)
+              parser.report(144);
+          nextToken(parser, context);
+          const expression = parseImportExpression(parser, context, privateScope, inGroup, start, parser.tokenValue);
+          parser.assignable = 2;
+          return expression;
+      }
+      if ((context & 2) === 0) {
+          throw new ParseError(propertyStart, propertyEnd, 171);
+      }
       if (token !== 209031 && parser.tokenValue !== 'meta') {
-          parser.report(174);
+          parser.report(176);
       }
       else if (token & -2147483648) {
-          parser.report(175);
+          parser.report(177);
       }
       parser.assignable = 2;
       return parser.finishNode({
@@ -6921,10 +7059,10 @@
           property: parseIdentifier(parser, context),
       }, start);
   }
-  function parseImportExpression(parser, context, privateScope, inGroup, start) {
+  function parseImportExpression(parser, context, privateScope, inGroup, start, phase = null) {
       consume(parser, context | 32, 67174411);
       if (parser.getToken() === 14)
-          parser.report(143);
+          parser.report(145);
       const source = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
       let options = null;
       if (parser.getToken() === 18) {
@@ -6939,6 +7077,7 @@
           type: 'ImportExpression',
           source,
           options,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       consume(parser, context, 16);
       return parser.finishNode(node, start);
@@ -6956,7 +7095,7 @@
           const value = parseStringLiteral(parser, context);
           const keyContent = key.type === 'Literal' ? key.value : key.name;
           if (keysContent.has(keyContent)) {
-              parser.report(145, keyContent);
+              parser.report(147, keyContent);
           }
           keysContent.add(keyContent);
           attributes.push(parser.finishNode({
@@ -6994,7 +7133,7 @@
       if (parser.getToken() === 134283267) {
           const value = parser.tokenValue;
           if (!value.isWellFormed()) {
-              parser.report(171);
+              parser.report(173);
           }
           return parseLiteral(parser, context);
       }
@@ -7169,7 +7308,7 @@
           type: 'ThisExpression',
       }, tokenStart);
   }
-  function parseFunctionDeclaration(parser, context, scope, privateScope, origin, allowGen, flags, isAsync, start) {
+  function parseFunctionDeclaration(parser, context, scope, privateScope, allowGen, flags, isAsync, start, origin = 0) {
       nextToken(parser, context | 32);
       const isGenerator = allowGen ? optionalBit(parser, context, 8391476) : 0;
       let id = null;
@@ -7223,7 +7362,7 @@
       functionScope = functionScope?.createChildScope(256);
       const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, functionScope, privateScope, 0, 1);
       const modifierFlags = 8 | 4 | 128 | 524288;
-      const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 32768 | 4096, functionScope?.createChildScope(64), privateScope, 8, funcNameToken, functionScope);
+      const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 32768 | 4096, functionScope?.createChildScope(64), privateScope, funcNameToken, functionScope, 8);
       return parser.finishNode({
           type: 'FunctionDeclaration',
           id,
@@ -7262,7 +7401,7 @@
       const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, scope, privateScope, inGroup, 1);
       const body = parseFunctionBody(parser, (context & -131229) |
           32768 |
-          4096, scope?.createChildScope(64), privateScope, 0, funcNameToken, scope);
+          4096, scope?.createChildScope(64), privateScope, funcNameToken, scope);
       parser.assignable = 2;
       return parser.finishNode({
           type: 'FunctionExpression',
@@ -7274,7 +7413,7 @@
       }, start);
   }
   function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGroup) {
-      const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
+      const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2);
       if (parser.destructible & 64) {
           parser.report(63);
       }
@@ -7283,7 +7422,7 @@
       }
       return expr;
   }
-  function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+  function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
       const { tokenStart: start } = parser;
       nextToken(parser, context | 32);
       const elements = [];
@@ -7392,7 +7531,7 @@
                   }
               }
               else if (token === 14) {
-                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, origin, 0, inGroup, isPattern);
+                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, 0, inGroup, isPattern, origin);
                   destructible |= parser.destructible;
                   if (parser.getToken() !== 18 && parser.getToken() !== 20)
                       parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -7462,7 +7601,7 @@
               right,
           }, start);
   }
-  function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, origin, isAsync, inGroup, isPattern) {
+  function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, isAsync, inGroup, isPattern, origin = 0) {
       const { tokenStart: start } = parser;
       nextToken(parser, context | 32);
       let argument = null;
@@ -7555,7 +7694,7 @@
           }
           parser.destructible = destructible;
           if (parser.getToken() !== closingToken && parser.getToken() !== 18)
-              parser.report(161);
+              parser.report(163);
           return parser.finishNode({
               type: isPattern ? 'RestElement' : 'SpreadElement',
               argument: argument,
@@ -7611,7 +7750,7 @@
       scope = scope?.createChildScope(64);
       const body = parseFunctionBody(parser, (context & -655373) |
           32768 |
-          4096, scope, privateScope, 0, void 0, scope?.parent);
+          4096, scope, privateScope, void 0, scope?.parent);
       return parser.finishNode({
           type: 'FunctionExpression',
           params,
@@ -7622,7 +7761,7 @@
       }, start);
   }
   function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGroup) {
-      const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
+      const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2);
       if (parser.destructible & 64) {
           parser.report(63);
       }
@@ -7631,7 +7770,7 @@
       }
       return expr;
   }
-  function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+  function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
       const { tokenStart: start } = parser;
       nextToken(parser, context);
       const properties = [];
@@ -7642,7 +7781,7 @@
           const { tokenValue, tokenStart } = parser;
           const token = parser.getToken();
           if (token === 14) {
-              properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, origin, 0, inGroup, isPattern));
+              properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, 0, inGroup, isPattern, origin));
           }
           else {
               let state = 0;
@@ -7814,7 +7953,7 @@
                           parser.report(95);
                       if (token === 209005) {
                           if (parser.flags & 1)
-                              parser.report(132);
+                              parser.report(134);
                           state |= 16 | 1;
                       }
                       else if (token === 209008) {
@@ -7878,7 +8017,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(133);
+                      parser.report(135);
                   }
               }
               else if ((parser.getToken() & 134217728) === 134217728) {
@@ -7982,7 +8121,7 @@
                       destructible = 16;
                   }
                   else {
-                      parser.report(134);
+                      parser.report(136);
                   }
               }
               else if (parser.getToken() === 69271571) {
@@ -8129,7 +8268,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(126);
+                      parser.report(128);
                   }
               }
               else {
@@ -8170,6 +8309,7 @@
       const params = [];
       parser.flags = (parser.flags | 128) ^ 128;
       parser.strictReservedRange = null;
+      parser.firstAwaitLocation = null;
       if (parser.getToken() === 16) {
           if (kind & 512) {
               parser.report(37, 'Setter', 'one', '');
@@ -8199,17 +8339,17 @@
                       parser.flags |= 512;
                   }
               }
-              left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
+              left = parseAndClassifyIdentifier(parser, context, scope, kind | 1);
           }
           else {
               if (parser.getToken() === 2162700) {
-                  left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
+                  left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type);
               }
               else if (parser.getToken() === 69271571) {
-                  left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
+                  left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type);
               }
               else if (parser.getToken() === 14) {
-                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, 0, inGroup, 1);
+                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, inGroup, 1);
               }
               isNonSimpleParameterList = 1;
               if (parser.destructible & (32 | 16))
@@ -8248,17 +8388,20 @@
       consume(parser, context, 20);
       return key;
   }
-  function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, origin, start) {
+  function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, start, origin) {
       parser.flags = (parser.flags | 128) ^ 128;
       const parenthesesStart = parser.tokenStart;
       nextToken(parser, context | 32 | 262144);
       const scope = parser.createScopeIfLexical()?.createChildScope(512);
       context = (context | 131072) ^ 131072;
       if (consumeOpt(parser, context, 16)) {
-          return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start);
+          return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start, origin);
       }
       let destructible = 0;
+      const previousAwaitYield = parser.destructible & (256 | 128);
       parser.destructible &= -385;
+      const previousFirstAwaitLocation = parser.firstAwaitLocation;
+      parser.firstAwaitLocation = null;
       let expr;
       let expressions = [];
       let isSequence = 0;
@@ -8270,14 +8413,14 @@
           const { tokenStart } = parser;
           const token = parser.getToken();
           if (token & 143360) {
-              scope?.addBlockName(context, parser.tokenValue, 1, 0);
+              scope?.addBlockName(context, parser.tokenValue, 1);
               if ((token & 537079808) === 537079808) {
                   isNonSimpleParameterList = 1;
               }
               else if ((token & 36864) === 36864) {
                   hasStrictReserved = 1;
               }
-              expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
+              expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart, 0);
               if (parser.getToken() === 16 || parser.getToken() === 18) {
                   if (parser.assignable & 2) {
                       destructible |= 16;
@@ -8300,14 +8443,14 @@
           else if ((token & 2097152) === 2097152) {
               expr =
                   token === 2162700
-                      ? parseObjectLiteralOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin)
-                      : parseArrayExpressionOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin);
+                      ? parseObjectLiteralOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind)
+                      : parseArrayExpressionOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind);
               destructible |= parser.destructible;
               isNonSimpleParameterList = 1;
               parser.assignable = 2;
               if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                   if (destructible & 8)
-                      parser.report(122);
+                      parser.report(124);
                   expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                   destructible |= 16;
                   if (parser.getToken() !== 16 && parser.getToken() !== 18) {
@@ -8316,7 +8459,7 @@
               }
           }
           else if (token === 14) {
-              expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 0, 1, 0);
+              expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 1, 0);
               if (parser.destructible & 16)
                   parser.report(74);
               isNonSimpleParameterList = 1;
@@ -8349,7 +8492,10 @@
                   }, tokenAfterParenthesesStart);
               }
               consume(parser, context, 16);
-              parser.destructible = destructible;
+              parser.destructible = destructible | previousAwaitYield;
+              if (previousFirstAwaitLocation) {
+                  parser.firstAwaitLocation = previousFirstAwaitLocation;
+              }
               return parser.options.preserveParens
                   ? parser.finishNode({
                       type: 'ParenthesizedExpression',
@@ -8380,7 +8526,7 @@
       }
       consume(parser, context, 16);
       if (destructible & 16 && destructible & 8)
-          parser.report(151);
+          parser.report(153);
       destructible |=
           parser.destructible & 256
               ? 256
@@ -8390,8 +8536,12 @@
       if (parser.getToken() === 10) {
           if (destructible & (32 | 16))
               parser.report(49);
-          if (context & (2048 | 2) && destructible & 128)
+          if (context & (2048 | 2) && destructible & 128) {
+              const loc = parser.firstAwaitLocation;
+              if (loc)
+                  throw new ParseError(loc.start, loc.end, 31);
               parser.report(31);
+          }
           if (context & (1 | 1024) && destructible & 256) {
               parser.report(32);
           }
@@ -8399,15 +8549,19 @@
               parser.flags |= 128;
           if (hasStrictReserved)
               parser.flags |= 256;
-          return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start);
+          return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start, origin);
       }
       if (destructible & 64) {
           parser.report(63);
       }
       if (destructible & 8) {
-          parser.report(144);
+          parser.report(146);
+      }
+      parser.destructible =
+          ((parser.destructible | 256) ^ 256) | destructible | previousAwaitYield;
+      if (previousFirstAwaitLocation) {
+          parser.firstAwaitLocation = previousFirstAwaitLocation;
       }
-      parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
       return parser.options.preserveParens
           ? parser.finishNode({
               type: 'ParenthesizedExpression',
@@ -8438,23 +8592,23 @@
       }
       return expr;
   }
-  function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start) {
+  function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start, origin = 0) {
       if (!canAssign)
           parser.report(57);
       if (inNew)
           parser.report(51);
       parser.flags &= -129;
       const scope = parser.options.lexical ? createArrowHeadParsingScope(parser, context, value) : void 0;
-      return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start);
+      return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start, origin);
   }
-  function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start) {
+  function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start, origin = 0) {
       if (!canAssign)
           parser.report(57);
       for (let i = 0; i < params.length; ++i)
           reinterpretToPattern(parser, params[i]);
-      return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start);
+      return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, origin);
   }
-  function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start) {
+  function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, origin = 0) {
       if (parser.flags & 1)
           parser.report(48);
       consume(parser, context | 32, 10);
@@ -8472,29 +8626,32 @@
       else {
           scope = scope?.createChildScope(64);
           const modifierFlags = 4 | 131072 | 8;
-          body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, 16, void 0, void 0);
+          body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, void 0, void 0, 16);
           switch (parser.getToken()) {
               case 69271571:
                   if ((parser.flags & 1) === 0) {
-                      parser.report(116);
+                      parser.report(118);
                   }
                   parser.flags |= 8192;
                   break;
               case 67108877:
               case 67174409:
               case 22:
-                  parser.report(117);
+                  parser.report(119);
               case 67174411:
                   if ((parser.flags & 1) === 0) {
-                      parser.report(116);
+                      parser.report(118);
                   }
                   parser.flags |= 1024;
                   break;
           }
-          if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0)
-              parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+          if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0) {
+              if (parser.getToken() !== 8673330 || origin !== 32) {
+                  parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+              }
+          }
           if ((parser.getToken() & 33619968) === 33619968)
-              parser.report(125);
+              parser.report(127);
       }
       parser.assignable = 2;
       return parser.finishNode({
@@ -8510,6 +8667,7 @@
       consume(parser, context, 67174411);
       parser.flags = (parser.flags | 128) ^ 128;
       parser.strictReservedRange = null;
+      parser.firstAwaitLocation = null;
       const params = [];
       if (consumeOpt(parser, context, 16))
           return params;
@@ -8529,17 +8687,17 @@
                       parser.flags |= 512;
                   }
               }
-              left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
+              left = parseAndClassifyIdentifier(parser, context, scope, kind | 1);
           }
           else {
               if (token === 2162700) {
-                  left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
+                  left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind);
               }
               else if (token === 69271571) {
-                  left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
+                  left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind);
               }
               else if (token === 14) {
-                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 0, inGroup, 1);
+                  left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, inGroup, 1);
               }
               else {
                   parser.report(30, KeywordDescTable[token & 255]);
@@ -8634,7 +8792,7 @@
       const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
       context = (context | 131072) ^ 131072;
       if (parser.getToken() === 67108991)
-          parser.report(168);
+          parser.report(170);
       const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
       parser.assignable = 2;
       return parser.finishNode({
@@ -8663,9 +8821,11 @@
       }
       return parseArrowFromIdentifier(parser, (context & -524289) | 2048, privateScope, parser.tokenValue, parseIdentifier(parser, context), 0, canAssign, 1, start);
   }
-  function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, origin, flags, start) {
+  function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, flags, start) {
       nextToken(parser, context | 32);
       const scope = parser.createScopeIfLexical()?.createChildScope(512);
+      const previousFirstAwaitLocation = parser.firstAwaitLocation;
+      parser.firstAwaitLocation = null;
       context = (context | 131072) ^ 131072;
       if (consumeOpt(parser, context, 16)) {
           if (parser.getToken() === 10) {
@@ -8679,6 +8839,8 @@
           else {
               parser.assignable = 2;
           }
+          if (previousFirstAwaitLocation)
+              parser.firstAwaitLocation = previousFirstAwaitLocation;
           return parser.finishNode({
               type: 'CallExpression',
               callee,
@@ -8697,7 +8859,7 @@
           const { tokenStart } = parser;
           const token = parser.getToken();
           if (token & 143360) {
-              scope?.addBlockName(context, parser.tokenValue, kind, 0);
+              scope?.addBlockName(context, parser.tokenValue, kind);
               if ((token & 537079808) === 537079808) {
                   parser.flags |= 512;
               }
@@ -8727,13 +8889,13 @@
           else if (token & 2097152) {
               expr =
                   token === 2162700
-                      ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin)
-                      : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin);
+                      ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind)
+                      : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind);
               destructible |= parser.destructible;
               isNonSimpleParameterList = 1;
               if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                   if (destructible & 8)
-                      parser.report(122);
+                      parser.report(124);
                   expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                   destructible |= 16;
                   if ((parser.getToken() & 8388608) === 8388608) {
@@ -8745,7 +8907,7 @@
               }
           }
           else if (token === 14) {
-              expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 1, 1, 0);
+              expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 1, 1, 0);
               destructible |=
                   (parser.getToken() === 16 ? 0 : 16) | parser.destructible;
               isNonSimpleParameterList = 1;
@@ -8766,6 +8928,8 @@
               else {
                   parser.assignable = 2;
               }
+              if (previousFirstAwaitLocation)
+                  parser.firstAwaitLocation = previousFirstAwaitLocation;
               return parser.finishNode({
                   type: 'CallExpression',
                   callee,
@@ -8789,8 +8953,12 @@
               parser.report(27);
           if (parser.flags & 1 || flags & 1)
               parser.report(48);
-          if (destructible & 128)
+          if (destructible & 128) {
+              const loc = parser.firstAwaitLocation;
+              if (loc)
+                  throw new ParseError(loc.start, loc.end, 31);
               parser.report(31);
+          }
           if (context & (1 | 1024) && destructible & 256)
               parser.report(32);
           if (isNonSimpleParameterList)
@@ -8809,6 +8977,8 @@
       else {
           parser.assignable = 2;
       }
+      if (previousFirstAwaitLocation)
+          parser.firstAwaitLocation = previousFirstAwaitLocation;
       return parser.finishNode({
           type: 'CallExpression',
           callee,
@@ -8834,9 +9004,6 @@
       let start;
       let decorators;
       if (parser.leadingDecorators.decorators.length) {
-          if (parser.getToken() === 133) {
-              parser.report(30, '@');
-          }
           start = parser.leadingDecorators.start;
           decorators = [...parser.leadingDecorators.decorators];
           parser.leadingDecorators.decorators.length = 0;
@@ -8846,19 +9013,19 @@
           decorators = parseDecorators(parser, context, privateScope);
       }
       context = (context | 16384 | 1) ^ 16384;
-      nextToken(parser, context);
+      consume(parser, context, 86094);
       let id = null;
       let superClass = null;
       const { tokenValue } = parser;
       if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
           if (isStrictReservedWord(parser, context, parser.getToken())) {
-              parser.report(118);
+              parser.report(120);
           }
           if ((parser.getToken() & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
           if (scope) {
-              scope.addBlockName(context, tokenValue, 32, 0);
+              scope.addBlockName(context, tokenValue, 32);
               if (flags) {
                   if (flags & 2) {
                       parser.declareUnboundVariable(tokenValue);
@@ -8879,13 +9046,13 @@
       else {
           inheritedContext = (inheritedContext | 512) ^ 512;
       }
-      const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 8, 0);
+      const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 0, 8);
       return parser.finishNode({
           type: 'ClassDeclaration',
           id,
           superClass,
           body,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parseClassExpression(parser, context, privateScope, inGroup, start) {
@@ -8893,12 +9060,12 @@
       let superClass = null;
       const decorators = parseDecorators(parser, context, privateScope);
       context = (context | 1 | 16384) ^ 16384;
-      nextToken(parser, context);
+      consume(parser, context, 86094);
       if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
           if (isStrictReservedWord(parser, context, parser.getToken()))
-              parser.report(118);
+              parser.report(120);
           if ((parser.getToken() & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
           id = parseIdentifier(parser, context);
       }
@@ -8910,37 +9077,74 @@
       else {
           inheritedContext = (inheritedContext | 512) ^ 512;
       }
-      const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, 0, inGroup);
+      const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, inGroup);
       parser.assignable = 2;
       return parser.finishNode({
           type: 'ClassExpression',
           id,
           superClass,
           body,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parseDecorators(parser, context, privateScope) {
       const list = [];
-      if (parser.options.next) {
+      if (parser.features & 1) {
           while (parser.getToken() === 133) {
-              list.push(parseDecoratorList(parser, context, privateScope));
+              list.push(parseDecorator(parser, context, privateScope));
           }
       }
       return list;
   }
-  function parseDecoratorList(parser, context, privateScope) {
+  function parseDecorator(parser, context, privateScope) {
       const start = parser.tokenStart;
       nextToken(parser, context | 32);
       const expressionStart = parser.tokenStart;
-      let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
-      expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, expressionStart);
+      let expression;
+      if (parser.getToken() === 67174411) {
+          expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
+      }
+      else {
+          const token = parser.getToken();
+          if (((token & 143360) !== 143360 && !isValidIdentifier(context, token)) ||
+              (context & 1 && (token & 36864) === 36864)) {
+              parser.report(30, KeywordDescTable[token & 255]);
+          }
+          if (token === 209006 && context & (2048 | 2)) {
+              parser.report(112);
+          }
+          if (token === 241771 && context & 1024) {
+              parser.report(97, 'yield');
+          }
+          let memberExpression = parseIdentifier(parser, context | 64);
+          while (parser.getToken() === 67108877) {
+              nextToken(parser, (context | 262144 | 8) ^ 8);
+              const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
+              memberExpression = parser.finishNode({
+                  type: 'MemberExpression',
+                  object: memberExpression,
+                  computed: false,
+                  property,
+                  optional: false,
+              }, expressionStart);
+          }
+          expression = memberExpression;
+          if (parser.getToken() === 67174411) {
+              const args = parseArguments(parser, context, privateScope, 0);
+              expression = parser.finishNode({
+                  type: 'CallExpression',
+                  callee: memberExpression,
+                  arguments: args,
+                  optional: false,
+              }, expressionStart);
+          }
+      }
       return parser.finishNode({
           type: 'Decorator',
           expression,
       }, start);
   }
-  function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, origin, inGroup) {
+  function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, inGroup, origin = 0) {
       const { tokenStart } = parser;
       const privateScope = parser.createPrivateScopeIfLexical(parentScope);
       consume(parser, context | 32, 2162700);
@@ -8953,13 +9157,13 @@
           const decoratorStart = parser.tokenStart;
           const decorators = parseDecorators(parser, context, privateScope);
           if (decorators.length > 0 && parser.tokenValue === 'constructor') {
-              parser.report(109);
+              parser.report(111);
           }
           if (parser.getToken() === 1074790415)
-              parser.report(108);
+              parser.report(110);
           if (consumeOpt(parser, context, 1074790417)) {
               if (decorators.length > 0)
-                  parser.report(120);
+                  parser.report(122);
               continue;
           }
           body.push(parseClassElementList(parser, context, scope, privateScope, inheritedContext, kind, decorators, 0, inGroup, decorators.length > 0 ? decoratorStart : parser.tokenStart));
@@ -9022,7 +9226,7 @@
                       if ((parser.getToken() & 1073741824) === 1073741824) {
                           return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
                       }
-                      if (parser.options.next)
+                      if (parser.features & 1)
                           kind |= 1024;
                   }
                   break;
@@ -9075,12 +9279,12 @@
               key = parsePrivateIdentifier(parser, context, privateScope, kind);
           }
           else
-              parser.report(135);
+              parser.report(137);
       }
       if ((kind & 2) === 0) {
           if (parser.tokenValue === 'constructor') {
               if ((parser.getToken() & 1073741824) === 1073741824) {
-                  parser.report(129);
+                  parser.report(131);
               }
               else if ((kind & 32) === 0 && parser.getToken() === 67174411) {
                   if (kind & (768 | 16 | 128 | 8)) {
@@ -9118,7 +9322,7 @@
           computed: (kind & 2) > 0,
           key,
           value,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parsePrivateIdentifier(parser, context, privateScope, kind) {
@@ -9126,7 +9330,7 @@
       nextToken(parser, context);
       const { tokenValue } = parser;
       if (tokenValue === 'constructor')
-          parser.report(128);
+          parser.report(130);
       if (parser.options.lexical) {
           if (!privateScope)
               parser.report(4, tokenValue);
@@ -9151,7 +9355,7 @@
           nextToken(parser, context | 32);
           const { tokenStart } = parser;
           if (parser.getToken() === 537079928)
-              parser.report(119);
+              parser.report(121);
           const modifierFlags = 1024 |
               2048 |
               8192 |
@@ -9177,32 +9381,32 @@
           value,
           static: (state & 32) > 0,
           computed: (state & 2) > 0,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
-  function parseBindingPattern(parser, context, scope, privateScope, type, origin) {
+  function parseBindingPattern(parser, context, scope, privateScope, kind, origin = 0) {
       if (parser.getToken() & 143360 ||
           ((context & 1) === 0 && parser.getToken() === -2147483526))
-          return parseAndClassifyIdentifier(parser, context, scope, type, origin);
+          return parseAndClassifyIdentifier(parser, context, scope, kind, origin);
       if ((parser.getToken() & 2097152) !== 2097152)
           parser.report(30, KeywordDescTable[parser.getToken() & 255]);
       const left = parser.getToken() === 69271571
-          ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin)
-          : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin);
+          ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, kind, origin)
+          : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, kind, origin);
       if (parser.destructible & 16)
           parser.report(50);
       if (parser.destructible & 32)
           parser.report(50);
       return left;
   }
-  function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
+  function parseAndClassifyIdentifier(parser, context, scope, kind, origin = 0) {
       const token = parser.getToken();
       if (context & 1) {
           if ((token & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
           else if ((token & 36864) === 36864 || token === -2147483526) {
-              parser.report(118);
+              parser.report(120);
           }
       }
       if ((token & 20480) === 20480) {
@@ -9212,7 +9416,7 @@
           if (context & 1024)
               parser.report(32);
           if (context & 2)
-              parser.report(111);
+              parser.report(113);
       }
       if ((token & 255) === (241737 & 255)) {
           if (kind & (8 | 16))
@@ -9220,9 +9424,9 @@
       }
       if (token === 209006) {
           if (context & 2048)
-              parser.report(176);
+              parser.report(178);
           if (context & 2)
-              parser.report(110);
+              parser.report(112);
       }
       const { tokenValue, tokenStart: start } = parser;
       nextToken(parser, context);
@@ -9254,7 +9458,7 @@
           [children, closingElement] = parseJSXChildrenAndClosingElement(parser, context, privateScope, inJSXChild);
           const close = isEqualTagName(closingElement.name);
           if (isEqualTagName(openingElement.name) !== close)
-              parser.report(155, close);
+              parser.report(157, close);
       }
       return parser.finishNode({
           type: 'JSXElement',
@@ -9323,7 +9527,7 @@
   }
   function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
       if (parser.getToken() === 138)
-          return parseJSXText(parser, context);
+          return parseJSXText(parser);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
       if (parser.getToken() === 8456256) {
@@ -9337,7 +9541,7 @@
   }
   function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
       if (parser.getToken() === 138)
-          return parseJSXText(parser, context);
+          return parseJSXText(parser);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
       if (parser.getToken() === 8456256) {
@@ -9349,9 +9553,9 @@
       }
       parser.report(0);
   }
-  function parseJSXText(parser, context) {
+  function parseJSXText(parser) {
       const start = parser.tokenStart;
-      nextToken(parser, context);
+      nextJSXToken(parser);
       const node = {
           type: 'JSXText',
           value: parser.tokenValue,
@@ -9449,7 +9653,7 @@
                   value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                   break;
               default:
-                  parser.report(154);
+                  parser.report(156);
           }
       }
       return parser.finishNode({
@@ -9476,7 +9680,7 @@
       let expression;
       if (parser.getToken() === 1074790415) {
           if (isAttr)
-              parser.report(157);
+              parser.report(159);
           expression = parseJSXEmptyExpression(parser, {
               index: parser.startIndex,
               line: parser.startLine,