meriyah 7.1.0 → 7.1.2

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [7.1.2](https://github.com/meriyah/meriyah/compare/v7.1.1...v7.1.2) (2026-07-11)
+
+### Bug Fixes
+
+* **lexer:** reject empty unicode code point escape \u{} ([#562](https://github.com/meriyah/meriyah/issues/562)) ([6dd2bba](https://github.com/meriyah/meriyah/commit/6dd2bba7bf9375f751ee9214526e4592702dab9d))
+* **parser:** mark template literal with substitutions as invalid assignment target ([#563](https://github.com/meriyah/meriyah/issues/563)) ([addcad6](https://github.com/meriyah/meriyah/commit/addcad684d5f1e13bcaebe8e97db7ca39370f603))
+* **parser:** parse get and set fields before generators ([#576](https://github.com/meriyah/meriyah/issues/576)) ([cad0605](https://github.com/meriyah/meriyah/commit/cad06053fc9ee16a2217f84ca46d45d9b25c17e7))
+* **parser:** treat let as identifier before in and instanceof ([#577](https://github.com/meriyah/meriyah/issues/577)) ([4a08591](https://github.com/meriyah/meriyah/commit/4a085918dce320f39b535a15eafb774a0b4b90b0))
+
+## [7.1.1](https://github.com/meriyah/meriyah/compare/v7.1.0...v7.1.1) (2026-07-05)
+
+
+### Bug Fixes
+
+* **lexer:** accept \8 and \9 escapes in sloppy mode ([#559](https://github.com/meriyah/meriyah/issues/559)) ([8938494](https://github.com/meriyah/meriyah/commit/893849491bb493cd7e72280e82c4fb344915a4cb))
+* **parser:** fix for-of initializer check ([#549](https://github.com/meriyah/meriyah/issues/549)) ([72952d1](https://github.com/meriyah/meriyah/commit/72952d144b5f8a2715c72ba54c50e42e987dc4a8)), closes [#548](https://github.com/meriyah/meriyah/issues/548)
+* **parser:** fix the invoke check after arrow function when newline is involved ([#551](https://github.com/meriyah/meriyah/issues/551)) ([c6904bc](https://github.com/meriyah/meriyah/commit/c6904bce68ec824ca7dc9a42a7e5eb6352eddd47))
+* **parser:** report strict reserved parameters at their original range ([#558](https://github.com/meriyah/meriyah/issues/558)) ([842e276](https://github.com/meriyah/meriyah/commit/842e2768bf76f920a303df375e07eb6dcd085fb1)), closes [#470](https://github.com/meriyah/meriyah/issues/470)
+
+
+
 # [7.1.0](https://github.com/meriyah/meriyah/compare/v7.0.0...v7.1.0) (2026-02-04)
 
 

package/README.md

@@ -26,6 +26,10 @@
 - No backtracking
 - Low memory usage
 
+### Not yet supported features:
+
+- [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management)
+
 ## ESNext Stage 3 features
 
 ### Supported stage 3 features:
@@ -33,12 +37,11 @@
 These features need to be enabled with the `next` option.
 
 - [Decorators](https://github.com/tc39/proposal-decorators)
-- [JSON Modules](https://github.com/tc39/proposal-json-modules)
 
 ### Not yet supported stage 3 features:
 
-- [Explicit resource management](https://github.com/tc39/proposal-explicit-resource-management)
-- [Source phase import](https://github.com/tc39/proposal-source-phase-imports)
+- [Source Phase Imports](https://github.com/tc39/proposal-source-phase-imports)
+- [Deferring Module Evaluation](https://github.com/tc39/proposal-defer-import-eval)
 
 ## RegExp support
 
@@ -80,8 +83,10 @@ The available options:
   // The flag to enable stage 3 support (ESNext), default `false`
   next: boolean;
 
-  // The flag to enable start, end offsets and range: [start, end] to each node, default `false`
-  ranges: boolean;
+  // Enable start/end offsets to each node, default `false`
+  // true: emit start, end, and range: [start, end] (backwards compatible)
+  // object: selectively enable { start, end, range } — e.g. { start: true, end: true }
+  ranges: boolean | { start?: boolean; end?: boolean; range?: boolean };
 
   // Enable web compatibility, default `false`
   webcompat: boolean;

package/dist/meriyah.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
-var version$1 = "7.1.0";
+var version$1 = "7.1.2";
+var packageJson = {
+	version: version$1};
 
 const unicodeLookup = ((compressed, lookup) => {
     const result = new Uint32Array(69632);
@@ -1520,12 +1522,14 @@ function parseEscape(parser, context, first, isTemplate = 0) {
             const ch = advanceChar(parser);
             if (parser.currentChar === 123) {
                 let code = 0;
+                let digits = 0;
                 while ((CharTypes[advanceChar(parser)] & 64) !== 0) {
                     code = (code << 4) | toHex(parser.currentChar);
                     if (code > 1114111)
                         return -5;
+                    digits++;
                 }
-                if (parser.currentChar < 1 || parser.currentChar !== 125) {
+                if (digits === 0 || parser.currentChar < 1 || parser.currentChar !== 125) {
                     return -4;
                 }
                 return code;
@@ -1550,7 +1554,7 @@ function parseEscape(parser, context, first, isTemplate = 0) {
         }
         case 56:
         case 57:
-            if (isTemplate || !parser.options.webcompat || context & 1)
+            if (isTemplate || context & 1)
                 return -3;
             parser.flags |= 4096;
         default:
@@ -4544,10 +4548,22 @@ function rescanJSXIdentifier(parser) {
     return parser.getToken();
 }
 
+function normalizeRanges(ranges) {
+    if (!ranges)
+        return undefined;
+    if (ranges === true)
+        return { start: true, end: true, range: true };
+    return {
+        start: ranges.start ?? false,
+        end: ranges.end ?? false,
+        range: ranges.range ?? false,
+    };
+}
 function normalizeOptions(rawOptions) {
     const options = {
         validateRegex: true,
         ...rawOptions,
+        ranges: normalizeRanges(rawOptions.ranges),
     };
     if (options.module && !options.sourceType) {
         options.sourceType = 'module';
@@ -4733,6 +4749,7 @@ class Parser {
     exportedBindings = new Set();
     assignable = 0;
     destructible = 0;
+    strictReservedRange = null;
     leadingDecorators = { decorators: [] };
     constructor(source, rawOptions = {}) {
         this.source = source;
@@ -4789,11 +4806,15 @@ class Parser {
         return { index: this.index, line: this.line, column: this.column };
     }
     finishNode(node, start, end) {
-        if (this.options.ranges) {
-            node.start = start.index;
+        const { ranges } = this.options;
+        if (ranges) {
             const endIndex = end ? end.index : this.startIndex;
-            node.end = endIndex;
-            node.range = [start.index, endIndex];
+            if (ranges.start)
+                node.start = start.index;
+            if (ranges.end)
+                node.end = endIndex;
+            if (ranges.range)
+                node.range = [start.index, endIndex];
         }
         if (this.options.loc) {
             node.loc = {
@@ -4844,8 +4865,14 @@ class Parser {
         return this.cloneLocationInformation({ ...original }, original);
     }
     cloneLocationInformation(node, original) {
-        if (this.options.ranges) {
-            node.range = [...original.range];
+        const { ranges } = this.options;
+        if (ranges) {
+            if (ranges.start)
+                node.start = original.start;
+            if (ranges.end)
+                node.end = original.end;
+            if (ranges.range)
+                node.range = [...original.range];
         }
         if (this.options.loc) {
             node.loc = {
@@ -4863,10 +4890,14 @@ function pushComment(comments, options) {
             type,
             value,
         };
-        if (options.ranges) {
-            comment.start = start;
-            comment.end = end;
-            comment.range = [start, end];
+        const { ranges } = options;
+        if (ranges) {
+            if (ranges.start)
+                comment.start = start;
+            if (ranges.end)
+                comment.end = end;
+            if (ranges.range)
+                comment.range = [start, end];
         }
         if (options.loc) {
             comment.loc = loc;
@@ -4879,10 +4910,14 @@ function pushToken(tokens, options) {
         const token = {
             token: type,
         };
-        if (options.ranges) {
-            token.start = start;
-            token.end = end;
-            token.range = [start, end];
+        const { ranges } = options;
+        if (ranges) {
+            if (ranges.start)
+                token.start = start;
+            if (ranges.end)
+                token.end = end;
+            if (ranges.range)
+                token.range = [start, end];
         }
         if (options.loc) {
             token.loc = loc;
@@ -4901,7 +4936,7 @@ function parseSource(source, rawOptions = {}, context = 0) {
         context |= 1;
     skipHashBang(parser);
     const scope = parser.createScopeIfLexical();
-    let body = [];
+    let body;
     let sourceType = 'script';
     if (context & 2) {
         sourceType = 'module';
@@ -5394,7 +5429,6 @@ function parseTryStatement(parser, context, scope, privateScope, labels) {
 }
 function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
     let param = null;
-    let additionalScope = scope;
     if (consumeOpt(parser, context, 67174411)) {
         scope = scope?.createChildScope(4);
         param = parseBindingPattern(parser, context, scope, privateScope, (parser.getToken() & 2097152) === 2097152
@@ -5408,7 +5442,7 @@ function parseCatchBlock(parser, context, scope, privateScope, labels, start) {
         }
         consume(parser, context | 32, 16);
     }
-    additionalScope = scope?.createChildScope(32);
+    const additionalScope = scope?.createChildScope(32);
     const body = parseBlock(parser, context, additionalScope, privateScope, { $: labels });
     return parser.finishNode({
         type: 'CatchClause',
@@ -5446,7 +5480,8 @@ function parseLetIdentOrVarDeclarationStatement(parser, context, scope, privateS
     const { tokenValue, tokenStart } = parser;
     const token = parser.getToken();
     let expr = parseIdentifier(parser, context);
-    if (parser.getToken() & (143360 | 2097152)) {
+    if (parser.getToken() & (143360 | 2097152) &&
+        (parser.getToken() & 20480) !== 20480) {
         const declarations = parseVariableDeclarationList(parser, context, scope, privateScope, 8, 0);
         matchOrInsertSemicolon(parser, context | 32);
         return parser.finishNode({
@@ -5521,7 +5556,7 @@ function parseVariableDeclaration(parser, context, scope, privateScope, kind, or
     if (parser.getToken() === 1077936155) {
         nextToken(parser, context | 32);
         init = parseExpression(parser, context, privateScope, 1, 0, parser.tokenStart);
-        if (origin & 32 || (token & 2097152) === 0) {
+        if (origin & 32) {
             if (parser.getToken() === 471156 ||
                 (parser.getToken() === 8673330 &&
                     (token & 2097152 || (kind & 4) === 0 || context & 1))) {
@@ -5559,18 +5594,13 @@ function parseForStatement(parser, context, scope, privateScope, labels) {
     if (isVarDecl) {
         if (token === 241737) {
             init = parseIdentifier(parser, context);
-            if (parser.getToken() & (143360 | 2097152)) {
-                if (parser.getToken() === 8673330) {
-                    if (context & 1)
-                        parser.report(67);
-                }
-                else {
-                    init = parser.finishNode({
-                        type: 'VariableDeclaration',
-                        kind: 'let',
-                        declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 8, 32),
-                    }, tokenStart);
-                }
+            if (parser.getToken() & (143360 | 2097152) &&
+                (parser.getToken() & 20480) !== 20480) {
+                init = parser.finishNode({
+                    type: 'VariableDeclaration',
+                    kind: 'let',
+                    declarations: parseVariableDeclarationList(parser, context | 131072, scope, privateScope, 8, 32),
+                }, tokenStart);
                 parser.assignable = 1;
             }
             else if (context & 1) {
@@ -5691,7 +5721,7 @@ function parseRestrictedIdentifier(parser, context, scope) {
 function parseImportDeclaration(parser, context, scope) {
     const start = parser.tokenStart;
     nextToken(parser, context);
-    let source = null;
+    let source;
     const { tokenStart } = parser;
     let specifiers = [];
     if (parser.getToken() === 134283267) {
@@ -6268,8 +6298,12 @@ function parseFunctionBody(parser, context, scope, privateScope, origin, funcNam
             }
             if (parser.flags & 512)
                 parser.report(119);
-            if (parser.flags & 256)
+            if (parser.flags & 256) {
+                if (parser.strictReservedRange) {
+                    throw new ParseError(parser.strictReservedRange[0], parser.strictReservedRange[1], 118);
+                }
                 parser.report(118);
+            }
         }
     }
     parser.flags =
@@ -6354,6 +6388,10 @@ function parseMemberOrUpdateExpression(parser, context, privateScope, expr, inGr
                 break;
             }
             case 69271571: {
+                if ((parser.flags & 8192) === 8192) {
+                    parser.flags = (parser.flags | 8192) ^ 8192;
+                    return expr;
+                }
                 let restoreHasOptionalChaining = false;
                 if ((parser.flags & 2048) === 2048) {
                     restoreHasOptionalChaining = true;
@@ -6776,6 +6814,7 @@ function parseTemplate(parser, context, privateScope) {
         consume(parser, context, 67174409);
         quasis.push(parseTemplateElement(parser, tokenValue, tokenRaw, tokenStart, true));
     }
+    parser.assignable = 2;
     return parser.finishNode({
         type: 'TemplateLiteral',
         expressions,
@@ -6792,11 +6831,16 @@ function parseTemplateElement(parser, cooked, raw, start, tail) {
         tail,
     }, start);
     const tailSize = tail ? 1 : 2;
-    if (parser.options.ranges) {
-        node.start += 1;
-        node.range[0] += 1;
-        node.end -= tailSize;
-        node.range[1] -= tailSize;
+    const { ranges } = parser.options;
+    if (ranges) {
+        if (ranges.start)
+            node.start += 1;
+        if (ranges.end)
+            node.end -= tailSize;
+        if (ranges.range) {
+            node.range[0] += 1;
+            node.range[1] -= tailSize;
+        }
     }
     if (parser.options.loc) {
         node.loc.start.column += 1;
@@ -7886,6 +7930,7 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
     consume(parser, context, 67174411);
     const params = [];
     parser.flags = (parser.flags | 128) ^ 128;
+    parser.strictReservedRange = null;
     if (parser.getToken() === 16) {
         if (kind & 512) {
             parser.report(37, 'Setter', 'one', '');
@@ -7909,6 +7954,7 @@ function parseMethodFormals(parser, context, scope, privateScope, kind, type, in
             if ((context & 1) === 0) {
                 if ((parser.getToken() & 36864) === 36864) {
                     parser.flags |= 256;
+                    parser.strictReservedRange ??= [tokenStart, parser.currentLocation];
                 }
                 if ((parser.getToken() & 537079808) === 537079808) {
                     parser.flags |= 512;
@@ -8193,6 +8239,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
                 if ((parser.flags & 1) === 0) {
                     parser.report(116);
                 }
+                parser.flags |= 8192;
                 break;
             case 67108877:
             case 67174409:
@@ -8223,6 +8270,7 @@ function parseArrowFunctionExpression(parser, context, scope, privateScope, para
 function parseFormalParametersOrFormalList(parser, context, scope, privateScope, inGroup, kind) {
     consume(parser, context, 67174411);
     parser.flags = (parser.flags | 128) ^ 128;
+    parser.strictReservedRange = null;
     const params = [];
     if (consumeOpt(parser, context, 16))
         return params;
@@ -8236,6 +8284,7 @@ function parseFormalParametersOrFormalList(parser, context, scope, privateScope,
             if ((context & 1) === 0) {
                 if ((token & 36864) === 36864) {
                     parser.flags |= 256;
+                    parser.strictReservedRange ??= [tokenStart, parser.currentLocation];
                 }
                 if ((token & 537079808) === 537079808) {
                     parser.flags |= 512;
@@ -8399,7 +8448,7 @@ function parseAsyncArrowOrCallExpression(parser, context, privateScope, callee,
         }, start);
     }
     let destructible = 0;
-    let expr = null;
+    let expr;
     let isNonSimpleParameterList = 0;
     parser.destructible =
         (parser.destructible | 256 | 128) ^
@@ -8709,6 +8758,9 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                 break;
             case 209008:
                 if (parser.getToken() !== 67174411) {
+                    if (parser.getToken() === 8391476 && parser.flags & 1) {
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
+                    }
                     if ((parser.getToken() & 1073741824) === 1073741824) {
                         return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
                     }
@@ -8717,6 +8769,9 @@ function parseClassElementList(parser, context, scope, privateScope, inheritedCo
                 break;
             case 209009:
                 if (parser.getToken() !== 67174411) {
+                    if (parser.getToken() === 8391476 && parser.flags & 1) {
+                        return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
+                    }
                     if ((parser.getToken() & 1073741824) === 1073741824) {
                         return parsePropertyDefinition(parser, context, privateScope, key, kind, decorators, start);
                     }
@@ -9179,7 +9234,7 @@ function parseJSXExpressionContainer(parser, context, privateScope, inJSXChild,
     const { tokenStart } = parser;
     if (parser.getToken() === 14)
         return parseJSXSpreadChild(parser, context, privateScope, start);
-    let expression = null;
+    let expression;
     if (parser.getToken() === 1074790415) {
         if (isAttr)
             parser.report(157);
@@ -9233,7 +9288,7 @@ function parseJSXIdentifier(parser, context) {
     }, start);
 }
 
-const version = version$1;
+const { version } = packageJson;
 function parseScript(source, options) {
     return parseSource(source, { ...options, sourceType: 'script' });
 }