miniread 1.87.0 → 1.88.0

package/dist/transforms/_generated/manifest.js

@@ -320,10 +320,16 @@ const manifestData = {
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T14:45:47.110Z", "changedLines": 44, "durationSeconds": 167.840422062, "stableNames": 1358 } },
     },
     "rename-string-split-variables": {
-        recommended: true,
-        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+        recommended: false,
+        notes: "Superseded by rename-string-split-variables-v2, which also handles direct split results.",
+        supersededBy: "rename-string-split-variables-v2",
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-27T06:41:49.624Z", "changedLines": 0, "durationSeconds": 149.03264720899998, "stableNames": 1357 } },
     },
+    "rename-string-split-variables-v2": {
+        recommended: true,
+        notes: "Extends manual split helper renames to include direct split results. v2 helper modules are intentionally self-contained to match the project convention for versioned transforms.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99811516350957, "evaluatedAt": "2026-02-06T14:53:55.285Z", "changedLines": 1197, "durationSeconds": 209.837459189, "stableNames": 1359 } },
+    },
     "rename-this-aliases": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures.",
@@ -526,7 +532,7 @@ export const recommendedTransformIds = [
     "rename-search-parameters-variables",
     "rename-setstate-updater-parameters",
     "rename-file-extension-variables",
-    "rename-string-split-variables",
+    "rename-string-split-variables-v2",
     "rename-this-aliases",
     "rename-timeout-promises",
     "rename-timeout-ids",

package/dist/transforms/_generated/registry.js

@@ -67,6 +67,7 @@ import { renameSafePropertyAccessorParametersTransform } from "../rename-safe-pr
 import { renameSearchParametersVariablesTransform } from "../rename-search-parameters-variables/rename-search-parameters-variables-transform.js";
 import { renameSetstateUpdaterParametersTransform } from "../rename-setstate-updater-parameters/rename-setstate-updater-parameters-transform.js";
 import { renameStringSplitVariablesTransform } from "../rename-string-split-variables/rename-string-split-variables-transform.js";
+import { renameStringSplitVariablesV2Transform } from "../rename-string-split-variables-v2/rename-string-split-variables-v2-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";
@@ -161,6 +162,7 @@ export const transformRegistry = {
     [renameSearchParametersVariablesTransform.id]: renameSearchParametersVariablesTransform,
     [renameSetstateUpdaterParametersTransform.id]: renameSetstateUpdaterParametersTransform,
     [renameStringSplitVariablesTransform.id]: renameStringSplitVariablesTransform,
+    [renameStringSplitVariablesV2Transform.id]: renameStringSplitVariablesV2Transform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 30.431627556309493,
-        "notes": "Measured with baseline none: 30.43% of original diff."
+        "diffSizePercent": 30.510828892164643,
+        "notes": "Measured with baseline none: 30.51% 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", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "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-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-platform-win32-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-default-options-parameters-v3", "rename-deferred-resolve-parameters", "rename-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "rename-error-variables", "rename-event-parameters", "rename-add-event-listener-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-indexeddb-request-variables", "rename-loop-index-variables-v3", "rename-queue-traversal-variables", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-object-keys-reducer-parameters", "rename-object-entries-parameters", "rename-parameters-to-match-properties-v2", "rename-invalid-parameter-arguments", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-setstate-updater-parameters", "rename-file-extension-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-promises", "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", "rename-worker-handles", "rename-zod-check-parameters", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "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-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-platform-win32-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-default-options-parameters-v3", "rename-deferred-resolve-parameters", "rename-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "rename-error-variables", "rename-event-parameters", "rename-add-event-listener-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-indexeddb-request-variables", "rename-loop-index-variables-v3", "rename-queue-traversal-variables", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-object-keys-reducer-parameters", "rename-object-entries-parameters", "rename-parameters-to-match-properties-v2", "rename-invalid-parameter-arguments", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-setstate-updater-parameters", "rename-file-extension-variables", "rename-string-split-variables-v2", "rename-this-aliases", "rename-timeout-promises", "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", "rename-worker-handles", "rename-zod-check-parameters", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

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

@@ -78,7 +78,7 @@ export const recommendedTransformOrder = [
     "rename-search-parameters-variables",
     "rename-setstate-updater-parameters",
     "rename-file-extension-variables",
-    "rename-string-split-variables",
+    "rename-string-split-variables-v2",
     "rename-this-aliases",
     "rename-timeout-promises",
     "rename-timeout-ids",

package/dist/transforms/rename-string-split-variables/manifest.json

@@ -1,5 +1,6 @@
 {
-    "recommended": true,
+    "recommended": false,
+    "supersededBy": "rename-string-split-variables-v2",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
@@ -9,5 +10,5 @@
             "stableNames": 1357
         }
     },
-    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+    "notes": "Superseded by rename-string-split-variables-v2, which also handles direct split results."
 }

package/dist/transforms/rename-string-split-variables-v2/detect-split-result-candidate.d.ts

@@ -0,0 +1,7 @@
+import type { VariableDeclarator } from "@babel/types";
+type SplitResultCandidate = {
+    currentName: string;
+    requiresGlobalBoolean: boolean;
+};
+export declare const detectSplitResultCandidate: (node: VariableDeclarator) => SplitResultCandidate | undefined;
+export {};

package/dist/transforms/rename-string-split-variables-v2/detect-split-result-candidate.js

@@ -0,0 +1,117 @@
+import { getUnwrappedCallExpression } from "./unwrap-transparent-expression.js";
+const isAllowedSplitDelimiter = (expression) => {
+    return (expression.type === "StringLiteral" ||
+        expression.type === "RegExpLiteral" ||
+        expression.type === "Identifier");
+};
+const isAllowedSplitLimit = (expression) => {
+    if (expression.type === "NumericLiteral")
+        return true;
+    if (expression.type === "Identifier")
+        return true;
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "+" && expression.operator !== "-")
+        return false;
+    return expression.argument.type === "NumericLiteral";
+};
+const getMemberProperty = (callee) => {
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") {
+        return;
+    }
+    return callee;
+};
+const isSplitMember = (member) => {
+    const property = member.property;
+    if (property.type === "Identifier") {
+        if (member.computed)
+            return false;
+        return property.name === "split";
+    }
+    if (property.type === "StringLiteral") {
+        if (!member.computed)
+            return false;
+        return property.value === "split";
+    }
+    return false;
+};
+const hasSupportedSplitArguments = (node) => {
+    if (node.arguments.length > 2)
+        return false;
+    if (node.arguments.length === 0)
+        return true;
+    const [firstArgument] = node.arguments;
+    if (!firstArgument ||
+        firstArgument.type === "SpreadElement" ||
+        firstArgument.type === "ArgumentPlaceholder") {
+        return false;
+    }
+    if (!isAllowedSplitDelimiter(firstArgument))
+        return false;
+    const secondArgument = node.arguments[1];
+    if (!secondArgument)
+        return true;
+    if (secondArgument.type === "SpreadElement" ||
+        secondArgument.type === "ArgumentPlaceholder") {
+        return false;
+    }
+    return isAllowedSplitLimit(secondArgument);
+};
+const isSplitCall = (node) => {
+    const member = getMemberProperty(node.callee);
+    if (!member)
+        return false;
+    if (!isSplitMember(member))
+        return false;
+    return hasSupportedSplitArguments(node);
+};
+const isFilterBooleanCall = (node) => {
+    const member = getMemberProperty(node.callee);
+    if (!member)
+        return false;
+    const property = member.property;
+    if (member.computed && property.type !== "StringLiteral")
+        return false;
+    if (!member.computed && property.type !== "Identifier")
+        return false;
+    if (property.type === "Identifier" && property.name !== "filter")
+        return false;
+    if (property.type === "StringLiteral" && property.value !== "filter")
+        return false;
+    if (node.arguments.length !== 1)
+        return false;
+    const [predicate] = node.arguments;
+    if (!predicate)
+        return false;
+    return predicate.type === "Identifier" && predicate.name === "Boolean";
+};
+export const detectSplitResultCandidate = (node) => {
+    if (node.id.type !== "Identifier")
+        return undefined;
+    const init = getUnwrappedCallExpression(node.init);
+    if (!init)
+        return undefined;
+    if (isSplitCall(init)) {
+        return {
+            currentName: node.id.name,
+            requiresGlobalBoolean: false,
+        };
+    }
+    if (isFilterBooleanCall(init) &&
+        (init.callee.type === "MemberExpression" ||
+            init.callee.type === "OptionalMemberExpression")) {
+        if (init.callee.object.type === "Super")
+            return undefined;
+        const filterTarget = getUnwrappedCallExpression(init.callee.object);
+        if (!filterTarget)
+            return undefined;
+        if (!isSplitCall(filterTarget))
+            return undefined;
+        return {
+            currentName: node.id.name,
+            requiresGlobalBoolean: true,
+        };
+    }
+    return undefined;
+};

