miniread 1.1.0 → 1.3.0

package/dist/scripts/evaluate/parse-transform-manifest.d.ts

@@ -5,7 +5,7 @@ type TransformManifestEntry = {
     scope: Transform["scope"];
     parallelizable: boolean;
     diffReductionImpact: number;
-    enabledByDefault: boolean;
+    recommended: boolean;
     evaluatedAt?: string;
     notes?: string;
     supersededBy?: string;

package/dist/scripts/evaluate/parse-transform-manifest.js

@@ -6,7 +6,7 @@ const TransformManifestEntrySchema = z
     scope: z.union([z.literal("file"), z.literal("project")]),
     parallelizable: z.boolean(),
     diffReductionImpact: z.number(),
-    enabledByDefault: z.boolean(),
+    recommended: z.boolean(),
     evaluatedAt: z.iso.datetime().optional(),
     notes: z.string().optional(),
     supersededBy: z.string().min(1).optional(),

package/dist/scripts/evaluate/transform-manifest.js

@@ -45,7 +45,7 @@ export const updateTransformManifestFromEvaluation = async (options) => {
     }
     if (isBaselineNone) {
         const recommendedIds = manifest.transforms
-            .filter((entry) => entry.enabledByDefault)
+            .filter((entry) => entry.recommended)
             .map((entry) => entry.id);
         const testUniqueIds = uniqueIds(testIds);
         const recommendedUniqueIds = uniqueIds(recommendedIds);

package/dist/transforms/expand-special-number-literals/expand-special-number-literals-transform.d.ts

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

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

@@ -0,0 +1,139 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const directEvalCache = new WeakMap();
+const containsDirectEval = (container) => {
+    const cached = directEvalCache.get(container.node);
+    if (cached !== undefined)
+        return cached;
+    let found = false;
+    container.traverse({
+        CallExpression(callPath) {
+            if (callPath.node.callee.type !== "Identifier")
+                return;
+            if (callPath.node.callee.name !== "eval")
+                return;
+            // We only care about direct eval in sloppy mode because it can introduce `var`
+            // 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();
+        },
+        Function(functionPath) {
+            if (functionPath.node === container.node)
+                return;
+            functionPath.skip();
+        },
+    });
+    directEvalCache.set(container.node, found);
+    return found;
+};
+const isWithinWithStatement = (path) => {
+    return Boolean(path.findParent((p) => p.isWithStatement()));
+};
+const isWithinSloppyDirectEvalScope = (path) => {
+    for (let functionPath = path.getFunctionParent(); functionPath; functionPath = functionPath.getFunctionParent()) {
+        if (functionPath.isInStrictMode())
+            continue;
+        if (containsDirectEval(functionPath))
+            return true;
+    }
+    const programPath = path.scope.getProgramParent().path;
+    if (!programPath.isInStrictMode() && containsDirectEval(programPath)) {
+        return true;
+    }
+    return false;
+};
+const isDivisionByZero = (value) => {
+    return value === 0 || Object.is(value, -0);
+};
+export const expandSpecialNumberLiteralsTransform = {
+    id: "expand-special-number-literals",
+    description: "Expands 1/0 to Infinity, -1/0 (and 1/-0) to -Infinity, and 0/0 to NaN (when not shadowed)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                BinaryExpression(path) {
+                    nodesVisited++;
+                    const { operator, left } = path.node;
+                    if (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")
+                        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))
+                        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++;
+                        return;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-binding/get-target-name.d.ts

@@ -0,0 +1,4 @@
+import type { Binding, Scope } from "@babel/traverse";
+export declare const getTargetName: (bindingScope: Scope, binding: Binding, options: {
+    baseName: string;
+}) => string | undefined;

package/dist/transforms/rename-binding/get-target-name.js

@@ -0,0 +1,25 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+// Cap retries to avoid pathological loops while handling large bundles.
+const MAX_CANDIDATES = 1000;
+export const getTargetName = (bindingScope, binding, options) => {
+    const { baseName } = options;
+    if (baseName.length === 0)
+        return;
+    const programScope = bindingScope.getProgramParent();
+    for (let index = 0; index < MAX_CANDIDATES; index++) {
+        const candidate = index === 0 ? baseName : `${baseName}${index + 1}`;
+        if (!isValidBindingIdentifier(candidate))
+            continue;
+        // Avoid shadowing bindings in parent scopes.
+        if (bindingScope.hasBinding(candidate))
+            continue;
+        if (Object.hasOwn(programScope.globals, candidate))
+            continue;
+        const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== bindingScope &&
+            referencePath.scope.hasBinding(candidate));
+        if (wouldBeShadowed)
+            continue;
+        return candidate;
+    }
+    return;
+};

package/dist/transforms/rename-binding/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-binding/is-valid-binding-identifier.js

@@ -0,0 +1,10 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.d.ts

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

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+import { getTargetName } from "../rename-binding/get-target-name.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 = "timeoutId";
+const isSetTimeoutCall = (path, init) => {
+    if (init.callee.type !== "Identifier")
+        return false;
+    if (init.callee.name !== "setTimeout")
+        return false;
+    // If setTimeout is locally bound (imported or declared), semantics may differ.
+    if (path.scope.hasBinding("setTimeout", true))
+        return false;
+    return true;
+};
+const isClearTimeoutCallArgument = (referencePath, bindingName) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    const callPath = referencePath.parentPath;
+    if (!callPath.isCallExpression())
+        return false;
+    const call = callPath.node;
+    if (call.callee.type !== "Identifier")
+        return false;
+    if (call.callee.name !== "clearTimeout")
+        return false;
+    // If clearTimeout is locally bound (imported or declared), semantics may differ.
+    if (callPath.scope.hasBinding("clearTimeout", true))
+        return false;
+    const argument0 = call.arguments[0];
+    if (argument0?.type !== "Identifier")
+        return false;
+    if (argument0 !== referencePath.node)
+        return false;
+    if (argument0.name !== bindingName)
+        return false;
+    return true;
+};
+export const renameTimeoutIdsTransform = {
+    id: "rename-timeout-ids",
+    description: "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (id.name.length > 2)
+                        return;
+                    const init = path.node.init;
+                    if (init?.type !== "CallExpression")
+                        return;
+                    if (!isSetTimeoutCall(path, init))
+                        return;
+                    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) => isClearTimeoutCallArgument(referencePath, id.name)))
+                        return;
+                    const targetName = getTargetName(path.scope, binding, {
+                        baseName: BASE_NAME,
+                    });
+                    if (!targetName)
+                        return;
+                    if (id.name === targetName)
+                        return;
+                    path.scope.rename(id.name, targetName);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-presets.js

