miniread 1.52.0 → 1.53.0

package/dist/core/is-type-only-global-reference.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from "@babel/traverse";
+export declare const isTypeOnlyGlobalReference: (path: NodePath) => boolean;

package/dist/core/is-type-only-global-reference.js

@@ -0,0 +1,33 @@
+export const isTypeOnlyGlobalReference = (path) => {
+    // `typeof Foo` in a type position still resolves `Foo` from the value
+    // namespace, so it can be affected by local shadowing.
+    if (path.findParent((parent) => parent.node.type === "TSTypeQuery"))
+        return false;
+    // TypeScript keeps value and type namespaces separate, so introducing a local
+    // value binding will not affect a purely type-position reference like
+    // `type T = Foo`. We only reserve globals that are referenced from the value
+    // namespace.
+    return Boolean(path.findParent((parent) => {
+        const type = parent.node.type;
+        if (!type.startsWith("TS"))
+            return false;
+        // Some TS-prefixed nodes are runtime constructs (e.g. `enum`, `namespace`,
+        // `export = Foo`) and contain real value-position expressions. Treat those
+        // contexts as non-type-only unless we find a more specific type node
+        // closer to the identifier.
+        if (type === "TSEnumDeclaration" ||
+            type === "TSEnumMember" ||
+            type === "TSExportAssignment" ||
+            type === "TSImportEqualsDeclaration" ||
+            type === "TSExternalModuleReference" ||
+            type === "TSModuleBlock" ||
+            type === "TSModuleDeclaration" ||
+            type === "TSNamespaceExportDeclaration")
+            return false;
+        return (type !== "TSAsExpression" &&
+            type !== "TSNonNullExpression" &&
+            type !== "TSSatisfiesExpression" &&
+            type !== "TSInstantiationExpression" &&
+            type !== "TSTypeAssertion");
+    }));
+};

package/dist/core/stable-naming.js

@@ -7,6 +7,7 @@
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
  */