package/dist/transforms/rename-string-split-variables-v2/get-split-helper-info.d.ts

@@ -0,0 +1,8 @@
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+type SplitHelperInfo = SplitHelperDeclarations & {
+    inputName: string;
+    delimiterName: string;
+};
+export declare const getSplitHelperInfo: (node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression) => SplitHelperInfo | undefined;
+export {};

package/dist/transforms/rename-string-split-variables-v2/get-split-helper-info.js

@@ -0,0 +1,40 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { getSplitHelperDeclarationsFromStatements } from "./split-helper-declarations.js";
+import { isSplitHelperLoop } from "./split-helper-loop.js";
+import { isSplitHelperTail } from "./split-helper-tail.js";
+export const getSplitHelperInfo = (node) => {
+    if (node.params.length !== 2)
+        return undefined;
+    const inputParameter = node.params[0];
+    const delimiterParameter = node.params[1];
+    if (!isIdentifierNode(inputParameter) ||
+        !isIdentifierNode(delimiterParameter))
+        return undefined;
+    if (node.body.type !== "BlockStatement")
+        return undefined;
+    const statements = node.body.body;
+    const declarationsMatch = getSplitHelperDeclarationsFromStatements(statements, inputParameter.name, delimiterParameter.name);
+    if (!declarationsMatch)
+        return undefined;
+    const { nextStatementIndex, ...declarations } = declarationsMatch;
+    const loopStatement = statements[nextStatementIndex];
+    if (!isSplitHelperLoop(loopStatement, declarations, inputParameter.name, delimiterParameter.name))
+        return undefined;
+    const tailStatements = statements.slice(nextStatementIndex + 1);
+    if (!isSplitHelperTail(tailStatements, declarations, inputParameter.name))
+        return undefined;
+    const uniqueNames = new Set([
+        inputParameter.name,
+        delimiterParameter.name,
+        declarations.partsName,
+        declarations.startIndexName,
+        declarations.delimiterIndexName,
+    ]);
+    if (uniqueNames.size !== 5)
+        return undefined;
+    return {
+        inputName: inputParameter.name,
+        delimiterName: delimiterParameter.name,
+        ...declarations,
+    };
+};

