meriyah 7.1.2 → 7.3.0

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.1.2";
+  var version$1 = "7.3.0";
   var packageJson = {
   	version: version$1};
 
@@ -492,7 +492,7 @@
               return 'RegularExpression';
           case 67174408:
           case 67174409:
-          case 131:
+          case 132:
               return 'TemplateLiteral';
           default:
               if ((t & 143360) === 143360)
@@ -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,75 @@
       [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',
   };
   class ParseError extends SyntaxError {
       start;
@@ -800,7 +802,7 @@
       loc;
       description;
       constructor(start, end, type, ...params) {
-          const description = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+          const description = errorMessages[type].replaceAll(/%(\d+)/g, (_, i) => params[i]);
           const message = '[' + start.line + ':' + start.column + '-' + end.line + ':' + end.column + ']: ' + description;
           super(message);
           this.start = start.index;
@@ -815,10 +817,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',
@@ -835,79 +833,87 @@
       'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
       'this', 'throw', 'try', 'while', 'with',
       'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
-      'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of',
+      'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of', 'using',
       'enum', 'eval', 'arguments', 'escaped keyword', 'escaped future reserved keyword', 'reserved if strict', '#',
       'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
       'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
   ];
-  const descKeywordTable = {
-      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,
-      package: 36966,
-      private: 36967,
-      protected: 36968,
-      public: 36969,
-      set: 209009,
-      static: 36970,
-      super: 86109,
-      true: 86022,
-      with: 20579,
-      yield: 241771,
-      enum: 86133,
-      eval: 537079926,
-      as: 77932,
-      arguments: 537079927,
-      target: 209029,
-      meta: 209030,
-      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);
@@ -949,8 +955,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)
@@ -959,24 +965,24 @@
               if ((context & (2 | 2048)) === 0) {
                   return token | -2147483648;
               }
-              return -2147483528;
+              return -2147483527;
           }
           if (context & 1) {
               if (token === 36970) {
-                  return -2147483527;
+                  return -2147483526;
               }
               if ((token & 36864) === 36864) {
-                  return -2147483527;
+                  return -2147483526;
               }
               if ((token & 20480) === 20480) {
                   if (context & 262144 && (context & 8) === 0) {
                       return token | -2147483648;
                   }
                   else {
-                      return -2147483528;
+                      return -2147483527;
                   }
               }
-              return 209018 | -2147483648;
+              return 209019 | -2147483648;
           }
           if (context & 262144 &&
               (context & 8) === 0 &&
@@ -985,31 +991,31 @@
           }
           if (token === 241771) {
               return context & 262144
-                  ? 209018 | -2147483648
+                  ? 209019 | -2147483648
                   : context & 1024
-                      ? -2147483528
+                      ? -2147483527
                       : token | -2147483648;
           }
           if (token === 209005) {
-              return 209018 | -2147483648;
+              return 209019 | -2147483648;
           }
           if ((token & 36864) === 36864) {
               return token | 12288 | -2147483648;
           }
