meriyah 7.2.0 → 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.2.0";
+  var version$1 = "7.3.0";
   var packageJson = {
   	version: version$1};
 
@@ -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;
@@ -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',
@@ -840,75 +838,82 @@
       'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
       'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
   ];
-  const descKeywordTable = {
-      this: 86111,
-      function: 86104,
-      if: 20569,
-      return: 20572,
-      var: 86088,
-      else: 20563,
-      for: 20567,
-      new: 86107,
-      in: 8673330,
-      typeof: 16863275,
-      while: 20578,
-      case: 20556,
-      break: 20555,
-      try: 20577,
-      catch: 20557,
-      delete: 16863276,
-      throw: 86112,
-      switch: 86110,
-      continue: 20559,
-      default: 20561,
-      instanceof: 8411187,
-      do: 20562,
-      void: 16863277,
-      finally: 20566,
-      async: 209005,
-      await: 209006,
-      class: 86094,
-      const: 86090,
-      constructor: 12399,
-      debugger: 20560,
-      export: 20564,
-      extends: 20565,
-      false: 86021,
-      from: 209011,
-      get: 209008,
-      implements: 36964,
-      import: 86106,
-      interface: 36965,
-      let: 241737,
-      null: 86023,
-      of: 471156,
-      using: 209013,
-      package: 36966,
-      private: 36967,
-      protected: 36968,
-      public: 36969,
-      set: 209009,
-      static: 36970,
-      super: 86109,
-      true: 86022,
-      with: 20579,
-      yield: 241771,
-      enum: 86134,
-      eval: 537079927,
-      as: 77932,
-      arguments: 537079928,
-      target: 209030,
-      meta: 209031,
-      accessor: 12402,
-  };
+  const descKeywordTable = new Map([
+      ['this', 86111],
+      ['function', 86104],
+      ['if', 20569],
+      ['return', 20572],
+      ['var', 86088],
+      ['else', 20563],
+      ['for', 20567],
+      ['new', 86107],
+      ['in', 8673330],
+      ['typeof', 16863275],
+      ['while', 20578],
+      ['case', 20556],
+      ['break', 20555],
+      ['try', 20577],
+      ['catch', 20557],
+      ['delete', 16863276],
+      ['throw', 86112],
+      ['switch', 86110],
+      ['continue', 20559],
+      ['default', 20561],
+      ['instanceof', 8411187],
+      ['do', 20562],
+      ['void', 16863277],
+      ['finally', 20566],
+      ['async', 209005],
+      ['await', 209006],
+      ['class', 86094],
+      ['const', 86090],
+      ['constructor', 12399],
+      ['debugger', 20560],
+      ['export', 20564],
+      ['extends', 20565],
+      ['false', 86021],
+      ['from', 209011],
+      ['get', 209008],
+      ['implements', 36964],
+      ['import', 86106],
+      ['interface', 36965],
+      ['let', 241737],
+      ['null', 86023],
+      ['of', 471156],
+      ['using', 209013],
+      ['package', 36966],
+      ['private', 36967],
+      ['protected', 36968],
+      ['public', 36969],
+      ['set', 209009],
+      ['static', 36970],
+      ['super', 86109],
+      ['true', 86022],
+      ['with', 20579],
+      ['yield', 241771],
+      ['enum', 86134],
+      ['eval', 537079927],
+      ['as', 77932],
+      ['arguments', 537079928],
+      ['target', 209030],
+      ['meta', 209031],
+      ['accessor', 12402],
+  ]);
+  const keywordLengths = [...descKeywordTable.keys()].map((keyword) => keyword.length);
+  const minKeywordLength = Math.min(...keywordLengths);
+  const maxKeywordLength = Math.max(...keywordLengths);
 
   function scanIdentifier(parser, context, isValidAsKeyword) {
       while (isIdPart[advanceChar(parser)])
           ;
       parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
-      return parser.currentChar !== 92 && parser.currentChar <= 0x7e
-          ? (getOwnProperty(descKeywordTable, parser.tokenValue) ?? 208897)
-          : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+      if (parser.currentChar === 92 || parser.currentChar > 0x7e) {
+          return scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+      }
+      const length = parser.index - parser.tokenIndex;
+      if (length < minKeywordLength || length > maxKeywordLength)
+          return 208897;
+      return descKeywordTable.get(parser.tokenValue) ?? 208897;
   }
   function scanUnicodeIdentifier(parser, context) {
       const cookedChar = scanIdentifierUnicodeEscape(parser);
@@ -950,8 +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)
@@ -1075,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;
@@ -1086,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) {
@@ -1095,7 +1100,7 @@
                   while (CharTypes[char] & (32 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1107,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) {
@@ -1116,7 +1121,7 @@
                   while (CharTypes[char] & (128 | 4096)) {
                       if (char === 95) {
                           if (!allowSeparator) {
-                              parser.report(152);
+                              parser.report(154);
                           }
                           allowSeparator = 0;
                           char = advanceChar(parser);
@@ -1128,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) {
@@ -1161,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;
@@ -1172,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;
@@ -1237,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);
@@ -1248,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);
   }
@@ -1969,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;
@@ -2198,10 +2203,10 @@
   function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
       if (context & 1) {
           if ((t & 36864) === 36864) {
-              parser.report(118);
+              parser.report(120);
           }
           if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
       }
       if ((t & 20480) === 20480 || t === -2147483527) {
@@ -2211,7 +2216,7 @@
           parser.report(100);
       }
       if (context & (2048 | 2) && t === 209006) {
-          parser.report(110);
+          parser.report(112);
       }
       if (context & (1024 | 1) && t === 241771) {
           parser.report(97, 'yield');
@@ -2220,10 +2225,10 @@
   function validateFunctionName(parser, context, t) {
       if (context & 1) {
           if ((t & 36864) === 36864) {
-              parser.report(118);
+              parser.report(120);
           }
           if ((t & 537079808) === 537079808) {
-              parser.report(119);
+              parser.report(121);
           }
           if (t === -2147483526) {
               parser.report(95);
@@ -2236,7 +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');
@@ -2245,7 +2250,7 @@
   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)
@@ -2261,7 +2266,7 @@
       while (labels) {
           if (labels['$' + name]) {
               if (isIterationStatement)
-                  parser.report(137);
+                  parser.report(139);
               return 1;
           }
           if (isIterationStatement && labels.loop)
@@ -2274,7 +2279,7 @@
       let set = labels;
       while (set) {
           if (set['$' + name])
-              parser.report(136, name);
+              parser.report(138, name);
           set = set['$'];
       }
       labels['$' + name] = 1;
@@ -2302,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',
@@ -4435,8 +4440,8 @@
       zscr: '\uD835\uDCCF',
       zwj: '\u200D',
       zwnj: '\u200C',
-  };
-  const decodeMap = {
+  }));
+  const decodeMap = new Map(Object.entries({
       '0': 65533,
       '128': 8364,
       '130': 8218,
@@ -4465,7 +4470,7 @@
       '156': 339,
       '158': 382,
       '159': 376,
-  };
+  }).map(([key, value]) => [Number(key), value]));
   function decodeHTMLStrict(text) {
       return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
           if (key.charAt(1) === '#') {
@@ -4473,14 +4478,14 @@
               const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
               return decodeCodePoint(codePoint);
           }
-          return getOwnProperty(entities, key.slice(1, -1)) ?? key;
+          return entities.get(key.slice(1, -1)) ?? key;
       });
   }
   function decodeCodePoint(codePoint) {
       if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
           return '\uFFFD';
       }