package/dist/transforms/rename-string-split-variables-v2/has-array-like-split-usage.d.ts

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

package/dist/transforms/rename-string-split-variables-v2/has-array-like-split-usage.js

@@ -0,0 +1,70 @@
+const ARRAY_USAGE_MEMBER_NAMES = new Set([
+    "length",
+    "join",
+    "slice",
+    "map",
+    "filter",
+    "find",
+    "some",
+    "every",
+    "forEach",
+    "includes",
+    "indexOf",
+    "at",
+    "pop",
+    "push",
+    "shift",
+    "unshift",
+    "concat",
+]);
+export const hasArrayLikeSplitUsage = (binding) => {
+    // Intentionally conservative: require local array-like evidence to reduce
+    // false positives from arbitrary `.split(...)` methods on non-strings.
+    return binding.referencePaths.some((referencePath) => {
+        const parentPath = referencePath.parentPath;
+        if (!parentPath)
+            return false;
+        if (parentPath.isMemberExpression() ||
+            parentPath.isOptionalMemberExpression()) {
+            const member = parentPath.node;
+            if (member.object !== referencePath.node)
+                return false;
+            if (member.computed) {
+                if (member.property.type === "NumericLiteral")
+                    return true;
+                if (member.property.type !== "StringLiteral")
+                    return false;
+                return /^\d+$/u.test(member.property.value);
+            }
+            if (member.property.type !== "Identifier")
+                return false;
+            return ARRAY_USAGE_MEMBER_NAMES.has(member.property.name);
+        }
+        if (parentPath.isVariableDeclarator()) {
+            const { id, init } = parentPath.node;
+            if (init !== referencePath.node)
+                return false;
+            if (id.type === "ArrayPattern" || id.type === "ObjectPattern") {
+                return true;
+            }
+        }
+        if (parentPath.isAssignmentExpression()) {
+            const { left, right, operator } = parentPath.node;
+            if (operator !== "=" || right !== referencePath.node)
+                return false;
+            if (left.type === "ArrayPattern" || left.type === "ObjectPattern") {
+                return true;
+            }
+        }
+        if (parentPath.isForOfStatement()) {
+            return parentPath.node.right === referencePath.node;
+        }
+        if (parentPath.isSpreadElement()) {
+            return parentPath.node.argument === referencePath.node;
+        }
+        if (parentPath.isArrayExpression()) {
+            return parentPath.node.elements.includes(referencePath.node);
+        }
+        return false;
+    });
+};