-          return -2147483528;
+          return -2147483527;
       }
       return 208897 | (hasEscape ? -2147483648 : 0);
   }
   function scanPrivateIdentifier(parser) {
       let char = advanceChar(parser);
       if (char === 92)
-          return 130;
+          return 131;
       const merged = consumePossibleSurrogatePair(parser);
       if (merged)
           char = merged;
       if (!isIdentifierStart(char))
           parser.report(96);
-      return 130;
+      return 131;
   }
   function scanIdentifierUnicodeEscape(parser) {
       if (parser.source.charCodeAt(parser.index + 1) !== 117) {
@@ -1074,7 +1080,7 @@
                   while (CharTypes[char] & (64 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator)
-                              parser.report(152);
+                              parser.report(154);
                           allowSeparator = 0;
                           char = advanceChar(parser);
                           continue;
@@ -1085,7 +1091,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) {
@@ -1094,7 +1100,7 @@
                   while (CharTypes[char] & (32 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1106,7 +1112,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) {
@@ -1115,7 +1121,7 @@
                   while (CharTypes[char] & (128 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1127,7 +1133,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) {
@@ -1160,7 +1166,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;
@@ -1171,7 +1177,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;
@@ -1215,7 +1221,7 @@
       if (isBigInt) {
           parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
           parser.tokenValue = BigInt(parser.tokenRaw.slice(0, -1).replaceAll('_', ''));
-          return 134283388;
+          return 134283389;
       }
       parser.tokenValue =
           kind & (1 | 2 | 8 | 4)
@@ -1236,7 +1242,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);
@@ -1247,7 +1253,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);
   }
@@ -1584,6 +1590,7 @@
       const { index: start } = parser;
       let token = 67174409;
       let ret = '';
+      let hasCarriageReturn = false;
       let char = advanceChar(parser);
       while (char !== 96) {
           if (char === 36 && parser.source.charCodeAt(parser.index + 1) === 123) {
@@ -1593,6 +1600,8 @@
           }
           else if (char === 92) {
               char = advanceChar(parser);
+              if (char === 13)
+                  hasCarriageReturn = true;
               if (char > 0x7e) {
                   ret += String.fromCodePoint(char);
               }
@@ -1607,7 +1616,9 @@
                       parser.line = line;
                       parser.column = column;
                       ret = null;
-                      char = scanBadTemplate(parser, char);
+                      char = scanBadTemplate(parser, char, () => {
+                          hasCarriageReturn = true;
+                      });
                       if (char < 0)
                           token = 67174408;
                       break;
@@ -1618,10 +1629,13 @@
               }
           }
           else if (parser.index < parser.end) {
-              if (char === 13 && parser.source.charCodeAt(parser.index) === 10) {
-                  ret += String.fromCodePoint(char);
+              if (char === 13)
+                  hasCarriageReturn = true;
+              if (char === 13 && parser.source.charCodeAt(parser.index + 1) === 10) {
                   parser.currentChar = parser.source.charCodeAt(++parser.index);
               }
+              if (char === 13)
+                  char = 10;
               if (((char & 83) < 3 && char === 10) || (char ^ 8232) <= 1) {
                   parser.column = -1;
                   parser.line++;
@@ -1634,12 +1648,16 @@
       }
       advanceChar(parser);
       parser.tokenValue = ret;
-      parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+      const tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+      parser.tokenRaw = hasCarriageReturn ? tokenRaw.replaceAll(/\r\n?/g, '\n') : tokenRaw;
       return token;
   }
-  function scanBadTemplate(parser, ch) {
+  function scanBadTemplate(parser, ch, onCarriageReturn) {
       while (ch !== 96) {
           switch (ch) {
+              case 13:
+                  onCarriageReturn();
+                  break;
               case 36: {
                   const index = parser.index + 1;
                   if (index < parser.end && parser.source.charCodeAt(index) === 123) {
@@ -1670,42 +1688,42 @@
   }
 
   const TokenLookup = [
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      127,
-      135,
-      127,
-      127,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
       129,
       128,
+      136,
       128,
       128,
+      130,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
+      129,
       128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      128,
-      127,
       16842798,
       134283267,
-      130,
+      131,
       208897,
       8391477,
       8390213,
@@ -1734,7 +1752,7 @@
       1077936155,
       8390721,
       22,
-      132,
+      133,
       208897,
       208897,
       208897,
@@ -1762,11 +1780,11 @@
       208897,
       208897,
       69271571,
-      136,
+      137,
       20,
       8389959,
       208897,
-      131,
+      132,
       4096,
       4096,
       4096,
@@ -1797,7 +1815,7 @@
       8389702,
       1074790415,
       16842799,
-      128,
+      129,
   ];
   function nextToken(parser, context) {
       parser.flags = (parser.flags | 1) ^ 1;
@@ -1827,8 +1845,8 @@
                   case 1074790417:
                   case 18:
                   case 16842799:
-                  case 132:
-                  case 128:
+                  case 133:
+                  case 129:
                       advanceChar(parser);
                       return token;
                   case 208897:
@@ -1839,20 +1857,20 @@
                       return scanNumber(parser, context, 16 | 128);
                   case 134283267:
                       return scanString(parser, context, char);
-                  case 131:
+                  case 132:
                       return scanTemplate(parser, context);
-                  case 136:
+                  case 137:
                       return scanUnicodeIdentifier(parser, context);
-                  case 130:
+                  case 131:
                       return scanPrivateIdentifier(parser);
-                  case 127:
+                  case 128:
                       advanceChar(parser);
                       break;
-                  case 129:
+                  case 130:
                       state |= 1 | 4;
                       scanNewLine(parser);
                       break;
-                  case 135:
+                  case 136:
                       consumeLineFeed(parser, state);
                       state = (state & -5) | 1;
                       break;
@@ -1956,7 +1974,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;
@@ -2075,7 +2093,7 @@
                               advanceChar(parser);
                               return 4718634;
                           }
-                          return 276824445;
+                          return 276824446;
                       }
                       if (ch === 46) {
                           const index = parser.index + 1;
@@ -2083,7 +2101,7 @@
                               ch = source.charCodeAt(index);
                               if (!(ch >= 48 && ch <= 57)) {
                                   advanceChar(parser);
-                                  return 67108990;
+                                  return 67108991;
                               }
                           }
                       }
@@ -2185,20 +2203,20 @@
   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 === -2147483528) {
+      if ((t & 20480) === 20480 || t === -2147483527) {
           parser.report(102);
       }
       if (kind & (8 | 16) && (t & 255) === (241737 & 255)) {
           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');
@@ -2207,15 +2225,15 @@
   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 === -2147483527) {
+          if (t === -2147483526) {
               parser.report(95);
           }
-          if (t === -2147483528) {
+          if (t === -2147483527) {
               parser.report(95);
           }
       }
@@ -2223,7 +2241,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');
@@ -2232,14 +2250,14 @@
   function isStrictReservedWord(parser, context, t) {
       if (t === 209006) {
           if (context & (2048 | 2))
-              parser.report(110);
+              parser.report(112);
           parser.destructible |= 128;
       }
       if (t === 241771 && context & 1024)
           parser.report(97, 'yield');
       return ((t & 20480) === 20480 ||
           (t & 36864) === 36864 ||
-          t == -2147483527);
+          t == -2147483526);
   }
   function isPropertyWithPrivateFieldKey(expr) {
       return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
@@ -2248,7 +2266,7 @@
       while (labels) {
           if (labels['$' + name]) {
               if (isIterationStatement)
-                  parser.report(137);
+                  parser.report(139);
               return 1;
           }
           if (isIterationStatement && labels.loop)
@@ -2261,7 +2279,7 @@
       let set = labels;
       while (set) {
           if (set['$' + name])
-              parser.report(136, name);
+              parser.report(138, name);
           set = set['$'];
       }
       labels['$' + name] = 1;
@@ -2289,14 +2307,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',
@@ -4422,8 +4440,8 @@
       zscr: '\uD835\uDCCF',
       zwj: '\u200D',
       zwnj: '\u200C',
-  };
-  const decodeMap = {
+  }));
+  const decodeMap = new Map(Object.entries({
       '0': 65533,
       '128': 8364,
       '130': 8218,
@@ -4452,22 +4470,22 @@
       '156': 339,
       '158': 382,
       '159': 376,
-  };
+  }).map(([key, value]) => [Number(key), value]));
   function decodeHTMLStrict(text) {
-      return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
+      return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
           if (key.charAt(1) === '#') {
               const secondChar = key.charAt(2);
               const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
               return decodeCodePoint(codePoint);
           }
-          return 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) {
@@ -4537,7 +4555,7 @@
       if (parser.options.raw)
           parser.tokenRaw = raw;
       parser.tokenValue = decodeHTMLStrict(raw);
-      parser.setToken(137);
+      parser.setToken(138);
   }
   function rescanJSXIdentifier(parser) {
       if ((parser.getToken() & 143360) === 143360) {
@@ -4552,6 +4570,8 @@
       return parser.getToken();
   }
 
+  const nextFeatures = 1 | 2 | 4;
+
   function normalizeRanges(ranges) {
       if (!ranges)
           return undefined;
@@ -4564,17 +4584,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;
   }
 
@@ -4595,7 +4625,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);
       }
@@ -4656,17 +4686,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;
@@ -4680,7 +4710,7 @@
           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 &&
@@ -4688,22 +4718,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);
       }
@@ -4735,6 +4765,7 @@
       options;
       token = 1048576;
       flags = 0;
+      features = 0;
       index = 0;
       line = 1;
       column = 0;
@@ -4760,6 +4791,7 @@
           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);
           }
@@ -4840,7 +4872,7 @@
       declareUnboundVariable(name) {
           const { exportedNames } = this;
           if (exportedNames.has(name)) {
-              this.report(147, name);
+              this.report(149, name);
           }
           exportedNames.add(name);
       }
@@ -4863,29 +4895,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) {
@@ -4948,7 +4961,7 @@
           if (scope) {
               for (const name of parser.exportedBindings) {
                   if (!scope.hasVariable(name))
-                      parser.report(148, name);
+                      parser.report(150, name);
               }
           }
       }
