miniread 1.72.0 → 1.74.0

package/dist/transforms/_generated/manifest.js

@@ -99,9 +99,15 @@ const manifestData = {
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99622028196697, "evaluatedAt": "2026-01-25T23:12:36.102Z", "changedLines": 354, "durationSeconds": 62.624233667, "stableNames": 1362 } },
     },
     "rename-default-options-parameters": {
-        recommended: true,
+        recommended: false,
+        notes: "Superseded by rename-default-options-parameters-v2.",
+        supersededBy: "rename-default-options-parameters-v2",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T19:51:46.527Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:13:21.099Z", "changedLines": 0, "durationSeconds": 41.827803458, "stableNames": 1357 } },
     },
+    "rename-default-options-parameters-v2": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T12:59:48.597Z", "changedLines": 774, "durationSeconds": 235.023578515, "stableNames": 1358 } },
+    },
     "rename-deferred-resolve-parameters": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Renames single-parameter promise executors to $resolve when usage only stores or calls the resolver.",
@@ -140,6 +146,10 @@ const manifestData = {
         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-05T18:46:50.023Z", "changedLines": 4, "durationSeconds": 165.60063108, "stableNames": 1358 } },
     },
+    "rename-file-reader-variables": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-05T18:45:30.224Z", "changedLines": 56, "durationSeconds": 179.39064335899997, "stableNames": 1358 } },
+    },
     "rename-fs-sync-variables": {
         recommended: true,
         notes: "Auto-added by evaluation script. Note: rename transforms can slightly increase diff size in isolation (longer identifiers), but the goal here is stability/readability and improved alignment when composed with other transforms in the recommended preset. Safety: skips files with obvious dynamic name-lookup patterns (e.g. free `eval` / `Function` / `with`) since string-based lookups are not rewritten by renames.",
@@ -422,11 +432,12 @@ export const recommendedTransformIds = [
     "rename-client-aliases",
     "rename-comparison-flags",
     "rename-date-now-start-times",
-    "rename-default-options-parameters",
+    "rename-default-options-parameters-v2",
     "rename-deferred-resolve-parameters",
     "rename-destructured-aliases",
     "rename-rest-parameters",
     "rename-execfile-arguments",
+    "rename-file-reader-variables",
     "rename-error-first-callback-parameters",
     "rename-error-variables",
     "rename-event-parameters",

package/dist/transforms/_generated/registry.js

@@ -20,6 +20,7 @@ import { renameClientAliasesTransform } from "../rename-client-aliases/rename-cl
 import { renameComparisonFlagsTransform } from "../rename-comparison-flags/rename-comparison-flags-transform.js";
 import { renameDateNowStartTimesTransform } from "../rename-date-now-start-times/rename-date-now-start-times-transform.js";
 import { renameDefaultOptionsParametersTransform } from "../rename-default-options-parameters/rename-default-options-parameters-transform.js";
+import { renameDefaultOptionsParametersV2Transform } from "../rename-default-options-parameters-v2/rename-default-options-parameters-v2-transform.js";
 import { renameDeferredResolveParametersTransform } from "../rename-deferred-resolve-parameters/rename-deferred-resolve-parameters-transform.js";
 import { renameDestructuredAliasesTransform } from "../rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameDocumentFragmentVariablesTransform } from "../rename-document-fragment-variables/rename-document-fragment-variables-transform.js";
@@ -28,6 +29,7 @@ import { renameErrorVariablesTransform } from "../rename-error-variables/rename-
 import { renameEventParametersTransform } from "../rename-event-parameters/rename-event-parameters-transform.js";
 import { renameExecfileArgumentsTransform } from "../rename-execfile-arguments/rename-execfile-arguments-transform.js";
 import { renameFileExtensionVariablesTransform } from "../rename-file-extension-variables/rename-file-extension-variables-transform.js";
+import { renameFileReaderVariablesTransform } from "../rename-file-reader-variables/rename-file-reader-variables-transform.js";
 import { renameFsSyncVariablesTransform } from "../rename-fs-sync-variables/rename-fs-sync-variables-transform.js";
 import { renameHttpMethodParametersTransform } from "../rename-http-method-parameters/rename-http-method-parameters-transform.js";
 import { renameHttpServerParametersTransform } from "../rename-http-server-parameters/rename-http-server-parameters-transform.js";
@@ -99,6 +101,7 @@ export const transformRegistry = {
     [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDateNowStartTimesTransform.id]: renameDateNowStartTimesTransform,
     [renameDefaultOptionsParametersTransform.id]: renameDefaultOptionsParametersTransform,
+    [renameDefaultOptionsParametersV2Transform.id]: renameDefaultOptionsParametersV2Transform,
     [renameDeferredResolveParametersTransform.id]: renameDeferredResolveParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameDocumentFragmentVariablesTransform.id]: renameDocumentFragmentVariablesTransform,
@@ -107,6 +110,7 @@ export const transformRegistry = {
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameExecfileArgumentsTransform.id]: renameExecfileArgumentsTransform,
     [renameFileExtensionVariablesTransform.id]: renameFileExtensionVariablesTransform,
+    [renameFileReaderVariablesTransform.id]: renameFileReaderVariablesTransform,
     [renameFsSyncVariablesTransform.id]: renameFsSyncVariablesTransform,
     [renameHttpMethodParametersTransform.id]: renameHttpMethodParametersTransform,
     [renameHttpServerParametersTransform.id]: renameHttpServerParametersTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 33.4134388841768,
-        "notes": "Measured with baseline none: 33.41% of original diff."
+        "diffSizePercent": 30.450475921213833,
+        "notes": "Measured with baseline none: 30.45% of original diff."
     }
 }

