meriyah 7.2.0 → 7.3.1

package/dist/meriyah.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var version$1 = "7.2.0";
+var version$1 = "7.3.1";
 var packageJson = {
 	version: version$1};
 
@@ -93,7 +93,7 @@ const CharTypes = [
     0,
     16384,
     0,
-    0,
+    16384,
     0,
     0,
     1 | 2 | 64,
@@ -156,7 +156,7 @@ const CharTypes = [
     1 | 2 | 4,
     16384,
     0,
-    0,
+    16384,
     0,
     0
 ];
@@ -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,77 @@ 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',
+    [180]: "Unexpected token `}`. Did you mean `}` or `{'}'}`?",
+    [181]: "Unexpected token `>`. Did you mean `>` or `{'>'}`?",
 };
 class ParseError extends SyntaxError {
     start;
@@ -811,10 +815,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',
@@ -836,75 +836,82 @@ const KeywordDescTable = [
     'BigIntLiteral', '??', '?.', 'WhiteSpace', 'Illegal', 'LineTerminator', 'PrivateField',
     'Template', '@', 'target', 'meta', 'LineFeed', 'Escaped', 'JSXText'
 ];
-const descKeywordTable = {
-    this: 86111,
-    function: 86104,
-    if: 20569,
-    return: 20572,
-    var: 86088,
-    else: 20563,
-    for: 20567,
-    new: 86107,
-    in: 8673330,
-    typeof: 16863275,
-    while: 20578,
-    case: 20556,
-    break: 20555,
-    try: 20577,
-    catch: 20557,
-    delete: 16863276,
-    throw: 86112,
-    switch: 86110,
-    continue: 20559,
-    default: 20561,
-    instanceof: 8411187,
-    do: 20562,
-    void: 16863277,
-    finally: 20566,
-    async: 209005,
-    await: 209006,
-    class: 86094,
-    const: 86090,
-    constructor: 12399,
-    debugger: 20560,
-    export: 20564,
-    extends: 20565,
-    false: 86021,
-    from: 209011,
-    get: 209008,
-    implements: 36964,
-    import: 86106,
-    interface: 36965,
-    let: 241737,
-    null: 86023,
-    of: 471156,
-    using: 209013,
-    package: 36966,
-    private: 36967,
-    protected: 36968,
-    public: 36969,
-    set: 209009,
-    static: 36970,
-    super: 86109,
-    true: 86022,
-    with: 20579,
-    yield: 241771,
-    enum: 86134,
-    eval: 537079927,
-    as: 77932,
-    arguments: 537079928,
-    target: 209030,
-    meta: 209031,
-    accessor: 12402,
-};
+const descKeywordTable = new Map([
+    ['this', 86111],
+    ['function', 86104],
+    ['if', 20569],
+    ['return', 20572],
+    ['var', 86088],
+    ['else', 20563],
+    ['for', 20567],
+    ['new', 86107],
+    ['in', 8673330],
+    ['typeof', 16863275],
+    ['while', 20578],
+    ['case', 20556],
+    ['break', 20555],
+    ['try', 20577],
+    ['catch', 20557],
+    ['delete', 16863276],
+    ['throw', 86112],
+    ['switch', 86110],
+    ['continue', 20559],
+    ['default', 20561],
+    ['instanceof', 8411187],
+    ['do', 20562],
+    ['void', 16863277],
+    ['finally', 20566],
+    ['async', 209005],
+    ['await', 209006],
+    ['class', 86094],
+    ['const', 86090],
+    ['constructor', 12399],
+    ['debugger', 20560],
+    ['export', 20564],
+    ['extends', 20565],
+    ['false', 86021],
+    ['from', 209011],
+    ['get', 209008],
+    ['implements', 36964],
+    ['import', 86106],
+    ['interface', 36965],
+    ['let', 241737],
+    ['null', 86023],
+    ['of', 471156],
+    ['using', 209013],
+    ['package', 36966],
+    ['private', 36967],
+    ['protected', 36968],
+    ['public', 36969],
+    ['set', 209009],
+    ['static', 36970],
+    ['super', 86109],
+    ['true', 86022],
+    ['with', 20579],
+    ['yield', 241771],
+    ['enum', 86134],
+    ['eval', 537079927],
+    ['as', 77932],
+    ['arguments', 537079928],
+    ['target', 209030],
+    ['meta', 209031],
+    ['accessor', 12402],
+]);
+const keywordLengths = [...descKeywordTable.keys()].map((keyword) => keyword.length);
+const minKeywordLength = Math.min(...keywordLengths);
+const maxKeywordLength = Math.max(...keywordLengths);
 
 function scanIdentifier(parser, context, isValidAsKeyword) {
     while (isIdPart[advanceChar(parser)])
         ;
     parser.tokenValue = parser.source.slice(parser.tokenIndex, parser.index);
-    return parser.currentChar !== 92 && parser.currentChar <= 0x7e
-        ? (getOwnProperty(descKeywordTable, parser.tokenValue) ?? 208897)
-        : scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+    if (parser.currentChar === 92 || parser.currentChar > 0x7e) {
+        return scanIdentifierSlowCase(parser, context, 0, isValidAsKeyword);
+    }
+    const length = parser.index - parser.tokenIndex;
+    if (length < minKeywordLength || length > maxKeywordLength)
+        return 208897;
+    return descKeywordTable.get(parser.tokenValue) ?? 208897;
 }
 function scanUnicodeIdentifier(parser, context) {
     const cookedChar = scanIdentifierUnicodeEscape(parser);
@@ -946,8 +953,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)
@@ -1071,7 +1078,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;
@@ -1082,7 +1089,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) {
@@ -1091,7 +1098,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);
@@ -1103,7 +1110,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) {
@@ -1112,7 +1119,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);
@@ -1124,7 +1131,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) {
@@ -1157,7 +1164,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;
@@ -1168,7 +1175,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;
@@ -1233,7 +1240,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);
@@ -1244,7 +1251,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);
 }