package/dist/transforms/rename-string-split-variables-v2/is-runtime-boolean-shadowed.d.ts

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

package/dist/transforms/rename-string-split-variables-v2/is-runtime-boolean-shadowed.js

@@ -0,0 +1,46 @@
+const isTypeOnlyImportBinding = (scope) => {
+    const binding = scope.getBinding("Boolean");
+    if (!binding)
+        return false;
+    const parentImport = binding.path.parentPath?.isImportDeclaration()
+        ? binding.path.parentPath
+        : binding.path.findParent((path) => path.isImportDeclaration());
+    if (!parentImport?.isImportDeclaration())
+        return false;
+    if (parentImport.node.importKind === "type")
+        return true;
+    if (!binding.path.isImportSpecifier())
+        return false;
+    return binding.path.node.importKind === "type";
+};
+const isDeclareValueBinding = (scope) => {
+    const binding = scope.getBinding("Boolean");
+    if (!binding)
+        return false;
+    if (binding.path.isFunctionDeclaration() &&
+        binding.path.node.declare === true) {
+        return true;
+    }
+    if (binding.path.isClassDeclaration() && binding.path.node.declare === true) {
+        return true;
+    }
+    const declarationPath = binding.path.findParent((path) => path.isVariableDeclaration());
+    if (!declarationPath?.isVariableDeclaration())
+        return false;
+    return declarationPath.node.declare === true;
+};
+export const isRuntimeBooleanShadowed = (scope) => {
+    const binding = scope.getBinding("Boolean");
+    if (!binding)
+        return false;
+    if (isTypeOnlyImportBinding(scope))
+        return false;
+    if (isDeclareValueBinding(scope))
+        return false;
+    if (binding.path.isTSTypeAliasDeclaration() ||
+        binding.path.isTSInterfaceDeclaration() ||
+        binding.path.isTSTypeParameter()) {
+        return false;
+    }
+    return true;
+};

package/dist/transforms/rename-string-split-variables-v2/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99811516350957,
+            "evaluatedAt": "2026-02-06T14:53:55.285Z",
+            "changedLines": 1197,
+            "durationSeconds": 209.837459189,
+            "stableNames": 1359
+        }
+    },
+    "notes": "Extends manual split helper renames to include direct split results. v2 helper modules are intentionally self-contained to match the project convention for versioned transforms."
+}

package/dist/transforms/rename-string-split-variables-v2/rename-string-split-variables-v2-transform.d.ts

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

package/dist/transforms/rename-string-split-variables-v2/rename-string-split-variables-v2-transform.js