package/dist/transforms/recommended-transform-order.d.ts

@@ -4,4 +4,4 @@
  * This lets us tune transform interactions intentionally instead of relying on
  * alphabetical ID sorting.
  */
-export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-file-extension-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "rename-zod-check-parameters", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-file-extension-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "rename-zod-check-parameters", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

package/dist/transforms/recommended-transform-order.js

@@ -37,11 +37,12 @@ export const recommendedTransformOrder = [
     "rename-client-aliases",
     "rename-comparison-flags",
     "rename-date-now-start-times",
-    "rename-default-options-parameters",
+    "rename-default-options-parameters-v2",
     "rename-deferred-resolve-parameters",
     "rename-destructured-aliases",
     "rename-rest-parameters",
     "rename-execfile-arguments",
+    "rename-file-reader-variables",
     "rename-error-first-callback-parameters",
     "rename-error-variables",
     "rename-event-parameters",

package/dist/transforms/rename-default-options-parameters/manifest.json

@@ -1,5 +1,7 @@
 {
-    "recommended": true,
+    "recommended": false,
+    "supersededBy": "rename-default-options-parameters-v2",
+    "notes": "Superseded by rename-default-options-parameters-v2.",
     "evaluations": {
         "legacy:evaluation": {
             "evaluatedAt": "2026-01-25T19:51:46.527Z",

package/dist/transforms/rename-default-options-parameters-v2/collect-default-options-parameter-names.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+export declare const collectDefaultOptionsParameterNames: (path: NodePath<BabelFunction>) => string[];

package/dist/transforms/rename-default-options-parameters-v2/collect-default-options-parameter-names.js

@@ -0,0 +1,64 @@
+import * as t from "@babel/types";
+import { getDefaultedParameterName } from "./get-defaulted-parameter-name.js";
+const getDefaultOptionsParameterNamesFromChain = (statement, parameterNames, allowUndefinedCheck) => {
+    let matchedParameterName;
+    let current = statement;
+    while (current) {
+        const parameterName = getDefaultedParameterName(current, parameterNames, {
+            allowUndefinedCheck,
+        });
+        if (!parameterName)
+            return undefined;
+        if (!matchedParameterName) {
+            matchedParameterName = parameterName;
+        }
+        else if (matchedParameterName !== parameterName) {
+            return undefined;
+        }
+        if (!current.alternate) {
+            current = undefined;
+            continue;
+        }
+        if (!t.isIfStatement(current.alternate))
+            return undefined;
+        current = current.alternate;
+    }
+    return matchedParameterName;
+};
+export const collectDefaultOptionsParameterNames = (path) => {
+    const allowUndefinedCheck = !path.scope.hasBinding("undefined", true);
+    const body = path.node.body;
+    if (!t.isBlockStatement(body))
+        return [];
+    const parameterNames = new Set();
+    for (const parameter of path.node.params) {
+        if (!t.isIdentifier(parameter))
+            continue;
+        parameterNames.add(parameter.name);
+    }
+    let sawIfStatement = false;
+    let matchedParameterName;
+    for (const statement of body.body) {
+        if (t.isExpressionStatement(statement) &&
+            t.isStringLiteral(statement.expression)) {
+            continue;
+        }
+        if (!t.isIfStatement(statement))
+            break;
+        const chainMatch = getDefaultOptionsParameterNamesFromChain(statement, parameterNames, allowUndefinedCheck);
+        if (!chainMatch)
+            break;
+        sawIfStatement = true;
+        if (!matchedParameterName) {
+            matchedParameterName = chainMatch;
+            continue;
+        }
+        if (matchedParameterName !== chainMatch)
+            return [];
+    }
+    if (!sawIfStatement)
+        return [];
+    if (!matchedParameterName)
+        return [];
+    return [matchedParameterName];
+};

package/dist/transforms/rename-default-options-parameters-v2/get-defaulted-parameter-name.d.ts

@@ -0,0 +1,4 @@
+import type { IfStatement } from "@babel/types";
+export declare const getDefaultedParameterName: (statement: IfStatement, parameterNames: Set<string>, options: {
+    allowUndefinedCheck: boolean;
+}) => string | undefined;

package/dist/transforms/rename-default-options-parameters-v2/get-defaulted-parameter-name.js

@@ -0,0 +1,117 @@
+import * as t from "@babel/types";
+const isEmptyObjectAssignment = (expression, parameterName) => {
+    if (!t.isAssignmentExpression(expression, { operator: "=" }))
+        return false;
+    if (!t.isIdentifier(expression.left, { name: parameterName }))
+        return false;
+    if (!t.isObjectExpression(expression.right))
+        return false;
+    return expression.right.properties.length === 0;
+};
+const hasEmptyObjectAssignment = (statement, parameterName) => {
+    if (t.isReturnStatement(statement) || t.isThrowStatement(statement)) {
+        return false;
+    }
+    if (t.isExpressionStatement(statement)) {
+        return isEmptyObjectAssignment(statement.expression, parameterName);
+    }
+    if (t.isBlockStatement(statement)) {
+        for (const child of statement.body) {
+            if (t.isReturnStatement(child) || t.isThrowStatement(child))
+                return false;
+            if (!t.isExpressionStatement(child))
+                continue;
+            if (isEmptyObjectAssignment(child.expression, parameterName))
+                return true;
+        }
+    }
+    return false;
+};
+const getUndefinedCheckedParameterName = (test) => {
+    if (!t.isBinaryExpression(test, { operator: "===" }))
+        return undefined;
+    const { left, right } = test;
+    if (t.isIdentifier(left) && t.isIdentifier(right, { name: "undefined" })) {
+        return left.name;
+    }
+    if (t.isIdentifier(left, { name: "undefined" }) && t.isIdentifier(right)) {
+        return right.name;
+    }
+    return undefined;
+};
+const getFalsyCheckedParameterName = (test) => {
+    if (!t.isUnaryExpression(test, { operator: "!" }))
+        return undefined;
+    if (!t.isIdentifier(test.argument))
+        return undefined;
+    return test.argument.name;
+};
+const getTypeofFunctionCheckedParameterName = (test) => {
+    if (!t.isBinaryExpression(test))
+        return undefined;
+    if (test.operator !== "===" && test.operator !== "==")
+        return undefined;
+    const leftTypeofTarget = t.isUnaryExpression(test.left, {
+        operator: "typeof",
+    })
+        ? test.left.argument
+        : undefined;
+    const rightTypeofTarget = t.isUnaryExpression(test.right, {
+        operator: "typeof",
+    })
+        ? test.right.argument
+        : undefined;
+    const leftFunctionLiteral = t.isStringLiteral(test.left, {
+        value: "function",
+    })
+        ? test.left
+        : undefined;
+    const rightFunctionLiteral = t.isStringLiteral(test.right, {
+        value: "function",
+    })
+        ? test.right
+        : undefined;
+    if (leftFunctionLiteral &&
+        rightTypeofTarget &&
+        t.isIdentifier(rightTypeofTarget)) {
+        return rightTypeofTarget.name;
+    }
+    if (rightFunctionLiteral &&
+        leftTypeofTarget &&
+        t.isIdentifier(leftTypeofTarget)) {
+        return leftTypeofTarget.name;
+    }
+    return undefined;
+};
+export const getDefaultedParameterName = (statement, parameterNames, options) => {
+    if (options.allowUndefinedCheck) {
+        const undefinedCheckedName = getUndefinedCheckedParameterName(statement.test);
+        if (undefinedCheckedName) {
+            if (!parameterNames.has(undefinedCheckedName))
+                return undefined;
+            if (!hasEmptyObjectAssignment(statement.consequent, undefinedCheckedName)) {
+                return undefined;
+            }
+            return undefinedCheckedName;
+        }
+    }
+    const falsyCheckedName = getFalsyCheckedParameterName(statement.test);
+    if (falsyCheckedName) {
+        if (!parameterNames.has(falsyCheckedName))
+            return undefined;
+        if (!hasEmptyObjectAssignment(statement.consequent, falsyCheckedName)) {
+            return undefined;
+        }
+        return falsyCheckedName;
+    }
+    const typeofCheckedName = getTypeofFunctionCheckedParameterName(statement.test);
+    if (typeofCheckedName) {
+        if (!parameterNames.has(typeofCheckedName))
+            return undefined;
+        if (!hasEmptyObjectAssignment(statement.consequent, typeofCheckedName)) {
+            return undefined;
+        }
+        return typeofCheckedName;
+    }
+    return undefined;
+};

package/dist/transforms/rename-default-options-parameters-v2/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-06T12:59:48.597Z",
+            "changedLines": 774,
+            "durationSeconds": 235.023578515,
+            "stableNames": 1358
+        }
+    }
+}

package/dist/transforms/rename-default-options-parameters-v2/rename-default-options-parameters-v2-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameDefaultOptionsParametersV2Transform: Transform;

package/dist/transforms/rename-default-options-parameters-v2/rename-default-options-parameters-v2-transform.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { collectDefaultOptionsParameterNames } from "./collect-default-options-parameter-names.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 = "options";
+export const renameDefaultOptionsParametersV2Transform = {
+    id: "rename-default-options-parameters-v2",
+    description: "Renames defaulted options-like parameters into stable options names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const parameterNames = collectDefaultOptionsParameterNames(path);
+                    for (const parameterName of parameterNames) {
+                        if (parameterName === BASE_NAME)
+                            continue;
+                        if (isStableRenamed(parameterName))
+                            continue;
+                        group.add({
+                            scope: path.scope,
+                            currentName: parameterName,
+                            baseName: BASE_NAME,
+                        });
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

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

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-05T18:45:30.224Z",
+            "changedLines": 56,
+            "durationSeconds": 179.39064335899997,
+            "stableNames": 1358
+        }
+    }
+}