@@ -1965,7 +1972,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;
@@ -2194,10 +2201,10 @@ function reinterpretToPattern(parser, node) {
 function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
     if (context & 1) {
         if ((t & 36864) === 36864) {
-            parser.report(118);
+            parser.report(120);
         }
         if (!skipEvalArgCheck && (t & 537079808) === 537079808) {
-            parser.report(119);
+            parser.report(121);
         }
     }
     if ((t & 20480) === 20480 || t === -2147483527) {
@@ -2207,7 +2214,7 @@ function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
         parser.report(100);
     }
     if (context & (2048 | 2) && t === 209006) {
-        parser.report(110);
+        parser.report(112);
     }
     if (context & (1024 | 1) && t === 241771) {
         parser.report(97, 'yield');
@@ -2216,10 +2223,10 @@ function validateBindingIdentifier(parser, context, kind, t, skipEvalArgCheck) {
 function validateFunctionName(parser, context, t) {
     if (context & 1) {
         if ((t & 36864) === 36864) {
-            parser.report(118);
+            parser.report(120);
         }
         if ((t & 537079808) === 537079808) {
-            parser.report(119);
+            parser.report(121);
         }
         if (t === -2147483526) {
             parser.report(95);
@@ -2232,7 +2239,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');
@@ -2241,7 +2248,10 @@ function validateFunctionName(parser, context, t) {
 function isStrictReservedWord(parser, context, t) {
     if (t === 209006) {
         if (context & (2048 | 2))
-            parser.report(110);
+            parser.report(112);
+        if ((parser.destructible & 128) === 0) {
+            parser.firstAwaitLocation ??= { start: parser.tokenStart, end: parser.currentLocation };
+        }
         parser.destructible |= 128;
     }
     if (t === 241771 && context & 1024)
@@ -2257,7 +2267,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)
@@ -2270,7 +2280,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;
@@ -2298,14 +2308,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',
@@ -4431,8 +4441,8 @@ const entities = {
     zscr: '\uD835\uDCCF',
     zwj: '\u200D',
     zwnj: '\u200C',
-};
-const decodeMap = {
+}));
+const decodeMap = new Map(Object.entries({
     '0': 65533,
     '128': 8364,
     '130': 8218,
@@ -4461,7 +4471,7 @@ const decodeMap = {
     '156': 339,
     '158': 382,
     '159': 376,
-};
+}).map(([key, value]) => [Number(key), value]));
 function decodeHTMLStrict(text) {
     return text.replaceAll(/&(?:[a-zA-Z]+|#[xX][\da-fA-F]+|#\d+);/g, (key) => {
         if (key.charAt(1) === '#') {
@@ -4469,14 +4479,14 @@ function decodeHTMLStrict(text) {
             const codePoint = secondChar === 'X' || secondChar === 'x' ? parseInt(key.slice(3), 16) : parseInt(key.slice(2), 10);
             return decodeCodePoint(codePoint);
         }
-        return getOwnProperty(entities, key.slice(1, -1)) ?? key;
+        return entities.get(key.slice(1, -1)) ?? key;
     });
 }
 function decodeCodePoint(codePoint) {
     if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
         return '\uFFFD';
     }
-    return String.fromCodePoint(getOwnProperty(decodeMap, codePoint) ?? codePoint);
+    return String.fromCodePoint(decodeMap.get(codePoint) ?? codePoint);
 }
 
 function scanJSXAttributeValue(parser, context) {
@@ -4523,6 +4533,12 @@ function nextJSXToken(parser) {
         parser.setToken(2162700);
         return;
     }
+    if (parser.currentChar === 125) {
+        parser.report(180);
+    }
+    if (parser.currentChar === 62) {
+        parser.report(181);
+    }
     let state = 0;
     while (parser.index < parser.end) {
         const type = CharTypes[parser.source.charCodeAt(parser.index)];
@@ -4561,6 +4577,8 @@ function rescanJSXIdentifier(parser) {
     return parser.getToken();
 }
 
+const nextFeatures = 1 | 2 | 4;
+
 function normalizeRanges(ranges) {
     if (!ranges)
         return undefined;
@@ -4573,17 +4591,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;
 }
 
@@ -4604,7 +4632,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);
     }
@@ -4665,17 +4693,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;
@@ -4684,12 +4712,12 @@ class Scope {
     hasVariable(name) {
         return this.variableBindings.has(name);
     }
-    addBlockName(context, name, kind, origin) {
+    addBlockName(context, name, kind, origin = 0) {
         const { parser } = this;
         const value = this.variableBindings.get(name);
         if (value && (value & 2) === 0) {
             if (kind & 1) {
-                this.recordScopeError(145, name);
+                this.recordScopeError(147, name);
             }
             else if (parser.options.webcompat &&
                 (context & 1) === 0 &&
@@ -4697,22 +4725,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);
     }
@@ -4734,7 +4762,7 @@ class Scope {
 }
 function createArrowHeadParsingScope(parser, context, value) {
     const scope = parser.createScope().createChildScope(512);
-    scope.addBlockName(context, value, 1, 0);
+    scope.addBlockName(context, value, 1);
     return scope;
 }
 
@@ -4744,6 +4772,7 @@ class Parser {
     options;
     token = 1048576;
     flags = 0;
+    features = 0;
     index = 0;
     line = 1;
     column = 0;
@@ -4763,12 +4792,14 @@ class Parser {
     assignable = 0;
     destructible = 0;
     strictReservedRange = null;
+    firstAwaitLocation = null;
     leadingDecorators = { decorators: [] };
     constructor(source, rawOptions = {}) {
         this.source = source;
         this.end = source.length;
         this.currentChar = source.charCodeAt(0);
         this.options = normalizeOptions(rawOptions);
+        this.features = this.options.features;
         if (Array.isArray(this.options.onComment)) {
             this.options.onComment = pushComment(this.options.onComment, this.options);
         }
@@ -4849,7 +4880,7 @@ class Parser {
     declareUnboundVariable(name) {
         const { exportedNames } = this;
         if (exportedNames.has(name)) {
-            this.report(147, name);
+            this.report(149, name);
         }
         exportedNames.add(name);
     }
@@ -4872,29 +4903,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) {
@@ -4957,7 +4969,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);
             }
         }
     }
@@ -4989,7 +5001,7 @@ function parseStatementList(parser, context, scope) {
         statements.push(parseDirective(parser, context, expr, token, tokenStart));
     }
     while (parser.getToken() !== 1048576) {
-        statements.push(parseStatementListItem(parser, context, scope, undefined, 4, {}));
+        statements.push(parseStatementListItem(parser, context, scope, undefined, {}, 4));
     }
     return statements;
 }
@@ -5019,36 +5031,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);
+            moduleItem = parseStatementListItem(parser, context, scope, undefined, {}, 4);
     }
     return moduleItem;
 }
-function parseStatementListItem(parser, context, scope, privateScope, origin, labels) {
+function parseStatementListItem(parser, context, scope, privateScope, labels, origin = 2) {
     const start = parser.tokenStart;
+    if (parser.leadingDecorators.decorators.length && parser.getToken() !== 86094) {
+        parser.report(172);
+    }
     switch (parser.getToken()) {
         case 86104:
-            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 0, start);
+            return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 0, start, origin);
         case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             return parseClassDeclaration(parser, context, scope, privateScope, 0);
         case 86090:
-            return parseLexicalDeclaration(parser, context, scope, privateScope, 16, 0);
+            return parseLexicalDeclaration(parser, context, scope, privateScope, 16);
         case 241737:
             return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
         case 209013:
-            return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+            return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin);
         case 209006:
             if ((context & 2048 || (context & 2 && context & 8)) &&
                 nextTokenIsUsingOnSameLine(parser)) {
-                return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels);
+                return parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin);
             }
-            return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
+            return parseStatement(parser, context, scope, privateScope, labels, 1, origin);
         case 20564:
             parser.report(103, 'export');
         case 86106:
@@ -5062,15 +5080,15 @@ function parseStatementListItem(parser, context, scope, privateScope, origin, la
                     parser.report(103, 'import');
             }
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 1);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 1, origin);
         default:
-            return parseStatement(parser, context, scope, privateScope, origin, labels, 1);
+            return parseStatement(parser, context, scope, privateScope, labels, 1, origin);
     }
 }
-function parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+function parseStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin = 0) {
     switch (parser.getToken()) {
         case 86088:
-            return parseVariableStatement(parser, context, scope, privateScope, 0);
+            return parseVariableStatement(parser, context, scope, privateScope);
         case 20572:
             return parseReturnStatement(parser, context, privateScope);
         case 20569:
@@ -5100,11 +5118,11 @@ function parseStatement(parser, context, scope, privateScope, origin, labels, al
         case 20560:
             return parseDebuggerStatement(parser, context);
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, 0);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 0, origin);
         case 20557:
-            parser.report(162);
+            parser.report(164);
         case 20566:
-            parser.report(163);
+            parser.report(165);
         case 86104:
             parser.report(context & 1
                 ? 76
@@ -5114,10 +5132,10 @@ function parseStatement(parser, context, scope, privateScope, origin, labels, al
         case 86094:
             parser.report(79);
         default:
-            return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
+            return parseExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin);
     }
 }
-function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+function parseExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin) {
     const { tokenValue, tokenStart } = parser;
     const token = parser.getToken();
     let expr;
@@ -5132,11 +5150,11 @@ 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);
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, expr, token, tokenValue, tokenStart, origin);
 }
-function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart) {
+function finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, initialExpression, token, tokenValue, tokenStart, origin) {
     if (token & 143360 && parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart);
+        return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, initialExpression, token, allowFuncDecl, tokenStart, origin);
     }
     let expression = parseMemberOrUpdateExpression(parser, context, privateScope, initialExpression, 0, 0, tokenStart);
     expression = parseAssignmentExpression(parser, context, privateScope, 0, 0, tokenStart, expression);