+import { isTypeOnlyGlobalReference } from "./is-type-only-global-reference.js";
 const STABLE_PREFIX = "$";
 /**
  * Returns true if the name has been stable-renamed (starts with $).
@@ -35,27 +36,95 @@ const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referenc
     };
     return referencePath.scope.hasBinding(targetName, hasBindingOptions);
 });
+// Cache is keyed by the program `Scope` instance produced by Babel traversal,
+// so it won't leak across separate traversals / transform passes.
+const programValueGlobalsCache = new WeakMap();
+const getProgramValueGlobals = (scope) => {
+    const programScope = scope.getProgramParent();
+    const cached = programValueGlobalsCache.get(programScope);
+    if (cached)
+        return cached;
+    const programGlobals = programScope.globals;
+    const globalNames = Object.keys(programGlobals);
+    if (globalNames.length === 0) {
+        const empty = new Set();
+        programValueGlobalsCache.set(programScope, empty);
+        return empty;
+    }
+    const globalNameSet = new Set(globalNames);
+    const valueGlobals = new Set();
+    programScope.path.traverse({
+        Identifier(path) {
+            const name = path.node.name;
+            if (!globalNameSet.has(name))
+                return;
+            if (!path.isReferencedIdentifier())
+                return;
+            if (isTypeOnlyGlobalReference(path))
+                return;
+            valueGlobals.add(name);
+        },
+    });
+    // Cache is safe because we only ever use this set to prevent choosing rename
+    // targets that would shadow *existing* program-global references, and rename
+    // application should not introduce new free/global identifiers. If a future
+    // transform starts inserting new global references into the AST, this cache
+    // would need to be recomputed (or removed).
+    programValueGlobalsCache.set(programScope, valueGlobals);
+    return valueGlobals;
+};
 /**
  * Finds the next available name slot in a scope.
  */
 const findAvailableName = (scope, binding, baseName, startIndex, canBeStable, currentName) => {
     let index = startIndex;
+    // Treat any identifier referenced as a program-global value as reserved.
+    //
+    // For readable renames we check both the readable and stable variants; this
+    // keeps the stable/readable "slot" aligned (e.g. an existing `$foo` blocks
+    // introducing `foo`) and prevents introducing a local binding that would
+    // shadow a global used anywhere in the file (even across sibling scopes).
+    //
+    // For stable-only renames we only need to ensure the stable identifier itself
+    // is free (stable names don't collide with readable ones).
+    // Safe to read once per call: `globals` are gathered during traversal; actual
+    // renames happen later in `RenameGroup.apply()`.
+    // Note: This is intentionally conservative and can reduce rename coverage in
+    // bundles with many free identifiers.
+    const programGlobals = getProgramValueGlobals(scope);
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     while (true) {
         const suffix = index === 1 ? "" : String(index);
         const candidateBase = `${baseName}${suffix}`;
         const candidateStable = makeStableName(candidateBase);
         const candidateReadable = candidateBase;
-        // Check if either form is already taken in this scope
+        // Always reserve the stable name, even when we won't emit it, to keep the
+        // "slot" aligned across stable/readable naming and avoid collisions with
+        // already-stable identifiers.
         const stableTaken = candidateStable === currentName
             ? false
-            : scope.hasBinding(candidateStable);
+            : scope.hasBinding(candidateStable) ||
+                programGlobals.has(candidateStable);
+        if (canBeStable) {
+            if (stableTaken) {
+                index++;
+                continue;
+            }
+            // Stable names (`$foo`) don't collide with readable names (`foo`), so when
+            // we know we'll emit a stable name, we only need to check the stable slot.
+            const name = candidateStable;
+            if (binding && hasShadowingRisk(binding, scope, name)) {
+                index++;
+                continue;
+            }
+            return { name, nextIndex: index + 1 };
+        }
         const readableTaken = candidateReadable === currentName
             ? false
-            : scope.hasBinding(candidateReadable);
+            : scope.hasBinding(candidateReadable) ||
+                programGlobals.has(candidateReadable);
         if (!stableTaken && !readableTaken) {
-            // This slot is available
-            const name = canBeStable ? candidateStable : candidateReadable;
+            const name = candidateReadable;
             if (binding && hasShadowingRisk(binding, scope, name)) {
                 index++;
                 continue;

package/dist/transforms/_generated/manifest.js

@@ -201,6 +201,11 @@ const manifestData = {
         notes: "Negative diff reduction in evaluation; keep optional.",
         evaluations: { "legacy:evaluation": { "diffSizePercent": 100.00188483649043, "evaluatedAt": "2026-01-25T10:04:22.417Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0 } },
     },
+    "rename-search-parameters-variables": {
+        recommended: true,
+        notes: "Measured with baseline none: 100.00% of original diff. Added to recommended for readability.",
+        evaluations: { "legacy:evaluation": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T09:49:29.000Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-26T07:05:01.592Z", "changedLines": 32, "durationSeconds": 54.402595083, "stableNames": 1358 } },
+    },
     "rename-string-split-variables": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",

package/dist/transforms/_generated/registry.js

@@ -39,6 +39,7 @@ 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 { renameSafePropertyAccessorParametersTransform } from "../rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js";
+import { renameSearchParametersVariablesTransform } from "../rename-search-parameters-variables/rename-search-parameters-variables-transform.js";
 import { renameStringSplitVariablesTransform } from "../rename-string-split-variables/rename-string-split-variables-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";
@@ -96,6 +97,7 @@ export const transformRegistry = {
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameSafePropertyAccessorParametersTransform.id]: renameSafePropertyAccessorParametersTransform,
+    [renameSearchParametersVariablesTransform.id]: renameSearchParametersVariablesTransform,
     [renameStringSplitVariablesTransform.id]: renameStringSplitVariablesTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,

package/dist/transforms/get-url-construction-kind.d.ts

@@ -0,0 +1,5 @@
+import type { Scope } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+type UrlConstructionKind = "identifier" | "member";
+export declare const getUrlConstructionKind: (scope: Scope, node: Expression | null | undefined, constructorName: "URL" | "URLSearchParams") => UrlConstructionKind | undefined;
+export {};

package/dist/transforms/get-url-construction-kind.js

@@ -0,0 +1,47 @@
+import { isAllowedUrlNamespaceBindingInScope } from "./is-allowed-url-namespace-binding-in-scope.js";
+export const getUrlConstructionKind = (scope, node, constructorName) => {
+    if (node?.type !== "NewExpression")
+        return undefined;
+    const callee = node.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === constructorName ? "identifier" : undefined;
+    }
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") {
+        return undefined;
+    }
+    // `new url?.URL()` is a syntax error, but `new (url?.URL)(...)` is valid and
+    // produces an `OptionalMemberExpression` callee that Babel marks as
+    // parenthesized.
+    if (callee.type === "OptionalMemberExpression" &&
+        !callee.extra?.parenthesized) {
+        return undefined;
+    }
+    let propertyName = undefined;
+    if (callee.computed) {
+        if (callee.property.type === "StringLiteral") {
+            propertyName = callee.property.value;
+        }
+        else if (callee.property.type === "TemplateLiteral" &&
+            callee.property.expressions.length === 0 &&
+            callee.property.quasis.length === 1) {
+            const quasi = callee.property.quasis[0];
+            const cooked = quasi?.value.cooked;
+            propertyName = cooked ?? quasi?.value.raw;
+        }
+    }
+    else if (callee.property.type === "Identifier") {
+        propertyName = callee.property.name;
+    }
+    else if (callee.property.type === "StringLiteral") {
+        propertyName = callee.property.value;
+    }
+    if (propertyName !== constructorName)
+        return undefined;
+    if (callee.object.type !== "Identifier")
+        return undefined;
+    if (!isAllowedUrlNamespaceBindingInScope(scope, callee.object.name)) {
+        return undefined;
+    }
+    return "member";
+};

package/dist/transforms/is-allowed-url-constructor-in-scope.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from "@babel/traverse";
+export declare const isAllowedUrlConstructorInScope: (scope: Scope, constructorName: "URL" | "URLSearchParams") => boolean;

package/dist/transforms/is-allowed-url-constructor-in-scope.js

@@ -0,0 +1,70 @@
+import { isAllowedUrlModuleImportBinding } from "./is-allowed-url-module-import-binding.js";
+import { isNodeRequireInScope, isRequireFromUrlModule, } from "./is-require-from-url-module.js";
+const doesObjectPatternBindConstructorName = (pattern, constructorName) => {
+    for (const property of pattern.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        const keyName = property.computed
+            ? property.key.type === "StringLiteral"
+                ? property.key.value
+                : undefined
+            : property.key.type === "Identifier"
+                ? property.key.name
+                : property.key.type === "StringLiteral"
+                    ? property.key.value
+                    : undefined;
+        if (keyName !== constructorName)
+            continue;
+        const bindingName = property.value.type === "Identifier"
+            ? property.value.name
+            : property.value.type === "AssignmentPattern" &&
+                property.value.left.type === "Identifier"
+                ? property.value.left.name
+                : undefined;
+        if (bindingName !== constructorName)
+            continue;
+        return true;
+    }
+    return false;
+};
+export const isAllowedUrlConstructorInScope = (scope, constructorName) => {
+    const binding = scope.getBinding(constructorName);
+    if (!binding)
+        return true;
+    // Aliases like `const { URL: MyURL } = require("node:url")` do not create a
+    // binding for `URL`, so they don't affect this shadowing check.
+    if (binding.path.isImportSpecifier() &&
+        binding.path.parentPath.isImportDeclaration() &&
+        (binding.path.node.importKind === "type" ||
+            binding.path.parentPath.node.importKind === "type")) {
+        // `import type` doesn't introduce a runtime value binding. Treat it as if
+        // the constructor name wasn't bound locally (e.g. allow the global binding).
+        return true;
+    }
+    if (isAllowedUrlModuleImportBinding(binding.path, constructorName))
+        return true;
+    const declarator = binding.path.isVariableDeclarator()
+        ? binding.path
+        : binding.path.findParent((parent) => parent.isVariableDeclarator());
+    if (!declarator?.isVariableDeclarator())
+        return false;
+    const init = declarator.node.init;
+    if (declarator.node.id.type === "ObjectPattern") {
+        if (!doesObjectPatternBindConstructorName(declarator.node.id, constructorName)) {
+            return false;
+        }
+        if (!isRequireFromUrlModule(init))
+            return false;
+        if (!isNodeRequireInScope(declarator.scope))
+            return false;
+        return true;
+    }
+    if (declarator.node.id.type === "Identifier") {
+        if (!isRequireFromUrlModule(init, constructorName))
+            return false;
+        if (!isNodeRequireInScope(declarator.scope))
+            return false;
+        return true;
+    }
+    return false;
+};

package/dist/transforms/is-allowed-url-module-import-binding.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath } from "@babel/traverse";
+export declare const isAllowedUrlModuleImportBinding: (bindingPath: NodePath, importedName: "URL" | "URLSearchParams") => boolean;

package/dist/transforms/is-allowed-url-module-import-binding.js

@@ -0,0 +1,24 @@
+export const isAllowedUrlModuleImportBinding = (bindingPath, importedName) => {
+    // Only allow named imports (e.g. `import { URL } from "node:url"`).
+    // Default/namespace imports don't bind the constructor and often indicate
+    // interop or module-namespace values, so treating them as "safe stdlib" would
+    // create false positives.
+    if (!bindingPath.isImportSpecifier())
+        return false;
+    // `import type { URL } from "node:url"` (and TS 5.0 `import { type URL } ...`)
+    // doesn't introduce a runtime value binding, so it can't be treated as a safe
+    // stdlib constructor in scope.
+    if (bindingPath.node.importKind === "type")
+        return false;
+    const imported = bindingPath.node.imported;
+    const bindingImportedName = imported.type === "Identifier" ? imported.name : imported.value;
+    if (bindingImportedName !== importedName)
+        return false;
+    const importDeclaration = bindingPath.parentPath;
+    if (!importDeclaration.isImportDeclaration())
+        return false;
+    if (importDeclaration.node.importKind === "type")
+        return false;
+    const source = importDeclaration.node.source.value;
+    return source === "url" || source === "node:url";
+};

package/dist/transforms/is-allowed-url-namespace-binding-in-scope.d.ts

@@ -0,0 +1,2 @@
+import type { Scope } from "@babel/traverse";
+export declare const isAllowedUrlNamespaceBindingInScope: (scope: Scope, bindingName: string) => boolean;

package/dist/transforms/is-allowed-url-namespace-binding-in-scope.js

@@ -0,0 +1,35 @@
+import { isNodeRequireInScope, isRequireFromUrlModule, } from "./is-require-from-url-module.js";
+export const isAllowedUrlNamespaceBindingInScope = (scope, bindingName) => {
+    const binding = scope.getBinding(bindingName);
+    if (!binding)
+        return false;
+    if (binding.path.isImportNamespaceSpecifier() ||
+        binding.path.isImportDefaultSpecifier()) {
+        // Accept both:
+        // - `import * as url from "node:url"` (namespace import)
+        // - `import url from "node:url"` (CJS interop default import)
+        //
+        // In Node, `node:url` is a CommonJS module and default import resolves to
+        // the module exports object, so it supports `url.URL` / `url.URLSearchParams`.
+        // This also matches common transpiled/bundled output shapes.
+        const importDeclaration = binding.path.parentPath;
+        if (!importDeclaration.isImportDeclaration())
+            return false;
+        if (importDeclaration.node.importKind === "type")
+            return false;
+        const source = importDeclaration.node.source.value;
+        return source === "url" || source === "node:url";
+    }
+    const declarator = binding.path.isVariableDeclarator()
+        ? binding.path
+        : binding.path.findParent((parent) => parent.isVariableDeclarator());
+    if (!declarator?.isVariableDeclarator())
+        return false;
+    // No `propertyName` arg: ensure the binding is the module object
+    // (`require("node:url")`), not a specific export (`require("node:url").URL`).
+    if (!isRequireFromUrlModule(declarator.node.init))
+        return false;
+    if (!isNodeRequireInScope(declarator.scope))
+        return false;
+    return true;
+};

package/dist/transforms/is-require-from-url-module.d.ts

@@ -0,0 +1,15 @@
+import type { Scope } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+/**
+ * Returns `true` for:
+ * - `require("url")` / `require("node:url")`
+ * - `require("url").URL` / `require("node:url").URL` (or any other `propertyName`),
+ *   but only when the `propertyName` argument is provided
+ *
+ * Note: This helper only checks the shape of the AST. If `require` is locally
+ * bound in the current scope (e.g. by a bundler), callers should additionally
+ * verify that `require` refers to Node's `require()` (see
+ * {@link isNodeRequireInScope}).
+ */
+export declare const isRequireFromUrlModule: (node: Expression | null | undefined, propertyName?: string) => boolean;
+export declare const isNodeRequireInScope: (scope: Scope) => boolean;

package/dist/transforms/is-require-from-url-module.js

@@ -0,0 +1,163 @@
+const getRequireFromUrlModuleArgument = (expression) => {
+    if (expression.type !== "CallExpression")
+        return;
+    if (expression.callee.type !== "Identifier")
+        return;
+    if (expression.callee.name !== "require")
+        return;
+    if (expression.arguments.length !== 1)
+        return;
+    const argument = expression.arguments[0];
+    if (!argument)
+        return;
+    if (argument.type === "StringLiteral") {
+        if (argument.value === "url")
+            return "url";
+        if (argument.value === "node:url")
+            return "node:url";
+        return;
+    }
+    if (argument.type === "TemplateLiteral") {
+        if (argument.expressions.length > 0)
+            return;
+        const quasi = argument.quasis[0];
+        if (!quasi)
+            return;
+        const value = quasi.value.cooked ?? quasi.value.raw;
+        if (value === "url")
+            return "url";
+        if (value === "node:url")
+            return "node:url";
+        return;
+    }
+};
+/**
+ * Returns `true` for:
+ * - `require("url")` / `require("node:url")`
+ * - `require("url").URL` / `require("node:url").URL` (or any other `propertyName`),
+ *   but only when the `propertyName` argument is provided
+ *
+ * Note: This helper only checks the shape of the AST. If `require` is locally
+ * bound in the current scope (e.g. by a bundler), callers should additionally
+ * verify that `require` refers to Node's `require()` (see
+ * {@link isNodeRequireInScope}).
+ */
+export const isRequireFromUrlModule = (node, propertyName) => {
+    if (!node)
+        return false;
+    if (!propertyName)
+        return Boolean(getRequireFromUrlModuleArgument(node));
+    if (node.type !== "MemberExpression")
+        return false;
+    let memberPropertyName = undefined;
+    if (node.computed) {
+        if (node.property.type === "StringLiteral") {
+            memberPropertyName = node.property.value;
+        }
+        else if (node.property.type === "TemplateLiteral" &&
+            node.property.expressions.length === 0 &&
+            node.property.quasis.length === 1) {
+            const quasi = node.property.quasis[0];
+            memberPropertyName = quasi?.value.cooked ?? quasi?.value.raw;
+        }
+    }
+    else if (node.property.type === "Identifier") {
+        memberPropertyName = node.property.name;
+    }
+    const hasMatchingProperty = memberPropertyName === propertyName;
+    if (!hasMatchingProperty)
+        return false;
+    // We only accept a direct `require("url").X` (or `require("node:url").X`)
+    // member expression; deeper chains like `require("url").X.Y` are not relevant
+    // for our current usage and would fail the base `require("url")` check anyway.
+    if (node.object.type !== "CallExpression")
+        return false;
+    if (node.object.callee.type !== "Identifier")
+        return false;
+    if (node.object.callee.name !== "require")
+        return false;
+    return Boolean(getRequireFromUrlModuleArgument(node.object));
+};
+export const isNodeRequireInScope = (scope) => {
+    const requireBinding = scope.getBinding("require");
+    if (!requireBinding) {
+        const program = scope.getProgramParent().block;
+        if (program.type !== "Program")
+            return true;
+        // Ignore type-only module syntax: it's erased at runtime and commonly used
+        // in TS/CJS codebases that still rely on Node's `require`.
+        const hasModuleSyntax = program.body.some((statement) => {
+            if (statement.type === "ImportDeclaration") {
+                return statement.importKind !== "type";
+            }
+            if (statement.type === "ExportAllDeclaration") {
+                return statement.exportKind !== "type";
+            }
+            if (statement.type === "ExportNamedDeclaration") {
+                return statement.exportKind !== "type";
+            }
+            return statement.type === "ExportDefaultDeclaration";
+        });
+        // In value-level modules, an unbound `require` is unlikely to be Node's
+        // `require` (Node ESM doesn't provide it). Treat it as unsafe to avoid
+        // false positives from bundler shims.
+        if (hasModuleSyntax)
+            return false;
+        // In non-module files, assume an unbound `require` is Node's CJS `require`.
+        // This can be false for AMD/UMD/browser bundles, but tightening this would
+        // introduce false negatives for common Node/CJS inputs.
+        return true;
+    }
+    if (!requireBinding.path.isVariableDeclarator())
+        return false;
+    const init = requireBinding.path.node.init;
+    if (init?.type !== "CallExpression")
+        return false;
+    if (init.callee.type === "Identifier") {
+        const createRequireBinding = scope.getBinding(init.callee.name);
+        if (!createRequireBinding)
+            return false;
+        if (!createRequireBinding.path.isImportSpecifier())
+            return false;
+        if (createRequireBinding.path.node.importKind === "type")
+            return false;
+        const imported = createRequireBinding.path.node.imported;
+        const importedName = imported.type === "Identifier" ? imported.name : imported.value;
+        if (importedName !== "createRequire")
+            return false;
+        const importDeclaration = createRequireBinding.path.parentPath;
+        if (!importDeclaration.isImportDeclaration())
+            return false;
+        if (importDeclaration.node.importKind === "type")
+            return false;
+        const source = importDeclaration.node.source.value;
+        return source === "module" || source === "node:module";
+    }
+    if (init.callee.type !== "MemberExpression")
+        return false;
+    if (init.callee.object.type !== "Identifier")
+        return false;
+    const propertyName = init.callee.computed
+        ? init.callee.property.type === "StringLiteral"
+            ? init.callee.property.value
+            : undefined
+        : init.callee.property.type === "Identifier"
+            ? init.callee.property.name
+            : undefined;
+    if (propertyName !== "createRequire")
+        return false;
+    const moduleBindingName = init.callee.object.name;
+    const moduleBinding = scope.getBinding(moduleBindingName);
+    if (!moduleBinding)
+        return false;
+    const moduleBindingPath = moduleBinding.path;
+    if (!moduleBindingPath.isImportDefaultSpecifier() &&
+        !moduleBindingPath.isImportNamespaceSpecifier()) {
+        return false;
+    }
+    const importDeclaration = moduleBindingPath.parentPath;
+    if (!importDeclaration.isImportDeclaration())
+        return false;
+    const source = importDeclaration.node.source.value;
+    return source === "module" || source === "node:module";
+};

package/dist/transforms/rename-search-parameters-variables/get-member-expression-property-name.d.ts

@@ -0,0 +1,2 @@
+import type { MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getMemberExpressionPropertyName: (expression: MemberExpression | OptionalMemberExpression) => string | undefined;

package/dist/transforms/rename-search-parameters-variables/get-member-expression-property-name.js

@@ -0,0 +1,20 @@
+export const getMemberExpressionPropertyName = (expression) => {
+    const key = expression.property;
+    if (!expression.computed) {
+        if (key.type === "Identifier")
+            return key.name;
+        if (key.type === "StringLiteral")
+            return key.value;
+        return undefined;
+    }
+    if (key.type === "StringLiteral")
+        return key.value;
+    if (key.type === "TemplateLiteral" &&
+        key.expressions.length === 0 &&
+        key.quasis.length === 1) {
+        const quasi = key.quasis[0];
+        const cooked = quasi?.value.cooked;
+        return cooked ?? quasi?.value.raw;
+    }
+    return undefined;
+};

package/dist/transforms/rename-search-parameters-variables/get-search-parameters-member-expression.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getSearchParametersMemberExpression: (referencePath: NodePath) => NodePath<MemberExpression | OptionalMemberExpression> | undefined;

package/dist/transforms/rename-search-parameters-variables/get-search-parameters-member-expression.js

@@ -0,0 +1,26 @@
+export const getSearchParametersMemberExpression = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return;
+    if (parent.isMemberExpression() &&
+        parent.node.object === referencePath.node) {
+        return parent;
+    }
+    if (parent.isOptionalMemberExpression() &&
+        parent.node.object === referencePath.node) {
+        return parent;
+    }
+    if (parent.isTSNonNullExpression() &&
+        parent.node.expression === referencePath.node) {
+        const outer = parent.parentPath;
+        if (!outer)
+            return;
+        if (outer.isMemberExpression() && outer.node.object === parent.node) {
+            return outer;
+        }
+        if (outer.isOptionalMemberExpression() &&
+            outer.node.object === parent.node) {
+            return outer;
+        }
+    }
+};

package/dist/transforms/rename-search-parameters-variables/manifest.json

@@ -0,0 +1,20 @@
+{
+    "recommended": true,
+    "notes": "Measured with baseline none: 100.00% of original diff. Added to recommended for readability.",
+    "evaluations": {
+        "legacy:evaluation": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-25T09:49:29.000Z",
+            "changedLines": 0,
+            "durationSeconds": 0,
+            "stableNames": 0
+        },
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-26T07:05:01.592Z",
+            "changedLines": 32,
+            "durationSeconds": 54.402595083,
+            "stableNames": 1358
+        }
+    }
+}

package/dist/transforms/rename-search-parameters-variables/rename-search-parameters-variables-transform.d.ts

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

package/dist/transforms/rename-search-parameters-variables/rename-search-parameters-variables-transform.js

@@ -0,0 +1,75 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getUrlConstructionKind } from "../get-url-construction-kind.js";
+import { isAllowedUrlConstructorInScope } from "../is-allowed-url-constructor-in-scope.js";
+import { isSearchParametersDestructureUsage, isSearchParametersForOfUsage, isSearchParametersPropertyAccess, isSearchParametersSpreadUsage, } from "./search-parameters-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;
+export const renameSearchParametersVariablesTransform = {
+    id: "rename-search-parameters-variables",
+    description: "Renames variables initialized with new URLSearchParams(...) when they’re used (member access, destructuring, for-of, spread)",
+    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;
+                    // Only rename actual bindings. Patterns don't create a stable
+                    // `URLSearchParams` variable to rename, and `URLSearchParams` is
+                    // iterable (not a plain object), so destructuring doesn't map cleanly.
+                    if (path.node.id.type !== "Identifier")
+                        return;
+                    const constructionKind = getUrlConstructionKind(path.scope, path.node.init, "URLSearchParams");
+                    if (!constructionKind)
+                        return;
+                    if (constructionKind === "identifier" &&
+                        !isAllowedUrlConstructorInScope(path.scope, "URLSearchParams")) {
+                        return;
+                    }
+                    const currentName = path.node.id.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    // Unlike `URL`, `URLSearchParams` is frequently used via a single
+                    // method/property call. Construction is already a strong signal, so we
+                    // rename on first evidence of usage.
+                    let hasUsage = false;
+                    for (const referencePath of binding.referencePaths) {
+                        if (isSearchParametersPropertyAccess(referencePath) ||
+                            isSearchParametersForOfUsage(referencePath) ||
+                            isSearchParametersSpreadUsage(referencePath) ||
+                            isSearchParametersDestructureUsage(referencePath)) {
+                            hasUsage = true;
+                            break;
+                        }
+                    }
+                    if (!hasUsage)
+                        return;
+                    const candidateName = "searchParameters";
+                    if (candidateName === currentName)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: candidateName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-search-parameters-variables/search-parameters-usage-heuristics.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+export declare const isSearchParametersPropertyAccess: (referencePath: NodePath) => boolean;
+export declare const isSearchParametersForOfUsage: (referencePath: NodePath) => boolean;
+export declare const isSearchParametersSpreadUsage: (referencePath: NodePath) => boolean;
+export declare const isSearchParametersDestructureUsage: (referencePath: NodePath) => boolean;

package/dist/transforms/rename-search-parameters-variables/search-parameters-usage-heuristics.js

@@ -0,0 +1,151 @@
+import { getMemberExpressionPropertyName } from "./get-member-expression-property-name.js";
+import { getSearchParametersMemberExpression } from "./get-search-parameters-member-expression.js";
+const searchParametersPropertyNames = new Set([
+    "append",
+    "delete",
+    "entries",
+    "forEach",
+    "get",
+    "getAll",
+    "has",
+    "keys",
+    "set",
+    "size",
+    "sort",
+    "toString",
+    "values",
+]);
+export const isSearchParametersPropertyAccess = (referencePath) => {
+    const memberExpression = getSearchParametersMemberExpression(referencePath);
+    if (!memberExpression)
+        return false;
+    const keyName = getMemberExpressionPropertyName(memberExpression.node);
+    if (!keyName)
+        return false;
+    return searchParametersPropertyNames.has(keyName);
+};
+export const isSearchParametersForOfUsage = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (parent.isForOfStatement()) {
+        return parent.node.right === referencePath.node;
+    }
+    if (parent.isTSNonNullExpression() &&
+        parent.node.expression === referencePath.node) {
+        const forOf = parent.parentPath;
+        if (!forOf)
+            return false;
+        if (!forOf.isForOfStatement())
+            return false;
+        return forOf.node.right === parent.node;
+    }
+    return false;
+};
+export const isSearchParametersSpreadUsage = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (!parent)
+        return false;
+    if (parent.isSpreadElement()) {
+        const container = parent.parentPath;
+        if (!container)
+            return false;
+        if (!container.isArrayExpression() &&
+            !container.isCallExpression() &&
+            !container.isNewExpression()) {
+            return false;
+        }
+        return parent.node.argument === referencePath.node;
+    }
+    if (parent.isTSNonNullExpression() &&
+        parent.node.expression === referencePath.node) {
+        const spread = parent.parentPath;
+        if (!spread)
+            return false;
+        if (!spread.isSpreadElement())
+            return false;
+        const container = spread.parentPath;
+        if (!container)
+            return false;
+        if (!container.isArrayExpression() &&
+            !container.isCallExpression() &&
+            !container.isNewExpression()) {
+            return false;
+        }
+        return spread.node.argument === parent.node;
+    }
+    return false;
+};
+const isSearchParametersDestructurePattern = (pattern) => {
+    if (pattern.properties.length === 0)
+        return false;
+    for (const property of pattern.properties) {
+        // Rest properties suggest generic object destructuring, so we stay
+        // conservative and don't treat it as URLSearchParams usage evidence.
+        if (property.type === "RestElement")
+            return false;
+        const keyName = property.computed
+            ? property.key.type === "StringLiteral"
+                ? property.key.value
+                : undefined
+            : property.key.type === "Identifier"
+                ? property.key.name
+                : property.key.type === "StringLiteral"
+                    ? property.key.value
+                    : undefined;
+        if (!keyName)
+            return false;
+        // Be strict: `URLSearchParams` method names overlap with many other APIs, so
+        // we only treat destructuring as usage evidence when *every* key matches.
+        if (!searchParametersPropertyNames.has(keyName))
+            return false;
+    }
+    return true;
+};
+export const isSearchParametersDestructureUsage = (referencePath) => {
+    const parent = referencePath.parentPath;
+    if (parent?.isTSNonNullExpression() &&
+        parent.node.expression === referencePath.node) {
+        const outer = parent.parentPath;
+        if (!outer)
+            return false;
+        if (outer.isVariableDeclarator()) {
+            if (outer.node.init !== parent.node)
+                return false;
+            const id = outer.node.id;
+            if (id.type !== "ObjectPattern")
+                return false;
+            return isSearchParametersDestructurePattern(id);
+        }
+        if (outer.isAssignmentExpression()) {
+            if (outer.node.operator !== "=")
+                return false;
+            if (outer.node.right !== parent.node)
+                return false;
+            const left = outer.node.left;
+            if (left.type !== "ObjectPattern")
+                return false;
+            return isSearchParametersDestructurePattern(left);
+        }
+        return false;
+    }
+    if (parent?.isVariableDeclarator()) {
+        if (parent.node.init !== referencePath.node)
+            return false;
+        const id = parent.node.id;
+        if (id.type !== "ObjectPattern")
+            return false;
+        return isSearchParametersDestructurePattern(id);
+    }
+    if (parent?.isAssignmentExpression()) {
+        if (parent.node.operator !== "=")
+            return false;
+        if (parent.node.right !== referencePath.node)
+            return false;
+        const left = parent.node.left;
+        if (left.type !== "ObjectPattern")
+            return false;
+        return isSearchParametersDestructurePattern(left);
+    }
+    return false;
+};

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