@@ -0,0 +1,116 @@
+import { createRequire } from "node:module";
+import { collectExportedNames } from "../../core/collect-exported-names.js";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess } from "../../core/types.js";
+import { hasDynamicNameLookup } from "../has-dynamic-name-lookup.js";
+import { detectSplitResultCandidate } from "./detect-split-result-candidate.js";
+import { getSplitHelperInfo } from "./get-split-helper-info.js";
+import { hasArrayLikeSplitUsage } from "./has-array-like-split-usage.js";
+import { isRuntimeBooleanShadowed } from "./is-runtime-boolean-shadowed.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const collectSplitHelperRenames = (path, group) => {
+    // Intentionally no early-return based on stable-renamed params:
+    // parameters can be stable while helper locals are still minified.
+    const info = getSplitHelperInfo(path.node);
+    if (!info)
+        return;
+    const scope = path.scope;
+    group.add({
+        scope,
+        currentName: info.inputName,
+        baseName: "input",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterName,
+        baseName: "delimiter",
+    });
+    group.add({
+        scope,
+        currentName: info.partsName,
+        baseName: "parts",
+    });
+    group.add({
+        scope,
+        currentName: info.startIndexName,
+        baseName: "startIndex",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterIndexName,
+        baseName: "delimiterIndex",
+    });
+};
+const collectSplitResultRenames = (path, group, exportedNames) => {
+    const candidate = detectSplitResultCandidate(path.node);
+    if (!candidate)
+        return;
+    const { currentName } = candidate;
+    if (isStableRenamed(currentName))
+        return;
+    const binding = path.scope.getBinding(currentName);
+    if (!binding)
+        return;
+    if (!binding.constant)
+        return;
+    if (!hasArrayLikeSplitUsage(binding))
+        return;
+    if (candidate.requiresGlobalBoolean &&
+        // Candidate detection currently only marks `.filter(Boolean)` in the
+        // initializer expression, so declaration scope matches reference scope.
+        isRuntimeBooleanShadowed(binding.path.scope)) {
+        return;
+    }
+    if (binding.scope.block.type === "Program" &&
+        exportedNames.has(currentName)) {
+        return;
+    }
+    group.add({
+        scope: binding.scope,
+        currentName,
+        baseName: "parts",
+    });
+};
+export const renameStringSplitVariablesV2Transform = {
+    id: "rename-string-split-variables-v2",
+    description: "Renames variables holding string split results to stable $parts names (covers manual helpers and direct split results)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const hasDynamicLookup = hasDynamicNameLookup(fileInfo.ast);
+            const group = new RenameGroup();
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                FunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                ArrowFunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    // Dynamic name lookup can observe program-scope bindings by name, so
+                    // we skip direct split-result renames in those files. Helper renames
+                    // stay enabled because `getSplitHelperInfo` only matches strict
+                    // local helper structure and renames function-scoped locals.
+                    if (hasDynamicLookup)
+                        return;
+                    collectSplitResultRenames(path, group, exportedNames);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-declarations.d.ts

@@ -0,0 +1,11 @@
+import type { Statement } from "@babel/types";
+export type SplitHelperDeclarations = {
+    partsName: string;
+    startIndexName: string;
+    delimiterIndexName: string;
+};
+type SplitHelperDeclarationsMatch = SplitHelperDeclarations & {
+    nextStatementIndex: number;
+};
+export declare const getSplitHelperDeclarationsFromStatements: (statements: Statement[], inputName: string, delimiterName: string) => SplitHelperDeclarationsMatch | undefined;
+export {};

package/dist/transforms/rename-string-split-variables-v2/split-helper-declarations.js

@@ -0,0 +1,80 @@
+import { isIdentifierNode, isMemberCall, isNumericLiteralNode, } from "./split-helper-guards.js";
+const isDirectivePrologueStatement = (statement) => {
+    // In JavaScript, any leading sequence of `"..."`; expression statements is the
+    // "directive prologue" (most commonly `"use strict";`). Babel sometimes also
+    // marks these with `statement.directive`, but we intentionally only rely on
+    // the lexical shape so we still match after AST rewrites.
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    return statement.expression.type === "StringLiteral";
+};
+const getVariableDeclarators = (statement) => {
+    if (statement.type !== "VariableDeclaration")
+        return undefined;
+    if (statement.declarations.length === 0)
+        return undefined;
+    return statement.declarations;
+};
+export const getSplitHelperDeclarationsFromStatements = (statements, inputName, delimiterName) => {
+    const declarators = [];
+    let statementIndex = 0;
+    while (statementIndex < statements.length) {
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        if (!isDirectivePrologueStatement(statement))
+            break;
+        statementIndex++;
+    }
+    if (statementIndex >= statements.length)
+        return undefined;
+    let declarationStatementsConsumed = 0;
+    while (declarators.length < 3) {
+        if (statementIndex >= statements.length)
+            return undefined;
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        const statementDeclarators = getVariableDeclarators(statement);
+        if (!statementDeclarators)
+            return undefined;
+        declarationStatementsConsumed++;
+        if (declarationStatementsConsumed > 3)
+            return undefined;
+        const totalDeclarators = declarators.length + statementDeclarators.length;
+        if (totalDeclarators > 3)
+            return undefined;
+        declarators.push(...statementDeclarators);
+        statementIndex++;
+    }
+    const identifierDeclarators = declarators.filter((declarator) => declarator.id.type === "Identifier");
+    if (identifierDeclarators.length !== declarators.length)
+        return undefined;
+    const partsDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "ArrayExpression")
+            return false;
+        return declarator.init.elements.length === 0;
+    });
+    const startDeclarator = identifierDeclarators.find((declarator) => isNumericLiteralNode(declarator.init ?? undefined, 0));
+    const indexDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(declarator.init, inputName, "indexOf"))
+            return false;
+        if (!isIdentifierNode(declarator.init.arguments[0], delimiterName))
+            return false;
+        if (declarator.init.arguments.length === 1)
+            return true;
+        if (declarator.init.arguments.length !== 2)
+            return false;
+        return isNumericLiteralNode(declarator.init.arguments[1], 0);
+    });
+    if (!partsDeclarator || !startDeclarator || !indexDeclarator)
+        return undefined;
+    return {
+        partsName: partsDeclarator.id.name,
+        startIndexName: startDeclarator.id.name,
+        delimiterIndexName: indexDeclarator.id.name,
+        nextStatementIndex: statementIndex,
+    };
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-guards.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryExpression, CallExpression, Identifier, Node, NumericLiteral, Statement } from "@babel/types";
+export declare const isIdentifierNode: (node: Node | undefined, name?: string) => node is Identifier;
+export declare const isNumericLiteralNode: (node: Node | undefined, value?: number) => node is NumericLiteral;
+export declare const getBlockStatements: (statement: Statement) => Statement[] | undefined;
+export declare const isMemberCall: (expression: CallExpression, objectName: string, propertyName: string) => boolean;
+export declare const isPushSliceStatement: (statement: Statement, partsName: string, inputName: string, startName: string, endName?: string) => boolean;
+export declare const isAssignmentStatement: (statement: Statement, targetName: string, expectedExpression: (expression: Node) => boolean) => boolean;
+export declare const isBinaryExpression: (expression: Node, operator: BinaryExpression["operator"], leftName: string, rightValue: number) => boolean;