@@ -5149,7 +5167,7 @@ function parseBlock(parser, context, scope, privateScope, labels, start = parser
     const body = [];
     consume(parser, context | 32, 2162700);
     while (parser.getToken() !== 1074790415) {
-        body.push(parseStatementListItem(parser, context, scope, privateScope, 2, { $: labels }));
+        body.push(parseStatementListItem(parser, context, scope, privateScope, { $: labels }));
     }
     consume(parser, context | 32, 1074790415);
     return parser.finishNode({
@@ -5178,7 +5196,7 @@ function parseExpressionStatement(parser, context, expression, start) {
         expression,
     }, start);
 }
-function parseLabelledStatement(parser, context, scope, privateScope, origin, labels, value, expr, token, allowFuncDecl, start) {
+function parseLabelledStatement(parser, context, scope, privateScope, labels, value, expr, token, allowFuncDecl, start, origin) {
     validateBindingIdentifier(parser, context, 0, token, 1);
     validateAndDeclareLabel(parser, labels, value);
     nextToken(parser, context | 32);
@@ -5186,27 +5204,27 @@ function parseLabelledStatement(parser, context, scope, privateScope, origin, la
         (context & 1) === 0 &&
         parser.options.webcompat &&
         parser.getToken() === 86104
-        ? parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, origin, 0, 0, 0, parser.tokenStart)
-        : parseStatement(parser, context, scope, privateScope, origin, labels, allowFuncDecl);
+        ? parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, parser.tokenStart, origin)
+        : parseStatement(parser, context, scope, privateScope, labels, allowFuncDecl, origin);
     return parser.finishNode({
         type: 'LabeledStatement',
         label: expr,
         body,
     }, start);
 }
-function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, origin, labels, allowFuncDecl) {
+function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, allowFuncDecl, origin) {
     const { tokenValue, tokenStart: start } = parser;
     const token = parser.getToken();
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, labels, tokenValue, expr, token, 1, start);
+        return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, expr, token, 1, start, origin);
     }
     const asyncNewLine = parser.flags & 1;
     if (!asyncNewLine) {
         if (parser.getToken() === 86104) {
             if (!allowFuncDecl)
-                parser.report(123);
-            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
+                parser.report(125);
+            return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 1, start, origin);
         }
         if (isValidIdentifier(context, parser.getToken())) {
             expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start);