-      return String.fromCodePoint(getOwnProperty(decodeMap, codePoint) ?? codePoint);
+      return String.fromCodePoint(decodeMap.get(codePoint) ?? codePoint);
   }
 
   function scanJSXAttributeValue(parser, context) {
@@ -4565,6 +4570,8 @@
       return parser.getToken();
   }
 
+  const nextFeatures = 1 | 2 | 4;
+
   function normalizeRanges(ranges) {
       if (!ranges)
           return undefined;
@@ -4577,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;
+      }
+      ranges = normalizeRanges(ranges);
+      if (module && !sourceType) {
+          sourceType = 'module';
       }
-      if (options.globalReturn && (!options.sourceType || options.sourceType === 'script')) {
-          options.sourceType = 'commonjs';
+      if (globalReturn && (!sourceType || sourceType === 'script')) {
+          sourceType = 'commonjs';
       }
+      const options = {
+          ...restOptions,
+          ranges,
+          features,
+          sourceType,
+      };
       return options;
   }
 
@@ -4608,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);
       }
@@ -4669,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;
@@ -4693,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 &&
@@ -4701,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);
       }
@@ -4748,6 +4765,7 @@
       options;
       token = 1048576;
       flags = 0;
+      features = 0;
       index = 0;
       line = 1;
       column = 0;
