miniread 1.8.0 → 1.10.0

package/dist/scripts/snapshot/run-snapshot-cli.js

@@ -70,24 +70,11 @@ export const runSnapshotCli = async (argv) => {
     }
     const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
     const actualPath = path.join(testCaseDirectory, `${transform}.js`);
-    // Run the transform and format
-    let actualOutput;
-    try {
-        const rawOutput = await runTransform(basePath, transform);
-        actualOutput = await formatCode(rawOutput);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error running transform: ${message}`);
-        return 1;
-    }
     if (expected) {
         // Expected-file workflow
         // Step 1: Check if expected file exists, create from base.js if not
-        let expectedExists = false;
         try {
             await fs.access(expectedPath);
-            expectedExists = true;
         }
         catch {
             // Expected file doesn't exist, create it from base.js
@@ -96,67 +83,69 @@ export const runSnapshotCli = async (argv) => {
             await fs.writeFile(expectedPath, formattedBase);
             console.log(`Created: test-cases/${testcase}/${transform}-expected.js`);
             console.log("Edit this file to match your expected output, then re-run.");
-        }
-        // Step 2: Write actual output
-        await fs.writeFile(actualPath, actualOutput);
-        console.log(`Created: test-cases/${testcase}/${transform}.js`);
-        if (!expectedExists) {
-            // First run - just created expected file, user needs to edit it
-            return 0;
-        }
-        // Step 3: Compare expected vs actual
-        const expectedContent = await fs.readFile(expectedPath, "utf8");
-        if (expectedContent === actualOutput) {
-            // Success! Delete expected file
-            await fs.unlink(expectedPath);
-            console.log(`\nSuccess: Output matches expected.`);
-            console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
-            console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
             return 0;
         }
-        else {
-            // Diff - show the difference
-            console.log(`\nDiff: expected vs actual`);
-            console.log("---");
-            // Simple line-by-line diff output
-            const expectedLines = expectedContent.split("\n");
-            const actualLines = actualOutput.split("\n");
-            const maxLines = Math.max(expectedLines.length, actualLines.length);
-            let hasDiff = false;
-            for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
-                const exp = expectedLines[lineIndex];
-                const act = actualLines[lineIndex];
-                if (exp !== act) {
-                    hasDiff = true;
-                    if (exp !== undefined && act === undefined) {
-                        console.log(`Line ${lineIndex + 1}:`);
-                        console.log(`  - ${exp}`);
-                    }
-                    else if (exp === undefined && act !== undefined) {
-                        console.log(`Line ${lineIndex + 1}:`);
-                        console.log(`  + ${act}`);
-                    }
-                    else {
-                        console.log(`Line ${lineIndex + 1}:`);
-                        console.log(`  - ${exp}`);
-                        console.log(`  + ${act}`);
-                    }
-                }
+    }
+    // Common path: Run the transform, format, and write actual output
+    let actualOutput;
+    try {
+        const rawOutput = await runTransform(basePath, transform);
+        actualOutput = await formatCode(rawOutput);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Error running transform: ${message}`);
+        return 1;
+    }
+    await fs.writeFile(actualPath, actualOutput);
+    console.log(`Created: test-cases/${testcase}/${transform}.js`);
+    if (!expected) {
+        return 0;
+    }
+    // Step 3: Compare expected vs actual
+    const expectedContent = await fs.readFile(expectedPath, "utf8");
+    if (expectedContent === actualOutput) {
+        // Success! Delete expected file
+        await fs.unlink(expectedPath);
+        console.log(`\nSuccess: Output matches expected.`);
+        console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
+        console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
+        return 0;
+    }
+    // Diff - show the difference
+    console.log(`\nDiff: expected vs actual`);
+    console.log("---");
+    // Simple line-by-line diff output
+    const expectedLines = expectedContent.split("\n");
+    const actualLines = actualOutput.split("\n");
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    let hasDiff = false;
+    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
+        const exp = expectedLines[lineIndex];
+        const act = actualLines[lineIndex];
+        if (exp !== act) {
+            hasDiff = true;
+            if (exp !== undefined && act === undefined) {
+                console.log(`Line ${lineIndex + 1}:`);
+                console.log(`  - ${exp}`);
             }
-            if (!hasDiff) {
-                // Shouldn't happen since we already checked equality, but just in case
-                console.log("(no visible differences)");
+            else if (exp === undefined && act !== undefined) {
+                console.log(`Line ${lineIndex + 1}:`);
+                console.log(`  + ${act}`);
+            }
+            else {
+                console.log(`Line ${lineIndex + 1}:`);
+                console.log(`  - ${exp}`);
+                console.log(`  + ${act}`);
             }
-            console.log("---");
-            console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
-            console.log("Fix the implementation or update the expected file, then re-run.");
-            return 1;
         }
     }