@@ -5216,7 +5234,7 @@ function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, priva
         }
     }
     if (parser.getToken() === 67174411) {
-        expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, 0, asyncNewLine, start);
+        expr = parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, 1, 1, asyncNewLine, start);
     }
     else {
         if (parser.getToken() === 10) {
@@ -5302,8 +5320,8 @@ function parseConsequentOrAlternative(parser, context, scope, privateScope, labe
     return context & 1 ||
         !parser.options.webcompat ||
         parser.getToken() !== 86104
-        ? parseStatement(parser, context, scope, privateScope, 0, { $: labels }, 0)
-        : parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, 0, tokenStart);
+        ? parseStatement(parser, context, scope, privateScope, { $: labels }, 0)
+        : parseFunctionDeclaration(parser, context, scope?.createChildScope(), privateScope, 0, 0, 0, tokenStart);
 }
 function parseSwitchStatement(parser, context, scope, privateScope, labels) {
     const start = parser.tokenStart;
@@ -5332,7 +5350,7 @@ function parseSwitchStatement(parser, context, scope, privateScope, labels) {
         while (parser.getToken() !== 20556 &&
             parser.getToken() !== 1074790415 &&
             parser.getToken() !== 20561) {
-            const statement = parseStatementListItem(parser, context | 4, scope, privateScope, 2, {
+            const statement = parseStatementListItem(parser, context | 4, scope, privateScope, {
                 $: labels,
             });
             if (statement.type === 'VariableDeclaration' &&
@@ -5368,7 +5386,7 @@ function parseWhileStatement(parser, context, scope, privateScope, labels) {
     }, start);
 }
 function parseIterationStatementBody(parser, context, scope, privateScope, labels) {
-    return parseStatement(parser, ((context | 131072) ^ 131072) | 128, scope, privateScope, 0, { loop: 1, $: labels }, 0);
+    return parseStatement(parser, ((context | 131072) ^ 131072) | 128, scope, privateScope, { loop: 1, $: labels }, 0);
 }
 function parseContinueStatement(parser, context, labels) {
     if ((context & 128) === 0)
@@ -5380,7 +5398,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({
@@ -5396,7 +5414,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);
@@ -5415,7 +5433,7 @@ function parseWithStatement(parser, context, scope, privateScope, labels) {
     consume(parser, context | 32, 67174411);
     const object = parseExpressions(parser, context, privateScope, 0, 1, parser.tokenStart);
     consume(parser, context | 32, 16);
-    const body = parseStatement(parser, context, scope, privateScope, 2, labels, 0);
+    const body = parseStatement(parser, context, scope, privateScope, labels, 0, 2);
     return parser.finishNode({
         type: 'WithStatement',
         object,
@@ -5462,7 +5480,7 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
         scope = scope?.createChildScope(4);
         param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
             ? 256
-            : 512, 0);
+            : 512);
         if (parser.getToken() === 18) {
             parser.report(86);
         }
@@ -5511,7 +5529,7 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() & (143360 | 2097152) &&
         (parser.getToken() & 20480) !== 20480) {
-        const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
+        const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8);
         matchOrInsertSemicolon(parser, context | 32);
         return parser.finishNode({
             type: 'VariableDeclaration',
@@ -5523,7 +5541,7 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     if (context & 1)
         parser.report(85);
     if (parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, origin, {}, tokenValue, expr, token, 0, tokenStart);
+        return parseLabelledStatement(parser, context, scope, privateScope, {}, tokenValue, expr, token, 0, tokenStart, origin);
     }
     if (parser.getToken() === 10) {
         let scope = void 0;
@@ -5577,23 +5595,26 @@ function nextTokenIsUsingOnSameLine(parser) {
 function isResourceBindingStart(token) {
     return (token & 143360) === 143360 && (token & 20480) !== 20480;
 }
-function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+function parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin) {
     const { tokenStart, tokenValue } = parser;
     const token = parser.getToken();
     const expression = parseIdentifier(parser, context);
     if ((parser.flags & 1) === 0 && isResourceBindingStart(parser.getToken())) {
-        if (origin & 4 && context & 8 && (context & 2) === 0) {
+        if (origin & 4 &&
+            context & 8 &&
+            (context & 2) === 0 &&
+            (context & 4096) === 0) {
             parser.report(30, KeywordDescTable[parser.getToken() & 255]);
         }
         return parseLexicalDeclaration(parser, context, scope, privateScope, 16, origin, 'using', tokenStart, 1);
     }
     parser.assignable = 1;
-    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 1, expression, token, tokenValue, tokenStart);
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, 1, expression, token, tokenValue, tokenStart, origin);
 }
-function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, origin, labels) {
+function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin) {
     const start = parser.tokenStart;
     if (context & 524288)
-        parser.report(177);
+        parser.report(179);
     nextToken(parser, context | 32);
     let argument;
     if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5614,9 +5635,9 @@ function parseAwaitUsingDeclarationOrExpressionStatement(parser, context, scope,
         type: 'AwaitExpression',
         argument,
     }, start);
-    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, origin, labels, 0, expression, 1048576, '', start);
+    return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, 0, expression, 1048576, '', start, origin);
 }
-function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
+function parseLexicalDeclaration(parser, context, scope, privateScope, kind, origin = 0, declarationKind, declarationStart = parser.tokenStart, keywordConsumed = 0) {
     const start = declarationStart;
     if (!keywordConsumed)
         nextToken(parser, context);
@@ -5628,7 +5649,7 @@ function parseLexicalDeclaration(parser, context, scope, privateScope, kind, ori
         declarations,
     }, start);
 }
-function parseVariableStatement(parser, context, scope, privateScope, origin) {
+function parseVariableStatement(parser, context, scope, privateScope, origin = 0) {
     const start = parser.tokenStart;
     nextToken(parser, context);
     const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 4, origin);
@@ -5639,7 +5660,7 @@ function parseVariableStatement(parser, context, scope, privateScope, origin) {
         declarations,
     }, start);
 }
-function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin, declarationKind) {
+function parseVariableDeclarationList(parser, context, scope, privateScope, kind, origin = 0, declarationKind) {
     let bindingCount = 1;
     const firstDeclaration = parseVariableDeclaration(parser, context, scope, privateScope, kind, origin, declarationKind);
     const list = [firstDeclaration];
@@ -5650,7 +5671,7 @@ function parseVariableDeclarationList(parser, context, scope, privateScope, kind
         if (resourceNames) {
             const { name } = declaration.id;
             if (resourceNames.has(name))
-                parser.report(145, name);
+                parser.report(147, name);
             resourceNames.add(name);
         }
         list.push(declaration);
@@ -5670,11 +5691,14 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
     const id = parseBindingPattern(parser, context, scope, privateScope, kind, origin);
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 32);
-        init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
+        init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart, origin);
         if (origin & 32) {
             if (parser.getToken() === 471156 ||
                 (parser.getToken() === 8673330 &&
-                    (token & 2097152 || (kind & 4) === 0 || context & 1))) {
+                    (token & 2097152 ||
+                        (kind & 4) === 0 ||
+                        context & 1 ||
+                        !parser.options.webcompat))) {
                 throw new ParseError(tokenStart, parser.currentLocation, 60, parser.getToken() === 471156 ? 'of' : 'in');
             }
         }
@@ -5729,7 +5753,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                 parser.assignable = 1;
                 init = parseMemberOrUpdateExpression(parser, context, privateScope, init, 0, 0, tokenStart);
                 if (parser.getToken() === 471156)
-                    parser.report(115);
+                    parser.report(117);
             }
         }
         else if (token === 209013) {
@@ -5781,7 +5805,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                         if (resourceNames) {
                             const { name } = declaration.id;
                             if (resourceNames.has(name))
-                                parser.report(145, name);
+                                parser.report(147, name);
                             resourceNames.add(name);
                         }
                         declarations.push(declaration);
@@ -5826,7 +5850,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     else if (token === 209006 &&
         (context & 2048 || (context & 2 && context & 8))) {
         if (context & 524288)
-            parser.report(177);
+            parser.report(179);
         nextToken(parser, context | 32);
         let awaitArgument;
         if ((parser.flags & 1) === 0 && parser.getToken() === 209013) {
@@ -5944,16 +5968,18 @@ 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);
-    scope?.addBlockName(context, parser.tokenValue, 8, 0);
+        parser.report(121);
+    scope?.addBlockName(context, parser.tokenValue, 8);
     return parseIdentifier(parser, context);
 }
 function parseImportDeclaration(parser, context, scope) {
     const start = parser.tokenStart;
     nextToken(parser, context);
     let source;
+    let sourceParsed = false;
+    let phase = null;
     const { tokenStart } = parser;
     let specifiers = [];
     if (parser.getToken() === 134283267) {
@@ -5961,14 +5987,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);
+                        specifiers = [
+                            parser.finishNode({
+                                type: 'ImportDefaultSpecifier',
+                                local: phaseOrLocal,
+                            }, tokenStart),
+                        ];
+                    }
+                    else {
+                        parser.report(108);
+                    }
+                }
+                else if (parser.getToken() === 209011) {
+                    const fromToken = parser.getToken();
+                    const fromStart = parser.tokenStart;
+                    const fromLocal = parseIdentifier(parser, context);
+                    if (parser.getToken() === 209011) {
+                        validateBindingIdentifier(parser, context, 16, fromToken, 0);
+                        scope?.addBlockName(context, fromLocal.name, 8);
+                        phase = 'source';
+                        specifiers = [
+                            parser.finishNode({
+                                type: 'ImportDefaultSpecifier',
+                                local: fromLocal,
+                            }, fromStart),
+                        ];
+                    }
+                    else {
+                        scope?.addBlockName(context, tokenValue, 8);
+                        specifiers = [
+                            parser.finishNode({
+                                type: 'ImportDefaultSpecifier',
+                                local: phaseOrLocal,
+                            }, tokenStart),
+                        ];
+                        if (parser.getToken() !== 134283267)
+                            parser.report(105, 'Import');
+                        source = parseLiteral(parser, context);
+                        sourceParsed = true;
+                    }
+                }
+                else if (parser.getToken() & 143360) {
+                    phase = 'source';
+                    const localStart = parser.tokenStart;
+                    const local = parseRestrictedIdentifier(parser, context, scope);
+                    specifiers = [
+                        parser.finishNode({
+                            type: 'ImportDefaultSpecifier',
+                            local,
+                        }, localStart),
+                    ];
+                }
+                else if (parser.getToken() === 18) {
+                    scope?.addBlockName(context, tokenValue, 8);
+                    specifiers = [
+                        parser.finishNode({
+                            type: 'ImportDefaultSpecifier',
+                            local: phaseOrLocal,
+                        }, tokenStart),
+                    ];
+                }
+                else {
+                    parser.report(109);
+                }
+            }
+            else {
+                const local = parseRestrictedIdentifier(parser, context, scope);
+                specifiers = [
+                    parser.finishNode({
+                        type: 'ImportDefaultSpecifier',
+                        local,
+                    }, tokenStart),
+                ];
+            }
+            if (phase === null && !sourceParsed && consumeOpt(parser, context, 18)) {
                 switch (parser.getToken()) {
                     case 8391476:
                         specifiers.push(parseImportNamespaceSpecifier(parser, context, scope));
@@ -5997,7 +6102,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 = {
@@ -6005,6 +6111,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);
@@ -6052,7 +6159,7 @@ function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers)
         else {
             parser.report(25, KeywordDescTable[77932 & 255]);
         }
-        scope?.addBlockName(context, tokenValue, 8, 0);
+        scope?.addBlockName(context, tokenValue, 8);
         specifiers.push(parser.finishNode({
             type: 'ImportSpecifier',
             local,
@@ -6087,17 +6194,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);
+                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 1, 0, parser.tokenStart, 4);
                 break;
             }
             case 133:
+                if (!(parser.features & 1)) {
+                    parser.report(30, '@');
+                }
             case 86094:
                 declaration = parseClassDeclaration(parser, context, scope, undefined, 1);
                 break;
@@ -6107,11 +6221,11 @@ function parseExportDeclaration(parser, context, scope) {
                 const { flags } = parser;
                 if ((flags & 1) === 0) {
                     if (parser.getToken() === 86104) {
-                        declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 1, 1, tokenStart);
+                        declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 1, 1, tokenStart, 4);
                     }
                     else {
                         if (parser.getToken() === 67174411) {
-                            declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, 0, flags, tokenStart);
+                            declaration = parseAsyncArrowOrCallExpression(parser, context, undefined, declaration, 1, 1, flags, tokenStart);
                             declaration = parseMemberOrUpdateExpression(parser, context, undefined, declaration, 0, 0, tokenStart);
                             declaration = parseAssignmentExpression(parser, context, undefined, 0, 0, tokenStart, declaration);
                         }
@@ -6210,7 +6324,7 @@ function parseExportDeclaration(parser, context, scope) {
             }
             else {
                 if (hasLiteralLocal) {
-                    parser.report(172);
+                    parser.report(174);
                 }
                 if (scope) {
                     tmpExportedNames.forEach((n) => parser.declareUnboundVariable(n));
@@ -6221,11 +6335,14 @@ function parseExportDeclaration(parser, context, scope) {
             break;
         }
         case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             declaration = parseClassDeclaration(parser, context, scope, undefined, 2);
             break;
         case 86104:
-            declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 0, parser.tokenStart);
+            declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 2, 0, parser.tokenStart, 4);
             break;
         case 241737:
             declaration = parseLexicalDeclaration(parser, context, scope, undefined, 8, 64);
@@ -6240,7 +6357,7 @@ function parseExportDeclaration(parser, context, scope) {
             const { tokenStart } = parser;
             nextToken(parser, context);
             if ((parser.flags & 1) === 0 && parser.getToken() === 86104) {
-                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 4, 1, 2, 1, tokenStart);
+                declaration = parseFunctionDeclaration(parser, context, scope, undefined, 1, 2, 1, tokenStart, 4);
                 break;
             }
         }
@@ -6256,8 +6373,8 @@ function parseExportDeclaration(parser, context, scope) {
     };
     return parser.finishNode(node, start);
 }
-function parseExpression(parser, context, privateScope, canAssign, inGroup, start) {
-    let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start);
+function parseExpression(parser, context, privateScope, canAssign, inGroup, start, origin = 0) {
+    let expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, canAssign, inGroup, 1, start, origin);
     expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
     return parseAssignmentExpression(parser, context, privateScope, inGroup, 0, start, expr);
 }