@@ -2,17 +2,11 @@ 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";
+import { getUrlConstructionKind } from "../get-url-construction-kind.js";
+import { isAllowedUrlConstructorInScope } from "../is-allowed-url-constructor-in-scope.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)
@@ -48,14 +42,21 @@ export const renameUrlVariablesTransform = {
                     nodesVisited += 1;
                     if (path.node.id.type !== "Identifier")
                         return;
-                    if (!isUrlConstruction(path.node.init))
+                    const constructionKind = getUrlConstructionKind(path.scope, path.node.init, "URL");
+                    if (!constructionKind)
+                        return;
+                    if (constructionKind === "identifier" &&
+                        !isAllowedUrlConstructorInScope(path.scope, "URL")) {
                         return;
+                    }
                     const currentName = path.node.id.name;
                     if (isStableRenamed(currentName))
                         return;
                     const binding = path.scope.getBinding(currentName);
                     if (!binding)
                         return;
+                    if (!binding.constant)
+                        return;
                     let sawUrlDestructure = false;
                     let propertyAccesses = 0;
                     for (const referencePath of binding.referencePaths) {
@@ -71,12 +72,12 @@ export const renameUrlVariablesTransform = {
                     }
                     if (!sawUrlDestructure && propertyAccesses < 2)
                         return;
+                    // Name collisions (including unresolved program globals) are handled by
+                    // `RenameGroup`/`findAvailableName` so we don't need to bail out early
+                    // when `url` is already referenced elsewhere in the file.
                     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,

package/package.json

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