-    else {
-        // Simple mode: just write actual output
-        await fs.writeFile(actualPath, actualOutput);
-        console.log(`Created: test-cases/${testcase}/${transform}.js`);
-        return 0;
+    if (!hasDiff) {
+        // Shouldn't happen since we already checked equality, but just in case
+        console.log("(no visible differences)");
     }
+    console.log("---");
+    console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
+    console.log("Fix the implementation or update the expected file, then re-run.");
+    return 1;
 };

package/dist/transforms/rename-loop-index-variables-v2/get-loop-counter-name.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const LOOP_INDEX_BASE_NAME = "index";
+export declare const getStableRenamedIndexLoopCounterName: (path: NodePath<ForStatement>) => string | undefined;
+export declare const getLoopCounterNameIfEligible: (path: NodePath<ForStatement>) => string | undefined;

package/dist/transforms/rename-loop-index-variables-v2/get-loop-counter-name.js

@@ -0,0 +1,123 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
+export const LOOP_INDEX_BASE_NAME = "index";
+const isEligibleVariableDeclarationKind = (kind) => {
+    return kind === "let" || kind === "var";
+};
+const isStableRenamedIndexLoopCounterName = (name) => {
+    if (!isStableRenamed(name))
+        return false;
+    return name.startsWith(`$${LOOP_INDEX_BASE_NAME}`);
+};
+const isLoopCounterDeclarator = (loopCounterName, path) => {
+    const test = path.node.test;
+    if (!test)
+        return false;
+    if (test.type !== "BinaryExpression")
+        return false;
+    if (test.operator !== "<" && test.operator !== "<=")
+        return false;
+    if (test.left.type !== "Identifier")
+        return false;
+    if (test.left.name !== loopCounterName)
+        return false;
+    if (test.right.type !== "MemberExpression")
+        return false;
+    if (test.right.computed)
+        return false;
+    if (test.right.property.type !== "Identifier")
+        return false;
+    if (test.right.property.name !== "length")
+        return false;
+    const update = path.node.update;
+    if (!update)
+        return false;
+    if (update.type === "UpdateExpression") {
+        if (update.operator !== "++")
+            return false;
+        if (update.argument.type !== "Identifier")
+            return false;
+        if (update.argument.name !== loopCounterName)
+            return false;
+    }
+    else if (update.type === "AssignmentExpression") {
+        if (update.operator !== "+=")
+            return false;
+        if (update.left.type !== "Identifier")
+            return false;
+        if (update.left.name !== loopCounterName)
+            return false;
+        if (update.right.type !== "NumericLiteral")
+            return false;
+        if (update.right.value <= 0)
+            return false;
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+export const getStableRenamedIndexLoopCounterName = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    let stableName;
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isStableRenamedIndexLoopCounterName(loopCounterName))
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        if (stableName !== undefined)
+            return;
+        stableName = loopCounterName;
+    }
+    return stableName;
+};
+export const getLoopCounterNameIfEligible = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    if (init.kind === "let" && init.declarations.length < 2)
+        return;
+    const eligibleNames = [];
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        eligibleNames.push(loopCounterName);
+        if (eligibleNames.length > 1)
+            return;
+    }
+    const name0 = eligibleNames[0];
+    if (!name0)
+        return;
+    return name0;
+};