@@ -6353,7 +6470,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;
@@ -6380,10 +6497,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;
@@ -6412,7 +6529,7 @@ function parseAsyncExpression(parser, context, privateScope, inGroup, isLHS, can
         }
     }
     if (!inNew && parser.getToken() === 67174411) {
-        return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, 0, flags, start);
+        return parseAsyncArrowOrCallExpression(parser, context, privateScope, expr, canAssign, 1, flags, start);
     }
     if (parser.getToken() === 10) {
         classifyIdentifier(parser, context, token);
@@ -6436,7 +6553,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) {
@@ -6460,20 +6577,24 @@ function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup
     return parseIdentifierOrArrow(parser, context, privateScope);
 }
 function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start) {
-    if (inGroup)
+    if (inGroup) {
+        if ((parser.destructible & 128) === 0) {
+            parser.firstAwaitLocation ??= { start, end: parser.currentLocation };
+        }
         parser.destructible |= 128;
+    }
     if (context & 524288)
-        parser.report(177);
+        parser.report(179);
     const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope);
     const isIdentifier = possibleIdentifierOrArrowFunc.type === 'ArrowFunctionExpression' ||
         (parser.getToken() & 65536) === 0;
     if (isIdentifier) {
         if (context & 2048)
-            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 176);
+            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 178);
         if (context & 2)
-            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
+            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 112);
         if (context & 8192 && context & 2048)
-            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 110);
+            throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 112);
         return possibleIdentifierOrArrowFunc;
     }
     if (context & 8192) {
@@ -6495,8 +6616,9 @@ function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew,
         throw new ParseError(start, { index: parser.startIndex, line: parser.startLine, column: parser.startColumn }, 98);
     return possibleIdentifierOrArrowFunc;
 }
-function parseFunctionBody(parser, context, scope, privateScope, origin, funcNameToken, functionScope) {
+function parseFunctionBody(parser, context, scope, privateScope, funcNameToken, functionScope, origin = 0) {
     const { tokenStart } = parser;
+    parser.flags &= -4161;
     consume(parser, context | 32, 2162700);
     const body = [];
     if (parser.getToken() !== 1074790415) {
@@ -6522,19 +6644,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);
             }
         }
     }
@@ -6543,7 +6665,7 @@ function parseFunctionBody(parser, context, scope, privateScope, origin, funcNam
             (512 | 256 | 64 | 4096);
     parser.destructible = (parser.destructible | 256) ^ 256;
     while (parser.getToken() !== 1074790415) {
-        body.push(parseStatementListItem(parser, context, scope, privateScope, 4, {}));
+        body.push(parseStatementListItem(parser, context, scope, privateScope, {}, 4));
     }
     consume(parser, origin & (16 | 8) ? context | 32 : context, 1074790415);
     parser.flags &= -4289;
@@ -6559,7 +6681,7 @@ function parseSuperExpression(parser, context) {
     nextToken(parser, context);
     switch (parser.getToken()) {
         case 67108991:
-            parser.report(167);
+            parser.report(169);
         case 67174411: {
             if ((context & 512) === 0)
                 parser.report(28);
@@ -6606,7 +6728,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
             case 67108877: {
                 nextToken(parser, (context | 262144 | 8) ^ 8);
                 if (context & 16 && parser.getToken() === 131 && parser.tokenValue === 'super') {
-                    parser.report(173);
+                    parser.report(175);
                 }
                 parser.assignable =
                     (parser.flags & 2048) === 2048
@@ -6686,7 +6808,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({
@@ -6767,7 +6889,7 @@ function parsePropertyOrPrivatePropertyName(parser, context, privateScope) {
         parser.getToken() !== -2147483527 &&
         parser.getToken() !== -2147483526 &&
         parser.getToken() !== 131) {
-        parser.report(160);
+        parser.report(162);
     }
     return parser.getToken() === 131
         ? parsePrivateIdentifier(parser, context, privateScope, 0)
@@ -6792,7 +6914,7 @@ function parseUpdateExpressionPrefixed(parser, context, privateScope, inNew, isL
         prefix: true,
     }, start);
 }
-function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start) {
+function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canAssign, inGroup, isLHS, start, origin = 0) {
     if ((parser.getToken() & 143360) === 143360) {
         switch (parser.getToken()) {
             case 209006:
@@ -6812,16 +6934,16 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             if ((token & 36864) === 36864) {
                 parser.flags |= 256;
             }
-            return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start);
+            return parseArrowFromIdentifier(parser, context, privateScope, tokenValue, expr, inNew, canAssign, 0, start, origin);
         }
         if (context & 16 &&
             !(context & 32768) &&
             !(context & 8192) &&
             parser.tokenValue === 'arguments')
-            parser.report(130);
+            parser.report(132);
         if ((token & 255) === (241737 & 255)) {
             if (context & 1)
-                parser.report(113);
+                parser.report(115);
             if (kind & (8 | 16))
                 parser.report(100);
         }
@@ -6853,7 +6975,7 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         case 69271571:
             return parseArrayLiteral(parser, context, privateScope, canAssign ? 0 : 1, inGroup);
         case 67174411:
-            return parseParenthesizedExpression(parser, context | 64, privateScope, canAssign, 1, 0, start);
+            return parseParenthesizedExpression(parser, context | 64, privateScope, canAssign, 1, start, origin);
         case 86021:
         case 86022:
         case 86023:
@@ -6863,6 +6985,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         case 65540:
             return parseRegExpLiteral(parser, context);
         case 133:
+            if (!(parser.features & 1)) {
+                parser.report(30, '@');
+            }
         case 86094:
             return parseClassExpression(parser, context, privateScope, inGroup, start);
         case 86109:
@@ -6891,24 +7016,37 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
 function parseImportCallOrMetaExpression(parser, context, privateScope, inNew, inGroup, start) {
     let expr = parseIdentifier(parser, context);
     if (parser.getToken() === 67108877) {
-        return parseImportMetaExpression(parser, context, expr, start);
+        return parseImportMetaExpression(parser, context, expr, start, privateScope, inGroup, inNew);
     }
     if (inNew)
-        parser.report(142);
+        parser.report(144);
     expr = parseImportExpression(parser, context, privateScope, inGroup, start);
     parser.assignable = 2;
     return parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGroup, 0, start);
 }
-function parseImportMetaExpression(parser, context, meta, start) {
-    if ((context & 2) === 0)
-        parser.report(169);
+function parseImportMetaExpression(parser, context, meta, start, privateScope, inGroup = 0, inNew = 0) {
+    const propertyStart = parser.tokenStart;
+    const propertyEnd = parser.currentLocation;
     nextToken(parser, context);
     const token = parser.getToken();
+    const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && parser.tokenValue === 'defer';
+    const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && parser.tokenValue === 'source';
+    if (isPhaseDefer || isPhaseSource) {
+        if (inNew)
+            parser.report(144);
+        nextToken(parser, context);
+        const expression = parseImportExpression(parser, context, privateScope, inGroup, start, parser.tokenValue);
+        parser.assignable = 2;
+        return expression;
+    }
+    if ((context & 2) === 0) {
+        throw new ParseError(propertyStart, propertyEnd, 171);
+    }
     if (token !== 209031 && parser.tokenValue !== 'meta') {
-        parser.report(174);
+        parser.report(176);
     }
     else if (token & -2147483648) {
-        parser.report(175);
+        parser.report(177);
     }
     parser.assignable = 2;
     return parser.finishNode({
@@ -6917,10 +7055,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) {
@@ -6935,6 +7073,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);
@@ -6952,7 +7091,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({
@@ -6990,7 +7129,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);
     }
@@ -7165,7 +7304,7 @@ function parseThisExpression(parser, context) {
         type: 'ThisExpression',
     }, tokenStart);
 }
-function parseFunctionDeclaration(parser, context, scope, privateScope, origin, allowGen, flags, isAsync, start) {
+function parseFunctionDeclaration(parser, context, scope, privateScope, allowGen, flags, isAsync, start, origin = 0) {
     nextToken(parser, context | 32);
     const isGenerator = allowGen ? optionalBit(parser, context, 8391476) : 0;
     let id = null;
@@ -7219,7 +7358,7 @@ function parseFunctionDeclaration(parser, context, scope, privateScope, origin,
     functionScope = functionScope?.createChildScope(256);
     const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, functionScope, privateScope, 0, 1);
     const modifierFlags = 8 | 4 | 128 | 524288;
-    const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 32768 | 4096, functionScope?.createChildScope(64), privateScope, 8, funcNameToken, functionScope);
+    const body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 32768 | 4096, functionScope?.createChildScope(64), privateScope, funcNameToken, functionScope, 8);
     return parser.finishNode({
         type: 'FunctionDeclaration',
         id,
@@ -7258,7 +7397,7 @@ function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup
     const params = parseFormalParametersOrFormalList(parser, (context | 8192) & -524289, scope, privateScope, inGroup, 1);
     const body = parseFunctionBody(parser, (context & -131229) |
         32768 |
-        4096, scope?.createChildScope(64), privateScope, 0, funcNameToken, scope);
+        4096, scope?.createChildScope(64), privateScope, funcNameToken, scope);
     parser.assignable = 2;
     return parser.finishNode({
         type: 'FunctionExpression',
@@ -7270,7 +7409,7 @@ function parseFunctionExpression(parser, context, privateScope, isAsync, inGroup
     }, start);
 }
 function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGroup) {
-    const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
+    const expr = parseArrayExpressionOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2);
     if (parser.destructible & 64) {
         parser.report(63);
     }
@@ -7279,7 +7418,7 @@ function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGro
     }
     return expr;
 }
-function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
     const { tokenStart: start } = parser;
     nextToken(parser, context | 32);
     const elements = [];
@@ -7388,7 +7527,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                 }
             }
             else if (token === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, origin, 0, inGroup, isPattern);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 20, kind, 0, inGroup, isPattern, origin);
                 destructible |= parser.destructible;
                 if (parser.getToken() !== 18 && parser.getToken() !== 20)
                     parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -7458,7 +7597,7 @@ function parseArrayOrObjectAssignmentPattern(parser, context, privateScope, dest
             right,
         }, start);
 }
