meriyah 7.1.2 → 7.3.0

package/dist/meriyah.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var version$1 = "7.1.2";
+var version$1 = "7.3.0";
 var packageJson = {
 	version: version$1};
 
@@ -488,7 +488,7 @@ function convertTokenType(t) {
             return 'RegularExpression';
         case 67174408:
         case 67174409:
-        case 131:
+        case 132:
             return 'TemplateLiteral';
         default:
             if ((t & 143360) === 143360)
@@ -623,7 +623,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',
@@ -647,7 +647,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'",
@@ -659,7 +659,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",
@@ -721,73 +721,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;
@@ -796,7 +798,7 @@ class ParseError extends SyntaxError {
     loc;
     description;
     constructor(start, end, type, ...params) {
-        const description = errorMessages[type].replace(/%(\d+)/g, (_, i) => params[i]);
+        const description = errorMessages[type].replaceAll(/%(\d+)/g, (_, i) => params[i]);
         const message = '[' + start.line + ':' + start.column + '-' + end.line + ':' + end.column + ']: ' + description;
         super(message);
         this.start = start.index;
@@ -811,10 +813,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',
@@ -831,79 +829,87 @@ const KeywordDescTable = [
     'extends', 'finally', 'for', 'function', 'if', 'import', 'new', 'return', 'super', 'switch',
     'this', 'throw', 'try', 'while', 'with',
     'implements', 'interface', 'package', 'private', 'protected', 'public', 'static', 'yield',
-    'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of',
+    'as', 'async', 'await', 'constructor', 'get', 'set', 'accessor', 'from', 'of', 'using',
     'enum', 'eval', 'arguments', 'escaped keyword', 'escaped future reserved keyword', 'reserved if strict', '#',
     'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
     'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
 ];
-const descKeywordTable = {
-    this: 86111,
-    function: 86104,
-    if: 20569,
-    return: 20572,
-    var: 86088,
-    else: 20563,
-    for: 20567,
-    new: 86107,
-    in: 8673330,
-    typeof: 16863275,
-    while: 20578,
-    case: 20556,
-    break: 20555,
-    try: 20577,
-    catch: 20557,
-    delete: 16863276,
-    throw: 86112,
-    switch: 86110,
-    continue: 20559,
-    default: 20561,
-    instanceof: 8411187,
-    do: 20562,
-    void: 16863277,
-    finally: 20566,
-    async: 209005,
-    await: 209006,
-    class: 86094,
-    const: 86090,
-    constructor: 12399,
-    debugger: 20560,
-    export: 20564,
-    extends: 20565,
-    false: 86021,
-    from: 209011,
-    get: 209008,
-    implements: 36964,
-    import: 86106,
-    interface: 36965,
-    let: 241737,
-    null: 86023,
-    of: 471156,
-    package: 36966,
-    private: 36967,
-    protected: 36968,
-    public: 36969,
-    set: 209009,
-    static: 36970,
-    super: 86109,
-    true: 86022,
-    with: 20579,
-    yield: 241771,
-    enum: 86133,
-    eval: 537079926,
-    as: 77932,
-    arguments: 537079927,
-    target: 209029,
-    meta: 209030,
-    accessor: 12402,
-};
+const descKeywordTable = new Map([
+    ['this', 86111],
+    ['function', 86104],
+    ['if', 20569],
+    ['return', 20572],
+    ['var', 86088],
+    ['else', 20563],
+    ['for', 20567],
+    ['new', 86107],
+    ['in', 8673330],
+    ['typeof', 16863275],
+    ['while', 20578],
+    ['case', 20556],
+    ['break', 20555],
+    ['try', 20577],
+    ['catch', 20557],
+    ['delete', 16863276],
+    ['throw', 86112],
+    ['switch', 86110],
+    ['continue', 20559],
+    ['default', 20561],
+    ['instanceof', 8411187],
+    ['do', 20562],
+    ['void', 16863277],
+    ['finally', 20566],
+    ['async', 209005],
+    ['await', 209006],
+    ['class', 86094],
+    ['const', 86090],
+    ['constructor', 12399],
+    ['debugger', 20560],
+    ['export', 20564],
+    ['extends', 20565],
+    ['false', 86021],
+    ['from', 209011],
+    ['get', 209008],
+    ['implements', 36964],
+    ['import', 86106],
+    ['interface', 36965],
+    ['let', 241737],
+    ['null', 86023],
+    ['of', 471156],
+    ['using', 209013],
+    ['package', 36966],
+    ['private', 36967],
+    ['protected', 36968],
+    ['public', 36969],
+    ['set', 209009],
+    ['static', 36970],
+    ['super', 86109],
+    ['true', 86022],
+    ['with', 20579],
+    ['yield', 241771],
+    ['enum', 86134],
+    ['eval', 537079927],
+    ['as', 77932],
+    ['arguments', 537079928],
+    ['target', 209030],
+    ['meta', 209031],
+    ['accessor', 12402],
+]);
+const keywordLengths = [...descKeywordTable.keys()].map((keyword) => keyword.length);
+const minKeywordLength = Math.min(...keywordLengths);
+const maxKeywordLength = Math.max(...keywordLengths);
 
 function scanIdentifier(parser, context, isValidAsKeyword) {
     while (isIdPart[advanceChar(parser)])
         ;
     parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
-    return parser.currentChar !== 92 && parser.currentChar <= 0x7e
-        ? (getOwnProperty(descKeywordTable, parser.tokenValue) ?? 208897)
-        : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+    if (parser.currentChar === 92 || parser.currentChar > 0x7e) {
+        return scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+    }
+    const length = parser.index - parser.tokenIndex;
+    if (length < minKeywordLength || length > maxKeywordLength)
+        return 208897;
+    return descKeywordTable.get(parser.tokenValue) ?? 208897;
 }
 function scanUnicodeIdentifier(parser, context) {
     const cookedChar = scanIdentifierUnicodeEscape(parser);
@@ -945,8 +951,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)
@@ -955,24 +961,24 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
             if ((context & (2 | 2048)) === 0) {
                 return token | -2147483648;
             }
-            return -2147483528;
+            return -2147483527;
         }
         if (context & 1) {
             if (token === 36970) {
-                return -2147483527;
+                return -2147483526;
             }
             if ((token & 36864) === 36864) {
-                return -2147483527;
+                return -2147483526;
             }
             if ((token & 20480) === 20480) {
                 if (context & 262144 && (context & 8) === 0) {
                     return token | -2147483648;
                 }
                 else {
-                    return -2147483528;
+                    return -2147483527;
                 }
             }
-            return 209018 | -2147483648;
+            return 209019 | -2147483648;
         }
         if (context & 262144 &&
             (context & 8) === 0 &&
@@ -981,31 +987,31 @@ function scanIdentifierSlowCase(parser, context, hasEscape, isValidAsKeyword) {
         }
         if (token === 241771) {
             return context & 262144
-                ? 209018 | -2147483648
+                ? 209019 | -2147483648
                 : context & 1024
-                    ? -2147483528
+                    ? -2147483527
                     : token | -2147483648;
         }
         if (token === 209005) {
-            return 209018 | -2147483648;
+            return 209019 | -2147483648;
         }
         if ((token & 36864) === 36864) {
             return token | 12288 | -2147483648;
         }
-        return -2147483528;
+        return -2147483527;
     }
     return 208897 | (hasEscape ? -2147483648 : 0);
 }
 function scanPrivateIdentifier(parser) {
     let char = advanceChar(parser);
     if (char === 92)
-        return 130;
+        return 131;
     const merged = consumePossibleSurrogatePair(parser);
     if (merged)
         char = merged;
     if (!isIdentifierStart(char))
         parser.report(96);
-    return 130;
+    return 131;
 }
 function scanIdentifierUnicodeEscape(parser) {
     if (parser.source.charCodeAt(parser.index + 1) !== 117) {
@@ -1070,7 +1076,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;
@@ -1081,7 +1087,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) {
@@ -1090,7 +1096,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);
@@ -1102,7 +1108,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) {
@@ -1111,7 +1117,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);
@@ -1123,7 +1129,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) {
@@ -1156,7 +1162,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;
@@ -1167,7 +1173,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;
@@ -1211,7 +1217,7 @@ function scanNumber(parser, context, kind) {
     if (isBigInt) {
         parser.tokenRaw = parser.source.slice(parser.tokenIndex, parser.index);
         parser.tokenValue = BigInt(parser.tokenRaw.slice(0, -1).replaceAll('_', ''));
-        return 134283388;
+        return 134283389;
     }
     parser.tokenValue =
         kind & (1 | 2 | 8 | 4)
@@ -1232,7 +1238,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);
@@ -1243,7 +1249,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);
 }