package/dist/transforms/rename-loop-index-variables-v2/get-renamed-ancestor-loop-count.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const getRenamedAncestorLoopCount: (path: NodePath<ForStatement>, renamedLoops: WeakMap<ForStatement, string>) => number;

package/dist/transforms/rename-loop-index-variables-v2/get-renamed-ancestor-loop-count.js

@@ -0,0 +1,19 @@
+import { getStableRenamedIndexLoopCounterName } from "./get-loop-counter-name.js";
+export const getRenamedAncestorLoopCount = (path, renamedLoops) => {
+    let count = 0;
+    for (const ancestor of path.getAncestry()) {
+        if (ancestor === path)
+            continue;
+        if (!ancestor.isForStatement())
+            continue;
+        if (renamedLoops.has(ancestor.node)) {
+            count++;
+            continue;
+        }
+        const stableName = getStableRenamedIndexLoopCounterName(ancestor);
+        if (!stableName)
+            continue;
+        count++;
+    }
+    return count;
+};

package/dist/transforms/rename-loop-index-variables-v2/get-target-index-base-name.d.ts

@@ -0,0 +1 @@
+export declare const getTargetIndexBaseName: (renamedAncestorLoopCount: number) => string;

package/dist/transforms/rename-loop-index-variables-v2/get-target-index-base-name.js

@@ -0,0 +1,6 @@
+import { LOOP_INDEX_BASE_NAME } from "./get-loop-counter-name.js";
+export const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
+    if (renamedAncestorLoopCount === 0)
+        return LOOP_INDEX_BASE_NAME;
+    return `${LOOP_INDEX_BASE_NAME}${renamedAncestorLoopCount + 1}`;
+};

package/dist/transforms/rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.d.ts

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

