miniread 1.116.2 → 1.117.0

package/dist/transforms-by-id/expand-special-number-literals/expand-special-number-literals-transform.js

@@ -1,5 +1,6 @@
 import { createRequire } from "node:module";
 import { getFilesToProcess } from "../../core/types.js";
+import { getSpecialNumberReplacement } from "./get-special-number-replacement.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -20,9 +21,6 @@ const containsDirectEval = (container) => {
             // bindings into the current function scope (which could shadow `Infinity`/`NaN`
             // and change the meaning of an identifier replacement).
             //
-            // Note: Even if `eval` is lexically shadowed, we can't reliably prove statically
-            // that it's not bound to the built-in eval at runtime (e.g. `const eval =
-            // globalThis.eval`). Be conservative and treat any `eval(...)` call as direct.
             found = true;
             callPath.stop();
         },
@@ -66,71 +64,39 @@ export const expandSpecialNumberLiteralsTransform = {
             traverse(fileInfo.ast, {
                 BinaryExpression(path) {
                     nodesVisited++;
-                    const { operator, left } = path.node;
-                    if (operator !== "/")
+                    if (path.node.operator !== "/")
                         return;
-                    // Babel types allow `PrivateName` as a BinaryExpression operand for `#x in obj`
-                    // brand checks (operator `in`). This guard is just to satisfy the type system.
-                    if (left.type === "PrivateName")
+                    if (path.node.left.type === "PrivateName")
                         return;
                     const leftPath = path.get("left");
                     const rightPath = path.get("right");
-                    // Avoid dropping side effects: `evaluate()` can be confident for expressions that
-                    // are not pure (e.g. `(foo(), 1) / 0`). Only rewrite when both sides are pure.
-                    if (!leftPath.isPure() || !rightPath.isPure())
-                        return;
-                    const leftEvaluation = leftPath.evaluate();
-                    if (!leftEvaluation.confident)
-                        return;
-                    if (typeof leftEvaluation.value !== "number")
-                        return;
-                    const leftValue = leftEvaluation.value;
                     const rightEvaluation = rightPath.evaluate();
                     if (!rightEvaluation.confident)
                         return;
                     if (typeof rightEvaluation.value !== "number")
                         return;
-                    const rightValue = rightEvaluation.value;
-                    if (!isDivisionByZero(rightValue))
+                    if (!isDivisionByZero(rightEvaluation.value))
                         return;
-                    const result = leftValue / rightValue;
-                    if (Number.isNaN(result)) {
-                        // `0/0` is unaffected by dynamic scope, but `NaN` can be shadowed via `with` and
-                        // sloppy direct `eval()` in this scope or any enclosing scope.
-                        if (isWithinWithStatement(path))
-                            return;
-                        if (isWithinSloppyDirectEvalScope(path))
-                            return;
-                        if (path.scope.hasBinding("NaN", true))
-                            return;
-                        path.replaceWith(t.identifier("NaN"));
-                        transformationsApplied++;
-                        return;
-                    }
-                    if (result === Infinity) {
-                        // `1/0` is unaffected by dynamic scope, but `Infinity` can be shadowed via `with` and
-                        // sloppy direct `eval()` in this scope or any enclosing scope.
-                        if (isWithinWithStatement(path))
-                            return;
-                        if (isWithinSloppyDirectEvalScope(path))
-                            return;
-                        if (path.scope.hasBinding("Infinity", true))
-                            return;
-                        path.replaceWith(t.identifier("Infinity"));
-                        transformationsApplied++;
-                        return;
-                    }
-                    if (result === -Infinity) {
-                        if (isWithinWithStatement(path))
-                            return;
-                        if (isWithinSloppyDirectEvalScope(path))
-                            return;
-                        if (path.scope.hasBinding("Infinity", true))
-                            return;
-                        path.replaceWith(t.unaryExpression("-", t.identifier("Infinity")));
-                        transformationsApplied++;
+                    const leftEvaluation = leftPath.evaluate();
+                    const leftValue = leftEvaluation.confident && typeof leftEvaluation.value === "number"
+                        ? leftEvaluation.value
+                        : undefined;
+                    const replacement = getSpecialNumberReplacement({
+                        left: path.node.left,
+                        leftIsPure: leftPath.isPure(),
+                        right: path.node.right,
+                        rightIsPure: rightPath.isPure(),
+                        rightValue: rightEvaluation.value,
+                        leftValue,
+                        path,
+                        t,
+                        isWithinWithStatement,
+                        isWithinSloppyDirectEvalScope,
+                    });
+                    if (!replacement)
                         return;
-                    }
+                    path.replaceWith(replacement);
+                    transformationsApplied++;
                 },
             });
         }