@@ -4773,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);
           }
@@ -4853,7 +4872,7 @@
       declareUnboundVariable(name) {
           const { exportedNames } = this;
           if (exportedNames.has(name)) {
-              this.report(147, name);
+              this.report(149, name);
           }
           exportedNames.add(name);
       }
@@ -4876,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) {
@@ -4961,7 +4961,7 @@
           if (scope) {
               for (const name of parser.exportedBindings) {
                   if (!scope.hasVariable(name))
-                      parser.report(148, name);
+                      parser.report(150, name);
               }
           }
       }
@@ -5023,22 +5023,28 @@
               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 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               return parseClassDeclaration(parser, context, scope, privateScope, 0);
           case 86090:
@@ -5106,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
@@ -5209,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())) {
@@ -5384,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({
@@ -5400,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);
@@ -5597,7 +5603,7 @@
   function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
       const start = parser.tokenStart;
       if (context & 524288)
-          parser.report(177);
+          parser.report(179);
       nextToken(parser, context | 32);
       let argument;
       if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5654,7 +5660,7 @@
           if (resourceNames) {
               const { name } = declaration.id;
               if (resourceNames.has(name))
-                  parser.report(145, name);
+                  parser.report(147, name);
               resourceNames.add(name);
           }
           list.push(declaration);
@@ -5733,7 +5739,7 @@
                   parser.assignable = 1;
                   init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
                   if (parser.getToken() === 471156)
-                      parser.report(115);
+                      parser.report(117);
               }
           }
           else if (token === 209013) {
@@ -5785,7 +5791,7 @@
                           if (resourceNames) {
                               const { name } = declaration.id;
                               if (resourceNames.has(name))
-                                  parser.report(145, name);
+                                  parser.report(147, name);
                               resourceNames.add(name);
                           }
                           declarations.push(declaration);
@@ -5830,7 +5836,7 @@
       else if (token === 209006 &&
           (context & 2048 || (context & 2 && context & 8))) {
           if (context & 524288)
-              parser.report(177);
+              parser.report(179);
           nextToken(parser, context | 32);
           let awaitArgument;
           if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5948,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);
   }
@@ -5958,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) {
@@ -5965,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));
@@ -6001,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 = {
@@ -6009,6 +6097,7 @@
           specifiers,
           source,
           attributes,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       matchOrInsertSemicolon(parser, context | 32);
       return parser.finishNode(node, start);
@@ -6091,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 133:
+                  if (!(parser.features & 1)) {
+                      parser.report(30, '@');
+                  }
               case 86094:
                   declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                   break;
@@ -6214,7 +6310,7 @@
               }
               else {
                   if (hasLiteralLocal) {
-                      parser.report(172);
+                      parser.report(174);
                   }
                   if (scope) {
                       tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -6225,6 +6321,9 @@
               break;
           }
           case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
               break;
@@ -6357,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;
@@ -6384,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;
@@ -6440,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) {
@@ -6467,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) {
@@ -6501,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) {
@@ -6526,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);
               }
           }
       }