@@ -1580,6 +1586,7 @@ function scanTemplate(parser, context) {
     const { index: start } = parser;
     let token = 67174409;
     let ret = '';
+    let hasCarriageReturn = false;
     let char = advanceChar(parser);
     while (char !== 96) {
         if (char === 36 && parser.source.charCodeAt(parser.index + 1) === 123) {
@@ -1589,6 +1596,8 @@ function scanTemplate(parser, context) {
         }
         else if (char === 92) {
             char = advanceChar(parser);
+            if (char === 13)
+                hasCarriageReturn = true;
             if (char > 0x7e) {
                 ret += String.fromCodePoint(char);
             }
@@ -1603,7 +1612,9 @@ function scanTemplate(parser, context) {
                     parser.line = line;
                     parser.column = column;
                     ret = null;
-                    char = scanBadTemplate(parser, char);
+                    char = scanBadTemplate(parser, char, () => {
+                        hasCarriageReturn = true;
+                    });
                     if (char < 0)
                         token = 67174408;
                     break;
@@ -1614,10 +1625,13 @@ function scanTemplate(parser, context) {
             }
         }
         else if (parser.index < parser.end) {
-            if (char === 13 && parser.source.charCodeAt(parser.index) === 10) {
-                ret += String.fromCodePoint(char);
+            if (char === 13)
+                hasCarriageReturn = true;
+            if (char === 13 && parser.source.charCodeAt(parser.index + 1) === 10) {
                 parser.currentChar = parser.source.charCodeAt(++parser.index);
             }
+            if (char === 13)
+                char = 10;
             if (((char & 83) < 3 && char === 10) || (char ^ 8232) <= 1) {
                 parser.column = -1;
                 parser.line++;
@@ -1630,12 +1644,16 @@ function scanTemplate(parser, context) {
     }
     advanceChar(parser);
     parser.tokenValue = ret;
-    parser.tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+    const tokenRaw = parser.source.slice(start + 1, parser.index - (token === 67174409 ? 1 : 2));
+    parser.tokenRaw = hasCarriageReturn ? tokenRaw.replaceAll(/\r\n?/g, '\n') : tokenRaw;
     return token;
 }
-function scanBadTemplate(parser, ch) {
+function scanBadTemplate(parser, ch, onCarriageReturn) {
     while (ch !== 96) {
         switch (ch) {
+            case 13:
+                onCarriageReturn();
+                break;
             case 36: {
                 const index = parser.index + 1;
                 if (index < parser.end && parser.source.charCodeAt(index) === 123) {
@@ -1666,42 +1684,42 @@ function scanTemplateTail(parser, context) {
 }
 
 const TokenLookup = [
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    127,
-    135,
-    127,
-    127,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
     129,
     128,
+    136,
     128,
     128,
+    130,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
+    129,
     128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    128,
-    127,
     16842798,
     134283267,
-    130,
+    131,
     208897,
     8391477,
     8390213,
@@ -1730,7 +1748,7 @@ const TokenLookup = [
     1077936155,
     8390721,
     22,
-    132,
+    133,
     208897,
     208897,
     208897,
@@ -1758,11 +1776,11 @@ const TokenLookup = [
     208897,
     208897,
     69271571,
-    136,
+    137,
     20,
     8389959,
     208897,
-    131,
+    132,
     4096,
     4096,
     4096,
@@ -1793,7 +1811,7 @@ const TokenLookup = [
     8389702,
     1074790415,
     16842799,
-    128,
+    129,
 ];
 function nextToken(parser, context) {
     parser.flags = (parser.flags | 1) ^ 1;
@@ -1823,8 +1841,8 @@ function scanSingleToken(parser, context, state) {
                 case 1074790417:
                 case 18:
                 case 16842799:
-                case 132:
-                case 128:
+                case 133:
+                case 129:
                     advanceChar(parser);
                     return token;
                 case 208897:
@@ -1835,20 +1853,20 @@ function scanSingleToken(parser, context, state) {
                     return scanNumber(parser, context, 16 | 128);
                 case 134283267:
                     return scanString(parser, context, char);
-                case 131:
+                case 132:
                     return scanTemplate(parser, context);
-                case 136:
+                case 137:
                     return scanUnicodeIdentifier(parser, context);
-                case 130:
+                case 131:
                     return scanPrivateIdentifier(parser);
-                case 127:
+                case 128:
                     advanceChar(parser);
                     break;
-                case 129:
+                case 130:
                     state |= 1 | 4;
                     scanNewLine(parser);
                     break;
-                case 135:
+                case 136:
                     consumeLineFeed(parser, state);
                     state = (state & -5) | 1;
                     break;
@@ -1952,7 +1970,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;
@@ -2071,7 +2089,7 @@ function scanSingleToken(parser, context, state) {
                             advanceChar(parser);
                             return 4718634;
                         }
-                        return 276824445;
+                        return 276824446;
                     }
                     if (ch === 46) {
                         const index = parser.index + 1;
@@ -2079,7 +2097,7 @@ function scanSingleToken(parser, context, state) {
                             ch = source.charCodeAt(index);
                             if (!(ch >= 48 && ch <= 57)) {
                                 advanceChar(parser);
-                                return 67108990;
+                                return 67108991;
                             }
                         }
                     }
@@ -2181,20 +2199,20 @@ 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 === -2147483528) {
+    if ((t & 20480) === 20480 || t === -2147483527) {
         parser.report(102);
     }
     if (kind & (8 | 16) && (t & 255) === (241737 & 255)) {
         parser.report(100);
     }
     if (context & (2048 | 2) && t === 209006) {
-        parser.report(110);
+        parser.report(112);
     }
     if (context & (1024 | 1) && t === 241771) {
         parser.report(97, 'yield');
@@ -2203,15 +2221,15 @@ 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 === -2147483527) {
+        if (t === -2147483526) {
             parser.report(95);
         }
-        if (t === -2147483528) {
+        if (t === -2147483527) {
             parser.report(95);
         }
     }
@@ -2219,7 +2237,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');
@@ -2228,14 +2246,14 @@ 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)
         parser.report(97, 'yield');
     return ((t & 20480) === 20480 ||
         (t & 36864) === 36864 ||
-        t == -2147483527);
+        t == -2147483526);
 }
 function isPropertyWithPrivateFieldKey(expr) {
     return !expr.property ? false : expr.property.type === 'PrivateIdentifier';
@@ -2244,7 +2262,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)
@@ -2257,7 +2275,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;
@@ -2285,14 +2303,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',
@@ -4418,8 +4436,8 @@ const entities = {
     zscr: '\uD835\uDCCF',
     zwj: '\u200D',
     zwnj: '\u200C',
-};
-const decodeMap = {
+}));
+const decodeMap = new Map(Object.entries({
     '0': 65533,
     '128': 8364,
     '130': 8218,
@@ -4448,22 +4466,22 @@ const decodeMap = {
     '156': 339,
     '158': 382,
     '159': 376,
-};
+}).map(([key, value]) => [Number(key), value]));
 function decodeHTMLStrict(text) {
-    return text.replace(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
+    return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
         if (key.charAt(1) === '#') {
             const secondChar = key.charAt(2);
             const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
             return decodeCodePoint(codePoint);
         }
-        return getOwnProperty(entities, key.slice(1, -1)) ?? key;
+        return entities.get(key.slice(1, -1)) ?? key;
     });
 }
 function decodeCodePoint(codePoint) {
     if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
         return '\uFFFD';
     }
-    return String.fromCodePoint(getOwnProperty(decodeMap, codePoint) ?? codePoint);
+    return String.fromCodePoint(decodeMap.get(codePoint) ?? codePoint);
 }
 
 function scanJSXAttributeValue(parser, context) {
@@ -4533,7 +4551,7 @@ function nextJSXToken(parser) {
     if (parser.options.raw)
         parser.tokenRaw = raw;
     parser.tokenValue = decodeHTMLStrict(raw);
-    parser.setToken(137);
+    parser.setToken(138);
 }
 function rescanJSXIdentifier(parser) {
     if ((parser.getToken() & 143360) === 143360) {
@@ -4548,6 +4566,8 @@ function rescanJSXIdentifier(parser) {
     return parser.getToken();
 }
 
+const nextFeatures = 1 | 2 | 4;
+
 function normalizeRanges(ranges) {
     if (!ranges)
         return undefined;
@@ -4560,17 +4580,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;
     }
-    if (options.globalReturn && (!options.sourceType || options.sourceType === 'script')) {
-        options.sourceType = 'commonjs';
+    ranges = normalizeRanges(ranges);
+    if (module && !sourceType) {
+        sourceType = 'module';
     }
+    if (globalReturn && (!sourceType || sourceType === 'script')) {
+        sourceType = 'commonjs';
+    }
+    const options = {
+        ...restOptions,
+        ranges,
+        features,
+        sourceType,
+    };
     return options;
 }
 
@@ -4591,7 +4621,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);
     }
@@ -4652,17 +4682,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;
@@ -4676,7 +4706,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 &&
@@ -4684,22 +4714,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);
     }
@@ -4731,6 +4761,7 @@ class Parser {
     options;
     token = 1048576;
     flags = 0;
+    features = 0;
     index = 0;
     line = 1;
     column = 0;
@@ -4756,6 +4787,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);
         }
@@ -4836,7 +4868,7 @@ class Parser {
     declareUnboundVariable(name) {
         const { exportedNames } = this;
         if (exportedNames.has(name)) {
-            this.report(147, name);
+            this.report(149, name);
         }
         exportedNames.add(name);
     }
@@ -4859,29 +4891,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) {
@@ -4944,7 +4957,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);
             }
         }
     }
@@ -4994,7 +5007,7 @@ function parseModuleItemList(parser, context, scope) {
     return statements;
 }
 function parseModuleItem(parser, context, scope) {
-    if (parser.getToken() === 132) {
+    if (parser.getToken() === 133) {
         Object.assign(parser.leadingDecorators, {
             start: parser.tokenStart,
             decorators: parseDecorators(parser, context, undefined),
@@ -5006,28 +5019,42 @@ 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 132:
+        case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             return parseClassDeclaration(parser, context, scope, privateScope, 0);
         case 86090:
             return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
         case 241737:
             return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
+        case 209013:
+            return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+        case 209006:
+            if ((context & 2048 || (context & 2 && context & 8)) &&
+                nextTokenIsUsingOnSameLine(parser)) {
+                return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+            }
+            return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
         case 20564:
             parser.report(103, 'export');
         case 86106:
@@ -5081,9 +5108,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
@@ -5111,15 +5138,18 @@ function parseExpressionOrLabelledStatement(parser, context, scope, privateScope
         default:
             expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart);
     }
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, expr, token, tokenValue, tokenStart);
+}
+function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart) {
     if (token & 143360 && parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, allowFuncDecl, tokenStart);
+        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart);
     }
-    expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
-    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expr);
+    let expression = parseMemberOrUpdateExpression(parser, context, privateScope, initialExpression, 0, 0, tokenStart);
+    expression = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expression);
     if (parser.getToken() === 18) {
-        expr = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expr);
+        expression = parseSequenceExpression(parser, context, privateScope, 0, tokenStart, expression);
     }
-    return parseExpressionStatement(parser, context, expr, tokenStart);
+    return parseExpressionStatement(parser, context, expression, tokenStart);
 }
 function parseBlock(parser, context, scope, privateScope, labels, start = parser.tokenStart, type = 'BlockStatement') {
     const body = [];
@@ -5181,7 +5211,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())) {
@@ -5308,9 +5338,14 @@ function parseSwitchStatement(parser, context, scope, privateScope, labels) {
         while (parser.getToken() !== 20556 &&
             parser.getToken() !== 1074790415 &&
             parser.getToken() !== 20561) {
-            consequent.push(parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
+            const statement = parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
                 $: labels,
-            }));
+            });
+            if (statement.type === 'VariableDeclaration' &&
+                (statement.kind === 'using' || statement.kind === 'await using')) {
+                parser.report(30, statement.kind);
+            }
+            consequent.push(statement);
         }
         cases.push(parser.finishNode({
             type: 'SwitchCase',
@@ -5351,7 +5386,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({
@@ -5367,7 +5402,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);
@@ -5512,14 +5547,90 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     }
     return parseExpressionStatement(parser, context, expr, tokenStart);
 }
-function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin) {
+function nextTokenIsUsingOnSameLine(parser) {
+    const { index: parserIndex, source } = parser;
+    let index = parserIndex;
+    while (index < parser.end) {
+        const char = source.charCodeAt(index);
+        if (char === 0x0a || char === 0x0d || char === 0x2028 || char === 0x2029)
+            return false;
+        if (/\s/u.test(source[index])) {
+            index++;
+            continue;
+        }
+        if (char === 0x2f && source.charCodeAt(index + 1) === 0x2a) {
+            index += 2;
+            while (index < parser.end) {
+                const commentChar = source.charCodeAt(index);
+                if (commentChar === 0x0a || commentChar === 0x0d || commentChar === 0x2028 || commentChar === 0x2029) {
+                    return false;
+                }
+                if (commentChar === 0x2a && source.charCodeAt(index + 1) === 0x2f) {
+                    index += 2;
+                    break;
+                }
+                index++;
+            }
+            continue;
+        }
+        break;
+    }
+    if (source.slice(index, index + 5) !== 'using')
+        return false;
+    const following = source.codePointAt(index + 5);
+    return following === undefined || (following !== 0x5c && !isIdentifierPart(following));
+}
+function isResourceBindingStart(token) {
+    return (token & 143360) === 143360 && (token & 20480) !== 20480;
+}
+function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+    const { tokenStart, tokenValue } = parser;
+    const token = parser.getToken();
+    const expression = parseIdentifier(parser, context);
+    if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+        if (origin & 4 && context & 8 && (context & 2) === 0) {
+            parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+        }
+        return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'using', tokenStart, 1);
+    }
+    parser.assignable = 1;
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 1, expression, token, tokenValue, tokenStart);
+}
+function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
     const start = parser.tokenStart;
