meriyah 7.4.1 → 7.4.2

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+## [7.4.2](https://github.com/meriyah/meriyah/compare/v7.4.1...v7.4.2) (2026-11-08)
+
+### Bug Fixes
+
+* **lexer:** only treat `<!--` as a comment in web compatible script code ([#683](https://github.com/meriyah/meriyah/issues/683)) ([78eebfe](https://github.com/meriyah/meriyah/commit/78eebfe5a2eb4a51e11212598f6e586faa655606))
+* **lexer:** recognize an HTML close comment after a hashbang line ([#682](https://github.com/meriyah/meriyah/issues/682)) ([133b2b9](https://github.com/meriyah/meriyah/commit/133b2b906ddcc77941797f593389450baa5ad5c7))
+* **parser:** allow `#x in obj` as an array element, object property value and spread argument ([#678](https://github.com/meriyah/meriyah/issues/678)) ([1f7c40e](https://github.com/meriyah/meriyah/commit/1f7c40e8b031ea476934ab27610fdc04d35d2389)), closes [#x](https://github.com/meriyah/meriyah/issues/x)
+* **parser:** allow `arguments` as a label in class field initializers and static blocks ([#703](https://github.com/meriyah/meriyah/issues/703)) ([b3eae1f](https://github.com/meriyah/meriyah/commit/b3eae1f9958e12ffe5d36552b82f11b0cd8ff282))
+* **parser:** allow a nested class to use a private name declared later in an enclosing class ([#699](https://github.com/meriyah/meriyah/issues/699)) ([e476062](https://github.com/meriyah/meriyah/commit/e476062ed155cade8e8aa8fd70cd027068a3732f))
+* **parser:** allow an escaped strict mode reserved word as a class field name ([#698](https://github.com/meriyah/meriyah/issues/698)) ([5a764b5](https://github.com/meriyah/meriyah/commit/5a764b575b8e332a92c261e5e4fffef34e7c4eda))
+* **parser:** allow strict mode reserved words as identifiers in sloppy generators ([#674](https://github.com/meriyah/meriyah/issues/674)) ([0dc7926](https://github.com/meriyah/meriyah/commit/0dc792608674ac7796b8485f5b3cbaabbb604503))
+* **parser:** declare method parameters as parameters in lexical mode ([#688](https://github.com/meriyah/meriyah/issues/688)) ([c1dae06](https://github.com/meriyah/meriyah/commit/c1dae06f4cd76c75c780bd34c3c93ce08dc7980c))
+* **parser:** keep enclosing labels and allow web compat function declarations for a `let` label ([#692](https://github.com/meriyah/meriyah/issues/692)) ([0ab5c32](https://github.com/meriyah/meriyah/commit/0ab5c3289a0f581e42ec9a970851ffd929056627))
+* **parser:** parse `await` followed by a strict mode reserved word in sloppy async functions ([#679](https://github.com/meriyah/meriyah/issues/679)) ([dd8e9aa](https://github.com/meriyah/meriyah/commit/dd8e9aa6e16fe909e656bec4da02538e690597c0))
+* **parser:** parse operators after an import call at the start of a statement ([#677](https://github.com/meriyah/meriyah/issues/677)) ([c4b297a](https://github.com/meriyah/meriyah/commit/c4b297a26fbba6d01620f029d8ef9aef01a8b4a8))
+* **parser:** parse the computed key of a generator, async or accessor method in the enclosing context ([#695](https://github.com/meriyah/meriyah/issues/695)) ([a158249](https://github.com/meriyah/meriyah/commit/a1582490dc29ef1527e04af9cde38790da3bce32))
+* **parser:** reject `?.` and templates with substitutions after a block body arrow ([#686](https://github.com/meriyah/meriyah/issues/686)) ([1845d76](https://github.com/meriyah/meriyah/commit/1845d768841ccb0756372cf2f531b4184a59ce18))
+* **parser:** reject `++` and `--` after an array or object literal nested in another literal ([#694](https://github.com/meriyah/meriyah/issues/694)) ([7e1ec5e](https://github.com/meriyah/meriyah/commit/7e1ec5e78c1f00f911df78ad7b6fcb35e777dd9e))
+* **parser:** reject `++` and `--` on array and object literals ([#689](https://github.com/meriyah/meriyah/issues/689)) ([e13e7c9](https://github.com/meriyah/meriyah/commit/e13e7c922e91dfa692e35d49ba85f003087dbb5b))
+* **parser:** reject `arguments` in class field initializers and static blocks nested in functions ([#676](https://github.com/meriyah/meriyah/issues/676)) ([9a4f073](https://github.com/meriyah/meriyah/commit/9a4f07372b3766fa126d868fb40e45fd2554e50b))
+* **parser:** reject `await` in the concise body of a non-async arrow in module code ([#673](https://github.com/meriyah/meriyah/issues/673)) ([43449ea](https://github.com/meriyah/meriyah/commit/43449ea396c78524e1188ce816d4cc21d27a85a8))
+* **parser:** reject `break` and `continue` in an arrow or method body inside a loop ([#693](https://github.com/meriyah/meriyah/issues/693)) ([dfa8ad0](https://github.com/meriyah/meriyah/commit/dfa8ad0bb89f0bdd65db991e0f5e436f16ea67f9))
+* **parser:** reject `for await` in class static blocks ([#680](https://github.com/meriyah/meriyah/issues/680)) ([65d5350](https://github.com/meriyah/meriyah/commit/65d5350ad326d3f764500be51f4e93aa006b455a))
+* **parser:** reject a function declaration after an `async:` label in a single-statement context ([#697](https://github.com/meriyah/meriyah/issues/697)) ([4c4ea12](https://github.com/meriyah/meriyah/commit/4c4ea129bbb8eb6d68976b41d316752100694122))
+* **parser:** reject an escaped `yield` or `await` as the name of a generator or async function expression ([#702](https://github.com/meriyah/meriyah/issues/702)) ([1480dad](https://github.com/meriyah/meriyah/commit/1480dad32cc6546ea7d2a623e851f18fccf32a7f))
+* **parser:** reject an optional call as an assignment target in web compat mode ([#696](https://github.com/meriyah/meriyah/issues/696)) ([a3d5926](https://github.com/meriyah/meriyah/commit/a3d59264e1261c04030898a0001c7cbcd8a735ea))
+* **parser:** reject arrow functions after unary operators when the parameter is a reserved word ([#687](https://github.com/meriyah/meriyah/issues/687)) ([e79d7db](https://github.com/meriyah/meriyah/commit/e79d7dbd1a56f44144f6e9a5dcb281c2bc7f21d1))
+* **parser:** reject assignment to a statement-level arrow with an `async` parameter ([#690](https://github.com/meriyah/meriyah/issues/690)) ([1f16445](https://github.com/meriyah/meriyah/commit/1f164456e95a4338d45a80d3bb6489e1802c2ae8))
+* **parser:** reject optional chains after a member expression in `new` without arguments ([#691](https://github.com/meriyah/meriyah/issues/691)) ([b299db5](https://github.com/meriyah/meriyah/commit/b299db5590d7789d048eb2cdc89669ac58219921))
+* **parser:** template literal inside parentheses should not be processed as tagged template ([#701](https://github.com/meriyah/meriyah/issues/701)) ([431f0f4](https://github.com/meriyah/meriyah/commit/431f0f42faa4b51b1b1480371a55033fc126f30a)), closes [#700](https://github.com/meriyah/meriyah/issues/700)
+
 ## [7.4.1](https://github.com/meriyah/meriyah/compare/v7.4.0...v7.4.1) (2026-10-25)
 
 ### Bug Fixes

package/dist/meriyah.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var version$1 = "7.4.1";
+var version$1 = "7.4.2";
 var packageJson = {
 	version: version$1};
 
@@ -1888,7 +1888,9 @@ function scanSingleToken(parser, context, state) {
                         }
                         if (ch === 33) {
                             const index = parser.index + 1;
-                            if (index + 1 < parser.end &&
+                            if (parser.options.webcompat &&
+                                !(context & 2) &&
+                                index + 1 < parser.end &&
                                 source.charCodeAt(index) === 45 &&
                                 source.charCodeAt(index + 1) == 45) {
                                 parser.column += 3;
@@ -1970,7 +1972,10 @@ function scanSingleToken(parser, context, state) {
                     const ch = parser.currentChar;
                     if (ch === 45) {
                         advanceChar(parser);
-                        if ((state & 1 || isStartOfLine) && parser.currentChar === 62) {
+                        if (parser.currentChar === 62 &&
+                            (state & 1 ||
+                                isStartOfLine ||
+                                (parser.getToken() === 1048576 && parser.line > 1))) {
                             if (!parser.options.webcompat)
                                 parser.report(114);
                             advanceChar(parser);
@@ -2242,10 +2247,10 @@ function validateFunctionName(parser, context, t) {
     if ((t & 20480) === 20480) {
         parser.report(102);
     }
-    if (context & (2048 | 2) && t === 209006) {
+    if (context & (2048 | 2) && (t & 2147483647) === 209006) {
         parser.report(112);
     }
-    if (context & (1024 | 1) && t === 241771) {
+    if (context & (1024 | 1) && (t & 2147483647) === 241771) {
         parser.report(97, 'yield');
     }
 }
@@ -2305,7 +2310,8 @@ function isValidIdentifier(context, t) {
             return false;
         if (context & 1024 && t === 241771)
             return false;
-        return (t & 12288) === 12288;
+        if (context & 1)
+            return (t & 12288) === 12288;
     }
     return (t & 12288) === 12288 || (t & 36864) === 36864;
 }
@@ -2759,12 +2765,14 @@ class PrivateScope {
         this.refs[name] ??= [];
         this.refs[name].push(this.parser.tokenStart);
     }
-    isPrivateIdentifierDefined(name) {
-        return this.hasPrivateIdentifier(name) || Boolean(this.parent?.isPrivateIdentifierDefined(name));
-    }
     validatePrivateIdentifierRefs() {
         for (const name in this.refs) {
-            if (!this.isPrivateIdentifierDefined(name)) {
+            if (this.hasPrivateIdentifier(name))
+                continue;
+            if (this.parent) {
+                (this.parent.refs[name] ??= []).push(...this.refs[name]);
+            }
+            else {
                 const { index, line, column } = this.refs[name][0];
                 throw new ParseError({ index, line, column }, { index: index + name.length, line, column: column + name.length }, 4, name);
             }
@@ -3185,7 +3193,7 @@ function parseStatementListItem(parser, context, scope, privateScope, labels, or
         case 86090:
             return parseLexicalDeclaration(parser, context, scope, privateScope, 16);
         case 241737:
-            return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin);
+            return parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, labels, origin);
         case 209013:
             return parseUsingDeclarationOrExpressionStatement(parser, context, scope, privateScope, labels, origin);
         case 209006:
@@ -3207,7 +3215,7 @@ function parseStatementListItem(parser, context, scope, privateScope, labels, or
                     parser.report(103, 'import');
             }
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 1, origin);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 1, 1, origin);
         default:
             return parseStatement(parser, context, scope, privateScope, labels, 1, origin);
     }
@@ -3245,7 +3253,7 @@ function parseStatement(parser, context, scope, privateScope, labels, allowFuncD
         case 20560:
             return parseDebuggerStatement(parser, context);
         case 209005:
-            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 0, origin);
+            return parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, 0, allowFuncDecl, origin);
         case 20557:
             parser.report(164);
         case 20566:
@@ -3275,7 +3283,7 @@ function parseExpressionOrLabelledStatement(parser, context, scope, privateScope
                 parser.report(84);
             break;
         default:
-            expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart, 0, 1);
+            expr = parsePrimaryExpression(parser, context, privateScope, 2, 0, 1, 0, 1, parser.tokenStart, 1, 1);
     }
     return finishExpressionOrLabelledStatement(parser, context, scope, privateScope, labels, allowFuncDecl, expr, token, tokenValue, tokenStart, origin);
 }
@@ -3339,17 +3347,17 @@ function parseLabelledStatement(parser, context, scope, privateScope, labels, va
         body,
     }, start);
 }
-function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, allowFuncDecl, origin) {
+function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, privateScope, labels, allowAsyncFuncDecl, 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, labels, tokenValue, expr, token, 1, start, origin);
+        return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, expr, token, allowFuncDecl, start, origin);
     }
     const asyncNewLine = parser.flags & 1;
     if (!asyncNewLine) {
         if (parser.getToken() === 86104) {
-            if (!allowFuncDecl)
+            if (!allowAsyncFuncDecl)
                 parser.report(125);
             return parseFunctionDeclaration(parser, context, scope, privateScope, 1, 0, 1, start, origin);
         }
@@ -3371,7 +3379,9 @@ function parseAsyncArrowOrAsyncFunctionDeclaration(parser, context, scope, priva
             }
             expr = parseArrowFromIdentifier(parser, context | 2048, privateScope, parser.tokenValue, expr, 0, 1, 0, start);
         }
-        parser.assignable = 1;
+        else {
+            parser.assignable = 1;
+        }
     }
     expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
     expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, expr);
@@ -3626,7 +3636,12 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
 }
 function parseStaticBlock(parser, context, scope, privateScope, start) {
     scope = scope?.createChildScope();
-    const ctorContext = 512 | 4096 | 1024 | 4 | 128;
+    const ctorContext = 512 |
+        4096 |
+        1024 |
+        4 |
+        128 |
+        32768;
     context =
         ((context | ctorContext) ^ ctorContext) |
             256 |
@@ -3650,7 +3665,7 @@ function parseDoWhileStatement(parser, context, scope, privateScope, labels) {
         test,
     }, start);
 }
-function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, origin) {
+function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateScope, labels, origin) {
     const { tokenValue, tokenStart, currentLocation } = parser;
     const token = parser.getToken();
     let expr = parseIdentifier(parser, context);
@@ -3668,7 +3683,7 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     if (context & 1)
         parser.report(85);
     if (parser.getToken() === 21) {
-        return parseLabelledStatement(parser, context, scope, privateScope, {}, tokenValue, expr, token, 0, tokenStart, origin);
+        return parseLabelledStatement(parser, context, scope, privateScope, labels, tokenValue, expr, token, 1, tokenStart, origin);
     }
     if (parser.getToken() === 10) {
         let scope = void 0;
@@ -3851,6 +3866,9 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
 function parseForStatement(parser, context, scope, privateScope, labels) {
     const start = parser.tokenStart;
     nextToken(parser, context);
+    if (context & 524288 && parser.getToken() === 209006) {
+        parser.report(179);
+    }
     const forAwait = ((context & 2048) > 0 || ((context & 2) > 0 && (context & 8) > 0)) &&
         consumeOpt(parser, context, 209006);
     consume(parser, context | 32, 67174411);
@@ -4330,7 +4348,9 @@ function parseImportMetaDeclaration(parser, context, start) {
 }
 function parseImportCallDeclaration(parser, context, privateScope, start) {
     let expr = parseImportExpression(parser, context, privateScope, 0, start);
+    parser.assignable = 2;
     expr = parseMemberOrUpdateExpression(parser, context, privateScope, expr, 0, 0, start);
+    expr = parseAssignmentExpression(parser, context, privateScope, 0, 0, start, expr);
     if (parser.getToken() === 18) {
         expr = parseSequenceExpression(parser, context, privateScope, 0, start, expr);
     }
@@ -4738,9 +4758,9 @@ function parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup
     }
     if (context & 1)
         parser.report(97, 'yield');
-    return parseIdentifierOrArrow(parser, context, privateScope);
+    return parseIdentifierOrArrow(parser, context, privateScope, 0, canAssign);
 }
-function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start) {
+function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, canAssign, start) {
     if (inGroup) {
         if ((parser.destructible & 128) === 0) {
             parser.firstAwaitLocation ??= { start, end: parser.currentLocation };
@@ -4751,10 +4771,11 @@ function parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew,
         parser.report(179);
     const isEscaped = (parser.getToken() & -2147483648) !== 0;
     const allowRegExp = !isEscaped && context & (2048 | 2) ? 1 : 0;
-    const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope, allowRegExp);
+    const possibleIdentifierOrArrowFunc = parseIdentifierOrArrow(parser, context, privateScope, allowRegExp, canAssign);
     const isIdentifier = isEscaped ||
         possibleIdentifierOrArrowFunc.type === 'ArrowFunctionExpression' ||
-        (parser.getToken() & 65536) === 0;
+        ((parser.getToken() & 65536) === 0 &&
+            (parser.getToken() & 36864) !== 36864);
     if (isIdentifier) {
         if (context & 2048)
             throw new ParseError(start, parser.startPosition, 178);
@@ -4874,8 +4895,11 @@ function parseLeftHandSideExpression(parser, context, privateScope, canAssign, i
     return parseMemberOrUpdateExpression(parser, context, privateScope, expression, inGroup, 0, start);
 }
 function parseUpdateExpression(parser, context, expr, start) {
-    if (parser.assignable & 2)
+    if (parser.assignable & 2 ||
+        expr.type === 'ArrayExpression' ||
+        expr.type === 'ObjectExpression') {
         parser.report(55);
+    }
     const token = parser.getToken();
     nextToken(parser, context);
     parser.assignable = 2;
@@ -4954,7 +4978,7 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                     parser.flags = (parser.flags | 2048) ^ 2048;
                 }
                 const args = parseArguments(parser, context, privateScope, inGroup);
-                if (!(context & 1) && parser.options.webcompat) {
+                if (!restoreHasOptionalChaining && !(context & 1) && parser.options.webcompat) {
                     parser.assignable = 4;
                 }
                 else {
@@ -5027,12 +5051,7 @@ function parseOptionalChain(parser, context, privateScope, expr, start) {
     }
     else if (parser.getToken() === 67174411) {
         const args = parseArguments(parser, context, privateScope, 0);
-        if (!(context & 1) && parser.options.webcompat) {
-            parser.assignable = 4;
-        }
-        else {
-            parser.assignable = 2;
-        }
+        parser.assignable = 2;
         node = parser.finishNode({
             type: 'CallExpression',
             callee: expr,
@@ -5091,7 +5110,7 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         switch (parser.getToken()) {
             case 209006:
             case 209006 | -2147483648:
-                return parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, start);
+                return parseAwaitExpressionOrIdentifier(parser, context, privateScope, inNew, inGroup, canAssign, start);
             case 241771:
                 return parseYieldExpressionOrIdentifier(parser, context, privateScope, inGroup, canAssign, start);
             case 209005:
@@ -5112,8 +5131,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
         if (context & 16 &&
             !(context & 32768) &&
             !(context & 8192) &&
-            parser.tokenValue === 'arguments')
-            parser.report(132);
+            parser.tokenValue === 'arguments' &&
+            !(origin & 1 && parser.getToken() === 21))
+            throw new ParseError(start, parser.startPosition, 132);
         if ((token & 255) === (241737 & 255)) {
             if (context & 1)
                 parser.report(115);
@@ -5148,7 +5168,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, start, origin);
+            return parseParenthesizedExpression(parser, context, privateScope, canAssign, 1, start, origin);
         case 86021:
         case 86022:
         case 86023:
@@ -5189,8 +5209,9 @@ function parsePrimaryExpression(parser, context, privateScope, kind, inNew, canA
             if (parser.options.jsx)
                 return parseJSXRootElementOrFragment(parser, context, privateScope, 0, parser.tokenStart);
         default:
-            if (isValidIdentifier(context, parser.getToken()))
-                return parseIdentifierOrArrow(parser, context, privateScope);
+            if (isValidIdentifier(context, parser.getToken())) {
+                return parseIdentifierOrArrow(parser, context, privateScope, 0, canAssign);
+            }
             parser.report(30, KeywordDescTable[parser.getToken() & 255]);
     }
 }
@@ -5591,6 +5612,8 @@ function parseArrayLiteral(parser, context, privateScope, skipInitializer, inGro
     if (parser.destructible & 8) {
         parser.report(62);
     }
+    if (expr.type === 'ArrayExpression')
+        parser.assignable = 2;
     return expr;
 }
 function parseArrayExpressionOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
@@ -5702,8 +5725,10 @@ function parseArrayExpressionOrPattern(parser, context, scope, privateScope, ski
                     parser.report(30, KeywordDescTable[parser.getToken() & 255]);
             }
             else {
-                left = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
+                left = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, context & 131072 ? 0 : 1);
                 if (parser.getToken() !== 18 && parser.getToken() !== 20) {
+                    if (parser.getToken() !== 1077936155)
+                        destructible |= 16;
                     left = parseAssignmentExpression(parser, context, privateScope, inGroup, isPattern, tokenStart, left);
                     if ((kind & (2 | 1)) === 0 && token === 67174411)
                         destructible |= 16;
@@ -5835,7 +5860,7 @@ function parseSpreadOrRestElement(parser, context, scope, privateScope, closingT
     }
     else {
         destructible |= 32;
-        argument = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
+        argument = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1, context & 131072 ? 0 : 1);
         const token = parser.getToken();
         if (token === 1077936155) {
             if (parser.assignable & 2)
@@ -5911,7 +5936,8 @@ function parseMethodDefinition(parser, context, privateScope, kind, inGroup, sta
     let scope = parser.createScopeIfLexical(256);
     const params = parseMethodFormals(parser, (context | 8192) & -524289, scope, privateScope, kind, 1, inGroup);
     scope = scope?.createChildScope(64);
-    const body = parseFunctionBody(parser, (context & -655373) |
+    const body = parseFunctionBody(parser, (context &
+        -655501) |
         32768 |
         4096, scope, privateScope, void 0, scope?.parent);
     return parser.finishNode({
@@ -5931,6 +5957,8 @@ function parseObjectLiteral(parser, context, privateScope, skipInitializer, inGr
     if (parser.destructible & 8) {
         parser.report(62);
     }
+    if (expr.type === 'ObjectExpression')
+        parser.assignable = 2;
     return expr;
 }
 function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipInitializer, inGroup, isPattern, kind, origin = 0) {
@@ -5960,6 +5988,11 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                     parser.getToken() === 1074790415 ||
                     parser.getToken() === 1077936155) {
                     state |= 4;
+                    if (context & 16 &&
+                        !(context & 32768) &&
+                        !(context & 8192) &&
+                        tokenValue === 'arguments')
+                        throw new ParseError(tokenStart, currentLocation, 132);
                     if (context & 1 && (token & 537079808) === 537079808) {
                         destructible |= 16;
                     }
@@ -6073,7 +6106,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, inGroup, 1, context & 131072 ? 0 : 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -6254,7 +6287,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, context & 131072 ? 0 : 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -6367,7 +6400,7 @@ function parseObjectLiteralOrPattern(parser, context, scope, privateScope, skipI
                         }
                     }
                     else {
-                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1);
+                        value = parseLeftHandSideExpression(parser, context, privateScope, 1, 0, 1, context & 131072 ? 0 : 1);
                         destructible |=
                             parser.assignable & 1
                                 ? 32
@@ -6500,7 +6533,7 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
                     parser.flags |= 512;
                 }
             }
-            left = parseAndClassifyIdentifier(parser, context, scope, kind | 1);
+            left = parseAndClassifyIdentifier(parser, context, scope, type);
         }
         else {
             if (parser.getToken() === 2162700) {
@@ -6654,7 +6687,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
                     expressions: expressions,
                 }, tokenAfterParenthesesStart);
             }
-            consume(parser, context, 16);
+            consume(parser, context | 64, 16);
             parser.destructible = destructible | previousAwaitYield;
             if (previousFirstAwaitLocation) {
                 parser.firstAwaitLocation = previousFirstAwaitLocation;
@@ -6690,7 +6723,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
             expressions: expressions,
         }, tokenAfterParenthesesStart);
     }
-    consume(parser, context, 16);
+    consume(parser, context | 64, 16);
     if (destructible & 16 && destructible & 8)
         parser.report(153);
     destructible |=
@@ -6745,7 +6778,7 @@ function parseParenthesizedExpression(parser, context, privateScope, canAssign,
         }, parenthesesStart)
         : expr;
 }
-function parseIdentifierOrArrow(parser, context, privateScope, allowRegExp = 0) {
+function parseIdentifierOrArrow(parser, context, privateScope, allowRegExp = 0, canAssign = 1) {
     const { tokenValue, tokenStart, currentLocation } = parser;
     let isNonSimpleParameterList = 0;
     let hasStrictReserved = 0;
@@ -6758,6 +6791,8 @@ function parseIdentifierOrArrow(parser, context, privateScope, allowRegExp = 0)
     const expr = parseIdentifier(parser, context, allowRegExp);
     parser.assignable = 1;
     if (parser.getToken() === 10) {
+        if (!canAssign)
+            parser.report(57);
         const scope = parser.options.lexical
             ? createArrowHeadParsingScope(parser, context, tokenValue, tokenStart, currentLocation)
             : undefined;
@@ -6791,7 +6826,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
     if (parser.flags & 1)
         parser.report(48);
     consume(parser, context | 32, 10);
-    const modifierFlags = 1024 | 2048 | 8192 | 524288;
+    const modifierFlags = 1024 | 2048 | 8192 | 524288 | 8;
     context = ((context | modifierFlags) ^ modifierFlags) | (isAsync ? 2048 : 0);
     const expression = parser.getToken() !== 2162700;
     let body;
@@ -6804,7 +6839,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
     }
     else {
         scope = scope?.createChildScope(64);
-        const modifierFlags = 4 | 131072 | 8;
+        const modifierFlags = 4 | 128 | 131072 | 8;
         body = parseFunctionBody(parser, ((context | modifierFlags) ^ modifierFlags) | 4096, scope, privateScope, void 0, void 0, 16);
         switch (parser.getToken()) {
             case 69271571:
@@ -6814,7 +6849,9 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
                 parser.flags |= 8192;
                 break;
             case 67108877:
+            case 67108991:
             case 67174409:
+            case 67174408:
             case 22:
                 parser.report(119);
             case 67174411:
@@ -6971,9 +7008,9 @@ function parseNewExpression(parser, context, privateScope, inGroup) {
     }
     const expr = parsePrimaryExpression(parser, context, privateScope, 2, 1, 0, inGroup, 1, tokenStart);
     context = (context | 131072) ^ 131072;
+    const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
     if (parser.getToken() === 67108991)
         parser.report(170);
-    const callee = parseMemberExpressionNoCall(parser, context, privateScope, expr, inGroup, tokenStart);
     parser.assignable = 2;
     return parser.finishNode({
         type: 'NewExpression',
@@ -7443,8 +7480,6 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
     }
     else if (token === -2147483526) {
         key = parseIdentifier(parser, context);
-        if (parser.getToken() !== 67174411)
-            parser.report(30, KeywordDescTable[parser.getToken() & 255]);
     }
     else {
         parser.report(30, KeywordDescTable[parser.getToken() & 255]);
@@ -7460,7 +7495,7 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
         }
         else if (parser.getToken() === 69271571) {
             kind |= 2;
-            key = parseComputedPropertyName(parser, context, privateScope, 0);
+            key = parseComputedPropertyName(parser, inheritedContext, privateScope, 0);
         }
         else if (parser.getToken() === 131) {
             kind |= 8192;
@@ -7548,6 +7583,7 @@ function parsePropertyDefinition(parser, context, privateScope, key, state, deco
             2048 |
             8 |
             8192 |
+            32768 |
             ((state & 64) === 0 ? 512 | 16384 : 0);
         context =
             ((context | modifierFlags) ^ modifierFlags) |