-function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, origin, isAsync, inGroup, isPattern) {
+function parseSpreadOrRestElement(parser, context, scope, privateScope, closingToken, kind, isAsync, inGroup, isPattern, origin = 0) {
     const { tokenStart: start } = parser;
     nextToken(parser, context | 32);
     let argument = null;
@@ -7551,7 +7690,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,
@@ -7607,7 +7746,7 @@ function parseMethodDefinition(parser, context, privateScope, kind, inGroup, sta
     scope = scope?.createChildScope(64);
     const body = parseFunctionBody(parser, (context & -655373) |
         32768 |
-        4096, scope, privateScope, 0, void 0, scope?.parent);
+        4096, scope, privateScope, void 0, scope?.parent);
     return parser.finishNode({
         type: 'FunctionExpression',
         params,
@@ -7618,7 +7757,7 @@ function parseMethodDefinition(parser, context, privateScope, kind, inGroup, sta
     }, start);
 }
 function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGroup) {
-    const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2, 0);
+    const expr = parseObjectLiteralOrPattern(parser, context, void 0, privateScope, skipInitializer, inGroup, 0, 2);
     if (parser.destructible & 64) {
         parser.report(63);
     }
@@ -7627,7 +7766,7 @@ function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGr
     }
     return expr;
 }
-function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin) {
+function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
     const { tokenStart: start } = parser;
     nextToken(parser, context);
     const properties = [];
@@ -7638,7 +7777,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
         const { tokenValue, tokenStart } = parser;
         const token = parser.getToken();
         if (token === 14) {
-            properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, origin, 0, inGroup, isPattern));
+            properties.push(parseSpreadOrRestElement(parser, context, scope, privateScope, 1074790415, kind, 0, inGroup, isPattern, origin));
         }
         else {
             let state = 0;
@@ -7810,7 +7949,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         parser.report(95);
                     if (token === 209005) {
                         if (parser.flags & 1)
-                            parser.report(132);
+                            parser.report(134);
                         state |= 16 | 1;
                     }
                     else if (token === 209008) {
@@ -7874,7 +8013,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) {
@@ -7978,7 +8117,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     destructible = 16;
                 }
                 else {
-                    parser.report(134);
+                    parser.report(136);
                 }
             }
             else if (parser.getToken() === 69271571) {
@@ -8125,7 +8264,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 {
@@ -8166,6 +8305,7 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
     const params = [];
     parser.flags = (parser.flags | 128) ^ 128;
     parser.strictReservedRange = null;
+    parser.firstAwaitLocation = null;
     if (parser.getToken() === 16) {
         if (kind & 512) {
             parser.report(37, 'Setter', 'one', '');
@@ -8195,17 +8335,17 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
                     parser.flags |= 512;
                 }
             }
-            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
+            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1);
         }
         else {
             if (parser.getToken() === 2162700) {
-                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
+                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type);
             }
             else if (parser.getToken() === 69271571) {
-                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type, 0);
+                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, type);
             }
             else if (parser.getToken() === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, 0, inGroup, 1);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, type, 0, inGroup, 1);
             }
             isNonSimpleParameterList = 1;
             if (parser.destructible & (32 | 16))
@@ -8244,17 +8384,20 @@ function parseComputedPropertyName(parser, context, privateScope, inGroup) {
     consume(parser, context, 20);
     return key;
 }
-function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, origin, start) {
+function parseParenthesizedExpression(parser, context, privateScope, canAssign, kind, start, origin) {
     parser.flags = (parser.flags | 128) ^ 128;
     const parenthesesStart = parser.tokenStart;
     nextToken(parser, context | 32 | 262144);
     const scope = parser.createScopeIfLexical()?.createChildScope(512);
     context = (context | 131072) ^ 131072;
     if (consumeOpt(parser, context, 16)) {
-        return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start);
+        return parseParenthesizedArrow(parser, context, scope, privateScope, [], canAssign, 0, start, origin);
     }
     let destructible = 0;
+    const previousAwaitYield = parser.destructible & (256 | 128);
     parser.destructible &= -385;
+    const previousFirstAwaitLocation = parser.firstAwaitLocation;
+    parser.firstAwaitLocation = null;
     let expr;
     let expressions = [];
     let isSequence = 0;
@@ -8266,14 +8409,14 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         const { tokenStart } = parser;
         const token = parser.getToken();
         if (token & 143360) {
-            scope?.addBlockName(context, parser.tokenValue, 1, 0);
+            scope?.addBlockName(context, parser.tokenValue, 1);
             if ((token & 537079808) === 537079808) {
                 isNonSimpleParameterList = 1;
             }
             else if ((token & 36864) === 36864) {
                 hasStrictReserved = 1;
             }
-            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart);
+            expr = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, 1, 1, tokenStart, 0);
             if (parser.getToken() === 16 || parser.getToken() === 18) {
                 if (parser.assignable & 2) {
                     destructible |= 16;
@@ -8296,14 +8439,14 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         else if ((token & 2097152) === 2097152) {
             expr =
                 token === 2162700
-                    ? parseObjectLiteralOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin)
-                    : parseArrayExpressionOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind, origin);
+                    ? parseObjectLiteralOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind)
+                    : parseArrayExpressionOrPattern(parser, context | 262144, scope, privateScope, 0, 1, 0, kind);
             destructible |= parser.destructible;
             isNonSimpleParameterList = 1;
             parser.assignable = 2;
             if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                 if (destructible & 8)
-                    parser.report(122);
+                    parser.report(124);
                 expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                 destructible |= 16;
                 if (parser.getToken() !== 16 && parser.getToken() !== 18) {
@@ -8312,7 +8455,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             }
         }
         else if (token === 14) {
-            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 0, 1, 0);
+            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 1, 0);
             if (parser.destructible & 16)
                 parser.report(74);
             isNonSimpleParameterList = 1;
@@ -8345,7 +8488,10 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
                 }, tokenAfterParenthesesStart);
             }
             consume(parser, context, 16);
