miniread 1.36.0 → 1.38.0

package/dist/transforms/_generated/manifest.js

@@ -192,6 +192,12 @@ const manifestData = {
         evaluatedAt: "2026-01-23T17:57:26.908Z",
         notes: "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures.",
     },
+    "rename-timeout-duration-parameters": {
+        diffReductionImpact: -0.000018848364904400228,
+        recommended: false,
+        evaluatedAt: "2026-01-24T23:36:14.192Z",
+        notes: "Negative diff reduction; leaving out of recommended preset.",
+    },
     "rename-timeout-ids": {
         diffReductionImpact: 0.00003774938185385768,
         recommended: true,
@@ -214,6 +220,12 @@ const manifestData = {
         evaluatedAt: "2026-01-24T15:52:58.710Z",
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
     },
+    "rename-url-variables": {
+        diffReductionImpact: 0.000018848364904289205,
+        recommended: true,
+        evaluatedAt: "2026-01-24T23:50:56.857Z",
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+    },
     "rename-use-reference-guards": {
         diffReductionImpact: 0,
         recommended: false,

package/dist/transforms/_generated/registry.js

@@ -32,10 +32,12 @@ import { renameRegexBuildersTransform } from "../rename-regex-builders/rename-re
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
+import { renameTimeoutDurationParametersTransform } from "../rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameTypeofVariablesTransform } from "../rename-typeof-variables/rename-typeof-variables-transform.js";
 import { renameUint8arrayConcatVariablesTransform } from "../rename-uint8array-concat-variables/rename-uint8array-concat-variables-transform.js";
 import { renameUrlParametersTransform } from "../rename-url-parameters/rename-url-parameters-transform.js";
+import { renameUrlVariablesTransform } from "../rename-url-variables/rename-url-variables-transform.js";
 import { renameUseReferenceGuardsTransform } from "../rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "../rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
 import { simplifyBooleanNegationsTransform } from "../simplify-boolean-negations/simplify-boolean-negations-transform.js";
@@ -75,10 +77,12 @@ export const transformRegistry = {
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
+    [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameTypeofVariablesTransform.id]: renameTypeofVariablesTransform,
     [renameUint8arrayConcatVariablesTransform.id]: renameUint8arrayConcatVariablesTransform,
     [renameUrlParametersTransform.id]: renameUrlParametersTransform,
+    [renameUrlVariablesTransform.id]: renameUrlVariablesTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,

package/dist/transforms/rename-timeout-duration-parameters/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": -0.000018848364904400228,
+    "recommended": false,
+    "evaluatedAt": "2026-01-24T23:36:14.192Z",
+    "notes": "Negative diff reduction; leaving out of recommended preset."
+}

package/dist/transforms/rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.d.ts

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

package/dist/transforms/rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.js

@@ -0,0 +1,137 @@
+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 = "timeoutMs";
+const getParameterIdentifier = (parameter) => {
+    if (parameter.type === "Identifier")
+        return parameter;
+    if (parameter.type !== "AssignmentPattern")
+        return undefined;
+    const { left } = parameter;
+    if (left.type !== "Identifier")
+        return undefined;
+    return left;
+};
+const isSetTimeoutDelayReference = (referencePath, bindingName) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    const callPath = referencePath.parentPath;
+    if (!callPath.isCallExpression())
+        return false;
+    if (referencePath.listKey !== "arguments")
+        return false;
+    if (typeof referencePath.key !== "number")
+        return false;
+    if (referencePath.key !== 1)
+        return false;
+    const call = callPath.node;
+    if (call.callee.type !== "Identifier")
+        return false;
+    if (call.callee.name !== "setTimeout")
+        return false;
+    if (callPath.scope.hasBinding("setTimeout", true))
+        return false;
+    return referencePath.node.name === bindingName;
+};
+const isIfTestReference = (referencePath) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    const parentPath = referencePath.parentPath;
+    if (parentPath.isIfStatement()) {
+        return parentPath.node.test === referencePath.node;
+    }
+    if (parentPath.isUnaryExpression({ operator: "!" })) {
+        const ifPath = parentPath.parentPath;
+        if (!ifPath.isIfStatement())
+            return false;
+        if (ifPath.node.test !== parentPath.node)
+            return false;
+        return parentPath.node.argument === referencePath.node;
+    }
+    if (parentPath.isBinaryExpression()) {
+        const ifPath = parentPath.parentPath;
+        if (!ifPath.isIfStatement())
+            return false;
+        if (ifPath.node.test !== parentPath.node)
+            return false;
+        return (parentPath.node.left === referencePath.node ||
+            parentPath.node.right === referencePath.node);
+    }
+    return false;
+};
+const isLetter = (char) => /^[a-z]$/iu.test(char);
+const containsMsUnit = (raw) => {
+    let index = raw.indexOf("ms");
+    while (index !== -1) {
+        const before = raw[index - 1];
+        const after = raw[index + 2];
+        const beforeOk = before === undefined || !isLetter(before);
+        const afterOk = after === undefined || !isLetter(after);
+        if (beforeOk && afterOk)
+            return true;
+        index = raw.indexOf("ms", index + 2);
+    }
+    return false;
+};
+const isTimeoutTemplateReference = (referencePath) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    const parentPath = referencePath.parentPath;
+    if (!parentPath.isTemplateLiteral())
+        return false;
+    const template = parentPath.node;
+    return template.quasis.some((quasi) => containsMsUnit(quasi.value.raw));
+};
+const isAllowedTimeoutReference = (referencePath, bindingName) => {
+    return (isSetTimeoutDelayReference(referencePath, bindingName) ||
+        isIfTestReference(referencePath) ||
+        isTimeoutTemplateReference(referencePath));
+};
+export const renameTimeoutDurationParametersTransform = {
+    id: "rename-timeout-duration-parameters",
+    description: "Renames timeout duration parameters to $timeoutMs when used for setTimeout delays and timeout messages",
+    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++;
+                    for (const parameter of path.node.params) {
+                        const identifier = getParameterIdentifier(parameter);
+                        if (!identifier)
+                            continue;
+                        if (isStableRenamed(identifier.name))
+                            continue;
+                        const binding = path.scope.getBinding(identifier.name);
+                        if (!binding)
+                            continue;
+                        if (binding.kind !== "param")
+                            continue;
+                        if (!binding.constant)
+                            continue;
+                        if (binding.referencePaths.length === 0)
+                            continue;
+                        if (!binding.referencePaths.some((referencePath) => isSetTimeoutDelayReference(referencePath, identifier.name)))
+                            continue;
+                        if (!binding.referencePaths.every((referencePath) => isAllowedTimeoutReference(referencePath, identifier.name)))
+                            continue;
+                        group.add({
+                            scope: path.scope,
+                            currentName: identifier.name,
+                            baseName: BASE_NAME,
+                        });
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-url-parameters/rename-url-parameters-transform.js

@@ -2,59 +2,10 @@ import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
+import { hasUrlDestructure } from "../url-usage-heuristics.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const urlPropertyNames = new Set([
-    "hash",
-    "host",
-    "hostname",
-    "href",
-    "origin",
-    "password",
-    "pathname",
-    "port",
-    "protocol",
-    "search",
-    "searchParams",
-    "username",
-]);
-const countUrlProperties = (pattern) => {
-    let count = 0;
-    for (const property of pattern.properties) {
-        if (property.type !== "ObjectProperty")
-            continue;
-        if (property.computed)
-            continue;
-        const key = property.key;
-        const keyName = key.type === "Identifier"
-            ? key.name
-            : key.type === "StringLiteral"
-                ? key.value
-                : undefined;
-        if (keyName && urlPropertyNames.has(keyName)) {
-            count += 1;
-        }
-    }
-    return count;
-};
-const hasUrlDestructure = (referencePath) => {
-    const parent = referencePath.parentPath;
-    if (!parent)
-        return false;
-    if (parent.isVariableDeclarator() &&
-        parent.node.init === referencePath.node &&
-        parent.node.id.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.id) >= 2;
-    }
-    if (parent.isAssignmentExpression() &&
-        parent.node.operator === "=" &&
-        parent.node.right === referencePath.node &&
-        parent.node.left.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.left) >= 2;
-    }
-    return false;
-};
 const hasUrlConstruction = (referencePath) => {
     const parent = referencePath.parentPath;
     if (!parent?.isNewExpression())

package/dist/transforms/rename-url-variables/manifest.json

@@ -0,0 +1,6 @@
+{
+    "diffReductionImpact": 0.000018848364904289205,
+    "recommended": true,
+    "evaluatedAt": "2026-01-24T23:50:56.857Z",
+    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+}

package/dist/transforms/rename-url-variables/rename-url-variables-transform.d.ts

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

package/dist/transforms/rename-url-variables/rename-url-variables-transform.js

@@ -0,0 +1,94 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasUrlDestructure, urlPropertyNames, } from "../url-usage-heuristics.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const isUrlConstruction = (node) => {
+    if (node?.type !== "NewExpression")
+        return false;
+    if (node.callee.type !== "Identifier" || node.callee.name !== "URL") {
+        return false;
+    }
+    return true;
+};
+const isUrlPropertyAccess = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (!parent.isMemberExpression())
+        return false;
+    if (parent.node.object !== referencePath.node)
+        return false;
+    if (parent.node.computed)
+        return false;
+    const key = parent.node.property;
+    const keyName = key.type === "Identifier"
+        ? key.name
+        : key.type === "StringLiteral"
+            ? key.value
+            : undefined;
+    if (!keyName)
+        return false;
+    return urlPropertyNames.has(keyName);
+};
+export const renameUrlVariablesTransform = {
+    id: "rename-url-variables",
+    description: "Renames variables initialized with new URL(...) when they are accessed via URL properties",
+    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 += 1;
+                    if (path.node.id.type !== "Identifier")
+                        return;
+                    if (!isUrlConstruction(path.node.init))
+                        return;
+                    const currentName = path.node.id.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    let sawUrlDestructure = false;
+                    let propertyAccesses = 0;
+                    for (const referencePath of binding.referencePaths) {
+                        const hasDestructure = hasUrlDestructure(referencePath);
+                        if (hasDestructure) {
+                            sawUrlDestructure = true;
+                        }
+                        if (propertyAccesses < 2 && isUrlPropertyAccess(referencePath)) {
+                            propertyAccesses += 1;
+                        }
+                        if (sawUrlDestructure || propertyAccesses >= 2)
+                            break;
+                    }
+                    if (!sawUrlDestructure && propertyAccesses < 2)
+                        return;
+                    const candidateName = "url";
+                    if (candidateName === currentName)
+                        return;
+                    const programScope = path.scope.getProgramParent();
+                    if (Object.hasOwn(programScope.globals, candidateName))
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: candidateName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/url-usage-heuristics.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+export declare const urlPropertyNames: Set<string>;
+export declare const hasUrlDestructure: (referencePath: NodePath) => boolean;

package/dist/transforms/url-usage-heuristics.js

@@ -0,0 +1,50 @@
+export const urlPropertyNames = new Set([
+    "hash",
+    "host",
+    "hostname",
+    "href",
+    "origin",
+    "password",
+    "pathname",
+    "port",
+    "protocol",
+    "search",
+    "searchParams",
+    "username",
+]);
+const countUrlProperties = (pattern) => {
+    let count = 0;
+    for (const property of pattern.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        if (property.computed)
+            continue;
+        const key = property.key;
+        const keyName = key.type === "Identifier"
+            ? key.name
+            : key.type === "StringLiteral"
+                ? key.value
+                : undefined;
+        if (keyName && urlPropertyNames.has(keyName)) {
+            count += 1;
+        }
+    }
+    return count;
+};
+export const hasUrlDestructure = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (parent.isVariableDeclarator() &&
+        parent.node.init === referencePath.node &&
+        parent.node.id.type === "ObjectPattern") {
+        return countUrlProperties(parent.node.id) >= 2;
+    }
+    if (parent.isAssignmentExpression() &&
+        parent.node.operator === "=" &&
+        parent.node.right === referencePath.node &&
+        parent.node.left.type === "ObjectPattern") {
+        return countUrlProperties(parent.node.left) >= 2;
+    }
+    return false;
+};

package/package.json

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