package/dist/transforms/rename-string-split-variables-v2/split-helper-guards.js

@@ -0,0 +1,73 @@
+export const isIdentifierNode = (node, name) => {
+    if (node?.type !== "Identifier")
+        return false;
+    return name ? node.name === name : true;
+};
+export const isNumericLiteralNode = (node, value) => {
+    if (node?.type !== "NumericLiteral")
+        return false;
+    return value === undefined ? true : node.value === value;
+};
+export const getBlockStatements = (statement) => {
+    if (statement.type !== "BlockStatement")
+        return undefined;
+    return statement.body;
+};
+export const isMemberCall = (expression, objectName, propertyName) => {
+    const callee = expression.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, objectName))
+        return false;
+    return isIdentifierNode(callee.property, propertyName);
+};
+const isSliceCallWithArguments = (expression, inputName, startName, endName) => {
+    if (!isMemberCall(expression, inputName, "slice"))
+        return false;
+    if (!isIdentifierNode(expression.arguments[0], startName))
+        return false;
+    if (endName === undefined) {
+        return expression.arguments.length === 1;
+    }
+    if (!isIdentifierNode(expression.arguments[1], endName))
+        return false;
+    return expression.arguments.length === 2;
+};
+export const isPushSliceStatement = (statement, partsName, inputName, startName, endName) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "CallExpression")
+        return false;
+    if (!isMemberCall(expression, partsName, "push"))
+        return false;
+    if (expression.arguments.length !== 1)
+        return false;
+    const argument0 = expression.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    return isSliceCallWithArguments(argument0, inputName, startName, endName);
+};
+export const isAssignmentStatement = (statement, targetName, expectedExpression) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "AssignmentExpression")
+        return false;
+    if (expression.operator !== "=")
+        return false;
+    if (!isIdentifierNode(expression.left, targetName))
+        return false;
+    return expectedExpression(expression.right);
+};
+export const isBinaryExpression = (expression, operator, leftName, rightValue) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== operator)
+        return false;
+    if (!isIdentifierNode(expression.left, leftName))
+        return false;
+    return isNumericLiteralNode(expression.right, rightValue);
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-loop.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperLoop: (statement: Statement | undefined, declarations: SplitHelperDeclarations, inputName: string, delimiterName: string) => boolean;

package/dist/transforms/rename-string-split-variables-v2/split-helper-loop.js