@@ -4998,7 +5011,7 @@
       return statements;
   }
   function parseModuleItem(parser, context, scope) {
-      if (parser.getToken() === 132) {
+      if (parser.getToken() === 133) {
           Object.assign(parser.leadingDecorators, {
               start: parser.tokenStart,
               decorators: parseDecorators(parser, context, undefined),
@@ -5010,28 +5023,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);
-      }
       return moduleItem;
   }
   function parseStatementListItem(parser, context, scope, privateScope, origin, labels) {
       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);
-          case 132:
+          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);
           case 241737:
               return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
+          case 209013:
+              return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+          case 209006:
+              if ((context & 2048 || (context & 2 && context & 8)) &&
+                  nextTokenIsUsingOnSameLine(parser)) {
+                  return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+              }
+              return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
           case 20564:
               parser.report(103, 'export');
           case 86106:
@@ -5085,9 +5112,9 @@
           case 209005:
               return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
           case 20557:
-              parser.report(162);
+              parser.report(164);
           case 20566:
-              parser.report(163);
+              parser.report(165);
           case 86104:
               parser.report(context & 1
                   ? 76
@@ -5115,15 +5142,18 @@
           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);
+  }
+  function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart) {
       if (token & 143360 && parser.getToken() === 21) {
-          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, tokenStart);
+          return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart);
       }
-      expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
-      expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
+      let expression = parseMemberOrUpdateExpression(parser, context, privateScope, initialExpression, 0, 0, tokenStart);
+      expression = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expression);
       if (parser.getToken() === 18) {
-          expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
+          expression = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expression);
       }