@@ -6563,7 +6663,7 @@
       nextToken(parser, context);
       switch (parser.getToken()) {
           case 67108991:
-              parser.report(167);
+              parser.report(169);
           case 67174411: {
               if ((context & 512) === 0)
                   parser.report(28);
@@ -6610,7 +6710,7 @@
               case 67108877: {
                   nextToken(parser, (context | 262144 | 8) ^ 8);
                   if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
-                      parser.report(173);
+                      parser.report(175);
                   }
                   parser.assignable =
                       (parser.flags & 2048) === 2048
@@ -6690,7 +6790,7 @@
               }
               default:
                   if ((parser.flags & 2048) === 2048) {
-                      parser.report(166);
+                      parser.report(168);
                   }
                   parser.assignable = 2;
                   expr = parser.finishNode({
@@ -6771,7 +6871,7 @@
           parser.getToken() !== -2147483527 &&
           parser.getToken() !== -2147483526 &&
           parser.getToken() !== 131) {
-          parser.report(160);
+          parser.report(162);
       }
       return parser.getToken() === 131
           ? parsePrivateIdentifier(parser, context, privateScope, 0)
@@ -6822,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);
           }
@@ -6867,6 +6967,9 @@
           case 65540:
               return parseRegExpLiteral(parser, context);
           case 133:
+              if (!(parser.features & 1)) {
+                  parser.report(30, '@');
+              }
           case 86094:
               return parseClassExpression(parser, context, privateScope, inGroup, start);
           case 86109:
@@ -6895,24 +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();
+      const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && parser.tokenValue === 'defer';
+      const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && parser.tokenValue === 'source';
+      if (isPhaseDefer || isPhaseSource) {
+          if (inNew)
+              parser.report(144);
+          nextToken(parser, context);
+          const expression = parseImportExpression(parser, context, privateScope, inGroup, start, parser.tokenValue);
+          parser.assignable = 2;
+          return expression;
+      }
+      if ((context & 2) === 0) {
+          throw new ParseError(propertyStart, propertyEnd, 171);
+      }
       if (token !== 209031 && parser.tokenValue !== 'meta') {
-          parser.report(174);
+          parser.report(176);
       }
       else if (token & -2147483648) {
-          parser.report(175);
+          parser.report(177);
       }
       parser.assignable = 2;
       return parser.finishNode({
@@ -6921,10 +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) {
@@ -6939,6 +7055,7 @@
           type: 'ImportExpression',
           source,
           options,
+          ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
       };
       consume(parser, context, 16);
       return parser.finishNode(node, start);
@@ -6956,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({
@@ -6994,7 +7111,7 @@
       if (parser.getToken() === 134283267) {
           const value = parser.tokenValue;
           if (!value.isWellFormed()) {
-              parser.report(171);
+              parser.report(173);
           }
           return parseLiteral(parser, context);
       }
@@ -7555,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,
@@ -7814,7 +7931,7 @@
                           parser.report(95);
                       if (token === 209005) {
                           if (parser.flags & 1)
-                              parser.report(132);
+                              parser.report(134);
                           state |= 16 | 1;
                       }
                       else if (token === 209008) {
@@ -7878,7 +7995,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(133);
+                      parser.report(135);
                   }
               }
               else if ((parser.getToken() & 134217728) === 134217728) {
@@ -7982,7 +8099,7 @@
                       destructible = 16;
                   }
                   else {
-                      parser.report(134);
+                      parser.report(136);
                   }
               }
               else if (parser.getToken() === 69271571) {
@@ -8129,7 +8246,7 @@
                       value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                   }
                   else {
-                      parser.report(126);
+                      parser.report(128);
                   }
               }
               else {
@@ -8307,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) {
@@ -8380,7 +8497,7 @@
       }
       consume(parser, context, 16);
       if (destructible & 16 && destructible & 8)
-          parser.report(151);
+          parser.report(153);
       destructible |=
           parser.destructible & 256
               ? 256