-            parser.destructible = destructible;
+            parser.destructible = destructible | previousAwaitYield;
+            if (previousFirstAwaitLocation) {
+                parser.firstAwaitLocation = previousFirstAwaitLocation;
+            }
             return parser.options.preserveParens
                 ? parser.finishNode({
                     type: 'ParenthesizedExpression',
@@ -8376,7 +8522,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
@@ -8386,8 +8532,12 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     if (parser.getToken() === 10) {
         if (destructible & (32 | 16))
             parser.report(49);
-        if (context & (2048 | 2) && destructible & 128)
+        if (context & (2048 | 2) && destructible & 128) {
+            const loc = parser.firstAwaitLocation;
+            if (loc)
+                throw new ParseError(loc.start, loc.end, 31);
             parser.report(31);
+        }
         if (context & (1 | 1024) && destructible & 256) {
             parser.report(32);
         }
@@ -8395,15 +8545,19 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             parser.flags |= 128;
         if (hasStrictReserved)
             parser.flags |= 256;
-        return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start);
+        return parseParenthesizedArrow(parser, context, scope, privateScope, isSequence ? expressions : [expr], canAssign, 0, start, origin);
     }
     if (destructible & 64) {
         parser.report(63);
     }
     if (destructible & 8) {
-        parser.report(144);
+        parser.report(146);
+    }
+    parser.destructible =
+        ((parser.destructible | 256) ^ 256) | destructible | previousAwaitYield;
+    if (previousFirstAwaitLocation) {
+        parser.firstAwaitLocation = previousFirstAwaitLocation;
     }
-    parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
     return parser.options.preserveParens
         ? parser.finishNode({
             type: 'ParenthesizedExpression',
@@ -8434,23 +8588,23 @@ function parseIdentifierOrArrow(parser, context, privateScope) {
     }
     return expr;
 }
-function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start) {
+function parseArrowFromIdentifier(parser, context, privateScope, value, expr, inNew, canAssign, isAsync, start, origin = 0) {
     if (!canAssign)
         parser.report(57);
     if (inNew)
         parser.report(51);
     parser.flags &= -129;
     const scope = parser.options.lexical ? createArrowHeadParsingScope(parser, context, value) : void 0;
-    return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start);
+    return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], isAsync, start, origin);
 }
-function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start) {
+function parseParenthesizedArrow(parser, context, scope, privateScope, params, canAssign, isAsync, start, origin = 0) {
     if (!canAssign)
         parser.report(57);
     for (let i = 0; i < params.length; ++i)
         reinterpretToPattern(parser, params[i]);
-    return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start);
+    return parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, origin);
 }
-function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start) {
+function parseArrowFunctionExpression(parser, context, scope, privateScope, params, isAsync, start, origin = 0) {
     if (parser.flags & 1)
         parser.report(48);
     consume(parser, context | 32, 10);
@@ -8468,29 +8622,32 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
     else {
         scope = scope?.createChildScope(64);
         const modifierFlags = 4 | 131072 | 8;
-        body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, 16, void 0, void 0);
+        body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, void 0, void 0, 16);
         switch (parser.getToken()) {
             case 69271571:
                 if ((parser.flags & 1) === 0) {
-                    parser.report(116);
+                    parser.report(118);
                 }
                 parser.flags |= 8192;
                 break;
             case 67108877:
             case 67174409:
             case 22:
-                parser.report(117);
+                parser.report(119);
             case 67174411:
                 if ((parser.flags & 1) === 0) {
-                    parser.report(116);
+                    parser.report(118);
                 }
                 parser.flags |= 1024;
                 break;
         }
-        if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0)
-            parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+        if ((parser.getToken() & 8388608) === 8388608 && (parser.flags & 1) === 0) {
+            if (parser.getToken() !== 8673330 || origin !== 32) {
+                parser.report(30, KeywordDescTable[parser.getToken() & 255]);
+            }
+        }
         if ((parser.getToken() & 33619968) === 33619968)
-            parser.report(125);
+            parser.report(127);
     }
     parser.assignable = 2;
     return parser.finishNode({
@@ -8506,6 +8663,7 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
     consume(parser, context, 67174411);
     parser.flags = (parser.flags | 128) ^ 128;
     parser.strictReservedRange = null;
+    parser.firstAwaitLocation = null;
     const params = [];
     if (consumeOpt(parser, context, 16))
         return params;
@@ -8525,17 +8683,17 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
                     parser.flags |= 512;
                 }
             }
