meriyah 7.3.0 → 7.3.2

package/dist/meriyah.mjs

@@ -1,4 +1,4 @@
-var version$1 = "7.3.0";
+var version$1 = "7.3.2";
 var packageJson = {
 	version: version$1};
 
@@ -91,7 +91,7 @@ const CharTypes = [
     0,
     16384,
     0,
-    0,
+    16384,
     0,
     0,
     1 | 2 | 64,
@@ -154,7 +154,7 @@ const CharTypes = [
     1 | 2 | 4,
     16384,
     0,
-    0,
+    16384,
     0,
     0
 ];
@@ -788,6 +788,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;
@@ -2038,6 +2040,9 @@ function scanSingleToken(parser, context, state) {
                 }
                 case 8390721: {
                     advanceChar(parser);
+                    if (context & 1048576) {
+                        return 8390721;
+                    }
                     const ch = parser.currentChar;
                     if (ch === 61) {
                         advanceChar(parser);
@@ -2245,6 +2250,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)
@@ -4526,6 +4534,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)];
@@ -4552,7 +4566,7 @@ function nextJSXToken(parser) {
     parser.setToken(138);
 }
 function rescanJSXIdentifier(parser) {
-    if ((parser.getToken() & 143360) === 143360) {
+    if (parser.getToken() & 143360) {
         const { index } = parser;
         let char = parser.currentChar;
         while (CharTypes[char] & (32768 | 2)) {
@@ -4657,18 +4671,18 @@ class Scope {
     createChildScope(type) {
         return new Scope(this.parser, type, this);
     }
-    addVarOrBlock(context, name, kind, origin) {
+    addVarOrBlock(context, name, kind, tokenStart, tokenEnd, origin) {
         if (kind & 4) {
-            this.addVarName(context, name, kind);
+            this.addVarName(context, name, kind, tokenStart, tokenEnd);
         }
         else {
-            this.addBlockName(context, name, kind, origin);
+            this.addBlockName(context, name, kind, tokenStart, tokenEnd, origin);
         }
         if (origin & 64) {
             this.parser.declareUnboundVariable(name);
         }
     }
-    addVarName(context, name, kind) {
+    addVarName(context, name, kind, tokenStart, tokenEnd) {
         const { parser } = this;
         let currentScope = this;
         while (currentScope && (currentScope.type & 128) === 0) {
@@ -4680,17 +4694,17 @@ class Scope {
                     ((kind & 128 && value & 68) ||
                         (value & 128 && kind & 68))) ;
                 else {
-                    parser.report(147, name);
+                    throw new ParseError(tokenStart, tokenEnd, 147, name);
                 }
             }
             if (currentScope === this) {
                 if (value && value & 1 && kind & 1) {
-                    currentScope.recordScopeError(147, name);
+                    currentScope.recordScopeError(147, tokenStart, tokenEnd, name);
                 }
             }
             if (value &&
                 (value & 256 || (value & 512 && !parser.options.webcompat))) {
-                parser.report(147, name);
+                throw new ParseError(tokenStart, tokenEnd, 147, name);
             }
             currentScope.variableBindings.set(name, kind);
             currentScope = currentScope.parent;
@@ -4699,12 +4713,12 @@ class Scope {
     hasVariable(name) {
         return this.variableBindings.has(name);
     }
-    addBlockName(context, name, kind, origin) {
+    addBlockName(context, name, kind, tokenStart, tokenEnd, origin = 0) {
         const { parser } = this;
         const value = this.variableBindings.get(name);
         if (value && (value & 2) === 0) {
             if (kind & 1) {
-                this.recordScopeError(147, name);
+                this.recordScopeError(147, tokenStart, tokenEnd, name);
             }
             else if (parser.options.webcompat &&
                 (context & 1) === 0 &&
@@ -4712,31 +4726,31 @@ class Scope {
                 value === 64 &&
                 kind === 64) ;
             else {
-                parser.report(147, name);
+                throw new ParseError(tokenStart, tokenEnd, 147, name);
             }
         }
         if (this.type & 64 &&
             this.parent?.hasVariable(name) &&
             (this.parent.variableBindings.get(name) & 2) === 0) {
-            parser.report(147, name);
+            throw new ParseError(tokenStart, tokenEnd, 147, name);
         }
         if (this.type & 512 && value && (value & 2) === 0) {
             if (kind & 1) {
-                this.recordScopeError(147, name);
+                this.recordScopeError(147, tokenStart, tokenEnd, name);
             }
         }
         if (this.type & 32) {
             if (this.parent.variableBindings.get(name) & 768)
-                parser.report(161, name);
+                throw new ParseError(tokenStart, tokenEnd, 161, name);
         }
         this.variableBindings.set(name, kind);
     }
-    recordScopeError(type, ...params) {
-        this.scopeError = {
+    recordScopeError(type, tokenStart, tokenEnd, ...params) {
+        this.scopeError ??= {
             type,
             params,
-            start: this.parser.tokenStart,
-            end: this.parser.currentLocation,
+            start: tokenStart,
+            end: tokenEnd,
         };
     }
     reportScopeError() {
@@ -4747,9 +4761,9 @@ class Scope {
         throw new ParseError(scopeError.start, scopeError.end, scopeError.type, ...scopeError.params);
     }
 }
-function createArrowHeadParsingScope(parser, context, value) {
+function createArrowHeadParsingScope(parser, context, value, tokenStart, tokenEnd) {
     const scope = parser.createScope().createChildScope(512);
-    scope.addBlockName(context, value, 1, 0);
+    scope.addBlockName(context, value, 1, tokenStart, tokenEnd);
     return scope;
 }
 
@@ -4779,6 +4793,7 @@ class Parser {
     assignable = 0;
     destructible = 0;
     strictReservedRange = null;
+    firstAwaitLocation = null;
     leadingDecorators = { decorators: [] };
     constructor(source, rawOptions = {}) {
         this.source = source;
@@ -4987,7 +5002,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;
 }
@@ -5023,18 +5038,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, '@');
@@ -5042,17 +5057,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:
@@ -5066,15 +5081,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:
@@ -5104,7 +5119,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:
@@ -5118,10 +5133,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;
@@ -5136,11 +5151,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);
@@ -5153,7 +5168,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({
@@ -5182,7 +5197,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);
@@ -5190,27 +5205,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);
@@ -5220,7 +5235,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) {
@@ -5306,8 +5321,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;
@@ -5336,7 +5351,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' &&
@@ -5372,7 +5387,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)
@@ -5419,7 +5434,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,
@@ -5466,7 +5481,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);
         }
@@ -5510,12 +5525,12 @@ function parseDoWhileStatement(parser, context, scope, privateScope, labels) {
     }, start);
 }
 function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin) {
-    const { tokenValue, tokenStart } = parser;
+    const { tokenValue, tokenStart, currentLocation } = parser;
     const token = parser.getToken();
     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',
@@ -5527,12 +5542,12 @@ 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;
         if (parser.options.lexical)
-            scope = createArrowHeadParsingScope(parser, context, tokenValue);
+            scope = createArrowHeadParsingScope(parser, context, tokenValue, tokenStart, currentLocation);
         parser.flags = (parser.flags | 128) ^ 128;
         expr = parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, tokenStart);
     }
@@ -5581,20 +5596,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);
@@ -5618,9 +5636,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);
@@ -5632,7 +5650,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);
@@ -5643,7 +5661,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];
@@ -5674,11 +5692,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');
             }
         }
