meriyah 7.3.0 → 7.3.1

package/dist/meriyah.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var version$1 = "7.3.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
 ];
@@ -790,6 +790,8 @@ const errorMessages = {
     [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;
@@ -2247,6 +2249,9 @@ function isStrictReservedWord(parser, context, t) {
     if (t === 209006) {
         if (context & (2048 | 2))
             parser.report(112);
+        if ((parser.destructible & 128) === 0) {
+            parser.firstAwaitLocation ??= { start: parser.tokenStart, end: parser.currentLocation };
+        }
         parser.destructible |= 128;
     }
     if (t === 241771 && context & 1024)
@@ -4528,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)];
@@ -4701,7 +4712,7 @@ 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) {
@@ -4751,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;
 }
 
@@ -4781,6 +4792,7 @@ class Parser {
     assignable = 0;
     destructible = 0;
     strictReservedRange = null;
+    firstAwaitLocation = null;
     leadingDecorators = { decorators: [] };
     constructor(source, rawOptions = {}) {
         this.source = source;
@@ -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;
 }
@@ -5025,18 +5037,18 @@ function parseModuleItem(parser, context, scope) {
             moduleItem = parseImportDeclaration(parser, context, scope);
             break;
         default:
-            moduleItem = parseStatementListItem(parser, context, scope, undefined, 4, {});
+            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, '@');
@@ -5044,17 +5056,17 @@ function parseStatementListItem(parser, context, scope, privateScope, origin, la
         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:
@@ -5068,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:
@@ -5106,7 +5118,7 @@ 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(164);
         case 20566:
@@ -5120,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;
@@ -5138,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);
@@ -5155,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({
@@ -5184,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);
@@ -5192,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(125);
-            return parseFunctionDeclaration(parser, context, scope, privateScope, origin, 1, 0, 1, start);
+            return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 1, start, origin);
         }
         if (isValidIdentifier(context, parser.getToken())) {
             expr = parseAsyncArrowAfterIdent(parser, context, privateScope, 1, start);
@@ -5222,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) {
@@ -5308,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;
@@ -5338,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' &&
@@ -5374,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)
@@ -5421,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,
@@ -5468,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);
         }
@@ -5517,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',
@@ -5529,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;
@@ -5583,20 +5595,23 @@ 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(179);
@@ -5620,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);
@@ -5634,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);
@@ -5645,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];
@@ -5676,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');
             }
         }
@@ -5953,7 +5971,7 @@ function parseRestrictedIdentifier(parser, context, scope) {
         parser.report(120);
     if ((parser.getToken() & 537079808) === 537079808)
         parser.report(121);
-    scope?.addBlockName(context, parser.tokenValue, 8, 0);
+    scope?.addBlockName(context, parser.tokenValue, 8);
     return parseIdentifier(parser, context);
 }
 function parseImportDeclaration(parser, context, scope) {
@@ -5981,7 +5999,7 @@ function parseImportDeclaration(parser, context, scope) {
                         specifiers = [parseImportNamespaceSpecifier(parser, context, scope)];
                     }
                     else if (parser.getToken() === 209011 || parser.getToken() === 18) {
-                        scope?.addBlockName(context, tokenValue, 8, 0);
+                        scope?.addBlockName(context, tokenValue, 8);
                         specifiers = [
                             parser.finishNode({
                                 type: 'ImportDefaultSpecifier',
@@ -5999,7 +6017,7 @@ function parseImportDeclaration(parser, context, scope) {
                     const fromLocal = parseIdentifier(parser, context);
                     if (parser.getToken() === 209011) {
                         validateBindingIdentifier(parser, context, 16, fromToken, 0);
-                        scope?.addBlockName(context, fromLocal.name, 8, 0);
+                        scope?.addBlockName(context, fromLocal.name, 8);
                         phase = 'source';
                         specifiers = [
                             parser.finishNode({
@@ -6009,7 +6027,7 @@ function parseImportDeclaration(parser, context, scope) {
                         ];
                     }
                     else {
-                        scope?.addBlockName(context, tokenValue, 8, 0);
+                        scope?.addBlockName(context, tokenValue, 8);
                         specifiers = [
                             parser.finishNode({
                                 type: 'ImportDefaultSpecifier',
@@ -6034,7 +6052,7 @@ function parseImportDeclaration(parser, context, scope) {
                     ];
                 }
                 else if (parser.getToken() === 18) {
-                    scope?.addBlockName(context, tokenValue, 8, 0);
+                    scope?.addBlockName(context, tokenValue, 8);
                     specifiers = [
                         parser.finishNode({
                             type: 'ImportDefaultSpecifier',
@@ -6141,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,
@@ -6187,7 +6205,7 @@ function parseExportDeclaration(parser, context, scope) {
     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:
@@ -6203,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);
                         }
@@ -6324,7 +6342,7 @@ function parseExportDeclaration(parser, context, scope) {
             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);
@@ -6339,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;
             }
         }
@@ -6355,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);
 }
@@ -6511,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);
@@ -6559,8 +6577,12 @@ 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(179);
     const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope);
@@ -6594,7 +6616,7 @@ 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);
@@ -6643,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;
@@ -6892,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:
@@ -6912,7 +6934,7 @@ 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) &&
@@ -6953,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:
@@ -7282,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;
@@ -7336,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,
@@ -7375,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',
@@ -7387,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);
     }
@@ -7396,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 = [];
@@ -7505,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]);
@@ -7575,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;
@@ -7724,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,
@@ -7735,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);
     }
@@ -7744,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 = [];
@@ -7755,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;
@@ -8283,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', '');
@@ -8312,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))
@@ -8361,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;
@@ -8383,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;
@@ -8413,8 +8439,8 @@ 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;
@@ -8429,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;
@@ -8462,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',
@@ -8503,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);
         }