@@ -0,0 +1,116 @@
+import { isAssignmentStatement, isBinaryExpression, isIdentifierNode, isMemberCall, isNumericLiteralNode, isPushSliceStatement, } from "./split-helper-guards.js";
+const isNegativeOneLiteral = (expression) => {
+    if (expression.type === "NumericLiteral")
+        return expression.value === -1;
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "-")
+        return false;
+    if (expression.argument.type !== "NumericLiteral")
+        return false;
+    return expression.argument.value === 1;
+};
+const isNotMinusOneBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== "!==" && expression.operator !== "!=")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isFoundBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== ">")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isBitwiseNotTest = (expression, name) => {
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "~")
+        return false;
+    return isIdentifierNode(expression.argument, name);
+};
+export const isSplitHelperLoop = (statement, declarations, inputName, delimiterName) => {
+    if (statement?.type !== "WhileStatement")
+        return false;
+    const isNonNegativeTest = (expression) => {
+        if (isBinaryExpression(expression, ">=", declarations.delimiterIndexName, 0)) {
+            return true;
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "<=")
+            return false;
+        if (!isNumericLiteralNode(expression.left, 0))
+            return false;
+        return isIdentifierNode(expression.right, declarations.delimiterIndexName);
+    };
+    if (!isNonNegativeTest(statement.test) &&
+        !isNotMinusOneBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isFoundBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isBitwiseNotTest(statement.test, declarations.delimiterIndexName)) {
+        return false;
+    }
+    if (statement.body.type !== "BlockStatement")
+        return false;
+    if (statement.body.body.length !== 3)
+        return false;
+    const [pushStatement, advanceStatement, updateStatement] = statement.body.body;
+    if (!pushStatement || !advanceStatement || !updateStatement)
+        return false;
+    if (!isPushSliceStatement(pushStatement, declarations.partsName, inputName, declarations.startIndexName, declarations.delimiterIndexName))
+        return false;
+    const isAdvanceExpression = (expression) => {
+        if (isBinaryExpression(expression, "+", declarations.delimiterIndexName, 1)) {
+            return true;
+        }
+        if (expression.type === "BinaryExpression" && expression.operator === "+") {
+            if (isNumericLiteralNode(expression.left, 1) &&
+                isIdentifierNode(expression.right, declarations.delimiterIndexName)) {
+                return true;
+            }
+            const left = expression.left;
+            const right = expression.right;
+            if (left.type === "MemberExpression" &&
+                !left.computed &&
+                isIdentifierNode(left.object, delimiterName) &&
+                isIdentifierNode(left.property, "length") &&
+                isIdentifierNode(right, declarations.delimiterIndexName)) {
+                return true;
+            }
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "+")
+            return false;
+        if (!isIdentifierNode(expression.left, declarations.delimiterIndexName))
+            return false;
+        const right = expression.right;
+        if (right.type !== "MemberExpression")
+            return false;
+        if (right.computed)
+            return false;
+        if (!isIdentifierNode(right.object, delimiterName))
+            return false;
+        return isIdentifierNode(right.property, "length");
+    };
+    if (!isAssignmentStatement(advanceStatement, declarations.startIndexName, isAdvanceExpression))
+        return false;
+    const isUpdateExpression = (expression) => {
+        if (expression.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(expression, inputName, "indexOf"))
+            return false;
+        if (expression.arguments.length !== 2)
+            return false;
+        if (!isIdentifierNode(expression.arguments[0], delimiterName))
+            return false;
+        return isIdentifierNode(expression.arguments[1], declarations.startIndexName);
+    };
+    return isAssignmentStatement(updateStatement, declarations.delimiterIndexName, isUpdateExpression);
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail-expressions.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isReturnWithOptionalTailPush: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail-expressions.js

@@ -0,0 +1,86 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { isAtEndTest, isShouldPushTailTest, } from "./split-helper-tail-tests.js";
+const isPushSliceCallExpression = (node, declarations, inputName) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, declarations.partsName))
+        return false;
+    if (!isIdentifierNode(callee.property, "push"))
+        return false;
+    if (node.arguments.length !== 1)
+        return false;
+    const argument0 = node.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    const sliceCallee = argument0.callee;
+    if (sliceCallee.type !== "MemberExpression")
+        return false;
+    if (sliceCallee.computed)
+        return false;
+    if (!isIdentifierNode(sliceCallee.object, inputName))
+        return false;
+    if (!isIdentifierNode(sliceCallee.property, "slice"))
+        return false;
+    if (argument0.arguments.length !== 1)
+        return false;
+    return isIdentifierNode(argument0.arguments[0], declarations.startIndexName);
+};
+const isPushSequenceExpression = (node, declarations, inputName) => {
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isPushSliceCallExpression(first, declarations, inputName))
+        return false;
+    return isIdentifierNode(second, declarations.partsName);
+};
+export const isReturnWithOptionalTailPush = (node, declarations, inputName) => {
+    if (node.type === "ConditionalExpression") {
+        const testIsShouldPush = isShouldPushTailTest(node.test, declarations, inputName);
+        const testIsAtEnd = isAtEndTest(node.test, declarations, inputName);
+        if (!testIsShouldPush && !testIsAtEnd)
+            return false;
+        const consequent = node.consequent;
+        const alternate = node.alternate;
+        const consequentIsParts = isIdentifierNode(consequent, declarations.partsName);
+        const alternateIsParts = isIdentifierNode(alternate, declarations.partsName);
+        const consequentIsPush = isPushSequenceExpression(consequent, declarations, inputName);
+        const alternateIsPush = isPushSequenceExpression(alternate, declarations, inputName);
+        if (testIsShouldPush) {
+            if (!consequentIsPush)
+                return false;
+            return alternateIsParts;
+        }
+        if (!testIsAtEnd)
+            return false;
+        if (!alternateIsPush)
+            return false;
+        return consequentIsParts;
+    }
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isIdentifierNode(second, declarations.partsName))
+        return false;
+    if (isPushSliceCallExpression(first, declarations, inputName))
+        return true;
+    if (first.type === "LogicalExpression" &&
+        first.operator === "&&" &&
+        isShouldPushTailTest(first.left, declarations, inputName) &&
+        isPushSliceCallExpression(first.right, declarations, inputName)) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail-tests.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isShouldPushTailTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;
+export declare const isAtEndTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail-tests.js