@@ -5745,6 +5766,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
             }
             else if (parser.getToken() === 471156) {
                 const ofStart = parser.tokenStart;
+                const ofEnd = parser.currentLocation;
                 const ofToken = parser.getToken();
                 const ofValue = parser.tokenValue;
                 const ofIdentifier = parseIdentifier(parser, context);
@@ -5760,7 +5782,7 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
                 else {
                     resourceDeclarationKind = 'using';
                     validateBindingIdentifier(parser, context, 16, ofToken, 0);
-                    scope?.addBlockName(context, ofValue, 16, 32);
+                    scope?.addBlockName(context, ofValue, 16, ofStart, ofEnd, 32);
                     let declarationInitializer = null;
                     if (parser.getToken() === 1077936155) {
                         nextToken(parser, context | 32);
@@ -5951,7 +5973,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, parser.tokenStart, parser.currentLocation);
     return parseIdentifier(parser, context);
 }
 function parseImportDeclaration(parser, context, scope) {
@@ -5968,7 +5990,7 @@ function parseImportDeclaration(parser, context, scope) {
     else {
         if (parser.getToken() & 143360) {
             const token = parser.getToken();
-            const { tokenValue } = parser;
+            const { tokenValue, tokenStart: start, currentLocation } = parser;
             const isPhaseDefer = parser.features & 2 && (token & -2147483648) === 0 && tokenValue == 'defer';
             const isPhaseSource = parser.features & 4 && (token & -2147483648) === 0 && tokenValue == 'source';
             if (isPhaseDefer || isPhaseSource) {
@@ -5979,7 +6001,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, start, currentLocation);
                         specifiers = [
                             parser.finishNode({
                                 type: 'ImportDefaultSpecifier',
@@ -5994,10 +6016,11 @@ function parseImportDeclaration(parser, context, scope) {
                 else if (parser.getToken() === 209011) {
                     const fromToken = parser.getToken();
                     const fromStart = parser.tokenStart;
+                    const fromEnd = parser.currentLocation;
                     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, fromStart, fromEnd);
                         phase = 'source';
                         specifiers = [
                             parser.finishNode({
@@ -6007,7 +6030,7 @@ function parseImportDeclaration(parser, context, scope) {
                         ];
                     }
                     else {
-                        scope?.addBlockName(context, tokenValue, 8, 0);
+                        scope?.addBlockName(context, tokenValue, 8, start, currentLocation);
                         specifiers = [
                             parser.finishNode({
                                 type: 'ImportDefaultSpecifier',
@@ -6032,7 +6055,7 @@ function parseImportDeclaration(parser, context, scope) {
                     ];
                 }
                 else if (parser.getToken() === 18) {
-                    scope?.addBlockName(context, tokenValue, 8, 0);
+                    scope?.addBlockName(context, tokenValue, 8, start, currentLocation);
                     specifiers = [
                         parser.finishNode({
                             type: 'ImportDefaultSpecifier',
@@ -6117,7 +6140,8 @@ function parseModuleSpecifier(parser, context) {
 function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers) {
     nextToken(parser, context);
     while (parser.getToken() & 143360 || parser.getToken() === 134283267) {
-        let { tokenValue, tokenStart } = parser;
+        let { tokenValue, tokenStart, currentLocation } = parser;
+        const start = tokenStart;
         const token = parser.getToken();
         const imported = parseModuleExportName(parser, context);
         let local;
@@ -6130,6 +6154,8 @@ function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers)
                 validateBindingIdentifier(parser, context, 16, parser.getToken(), 0);
             }
             tokenValue = parser.tokenValue;
+            tokenStart = parser.tokenStart;
+            currentLocation = parser.currentLocation;
             local = parseIdentifier(parser, context);
         }
         else if (imported.type === 'Identifier') {
@@ -6139,12 +6165,12 @@ function parseImportSpecifierOrNamedImports(parser, context, scope, specifiers)
         else {
             parser.report(25, KeywordDescTable[77932 & 255]);
         }
-        scope?.addBlockName(context, tokenValue, 8, 0);
+        scope?.addBlockName(context, tokenValue, 8, tokenStart, currentLocation);
         specifiers.push(parser.finishNode({
             type: 'ImportSpecifier',
             local,
             imported,
-        }, tokenStart));
+        }, start));
         if (parser.getToken() !== 1074790415)
             consume(parser, context, 18);
     }
@@ -6185,7 +6211,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:
@@ -6201,17 +6227,17 @@ 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);
                         }
                         else if (parser.getToken() & 143360) {
                             if (scope)
-                                scope = createArrowHeadParsingScope(parser, context, parser.tokenValue);
+                                scope = createArrowHeadParsingScope(parser, context, parser.tokenValue, parser.tokenStart, parser.currentLocation);
                             declaration = parseIdentifier(parser, context);
                             declaration = parseArrowFunctionExpression(parser, context, scope, undefined, [declaration], 1, tokenStart);
                         }
@@ -6322,7 +6348,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);
@@ -6337,7 +6363,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;
             }
         }
@@ -6353,8 +6379,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);
 }
@@ -6509,7 +6535,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);
@@ -6557,8 +6583,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);
@@ -6592,7 +6622,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);
@@ -6641,7 +6671,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;
@@ -6890,7 +6920,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:
@@ -6910,7 +6940,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) &&
@@ -6951,7 +6981,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:
@@ -7280,7 +7310,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;
@@ -7296,12 +7326,7 @@ function parseFunctionDeclaration(parser, context, scope, privateScope, origin,
             : 64 | (isAsync ? 1024 : 0) | (isGenerator ? 1024 : 0);
         validateFunctionName(parser, context, parser.getToken());
         if (scope) {
-            if (kind & 4) {
-                scope.addVarName(context, parser.tokenValue, kind);
-            }
-            else {
-                scope.addBlockName(context, parser.tokenValue, kind, origin);
-            }
+            scope.addVarOrBlock(context, parser.tokenValue, kind, parser.tokenStart, parser.currentLocation, origin);
             functionScope = functionScope?.createChildScope(128);
             if (flags) {
                 if (flags & 2) {
@@ -7334,7 +7359,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,
@@ -7373,7 +7398,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',
@@ -7385,7 +7410,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);
     }
@@ -7394,7 +7419,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 = [];
@@ -7406,7 +7431,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
         }
         else {
             let left;
-            const { tokenStart, tokenValue } = parser;
+            const { tokenStart, tokenValue, currentLocation } = parser;
             const token = parser.getToken();
             if (token & 143360) {
                 left = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
@@ -7414,7 +7439,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                     if (parser.assignable & 2)
                         parser.report(26);
                     nextToken(parser, context | 32);
-                    scope?.addVarOrBlock(context, tokenValue, kind, origin);
+                    scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
                     const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
                     left = parser.finishNode(isPattern
                         ? {
@@ -7440,7 +7465,7 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                         destructible |= 16;
                     }
                     else {
-                        scope?.addVarOrBlock(context, tokenValue, kind, origin);
+                        scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
                     }
                     destructible |=
                         parser.destructible & 256
@@ -7503,7 +7528,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]);
@@ -7573,12 +7598,12 @@ 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;
     let destructible = 0;
-    const { tokenValue, tokenStart } = parser;
+    const { tokenValue, tokenStart, currentLocation } = parser;
     let token = parser.getToken();
     if (token & 143360) {
         parser.assignable = 1;
@@ -7595,7 +7620,7 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
             destructible |= 16;
         }
         else if (token === closingToken || token === 18) {
-            scope?.addVarOrBlock(context, tokenValue, kind, origin);
+            scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
         }
         else {
             destructible |= 32;
@@ -7722,7 +7747,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,
@@ -7733,7 +7758,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);
     }
@@ -7742,7 +7767,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 = [];
@@ -7750,10 +7775,10 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
     let prototypeCount = 0;
     context = (context | 131072) ^ 131072;
     while (parser.getToken() !== 1074790415) {
-        const { tokenValue, tokenStart } = parser;
+        const { tokenValue, tokenStart, currentLocation } = 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;
@@ -7775,7 +7800,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     else {
                         validateBindingIdentifier(parser, context, kind, token, 0);
                     }
-                    scope?.addVarOrBlock(context, tokenValue, kind, origin);
+                    scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
                     if (consumeOpt(parser, context | 32, 1077936155)) {
                         destructible |= 8;
                         const right = parseExpression(parser, context, privateScope, 1, inGroup, parser.tokenStart);
@@ -7799,7 +7824,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     }
                 }
                 else if (consumeOpt(parser, context | 32, 21)) {
-                    const { tokenStart } = parser;
+                    const { tokenStart, currentLocation } = parser;
                     if (tokenValue === '__proto__')
                         prototypeCount++;
                     if (parser.getToken() & 143360) {
@@ -7815,7 +7840,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                     destructible |= 16;
                                 }
                                 else if ((tokenAfterColon & 143360) === 143360) {
-                                    scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
+                                    scope?.addVarOrBlock(context, valueAfterColon, kind, tokenStart, currentLocation, origin);
                                 }
                             }
                             else {
@@ -7833,7 +7858,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                 destructible |= 32;
                             }
                             else {
-                                scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
+                                scope?.addVarOrBlock(context, valueAfterColon, kind, tokenStart, currentLocation, origin);
                             }
                             value = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, value);
                         }
@@ -8001,7 +8026,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         prototypeCount++;
                     if (parser.getToken() & 143360) {
                         value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
-                        const { tokenValue: valueAfterColon } = parser;
+                        const { tokenValue: valueAfterColon, tokenStart: start, currentLocation } = parser;
                         const token = parser.getToken();
                         value = parseMemberOrUpdateExpression(parser, context, privateScope, value, inGroup, 0, tokenStart);
                         if (parser.getToken() === 18 || parser.getToken() === 1074790415) {
@@ -8010,7 +8035,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                     destructible |= 16;
                                 }
                                 else {
-                                    scope?.addVarOrBlock(context, valueAfterColon, kind, origin);
+                                    scope?.addVarOrBlock(context, valueAfterColon, kind, start, currentLocation, origin);
                                 }
                             }
                             else {
@@ -8102,7 +8127,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                 state |= 2;
                 if (parser.getToken() === 21) {
                     nextToken(parser, context | 32);
-                    const { tokenStart, tokenValue } = parser;
+                    const { tokenStart, tokenValue, currentLocation } = parser;
                     const tokenAfterColon = parser.getToken();
                     if (parser.getToken() & 143360) {
                         value = parsePrimaryExpression(parser, context, privateScope, kind, 0, 1, inGroup, 1, tokenStart);
@@ -8123,7 +8148,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                                     destructible |= 16;
                                 }
                                 else if ((tokenAfterColon & 143360) === 143360) {
-                                    scope?.addVarOrBlock(context, tokenValue, kind, origin);
+                                    scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
                                 }
                             }
                             else {
@@ -8281,6 +8306,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', '');
@@ -8310,17 +8336,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))
@@ -8359,17 +8385,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;
@@ -8378,17 +8407,17 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
     const tokenAfterParenthesesStart = parser.tokenStart;
     parser.assignable = 1;
     while (parser.getToken() !== 16) {
-        const { tokenStart } = parser;
+        const { tokenStart, currentLocation } = parser;
         const token = parser.getToken();
         if (token & 143360) {
-            scope?.addBlockName(context, parser.tokenValue, 1, 0);
+            scope?.addBlockName(context, parser.tokenValue, 1, tokenStart, currentLocation);
             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;
@@ -8411,8 +8440,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;
@@ -8427,7 +8456,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;
@@ -8460,7 +8489,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',
@@ -8501,8 +8533,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);
         }
@@ -8510,7 +8546,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);
@@ -8518,7 +8554,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',
@@ -8527,8 +8567,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         : expr;
 }
 function parseIdentifierOrArrow(parser, context, privateScope) {
-    const { tokenStart: start } = parser;
-    const { tokenValue } = parser;
+    const { tokenValue, tokenStart, currentLocation } = parser;
     let isNonSimpleParameterList = 0;
     let hasStrictReserved = 0;
     if ((parser.getToken() & 537079808) === 537079808) {
@@ -8540,32 +8579,36 @@ function parseIdentifierOrArrow(parser, context, privateScope) {
     const expr = parseIdentifier(parser, context);
     parser.assignable = 1;
     if (parser.getToken() === 10) {
-        const scope = parser.options.lexical ? createArrowHeadParsingScope(parser, context, tokenValue) : undefined;
+        const scope = parser.options.lexical
+            ? createArrowHeadParsingScope(parser, context, tokenValue, tokenStart, currentLocation)
+            : undefined;
         if (isNonSimpleParameterList)
             parser.flags |= 128;
         if (hasStrictReserved)
             parser.flags |= 256;
-        return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, start);
+        return parseArrowFunctionExpression(parser, context, scope, privateScope, [expr], 0, tokenStart);
     }
     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);
+    const scope = parser.options.lexical
+        ? createArrowHeadParsingScope(parser, context, value, start, parser.currentLocation)
+        : void 0;
+    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);
@@ -8583,7 +8626,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) {
@@ -8602,8 +8645,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);
     }