package/dist/transforms-by-id/expand-special-number-literals/get-special-number-replacement.d.ts

@@ -0,0 +1,22 @@
+import type { NodePath } from "@babel/traverse";
+import type { BinaryExpression, Expression } from "@babel/types";
+type BabelTypesApi = {
+    identifier: (name: string) => Expression;
+    unaryExpression: (operator: "-", argument: Expression) => Expression;
+    sequenceExpression: (expressions: Expression[]) => Expression;
+    binaryExpression: (operator: "*", left: Expression, right: Expression) => Expression;
+};
+type GetSpecialNumberReplacementArguments = {
+    left: Expression;
+    leftIsPure: boolean;
+    right: Expression;
+    rightIsPure: boolean;
+    rightValue: number;
+    leftValue: number | undefined;
+    path: NodePath<BinaryExpression>;
+    t: BabelTypesApi;
+    isWithinWithStatement: (path: NodePath) => boolean;
+    isWithinSloppyDirectEvalScope: (path: NodePath) => boolean;
+};
+export declare const getSpecialNumberReplacement: (arguments_: GetSpecialNumberReplacementArguments) => Expression | undefined;
+export {};

package/dist/transforms-by-id/expand-special-number-literals/get-special-number-replacement.js

@@ -0,0 +1,66 @@
+const hasUnsafeInfinityScope = (path, isWithinWithStatement, isWithinSloppyDirectEvalScope) => {
+    if (isWithinWithStatement(path))
+        return true;
+    if (isWithinSloppyDirectEvalScope(path))
+        return true;
+    return path.scope.hasBinding("Infinity", true);
+};
+const hasUnsafeNaNScope = (path, isWithinWithStatement, isWithinSloppyDirectEvalScope) => {
+    if (isWithinWithStatement(path))
+        return true;
+    if (isWithinSloppyDirectEvalScope(path))
+        return true;
+    return path.scope.hasBinding("NaN", true);
+};
+const createInfinityProduct = (arguments_) => {
+    if (Object.is(arguments_.rightValue, -0)) {
+        return arguments_.t.binaryExpression("*", arguments_.left, arguments_.t.unaryExpression("-", arguments_.t.identifier("Infinity")));
+    }
+    return arguments_.t.binaryExpression("*", arguments_.left, arguments_.t.identifier("Infinity"));
+};
+const withSideEffectsPreserved = (arguments_, replacement) => {
+    if (arguments_.leftIsPure && arguments_.rightIsPure)
+        return replacement;
+    const expressions = [];
+    if (!arguments_.leftIsPure)
+        expressions.push(arguments_.left);
+    if (!arguments_.rightIsPure)
+        expressions.push(arguments_.right);
+    expressions.push(replacement);
+    return arguments_.t.sequenceExpression(expressions);
+};
+export const getSpecialNumberReplacement = (arguments_) => {
+    if (arguments_.leftValue === undefined) {
+        if (!arguments_.leftIsPure)
+            return undefined;
+        // Replacement still evaluates `left`; skip when `right` has side effects so
+        // we do not reorder runtime evaluation from `left`-then-`right` to
+        // `right`-then-`left`.
+        if (!arguments_.rightIsPure)
+            return undefined;
+        if (hasUnsafeInfinityScope(arguments_.path, arguments_.isWithinWithStatement, arguments_.isWithinSloppyDirectEvalScope)) {
+            return undefined;
+        }
+        return withSideEffectsPreserved(arguments_, createInfinityProduct(arguments_));
+    }
+    const result = arguments_.leftValue / arguments_.rightValue;
+    if (Number.isNaN(result)) {
+        if (hasUnsafeNaNScope(arguments_.path, arguments_.isWithinWithStatement, arguments_.isWithinSloppyDirectEvalScope)) {
+            return undefined;
+        }
+        return withSideEffectsPreserved(arguments_, arguments_.t.identifier("NaN"));
+    }
+    if (result === Infinity) {
+        if (hasUnsafeInfinityScope(arguments_.path, arguments_.isWithinWithStatement, arguments_.isWithinSloppyDirectEvalScope)) {
+            return undefined;
+        }
+        return withSideEffectsPreserved(arguments_, arguments_.t.identifier("Infinity"));
+    }
+    if (result === -Infinity) {
+        if (hasUnsafeInfinityScope(arguments_.path, arguments_.isWithinWithStatement, arguments_.isWithinSloppyDirectEvalScope)) {
+            return undefined;
+        }
+        return withSideEffectsPreserved(arguments_, arguments_.t.unaryExpression("-", arguments_.t.identifier("Infinity")));
+    }
+    return withSideEffectsPreserved(arguments_, createInfinityProduct(arguments_));
+};