@@ -3,7 +3,7 @@ import * as z from "zod";
 const TransformManifestEntry = z
     .object({
     id: z.string().min(1),
-    enabledByDefault: z.boolean(),
+    recommended: z.boolean(),
 })
     .loose();
 const TransformManifest = z
@@ -14,6 +14,6 @@ const TransformManifest = z
 const transformManifest = TransformManifest.parse(transformManifestJson);
 export const transformPresets = {
     recommended: transformManifest.transforms
-        .filter((transform) => transform.enabledByDefault)
+        .filter((transform) => transform.recommended)
         .map((transform) => transform.id),
 };

package/dist/transforms/transform-registry.js

@@ -2,6 +2,7 @@ import { expandBooleanLiteralsTransform } from "./expand-boolean-literals/expand
 import { expandReturnSequenceTransform } from "./expand-return-sequence/expand-return-sequence-transform.js";
 import { expandSequenceExpressionsTransform } from "./expand-sequence-expressions/expand-sequence-expressions-transform.js";
 import { expandSequenceExpressionsV2Transform } from "./expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js";
+import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-literals/expand-special-number-literals-transform.js";
 import { expandSequenceExpressionsV3Transform } from "./expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.js";
 import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-throw-sequence-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
@@ -9,6 +10,7 @@ import { renameCatchParametersTransform } from "./rename-catch-parameters/rename
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
+import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
@@ -17,12 +19,14 @@ export const transformRegistry = {
     [expandSequenceExpressionsTransform.id]: expandSequenceExpressionsTransform,
     [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
     [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
+    [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
 };

package/package.json

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

package/transform-manifest.json

@@ -6,7 +6,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-21T15:01:23.708Z",
       "notes": "Improves readability but does not reduce diffs (boolean literals are already deterministic)"
     },
@@ -16,7 +16,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-21T16:27:42.316Z",
       "notes": "Auto-added by evaluation script."
     },
@@ -26,7 +26,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-21T21:06:19.512Z",
       "notes": "Auto-added by evaluation script."
     },
@@ -36,7 +36,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0.0007738623280043599,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-23T07:48:59.087Z",
       "notes": "Auto-added by evaluation script."
     },
@@ -46,7 +46,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0.000943734546346775,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-22T12:49:10.952Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: 0.09%."
     },
@@ -56,7 +56,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.0012834789830316051,
-      "enabledByDefault": false,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T15:19:04.615Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: -0.13%. Superseded by expand-sequence-expressions-v2 in the recommended preset."
     },
@@ -66,7 +66,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.01282535248485317,
-      "enabledByDefault": false,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T17:15:48.528Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: -1.28%. Enabled for readability even when line diffs increase. Kept separate from expand-return-sequence to avoid modifying existing transforms and to allow independent enabling."
     },
@@ -76,7 +76,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.014316453068081048,
-      "enabledByDefault": false,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T18:22:48.609Z",
       "notes": "Superseded by expand-sequence-expressions-v3."
     },
@@ -86,7 +86,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.014391951831788763,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-23T08:21:23.662Z",
       "notes": "Supersedes expand-sequence-expressions-v2 in the recommended preset. Measured with baseline none: -1.44%. Enabled for readability even when line diffs increase."
     },
@@ -96,17 +96,27 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-22T17:03:19.826Z",
       "notes": "Auto-added by evaluation script."
     },
+    {
+      "id": "rename-timeout-ids",
+      "description": "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.00003774938185385768,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T10:29:23.279Z",
+      "notes": "Measured with baseline none: 0.00%. Not enabled by default (readability-only)."
+    },
     {
       "id": "split-variable-declarations",
       "description": "Splits multi-declarator variable declarations into separate statements",
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.0027651422207961573,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-23T05:45:27.981Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase."
     },
@@ -116,7 +126,7 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.00007549876370771536,
-      "enabledByDefault": false,
+      "recommended": false,
       "evaluatedAt": "2026-01-23T07:48:29.356Z",
       "notes": "Largely superseded by expand-sequence-expressions-v3 (which also expands throw sequences), but kept for isolated runs and comparison."
     },
@@ -126,9 +136,19 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "enabledByDefault": true,
+      "recommended": true,
       "evaluatedAt": "2026-01-22T21:39:53.578Z",
       "notes": "Auto-added by evaluation script."
+    },
+    {
+      "id": "expand-special-number-literals",
+      "description": "Expands 1/0 to Infinity, -1/0 (and 1/-0) to -Infinity, and 0/0 to NaN (when not shadowed)",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T08:17:45.579Z",
+      "notes": "Auto-added by evaluation script."
     }
   ],
   "presetStats": {