-    nextToken(parser, context);
-    const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin);
+    if (context & 524288)
+        parser.report(179);
+    nextToken(parser, context | 32);
+    let argument;
+    if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+        const usingStart = parser.tokenStart;
+        const usingIdentifier = parseIdentifier(parser, context);
+        if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+            return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'await using', start, 1);
+        }
+        argument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+    }
+    else {
+        argument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+    }
+    if (parser.getToken() === 8391735)
+        parser.report(33);
+    parser.assignable = 2;
+    const expression = parser.finishNode({
+        type: 'AwaitExpression',
+        argument,
+    }, start);
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 0, expression, 1048576, '', start);
+}
+function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
+    const start = declarationStart;
+    if (!keywordConsumed)
+        nextToken(parser, context);
+    const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind);
     matchOrInsertSemicolon(parser, context | 32);
     return parser.finishNode({
         type: 'VariableDeclaration',
-        kind: kind & 8 ? 'let' : 'const',
+        kind: declarationKind ?? (kind & 8 ? 'let' : 'const'),
         declarations,
     }, start);
 }
@@ -5534,24 +5645,34 @@ function parseVariableStatement(parser, context, scope, privateScope, origin) {
         declarations,
     }, start);
 }
-function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin) {
+function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind) {
     let bindingCount = 1;
-    const list = [
-        parseVariableDeclaration(parser, context, scope, privateScope, kind, origin),
-    ];
+    const firstDeclaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+    const list = [firstDeclaration];
+    const resourceNames = declarationKind && parser.options.lexical ? new Set([firstDeclaration.id.name]) : undefined;
     while (consumeOpt(parser, context, 18)) {
         bindingCount++;
-        list.push(parseVariableDeclaration(parser, context, scope, privateScope, kind, origin));
+        const declaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
+        if (resourceNames) {
+            const { name } = declaration.id;
+            if (resourceNames.has(name))
+                parser.report(147, name);
+            resourceNames.add(name);
+        }
+        list.push(declaration);
     }
     if (bindingCount > 1 && origin & 32 && parser.getToken() & 262144) {
         parser.report(61, KeywordDescTable[parser.getToken() & 255]);
     }
     return list;
 }
