miniread 1.6.0 → 1.7.0

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

@@ -1,4 +1,6 @@
 import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
 import { processEventHandlerFunction } from "./process-event-handler-function.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -9,28 +11,29 @@ export const renameEventParametersTransform = {
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
-        const stats = { transformationsApplied: 0 };
-        for (const [, fileInfo] of projectGraph.files) {
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 FunctionDeclaration(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
                 FunctionExpression(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
                 ArrowFunctionExpression(path) {
                     nodesVisited++;
-                    processEventHandlerFunction(path, stats);
+                    processEventHandlerFunction(path, group);
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,
-            transformationsApplied: stats.transformationsApplied,
+            transformationsApplied,
         });
     },
 };

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

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -15,10 +16,11 @@ const getRenamedAncestorLoopCount = (path, renamedLoops) => {
     }
     return count;
 };
-const getTargetIndexName = (renamedAncestorLoopCount) => {
+const BASE_NAME = "index";
+const getTargetIndexBaseName = (renamedAncestorLoopCount) => {
     if (renamedAncestorLoopCount === 0)
-        return "index";
-    return `index${renamedAncestorLoopCount + 1}`;
+        return BASE_NAME;
+    return `${BASE_NAME}${renamedAncestorLoopCount + 1}`;
 };
 const getLoopCounterNameIfEligible = (path) => {
     const init = path.node.init;
@@ -91,31 +93,35 @@ const getLoopCounterNameIfEligible = (path) => {
 };
 export const renameLoopIndexVariablesTransform = {
     id: "rename-loop-index-variables",
-    description: "Renames numeric for-loop counters to index/index2/... based on nesting depth",
+    description: "Renames numeric for-loop counters 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 renamedLoops = new WeakMap();
+            const group = new RenameGroup();
+            const eligibleLoops = new WeakMap();
             traverse(fileInfo.ast, {
                 ForStatement(path) {
                     nodesVisited++;
                     const loopCounterName = getLoopCounterNameIfEligible(path);
                     if (!loopCounterName)
                         return;
-                    const renamedAncestorLoopCount = getRenamedAncestorLoopCount(path, renamedLoops);
-                    const targetName = getTargetIndexName(renamedAncestorLoopCount);
-                    if (loopCounterName === targetName)
+                    // Skip already-stable names
+                    if (isStableRenamed(loopCounterName))
                         return;
-                    if (path.scope.hasBinding(targetName))
-                        return;
-                    path.scope.rename(loopCounterName, targetName);
-                    renamedLoops.set(path.node, targetName);
-                    transformationsApplied++;
+                    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,

package/dist/transforms/rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js

@@ -1,13 +1,15 @@
 import { createRequire } from "node:module";
+import { isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getExecutorFunctionIfEligible, isAssignedToOnHandlerProperty, isDirectCallOfBinding, wouldShadowReferencedOuterBinding, } from "./promise-executor-heuristics.js";
 import { canRenameBindingSafely, renameBindingIfSafe, } from "./rename-binding-if-safe.js";
+const STABLE_PREFIX = "$";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
 export const renamePromiseExecutorParametersTransform = {
     id: "rename-promise-executor-parameters",
-    description: "Renames promise-like executor parameters in `new X(executor)` to resolve/reject when usage is high-confidence",
+    description: "Renames promise-like executor parameters in `new X(executor)` to $resolve/$reject when usage is high-confidence",
     scope: "file",
     parallelizable: true,
     transform(context) {
@@ -22,6 +24,11 @@ export const renamePromiseExecutorParametersTransform = {
                         return;
                     const [resolveParameter, rejectParameter] = executorPath.node
                         .params;
+                    // Skip already-stable names
+                    if (isStableRenamed(resolveParameter.name))
+                        return;
+                    if (isStableRenamed(rejectParameter.name))
+                        return;
                     const bindingScope = executorPath.scope;
                     const resolveBinding = bindingScope.getBinding(resolveParameter.name);
                     const rejectBinding = bindingScope.getBinding(rejectParameter.name);
@@ -41,10 +48,10 @@ export const renamePromiseExecutorParametersTransform = {
                         isAssignedToOnHandlerProperty(referencePath));
                     if (!rejectIsOnlyCalledOrHandlerAssigned)
                         return;
-                    const resolveWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "resolve");
-                    const rejectWouldShadow = wouldShadowReferencedOuterBinding(executorPath, "reject");
-                    const targetResolveName = "resolve";
-                    const targetRejectName = "reject";
+                    const targetResolveName = `${STABLE_PREFIX}resolve`;
+                    const targetRejectName = `${STABLE_PREFIX}reject`;
+                    const resolveWouldShadow = wouldShadowReferencedOuterBinding(executorPath, targetResolveName);
+                    const rejectWouldShadow = wouldShadowReferencedOuterBinding(executorPath, targetRejectName);
                     const wantsResolveRename = resolveParameter.name !== targetResolveName;
                     const wantsRejectRename = rejectParameter.name !== targetRejectName;
                     const canRenameResolve = !wantsResolveRename ||

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.d.ts

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

package/dist/transforms/rename-timeout-ids/rename-timeout-ids-transform.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
-import { getFilesToProcess } from "../../core/types.js";
-import { getTargetName } from "../rename-binding/get-target-name.js";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -40,20 +40,22 @@ const isClearTimeoutCallArgument = (referencePath, bindingName) => {
 };
 export const renameTimeoutIdsTransform = {
     id: "rename-timeout-ids",
-    description: "Renames setTimeout handle variables to timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
+    description: "Renames setTimeout handle variables to $timeoutId/$timeoutId2/... or timeoutId/timeoutId2/... when usage is only clearTimeout(...)",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
                     const id = path.node.id;
                     if (id.type !== "Identifier")
                         return;
-                    if (id.name.length > 2)
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
                         return;
                     const init = path.node.init;
                     if (init?.type !== "CallExpression")
@@ -69,17 +71,14 @@ export const renameTimeoutIdsTransform = {
                         return;
                     if (!binding.referencePaths.every((referencePath) => isClearTimeoutCallArgument(referencePath, id.name)))
                         return;
-                    const targetName = getTargetName(path.scope, binding, {
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
                         baseName: BASE_NAME,
                     });
-                    if (!targetName)
-                        return;
-                    if (id.name === targetName)
-                        return;
-                    path.scope.rename(id.name, targetName);
-                    transformationsApplied++;
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({ nodesVisited, transformationsApplied });
     },

package/dist/transforms/rename-use-reference-guards/rename-use-reference-guards-transform.js

@@ -1,28 +1,28 @@
 import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getReferenceUsage } from "./get-reference-usage.js";
-import { getTargetName } from "./get-target-name.js";
 import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const BASE_NAME = "hasRunRef";
 const renameUseReferenceGuardsTransform = {
     id: "rename-use-reference-guards",
-    description: "Renames boolean useRef(false) guard variables to hasRunRef/hasRunRef2/...",
+    description: "Renames boolean useRef(false) guard variables to $hasRunRef/$hasRunRef2/... or hasRunRef/hasRunRef2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
                     const id = path.node.id;
                     if (id.type !== "Identifier")
                         return;
-                    if (id.name.length > 2)
-                        return;
                     if (!isUseReferenceFalseInitializer(path.node))
                         return;
                     const binding = path.scope.getBinding(id.name);
@@ -36,15 +36,14 @@ const renameUseReferenceGuardsTransform = {
                         !usage.hasTrueWrite ||
                         usage.hasFalseWrite)
                         return;
-                    const targetName = getTargetName(path.scope, binding);
-                    if (!targetName)
-                        return;
-                    if (id.name === targetName)
-                        return;
-                    path.scope.rename(id.name, targetName);
-                    transformationsApplied++;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.d.ts

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

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js

@@ -1,27 +1,29 @@
 import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
 import { getReferenceUsage } from "./get-reference-usage.js";
-import { getTargetName } from "./get-target-name.js";
 import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const BASE_NAME = "hasRunRef";
 const renameUseReferenceGuardsV2Transform = {
     id: "rename-use-reference-guards-v2",
-    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to $hasRunRef/$hasRunRef2/... or hasRunRef/hasRunRef2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
-        const { projectGraph } = context;
         let nodesVisited = 0;
         let transformationsApplied = 0;
-        for (const [, fileInfo] of projectGraph.files) {
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
                     const id = path.node.id;
                     if (id.type !== "Identifier")
                         return;
-                    if (id.name.length > 2)
+                    if (isStableRenamed(id.name))
                         return;
                     if (!isUseReferenceFalseInitializer(path.node))
                         return;
@@ -31,17 +33,17 @@ const renameUseReferenceGuardsV2Transform = {
                     if (!binding.constant)
                         return;
                     const usage = getReferenceUsage(binding);
+                    // Unlike v1, this version also accepts guards that reset to false
                     if (!usage.isSafe || !usage.hasRead || !usage.hasTrueWrite)
                         return;
-                    const targetName = getTargetName(path.scope, binding);
-                    if (!targetName)
-                        return;
-                    if (id.name === targetName)
-                        return;
-                    path.scope.rename(id.name, targetName);
-                    transformationsApplied++;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

package/dist/transforms/transform-registry.js

@@ -1,11 +1,6 @@
 import { expandBooleanLiteralsTransform } from "./expand-boolean-literals/expand-boolean-literals-transform.js";
-import { expandReturnSequenceTransform } from "./expand-return-sequence/expand-return-sequence-transform.js";
-import { expandSequenceExpressionsTransform } from "./expand-sequence-expressions/expand-sequence-expressions-transform.js";
-import { expandSequenceExpressionsV2Transform } from "./expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js";
 import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-literals/expand-special-number-literals-transform.js";
-import { expandSequenceExpressionsV3Transform } from "./expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.js";
 import { expandSequenceExpressionsV4Transform } from "./expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js";
-import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-throw-sequence-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
@@ -18,13 +13,8 @@ import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guar
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
-    [expandReturnSequenceTransform.id]: expandReturnSequenceTransform,
-    [expandSequenceExpressionsTransform.id]: expandSequenceExpressionsTransform,
-    [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
-    [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
-    [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,

package/package.json

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

package/transform-manifest.json

@@ -59,46 +59,6 @@
       "evaluatedAt": "2026-01-22T12:49:10.952Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: 0.09%."
     },
-    {
-      "id": "expand-return-sequence",
-      "description": "Expands return sequences like `return a(), b();`",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.0012834789830316051,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T15:19:04.615Z",
-      "notes": "Auto-added by evaluation script. Measured with baseline none: -0.13%. Superseded by expand-sequence-expressions-v2 in the recommended preset."
-    },
-    {
-      "id": "expand-sequence-expressions",
-      "description": "Expands comma operator sequences in statements and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.01282535248485317,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T17:15:48.528Z",
-      "notes": "Auto-added by evaluation script. Measured with baseline none: -1.28%. Enabled for readability even when line diffs increase. Kept separate from expand-return-sequence to avoid modifying existing transforms and to allow independent enabling."
-    },
-    {
-      "id": "expand-sequence-expressions-v2",
-      "description": "Expands comma operator sequences in returns, statements, and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.014316453068081048,
-      "recommended": false,
-      "evaluatedAt": "2026-01-22T18:22:48.609Z",
-      "notes": "Superseded by expand-sequence-expressions-v3."
-    },
-    {
-      "id": "expand-sequence-expressions-v3",
-      "description": "Expands comma operator sequences in returns, throws, statements, and variable initializers",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.014391951831788763,
-      "recommended": false,
-      "evaluatedAt": "2026-01-23T08:21:23.662Z",
-      "notes": "Supersedes expand-sequence-expressions-v2 in the recommended preset. Measured with baseline none: -1.44%. Enabled for readability even when line diffs increase."
-    },
     {
       "id": "expand-sequence-expressions-v4",
       "description": "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), and variable initializers",
@@ -107,7 +67,7 @@
       "diffReductionImpact": -0.01730809158000035,
       "recommended": true,
       "evaluatedAt": "2026-01-23T10:57:45.082Z",
-      "notes": "Measured with baseline none: -1.73%. Supersedes expand-sequence-expressions-v3 and includes control-flow-body expansion."
+      "notes": "Measured with baseline none: -1.73%. Supersedes all prior sequence expression transforms."
     },
     {
       "id": "rename-use-reference-guards",
@@ -135,9 +95,9 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0.00003774938185385768,
-      "recommended": false,
+      "recommended": true,
       "evaluatedAt": "2026-01-23T10:29:23.279Z",
-      "notes": "Measured with baseline none: 0.00%. Not enabled by default (readability-only)."
+      "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
     },
     {
       "id": "split-variable-declarations",
@@ -149,16 +109,6 @@
       "evaluatedAt": "2026-01-23T05:45:27.981Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase."
     },
-    {
-      "id": "expand-throw-sequence",
-      "description": "Expands throw sequences like `throw (a(), b)`",
-      "scope": "file",
-      "parallelizable": true,
-      "diffReductionImpact": -0.00007549876370771536,
-      "recommended": false,
-      "evaluatedAt": "2026-01-23T07:48:29.356Z",
-      "notes": "Largely superseded by expand-sequence-expressions-v3 (which also expands throw sequences), but kept for isolated runs and comparison."
-    },
     {
       "id": "rename-promise-executor-parameters",
       "description": "Renames promise-like executor parameters in `new X(executor)` to resolve/reject when usage is high-confidence",

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.d.ts

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

package/dist/transforms/expand-return-sequence/expand-return-sequence-transform.js

@@ -1,91 +0,0 @@
-import { createRequire } from "node:module";
-import { getFilesToProcess, } from "../../core/types.js";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const traverse = require("@babel/traverse").default;
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const t = require("@babel/types");
-const isSupportedParent = (path) => {
-    return path.parentPath.isBlockStatement() || path.parentPath.isSwitchCase();
-};
-const getSequenceExpressions = (node) => {
-    const argument = node.argument;
-    if (!argument)
-        return;
-    if (argument.type !== "SequenceExpression")
-        return;
-    if (argument.expressions.length < 2)
-        return;
-    return argument.expressions;
-};
-const createExpressionStatement = (expression) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    return t.expressionStatement(expression);
-};
-const createReturnStatement = (expression) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-    return t.returnStatement(expression);
-};
-const isDirectiveProloguePosition = (path) => {
-    if (!path.parentPath.isBlockStatement())
-        return false;
-    const siblings = path.parentPath.get("body");
-    if (!Array.isArray(siblings))
-        return false;
-    const index = siblings.findIndex((sibling) => sibling.node === path.node);
-    if (index === -1)
-        return false;
-    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
-        const sibling = siblings[bodyIndex];
-        if (!sibling)
-            return false;
-        if (!sibling.isExpressionStatement())
-            return false;
-        if (sibling.node.expression.type !== "StringLiteral")
-            return false;
-    }
-    return true;
-};
-export const expandReturnSequenceTransform = {
-    id: "expand-return-sequence",
-    description: "Expands return sequences like `return a(), b();`",
-    scope: "file",
-    parallelizable: true,
-    transform(context) {
-        let nodesVisited = 0;
-        let transformationsApplied = 0;
-        for (const fileInfo of getFilesToProcess(context)) {
-            traverse(fileInfo.ast, {
-                ReturnStatement(path) {
-                    nodesVisited++;
-                    if (!isSupportedParent(path))
-                        return;
-                    const expressions = getSequenceExpressions(path.node);
-                    if (!expressions)
-                        return;
-                    const leadingExpressions = expressions.slice(0, -1);
-                    const lastExpression = expressions.at(-1);
-                    if (!lastExpression)
-                        return;
-                    const firstExpression = leadingExpressions[0];
-                    if (firstExpression?.type === "StringLiteral" &&
-                        isDirectiveProloguePosition(path)) {
-                        return;
-                    }
-                    const statements = leadingExpressions.map((expression) => createExpressionStatement(
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                    t.cloneNode(expression, true)));
-                    statements.push(createReturnStatement(
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-                    t.cloneNode(lastExpression, true)));
-                    path.replaceWithMultiple(statements);
-                    transformationsApplied++;
-                },
-            });
-        }
-        return Promise.resolve({
-            nodesVisited,
-            transformationsApplied,
-        });
-    },
-};

package/dist/transforms/expand-sequence-expressions/expand-expression-statement-sequence.d.ts

@@ -1,3 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type { ExpressionStatement } from "@babel/types";
-export declare const tryExpandExpressionStatementSequence: (path: NodePath<ExpressionStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions/expand-expression-statement-sequence.js

@@ -1,57 +0,0 @@
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const t = require("@babel/types");
-const isSupportedStatementContainer = (path) => {
-    const parentPath = path.parentPath;
-    if (!parentPath)
-        return false;
-    return (parentPath.isProgram() ||
-        parentPath.isBlockStatement() ||
-        parentPath.isSwitchCase());
-};
-const isDirectiveProloguePosition = (path) => {
-    const parentPath = path.parentPath;
-    if (!parentPath)
-        return false;
-    if (!parentPath.isProgram() && !parentPath.isBlockStatement())
-        return false;
-    const siblings = parentPath.get("body");
-    if (!Array.isArray(siblings))
-        return false;
-    const index = siblings.findIndex((sibling) => sibling.node === path.node);
-    if (index === -1)
-        return false;
-    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
-        const sibling = siblings[bodyIndex];
-        if (!sibling)
-            return false;
-        if (!sibling.isExpressionStatement())
-            return false;
-        if (sibling.node.expression.type !== "StringLiteral")
-            return false;
-    }
-    return true;
-};
-export const tryExpandExpressionStatementSequence = (path) => {
-    if (!isSupportedStatementContainer(path))
-        return false;
-    const expression = path.node.expression;
-    if (expression.type !== "SequenceExpression")
-        return false;
-    if (expression.expressions.length < 2)
-        return false;
-    const firstExpression = expression.expressions[0];
-    if (firstExpression?.type === "StringLiteral" &&
-        isDirectiveProloguePosition(path)) {
-        return false;
-    }
-    const statements = expression.expressions.map((expr) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        return t.expressionStatement(
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        t.cloneNode(expr, true));
-    });
-    path.replaceWithMultiple(statements);
-    return true;
-};

package/dist/transforms/expand-sequence-expressions/expand-sequence-expressions-transform.d.ts

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