package/dist/transforms/rename-file-reader-variables/rename-file-reader-variables-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameFileReaderVariablesTransform: Transform;

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

@@ -0,0 +1,111 @@
+import { createRequire } from "node:module";
+import { collectExportedNames } from "../../core/collect-exported-names.js";
+import { RenameGroup, isStableRenamed } from "../../core/stable-naming.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 isTypeOnlyImportSpecifier = (binding, node) => {
+    const declaration = binding.path.parent;
+    if (declaration.type !== "ImportDeclaration") {
+        return false;
+    }
+    if (node.type === "ImportSpecifier" && node.importKind === "type") {
+        return true;
+    }
+    return declaration.importKind === "type";
+};
+const isTypeOnlyFileReaderBinding = (binding) => {
+    const node = binding.path.node;
+    const declaration = binding.path.parent;
+    if (node.type === "ImportSpecifier" ||
+        node.type === "ImportDefaultSpecifier") {
+        return isTypeOnlyImportSpecifier(binding, node);
+    }
+    if (declaration.type === "VariableDeclaration" && declaration.declare) {
+        return true;
+    }
+    if (node.type === "TSDeclareFunction" ||
+        (node.type === "ClassDeclaration" && node.declare === true) ||
+        (node.type === "FunctionDeclaration" && node.declare === true)) {
+        return true;
+    }
+    return (node.type === "TSTypeAliasDeclaration" ||
+        node.type === "TSInterfaceDeclaration");
+};
+const hasRuntimeFileReaderShadowing = (path) => {
+    const binding = path.scope.getBinding("FileReader");
+    // Ambient declarations like `declare class FileReader` typically do not
+    // produce bindings in Babel's TS scope model, so `binding` is often absent.
+    if (!binding) {
+        return false;
+    }
+    // Keep using getBinding so we can inspect and ignore type-only TS bindings.
+    if (isTypeOnlyFileReaderBinding(binding)) {
+        return false;
+    }
+    return true;
+};
+const isFileReaderConstructor = (path) => {
+    const { callee } = path.node;
+    if (callee.type !== "Identifier")
+        return false;
+    if (callee.name !== "FileReader")
+        return false;
+    if (hasRuntimeFileReaderShadowing(path))
+        return false;
+    return true;
+};
+export const renameFileReaderVariablesTransform = {
+    id: "rename-file-reader-variables",
+    description: "Rename variables initialized with new FileReader() to stable fileReader-derived names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const renameGroup = new RenameGroup();
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const { id } = path.node;
+                    if (id.type !== "Identifier") {
+                        return;
+                    }
+                    const initPath = path.get("init");
+                    if (Array.isArray(initPath) || !initPath.isNewExpression()) {
+                        return;
+                    }
+                    if (!isFileReaderConstructor(initPath)) {
+                        return;
+                    }
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName)) {
+                        return;
+                    }
+                    // Preserve already-semantic names (e.g. myFileReader) to avoid needless churn.
+                    if (currentName.toLowerCase().includes("filereader")) {
+                        return;
+                    }
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding?.constant) {
+                        return;
+                    }
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(currentName)) {
+                        return;
+                    }
+                    renameGroup.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: "fileReader",
+                    });
+                },
+            });
+            transformationsApplied += renameGroup.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/package.json

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