-function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin) {
+function parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind) {
     const { tokenStart } = parser;
     const token = parser.getToken();
     let init = null;
+    if (declarationKind && (token & 2097152) === 2097152) {
+        parser.report(50);
+    }
     const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 32);
@@ -5566,7 +5687,7 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
     }
     else if ((kind & 16 || (token & 2097152) > 0) &&
         (parser.getToken() & 262144) !== 262144) {
-        parser.report(59, kind & 16 ? 'const' : 'destructuring');
+        parser.report(59, declarationKind ?? (kind & 16 ? 'const' : 'destructuring'));
     }
     return parser.finishNode({
         type: 'VariableDeclarator',
@@ -5587,7 +5708,10 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     let init = null;
     let isVarDecl = parser.getToken() === 86088 ||
         parser.getToken() === 241737 ||
-        parser.getToken() === 86090;
+        parser.getToken() === 86090 ||
+        parser.getToken() === 209013;
+    let resourceDeclarationKind;
+    let consumedForOfDelimiter = false;
     let right;
     const { tokenStart } = parser;
     const token = parser.getToken();
@@ -5611,7 +5735,82 @@ 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) {
+            const usingIdentifier = parseIdentifier(parser, context);
+            if ((parser.flags & 1) !== 0 || !isResourceBindingStart(parser.getToken())) {
+                isVarDecl = false;
+                parser.assignable = 1;
+                init = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, tokenStart);
+            }
+            else if (parser.getToken() === 471156) {
+                const ofStart = parser.tokenStart;
+                const ofToken = parser.getToken();
+                const ofValue = parser.tokenValue;
+                const ofIdentifier = parseIdentifier(parser, context);
+                if (parser.getToken() !== 1077936155 &&
+                    parser.getToken() !== 8673330 &&
+                    parser.getToken() !== 1074790417 &&
+                    parser.getToken() !== 18) {
+                    isVarDecl = false;
+                    consumedForOfDelimiter = true;
+                    parser.assignable = 1;
+                    init = usingIdentifier;
+                }
+                else {
+                    resourceDeclarationKind = 'using';
+                    validateBindingIdentifier(parser, context, 16, ofToken, 0);
+                    scope?.addBlockName(context, ofValue, 16, 32);
+                    let declarationInitializer = null;
+                    if (parser.getToken() === 1077936155) {
+                        nextToken(parser, context | 32);
+                        declarationInitializer = parseExpression(parser, context | 131072, privateScope, 1, 0, parser.tokenStart);
+                        if ((parser.getToken() & 262144) === 262144) {
+                            throw new ParseError(ofStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
+                        }
+                    }
+                    else if (parser.getToken() !== 8673330) {
+                        parser.report(59, resourceDeclarationKind);
+                    }
+                    const declarations = [
+                        parser.finishNode({
+                            type: 'VariableDeclarator',
+                            id: ofIdentifier,
+                            init: declarationInitializer,
+                        }, ofStart),
+                    ];
+                    const resourceNames = parser.options.lexical ? new Set([ofValue]) : undefined;
+                    while (consumeOpt(parser, context | 131072, 18)) {
+                        const declaration = parseVariableDeclaration(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind);
+                        if (resourceNames) {
+                            const { name } = declaration.id;
+                            if (resourceNames.has(name))
+                                parser.report(147, name);
+                            resourceNames.add(name);
+                        }
+                        declarations.push(declaration);
+                    }
+                    if (declarations.length > 1 && parser.getToken() & 262144) {
+                        parser.report(61, KeywordDescTable[parser.getToken() & 255]);
+                    }
+                    init = parser.finishNode({
+                        type: 'VariableDeclaration',
+                        kind: resourceDeclarationKind,
+                        declarations,
+                    }, tokenStart);
+                    parser.assignable = 1;
+                }
+            }
+            else {
+                resourceDeclarationKind = 'using';
+                init = parser.finishNode({
+                    type: 'VariableDeclaration',
+                    kind: resourceDeclarationKind,
+                    declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                }, tokenStart);
+                parser.assignable = 1;
             }
         }
         else {
@@ -5630,6 +5829,42 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
             parser.assignable = 1;
         }
     }