@@ -8621,6 +8667,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;
@@ -8640,17 +8687,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]);
@@ -8774,9 +8821,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) {
@@ -8790,6 +8839,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         else {
             parser.assignable = 2;
         }
+        if (previousFirstAwaitLocation)
+            parser.firstAwaitLocation = previousFirstAwaitLocation;
         return parser.finishNode({
             type: 'CallExpression',
             callee,
@@ -8805,10 +8856,10 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             (256 | 128);
     const params = [];
     while (parser.getToken() !== 16) {
-        const { tokenStart } = parser;
+        const { tokenStart, currentLocation } = parser;
         const token = parser.getToken();
         if (token & 143360) {
-            scope?.addBlockName(context, parser.tokenValue, kind, 0);
+            scope?.addBlockName(context, parser.tokenValue, kind, tokenStart, currentLocation);
             if ((token & 537079808) === 537079808) {
                 parser.flags |= 512;
             }
@@ -8838,8 +8889,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) {
@@ -8856,7 +8907,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;
@@ -8877,6 +8928,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
             else {
                 parser.assignable = 2;
             }
+            if (previousFirstAwaitLocation)
+                parser.firstAwaitLocation = previousFirstAwaitLocation;
             return parser.finishNode({
                 type: 'CallExpression',
                 callee,
@@ -8900,8 +8953,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)
@@ -8920,6 +8977,8 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
     else {
         parser.assignable = 2;
     }
+    if (previousFirstAwaitLocation)
+        parser.firstAwaitLocation = previousFirstAwaitLocation;
     return parser.finishNode({
         type: 'CallExpression',
         callee,
@@ -8957,7 +9016,7 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
     consume(parser, context, 86094);
     let id = null;
     let superClass = null;
-    const { tokenValue } = parser;
+    const { tokenValue, tokenStart, currentLocation } = parser;
     if (parser.getToken() & 4096 && parser.getToken() !== 20565) {
         if (isStrictReservedWord(parser, context, parser.getToken())) {
             parser.report(120);
@@ -8966,7 +9025,7 @@ function parseClassDeclaration(parser, context, scope, privateScope, flags) {
             parser.report(121);
         }
         if (scope) {
-            scope.addBlockName(context, tokenValue, 32, 0);
+            scope.addBlockName(context, tokenValue, 32, tokenStart, currentLocation);
             if (flags) {
                 if (flags & 2) {
                     parser.declareUnboundVariable(tokenValue);
@@ -8987,7 +9046,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,
@@ -9018,7 +9077,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',
@@ -9085,7 +9144,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);
@@ -9325,22 +9384,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) {
@@ -9369,13 +9428,13 @@ function parseAndClassifyIdentifier(parser, context, scope, kind, origin) {
         if (context & 2)
             parser.report(112);
     }
-    const { tokenValue, tokenStart: start } = parser;
+    const { tokenValue, tokenStart, currentLocation } = parser;
     nextToken(parser, context);
-    scope?.addVarOrBlock(context, tokenValue, kind, origin);
+    scope?.addVarOrBlock(context, tokenValue, kind, tokenStart, currentLocation, origin);
     return parser.finishNode({
         type: 'Identifier',
         name: tokenValue,
-    }, start);
+    }, tokenStart);
 }
 function parseJSXRootElementOrFragment(parser, context, privateScope, inJSXChild, start) {
     if (!inJSXChild)
@@ -9468,7 +9527,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) {
@@ -9482,7 +9541,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) {
@@ -9494,9 +9553,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,
@@ -9514,7 +9573,7 @@ function parseJSXOpeningElementOrSelfCloseElement(parser, context, privateScope,
     const attributes = parseJSXAttributes(parser, context, privateScope);
     const selfClosing = parser.getToken() === 8457014;
     if (selfClosing)
-        consume(parser, context, 8457014);
+        consume(parser, context | 1048576, 8457014);
     if (parser.getToken() !== 8390721) {
         parser.report(25, KeywordDescTable[8390721 & 255]);
     }
@@ -9665,7 +9724,7 @@ function parseJSXIdentifier(parser, context) {
         parser.report(30, KeywordDescTable[parser.getToken() & 255]);
     }
     const { tokenValue } = parser;
-    nextToken(parser, context);
+    nextToken(parser, context | 1048576);
     return parser.finishNode({
         type: 'JSXIdentifier',
         name: tokenValue,