miniread 1.23.0 → 1.25.0

package/dist/core/stable-naming.js

@@ -22,10 +22,23 @@ export const isStableRenamed = (name) => {
 const makeStableName = (baseName) => {
     return `${STABLE_PREFIX}${baseName}`;
 };
+const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referencePaths.some((referencePath) => {
+    if (referencePath.scope === bindingScope)
+        return false;
+    // Only consider bindings between this reference’s scope and the binding scope.
+    // This avoids incorrectly blocking safe renames due to unrelated outer bindings.
+    const hasBindingOptions = {
+        noGlobals: true,
+        noUids: true,
+        // Present in Babel scope implementation, but missing from our TypeScript types.
+        upToScope: bindingScope,
+    };
+    return referencePath.scope.hasBinding(targetName, hasBindingOptions);
+});
 /**
  * Finds the next available name slot in a scope.
  */
-const findAvailableName = (scope, baseName, startIndex, canBeStable) => {
+const findAvailableName = (scope, binding, baseName, startIndex, canBeStable) => {
     let index = startIndex;
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
@@ -39,6 +52,10 @@ const findAvailableName = (scope, baseName, startIndex, canBeStable) => {
         if (!stableTaken && !readableTaken) {
             // This slot is available
             const name = canBeStable ? candidateStable : candidateReadable;
+            if (binding && hasShadowingRisk(binding, scope, name)) {
+                index++;
+                continue;
+            }
             return { name, nextIndex: index + 1 };
         }
         index++;
@@ -107,7 +124,7 @@ export class RenameGroup {
                 let index = 1;
                 for (const entry of group) {
                     // Find next available name slot
-                    const targetName = findAvailableName(scope, baseName, index, canBeStable);
+                    const targetName = findAvailableName(scope, scope.getBinding(entry.currentName), baseName, index, canBeStable);
                     index = targetName.nextIndex;
                     if (entry.currentName !== targetName.name) {
                         scope.rename(entry.currentName, targetName.name);

package/dist/transforms/_generated/manifest.js

@@ -130,6 +130,10 @@ const manifestData = {
         evaluatedAt: "2026-01-23T17:28:09.184Z",
         notes: "Measured with baseline none: 0.00%.",
     },
+    "rename-rest-parameters": {
+        diffReductionImpact: 0,
+        recommended: true,
+    },
     "rename-this-aliases": {
         diffReductionImpact: 0.00003774938185385768,
         recommended: true,
@@ -146,6 +150,12 @@ const manifestData = {
         diffReductionImpact: 0,
         recommended: true,
     },
+    "rename-url-parameters": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-24T15:52:58.710Z",
+        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

@@ -21,9 +21,11 @@ import { renameParametersToMatchPropertiesTransform } from "../rename-parameters
 import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
 import { renamePromiseExecutorParametersTransform } from "../rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 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 { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameTypeofVariablesTransform } from "../rename-typeof-variables/rename-typeof-variables-transform.js";
+import { renameUrlParametersTransform } from "../rename-url-parameters/rename-url-parameters-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";
@@ -50,9 +52,11 @@ export const transformRegistry = {
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
+    [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameTypeofVariablesTransform.id]: renameTypeofVariablesTransform,
+    [renameUrlParametersTransform.id]: renameUrlParametersTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffReductionImpact": 0.001470172462538888,
+        "diffReductionImpact": 0.0015078691923475773,
         "notes": "Measured with baseline none: 0.15%."
     }
 }

package/dist/transforms/rename-rest-parameters/manifest.json

@@ -0,0 +1,4 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true
+}

package/dist/transforms/rename-rest-parameters/rename-rest-parameters-transform.d.ts

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

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

@@ -0,0 +1,62 @@
+import { createRequire } from "node:module";
+import { isIdentifier } from "@babel/types";
+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 BASE_NAME = "args";
+const getRestParameter = (parameters) => {
+    const lastParameter = parameters.at(-1);
+    if (!lastParameter)
+        return undefined;
+    if (lastParameter.type !== "RestElement")
+        return undefined;
+    return lastParameter;
+};
+export const renameRestParametersTransform = {
+    id: "rename-rest-parameters",
+    description: "Renames rest parameters to $args (stable when unique)",
+    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 restParameter = getRestParameter(path.node.params);
+                    if (!restParameter)
+                        return;
+                    const argument = restParameter.argument;
+                    if (!isIdentifier(argument))
+                        return;
+                    const currentName = argument.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    if (currentName.length > 2)
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

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

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

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

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

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

@@ -0,0 +1,135 @@
+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";
+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())
+        return false;
+    if (parent.node.callee.type !== "Identifier" ||
+        parent.node.callee.name !== "URL") {
+        return false;
+    }
+    if (parent.node.arguments.length === 0 || parent.node.arguments.length > 2) {
+        return false;
+    }
+    return parent.node.arguments[0] === referencePath.node;
+};
+export const renameUrlParametersTransform = {
+    id: "rename-url-parameters",
+    description: "Renames parameters that are normalized with new URL(...) and destructured into URL fields",
+    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 parameterPath of path.get("params")) {
+                        if (!parameterPath.isIdentifier())
+                            continue;
+                        const currentName = parameterPath.node.name;
+                        if (isStableRenamed(currentName))
+                            continue;
+                        const binding = path.scope.getBinding(currentName);
+                        if (!binding)
+                            continue;
+                        let sawUrlConstruction = false;
+                        let sawUrlDestructure = false;
+                        for (const referencePath of binding.referencePaths) {
+                            if (!sawUrlConstruction && hasUrlConstruction(referencePath)) {
+                                sawUrlConstruction = true;
+                            }
+                            if (!sawUrlDestructure && hasUrlDestructure(referencePath)) {
+                                sawUrlDestructure = true;
+                            }
+                            if (sawUrlConstruction && sawUrlDestructure)
+                                break;
+                        }
+                        if (!sawUrlConstruction || !sawUrlDestructure)
+                            continue;
+                        const candidateName = "url";
+                        if (candidateName === currentName ||
+                            !isIdentifierName(candidateName) ||
+                            isKeyword(candidateName) ||
+                            isStrictBindReservedWord(candidateName, true)) {
+                            continue;
+                        }
+                        const programScope = path.scope.getProgramParent();
+                        if (Object.hasOwn(programScope.globals, candidateName))
+                            continue;
+                        // `RenameGroup` avoids collisions for both the readable and stable forms
+                        // (e.g. `url` and `$url`) across the scope chain, so we don't need an
+                        // additional `wouldShadowReferencedOuterBinding` check here.
+                        group.add({
+                            scope: path.scope,
+                            currentName,
+                            baseName: candidateName,
+                        });
+                    }
+                },
+            });
+            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.23.0",
+  "version": "1.25.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",