+    else if (token === 209006 &&
+        (context & 2048 || (context & 2 && context & 8))) {
+        if (context & 524288)
+            parser.report(179);
+        nextToken(parser, context | 32);
+        let awaitArgument;
+        if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
+            const usingStart = parser.tokenStart;
+            const usingIdentifier = parseIdentifier(parser, context);
+            if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
+                resourceDeclarationKind = 'await using';
+                isVarDecl = true;
+                init = parser.finishNode({
+                    type: 'VariableDeclaration',
+                    kind: resourceDeclarationKind,
+                    declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 16, 32, resourceDeclarationKind),
+                }, tokenStart);
+                parser.assignable = 1;
+            }
+            else {
+                awaitArgument = parseMemberOrUpdateExpression(parser, context, privateScope, usingIdentifier, 0, 0, usingStart);
+            }
+        }
+        else {
+            awaitArgument = parseLeftHandSideExpression(parser, context, privateScope, 0, 0, 1);
+        }
+        if (!isVarDecl) {
+            if (parser.getToken() === 8391735)
+                parser.report(33);
+            parser.assignable = 2;
+            init = parser.finishNode({
+                type: 'AwaitExpression',
+                argument: awaitArgument,
+            }, tokenStart);
+        }
+    }
     else if (token === 1074790417) {
         if (forAwait)
             parser.report(82);
@@ -5651,12 +5886,13 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     else {
         init = parseLeftHandSideExpression(parser, context | 131072, privateScope, 1, 0, 1);
     }
-    if ((parser.getToken() & 262144) === 262144) {
-        if (parser.getToken() === 471156) {
+    if (consumedForOfDelimiter || (parser.getToken() & 262144) === 262144) {
+        if (consumedForOfDelimiter || parser.getToken() === 471156) {
             if (parser.assignable & 2)
                 parser.report(80, forAwait ? 'await' : 'of');
             reinterpretToPattern(parser, init);
-            nextToken(parser, context | 32);
+            if (!consumedForOfDelimiter)
+                nextToken(parser, context | 32);
             right = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
             consume(parser, context | 32, 16);
             const body = parseIterationStatementBody(parser, context, scope, privateScope, labels);
@@ -5668,6 +5904,8 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                 await: forAwait,
             }, start);
         }
+        if (resourceDeclarationKind)
+            parser.report(30, 'in');
         if (parser.assignable & 2)
             parser.report(80, 'in');
         reinterpretToPattern(parser, init);
@@ -5712,9 +5950,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);
 }