-      return parseExpressionStatement(parser, context, expr, tokenStart);
+      return parseExpressionStatement(parser, context, expression, tokenStart);
   }
   function parseBlock(parser, context, scope, privateScope, labels, start = parser.tokenStart, type = 'BlockStatement') {
       const body = [];
@@ -5185,7 +5215,7 @@
       if (!asyncNewLine) {
           if (parser.getToken() === 86104) {
               if (!allowFuncDecl)
-                  parser.report(123);
+                  parser.report(125);
               return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
           }
           if (isValidIdentifier(context, parser.getToken())) {
@@ -5312,9 +5342,14 @@
           while (parser.getToken() !== 20556 &&
               parser.getToken() !== 1074790415 &&
               parser.getToken() !== 20561) {
-              consequent.push(parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
+              const statement = parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
                   $: labels,
-              }));
+              });
+              if (statement.type === 'VariableDeclaration' &&
+                  (statement.kind === 'using' || statement.kind === 'await using')) {
+                  parser.report(30, statement.kind);
+              }
+              consequent.push(statement);
           }
           cases.push(parser.finishNode({
               type: 'SwitchCase',
@@ -5355,7 +5390,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({
@@ -5371,7 +5406,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);
@@ -5516,14 +5551,90 @@
       }
       return parseExpressionStatement(parser, context, expr, tokenStart);
   }
-  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin) {
+  function nextTokenIsUsingOnSameLine(parser) {
+      const { index: parserIndex, source } = parser;
+      let index = parserIndex;
+      while (index < parser.end) {
+          const char = source.charCodeAt(index);
+          if (char === 0x0a || char === 0x0d || char === 0x2028 || char === 0x2029)
+              return false;
+          if (/\s/u.test(source[index])) {
+              index++;
+              continue;
+          }
+          if (char === 0x2f && source.charCodeAt(index + 1) === 0x2a) {
+              index += 2;
+              while (index < parser.end) {
+                  const commentChar = source.charCodeAt(index);
+                  if (commentChar === 0x0a || commentChar === 0x0d || commentChar === 0x2028 || commentChar === 0x2029) {
+                      return false;
+                  }
+                  if (commentChar === 0x2a && source.charCodeAt(index + 1) === 0x2f) {
+                      index += 2;
+                      break;
+                  }
+                  index++;
+              }
+              continue;
+          }
+          break;
+      }
+      if (source.slice(index, index + 5) !== 'using')
+          return false;
+      const following = source.codePointAt(index + 5);
+      return following === undefined || (following !== 0x5c && !isIdentifierPart(following));
+  }
+  function isResourceBindingStart(token) {
+      return (token & 143360) === 143360 && (token & 20480) !== 20480;
+  }
+  function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+      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) {
+              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);
+  }
+  function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
       const start = parser.tokenStart;
-      nextToken(parser, context);
-      const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin);
+      if (context & 524288)
+          parser.report(179);
+      nextToken(parser, context | 32);
+      let argument;
+      if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+          const usingStart = parser.tokenStart;
+          const usingIdentifier = parseIdentifier(parser, context);
+          if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+              return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'await using', start, 1);
+          }
+          argument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+      }
+      else {
+          argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+      }
+      if (parser.getToken() === 8391735)
+          parser.report(33);
+      parser.assignable = 2;
+      const expression = parser.finishNode({
+          type: 'AwaitExpression',
+          argument,
+      }, start);
+      return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 0, expression, 1048576, '', start);
+  }
+  function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
+      const start = declarationStart;
+      if (!keywordConsumed)
+          nextToken(parser, context);
+      const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind);
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode({
           type: 'VariableDeclaration',
-          kind: kind & 8 ? 'let' : 'const',
+          kind: declarationKind ?? (kind & 8 ? 'let' : 'const'),
           declarations,
       }, start);
   }
@@ -5538,24 +5649,34 @@
           declarations,
       }, start);
   }
-  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin) {
+  function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind) {
       let bindingCount = 1;
-      const list = [
-          parseVariableDeclaration(parser, context, scope, privateScope, kind, origin),
-      ];
+      const firstDeclaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+      const list = [firstDeclaration];
+      const resourceNames = declarationKind && parser.options.lexical ? new Set([firstDeclaration.id.name]) : undefined;
       while (consumeOpt(parser, context, 18)) {
           bindingCount++;
-          list.push(parseVariableDeclaration(parser, context, scope, privateScope, kind, origin));
+          const declaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+          if (resourceNames) {
+              const { name } = declaration.id;
+              if (resourceNames.has(name))
+                  parser.report(147, name);
+              resourceNames.add(name);
+          }
+          list.push(declaration);
       }
       if (bindingCount > 1 && origin & 32 && parser.getToken() & 262144) {
           parser.report(61, KeywordDescTable[parser.getToken() & 255]);
       }
       return list;
   }
