meriyah 7.2.0 → 7.3.0

package/dist/meriyah.mjs

@@ -1,4 +1,4 @@
-var version$1 = "7.2.0";
+var version$1 = "7.3.0";
 var packageJson = {
 	version: version$1};
 
@@ -621,7 +621,7 @@ const errorMessages = {
     [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',
@@ -645,7 +645,7 @@ const errorMessages = {
     [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'",
@@ -657,7 +657,7 @@ const errorMessages = {
     [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",
@@ -719,73 +719,75 @@ const errorMessages = {
     [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;
@@ -809,10 +811,6 @@ class ParseError extends SyntaxError {
 }
 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',
@@ -834,75 +832,82 @@ const KeywordDescTable = [
     '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);
@@ -944,8 +949,8 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
         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)
@@ -1069,7 +1074,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (64 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator)
-                            parser.report(152);
+                            parser.report(154);
                         allowSeparator = 0;
                         char = advanceChar(parser);
                         continue;
@@ -1080,7 +1085,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    parser.report(digits === 0 ? 21 : 153);
+                    parser.report(digits === 0 ? 21 : 155);
                 }
             }
             else if ((char | 32) === 111) {
@@ -1089,7 +1094,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (32 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator) {
-                            parser.report(152);
+                            parser.report(154);
                         }
                         allowSeparator = 0;
                         char = advanceChar(parser);
@@ -1101,7 +1106,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    parser.report(digits === 0 ? 0 : 153);
+                    parser.report(digits === 0 ? 0 : 155);
                 }
             }
             else if ((char | 32) === 98) {
@@ -1110,7 +1115,7 @@ function scanNumber(parser, context, kind) {
                 while (CharTypes[char] & (128 | 4096)) {
                     if (char === 95) {
                         if (!allowSeparator) {
-                            parser.report(152);
+                            parser.report(154);
                         }
                         allowSeparator = 0;
                         char = advanceChar(parser);
@@ -1122,7 +1127,7 @@ function scanNumber(parser, context, kind) {
                     char = advanceChar(parser);
                 }
                 if (digits === 0 || !allowSeparator) {
-                    parser.report(digits === 0 ? 0 : 153);
+                    parser.report(digits === 0 ? 0 : 155);
                 }
             }
             else if (CharTypes[char] & 32) {
@@ -1155,7 +1160,7 @@ function scanNumber(parser, context, kind) {
                     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;
@@ -1166,7 +1171,7 @@ function scanNumber(parser, context, kind) {
                     --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;
@@ -1231,7 +1236,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
             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);
@@ -1242,7 +1247,7 @@ function scanDecimalDigitsOrSeparator(parser, char) {
         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);
 }
@@ -1963,7 +1968,7 @@ function scanSingleToken(parser, context, state) {
                         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;
@@ -2192,10 +2197,10 @@ function reinterpretToPattern(parser, node) {
 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) {
@@ -2205,7 +2210,7 @@ function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
         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');
@@ -2214,10 +2219,10 @@ function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
 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);
@@ -2230,7 +2235,7 @@ function validateFunctionName(parser, context, t) {
         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');
@@ -2239,7 +2244,7 @@ function validateFunctionName(parser, context, t) {
 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)
@@ -2255,7 +2260,7 @@ function isValidLabel(parser, labels, name, isIterationStatement) {
     while (labels) {
         if (labels['$' + name]) {
             if (isIterationStatement)
-                parser.report(137);
+                parser.report(139);
             return 1;
         }
         if (isIterationStatement && labels.loop)
@@ -2268,7 +2273,7 @@ function validateAndDeclareLabel(parser, labels, name) {
     let set = labels;
     while (set) {
         if (set['$' + name])
-            parser.report(136, name);
+            parser.report(138, name);
         set = set['$'];
     }
     labels['$' + name] = 1;
@@ -2296,14 +2301,14 @@ function isValidIdentifier(context, t) {
 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',
@@ -4429,8 +4434,8 @@ const entities = {
     zscr: '\uD835\uDCCF',
     zwj: '\u200D',
     zwnj: '\u200C',
-};
-const decodeMap = {
+}));
+const decodeMap = new Map(Object.entries({
     '0': 65533,
     '128': 8364,
     '130': 8218,
@@ -4459,7 +4464,7 @@ const decodeMap = {
     '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) === '#') {
@@ -4467,14 +4472,14 @@ function decodeHTMLStrict(text) {
             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) {
@@ -4559,6 +4564,8 @@ function rescanJSXIdentifier(parser) {
     return parser.getToken();
 }
 
+const nextFeatures = 1 | 2 | 4;
+
 function normalizeRanges(ranges) {
     if (!ranges)
         return undefined;
@@ -4571,17 +4578,27 @@ function normalizeRanges(ranges) {
     };
 }
 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;
 }
 
@@ -4602,7 +4619,7 @@ class PrivateScope {
         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);
     }
@@ -4663,17 +4680,17 @@ class Scope {
                     ((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;
@@ -4687,7 +4704,7 @@ class Scope {
         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 &&
@@ -4695,22 +4712,22 @@ class Scope {
                 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);
     }
@@ -4742,6 +4759,7 @@ class Parser {
     options;
     token = 1048576;
     flags = 0;
+    features = 0;
     index = 0;
     line = 1;
     column = 0;
@@ -4767,6 +4785,7 @@ class Parser {
         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);
         }
@@ -4847,7 +4866,7 @@ class Parser {
     declareUnboundVariable(name) {
         const { exportedNames } = this;
         if (exportedNames.has(name)) {
-            this.report(147, name);
+            this.report(149, name);
         }
         exportedNames.add(name);
     }
@@ -4870,29 +4889,10 @@ class Parser {
         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) {
@@ -4955,7 +4955,7 @@ function parseSource(source, rawOptions = {}, context = 0) {
         if (scope) {
             for (const name of parser.exportedBindings) {
                 if (!scope.hasVariable(name))
-                    parser.report(148, name);
+                    parser.report(150, name);
             }
         }
     }
@@ -5017,22 +5017,28 @@ function parseModuleItem(parser, context, scope) {
             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:
@@ -5100,9 +5106,9 @@ function parseStatement(parser, context, scope, privateScope, origin, labels, al
         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
@@ -5203,7 +5209,7 @@ function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, priva
     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())) {
@@ -5378,7 +5384,7 @@ function parseContinueStatement(parser, context, labels) {
         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({
@@ -5394,7 +5400,7 @@ function parseBreakStatement(parser, context, labels) {
         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);
@@ -5591,7 +5597,7 @@ function parseUsingDeclarationOrExpressionStatement(parser, context, scope, priv
 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) {
@@ -5648,7 +5654,7 @@ function parseVariableDeclarationList(parser, context, scope, privateScope, kind
         if (resourceNames) {
             const { name } = declaration.id;
             if (resourceNames.has(name))
-                parser.report(145, name);
+                parser.report(147, name);
             resourceNames.add(name);
         }
         list.push(declaration);
@@ -5727,7 +5733,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                 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) {
@@ -5779,7 +5785,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                         if (resourceNames) {
                             const { name } = declaration.id;
                             if (resourceNames.has(name))
-                                parser.report(145, name);
+                                parser.report(147, name);
                             resourceNames.add(name);
                         }
                         declarations.push(declaration);
@@ -5824,7 +5830,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     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) {
@@ -5942,9 +5948,9 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
 }
 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);
 }
@@ -5952,6 +5958,8 @@ function parseImportDeclaration(parser, context, scope) {
     const start = parser.tokenStart;
     nextToken(parser, context);
     let source;
+    let sourceParsed = false;
+    let phase = null;
     const { tokenStart } = parser;
     let specifiers = [];
     if (parser.getToken() === 134283267) {
@@ -5959,14 +5967,93 @@ function parseImportDeclaration(parser, context, scope) {
     }
     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));
@@ -5995,7 +6082,8 @@ function parseImportDeclaration(parser, context, scope) {
                     parser.report(30, KeywordDescTable[parser.getToken() & 255]);
             }
         }
-        source = parseModuleSpecifier(parser, context);
+        if (!sourceParsed)
+            source = parseModuleSpecifier(parser, context);
     }
     const attributes = parseImportAttributes(parser, context);
     const node = {
@@ -6003,6 +6091,7 @@ function parseImportDeclaration(parser, context, scope) {
         specifiers,
         source,
         attributes,
+        ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
     };
     matchOrInsertSemicolon(parser, context | 32);
     return parser.finishNode(node, start);
@@ -6085,17 +6174,24 @@ function parseImportCallDeclaration(parser, context, privateScope, start) {
 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;
@@ -6208,7 +6304,7 @@ function parseExportDeclaration(parser, context, scope) {
             }
             else {
                 if (hasLiteralLocal) {
-                    parser.report(172);
+                    parser.report(174);
                 }
                 if (scope) {
                     tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -6219,6 +6315,9 @@ function parseExportDeclaration(parser, context, scope) {
             break;
         }
         case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
             break;
@@ -6351,7 +6450,7 @@ function parseBinaryExpression(parser, context, privateScope, inGroup, start, mi
         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;
@@ -6378,10 +6477,10 @@ function parseUnaryExpression(parser, context, privateScope, isLHS, inGroup) {
         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;
@@ -6434,7 +6533,7 @@ function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup
         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) {
@@ -6461,17 +6560,17 @@ function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew,
     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) {
@@ -6495,6 +6594,7 @@ function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew,
 }
 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) {
@@ -6520,19 +6620,19 @@ function parseFunctionBody(parser, context, scope, privateScope, origin, funcNam
         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);
             }
         }
     }
@@ -6557,7 +6657,7 @@ function parseSuperExpression(parser, context) {
     nextToken(parser, context);
     switch (parser.getToken()) {
         case 67108991:
-            parser.report(167);
+            parser.report(169);
         case 67174411: {
             if ((context & 512) === 0)
                 parser.report(28);
@@ -6604,7 +6704,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
             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
@@ -6684,7 +6784,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
             }
             default:
                 if ((parser.flags & 2048) === 2048) {
-                    parser.report(166);
+                    parser.report(168);
                 }
                 parser.assignable = 2;
                 expr = parser.finishNode({
@@ -6765,7 +6865,7 @@ function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
         parser.getToken() !== -2147483527 &&
         parser.getToken() !== -2147483526 &&
         parser.getToken() !== 131) {
-        parser.report(160);
+        parser.report(162);
     }
     return parser.getToken() === 131
         ? parsePrivateIdentifier(parser, context, privateScope, 0)
@@ -6816,10 +6916,10 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             !(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);
         }
@@ -6861,6 +6961,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         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:
@@ -6889,24 +6992,37 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
 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({
@@ -6915,10 +7031,10 @@ function parseImportMetaExpression(parser, context, meta, start) {
         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) {
@@ -6933,6 +7049,7 @@ function parseImportExpression(parser, context, privateScope, inGroup, start) {
         type: 'ImportExpression',
         source,
         options,
+        ...(parser.features & 2 || parser.features & 4 ? { phase } : null),
     };
     consume(parser, context, 16);
     return parser.finishNode(node, start);
@@ -6950,7 +7067,7 @@ function parseImportAttributes(parser, context) {
         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({
@@ -6988,7 +7105,7 @@ function parseModuleExportName(parser, context) {
     if (parser.getToken() === 134283267) {
         const value = parser.tokenValue;
         if (!value.isWellFormed()) {
-            parser.report(171);
+            parser.report(173);
         }
         return parseLiteral(parser, context);
     }
@@ -7549,7 +7666,7 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
         }
         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,
@@ -7808,7 +7925,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         parser.report(95);
                     if (token === 209005) {
                         if (parser.flags & 1)
-                            parser.report(132);
+                            parser.report(134);
                         state |= 16 | 1;
                     }
                     else if (token === 209008) {
@@ -7872,7 +7989,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else {
-                    parser.report(133);
+                    parser.report(135);
                 }
             }
             else if ((parser.getToken() & 134217728) === 134217728) {
@@ -7976,7 +8093,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     destructible = 16;
                 }
                 else {
-                    parser.report(134);
+                    parser.report(136);
                 }
             }
             else if (parser.getToken() === 69271571) {
@@ -8123,7 +8240,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     value = parseMethodDefinition(parser, context, privateScope, state, inGroup, parser.tokenStart);
                 }
                 else {
-                    parser.report(126);
+                    parser.report(128);
                 }
             }
             else {
@@ -8301,7 +8418,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             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) {
@@ -8374,7 +8491,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     }
     consume(parser, context, 16);
     if (destructible & 16 && destructible & 8)
-        parser.report(151);
+        parser.report(153);
     destructible |=
         parser.destructible & 256
             ? 256
@@ -8399,7 +8516,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         parser.report(63);
     }
     if (destructible & 8) {
-        parser.report(144);
+        parser.report(146);
     }
     parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
     return parser.options.preserveParens
@@ -8470,17 +8587,17 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
         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;
@@ -8488,7 +8605,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
         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({
@@ -8628,7 +8745,7 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     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({
@@ -8727,7 +8844,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             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) {
@@ -8828,9 +8945,6 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     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;
@@ -8840,16 +8954,16 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
         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);
@@ -8879,7 +8993,7 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
         id,
         superClass,
         body,
-        ...(parser.options.next ? { decorators } : null),
+        ...(parser.features & 1 ? { decorators } : null),
     }, start);
 }
 function parseClassExpression(parser, context, privateScope, inGroup, start) {
@@ -8887,12 +9001,12 @@ function parseClassExpression(parser, context, privateScope, inGroup, start) {
     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);
     }
@@ -8911,24 +9025,61 @@ function parseClassExpression(parser, context, privateScope, inGroup, start) {
         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,
@@ -8947,13 +9098,13 @@ function parseClassBody(parser, context, inheritedContext, scope, parentScope, k
         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));
@@ -9016,7 +9167,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                     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;
@@ -9069,12 +9220,12 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             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)) {
@@ -9112,7 +9263,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         computed: (kind & 2) > 0,
         key,
         value,
-        ...(parser.options.next ? { decorators } : null),
+        ...(parser.features & 1 ? { decorators } : null),
     }, start);
 }
 function parsePrivateIdentifier(parser, context, privateScope, kind) {
@@ -9120,7 +9271,7 @@ function parsePrivateIdentifier(parser, context, privateScope, kind) {
     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);
@@ -9145,7 +9296,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
         nextToken(parser, context | 32);
         const { tokenStart } = parser;
         if (parser.getToken() === 537079928)
-            parser.report(119);
+            parser.report(121);
         const modifierFlags = 1024 |
             2048 |
             8192 |
@@ -9171,7 +9322,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
         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) {
@@ -9193,10 +9344,10 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
     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) {
@@ -9206,7 +9357,7 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
         if (context & 1024)
             parser.report(32);
         if (context & 2)
-            parser.report(111);
+            parser.report(113);
     }
     if ((token & 255) === (241737 & 255)) {
         if (kind & (8 | 16))
@@ -9214,9 +9365,9 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
     }
     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);
@@ -9248,7 +9399,7 @@ function parseJSXRootElementOrFragment(parser, context, privateScope, inJSXChild
         [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',
@@ -9443,7 +9594,7 @@ function parseJsxAttribute(parser, context, privateScope) {
                 value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                 break;
             default:
-                parser.report(154);
+                parser.report(156);
         }
     }
     return parser.finishNode({
@@ -9470,7 +9621,7 @@ function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild,
     let expression;
     if (parser.getToken() === 1074790415) {
         if (isAttr)
-            parser.report(157);
+            parser.report(159);
         expression = parseJSXEmptyExpression(parser, {
             index: parser.startIndex,
             line: parser.startLine,