@@ -5722,6 +5960,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) {
@@ -5729,14 +5969,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));
@@ -5765,7 +6084,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 = {
@@ -5773,6 +6093,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);
@@ -5855,17 +6176,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 132:
+            case 133:
+                if (!(parser.features & 1)) {
+                    parser.report(30, '@');
+                }
             case 86094:
                 declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                 break;
@@ -5978,7 +6306,7 @@ function parseExportDeclaration(parser, context, scope) {
             }
             else {
                 if (hasLiteralLocal) {
-                    parser.report(172);
+                    parser.report(174);
                 }
                 if (scope) {
                     tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -5988,7 +6316,10 @@ function parseExportDeclaration(parser, context, scope) {
             matchOrInsertSemicolon(parser, context | 32);
             break;
         }
-        case 132:
+        case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
             break;
@@ -6121,7 +6452,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;
@@ -6148,10 +6479,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;
@@ -6204,7 +6535,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) {
@@ -6231,17 +6562,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) {
@@ -6265,6 +6596,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) {
@@ -6290,19 +6622,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);
             }
         }
     }
@@ -6326,8 +6658,8 @@ function parseSuperExpression(parser, context) {
     const { tokenStart } = parser;
     nextToken(parser, context);
     switch (parser.getToken()) {
-        case 67108990:
-            parser.report(167);
+        case 67108991:
+            parser.report(169);
         case 67174411: {
             if ((context & 512) === 0)
                 parser.report(28);
@@ -6373,10 +6705,13 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
         switch (parser.getToken()) {
             case 67108877: {
                 nextToken(parser, (context | 262144 | 8) ^ 8);
-                if (context & 16 && parser.getToken() === 130 && parser.tokenValue === 'super') {
-                    parser.report(173);
+                if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
+                    parser.report(175);
                 }
-                parser.assignable = 1;
+                parser.assignable =
+                    (parser.flags & 2048) === 2048
+                        ? 2
+                        : 1;
                 const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
                 expr = parser.finishNode({
                     type: 'MemberExpression',
@@ -6401,7 +6736,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 const { tokenStart } = parser;
                 const property = parseExpressions(parser, context, privateScope, inGroup, 1, tokenStart);
                 consume(parser, context, 20);
-                parser.assignable = 1;
+                parser.assignable = restoreHasOptionalChaining ? 2 : 1;
                 expr = parser.finishNode({
                     type: 'MemberExpression',
                     object: expr,
@@ -6442,7 +6777,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 }
                 break;
             }
-            case 67108990: {
+            case 67108991: {
                 nextToken(parser, (context | 262144 | 8) ^ 8);
                 parser.flags |= 2048;
                 parser.assignable = 2;
@@ -6451,7 +6786,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({
@@ -6529,12 +6864,12 @@ function parseOptionalChain(parser, context, privateScope, expr, start) {
 }
 function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
     if ((parser.getToken() & 143360) === 0 &&
-        parser.getToken() !== -2147483528 &&
         parser.getToken() !== -2147483527 &&
-        parser.getToken() !== 130) {
-        parser.report(160);
+        parser.getToken() !== -2147483526 &&
+        parser.getToken() !== 131) {
+        parser.report(162);
     }
-    return parser.getToken() === 130
+    return parser.getToken() === 131
         ? parsePrivateIdentifier(parser, context, privateScope, 0)
         : parseIdentifier(parser, context);
 }
@@ -6583,10 +6918,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);
         }
@@ -6627,7 +6962,10 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             return parseThisExpression(parser, context);
         case 65540:
             return parseRegExpLiteral(parser, context);
-        case 132:
+        case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             return parseClassExpression(parser, context, privateScope, inGroup, start);
         case 86109:
@@ -6638,9 +6976,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             return parseTemplate(parser, context, privateScope);
         case 86107:
             return parseNewExpression(parser, context, privateScope, inGroup);
-        case 134283388:
+        case 134283389:
             return parseBigIntLiteral(parser, context);
-        case 130:
+        case 131:
             return parsePrivateIdentifier(parser, context, privateScope, 0);
         case 86106:
             return parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start);
@@ -6656,24 +6994,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();
-    if (token !== 209030 && parser.tokenValue !== 'meta') {
-        parser.report(174);
+    const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && parser.tokenValue === 'defer';
+    const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && parser.tokenValue === 'source';
+    if (isPhaseDefer || isPhaseSource) {
+        if (inNew)
+            parser.report(144);
+        nextToken(parser, context);
+        const expression = parseImportExpression(parser, context, privateScope, inGroup, start, parser.tokenValue);
+        parser.assignable = 2;
+        return expression;
+    }
+    if ((context & 2) === 0) {
+        throw new ParseError(propertyStart, propertyEnd, 171);
+    }
+    if (token !== 209031 && parser.tokenValue !== 'meta') {
+        parser.report(176);
     }
     else if (token & -2147483648) {
-        parser.report(175);
+        parser.report(177);
     }
     parser.assignable = 2;
     return parser.finishNode({
@@ -6682,10 +7033,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) {
@@ -6700,6 +7051,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);
@@ -6717,7 +7069,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({
@@ -6755,7 +7107,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);
     }
@@ -6893,7 +7245,7 @@ function parseIdentifier(parser, context) {
 }
 function parseLiteral(parser, context) {
     const { tokenValue, tokenRaw, tokenStart } = parser;
-    if (parser.getToken() === 134283388) {
+    if (parser.getToken() === 134283389) {
         return parseBigIntLiteral(parser, context);
     }
     const node = {
@@ -7316,7 +7668,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,
@@ -7410,9 +7762,9 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
             let key = null;
             let value;
             if (parser.getToken() & 143360 ||
-                parser.getToken() === -2147483528 ||
-                parser.getToken() === -2147483527) {
-                if (parser.getToken() === -2147483527)
+                parser.getToken() === -2147483527 ||
+                parser.getToken() === -2147483526) {
+                if (parser.getToken() === -2147483526)
                     destructible |= 16;
                 key = parseIdentifier(parser, context);
                 if (parser.getToken() === 18 ||
@@ -7444,7 +7796,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     else {
                         destructible |=
                             (token === 209006 ? 128 : 0) |
-                                (token === -2147483528 ? 16 : 0);
+                                (token === -2147483527 ? 16 : 0);
                         value = parser.cloneIdentifier(key);
                     }
                 }
@@ -7571,11 +7923,11 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 }
                 else if (parser.getToken() & 143360) {
                     destructible |= 16;
-                    if (token === -2147483528)
+                    if (token === -2147483527)
                         parser.report(95);
                     if (token === 209005) {
                         if (parser.flags & 1)
-                            parser.report(132);
+                            parser.report(134);
                         state |= 16 | 1;
                     }
                     else if (token === 209008) {
@@ -7639,7 +7991,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) {
@@ -7743,7 +8095,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     destructible = 16;
                 }
                 else {
-                    parser.report(134);
+                    parser.report(136);
                 }
             }
             else if (parser.getToken() === 69271571) {
@@ -7890,7 +8242,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 {
@@ -8068,7 +8420,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) {
@@ -8141,7 +8493,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
@@ -8166,7 +8518,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
@@ -8237,17 +8589,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;
@@ -8255,7 +8607,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({
@@ -8382,7 +8734,7 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     const id = parseIdentifier(parser, context | 32);
     const { tokenStart } = parser;
     if (consumeOpt(parser, context, 67108877)) {
-        if (context & 65536 && parser.getToken() === 209029) {
+        if (context & 65536 && parser.getToken() === 209030) {
             parser.assignable = 2;
             return parseMetaProperty(parser, context, id, start);
         }
@@ -8394,8 +8746,8 @@ 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() === 67108990)
-        parser.report(168);
+    if (parser.getToken() === 67108991)
+        parser.report(170);
     const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
     parser.assignable = 2;
     return parser.finishNode({
@@ -8494,7 +8846,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) {
@@ -8595,9 +8947,6 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     let start;
     let decorators;
     if (parser.leadingDecorators.decorators.length) {
-        if (parser.getToken() === 132) {
-            parser.report(30, '@');
-        }
         start = parser.leadingDecorators.start;
         decorators = [...parser.leadingDecorators.decorators];
         parser.leadingDecorators.decorators.length = 0;
@@ -8607,16 +8956,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);
@@ -8646,7 +8995,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) {
@@ -8654,12 +9003,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);
     }
@@ -8678,24 +9027,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) {
-        while (parser.getToken() === 132) {
-            list.push(parseDecoratorList(parser, context, privateScope));
+    if (parser.features & 1) {
+        while (parser.getToken() === 133) {
+            list.push(parseDecorator(parser, context, privateScope));
         }
     }
     return list;
 }
-function parseDecoratorList(parser, context, privateScope) {
+function parseDecorator(parser, context, privateScope) {
     const start = parser.tokenStart;
     nextToken(parser, context | 32);
     const expressionStart = parser.tokenStart;
-    let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
-    expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, expressionStart);
+    let expression;
+    if (parser.getToken() === 67174411) {
+        expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
+    }
+    else {
+        const token = parser.getToken();
+        if (((token & 143360) !== 143360 && !isValidIdentifier(context, token)) ||
+            (context & 1 && (token & 36864) === 36864)) {
+            parser.report(30, KeywordDescTable[token & 255]);
+        }
+        if (token === 209006 && context & (2048 | 2)) {
+            parser.report(112);
+        }
+        if (token === 241771 && context & 1024) {
+            parser.report(97, 'yield');
+        }
+        let memberExpression = parseIdentifier(parser, context | 64);
+        while (parser.getToken() === 67108877) {
+            nextToken(parser, (context | 262144 | 8) ^ 8);
+            const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
+            memberExpression = parser.finishNode({
+                type: 'MemberExpression',
+                object: memberExpression,
+                computed: false,
+                property,
+                optional: false,
+            }, expressionStart);
+        }
+        expression = memberExpression;
+        if (parser.getToken() === 67174411) {
+            const args = parseArguments(parser, context, privateScope, 0);
+            expression = parser.finishNode({
+                type: 'CallExpression',
+                callee: memberExpression,
+                arguments: args,
+                optional: false,
+            }, expressionStart);
+        }
+    }
     return parser.finishNode({
         type: 'Decorator',
         expression,
@@ -8714,13 +9100,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));
@@ -8737,7 +9123,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     let kind = isStatic ? 32 : 0;
     let key = null;
     const token = parser.getToken();
-    if (token & (143360 | 36864) || token === -2147483528) {
+    if (token & (143360 | 36864) || token === -2147483527) {
         key = parseIdentifier(parser, context);
         switch (token) {
             case 36970:
@@ -8783,7 +9169,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;
@@ -8800,7 +9186,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         kind |= 8;
         nextToken(parser, context);
     }
-    else if (parser.getToken() === 130) {
+    else if (parser.getToken() === 131) {
         kind |= 8192;
         key = parsePrivateIdentifier(parser, context | 16, privateScope, 768);
     }
@@ -8810,7 +9196,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     else if (isStatic && token === 2162700) {
         return parseStaticBlock(parser, context | 16, scope, privateScope, start);
     }
-    else if (token === -2147483527) {
+    else if (token === -2147483526) {
         key = parseIdentifier(parser, context);
         if (parser.getToken() !== 67174411)
             parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8820,8 +9206,8 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     }
     if (kind & (8 | 16 | 768 | 1024)) {
         if (parser.getToken() & 143360 ||
-            parser.getToken() === -2147483528 ||
-            parser.getToken() === -2147483527) {
+            parser.getToken() === -2147483527 ||
+            parser.getToken() === -2147483526) {
             key = parseIdentifier(parser, context);
         }
         else if ((parser.getToken() & 134217728) === 134217728) {
@@ -8831,17 +9217,17 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             kind |= 2;
             key = parseComputedPropertyName(parser, context, privateScope, 0);
         }
-        else if (parser.getToken() === 130) {
+        else if (parser.getToken() === 131) {
             kind |= 8192;
             key = parsePrivateIdentifier(parser, context, privateScope, kind);
         }
         else
-            parser.report(135);
+            parser.report(137);
     }
     if ((kind & 2) === 0) {
         if (parser.tokenValue === 'constructor') {
             if ((parser.getToken() & 1073741824) === 1073741824) {
-                parser.report(129);
+                parser.report(131);
             }
             else if ((kind & 32) === 0 && parser.getToken() === 67174411) {
                 if (kind & (768 | 16 | 128 | 8)) {
@@ -8879,7 +9265,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) {
@@ -8887,7 +9273,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);
@@ -8911,8 +9297,8 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 32);
         const { tokenStart } = parser;
-        if (parser.getToken() === 537079927)
-            parser.report(119);
+        if (parser.getToken() === 537079928)
+            parser.report(121);
         const modifierFlags = 1024 |
             2048 |
             8192 |
@@ -8938,12 +9324,12 @@ 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) {
     if (parser.getToken() & 143360 ||
-        ((context & 1) === 0 && parser.getToken() === -2147483527))
+        ((context & 1) === 0 && parser.getToken() === -2147483526))
         return parseAndClassifyIdentifier(parser, context, scope, type, origin);
     if ((parser.getToken() & 2097152) !== 2097152)
         parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -8960,10 +9346,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 === -2147483527) {
-            parser.report(118);
+        else if ((token & 36864) === 36864 || token === -2147483526) {
+            parser.report(120);
         }
     }
     if ((token & 20480) === 20480) {
@@ -8973,7 +9359,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))
@@ -8981,9 +9367,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);
@@ -9015,7 +9401,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',
@@ -9083,7 +9469,7 @@ function parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSX
     }
 }
 function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
-    if (parser.getToken() === 137)
+    if (parser.getToken() === 138)
         return parseJSXText(parser, context);
     if (parser.getToken() === 2162700)
         return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9097,7 +9483,7 @@ function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild
     parser.report(0);
 }
 function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
-    if (parser.getToken() === 137)
+    if (parser.getToken() === 138)
         return parseJSXText(parser, context);
     if (parser.getToken() === 2162700)
         return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
@@ -9210,7 +9596,7 @@ function parseJsxAttribute(parser, context, privateScope) {
                 value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                 break;
             default:
-                parser.report(154);
+                parser.report(156);
         }
     }
     return parser.finishNode({
@@ -9237,7 +9623,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,