package/dist/transforms-by-id/expand-special-number-literals/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Auto-added by evaluation script.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:16:49.085Z",
-            "changedLines": 310,
-            "durationSeconds": 206.054788542,
+            "evaluatedAt": "2026-02-21T16:47:56.238Z",
+            "changedLines": 314,
+            "durationSeconds": 40.9949115,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-charcode-variables-v2/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Derives names from charCodeAt argument for better stability (e.g., $charCodeAtIndex, $charCodeAtIndexPlus1).",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:19:25.440Z",
-            "changedLines": 238,
-            "durationSeconds": 150.12261538,
-            "stableNames": 1367
+            "evaluatedAt": "2026-02-21T15:11:23.165Z",
+            "changedLines": 292,
+            "durationSeconds": 192.198072639,
+            "stableNames": 1370
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-charcode-variables-v2/rename-charcode-variables-v2-transform.js

@@ -55,6 +55,19 @@ const getArgumentSuffix = (expression, depth = 0) => {
             }
         }
     }
+    // Member expression: charCodeAt(cursor.pos) → "Pos"
+    if (expression.type === "MemberExpression") {
+        if (expression.property.type === "Identifier") {
+            return capitalize(expression.property.name);
+        }
+        if (expression.property.type === "NumericLiteral") {
+            if (Number.isInteger(expression.property.value) &&
+                expression.property.value >= 0) {
+                return String(expression.property.value);
+            }
+            return undefined;
+        }
+    }
     return undefined;
 };
 /**

package/dist/transforms-by-id/rename-file-extension-variables/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 100.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:35:34.320Z",
-            "changedLines": 4,
-            "durationSeconds": 315.94628195100006,
+            "evaluatedAt": "2026-02-21T17:06:33.862Z",
+            "changedLines": 40,
+            "durationSeconds": 27.991182833,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-file-extension-variables/match-file-extension-expression.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const isFileExtensionExpression: (expression: Expression) => boolean;

package/dist/transforms-by-id/rename-file-extension-variables/match-file-extension-expression.js

@@ -0,0 +1,145 @@
+import * as t from "@babel/types";
+const unwrapExpressionWithStringFallback = (expression) => {
+    if (!t.isLogicalExpression(expression))
+        return undefined;
+    if (expression.operator !== "||" && expression.operator !== "??") {
+        return undefined;
+    }
+    if (!t.isStringLiteral(expression.right))
+        return undefined;
+    return expression.left;
+};
+const getMemberPropertyName = (callee) => {
+    if (t.isIdentifier(callee.property))
+        return callee.property.name;
+    if (callee.computed && t.isStringLiteral(callee.property)) {
+        return callee.property.value;
+    }
+    return undefined;
+};
+const getCallTarget = (expression, propertyName, argumentsLength) => {
+    if (t.isCallExpression(expression)) {
+        if (expression.arguments.length !== argumentsLength)
+            return undefined;
+        if (!t.isMemberExpression(expression.callee))
+            return undefined;
+        const property = getMemberPropertyName(expression.callee);
+        if (property !== propertyName)
+            return undefined;
+        if (t.isSuper(expression.callee.object))
+            return undefined;
+        return expression.callee.object;
+    }
+    if (t.isOptionalCallExpression(expression)) {
+        if (expression.arguments.length !== argumentsLength)
+            return undefined;
+        if (!t.isOptionalMemberExpression(expression.callee))
+            return undefined;
+        const property = getMemberPropertyName(expression.callee);
+        if (property !== propertyName)
+            return undefined;
+        if (t.isSuper(expression.callee.object))
+            return undefined;
+        return expression.callee.object;
+    }
+    return undefined;
+};
+const isPathExtnameCall = (expression) => {
+    if (!t.isCallExpression(expression) &&
+        !t.isOptionalCallExpression(expression)) {
+        return false;
+    }
+    if (expression.arguments.length !== 1)
+        return false;
+    const callee = expression.callee;
+    if (!t.isMemberExpression(callee) && !t.isOptionalMemberExpression(callee)) {
+        return false;
+    }
+    const property = getMemberPropertyName(callee);
+    return property === "extname";
+};
+const isSplitDotCall = (expression) => {
+    if (!t.isCallExpression(expression) &&
+        !t.isOptionalCallExpression(expression)) {
+        return false;
+    }
+    const splitTarget = getCallTarget(expression, "split", 1);
+    if (!splitTarget)
+        return false;
+    const [delimiter] = expression.arguments;
+    if (!delimiter || !t.isStringLiteral(delimiter))
+        return false;
+    return delimiter.value === ".";
+};
+const getSliceOneTarget = (expression) => {
+    const sliceTarget = getCallTarget(expression, "slice", 1);
+    if (!sliceTarget)
+        return undefined;
+    if (!t.isCallExpression(expression) &&
+        !t.isOptionalCallExpression(expression)) {
+        return undefined;
+    }
+    const [sliceStart] = expression.arguments;
+    if (!sliceStart || !t.isExpression(sliceStart))
+        return undefined;
+    if (!t.isNumericLiteral(sliceStart))
+        return undefined;
+    if (sliceStart.value !== 1)
+        return undefined;
+    return sliceTarget;
+};
+const isNegativeOne = (expression) => {
+    return t.isNumericLiteral(expression)
+        ? expression.value === -1
+        : t.isUnaryExpression(expression) &&
+            expression.operator === "-" &&
+            t.isNumericLiteral(expression.argument) &&
+            expression.argument.value === 1;
+};
+const isSplitAtLastExpression = (expression) => {
+    const atTarget = getCallTarget(expression, "at", 1);
+    if (!atTarget)
+        return false;
+    if (!t.isCallExpression(expression) &&
+        !t.isOptionalCallExpression(expression)) {
+        return false;
+    }
+    const [atIndex] = expression.arguments;
+    if (!atIndex || !t.isExpression(atIndex))
+        return false;
+    if (!isNegativeOne(atIndex))
+        return false;
+    return isSplitDotCall(atTarget);
+};
+const isPathExtnameDerivedExpression = (expression) => {
+    if (isPathExtnameCall(expression))
+        return true;
+    const lowerTarget = getCallTarget(expression, "toLowerCase", 0);
+    if (lowerTarget && isPathExtnameCall(lowerTarget))
+        return true;
+    const sliceTarget = getSliceOneTarget(expression);
+    if (sliceTarget && isPathExtnameCall(sliceTarget))
+        return true;
+    if (sliceTarget) {
+        const lowerBeforeSlice = getCallTarget(sliceTarget, "toLowerCase", 0);
+        if (lowerBeforeSlice && isPathExtnameCall(lowerBeforeSlice))
+            return true;
+    }
+    if (lowerTarget) {
+        const sliceBeforeLower = getSliceOneTarget(lowerTarget);
+        if (sliceBeforeLower && isPathExtnameCall(sliceBeforeLower))
+            return true;
+    }
+    return false;
+};
+export const isFileExtensionExpression = (expression) => {
+    const normalized = unwrapExpressionWithStringFallback(expression) ?? expression;
+    if (isPathExtnameDerivedExpression(normalized))
+        return true;
+    const lowerTarget = getCallTarget(normalized, "toLowerCase", 0);
+    const extractionTarget = lowerTarget ?? normalized;
+    const popTarget = getCallTarget(extractionTarget, "pop", 0);
+    if (popTarget)
+        return isSplitDotCall(popTarget);
+    return isSplitAtLastExpression(extractionTarget);
+};

package/dist/transforms-by-id/rename-file-extension-variables/rename-file-extension-variables-transform.js

@@ -2,74 +2,18 @@ import { createRequire } from "node:module";
 import * as t from "@babel/types";
 import { RenameGroup, isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess } from "../../core/types.js";
+import { isFileExtensionExpression } from "./match-file-extension-expression.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const unwrapExpressionWithStringFallback = (expression) => {
-    if (!t.isLogicalExpression(expression))
-        return undefined;
-    if (expression.operator !== "||" && expression.operator !== "??") {
-        return undefined;
-    }
-    if (!t.isStringLiteral(expression.right))
-        return undefined;
-    return expression.left;
-};
-const getMemberPropertyName = (callee) => {
-    if (t.isIdentifier(callee.property))
-        return callee.property.name;
-    if (callee.computed && t.isStringLiteral(callee.property)) {
-        return callee.property.value;
-    }
-    return undefined;
-};
-const getCallTarget = (expression, propertyName, argumentsLength) => {
-    if (t.isCallExpression(expression)) {
-        if (expression.arguments.length !== argumentsLength)
-            return undefined;
-        if (!t.isMemberExpression(expression.callee))
-            return undefined;
-        const property = getMemberPropertyName(expression.callee);
-        if (property !== propertyName)
-            return undefined;
-        if (t.isSuper(expression.callee.object))
-            return undefined;
-        return expression.callee.object;
-    }
-    if (t.isOptionalCallExpression(expression)) {
-        if (expression.arguments.length !== argumentsLength)
-            return undefined;
-        if (!t.isOptionalMemberExpression(expression.callee))
-            return undefined;
-        const property = getMemberPropertyName(expression.callee);
-        if (property !== propertyName)
-            return undefined;
-        if (t.isSuper(expression.callee.object))
-            return undefined;
-        return expression.callee.object;
-    }
-    return undefined;
-};
-const isFileExtensionExpression = (expression) => {
-    const normalized = unwrapExpressionWithStringFallback(expression);
-    if (!normalized)
-        return false;
-    const lowerTarget = getCallTarget(normalized, "toLowerCase", 0);
-    const popTarget = lowerTarget ?? normalized;
-    const splitTarget = getCallTarget(popTarget, "pop", 0);
-    if (!splitTarget)
-        return false;
-    const splitCallTarget = getCallTarget(splitTarget, "split", 1);
-    if (!splitCallTarget)
-        return false;
-    if (!t.isCallExpression(splitTarget) &&
-        !t.isOptionalCallExpression(splitTarget)) {
-        return false;
-    }
-    const [delimiter] = splitTarget.arguments;
-    if (!delimiter || !t.isStringLiteral(delimiter))
-        return false;
-    return delimiter.value === ".";
+const addRenameCandidate = (currentName, scope, group) => {
+    if (isStableRenamed(currentName))
+        return;
+    group.add({
+        scope,
+        currentName,
+        baseName: "fileExtension",
+    });
 };
 const collectFileExtensionParameterRenames = (path, group) => {
     for (const parameter of path.node.params) {
@@ -79,19 +23,7 @@ const collectFileExtensionParameterRenames = (path, group) => {
             continue;
         if (!isFileExtensionExpression(parameter.right))
             continue;
-        const currentName = parameter.left.name;
-        if (isStableRenamed(currentName))
-            continue;
-        if (currentName === "fileExtension")
-            continue;
-        const binding = path.scope.getBinding(currentName);
-        if (!binding?.constant)
-            continue;
-        group.add({
-            scope: path.scope,
-            currentName,
-            baseName: "fileExtension",
-        });
+        addRenameCandidate(parameter.left.name, path.scope, group);
     }
 };
 export const renameFileExtensionVariablesTransform = {
@@ -126,20 +58,7 @@ export const renameFileExtensionVariablesTransform = {
                         return;
                     if (!isFileExtensionExpression(init))
                         return;
-                    const currentName = id.name;
-                    if (isStableRenamed(currentName))
-                        return;
-                    if (currentName === "fileExtension")
-                        return;
-                    const binding = path.scope.getBinding(currentName);
-                    if (!binding?.constant)
-                        return;
-                    const scope = path.scope;
-                    group.add({
-                        scope,
-                        currentName,
-                        baseName: "fileExtension",
-                    });
+                    addRenameCandidate(id.name, path.scope, group);
                 },
             });
             transformationsApplied += group.apply();

package/dist/transforms-by-id/rename-parameters-to-match-properties-v2/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Extends v1 to also handle this.property = param assignments.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99057581754784,
-            "evaluatedAt": "2026-02-07T21:11:38.249Z",
-            "changedLines": 20501,
-            "durationSeconds": 241.015244141,
+            "diffSizePercent": 99.99244056393393,
+            "evaluatedAt": "2026-02-21T16:50:11.730Z",
+            "changedLines": 20517,
+            "durationSeconds": 41.078400416,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js

@@ -5,6 +5,25 @@ import { isStableRenamed } from "../../core/stable-naming.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const hasUnresolvedGlobalReference = (functionPath, name) => {
+    let found = false;
+    functionPath.traverse({
+        Identifier(identifierPath) {
+            if (found) {
+                identifierPath.skip();
+                return;
+            }
+            if (identifierPath.node.name !== name)
+                return;
+            if (!identifierPath.isReferencedIdentifier())
+                return;
+            if (identifierPath.scope.hasBinding(name))
+                return;
+            found = true;
+        },
+    });
+    return found;
+};
 export const renameParametersToMatchPropertiesV2Transform = {
     id: "rename-parameters-to-match-properties-v2",
     description: "Renames parameters assigned to object properties or this.property",
@@ -77,11 +96,6 @@ export const renameParametersToMatchPropertiesV2Transform = {
                             }
                         }
                         if (candidateName) {
-                            // Check global references (conservative: if file uses 'console', don't use 'console')
-                            const programScope = path.scope.getProgramParent();
-                            if (Object.hasOwn(programScope.globals, candidateName)) {
-                                isConsistent = false;
-                            }
                             // Check for nested scope shadowing
                             // If we rename `a` -> `b`, and a nested scope has `b` bound,
                             // and we use `a` in that nested scope, it will become `b` (referring to inner `b`).
@@ -90,6 +104,10 @@ export const renameParametersToMatchPropertiesV2Transform = {
                             if (wouldBeShadowed) {
                                 isConsistent = false;
                             }
+                            if (isConsistent &&
+                                hasUnresolvedGlobalReference(path, candidateName)) {
+                                isConsistent = false;
+                            }
                         }
                         // Constraints:
                         // 1. New name must be valid identifier

package/dist/transforms-by-id/rename-regex-builders/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:20:54.287Z",
-            "changedLines": 6,
-            "durationSeconds": 193.29200997400002,
-            "stableNames": 1358
+            "evaluatedAt": "2026-02-21T16:55:47.330Z",
+            "changedLines": 66,
+            "durationSeconds": 33.044639417,
+            "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-regex-builders/rename-regex-builders-transform.js

@@ -6,10 +6,24 @@ import { isRegexBuilderObject } from "./is-regex-builder-object.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const BASE_NAME = "regexBuilder";
+const BUILDER_BASE_NAME = "regexBuilder";
+const FACTORY_BASE_NAME = "createRegexBuilder";
+const getReturnedObjectBindingName = (functionPath) => {
+    const bodyPath = functionPath.get("body");
+    const statements = bodyPath.get("body");
+    for (const statementPath of statements) {
+        if (!statementPath.isReturnStatement())
+            continue;
+        const argumentPath = statementPath.get("argument");
+        if (!argumentPath.isIdentifier())
+            continue;
+        return argumentPath.node.name;
+    }
+    return undefined;
+};
 export const renameRegexBuildersTransform = {
     id: "rename-regex-builders",
-    description: "Renames fluent regex builder objects to $regexBuilder/$regexBuilder2 when they expose replace() and getRegex().",
+    description: "Renames fluent regex builder objects and their factory functions to stable names.",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -35,12 +49,47 @@ export const renameRegexBuildersTransform = {
                         return;
                     if (!isRegexBuilderObject(initPath, id.name, binding))
                         return;
-                    if (path.scope.hasBinding("RegExp", true))
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BUILDER_BASE_NAME,
+                    });
+                },
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (!id)
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    const functionBinding = path.scope.getBinding(id.name);
+                    if (!functionBinding)
+                        return;
+                    const returnedBindingName = getReturnedObjectBindingName(path);
+                    if (!returnedBindingName)
+                        return;
+                    const returnedBinding = path.scope.getBinding(returnedBindingName);
+                    if (!returnedBinding)
+                        return;
+                    const functionScope = path.get("body").scope;
+                    if (returnedBinding.scope.getFunctionParent() !== functionScope) {
+                        return;
+                    }
+                    if (!returnedBinding.constant)
+                        return;
+                    const bindingPath = returnedBinding.path;
+                    if (!bindingPath.isVariableDeclarator())
+                        return;
+                    const initPath = bindingPath.get("init");
+                    if (!initPath.isObjectExpression())
+                        return;
+                    if (!isRegexBuilderObject(initPath, returnedBindingName, returnedBinding)) {
                         return;
+                    }
                     group.add({
                         scope: path.scope,
                         currentName: id.name,
-                        baseName: BASE_NAME,
+                        baseName: FACTORY_BASE_NAME,
                     });
                 },
             });

package/dist/transforms-by-id/rename-this-aliases/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99623032701913,
-            "evaluatedAt": "2026-02-07T21:13:14.820Z",
-            "changedLines": 1382,
-            "durationSeconds": 159.934804951,
+            "diffSizePercent": 99.99622028196697,
+            "evaluatedAt": "2026-02-21T16:46:34.305Z",
+            "changedLines": 1729,
+            "durationSeconds": 44.609521334,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-this-aliases/rename-this-aliases-transform.js

@@ -31,8 +31,6 @@ export const renameThisAliasesTransform = {
                     const binding = path.scope.getBinding(currentName);
                     if (!binding)
                         return;
-                    if (!binding.constant)
-                        return;
                     if (binding.scope.block.type === "Program" &&
                         exportedNames.has(currentName)) {
                         return;

package/dist/transforms-by-id/rename-to-buffer-results/manifest.json

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:21:20.792Z",
-            "changedLines": 56,
-            "durationSeconds": 161.838725924,
+            "diffSizePercent": 99.98299126885134,
+            "evaluatedAt": "2026-02-21T16:54:10.786Z",
+            "changedLines": 392,
+            "durationSeconds": 50.692648416000004,
             "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-to-buffer-results/rename-to-buffer-results-transform.js

@@ -4,6 +4,17 @@ import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const isBufferFromCall = (callee) => {
+    if (callee.type !== "MemberExpression") {
+        return false;
+    }
+    if (callee.computed || callee.object.type !== "Identifier") {
+        return false;
+    }
+    return (callee.object.name === "Buffer" &&
+        callee.property.type === "Identifier" &&
+        callee.property.name === "from");
+};
 const isToBufferCall = (callee) => {
     if (callee.type !== "MemberExpression" &&
         callee.type !== "OptionalMemberExpression") {
@@ -23,9 +34,51 @@ const isToBufferCall = (callee) => {
     }
     return (callee.property.type === "Identifier" && callee.property.name === "toBuffer");
 };
+const isBufferProducingCall = (callExpression) => {
+    return (isToBufferCall(callExpression.callee) ||
+        (callExpression.type === "CallExpression" &&
+            isBufferFromCall(callExpression.callee)));
+};
+const getBufferProducingCallExpression = (expression) => {
+    if (expression.type === "CallExpression" ||
+        expression.type === "OptionalCallExpression") {
+        return isBufferProducingCall(expression) ? expression : undefined;
+    }
+    if (expression.type !== "AwaitExpression") {
+        return undefined;
+    }
+    if (expression.argument.type !== "CallExpression" &&
+        expression.argument.type !== "OptionalCallExpression") {
+        return undefined;
+    }
+    return isBufferProducingCall(expression.argument)
+        ? expression.argument
+        : undefined;
+};
+const queueBufferRename = (path, renameGroup, queuedBindings, currentName) => {
+    if (isStableRenamed(currentName)) {
+        return;
+    }
+    if (currentName.toLowerCase().includes("buffer")) {
+        return;
+    }
+    const binding = path.scope.getBinding(currentName);
+    if (!binding) {
+        return;
+    }
+    if (queuedBindings.has(binding)) {
+        return;
+    }
+    queuedBindings.add(binding);
+    renameGroup.add({
+        scope: path.scope,
+        currentName,
+        baseName: "buffer",
+    });
+};
 export const renameToBufferResultsTransform = {
     id: "rename-to-buffer-results",
-    description: "Renames variables assigned from toBuffer() results to buffer",
+    description: "Renames variables assigned from toBuffer()/Buffer.from() results to buffer",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -33,6 +86,7 @@ export const renameToBufferResultsTransform = {
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
             const renameGroup = new RenameGroup();
+            const queuedBindings = new Set();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
@@ -40,40 +94,24 @@ export const renameToBufferResultsTransform = {
                     if (!init || id.type !== "Identifier") {
                         return;
                     }
-                    let callExpression;
-                    if (init.type === "CallExpression" ||
-                        init.type === "OptionalCallExpression") {
-                        callExpression = init;
-                    }
-                    else if (init.type === "AwaitExpression") {
-                        if (init.argument.type !== "CallExpression" &&
-                            init.argument.type !== "OptionalCallExpression") {
-                            return;
-                        }
-                        callExpression = init.argument;
-                    }
-                    else {
-                        return;
-                    }
-                    if (!isToBufferCall(callExpression.callee)) {
+                    if (!getBufferProducingCallExpression(init)) {
                         return;
                     }
-                    const currentName = id.name;
-                    if (isStableRenamed(currentName)) {
+                    queueBufferRename(path, renameGroup, queuedBindings, id.name);
+                },
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    const { left, operator, right } = path.node;
+                    if (operator !== "=") {
                         return;
                     }
-                    if (currentName.toLowerCase().includes("buffer")) {
+                    if (left.type !== "Identifier") {
                         return;
                     }
-                    const binding = path.scope.getBinding(currentName);
-                    if (!binding?.constant) {
+                    if (!getBufferProducingCallExpression(right)) {
                         return;
                     }
-                    renameGroup.add({
-                        scope: path.scope,
-                        currentName,
-                        baseName: "buffer",
-                    });
+                    queueBufferRename(path, renameGroup, queuedBindings, left.name);
                 },
             });
             transformationsApplied += renameGroup.apply();

package/dist/transforms-by-id/rename-use-reference-guards-v2/get-reference-usage.js

@@ -2,6 +2,12 @@ import { getMemberExpressionForReference } from "./get-member-expression-for-ref
 const getKnownBooleanValue = (expression) => {
     if (expression.type === "BooleanLiteral")
         return expression.value;
+    if (expression.type === "NumericLiteral") {
+        if (expression.value === 0)
+            return false;
+        if (expression.value === 1)
+            return true;
+    }
     if (expression.type === "UnaryExpression" &&
         expression.operator === "!" &&
         expression.argument.type === "NumericLiteral" &&
@@ -33,8 +39,6 @@ export const getReferenceUsage = (binding) => {
                 return { isSafe: false, hasRead, hasTrueWrite };
             const right = parentPath.node.right;
             const value = getKnownBooleanValue(right);
-            if (value === undefined)
-                return { isSafe: false, hasRead, hasTrueWrite };
             if (value) {
                 hasTrueWrite = true;
             }

package/dist/transforms-by-id/rename-use-reference-guards-v2/is-use-reference-false-initializer.js

@@ -1,6 +1,8 @@
 const isKnownFalseValue = (expression) => {
     if (expression.type === "BooleanLiteral")
         return !expression.value;
+    if (expression.type === "NumericLiteral")
+        return expression.value === 0;
     if (expression.type === "UnaryExpression" &&
         expression.operator === "!" &&
         expression.argument.type === "NumericLiteral" &&

package/dist/transforms-by-id/rename-use-reference-guards-v2/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Supersedes rename-use-reference-guards and also covers guards that reset to false.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-08T05:50:16.997Z",
-            "changedLines": 166,
-            "durationSeconds": 29.099741833,
-            "stableNames": 1358
+            "evaluatedAt": "2026-02-21T16:41:17.818Z",
+            "changedLines": 202,
+            "durationSeconds": 34.530502708,
+            "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js

@@ -7,9 +7,10 @@ const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
 const BASE_NAME = "hasRunRef";
+const SAFE_READ_ONLY_BASE_NAME = "guardRef";
 const renameUseReferenceGuardsV2Transform = {
     id: "rename-use-reference-guards-v2",
-    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to $hasRunRef/$hasRunRef2/... or hasRunRef/hasRunRef2/...",
+    description: "Renames safe useRef(false) guard variables: true-write guards to $hasRunRef/$hasRunRef2/... and read-only/false-only guards to $guardRef/$guardRef2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -34,12 +35,14 @@ const renameUseReferenceGuardsV2Transform = {
                         return;
                     const usage = getReferenceUsage(binding);
                     // Unlike v1, this version also accepts guards that reset to false
-                    if (!usage.isSafe || !usage.hasRead || !usage.hasTrueWrite)
+                    if (!usage.isSafe)
+                        return;
+                    if (!usage.hasRead)
                         return;
                     group.add({
                         scope: path.scope,
                         currentName: id.name,
-                        baseName: BASE_NAME,
+                        baseName: usage.hasTrueWrite ? BASE_NAME : SAFE_READ_ONLY_BASE_NAME,
                     });
                 },
             });

package/dist/transforms-by-id/use-optional-chaining/is-nullish-check.js

@@ -14,7 +14,8 @@ const mergeCoverage = (left, right) => {
 const getNullishCoverage = (test, identifierName) => {
     const unwrapped = unwrapParentheses(test);
     if (isBinaryExpression(unwrapped)) {
-        if (unwrapped.operator !== "===")
+        const operator = unwrapped.operator;
+        if (operator !== "===" && operator !== "==")
             return noCoverage;
         const getValueCoverage = (value) => {
             if (isPrivateName(value))
@@ -32,6 +33,23 @@ const getNullishCoverage = (test, identifierName) => {
         const right = unwrapped.right;
         if (isPrivateName(left))
             return noCoverage;
+        if (operator === "==") {
+            if (isIdentifier(left) && left.name === identifierName) {
+                const valueCoverage = getValueCoverage(right);
+                if (valueCoverage.coversNull) {
+                    return { coversNull: true, coversUndefined: true };
+                }
+            }
+            if (!isPrivateName(right) &&
+                isIdentifier(right) &&
+                right.name === identifierName) {
+                const valueCoverage = getValueCoverage(left);
+                if (valueCoverage.coversNull) {
+                    return { coversNull: true, coversUndefined: true };
+                }
+            }
+            return noCoverage;
+        }
         if (isIdentifier(left) && left.name === identifierName) {
             return getValueCoverage(right);
         }

package/dist/transforms-by-id/use-optional-chaining/manifest.json

@@ -1,13 +1,13 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-08T05:46:19.740Z",
-            "changedLines": 582,
-            "durationSeconds": 34.011375708,
+            "evaluatedAt": "2026-02-21T16:46:18.553Z",
+            "changedLines": 614,
+            "durationSeconds": 40.285438,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.116.2",
+  "version": "1.117.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",