package/dist/transforms/rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getLoopCounterNameIfEligible } from "./get-loop-counter-name.js";
+import { getRenamedAncestorLoopCount } from "./get-renamed-ancestor-loop-count.js";
+import { getTargetIndexBaseName } from "./get-target-index-base-name.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 renameLoopIndexVariablesV2Transform = {
+    id: "rename-loop-index-variables-v2",
+    description: "Renames numeric for-loop counters in `for (var ...)` (single or multi-declarator) and `for (let ...)` (multi-declarator) to $index/$index2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
+            traverse(fileInfo.ast, {
+                ForStatement(path) {
+                    nodesVisited++;
+                    const loopCounterName = getLoopCounterNameIfEligible(path);
+                    if (!loopCounterName)
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
+                        return;
+                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, eligibleLoops);
+                    const baseName = getTargetIndexBaseName(renamedAncestorLoopCount);
+                    eligibleLoops.set(path.node, baseName);
+                    group.add({
+                        scope: path.scope,
+                        currentName: loopCounterName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-loop-index-variables-v3/get-loop-counter-name.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const LOOP_INDEX_BASE_NAME = "index";
+export declare const getStableRenamedIndexLoopCounterName: (path: NodePath<ForStatement>) => string | undefined;
+export declare const getLoopCounterNameIfEligible: (path: NodePath<ForStatement>) => string | undefined;

package/dist/transforms/rename-loop-index-variables-v3/get-loop-counter-name.js

@@ -0,0 +1,121 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
+export const LOOP_INDEX_BASE_NAME = "index";
+const isEligibleVariableDeclarationKind = (kind) => {
+    return kind === "let" || kind === "var";
+};
+const isStableRenamedIndexLoopCounterName = (name) => {
+    if (!isStableRenamed(name))
+        return false;
+    return name.startsWith(`$${LOOP_INDEX_BASE_NAME}`);
+};
+const isLoopCounterDeclarator = (loopCounterName, path) => {
+    const test = path.node.test;
+    if (!test)
+        return false;
+    if (test.type !== "BinaryExpression")
+        return false;
+    if (test.operator !== "<" && test.operator !== "<=")
+        return false;
+    if (test.left.type !== "Identifier")
+        return false;
+    if (test.left.name !== loopCounterName)
+        return false;
+    if (test.right.type !== "MemberExpression")
+        return false;
+    if (test.right.computed)
+        return false;
+    if (test.right.property.type !== "Identifier")
+        return false;
+    if (test.right.property.name !== "length")
+        return false;
+    const update = path.node.update;
+    if (!update)
+        return false;
+    if (update.type === "UpdateExpression") {
+        if (update.operator !== "++")
+            return false;
+        if (update.argument.type !== "Identifier")
+            return false;
+        if (update.argument.name !== loopCounterName)
+            return false;
+    }
+    else if (update.type === "AssignmentExpression") {
+        if (update.operator !== "+=")
+            return false;
+        if (update.left.type !== "Identifier")
+            return false;
+        if (update.left.name !== loopCounterName)
+            return false;
+        if (update.right.type !== "NumericLiteral")
+            return false;
+        if (update.right.value <= 0)
+            return false;
+    }
+    else {
+        return false;
+    }
+    return true;
+};
+export const getStableRenamedIndexLoopCounterName = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    let stableName;
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isStableRenamedIndexLoopCounterName(loopCounterName))
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        if (stableName !== undefined)
+            return;
+        stableName = loopCounterName;
+    }
+    return stableName;
+};
+export const getLoopCounterNameIfEligible = (path) => {
+    const init = path.node.init;
+    if (!init)
+        return;
+    if (init.type !== "VariableDeclaration")
+        return;
+    if (!isEligibleVariableDeclarationKind(init.kind))
+        return;
+    if (init.declarations.length === 0)
+        return;
+    const eligibleNames = [];
+    for (const declarator of init.declarations) {
+        if (declarator.id.type !== "Identifier")
+            continue;
+        if (!declarator.init)
+            continue;
+        if (declarator.init.type !== "NumericLiteral")
+            continue;
+        if (declarator.init.value !== 0)
+            continue;
+        const loopCounterName = declarator.id.name;
+        if (!isLoopCounterDeclarator(loopCounterName, path))
+            continue;
+        eligibleNames.push(loopCounterName);
+        if (eligibleNames.length > 1)
+            return;
+    }
+    const name0 = eligibleNames[0];
+    if (!name0)
+        return;
+    return name0;
+};

package/dist/transforms/rename-loop-index-variables-v3/get-renamed-ancestor-loop-count.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ForStatement } from "@babel/types";
+export declare const getRenamedAncestorLoopCount: (path: NodePath<ForStatement>, renamedLoops: WeakMap<ForStatement, string>) => number;

package/dist/transforms/rename-loop-index-variables-v3/get-renamed-ancestor-loop-count.js

@@ -0,0 +1,19 @@
+import { getStableRenamedIndexLoopCounterName } from "./get-loop-counter-name.js";
+export const getRenamedAncestorLoopCount = (path, renamedLoops) => {
+    let count = 0;
+    for (const ancestor of path.getAncestry()) {
+        if (ancestor === path)
+            continue;
+        if (!ancestor.isForStatement())
+            continue;
+        if (renamedLoops.has(ancestor.node)) {
+            count++;
+            continue;
+        }
+        const stableName = getStableRenamedIndexLoopCounterName(ancestor);
+        if (!stableName)
+            continue;
+        count++;
+    }
+    return count;
+};

package/dist/transforms/rename-loop-index-variables-v3/get-target-index-base-name.d.ts

@@ -0,0 +1 @@
+export declare const getTargetIndexBaseName: (renamedAncestorLoopCount: number) => string;

package/dist/transforms/rename-loop-index-variables-v3/get-target-index-base-name.js

@@ -0,0 +1,6 @@
+import { LOOP_INDEX_BASE_NAME } from "./get-loop-counter-name.js";
+export const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
+    if (renamedAncestorLoopCount === 0)
+        return LOOP_INDEX_BASE_NAME;
+    return `${LOOP_INDEX_BASE_NAME}${renamedAncestorLoopCount + 1}`;
+};

package/dist/transforms/rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.d.ts

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

