miniread 1.115.4 → 1.116.0

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 25.62554333446725,
-        "notes": "Measured with baseline none: 25.63% of original diff."
+        "diffSizePercent": 25.52727066560835,
+        "notes": "Measured with baseline none: 25.53% of original diff."
     }
 }

package/dist/transforms-by-id/rename-char-code-at/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%. Renames variables used in charCodeAt to improve readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99811516350957,
-            "evaluatedAt": "2026-02-07T21:16:53.166Z",
-            "changedLines": 1716,
-            "durationSeconds": 154.14203526499998,
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-21T14:03:29.674Z",
+            "changedLines": 1766,
+            "durationSeconds": 49.117882333000004,
             "stableNames": 1362
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-char-code-at/rename-char-code-at-transform.js

@@ -4,6 +4,92 @@ 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 visitCharCodeAtCall = (path, group, processedBindings) => {
+    const node = path.node;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression")
+        return;
+    if (callee.computed)
+        return;
+    if (callee.property.type !== "Identifier")
+        return;
+    if (callee.property.name !== "charCodeAt")
+        return;
+    // Rename object (str)
+    if (callee.object.type === "Identifier") {
+        const currentName = callee.object.name;
+        const binding = path.scope.getBinding(currentName);
+        if (binding &&
+            !processedBindings.has(binding) &&
+            !isStableRenamed(currentName)) {
+            processedBindings.add(binding);
+            group.add({
+                scope: binding.scope,
+                currentName,
+                baseName: "str",
+            });
+        }
+    }
+    const argumentPaths = path.get("arguments");
+    if (!Array.isArray(argumentPaths))
+        return;
+    const firstArgumentPath = argumentPaths[0];
+    if (!firstArgumentPath)
+        return;
+    if (firstArgumentPath.isIdentifier()) {
+        const currentName = firstArgumentPath.node.name;
+        const binding = firstArgumentPath.scope.getBinding(currentName);
+        if (binding &&
+            !processedBindings.has(binding) &&
+            !isStableRenamed(currentName)) {
+            processedBindings.add(binding);
+            group.add({
+                scope: binding.scope,
+                currentName,
+                baseName: "index",
+            });
+        }
+        return;
+    }
+    firstArgumentPath.traverse({
+        Identifier(argumentIdentifierPath) {
+            if (!argumentIdentifierPath.isReferencedIdentifier())
+                return;
+            const parentPath = argumentIdentifierPath.parentPath;
+            if (parentPath.isMemberExpression({
+                object: argumentIdentifierPath.node,
+            }) ||
+                parentPath.isOptionalMemberExpression({
+                    object: argumentIdentifierPath.node,
+                }) ||
+                parentPath.isCallExpression({
+                    callee: argumentIdentifierPath.node,
+                }) ||
+                parentPath.isOptionalCallExpression({
+                    callee: argumentIdentifierPath.node,
+                }) ||
+                parentPath.isNewExpression({
+                    callee: argumentIdentifierPath.node,
+                })) {
+                return;
+            }
+            const currentName = argumentIdentifierPath.node.name;
+            const binding = argumentIdentifierPath.scope.getBinding(currentName);
+            if (!binding ||
+                processedBindings.has(binding) ||
+                isStableRenamed(currentName)) {
+                return;
+            }
+            processedBindings.add(binding);
+            group.add({
+                scope: binding.scope,
+                currentName,
+                baseName: "index",
+            });
+        },
+    });
+};
 export const renameCharCodeAtTransform = {
     id: "rename-char-code-at",
     description: "Renames variables used in charCodeAt calls (str.charCodeAt(index))",
@@ -18,49 +104,11 @@ export const renameCharCodeAtTransform = {
             traverse(fileInfo.ast, {
                 CallExpression(path) {
                     nodesVisited++;
-                    const node = path.node;
-                    if (node.callee.type !== "MemberExpression")
-                        return;
-                    const callee = node.callee;
-                    if (callee.computed)
-                        return;
-                    if (callee.property.type !== "Identifier")
-                        return;
-                    if (callee.property.name !== "charCodeAt")
-                        return;
-                    // Rename object (str)
-                    if (callee.object.type === "Identifier") {
-                        const currentName = callee.object.name;
-                        const binding = path.scope.getBinding(currentName);
-                        if (binding &&
-                            !processedBindings.has(binding) &&
-                            !isStableRenamed(currentName)) {
-                            processedBindings.add(binding);
-                            group.add({
-                                scope: binding.scope,
-                                currentName,
-                                baseName: "str",
-                            });
-                        }
-                    }
-                    // Rename first argument (index)
-                    if (node.arguments.length > 0) {
-                        const firstArgument = node.arguments[0];
-                        if (firstArgument?.type === "Identifier") {
-                            const currentName = firstArgument.name;
-                            const binding = path.scope.getBinding(currentName);
-                            if (binding &&
-                                !processedBindings.has(binding) &&
-                                !isStableRenamed(currentName)) {
-                                processedBindings.add(binding);
-                                group.add({
-                                    scope: binding.scope,
-                                    currentName,
-                                    baseName: "index",
-                                });
-                            }
-                        }
-                    }
+                    visitCharCodeAtCall(path, group, processedBindings);
+                },
+                OptionalCallExpression(path) {
+                    nodesVisited++;
+                    visitCharCodeAtCall(path, group, processedBindings);
                 },
             });
             transformationsApplied += group.apply();

package/dist/transforms-by-id/rename-client-aliases/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:09:25.869Z",
-            "changedLines": 68,
-            "durationSeconds": 155.66230856399997,
+            "evaluatedAt": "2026-02-21T13:20:37.557Z",
+            "changedLines": 190,
+            "durationSeconds": 142.81505346600002,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

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

@@ -16,6 +16,37 @@ const isClientMemberExpression = (node) => {
     }
     return node.property.type === "Identifier" && node.property.name === "client";
 };
+const isClientProperty = (node) => {
+    if (node.computed)
+        return false;
+    if (node.key.type === "Identifier")
+        return node.key.name === "client";
+    if (node.key.type === "StringLiteral")
+        return node.key.value === "client";
+    return false;
+};
+const getClientAliasName = (path) => {
+    const id = path.node.id;
+    if (id.type === "Identifier")
+        return id.name;
+    if (id.type !== "ObjectPattern")
+        return undefined;
+    if (!path.node.init)
+        return undefined;
+    for (const property of id.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        if (!isClientProperty(property))
+            continue;
+        if (property.value.type === "Identifier")
+            return property.value.name;
+        if (property.value.type === "AssignmentPattern" &&
+            property.value.left.type === "Identifier") {
+            return property.value.left.name;
+        }
+    }
+    return undefined;
+};
 export const renameClientAliasesTransform = {
     id: "rename-client-aliases",
     description: "Renames aliases of *.client to $client/$client2/...",
@@ -30,17 +61,17 @@ export const renameClientAliasesTransform = {
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
-                    const id = path.node.id;
-                    if (id.type !== "Identifier")
+                    const clientAliasName = getClientAliasName(path);
+                    if (!clientAliasName)
                         return;
-                    if (isStableRenamed(id.name))
+                    if (isStableRenamed(clientAliasName))
                         return;
                     const init = path.node.init;
-                    if (init?.type !== "MemberExpression")
-                        return;
-                    if (!isClientMemberExpression(init))
+                    const fromMemberExpression = init?.type === "MemberExpression" && isClientMemberExpression(init);
+                    const fromObjectPattern = path.node.id.type === "ObjectPattern";
+                    if (!fromMemberExpression && !fromObjectPattern)
                         return;
-                    const binding = path.scope.getBinding(id.name);
+                    const binding = path.scope.getBinding(clientAliasName);
                     if (!binding)
                         return;
                     if (!binding.constant)
@@ -48,12 +79,12 @@ export const renameClientAliasesTransform = {
                     if (binding.referencePaths.length === 0)
                         return;
                     if (binding.scope.block.type === "Program" &&
-                        exportedNames.has(id.name)) {
+                        exportedNames.has(clientAliasName)) {
                         return;
                     }
                     group.add({
                         scope: binding.scope,
-                        currentName: id.name,
+                        currentName: clientAliasName,
                         baseName: BASE_NAME,
                     });
                 },

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

@@ -3,10 +3,10 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-14T07:23:12.948Z",
-            "changedLines": 0,
-            "durationSeconds": 25.987191208,
-            "stableNames": 1357
+            "evaluatedAt": "2026-02-21T10:23:01.538Z",
+            "changedLines": 46,
+            "durationSeconds": 38.284109375,
+            "stableNames": 1358
         }
     },
     "recommended": true,

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

@@ -6,8 +6,6 @@ import { queueFileReaderEventRename } from "./queue-file-reader-event-rename.js"
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const FILE_READER_BINDING_PATTERN = /^\$?fileReader(?:Instance)?\d*$/u;
-const isTrackedFileReaderBindingName = (name) => FILE_READER_BINDING_PATTERN.test(name);
 const getMemberPropertyName = (memberExpression) => {
     if (!memberExpression.computed) {
         if (!t.isIdentifier(memberExpression.property))
@@ -61,7 +59,9 @@ export const renameFileReaderVariablesTransform = {
                     nodesVisited++;
                     if (path.node.id.type !== "Identifier")
                         return;
-                    if (!isTrackedFileReaderBindingName(path.node.id.name))
+                    if (!path.node.init)
+                        return;
+                    if (!isFileReaderConstructorExpression(path.node.init))
                         return;
                     const binding = path.scope.getBinding(path.node.id.name);
                     if (!binding)
@@ -76,9 +76,6 @@ export const renameFileReaderVariablesTransform = {
                         if (!binding) {
                             return;
                         }
-                        if (!isTrackedFileReaderBindingName(binding.identifier.name)) {
-                            return;
-                        }
                         if (operator !== "=") {
                             fileReaderBindings.delete(binding);
                             return;

package/dist/transforms-by-id/rename-indexeddb-request-variables/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:23:34.206Z",
-            "changedLines": 0,
-            "durationSeconds": 192.01525400399998,
-            "stableNames": 1357
+            "evaluatedAt": "2026-02-21T10:25:57.574Z",
+            "changedLines": 30,
+            "durationSeconds": 29.580905417,
+            "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-indexeddb-request-variables/rename-indexeddb-request-variables-transform.js

@@ -4,7 +4,7 @@ import { collectExportedNames } from "../../core/collect-exported-names.js";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getBindingStableStart } from "../../transforms/get-binding-stable-start.js";
-import { hasDynamicNameLookup } from "../../transforms/has-dynamic-name-lookup.js";
+import { detectDynamicNameLookup } from "../../transforms/dynamic-name-lookup/detect-dynamic-name-lookup.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -25,7 +25,10 @@ export const renameIndexeddbRequestVariablesTransform = {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            if (hasDynamicNameLookup(fileInfo.ast))
+            const dynamicNameLookup = detectDynamicNameLookup(fileInfo.ast, {
+                stopEarly: true,
+            });
+            if (dynamicNameLookup.hasLocalScopeDynamicNameLookup)
                 continue;
             const renameCandidatesByScope = new Map();
             const isScript = fileInfo.ast.program.sourceType === "script";

package/dist/transforms-by-id/rename-interval-ids/is-allowed-interval-handle-reference.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from "@babel/traverse";
+export declare const isAllowedIntervalHandleReference: (referencePath: NodePath, isAllowedClearIntervalArgument: (path: NodePath) => boolean) => boolean;

package/dist/transforms-by-id/rename-interval-ids/is-allowed-interval-handle-reference.js

@@ -0,0 +1,3 @@
+export const isAllowedIntervalHandleReference = (referencePath, isAllowedClearIntervalArgument) => {
+    return isAllowedClearIntervalArgument(referencePath);
+};

package/dist/transforms-by-id/rename-interval-ids/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:10:24.793Z",
-            "changedLines": 58,
-            "durationSeconds": 205.348939381,
+            "evaluatedAt": "2026-02-21T13:56:01.303Z",
+            "changedLines": 74,
+            "durationSeconds": 40.303941625,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/rename-interval-ids/rename-interval-ids-transform.js

@@ -1,14 +1,40 @@
 import { createRequire } from "node:module";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { isAllowedIntervalHandleReference } from "./is-allowed-interval-handle-reference.js";
 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 BASE_NAME = "intervalId";
-const isSetIntervalCall = (path, init) => {
-    if (init.callee.type !== "Identifier")
+const hasExpectedMemberProperty = (callee, expectedMethodName) => {
+    if (!callee.computed) {
+        if (callee.property.type !== "Identifier")
+            return false;
+        return callee.property.name === expectedMethodName;
+    }
+    if (callee.property.type !== "StringLiteral")
+        return false;
+    return callee.property.value === expectedMethodName;
+};
+const isGlobalTimerMemberCall = (callee, expectedMethodName, hasLocalBinding) => {
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.object.type !== "Identifier")
         return false;
-    if (init.callee.name !== "setInterval")
+    if (!hasExpectedMemberProperty(callee, expectedMethodName))
+        return false;
+    if (callee.object.name !== "window" &&
+        callee.object.name !== "globalThis" &&
+        callee.object.name !== "self")
+        return false;
+    if (hasLocalBinding(callee.object.name))
+        return false;
+    return true;
+};
+const isSetIntervalCall = (path, init) => {
+    if (!((init.callee.type === "Identifier" &&
+        init.callee.name === "setInterval") ||
+        isGlobalTimerMemberCall(init.callee, "setInterval", (name) => path.scope.hasBinding(name, true))))
         return false;
     // If setInterval is locally bound (imported or declared), semantics may differ.
     if (path.scope.hasBinding("setInterval", true))
@@ -22,9 +48,9 @@ const isClearIntervalCallArgument = (referencePath, bindingName) => {
     if (!callPath.isCallExpression())
         return false;
     const call = callPath.node;
-    if (call.callee.type !== "Identifier")
-        return false;
-    if (call.callee.name !== "clearInterval")
+    if (!((call.callee.type === "Identifier" &&
+        call.callee.name === "clearInterval") ||
+        isGlobalTimerMemberCall(call.callee, "clearInterval", (name) => callPath.scope.hasBinding(name, true))))
         return false;
     // If clearInterval is locally bound (imported or declared), semantics may differ.
     if (callPath.scope.hasBinding("clearInterval", true))
@@ -65,11 +91,11 @@ export const renameIntervalIdsTransform = {
                     const binding = path.scope.getBinding(id.name);
                     if (!binding)
                         return;
-                    if (!binding.constant)
-                        return;
                     if (binding.referencePaths.length === 0)
                         return;
-                    if (!binding.referencePaths.every((referencePath) => isClearIntervalCallArgument(referencePath, id.name)))
+                    if (!binding.referencePaths.some((referencePath) => isClearIntervalCallArgument(referencePath, id.name)))
+                        return;
+                    if (!binding.referencePaths.every((referencePath) => isAllowedIntervalHandleReference(referencePath, (path) => isClearIntervalCallArgument(path, id.name))))
                         return;
                     group.add({
                         scope: path.scope,

package/dist/transforms-by-id/rename-loop-length-variables/get-loop-length-identifier.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement, Identifier, VariableDeclaration } from "@babel/types";
+export declare const LOOP_LENGTH_BASE_NAME = "length";
+export declare const getLoopLengthIdentifier: (loopPath: NodePath<ForStatement>, init: VariableDeclaration) => Identifier | undefined;

package/dist/transforms-by-id/rename-loop-length-variables/get-loop-length-identifier.js

@@ -0,0 +1,101 @@
+export const LOOP_LENGTH_BASE_NAME = "length";
+const isLengthMemberExpression = (init) => {
+    if (!init)
+        return false;
+    if (init.type !== "MemberExpression")
+        return false;
+    if (init.computed) {
+        return (init.property.type === "StringLiteral" &&
+            init.property.value === LOOP_LENGTH_BASE_NAME);
+    }
+    return (init.property.type === "Identifier" &&
+        init.property.name === LOOP_LENGTH_BASE_NAME);
+};
+const isReferenceInLoopTest = (referencePath, loopPath) => {
+    const test = loopPath.node.test;
+    if (!test)
+        return false;
+    return (referencePath.findParent((ancestorPath) => ancestorPath.node === test) !==
+        null);
+};
+const isReferenceInDeclaratorInit = (referencePath, declarator) => {
+    const init = declarator.init;
+    if (!init)
+        return false;
+    return (referencePath.findParent((ancestorPath) => ancestorPath.node === init) !==
+        null);
+};
+const getDeclaratorsByName = (init) => {
+    const declaratorsByName = new Map();
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        declaratorsByName.set(declarator.id.name, declarator);
+    }
+    return declaratorsByName;
+};
+const getDirectTestReferenceNames = (loopPath, declaratorsByName) => {
+    const directNames = new Set();
+    for (const name of declaratorsByName.keys()) {
+        const binding = loopPath.scope.getBinding(name);
+        if (!binding)
+            continue;
+        if (binding.referencePaths.some((referencePath) => isReferenceInLoopTest(referencePath, loopPath))) {
+            directNames.add(name);
+        }
+    }
+    return directNames;
+};
+const getDeclaratorDependencyNames = (loopPath, declaratorsByName, seedNames) => {
+    const dependencyNames = new Set(seedNames);
+    let didChange = true;
+    while (didChange) {
+        didChange = false;
+        for (const [name] of declaratorsByName) {
+            if (dependencyNames.has(name))
+                continue;
+            const binding = loopPath.scope.getBinding(name);
+            if (!binding)
+                continue;
+            let contributesToSeed = false;
+            for (const dependentName of dependencyNames) {
+                const dependentDeclarator = declaratorsByName.get(dependentName);
+                if (!dependentDeclarator)
+                    continue;
+                if (binding.referencePaths.some((referencePath) => isReferenceInDeclaratorInit(referencePath, dependentDeclarator))) {
+                    contributesToSeed = true;
+                    break;
+                }
+            }
+            if (!contributesToSeed)
+                continue;
+            dependencyNames.add(name);
+            didChange = true;
+        }
+    }
+    return dependencyNames;
+};
+const findLengthIdentifier = (loopPath, init, candidateNames) => {
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        if (!isLengthMemberExpression(declarator.init))
+            continue;
+        if (!candidateNames.has(declarator.id.name))
+            continue;
+        const binding = loopPath.scope.getBinding(declarator.id.name);
+        if (!binding)
+            continue;
+        return declarator.id;
+    }
+    return undefined;
+};
+export const getLoopLengthIdentifier = (loopPath, init) => {
+    const declaratorsByName = getDeclaratorsByName(init);
+    const directTestReferenceNames = getDirectTestReferenceNames(loopPath, declaratorsByName);
+    const direct = findLengthIdentifier(loopPath, init, directTestReferenceNames);
+    if (direct)
+        return direct;
+    const dependencyNames = getDeclaratorDependencyNames(loopPath, declaratorsByName, directTestReferenceNames);
+    return findLengthIdentifier(loopPath, init, dependencyNames);
+};

package/dist/transforms-by-id/rename-loop-length-variables/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:20:22.462Z",
-            "changedLines": 208,
-            "durationSeconds": 197.333827544,
+            "evaluatedAt": "2026-02-21T14:03:56.369Z",
+            "changedLines": 214,
+            "durationSeconds": 41.69858095800001,
             "stableNames": 1358
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }