miniread 1.6.0 → 1.8.0

package/dist/scripts/snapshot.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { runSnapshotCli } from "./snapshot/run-snapshot-cli.js";
+try {
+    const exitCode = await runSnapshotCli(process.argv);
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}

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

@@ -1,63 +1,40 @@
 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
 const traverse = require("@babel/traverse").default;
 const BASE_NAME = "caughtError";
-const getRenamedAncestorCatchCount = (path, renamedCatches) => {
-    let count = 0;
-    for (const ancestor of path.getAncestry()) {
-        if (ancestor === path)
-            continue;
-        if (!ancestor.isCatchClause())
-            continue;
-        if (renamedCatches.has(ancestor.node))
-            count++;
-    }
-    return count;
-};
-const getTargetCaughtErrorName = (renamedAncestorCatchCount) => {
-    if (renamedAncestorCatchCount === 0)
-        return BASE_NAME;
-    return `${BASE_NAME}${renamedAncestorCatchCount + 1}`;
-};
-const getCatchParameterNameIfEligible = (path) => {
-    const parameter = path.node.param;
-    if (!parameter)
-        return;
-    if (parameter.type !== "Identifier")
-        return;
-    if (parameter.name.length > 2)
-        return;
-    return parameter.name;
-};
 export const renameCatchParametersTransform = {
     id: "rename-catch-parameters",
-    description: "Renames minified catch clause parameters to caughtError/caughtError2/...",
+    description: "Renames catch clause parameters to $caughtError/$caughtError2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            const renamedCatches = new WeakMap();
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 CatchClause(path) {
                     nodesVisited++;
-                    const currentName = getCatchParameterNameIfEligible(path);
-                    if (!currentName)
+                    const parameter = path.node.param;
+                    if (!parameter)
                         return;
-                    const renamedAncestorCatchCount = getRenamedAncestorCatchCount(path, renamedCatches);
-                    const targetName = getTargetCaughtErrorName(renamedAncestorCatchCount);
-                    if (currentName === targetName)
+                    if (parameter.type !== "Identifier")
                         return;
-                    if (path.scope.hasBinding(targetName))
+                    const currentName = parameter.name;
+                    // Skip already-stable names
+                    if (isStableRenamed(currentName))
                         return;
-                    path.scope.rename(currentName, targetName);
-                    renamedCatches.set(path.node, targetName);
-                    transformationsApplied++;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

package/dist/transforms/rename-destructured-aliases/rename-destructured-aliases-transform.js

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
 import { getFilesToProcess, } from "../../core/types.js";
+import { RenameGroup } from "../../core/stable-naming.js";
 import { isBindingContext } from "./binding-context.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -22,7 +23,7 @@ const isValidBindingIdentifier = (name) => {
         return false;
     return true;
 };
-const processObjectPattern = (path, stats) => {
+const processObjectPattern = (path, group) => {
     // Only process in binding contexts, not assignment expressions
     if (!isBindingContext(path))
         return;
@@ -84,14 +85,12 @@ const processObjectPattern = (path, stats) => {
             referencePath.scope.hasBinding(keyName));
         if (wouldBeShadowed)
             continue;
-        // Rename the variable in the scope
-        bindingScope.rename(aliasName, keyName);
-        // Update the destructuring to use shorthand
-        // For { a: b } -> { a }
-        // For { a: b = 1 } -> { a = 1 }
-        property.shorthand = true;
-        aliasIdentifier.name = keyName;
-        stats.transformationsApplied++;
+        // Add to rename group for batch processing with stability logic
+        group.add({
+            scope: bindingScope,
+            currentName: aliasName,
+            baseName: keyName,
+        });
     }
 };
 export const renameDestructuredAliasesTransform = {
@@ -101,18 +100,20 @@ export const renameDestructuredAliasesTransform = {
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
-        const stats = { transformationsApplied: 0 };
+        let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 ObjectPattern(path) {
                     nodesVisited++;
-                    processObjectPattern(path, stats);
+                    processObjectPattern(path, group);
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,
-            transformationsApplied: stats.transformationsApplied,
+            transformationsApplied,
         });
     },
 };

package/dist/transforms/rename-event-parameters/process-event-handler-function.d.ts

@@ -1,5 +1,4 @@
 import type { NodePath } from "@babel/traverse";
 import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
-export declare const processEventHandlerFunction: (path: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, stats: {
-    transformationsApplied: number;
-}) => void;
+import { type RenameGroup } from "../../core/stable-naming.js";
+export declare const processEventHandlerFunction: (path: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, group: RenameGroup) => void;

package/dist/transforms/rename-event-parameters/process-event-handler-function.js

@@ -1,3 +1,4 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
 import { getEventParameterUsage, isHighConfidenceEventParameter, } from "./event-parameter-usage.js";
 import { getTargetEventName } from "./get-target-event-name.js";
 import { canRenameBindingSafely } from "./can-rename-binding-safely.js";
@@ -23,7 +24,7 @@ const wouldShadowReferencedImplicitGlobal = (functionPath, targetName) => {
     });
     return foundReference;
 };
-export const processEventHandlerFunction = (path, stats) => {
+export const processEventHandlerFunction = (path, group) => {
     const parameters = path.node.params;
     if (parameters.length !== 1)
         return;
@@ -32,12 +33,12 @@ export const processEventHandlerFunction = (path, stats) => {
         return;
     if (parameter.type !== "Identifier")
         return;
-    // 1-2 character parameter names are a strong minification signal (e.g. `e`, `t`, `WA`).
-    // Keeping this conservative avoids renaming common intentional abbreviations (e.g. `evt`).
-    if (parameter.name.length > 2)
+    const currentName = parameter.name;
+    // Skip already-stable names
+    if (isStableRenamed(currentName))
         return;
     const bindingScope = path.scope;
-    const binding = bindingScope.getBinding(parameter.name);
+    const binding = bindingScope.getBinding(currentName);
     if (!binding)
         return;
     if (!binding.constant)
@@ -46,14 +47,17 @@ export const processEventHandlerFunction = (path, stats) => {
     if (!isHighConfidenceEventParameter(usage))
         return;
     const targetName = getTargetEventName(usage);
-    if (parameter.name === targetName)
+    if (currentName === targetName)
         return;
     if (wouldShadowReferencedImplicitGlobal(path, targetName))
         return;
     if (wouldShadowReferencedOuterBinding(path, targetName))
         return;
-    if (!canRenameBindingSafely(bindingScope, parameter.name, targetName))
+    if (!canRenameBindingSafely(bindingScope, currentName, targetName))
         return;
-    bindingScope.rename(parameter.name, targetName);
-    stats.transformationsApplied++;
+    group.add({
+        scope: bindingScope,
+        currentName,
+        baseName: targetName,
+    });
 };

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

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

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.8.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",
@@ -24,7 +24,8 @@
   "bin": {
     "miniread": "bin/miniread",
     "miniread-evaluate": "bin/miniread-evaluate",
-    "miniread-sample": "bin/miniread-sample"
+    "miniread-sample": "bin/miniread-sample",
+    "miniread-snapshot": "bin/miniread-snapshot"
   },
   "files": [
     "bin/",
@@ -47,6 +48,7 @@
     "miniread": "pnpm -s run rebuild && node bin/miniread",
     "miniread-evaluate": "pnpm -s run rebuild && node bin/miniread-evaluate",
     "miniread-sample": "pnpm -s run rebuild && node bin/miniread-sample",
+    "snapshot": "pnpm -s run rebuild && node bin/miniread-snapshot",
     "rebuild": "pnpm run clean && pnpm run build",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",