miniread 1.54.0 → 1.56.0

package/dist/transforms/_generated/manifest.js

@@ -23,6 +23,11 @@ const manifestData = {
         notes: "Auto-added by evaluation script.",
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T22:59:37.142Z", "changedLines": 310, "durationSeconds": 57.105855792, "stableNames": 1357 } },
     },
+    "expand-typeof-undefined-comparisons": {
+        recommended: true,
+        notes: "Improves readability by expanding minified typeof comparisons; expected to be diff-neutral.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-01T22:27:53.830Z", "changedLines": 780, "durationSeconds": 138.901942826, "stableNames": 1357 } },
+    },
     "expand-undefined-literals": {
         recommended: true,
         notes: "Auto-added by evaluation script.",
@@ -118,6 +123,10 @@ const manifestData = {
         notes: "Added manually; recommended based on high-confidence heuristics. Evaluated diff-neutral on claude-code-2.1.10→2.1.11.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:01:29.649Z", "changedLines": 8, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-29T14:35:18.029Z", "changedLines": 8, "durationSeconds": 34.694468833, "stableNames": 1358 } },
     },
+    "rename-interval-ids": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-01T09:30:55.276Z", "changedLines": 58, "durationSeconds": 201.398360841, "stableNames": 1358 } },
+    },
     "rename-loop-index-variables": {
         recommended: false,
         notes: "Superseded by rename-loop-index-variables-v3.",
@@ -320,6 +329,7 @@ export const recommendedTransformIds = [
     "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",
@@ -338,6 +348,7 @@ export const recommendedTransformIds = [
     "rename-error-first-callback-parameters",
     "rename-error-variables",
     "rename-event-parameters",
+    "rename-interval-ids",
     "rename-loop-index-variables-v3",
     "rename-loop-length-variables",
     "rename-object-keys-variables",

package/dist/transforms/_generated/registry.js

@@ -4,6 +4,7 @@ import { expandBooleanLiteralsTransform } from "../expand-boolean-literals/expan
 import { expandSequenceExpressionsV4Transform } from "../expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js";
 import { expandSequenceExpressionsV5Transform } from "../expand-sequence-expressions-v5/expand-sequence-expressions-v5-transform.js";
 import { expandSpecialNumberLiteralsTransform } from "../expand-special-number-literals/expand-special-number-literals-transform.js";
+import { expandTypeofUndefinedComparisonsTransform } from "../expand-typeof-undefined-comparisons/expand-typeof-undefined-comparisons-transform.js";
 import { expandUndefinedLiteralsTransform } from "../expand-undefined-literals/expand-undefined-literals-transform.js";
 import { removeRedundantElseTransform } from "../remove-redundant-else/remove-redundant-else-transform.js";
 import { renameArgumentsLengthFlagsTransform } from "../rename-arguments-length-flags/rename-arguments-length-flags-transform.js";
@@ -23,6 +24,7 @@ import { renameDestructuredAliasesTransform } from "../rename-destructured-alias
 import { renameErrorFirstCallbackParametersTransform } from "../rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js";
 import { renameErrorVariablesTransform } from "../rename-error-variables/rename-error-variables-transform.js";
 import { renameEventParametersTransform } from "../rename-event-parameters/rename-event-parameters-transform.js";
+import { renameIntervalIdsTransform } from "../rename-interval-ids/rename-interval-ids-transform.js";
 import { renameLoopIndexVariablesTransform } from "../rename-loop-index-variables/rename-loop-index-variables-transform.js";
 import { renameLoopIndexVariablesV2Transform } from "../rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
 import { renameLoopIndexVariablesV3Transform } from "../rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
@@ -64,6 +66,7 @@ export const transformRegistry = {
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
     [expandSequenceExpressionsV5Transform.id]: expandSequenceExpressionsV5Transform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
+    [expandTypeofUndefinedComparisonsTransform.id]: expandTypeofUndefinedComparisonsTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [removeRedundantElseTransform.id]: removeRedundantElseTransform,
     [renameArgumentsLengthFlagsTransform.id]: renameArgumentsLengthFlagsTransform,
@@ -83,6 +86,7 @@ export const transformRegistry = {
     [renameErrorFirstCallbackParametersTransform.id]: renameErrorFirstCallbackParametersTransform,
     [renameErrorVariablesTransform.id]: renameErrorVariablesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
+    [renameIntervalIdsTransform.id]: renameIntervalIdsTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,

package/dist/transforms/expand-typeof-undefined-comparisons/expand-typeof-undefined-comparisons-transform.d.ts

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

package/dist/transforms/expand-typeof-undefined-comparisons/expand-typeof-undefined-comparisons-transform.js

@@ -0,0 +1,65 @@
+import { createRequire } from "node:module";
+import * as t from "@babel/types";
+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 isExpression = (value) => !t.isPrivateName(value);
+const isTypeofExpression = (expression) => isExpression(expression) &&
+    t.isUnaryExpression(expression, {
+        operator: "typeof",
+    });
+const isUStringLiteral = (expression) => isExpression(expression) && t.isStringLiteral(expression, { value: "u" });
+const getTypeofUndefinedComparison = (expression) => {
+    if (expression.operator !== "<" &&
+        expression.operator !== "<=" &&
+        expression.operator !== ">" &&
+        expression.operator !== ">=") {
+        return undefined;
+    }
+    const operator = expression.operator === "<" || expression.operator === "<=" ? "<" : ">";
+    const { left, right } = expression;
+    const leftTypeof = isTypeofExpression(left) ? left : undefined;
+    const rightTypeof = isTypeofExpression(right) ? right : undefined;
+    const leftIsU = isUStringLiteral(left);
+    const rightIsU = isUStringLiteral(right);
+    if (leftTypeof && rightIsU) {
+        // "typeof X" strings are lexicographically < "u" for all types except "undefined".
+        return {
+            typeofExpression: leftTypeof,
+            operator: operator === "<" ? "!==" : "===",
+        };
+    }
+    if (rightTypeof && leftIsU) {
+        // "u" < typeof X only when typeof X === "undefined"; otherwise "u" > typeof X.
+        return {
+            typeofExpression: rightTypeof,
+            operator: operator === "<" ? "===" : "!==",
+        };
+    }
+    return undefined;
+};
+export const expandTypeofUndefinedComparisonsTransform = {
+    id: "expand-typeof-undefined-comparisons",
+    description: "Expands typeof comparisons against 'u' into explicit undefined checks",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                BinaryExpression(path) {
+                    nodesVisited++;
+                    const comparison = getTypeofUndefinedComparison(path.node);
+                    if (!comparison)
+                        return;
+                    const replacement = t.binaryExpression(comparison.operator, t.cloneNode(comparison.typeofExpression, true), t.stringLiteral("undefined"));
+                    path.replaceWith(replacement);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/expand-typeof-undefined-comparisons/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-01T22:27:53.830Z",
+            "changedLines": 780,
+            "durationSeconds": 138.901942826,
+            "stableNames": 1357
+        }
+    },
+    "notes": "Improves readability by expanding minified typeof comparisons; expected to be diff-neutral."
+}

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 83.6526599845798,
-        "notes": "Measured with baseline none: 83.65% of original diff."
+        "diffSizePercent": 78.49967015361418,
+        "notes": "Measured with baseline none: 78.50% 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", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-buffer-variables", "rename-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-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-object-keys-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-rest-parameters", "rename-search-parameters-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", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "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-buffer-variables", "rename-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-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-object-keys-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-rest-parameters", "rename-search-parameters-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", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

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

@@ -11,6 +11,7 @@ export const recommendedTransformOrder = [
     "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",
@@ -29,6 +30,7 @@ export const recommendedTransformOrder = [
     "rename-error-first-callback-parameters",
     "rename-error-variables",
     "rename-event-parameters",
+    "rename-interval-ids",
     "rename-loop-index-variables-v3",
     "rename-loop-length-variables",
     "rename-object-keys-variables",

package/dist/transforms/rename-interval-ids/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-01T09:30:55.276Z",
+            "changedLines": 58,
+            "durationSeconds": 201.398360841,
+            "stableNames": 1358
+        }
+    }
+}

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

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

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

@@ -0,0 +1,85 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } 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 BASE_NAME = "intervalId";
+const isSetIntervalCall = (path, init) => {
+    if (init.callee.type !== "Identifier")
+        return false;
+    if (init.callee.name !== "setInterval")
+        return false;
+    // If setInterval is locally bound (imported or declared), semantics may differ.
+    if (path.scope.hasBinding("setInterval", true))
+        return false;
+    return true;
+};
+const isClearIntervalCallArgument = (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 !== "clearInterval")
+        return false;
+    // If clearInterval is locally bound (imported or declared), semantics may differ.
+    if (callPath.scope.hasBinding("clearInterval", 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 renameIntervalIdsTransform = {
+    id: "rename-interval-ids",
+    description: "Renames setInterval handle variables to $intervalId/$intervalId2/... or intervalId/intervalId2/... when usage is only clearInterval(...)",
+    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, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
+                        return;
+                    const init = path.node.init;
+                    if (init?.type !== "CallExpression")
+                        return;
+                    if (!isSetIntervalCall(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) => isClearIntervalCallArgument(referencePath, id.name)))
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/package.json

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