-            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1, 0);
+            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1);
         }
         else {
             if (token === 2162700) {
-                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
+                left = parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind);
             }
             else if (token === 69271571) {
-                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind, 0);
+                left = parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, inGroup, 1, kind);
             }
             else if (token === 14) {
-                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, 0, inGroup, 1);
+                left = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 0, inGroup, 1);
             }
             else {
                 parser.report(30, KeywordDescTable[token & 255]);
@@ -8630,7 +8788,7 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
     context = (context | 131072) ^ 131072;
     if (parser.getToken() === 67108991)
-        parser.report(168);
+        parser.report(170);
     const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
     parser.assignable = 2;
     return parser.finishNode({
@@ -8659,9 +8817,11 @@ function parseAsyncArrowAfterIdent(parser, context, privateScope, canAssign, sta
     }
     return parseArrowFromIdentifier(parser, (context & -524289) | 2048, privateScope, parser.tokenValue, parseIdentifier(parser, context), 0, canAssign, 1, start);
 }
-function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, origin, flags, start) {
+function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee, canAssign, kind, flags, start) {
     nextToken(parser, context | 32);
     const scope = parser.createScopeIfLexical()?.createChildScope(512);
+    const previousFirstAwaitLocation = parser.firstAwaitLocation;
+    parser.firstAwaitLocation = null;
     context = (context | 131072) ^ 131072;
     if (consumeOpt(parser, context, 16)) {
         if (parser.getToken() === 10) {
@@ -8675,6 +8835,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         else {
             parser.assignable = 2;
         }
+        if (previousFirstAwaitLocation)
+            parser.firstAwaitLocation = previousFirstAwaitLocation;
         return parser.finishNode({
             type: 'CallExpression',
             callee,
@@ -8693,7 +8855,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         const { tokenStart } = parser;
         const token = parser.getToken();
         if (token & 143360) {
-            scope?.addBlockName(context, parser.tokenValue, kind, 0);
+            scope?.addBlockName(context, parser.tokenValue, kind);
             if ((token & 537079808) === 537079808) {
                 parser.flags |= 512;
             }
@@ -8723,13 +8885,13 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         else if (token & 2097152) {
             expr =
                 token === 2162700
-                    ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin)
-                    : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind, origin);
+                    ? parseObjectLiteralOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind)
+                    : parseArrayExpressionOrPattern(parser, context, scope, privateScope, 0, 1, 0, kind);
             destructible |= parser.destructible;
             isNonSimpleParameterList = 1;
             if (parser.getToken() !== 16 && parser.getToken() !== 18) {
                 if (destructible & 8)
-                    parser.report(122);
+                    parser.report(124);
                 expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, tokenStart);
                 destructible |= 16;
                 if ((parser.getToken() & 8388608) === 8388608) {
@@ -8741,7 +8903,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             }
         }
         else if (token === 14) {
-            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, origin, 1, 1, 0);
+            expr = parseSpreadOrRestElement(parser, context, scope, privateScope, 16, kind, 1, 1, 0);
             destructible |=
                 (parser.getToken() === 16 ? 0 : 16) | parser.destructible;
             isNonSimpleParameterList = 1;
@@ -8762,6 +8924,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             else {
                 parser.assignable = 2;
             }
+            if (previousFirstAwaitLocation)
+                parser.firstAwaitLocation = previousFirstAwaitLocation;
             return parser.finishNode({
                 type: 'CallExpression',
                 callee,
@@ -8785,8 +8949,12 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             parser.report(27);
         if (parser.flags & 1 || flags & 1)
             parser.report(48);
-        if (destructible & 128)
+        if (destructible & 128) {
+            const loc = parser.firstAwaitLocation;
+            if (loc)
+                throw new ParseError(loc.start, loc.end, 31);
             parser.report(31);
+        }
         if (context & (1 | 1024) && destructible & 256)
             parser.report(32);
         if (isNonSimpleParameterList)
@@ -8805,6 +8973,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
     else {
         parser.assignable = 2;
     }
+    if (previousFirstAwaitLocation)
+        parser.firstAwaitLocation = previousFirstAwaitLocation;
     return parser.finishNode({
         type: 'CallExpression',
         callee,
@@ -8830,9 +9000,6 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     let start;
     let decorators;
     if (parser.leadingDecorators.decorators.length) {
-        if (parser.getToken() === 133) {
-            parser.report(30, '@');
-        }
         start = parser.leadingDecorators.start;
         decorators = [...parser.leadingDecorators.decorators];
         parser.leadingDecorators.decorators.length = 0;
@@ -8842,19 +9009,19 @@ 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);
+            scope.addBlockName(context, tokenValue, 32);
             if (flags) {
                 if (flags & 2) {
                     parser.declareUnboundVariable(tokenValue);
@@ -8875,13 +9042,13 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     else {
         inheritedContext = (inheritedContext | 512) ^ 512;
     }
-    const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 8, 0);
+    const body = parseClassBody(parser, inheritedContext, context, scope, privateScope, 2, 0, 8);
     return parser.finishNode({
         type: 'ClassDeclaration',
         id,
         superClass,
         body,
-        ...(parser.options.next ? { decorators } : null),
+        ...(parser.features & 1 ? { decorators } : null),
     }, start);
 }
 function parseClassExpression(parser, context, privateScope, inGroup, start) {
@@ -8889,12 +9056,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);
     }
@@ -8906,37 +9073,74 @@ function parseClassExpression(parser, context, privateScope, inGroup, start) {
     else {
         inheritedContext = (inheritedContext | 512) ^ 512;
     }
-    const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, 0, inGroup);
+    const body = parseClassBody(parser, inheritedContext, context, void 0, privateScope, 2, inGroup);
     parser.assignable = 2;
     return parser.finishNode({
         type: 'ClassExpression',
         id,
         superClass,
         body,
-        ...(parser.options.next ? { decorators } : null),
+        ...(parser.features & 1 ? { decorators } : null),
     }, start);
 }
 function parseDecorators(parser, context, privateScope) {
     const list = [];
-    if (parser.options.next) {
+    if (parser.features & 1) {
         while (parser.getToken() === 133) {
-            list.push(parseDecoratorList(parser, context, privateScope));
+            list.push(parseDecorator(parser, context, privateScope));
         }
     }
     return list;
 }
-function parseDecoratorList(parser, context, privateScope) {
+function parseDecorator(parser, context, privateScope) {
     const start = parser.tokenStart;
     nextToken(parser, context | 32);
     const expressionStart = parser.tokenStart;
-    let expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
-    expression = parseMemberOrUpdateExpression(parser, context, privateScope, expression, 0, 0, expressionStart);
+    let expression;
+    if (parser.getToken() === 67174411) {
+        expression = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, start);
+    }
+    else {
+        const token = parser.getToken();
+        if (((token & 143360) !== 143360 && !isValidIdentifier(context, token)) ||
+            (context & 1 && (token & 36864) === 36864)) {
+            parser.report(30, KeywordDescTable[token & 255]);
+        }
+        if (token === 209006 && context & (2048 | 2)) {
+            parser.report(112);
+        }
+        if (token === 241771 && context & 1024) {
+            parser.report(97, 'yield');
+        }
+        let memberExpression = parseIdentifier(parser, context | 64);
+        while (parser.getToken() === 67108877) {
+            nextToken(parser, (context | 262144 | 8) ^ 8);
+            const property = parsePropertyOrPrivatePropertyName(parser, context | 64, privateScope);
+            memberExpression = parser.finishNode({
+                type: 'MemberExpression',
+                object: memberExpression,
+                computed: false,
+                property,
+                optional: false,
+            }, expressionStart);
+        }
+        expression = memberExpression;
+        if (parser.getToken() === 67174411) {
+            const args = parseArguments(parser, context, privateScope, 0);
+            expression = parser.finishNode({
+                type: 'CallExpression',
+                callee: memberExpression,
+                arguments: args,
+                optional: false,
+            }, expressionStart);
+        }
+    }
     return parser.finishNode({
         type: 'Decorator',
         expression,
     }, start);
 }
-function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, origin, inGroup) {
+function parseClassBody(parser, context, inheritedContext, scope, parentScope, kind, inGroup, origin = 0) {
     const { tokenStart } = parser;
     const privateScope = parser.createPrivateScopeIfLexical(parentScope);
     consume(parser, context | 32, 2162700);
@@ -8949,13 +9153,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));
@@ -9018,7 +9222,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;
@@ -9071,12 +9275,12 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
             key = parsePrivateIdentifier(parser, context, privateScope, kind);
         }
         else
-            parser.report(135);
+            parser.report(137);
     }
     if ((kind & 2) === 0) {
         if (parser.tokenValue === 'constructor') {
             if ((parser.getToken() & 1073741824) === 1073741824) {
-                parser.report(129);
+                parser.report(131);
             }
             else if ((kind & 32) === 0 && parser.getToken() === 67174411) {
                 if (kind & (768 | 16 | 128 | 8)) {
@@ -9114,7 +9318,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) {
@@ -9122,7 +9326,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);
@@ -9147,7 +9351,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
         nextToken(parser, context | 32);
         const { tokenStart } = parser;
         if (parser.getToken() === 537079928)
-            parser.report(119);
+            parser.report(121);
         const modifierFlags = 1024 |
             2048 |
             8192 |
@@ -9173,32 +9377,32 @@ 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) {
+function parseBindingPattern(parser, context, scope, privateScope, kind, origin = 0) {
     if (parser.getToken() & 143360 ||
         ((context & 1) === 0 && parser.getToken() === -2147483526))
-        return parseAndClassifyIdentifier(parser, context, scope, type, origin);
+        return parseAndClassifyIdentifier(parser, context, scope, kind, origin);
     if ((parser.getToken() & 2097152) !== 2097152)
         parser.report(30, KeywordDescTable[parser.getToken() & 255]);
     const left = parser.getToken() === 69271571
-        ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin)
-        : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, type, origin);
+        ? parseArrayExpressionOrPattern(parser, context, scope, privateScope, 1, 0, 1, kind, origin)
+        : parseObjectLiteralOrPattern(parser, context, scope, privateScope, 1, 0, 1, kind, origin);
     if (parser.destructible & 16)
         parser.report(50);
     if (parser.destructible & 32)
         parser.report(50);
     return left;
 }
-function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
+function parseAndClassifyIdentifier(parser, context, scope, kind, origin = 0) {
     const token = parser.getToken();
     if (context & 1) {
         if ((token & 537079808) === 537079808) {
-            parser.report(119);
+            parser.report(121);
         }
         else if ((token & 36864) === 36864 || token === -2147483526) {
-            parser.report(118);
+            parser.report(120);
         }
     }
     if ((token & 20480) === 20480) {
@@ -9208,7 +9412,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))
@@ -9216,9 +9420,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);
@@ -9250,7 +9454,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',
@@ -9319,7 +9523,7 @@ function parseJSXChildrenAndClosingFragment(parser, context, privateScope, inJSX
 }
 function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild) {
     if (parser.getToken() === 138)
-        return parseJSXText(parser, context);
+        return parseJSXText(parser);
     if (parser.getToken() === 2162700)
         return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
     if (parser.getToken() === 8456256) {
@@ -9333,7 +9537,7 @@ function parseJSXChildOrClosingElement(parser, context, privateScope, inJSXChild
 }
 function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChild) {
     if (parser.getToken() === 138)
-        return parseJSXText(parser, context);
+        return parseJSXText(parser);
     if (parser.getToken() === 2162700)
         return parseJSXExpressionContainer(parser, context, privateScope, 1, 0);
     if (parser.getToken() === 8456256) {
@@ -9345,9 +9549,9 @@ function parseJSXChildOrClosingFragment(parser, context, privateScope, inJSXChil
     }
     parser.report(0);
 }
-function parseJSXText(parser, context) {
+function parseJSXText(parser) {
     const start = parser.tokenStart;
-    nextToken(parser, context);
+    nextJSXToken(parser);
     const node = {
         type: 'JSXText',
         value: parser.tokenValue,
@@ -9445,7 +9649,7 @@ function parseJsxAttribute(parser, context, privateScope) {
                 value = parseJSXExpressionContainer(parser, context, privateScope, 0, 1);
                 break;
             default:
-                parser.report(154);
+                parser.report(156);
         }
     }
     return parser.finishNode({
@@ -9472,7 +9676,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,