package/dist/transforms/rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getLoopCounterNameIfEligible } from "./get-loop-counter-name.js";
+import { getRenamedAncestorLoopCount } from "./get-renamed-ancestor-loop-count.js";
+import { getTargetIndexBaseName } from "./get-target-index-base-name.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 renameLoopIndexVariablesV3Transform = {
+    id: "rename-loop-index-variables-v3",
+    description: "Renames numeric for-loop counters (single or multi-declarator `for (var/let ...)`) to $index/$index2/... based on nesting depth",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
+            traverse(fileInfo.ast, {
+                ForStatement(path) {
+                    nodesVisited++;
+                    const loopCounterName = getLoopCounterNameIfEligible(path);
+                    if (!loopCounterName)
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
+                        return;
+                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, eligibleLoops);
+                    const baseName = getTargetIndexBaseName(renamedAncestorLoopCount);
+                    eligibleLoops.set(path.node, baseName);
+                    group.add({
+                        scope: path.scope,
+                        currentName: loopCounterName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-replace-child-parameters/ast-node-predicates.d.ts

@@ -0,0 +1,3 @@
+import type { Identifier, StringLiteral } from "@babel/types";
+export declare const isIdentifierNamed: (node: unknown, name: string) => node is Identifier;
+export declare const isStringLiteralValue: (node: unknown, value: string) => node is StringLiteral;

package/dist/transforms/rename-replace-child-parameters/ast-node-predicates.js

@@ -0,0 +1,12 @@
+export const isIdentifierNamed = (node, name) => {
+    return (typeof node === "object" &&
+        node !== null &&
+        node.type === "Identifier" &&
+        node.name === name);
+};
+export const isStringLiteralValue = (node, value) => {
+    return (typeof node === "object" &&
+        node !== null &&
+        node.type === "StringLiteral" &&
+        node.value === value);
+};

package/dist/transforms/rename-replace-child-parameters/collect-replace-child-parameter-renames.d.ts

@@ -0,0 +1,3 @@
+import type { RenameGroup } from "../../core/stable-naming.js";
+import type { ReplaceChildFunctionPath } from "./replace-child-types.js";
+export declare const collectReplaceChildParameterRenames: (path: ReplaceChildFunctionPath, group: RenameGroup) => void;

package/dist/transforms/rename-replace-child-parameters/collect-replace-child-parameter-renames.js

@@ -0,0 +1,39 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { BASE_NEW_CHILD, BASE_OLD_CHILD } from "./constants.js";
+import { getSingleReturnIdentifierName } from "./get-single-return-identifier-name.js";
+import { getTwoIdentifierParameters } from "./get-two-identifier-parameters.js";
+import { hasReplaceChildForwardingCall } from "./has-replace-child-forwarding-call.js";
+import { isAlreadyChildParameterName } from "./is-already-child-parameter-name.js";
+import { isReplaceChildNamedFunction } from "./is-replace-child-named-function.js";
+export const collectReplaceChildParameterRenames = (path, group) => {
+    if (!isReplaceChildNamedFunction(path))
+        return;
+    if (path.node.body.type !== "BlockStatement")
+        return;
+    const parameters = getTwoIdentifierParameters(path);
+    if (!parameters)
+        return;
+    const returnIdentifierName = getSingleReturnIdentifierName(path);
+    if (returnIdentifierName !== parameters.parameter1.name)
+        return;
+    if (!hasReplaceChildForwardingCall(path, parameters.parameter0.name, parameters.parameter1.name))
+        return;
+    const parameter0Name = parameters.parameter0.name;
+    if (!isStableRenamed(parameter0Name) &&
+        !isAlreadyChildParameterName(parameter0Name, BASE_NEW_CHILD)) {
+        group.add({
+            scope: path.scope,
+            currentName: parameter0Name,
+            baseName: BASE_NEW_CHILD,
+        });
+    }
+    const parameter1Name = parameters.parameter1.name;
+    if (!isStableRenamed(parameter1Name) &&
+        !isAlreadyChildParameterName(parameter1Name, BASE_OLD_CHILD)) {
+        group.add({
+            scope: path.scope,
+            currentName: parameter1Name,
+            baseName: BASE_OLD_CHILD,
+        });
+    }
+};

package/dist/transforms/rename-replace-child-parameters/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const REPLACE_CHILD_NAME = "replaceChild";
+export declare const BASE_NEW_CHILD = "newChild";
+export declare const BASE_OLD_CHILD = "oldChild";

package/dist/transforms/rename-replace-child-parameters/constants.js

@@ -0,0 +1,3 @@
+export const REPLACE_CHILD_NAME = "replaceChild";
+export const BASE_NEW_CHILD = "newChild";
+export const BASE_OLD_CHILD = "oldChild";

package/dist/transforms/rename-replace-child-parameters/get-single-return-identifier-name.d.ts

@@ -0,0 +1,2 @@
+import type { ReplaceChildFunctionPath } from "./replace-child-types.js";
+export declare const getSingleReturnIdentifierName: (path: ReplaceChildFunctionPath) => string | undefined;

package/dist/transforms/rename-replace-child-parameters/get-single-return-identifier-name.js

@@ -0,0 +1,23 @@
+export const getSingleReturnIdentifierName = (path) => {
+    let returnCount = 0;
+    let identifierName;
+    const rootNode = path.node;
+    path.traverse({
+        Function(innerPath) {
+            if (innerPath.node !== rootNode)
+                innerPath.skip();
+        },
+        ReturnStatement(returnPath) {
+            returnCount++;
+            const argument = returnPath.node.argument;
+            if (argument?.type !== "Identifier") {
+                identifierName = undefined;
+                return;
+            }
+            identifierName = argument.name;
+        },
+    });
+    if (returnCount !== 1)
+        return;
+    return identifierName;
+};

package/dist/transforms/rename-replace-child-parameters/get-two-identifier-parameters.d.ts

@@ -0,0 +1,6 @@
+import type { Identifier } from "@babel/types";
+import type { ReplaceChildFunctionPath } from "./replace-child-types.js";
+export declare const getTwoIdentifierParameters: (path: ReplaceChildFunctionPath) => {
+    parameter0: Identifier;
+    parameter1: Identifier;
+} | undefined;

package/dist/transforms/rename-replace-child-parameters/get-two-identifier-parameters.js

@@ -0,0 +1,13 @@
+export const getTwoIdentifierParameters = (path) => {
+    if (path.node.params.length !== 2)
+        return;
+    const parameter0 = path.node.params[0];
+    const parameter1 = path.node.params[1];
+    if (parameter0?.type !== "Identifier")
+        return;
+    if (parameter1?.type !== "Identifier")
+        return;
+    if (parameter0.name === parameter1.name)
+        return;
+    return { parameter0, parameter1 };
+};

package/dist/transforms/rename-replace-child-parameters/has-replace-child-forwarding-call.d.ts

@@ -0,0 +1,2 @@
+import type { ReplaceChildFunctionPath } from "./replace-child-types.js";
+export declare const hasReplaceChildForwardingCall: (path: ReplaceChildFunctionPath, parameter0Name: string, parameter1Name: string) => boolean;

package/dist/transforms/rename-replace-child-parameters/has-replace-child-forwarding-call.js

@@ -0,0 +1,57 @@
+import { isIdentifierNamed } from "./ast-node-predicates.js";
+import { REPLACE_CHILD_NAME } from "./constants.js";
+export const hasReplaceChildForwardingCall = (path, parameter0Name, parameter1Name) => {
+    let found = false;
+    const rootNode = path.node;
+    path.traverse({
+        Function(innerPath) {
+            if (innerPath.node !== rootNode)
+                innerPath.skip();
+        },
+        CallExpression(callPath) {
+            if (found)
+                return;
+            const call = callPath.node;
+            const callee = call.callee;
+            if (callee.type !== "MemberExpression")
+                return;
+            if (callee.computed)
+                return;
+            if (callee.property.type !== "Identifier")
+                return;
+            // something.replaceChild(parameter0, parameter1)
+            if (callee.property.name === REPLACE_CHILD_NAME) {
+                const argument0 = call.arguments[0];
+                const argument1 = call.arguments[1];
+                if (!isIdentifierNamed(argument0, parameter0Name))
+                    return;
+                if (!isIdentifierNamed(argument1, parameter1Name))
+                    return;
+                found = true;
+                callPath.stop();
+                return;
+            }
+            // something.replaceChild.call(this, parameter0, parameter1)
+            if (callee.property.name !== "call")
+                return;
+            const target = callee.object;
+            if (target.type !== "MemberExpression")
+                return;
+            if (target.computed)
+                return;
+            if (target.property.type !== "Identifier")
+                return;
+            if (target.property.name !== REPLACE_CHILD_NAME)
+                return;
+            const argument1 = call.arguments[1];
+            const argument2 = call.arguments[2];
+            if (!isIdentifierNamed(argument1, parameter0Name))
+                return;
+            if (!isIdentifierNamed(argument2, parameter1Name))
+                return;
+            found = true;
+            callPath.stop();
+        },
+    });
+    return found;
+};

package/dist/transforms/rename-replace-child-parameters/is-already-child-parameter-name.d.ts

@@ -0,0 +1 @@
+export declare const isAlreadyChildParameterName: (name: string, base: string) => boolean;

package/dist/transforms/rename-replace-child-parameters/is-already-child-parameter-name.js

@@ -0,0 +1,8 @@
+export const isAlreadyChildParameterName = (name, base) => {
+    if (name === base)
+        return true;
+    if (!name.startsWith(base))
+        return false;
+    const suffix = name.slice(base.length);
+    return /^\d+$/u.test(suffix);
+};

package/dist/transforms/rename-replace-child-parameters/is-replace-child-named-function.d.ts

@@ -0,0 +1,2 @@
+import type { ReplaceChildFunctionPath } from "./replace-child-types.js";
+export declare const isReplaceChildNamedFunction: (path: ReplaceChildFunctionPath) => boolean;

package/dist/transforms/rename-replace-child-parameters/is-replace-child-named-function.js

@@ -0,0 +1,43 @@
+import { isIdentifierNamed, isStringLiteralValue, } from "./ast-node-predicates.js";
+import { REPLACE_CHILD_NAME } from "./constants.js";
+const isReplaceChildKey = (key) => {
+    if (isIdentifierNamed(key, REPLACE_CHILD_NAME))
+        return true;
+    if (isStringLiteralValue(key, REPLACE_CHILD_NAME))
+        return true;
+    return false;
+};
+const isReplaceChildValueDescriptorFunction = (path) => {
+    const valueProperty = path.parentPath;
+    if (!valueProperty.isObjectProperty())
+        return false;
+    const valueKey = valueProperty.node.key;
+    const isValueKey = isIdentifierNamed(valueKey, "value") ||
+        isStringLiteralValue(valueKey, "value");
+    if (!isValueKey)
+        return false;
+    const descriptor = valueProperty.parentPath;
+    if (!descriptor.isObjectExpression())
+        return false;
+    const replaceChildProperty = descriptor.parentPath;
+    if (!replaceChildProperty.isObjectProperty())
+        return false;
+    return isReplaceChildKey(replaceChildProperty.node.key);
+};
+export const isReplaceChildNamedFunction = (path) => {
+    if ((path.isFunctionDeclaration() || path.isFunctionExpression()) &&
+        isIdentifierNamed(path.node.id, REPLACE_CHILD_NAME)) {
+        return true;
+    }
+    if (path.isObjectMethod() || path.isClassMethod()) {
+        return isReplaceChildKey(path.node.key);
+    }
+    const parent = path.parentPath;
+    if (parent.isObjectProperty() && isReplaceChildKey(parent.node.key)) {
+        return true;
+    }
+    if (path.isFunctionExpression() || path.isArrowFunctionExpression()) {
+        return isReplaceChildValueDescriptorFunction(path);
+    }
+    return false;
+};

package/dist/transforms/rename-replace-child-parameters/rename-replace-child-parameters-transform.d.ts

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

package/dist/transforms/rename-replace-child-parameters/rename-replace-child-parameters-transform.js

@@ -0,0 +1,44 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { collectReplaceChildParameterRenames } from "./collect-replace-child-parameter-renames.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 renameReplaceChildParametersTransform = {
+    id: "rename-replace-child-parameters",
+    description: "Renames replaceChild forwarding wrapper parameters to $newChild and $oldChild",
+    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, {
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    collectReplaceChildParameterRenames(path, group);
+                },
+                FunctionExpression(path) {
+                    nodesVisited++;
+                    collectReplaceChildParameterRenames(path, group);
+                },
+                ArrowFunctionExpression(path) {
+                    nodesVisited++;
+                    collectReplaceChildParameterRenames(path, group);
+                },
+                ObjectMethod(path) {
+                    nodesVisited++;
+                    collectReplaceChildParameterRenames(path, group);
+                },
+                ClassMethod(path) {
+                    nodesVisited++;
+                    collectReplaceChildParameterRenames(path, group);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-replace-child-parameters/replace-child-types.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, ClassMethod, FunctionDeclaration, FunctionExpression, ObjectMethod } from "@babel/types";
+export type ReplaceChildFunctionPath = NodePath<FunctionDeclaration> | NodePath<FunctionExpression> | NodePath<ArrowFunctionExpression> | NodePath<ObjectMethod> | NodePath<ClassMethod>;

package/dist/transforms/rename-replace-child-parameters/replace-child-types.js

@@ -0,0 +1 @@
+export {};

package/dist/transforms/transform-registry.js

@@ -6,7 +6,10 @@ import { renameCatchParametersTransform } from "./rename-catch-parameters/rename
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameEventParametersTransform } from "./rename-event-parameters/rename-event-parameters-transform.js";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
+import { renameLoopIndexVariablesV2Transform } from "./rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
+import { renameLoopIndexVariablesV3Transform } from "./rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
+import { renameReplaceChildParametersTransform } from "./rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
@@ -20,7 +23,10 @@ export const transformRegistry = {
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
+    [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
+    [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,

package/package.json

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

package/transform-manifest.json

@@ -26,9 +26,31 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-21T21:06:19.512Z",
-      "notes": "Auto-added by evaluation script."
+      "notes": "Superseded by rename-loop-index-variables-v3.",
+      "supersededBy": "rename-loop-index-variables-v3"
+    },
+    {
+      "id": "rename-loop-index-variables-v2",
+      "description": "Renames numeric for-loop counters in `for (var ...)` (single or multi-declarator) and `for (let ...)` (multi-declarator) inits to index/index2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T16:34:06.000Z",
+      "notes": "Superseded by rename-loop-index-variables-v3.",
+      "supersededBy": "rename-loop-index-variables-v3"
+    },
+    {
+      "id": "rename-loop-index-variables-v3",
+      "description": "Renames numeric for-loop counters (single or multi-declarator `for (var/let ...)`) to index/index2/... based on nesting depth",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T17:09:04.000Z",
+      "notes": "Unifies rename-loop-index-variables and rename-loop-index-variables-v2 without modifying older transforms. Measured with baseline none: 0.00%."
     },
     {
       "id": "rename-catch-parameters",
@@ -119,6 +141,16 @@
       "evaluatedAt": "2026-01-22T21:39:53.578Z",
       "notes": "Auto-added by evaluation script."
     },
+    {
+      "id": "rename-replace-child-parameters",
+      "description": "Renames replaceChild forwarding wrapper parameters to $newChild and $oldChild",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T17:28:09.184Z",
+      "notes": "Measured with baseline none: 0.00%."
+    },
     {
       "id": "expand-special-number-literals",
       "description": "Expands 1/0 to Infinity, -1/0 (and 1/-0) to -Infinity, and 0/0 to NaN (when not shadowed)",