-  function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin) {
+  function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind) {
       const { tokenStart } = parser;
       const token = parser.getToken();
       let init = null;
+      if (declarationKind && (token & 2097152) === 2097152) {
+          parser.report(50);
+      }
       const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
       if (parser.getToken() === 1077936155) {
           nextToken(parser, context | 32);
@@ -5570,7 +5691,7 @@
       }
       else if ((kind & 16 || (token & 2097152) > 0) &&
           (parser.getToken() & 262144) !== 262144) {
-          parser.report(59, kind & 16 ? 'const' : 'destructuring');
+          parser.report(59, declarationKind ?? (kind & 16 ? 'const' : 'destructuring'));
       }
       return parser.finishNode({
           type: 'VariableDeclarator',
@@ -5591,7 +5712,10 @@
       let init = null;
       let isVarDecl = parser.getToken() === 86088 ||
           parser.getToken() === 241737 ||
-          parser.getToken() === 86090;
+          parser.getToken() === 86090 ||
+          parser.getToken() === 209013;
+      let resourceDeclarationKind;
+      let consumedForOfDelimiter = false;
       let right;
       const { tokenStart } = parser;
       const token = parser.getToken();
@@ -5615,7 +5739,82 @@
                   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) {
+              const usingIdentifier = parseIdentifier(parser, context);
+              if ((parser.flags & 1) !== 0 || !isResourceBindingStart(parser.getToken())) {
+                  isVarDecl = false;
+                  parser.assignable = 1;
+                  init = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, tokenStart);
+              }
+              else if (parser.getToken() === 471156) {
+                  const ofStart = parser.tokenStart;
+                  const ofToken = parser.getToken();
+                  const ofValue = parser.tokenValue;
+                  const ofIdentifier = parseIdentifier(parser, context);
+                  if (parser.getToken() !== 1077936155 &&
+                      parser.getToken() !== 8673330 &&
+                      parser.getToken() !== 1074790417 &&
+                      parser.getToken() !== 18) {
+                      isVarDecl = false;
+                      consumedForOfDelimiter = true;
+                      parser.assignable = 1;
+                      init = usingIdentifier;
+                  }
+                  else {
+                      resourceDeclarationKind = 'using';
+                      validateBindingIdentifier(parser, context, 16, ofToken, 0);
+                      scope?.addBlockName(context, ofValue, 16, 32);
+                      let declarationInitializer = null;
+                      if (parser.getToken() === 1077936155) {
+                          nextToken(parser, context | 32);
+                          declarationInitializer = parseExpression(parser, context | 131072, privateScope, 1, 0, parser.tokenStart);
+                          if ((parser.getToken() & 262144) === 262144) {
+                              throw new ParseError(ofStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
+                          }
+                      }
+                      else if (parser.getToken() !== 8673330) {
+                          parser.report(59, resourceDeclarationKind);
+                      }
+                      const declarations = [
+                          parser.finishNode({
+                              type: 'VariableDeclarator',
+                              id: ofIdentifier,
+                              init: declarationInitializer,
+                          }, ofStart),
+                      ];
+                      const resourceNames = parser.options.lexical ? new Set([ofValue]) : undefined;
+                      while (consumeOpt(parser, context | 131072, 18)) {
+                          const declaration = parseVariableDeclaration(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind);
+                          if (resourceNames) {
+                              const { name } = declaration.id;
+                              if (resourceNames.has(name))
+                                  parser.report(147, name);
+                              resourceNames.add(name);
+                          }
+                          declarations.push(declaration);
+                      }
+                      if (declarations.length > 1 && parser.getToken() & 262144) {
+                          parser.report(61, KeywordDescTable[parser.getToken() & 255]);
+                      }
+                      init = parser.finishNode({
+                          type: 'VariableDeclaration',
+                          kind: resourceDeclarationKind,
+                          declarations,
+                      }, tokenStart);
+                      parser.assignable = 1;
+                  }
+              }
+              else {
+                  resourceDeclarationKind = 'using';
+                  init = parser.finishNode({
+                      type: 'VariableDeclaration',
+                      kind: resourceDeclarationKind,
+                      declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                  }, tokenStart);
+                  parser.assignable = 1;
               }
           }
           else {
@@ -5634,6 +5833,42 @@
               parser.assignable = 1;
           }
       }
+      else if (token === 209006 &&
+          (context & 2048 || (context & 2 && context & 8))) {
+          if (context & 524288)
+              parser.report(179);
+          nextToken(parser, context | 32);
+          let awaitArgument;
+          if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+              const usingStart = parser.tokenStart;
+              const usingIdentifier = parseIdentifier(parser, context);
+              if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+                  resourceDeclarationKind = 'await using';
+                  isVarDecl = true;
+                  init = parser.finishNode({
+                      type: 'VariableDeclaration',
+                      kind: resourceDeclarationKind,
+                      declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                  }, tokenStart);
+                  parser.assignable = 1;
+              }
+              else {
+                  awaitArgument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+              }
+          }
+          else {
+              awaitArgument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+          }
+          if (!isVarDecl) {
+              if (parser.getToken() === 8391735)
+                  parser.report(33);
+              parser.assignable = 2;
+              init = parser.finishNode({
+                  type: 'AwaitExpression',
+                  argument: awaitArgument,
+              }, tokenStart);
+          }
+      }
       else if (token === 1074790417) {
           if (forAwait)
               parser.report(82);
@@ -5655,12 +5890,13 @@
       else {
           init = parseLeftHandSideExpression(parser, context | 131072, privateScope, 1, 0, 1);
       }
-      if ((parser.getToken() & 262144) === 262144) {
-          if (parser.getToken() === 471156) {
+      if (consumedForOfDelimiter || (parser.getToken() & 262144) === 262144) {
+          if (consumedForOfDelimiter || parser.getToken() === 471156) {
               if (parser.assignable & 2)
                   parser.report(80, forAwait ? 'await' : 'of');
               reinterpretToPattern(parser, init);
-              nextToken(parser, context | 32);
+              if (!consumedForOfDelimiter)
+                  nextToken(parser, context | 32);
               right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
               consume(parser, context | 32, 16);
               const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
@@ -5672,6 +5908,8 @@
                   await: forAwait,
               }, start);
           }
+          if (resourceDeclarationKind)
+              parser.report(30, 'in');
           if (parser.assignable & 2)
               parser.report(80, 'in');
           reinterpretToPattern(parser, init);
@@ -5716,9 +5954,9 @@
   }
   function parseRestrictedIdentifier(parser, context, scope) {
       if (!isValidIdentifier(context, parser.getToken()))
-          parser.report(118);
+          parser.report(120);
       if ((parser.getToken() & 537079808) === 537079808)
-          parser.report(119);
+          parser.report(121);
       scope?.addBlockName(context, parser.tokenValue, 8, 0);
       return parseIdentifier(parser, context);
   }
@@ -5726,6 +5964,8 @@
       const start = parser.tokenStart;
       nextToken(parser, context);
       let source;
+      let sourceParsed = false;
+      let phase = null;
       const { tokenStart } = parser;
       let specifiers = [];
       if (parser.getToken() === 134283267) {
@@ -5733,14 +5973,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, 0);
+                          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, 0);
+                          phase = 'source';
+                          specifiers = [
+                              parser.finishNode({
+                                  type: 'ImportDefaultSpecifier',
+                                  local: fromLocal,
+                              }, fromStart),
+                          ];
+                      }
+                      else {
+                          scope?.addBlockName(context, tokenValue, 8, 0);
+                          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, 0);
+                      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));
@@ -5769,7 +6088,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 = {
@@ -5777,6 +6097,7 @@
           specifiers,
           source,
           attributes,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode(node, start);
@@ -5859,17 +6180,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);
                   break;
               }