@@ -8512,7 +8545,7 @@ 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);
@@ -8520,7 +8553,11 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     if (destructible & 8) {
         parser.report(146);
     }
-    parser.destructible = ((parser.destructible | 256) ^ 256) | destructible;
+    parser.destructible =
+        ((parser.destructible | 256) ^ 256) | destructible | previousAwaitYield;
+    if (previousFirstAwaitLocation) {
+        parser.firstAwaitLocation = previousFirstAwaitLocation;
+    }
     return parser.options.preserveParens
         ? parser.finishNode({
             type: 'ParenthesizedExpression',
@@ -8551,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);
@@ -8585,7 +8622,7 @@ 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) {
@@ -8604,8 +8641,11 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
                 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(127);
     }
@@ -8623,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;
@@ -8642,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]);
@@ -8776,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) {
@@ -8792,6 +8835,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         else {
             parser.assignable = 2;
         }
+        if (previousFirstAwaitLocation)
+            parser.firstAwaitLocation = previousFirstAwaitLocation;
         return parser.finishNode({
             type: 'CallExpression',
             callee,
@@ -8810,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;
             }
@@ -8840,8 +8885,8 @@ 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) {
@@ -8858,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;
@@ -8879,6 +8924,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             else {
                 parser.assignable = 2;
             }
+            if (previousFirstAwaitLocation)
+                parser.firstAwaitLocation = previousFirstAwaitLocation;
             return parser.finishNode({
                 type: 'CallExpression',
                 callee,
@@ -8902,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)
@@ -8922,6 +8973,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
     else {
         parser.assignable = 2;
     }
+    if (previousFirstAwaitLocation)
+        parser.firstAwaitLocation = previousFirstAwaitLocation;
     return parser.finishNode({
         type: 'CallExpression',
         callee,
@@ -8968,7 +9021,7 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
             parser.report(121);
         }
         if (scope) {
-            scope.addBlockName(context, tokenValue, 32, 0);
+            scope.addBlockName(context, tokenValue, 32);
             if (flags) {
                 if (flags & 2) {
                     parser.declareUnboundVariable(tokenValue);
@@ -8989,7 +9042,7 @@ 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,
@@ -9020,7 +9073,7 @@ 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',
@@ -9087,7 +9140,7 @@ function parseDecorator(parser, context, privateScope) {
         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);
@@ -9327,22 +9380,22 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
         ...(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) {
@@ -9470,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) {
@@ -9484,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) {
@@ -9496,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,