@@ -8405,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
@@ -8476,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;
@@ -8494,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({
@@ -8634,7 +8751,7 @@
       const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
       context = (context | 131072) ^ 131072;
       if (parser.getToken() === 67108991)
-          parser.report(168);
+          parser.report(170);
       const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
       parser.assignable = 2;
       return parser.finishNode({
@@ -8733,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) {
@@ -8834,9 +8951,6 @@
       let start;
       let decorators;
       if (parser.leadingDecorators.decorators.length) {
-          if (parser.getToken() === 133) {
-              parser.report(30, '@');
-          }
           start = parser.leadingDecorators.start;
           decorators = [...parser.leadingDecorators.decorators];
           parser.leadingDecorators.decorators.length = 0;
@@ -8846,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);
@@ -8885,7 +8999,7 @@
           id,
           superClass,
           body,
-          ...(parser.options.next ? { decorators } : null),
+          ...(parser.features & 1 ? { decorators } : null),
       }, start);
   }
   function parseClassExpression(parser, context, privateScope, inGroup, start) {
@@ -8893,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);
       }
@@ -8917,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) {
+      if (parser.features & 1) {
           while (parser.getToken() === 133) {
-              list.push(parseDecoratorList(parser, context, privateScope));
+              list.push(parseDecorator(parser, context, privateScope));
           }
       }
       return list;
   }
-  function parseDecoratorList(parser, context, privateScope) {
+  function parseDecorator(parser, context, privateScope) {
       const start = parser.tokenStart;
       nextToken(parser, context | 32);
       const expressionStart = parser.tokenStart;
-      let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
-      expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, expressionStart);
+      let expression;
+      if (parser.getToken() === 67174411) {
+          expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
+      }
+      else {
+          const token = parser.getToken();
+          if (((token & 143360) !== 143360 && !isValidIdentifier(context, token)) ||
+              (context & 1 && (token & 36864) === 36864)) {
+              parser.report(30, KeywordDescTable[token & 255]);
+          }
+          if (token === 209006 && context & (2048 | 2)) {
+              parser.report(112);
+          }
+          if (token === 241771 && context & 1024) {
+              parser.report(97, 'yield');
+          }
+          let memberExpression = parseIdentifier(parser, context | 64);
+          while (parser.getToken() === 67108877) {
+              nextToken(parser, (context | 262144 | 8) ^ 8);
+              const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
+              memberExpression = parser.finishNode({
+                  type: 'MemberExpression',
+                  object: memberExpression,
+                  computed: false,
+                  property,
+                  optional: false,
+              }, expressionStart);
+          }
+          expression = memberExpression;
+          if (parser.getToken() === 67174411) {
+              const args = parseArguments(parser, context, privateScope, 0);
+              expression = parser.finishNode({
+                  type: 'CallExpression',
+                  callee: memberExpression,
+                  arguments: args,
+                  optional: false,
+              }, expressionStart);
+          }
+      }
       return parser.finishNode({
           type: 'Decorator',
           expression,
@@ -8953,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));
@@ -9022,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;
@@ -9075,12 +9226,12 @@
               key = parsePrivateIdentifier(parser, context, privateScope, kind);
           }
           else
-              parser.report(135);
+              parser.report(137);
       }
       if ((kind & 2) === 0) {
           if (parser.tokenValue === 'constructor') {
               if ((parser.getToken() & 1073741824) === 1073741824) {
-                  parser.report(129);
+                  parser.report(131);
               }
               else if ((kind & 32) === 0 && parser.getToken() === 67174411) {
                   if (kind & (768 | 16 | 128 | 8)) {
@@ -9118,7 +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) {
@@ -9126,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);
@@ -9151,7 +9302,7 @@
           nextToken(parser, context | 32);
           const { tokenStart } = parser;
           if (parser.getToken() === 537079928)
-              parser.report(119);
+              parser.report(121);
           const modifierFlags = 1024 |
               2048 |
               8192 |
@@ -9177,7 +9328,7 @@
           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) {
@@ -9199,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 === -2147483526) {
-              parser.report(118);
+              parser.report(120);
           }
       }
       if ((token & 20480) === 20480) {
@@ -9212,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))
@@ -9220,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);
@@ -9254,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',
@@ -9449,7 +9600,7 @@
                   value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                   break;
               default:
-                  parser.report(154);
+                  parser.report(156);
           }
       }
       return parser.finishNode({
@@ -9476,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,