@@ -0,0 +1,39 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+const isInputLengthMemberExpression = (node, inputName) => {
+    if (node.type !== "MemberExpression")
+        return false;
+    if (node.computed)
+        return false;
+    if (!isIdentifierNode(node.object, inputName))
+        return false;
+    return isIdentifierNode(node.property, "length");
+};
+export const isShouldPushTailTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if ((operator === "!==" || operator === "!=" || operator === "<") &&
+        isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    if ((operator === "!==" || operator === "!=" || operator === ">") &&
+        isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName)) {
+        return true;
+    }
+    return false;
+};
+export const isAtEndTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if (operator !== "===" && operator !== "==")
+        return false;
+    if (isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    return (isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName));
+};

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperTail: (tailStatements: Statement[], declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables-v2/split-helper-tail.js

@@ -0,0 +1,49 @@
+import { getBlockStatements, isIdentifierNode, isPushSliceStatement, } from "./split-helper-guards.js";
+import { isReturnWithOptionalTailPush } from "./split-helper-tail-expressions.js";
+import { isShouldPushTailTest } from "./split-helper-tail-tests.js";
+const isReturnPartsStatement = (statement, declarations) => {
+    if (statement?.type !== "ReturnStatement")
+        return false;
+    return isIdentifierNode(statement.argument ?? undefined, declarations.partsName);
+};
+export const isSplitHelperTail = (tailStatements, declarations, inputName) => {
+    if (tailStatements.length === 2) {
+        const [firstTailStatement, secondTailStatement] = tailStatements;
+        if (!firstTailStatement || !secondTailStatement)
+            return false;
+        if (firstTailStatement.type === "IfStatement") {
+            const ifStatement = firstTailStatement;
+            const returnStatement = secondTailStatement;
+            if (ifStatement.alternate)
+                return false;
+            if (!isShouldPushTailTest(ifStatement.test, declarations, inputName))
+                return false;
+            const ifStatements = getBlockStatements(ifStatement.consequent) ?? [
+                ifStatement.consequent,
+            ];
+            if (ifStatements.length !== 1)
+                return false;
+            const ifConsequent = ifStatements[0];
+            if (!ifConsequent)
+                return false;
+            if (!isPushSliceStatement(ifConsequent, declarations.partsName, inputName, declarations.startIndexName))
+                return false;
+            return isReturnPartsStatement(returnStatement, declarations);
+        }
+        if (isPushSliceStatement(firstTailStatement, declarations.partsName, inputName, declarations.startIndexName)) {
+            return isReturnPartsStatement(secondTailStatement, declarations);
+        }
+        return false;
+    }
+    if (tailStatements.length !== 1)
+        return false;
+    const tailStatement = tailStatements[0];
+    if (!tailStatement)
+        return false;
+    if (tailStatement.type !== "ReturnStatement")
+        return false;
+    const argument = tailStatement.argument;
+    if (!argument)
+        return false;
+    return isReturnWithOptionalTailPush(argument, declarations, inputName);
+};

package/dist/transforms/rename-string-split-variables-v2/unwrap-transparent-expression.d.ts

@@ -0,0 +1,2 @@
+import type { CallExpression, Expression, OptionalCallExpression } from "@babel/types";
+export declare const getUnwrappedCallExpression: (expression: Expression | null | undefined) => CallExpression | OptionalCallExpression | undefined;

package/dist/transforms/rename-string-split-variables-v2/unwrap-transparent-expression.js

@@ -0,0 +1,22 @@
+const unwrapTransparentExpression = (expression) => {
+    let current = expression;
+    while (current.type === "ParenthesizedExpression" ||
+        current.type === "TSAsExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "TSInstantiationExpression" ||
+        current.type === "TSNonNullExpression" ||
+        current.type === "TSSatisfiesExpression") {
+        current = current.expression;
+    }
+    return current;
+};
+export const getUnwrappedCallExpression = (expression) => {
+    if (!expression)
+        return undefined;
+    const unwrapped = unwrapTransparentExpression(expression);
+    if (unwrapped.type !== "CallExpression" &&
+        unwrapped.type !== "OptionalCallExpression") {
+        return undefined;
+    }
+    return unwrapped;
+};

package/package.json

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