-              case 132:
+              case 133:
+                  if (!(parser.features & 1)) {
+                      parser.report(30, '@');
+                  }
               case 86094:
                   declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                   break;
@@ -5982,7 +6310,7 @@
               }
               else {
                   if (hasLiteralLocal) {
-                      parser.report(172);
+                      parser.report(174);
                   }
                   if (scope) {
                       tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -5992,7 +6320,10 @@
               matchOrInsertSemicolon(parser, context | 32);
               break;
           }
-          case 132:
+          case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
               break;
@@ -6125,7 +6456,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;
@@ -6152,10 +6483,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;
@@ -6208,7 +6539,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) {
@@ -6235,17 +6566,17 @@
       if (inGroup)
           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) {
@@ -6269,6 +6600,7 @@
   }
   function parseFunctionBody(parser, context, scope, privateScope, origin, funcNameToken, functionScope) {
       const { tokenStart } = parser;
+      parser.flags &= -4161;
       consume(parser, context | 32, 2162700);
       const body = [];
       if (parser.getToken() !== 1074790415) {
@@ -6294,19 +6626,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);
               }
           }
       }
@@ -6330,8 +6662,8 @@
       const { tokenStart } = parser;
       nextToken(parser, context);
       switch (parser.getToken()) {
-          case 67108990:
-              parser.report(167);
+          case 67108991:
+              parser.report(169);
           case 67174411: {
               if ((context & 512) === 0)
                   parser.report(28);
@@ -6377,10 +6709,13 @@
           switch (parser.getToken()) {
               case 67108877: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
-                  if (context & 16 && parser.getToken() === 130 && parser.tokenValue === 'super') {
-                      parser.report(173);
+                  if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
+                      parser.report(175);
                   }
-                  parser.assignable = 1;
+                  parser.assignable =
+                      (parser.flags & 2048) === 2048
+                          ? 2
+                          : 1;
                   const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
                   expr = parser.finishNode({
                       type: 'MemberExpression',
@@ -6405,7 +6740,7 @@
                   const { tokenStart } = parser;
                   const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
                   consume(parser, context, 20);
-                  parser.assignable = 1;
+                  parser.assignable = restoreHasOptionalChaining ? 2 : 1;
                   expr = parser.finishNode({
                       type: 'MemberExpression',
                       object: expr,
@@ -6446,7 +6781,7 @@
                   }
                   break;
               }
-              case 67108990: {
+              case 67108991: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
                   parser.flags |= 2048;
                   parser.assignable = 2;
@@ -6455,7 +6790,7 @@
               }
               default:
                   if ((parser.flags & 2048) === 2048) {
-                      parser.report(166);
+                      parser.report(168);
                   }
                   parser.assignable = 2;
                   expr = parser.finishNode({
@@ -6533,12 +6868,12 @@
   }
   function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
       if ((parser.getToken() & 143360) === 0 &&
-          parser.getToken() !== -2147483528 &&
           parser.getToken() !== -2147483527 &&
-          parser.getToken() !== 130) {
-          parser.report(160);
+          parser.getToken() !== -2147483526 &&
+          parser.getToken() !== 131) {
+          parser.report(162);
       }
-      return parser.getToken() === 130
+      return parser.getToken() === 131
           ? parsePrivateIdentifier(parser, context, privateScope, 0)
           : parseIdentifier(parser, context);
   }
@@ -6587,10 +6922,10 @@
               !(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);
           }
@@ -6631,7 +6966,10 @@
               return parseThisExpression(parser, context);
           case 65540:
               return parseRegExpLiteral(parser, context);
-          case 132:
+          case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               return parseClassExpression(parser, context, privateScope, inGroup, start);
           case 86109:
@@ -6642,9 +6980,9 @@
               return parseTemplate(parser, context, privateScope);
           case 86107:
               return parseNewExpression(parser, context, privateScope, inGroup);
-          case 134283388:
+          case 134283389:
               return parseBigIntLiteral(parser, context);
-          case 130:
+          case 131:
               return parsePrivateIdentifier(parser, context, privateScope, 0);
           case 86106:
               return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start);
@@ -6660,24 +6998,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();
-      if (token !== 209030 && parser.tokenValue !== 'meta') {
-          parser.report(174);
+      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(176);
       }
       else if (token & -2147483648) {
-          parser.report(175);
+          parser.report(177);
       }
       parser.assignable = 2;
       return parser.finishNode({
@@ -6686,10 +7037,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) {
@@ -6704,6 +7055,7 @@
           type: 'ImportExpression',
           source,
           options,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       consume(parser, context, 16);
       return parser.finishNode(node, start);
@@ -6721,7 +7073,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({
@@ -6759,7 +7111,7 @@
       if (parser.getToken() === 134283267) {
           const value = parser.tokenValue;
           if (!value.isWellFormed()) {
-              parser.report(171);
+              parser.report(173);
           }
           return parseLiteral(parser, context);
       }
@@ -6897,7 +7249,7 @@
   }
   function parseLiteral(parser, context) {
       const { tokenValue, tokenRaw, tokenStart } = parser;
-      if (parser.getToken() === 134283388) {
+      if (parser.getToken() === 134283389) {
           return parseBigIntLiteral(parser, context);
       }
       const node = {
@@ -7320,7 +7672,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,
@@ -7414,9 +7766,9 @@
               let key = null;
               let value;
               if (parser.getToken() & 143360 ||
-                  parser.getToken() === -2147483528 ||
-                  parser.getToken() === -2147483527) {
-                  if (parser.getToken() === -2147483527)
+                  parser.getToken() === -2147483527 ||
+                  parser.getToken() === -2147483526) {
+                  if (parser.getToken() === -2147483526)
                       destructible |= 16;
                   key = parseIdentifier(parser, context);
                   if (parser.getToken() === 18 ||
@@ -7448,7 +7800,7 @@
                       else {
                           destructible |=
                               (token === 209006 ? 128 : 0) |
-                                  (token === -2147483528 ? 16 : 0);
+                                  (token === -2147483527 ? 16 : 0);
                           value = parser.cloneIdentifier(key);
                       }
                   }
@@ -7575,11 +7927,11 @@
                   }
                   else if (parser.getToken() & 143360) {
                       destructible |= 16;
-                      if (token === -2147483528)
+                      if (token === -2147483527)
                           parser.report(95);
                       if (token === 209005) {
                           if (parser.flags & 1)
-                              parser.report(132);
+                              parser.report(134);
                           state |= 16 | 1;
                       }
                       else if (token === 209008) {
@@ -7643,7 +7995,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(133);
+                      parser.report(135);
                   }
               }
               else if ((parser.getToken() & 134217728) === 134217728) {
@@ -7747,7 +8099,7 @@
                       destructible = 16;
                   }
                   else {
-                      parser.report(134);
+                      parser.report(136);
                   }
               }
               else if (parser.getToken() === 69271571) {
@@ -7894,7 +8246,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(126);
+                      parser.report(128);
                   }
               }
               else {
@@ -8072,7 +8424,7 @@
               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) {
@@ -8145,7 +8497,7 @@
       }
       consume(parser, context, 16);
       if (destructible & 16 && destructible & 8)
-          parser.report(151);
+          parser.report(153);
       destructible |=
           parser.destructible & 256
               ? 256
@@ -8170,7 +8522,7 @@
           parser.report(63);
       }
       if (destructible & 8) {
-          parser.report(144);
+          parser.report(146);
       }
       parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
       return parser.options.preserveParens
@@ -8241,17 +8593,17 @@
           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;
@@ -8259,7 +8611,7 @@
           if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0)
               parser.report(30, KeywordDescTable[parser.getToken() & 255]);
           if ((parser.getToken() & 33619968) === 33619968)
-              parser.report(125);
+              parser.report(127);
       }
       parser.assignable = 2;
       return parser.finishNode({
@@ -8386,7 +8738,7 @@
       const id = parseIdentifier(parser, context | 32);
       const { tokenStart } = parser;
       if (consumeOpt(parser, context, 67108877)) {
-          if (context & 65536 && parser.getToken() === 209029) {
+          if (context & 65536 && parser.getToken() === 209030) {
               parser.assignable = 2;
               return parseMetaProperty(parser, context, id, start);
           }
@@ -8398,8 +8750,8 @@
       }
       const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
       context = (context | 131072) ^ 131072;
-      if (parser.getToken() === 67108990)
-          parser.report(168);
+      if (parser.getToken() === 67108991)
+          parser.report(170);
       const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
       parser.assignable = 2;
       return parser.finishNode({
@@ -8498,7 +8850,7 @@
               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) {
@@ -8599,9 +8951,6 @@
       let start;
       let decorators;
       if (parser.leadingDecorators.decorators.length) {
-          if (parser.getToken() === 132) {
-              parser.report(30, '@');
-          }
           start = parser.leadingDecorators.start;
           decorators = [...parser.leadingDecorators.decorators];
           parser.leadingDecorators.decorators.length = 0;
@@ -8611,16 +8960,16 @@
           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);
@@ -8650,7 +8999,7 @@
           id,
           superClass,
           body,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parseClassExpression(parser, context, privateScope, inGroup, start) {
@@ -8658,12 +9007,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);
       }
@@ -8682,24 +9031,61 @@
           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) {
-          while (parser.getToken() === 132) {
-              list.push(parseDecoratorList(parser, context, privateScope));
+      if (parser.features & 1) {
+          while (parser.getToken() === 133) {
+              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,
@@ -8718,13 +9104,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));
@@ -8741,7 +9127,7 @@
       let kind = isStatic ? 32 : 0;
       let key = null;
       const token = parser.getToken();
-      if (token & (143360 | 36864) || token === -2147483528) {
+      if (token & (143360 | 36864) || token === -2147483527) {
           key = parseIdentifier(parser, context);
           switch (token) {
               case 36970:
@@ -8787,7 +9173,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;
@@ -8804,7 +9190,7 @@
           kind |= 8;
           nextToken(parser, context);
       }
-      else if (parser.getToken() === 130) {
+      else if (parser.getToken() === 131) {
           kind |= 8192;
           key = parsePrivateIdentifier(parser, context | 16, privateScope, 768);
       }
@@ -8814,7 +9200,7 @@
       else if (isStatic && token === 2162700) {
           return parseStaticBlock(parser, context | 16, scope, privateScope, start);
       }
-      else if (token === -2147483527) {
+      else if (token === -2147483526) {
           key = parseIdentifier(parser, context);
           if (parser.getToken() !== 67174411)
               parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8824,8 +9210,8 @@
       }
       if (kind & (8 | 16 | 768 | 1024)) {
           if (parser.getToken() & 143360 ||
-              parser.getToken() === -2147483528 ||
-              parser.getToken() === -2147483527) {
+              parser.getToken() === -2147483527 ||
+              parser.getToken() === -2147483526) {
               key = parseIdentifier(parser, context);
           }
           else if ((parser.getToken() & 134217728) === 134217728) {
@@ -8835,17 +9221,17 @@
               kind |= 2;
               key = parseComputedPropertyName(parser, context, privateScope, 0);
           }
-          else if (parser.getToken() === 130) {
+          else if (parser.getToken() === 131) {
               kind |= 8192;
               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)) {
@@ -8883,7 +9269,7 @@
           computed: (kind & 2) > 0,
           key,
           value,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parsePrivateIdentifier(parser, context, privateScope, kind) {
@@ -8891,7 +9277,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);
@@ -8915,8 +9301,8 @@
       if (parser.getToken() === 1077936155) {
           nextToken(parser, context | 32);
           const { tokenStart } = parser;
-          if (parser.getToken() === 537079927)
-              parser.report(119);
+          if (parser.getToken() === 537079928)
+              parser.report(121);
           const modifierFlags = 1024 |
               2048 |
               8192 |
@@ -8942,12 +9328,12 @@
           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) {
       if (parser.getToken() & 143360 ||
-          ((context & 1) === 0 && parser.getToken() === -2147483527))
+          ((context & 1) === 0 && parser.getToken() === -2147483526))
           return parseAndClassifyIdentifier(parser, context, scope, type, origin);
       if ((parser.getToken() & 2097152) !== 2097152)
           parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8964,10 +9350,10 @@
       const token = parser.getToken();
       if (context & 1) {
           if ((token & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
-          else if ((token & 36864) === 36864 || token === -2147483527) {
-              parser.report(118);
+          else if ((token & 36864) === 36864 || token === -2147483526) {
+              parser.report(120);
           }
       }
       if ((token & 20480) === 20480) {
@@ -8977,7 +9363,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))
@@ -8985,9 +9371,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);
@@ -9019,7 +9405,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',
@@ -9087,7 +9473,7 @@
       }
   }
   function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
-      if (parser.getToken() === 137)
+      if (parser.getToken() === 138)
           return parseJSXText(parser, context);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9101,7 +9487,7 @@
       parser.report(0);
   }
   function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
-      if (parser.getToken() === 137)
+      if (parser.getToken() === 138)
           return parseJSXText(parser, context);
       if (parser.getToken() === 2162700)
           return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9214,7 +9600,7 @@
                   value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                   break;
               default:
-                  parser.report(154);
+                  parser.report(156);
           }
       }
       return parser.finishNode({
@@ -9241,7 +9627,7 @@
       let expression;
       if (parser.getToken() === 1074790415) {
           if (isAttr)
-              parser.report(157);
+              parser.report(159);
           expression = parseJSXEmptyExpression(parser, {
               index: parser.startIndex,
               line: parser.startLine,