miniread 1.102.1 → 1.103.0

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.32290131156216,
-        "notes": "Measured with baseline none: 26.32% of original diff."
+        "diffSizePercent": 26.281324413198774,
+        "notes": "Measured with baseline none: 26.28% of original diff."
     }
 }

package/dist/transforms/shared/would-capture-referenced-outer-binding.d.ts

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

package/dist/transforms/shared/would-capture-referenced-outer-binding.js

@@ -0,0 +1,14 @@
+export const wouldCaptureReferencedOuterBinding = (bindingScope, targetName) => {
+    if (bindingScope.path.isProgram())
+        return false;
+    const outerBinding = bindingScope.parent.getBinding(targetName);
+    if (!outerBinding)
+        return false;
+    const outerUsagePaths = [
+        ...outerBinding.referencePaths,
+        ...outerBinding.constantViolations,
+    ];
+    return outerUsagePaths.some((usagePath) => {
+        return usagePath.isDescendant(bindingScope.path);
+    });
+};

package/dist/transforms-by-id/expand-boolean-literals/detect-global-boolean-rebinding.d.ts

@@ -0,0 +1,2 @@
+import type { File } from "@babel/types";
+export declare const hasGlobalBooleanRebinding: (ast: File) => boolean;

package/dist/transforms-by-id/expand-boolean-literals/detect-global-boolean-rebinding.js

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const GLOBAL_OBJECT_NAMES = new Set(["globalThis", "global", "window", "self"]);
+const isGlobalBooleanMemberExpression = (node) => {
+    if (node.object.type !== "Identifier")
+        return false;
+    if (!GLOBAL_OBJECT_NAMES.has(node.object.name))
+        return false;
+    if (!node.computed) {
+        return (node.property.type === "Identifier" && node.property.name === "Boolean");
+    }
+    return (node.property.type === "StringLiteral" && node.property.value === "Boolean");
+};
+export const hasGlobalBooleanRebinding = (ast) => {
+    let foundGlobalBooleanRebinding = false;
+    traverse(ast, {
+        AssignmentExpression(path) {
+            if (foundGlobalBooleanRebinding)
+                return;
+            const { left } = path.node;
+            if (left.type === "Identifier" && left.name === "Boolean") {
+                if (!path.scope.hasBinding("Boolean", true)) {
+                    foundGlobalBooleanRebinding = true;
+                    path.stop();
+                }
+                return;
+            }
+            if (left.type === "MemberExpression" &&
+                isGlobalBooleanMemberExpression(left)) {
+                foundGlobalBooleanRebinding = true;
+                path.stop();
+            }
+        },
+        UpdateExpression(path) {
+            if (foundGlobalBooleanRebinding)
+                return;
+            const { argument } = path.node;
+            if (argument.type === "Identifier" && argument.name === "Boolean") {
+                if (!path.scope.hasBinding("Boolean", true)) {
+                    foundGlobalBooleanRebinding = true;
+                    path.stop();
+                }
+                return;
+            }
+            if (argument.type === "MemberExpression" &&
+                isGlobalBooleanMemberExpression(argument)) {
+                foundGlobalBooleanRebinding = true;
+                path.stop();
+            }
+        },
+    });
+    return foundGlobalBooleanRebinding;
+};

package/dist/transforms-by-id/expand-boolean-literals/expand-boolean-literals-transform.js

@@ -1,58 +1,11 @@
 import { createRequire } from "node:module";
 import { getFilesToProcess, } from "../../core/types.js";
+import { hasGlobalBooleanRebinding } from "./detect-global-boolean-rebinding.js";
+import { resolveBooleanNegationValue, resolveDoubleNegationValue, } from "./resolve-literal-boolean-value.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
 const t = require("@babel/types");
-const GLOBAL_OBJECT_NAMES = new Set(["globalThis", "global", "window", "self"]);
-const isGlobalBooleanMemberExpression = (node) => {
-    if (node.object.type !== "Identifier") {
-        return false;
-    }
-    if (!GLOBAL_OBJECT_NAMES.has(node.object.name)) {
-        return false;
-    }
-    if (!node.computed) {
-        return (node.property.type === "Identifier" && node.property.name === "Boolean");
-    }
-    return (node.property.type === "StringLiteral" && node.property.value === "Boolean");
-};
-const hasGlobalBooleanRebinding = (ast) => {
-    let globalBooleanRebound = false;
-    traverse(ast, {
-        AssignmentExpression(path) {
-            const { left } = path.node;
-            if (left.type === "Identifier" && left.name === "Boolean") {
-                if (!path.scope.hasBinding("Boolean", true)) {
-                    globalBooleanRebound = true;
-                    path.stop();
-                }
-                return;
-            }
-            if (left.type === "MemberExpression" &&
-                isGlobalBooleanMemberExpression(left)) {
-                globalBooleanRebound = true;
-                path.stop();
-            }
-        },
-        UpdateExpression(path) {
-            const { argument } = path.node;
-            if (argument.type === "Identifier" && argument.name === "Boolean") {
-                if (!path.scope.hasBinding("Boolean", true)) {
-                    globalBooleanRebound = true;
-                    path.stop();
-                }
-                return;
-            }
-            if (argument.type === "MemberExpression" &&
-                isGlobalBooleanMemberExpression(argument)) {
-                globalBooleanRebound = true;
-                path.stop();
-            }
-        },
-    });
-    return globalBooleanRebound;
-};
 export const expandBooleanLiteralsTransform = {
     id: "expand-boolean-literals",
     description: "Expands !0 to true and !1 to false",
@@ -62,7 +15,7 @@ export const expandBooleanLiteralsTransform = {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            const globalBooleanRebound = hasGlobalBooleanRebinding(fileInfo.ast);
+            const hasGlobalBooleanRebindingInFile = hasGlobalBooleanRebinding(fileInfo.ast);
             traverse(fileInfo.ast, {
                 UnaryExpression(path) {
                     nodesVisited++;
@@ -70,34 +23,54 @@ export const expandBooleanLiteralsTransform = {
                     if (operator !== "!") {
                         return;
                     }
-                    if (argument.type === "NumericLiteral") {
-                        // !0 = true, !1 = false, !2 = false
-                        const booleanValue = argument.value === 0;
-                        path.replaceWith(t.booleanLiteral(booleanValue));
+                    if (path.findParent((parentPath) => parentPath.isWithStatement())) {
+                        return;
+                    }
+                    const booleanNegationResolution = resolveBooleanNegationValue(path, argument);
+                    if (booleanNegationResolution !== undefined) {
+                        if (booleanNegationResolution.kind === "literal" &&
+                            !path.get("argument").isPure()) {
+                            return;
+                        }
+                        path.replaceWith(t.booleanLiteral(booleanNegationResolution.value));
                         transformationsApplied++;
                         return;
                     }
                     if (argument.type === "UnaryExpression" &&
                         argument.operator === "!" &&
                         argument.argument.type === "NumericLiteral") {
-                        // !!0 = false, !!1 = true, !!2 = true
                         const booleanValue = argument.argument.value !== 0;
                         path.replaceWith(t.booleanLiteral(booleanValue));
                         transformationsApplied++;
                         return;
                     }
+                    if (argument.type === "BinaryExpression" &&
+                        (argument.operator === "in" || argument.operator === "instanceof")) {
+                        path.replaceWith(t.binaryExpression("===", t.parenthesizedExpression(t.cloneNode(argument, true)), t.booleanLiteral(false)));
+                        transformationsApplied++;
+                        return;
+                    }
                     if (argument.type === "UnaryExpression" &&
                         argument.operator === "!") {
-                        if (path.scope.hasBinding("Boolean", true)) {
+                        const doubleNegationResolution = resolveDoubleNegationValue(path, argument.argument);
+                        if (doubleNegationResolution !== undefined) {
+                            if (doubleNegationResolution.kind === "literal" &&
+                                !path.get("argument.argument").isPure()) {
+                                return;
+                            }
+                            path.replaceWith(t.booleanLiteral(doubleNegationResolution.value));
+                            transformationsApplied++;
                             return;
                         }
-                        if (globalBooleanRebound) {
+                    }
+                    if (argument.type === "UnaryExpression" &&
+                        argument.operator === "!") {
+                        if (path.scope.hasBinding("Boolean", true)) {
                             return;
                         }
-                        if (path.findParent((parentPath) => parentPath.isWithStatement())) {
+                        if (hasGlobalBooleanRebindingInFile) {
                             return;
                         }
-                        // !!value = Boolean(value) when Boolean isn't shadowed
                         path.replaceWith(t.callExpression(t.identifier("Boolean"), [
                             t.cloneNode(argument.argument, true),
                         ]));

package/dist/transforms-by-id/expand-boolean-literals/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Improves readability but does not reduce diffs (boolean literals are already deterministic)",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-09T10:17:51.112Z",
-            "changedLines": 36892,
-            "durationSeconds": 40.374271209,
+            "evaluatedAt": "2026-02-10T20:27:40.370Z",
+            "changedLines": 37534,
+            "durationSeconds": 40.372261375,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/expand-boolean-literals/resolve-literal-boolean-value.d.ts

@@ -0,0 +1,10 @@
+import type { NodePath } from "@babel/traverse";
+import type * as BabelTypes from "@babel/types";
+import type { UnaryExpression } from "@babel/types";
+type ResolvedBooleanValue = {
+    kind: "literal" | "global-identifier" | "const-identifier";
+    value: boolean;
+};
+export declare const resolveBooleanNegationValue: (path: NodePath<UnaryExpression>, argument: BabelTypes.Expression) => ResolvedBooleanValue | undefined;
+export declare const resolveDoubleNegationValue: (path: NodePath<UnaryExpression>, argument: BabelTypes.Expression) => ResolvedBooleanValue | undefined;
+export {};

package/dist/transforms-by-id/expand-boolean-literals/resolve-literal-boolean-value.js

@@ -0,0 +1,86 @@
+const getLiteralBooleanValue = (node) => {
+    if (node.type === "NumericLiteral")
+        return node.value !== 0;
+    if (node.type === "BigIntLiteral")
+        return BigInt(node.value) !== 0n;
+    if (node.type === "StringLiteral")
+        return node.value.length > 0;
+    if (node.type === "BooleanLiteral")
+        return node.value;
+    if (node.type === "NullLiteral")
+        return false;
+    if (node.type === "UnaryExpression") {
+        return node.operator === "void" ? false : undefined;
+    }
+    if (node.type === "ArrayExpression" ||
+        node.type === "ObjectExpression" ||
+        node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "ClassExpression" ||
+        node.type === "RegExpLiteral") {
+        return true;
+    }
+    return undefined;
+};
+const getGlobalIdentifierBooleanValue = (path, node) => {
+    if (node.type !== "Identifier")
+        return undefined;
+    if (path.scope.hasBinding(node.name, true))
+        return undefined;
+    if (node.name === "NaN")
+        return false;
+    if (node.name === "Infinity")
+        return true;
+    return undefined;
+};
+const getConstIdentifierBooleanValue = (path, node) => {
+    if (node.type !== "Identifier")
+        return undefined;
+    const binding = path.scope.getBinding(node.name);
+    if (binding?.kind !== "const")
+        return undefined;
+    if (!binding.path.isVariableDeclarator())
+        return undefined;
+    const declarationEnd = binding.path.node.end;
+    const expressionStart = path.node.start;
+    if (declarationEnd === undefined ||
+        declarationEnd === null ||
+        expressionStart === undefined ||
+        expressionStart === null ||
+        declarationEnd >= expressionStart) {
+        return undefined;
+    }
+    const initializer = binding.path.node.init;
+    if (!initializer)
+        return undefined;
+    return getLiteralBooleanValue(initializer);
+};
+export const resolveBooleanNegationValue = (path, argument) => {
+    const literalBooleanValue = getLiteralBooleanValue(argument);
+    if (literalBooleanValue !== undefined) {
+        return { kind: "literal", value: !literalBooleanValue };
+    }
+    const globalIdentifierBooleanValue = getGlobalIdentifierBooleanValue(path, argument);
+    if (globalIdentifierBooleanValue !== undefined) {
+        return { kind: "global-identifier", value: !globalIdentifierBooleanValue };
+    }
+    const constIdentifierBooleanValue = getConstIdentifierBooleanValue(path, argument);
+    if (constIdentifierBooleanValue !== undefined) {
+        return { kind: "const-identifier", value: !constIdentifierBooleanValue };
+    }
+    return undefined;
+};
+export const resolveDoubleNegationValue = (path, argument) => {
+    const literalBooleanValue = getLiteralBooleanValue(argument);
+    if (literalBooleanValue !== undefined) {
+        return { kind: "literal", value: literalBooleanValue };
+    }
+    const globalIdentifierBooleanValue = getGlobalIdentifierBooleanValue(path, argument);
+    if (globalIdentifierBooleanValue !== undefined) {
+        return { kind: "global-identifier", value: globalIdentifierBooleanValue };
+    }
+    const constIdentifierBooleanValue = getConstIdentifierBooleanValue(path, argument);
+    if (constIdentifierBooleanValue === undefined)
+        return undefined;
+    return { kind: "const-identifier", value: constIdentifierBooleanValue };
+};

package/dist/transforms-by-id/expand-sequence-expressions-v5/expand-sequence-expressions-v5-transform.js

@@ -17,38 +17,53 @@ export const expandSequenceExpressionsV5Transform = {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const [, fileInfo] of projectGraph.files) {
+            let fileTransformationsApplied = 0;
             traverse(fileInfo.ast, {
                 ReturnStatement(path) {
                     nodesVisited++;
                     if (!tryExpandReturnSequence(path))
                         return;
+                    fileTransformationsApplied += 1;
                     transformationsApplied += 1;
                 },
                 ThrowStatement(path) {
                     nodesVisited++;
                     if (!tryExpandThrowSequence(path))
                         return;
+                    fileTransformationsApplied += 1;
                     transformationsApplied += 1;
                 },
                 ExpressionStatement(path) {
                     nodesVisited++;
                     if (!tryExpandExpressionStatementSequence(path))
                         return;
+                    fileTransformationsApplied += 1;
                     transformationsApplied += 1;
                 },
                 VariableDeclaration(path) {
                     nodesVisited++;
                     if (!tryExpandVariableDeclarationSequenceInitializers(path))
                         return;
+                    fileTransformationsApplied += 1;
                     transformationsApplied += 1;
                 },
                 IfStatement(path) {
                     nodesVisited++;
                     if (!tryExpandIfStatementTestSequence(path))
                         return;
+                    fileTransformationsApplied += 1;
                     transformationsApplied += 1;
                 },
             });
+            if (fileTransformationsApplied === 0)
+                continue;
+            // Keep scope bindings/reference paths in sync for downstream transforms.
+            traverse(fileInfo.ast, {
+                Program(path) {
+                    path.scope.crawl();
+                    path.stop();
+                },
+            });
         }
         return Promise.resolve({ nodesVisited, transformationsApplied });
     },

package/dist/transforms-by-id/expand-sequence-expressions-v5/expand-variable-declaration-sequence.js

@@ -1,4 +1,5 @@
 import { createRequire } from "node:module";
+import { tryExpandForStatementInitSequence } from "./try-expand-for-statement-init-sequence.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const t = require("@babel/types");
@@ -28,7 +29,7 @@ const createVariableDeclarator = (id, init) => {
             t.cloneNode(init, true)
         : undefined);
 };
-const isSupportedStatementContainer = (path) => {
+const canReplaceWithMultiple = (path) => {
     const parentPath = path.parentPath;
     if (!parentPath)
         return false;
@@ -37,6 +38,28 @@ const isSupportedStatementContainer = (path) => {
         parentPath.isStaticBlock() ||
         parentPath.isSwitchCase());
 };
+const canWrapInBlock = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    if (parentPath.isLabeledStatement() && path.key === "body") {
+        return true;
+    }
+    if (parentPath.isIfStatement() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        return true;
+    }
+    if ((parentPath.isForStatement() ||
+        parentPath.isForInStatement() ||
+        parentPath.isForOfStatement() ||
+        parentPath.isWhileStatement() ||
+        parentPath.isDoWhileStatement() ||
+        parentPath.isWithStatement()) &&
+        path.key === "body") {
+        return true;
+    }
+    return false;
+};
 const isDirectiveProloguePosition = (path) => {
     const parentPath = path.parentPath;
     if (!parentPath)
@@ -69,14 +92,25 @@ const isDirectiveProloguePosition = (path) => {
     return true;
 };
 export const tryExpandVariableDeclarationSequenceInitializers = (path) => {
-    if (!isSupportedStatementContainer(path))
-        return false;
-    const isDirectivePrologueAtInsertion = isDirectiveProloguePosition(path);
-    const hasAnySequence = path.node.declarations.some((declarator) => declarator.init?.type === "SequenceExpression" &&
-        declarator.init.expressions.length >= 2);
+    const hasAnySequence = path.node.declarations.some((declarator) => {
+        return (declarator.init?.type === "SequenceExpression" &&
+            declarator.init.expressions.length >= 2);
+    });
     if (!hasAnySequence)
         return false;
     const kind = path.node.kind;
+    if (tryExpandForStatementInitSequence(path, {
+        canReplaceWithMultiple,
+        canWrapInBlock,
+        createExpressionStatement,
+        createVariableDeclarator,
+        isDirectiveProloguePosition,
+    })) {
+        return true;
+    }
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const isDirectivePrologueAtInsertion = isDirectiveProloguePosition(path);
     const statements = [];
     for (const declarator of path.node.declarations) {
         const init = declarator.init;
@@ -98,6 +132,14 @@ export const tryExpandVariableDeclarationSequenceInitializers = (path) => {
         const newDeclarator = createVariableDeclarator(declarator.id, lastExpression);
         statements.push(createVariableDeclarationStatement(kind, newDeclarator));
     }
-    path.replaceWithMultiple(statements);
-    return true;
+    if (canReplaceWithMultiple(path)) {
+        path.replaceWithMultiple(statements);
+        return true;
+    }
+    if (canWrapInBlock(path)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        path.replaceWith(t.blockStatement(statements));
+        return true;
+    }
+    return false;
 };

package/dist/transforms-by-id/expand-sequence-expressions-v5/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Extends expand-sequence-expressions-v4 by also expanding `if ((a, b)) ...` style tests.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 102.02808406370747,
-            "evaluatedAt": "2026-02-07T21:13:19.936Z",
-            "changedLines": 205350,
-            "durationSeconds": 256.357508961,
+            "diffSizePercent": 102.02970858373965,
+            "evaluatedAt": "2026-02-11T06:06:13.210Z",
+            "changedLines": 204853,
+            "durationSeconds": 46.743897499999996,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/expand-sequence-expressions-v5/try-expand-for-statement-init-sequence.d.ts

@@ -0,0 +1,13 @@
+import type { NodePath } from "@babel/traverse";
+import type { Expression, Statement, VariableDeclaration } from "@babel/types";
+type ForStatementInitHelpers = {
+    canReplaceWithMultiple: (path: NodePath) => boolean;
+    canWrapInBlock: (path: NodePath) => boolean;
+    createExpressionStatement: (expression: Expression, options: {
+        wrapStringLiteralDirective: boolean;
+    }) => Statement;
+    createVariableDeclarator: (id: VariableDeclaration["declarations"][number]["id"], init: VariableDeclaration["declarations"][number]["init"]) => VariableDeclaration["declarations"][number];
+    isDirectiveProloguePosition: (path: NodePath) => boolean;
+};
+export declare const tryExpandForStatementInitSequence: (path: NodePath<VariableDeclaration>, helpers: ForStatementInitHelpers) => boolean;
+export {};

package/dist/transforms-by-id/expand-sequence-expressions-v5/try-expand-for-statement-init-sequence.js

@@ -0,0 +1,110 @@
+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");
+export const tryExpandForStatementInitSequence = (path, helpers) => {
+    const parentPath = path.parentPath;
+    if (!parentPath.isForStatement())
+        return false;
+    if (path.key !== "init")
+        return false;
+    if (path.node.kind !== "var")
+        return false;
+    const sequenceDeclaratorIndices = path.node.declarations
+        .map((declarator, index) => {
+        if (declarator.init?.type !== "SequenceExpression")
+            return -1;
+        return declarator.init.expressions.length >= 2 ? index : -1;
+    })
+        .filter((index) => index !== -1);
+    if (sequenceDeclaratorIndices.length === 0)
+        return false;
+    const insertionTarget = parentPath.parentPath.isLabeledStatement()
+        ? parentPath.parentPath
+        : parentPath;
+    const canReplace = helpers.canReplaceWithMultiple(insertionTarget);
+    const canWrap = helpers.canWrapInBlock(insertionTarget);
+    if (!canReplace && !canWrap)
+        return false;
+    const shouldWrapDirective = helpers.isDirectiveProloguePosition(insertionTarget);
+    const createVariableDeclarationStatement = (declarator) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.variableDeclaration(path.node.kind, [
+            helpers.createVariableDeclarator(declarator.id, declarator.init),
+        ]);
+    };
+    if (sequenceDeclaratorIndices.length >= 2) {
+        const statements = [];
+        for (const declarator of path.node.declarations) {
+            const init = declarator.init;
+            if (init?.type !== "SequenceExpression") {
+                statements.push(createVariableDeclarationStatement(declarator));
+                continue;
+            }
+            const leadingExpressions = init.expressions.slice(0, -1);
+            const lastExpression = init.expressions.at(-1);
+            if (!lastExpression) {
+                statements.push(createVariableDeclarationStatement(declarator));
+                continue;
+            }
+            for (const expression of leadingExpressions) {
+                statements.push(helpers.createExpressionStatement(expression, {
+                    wrapStringLiteralDirective: shouldWrapDirective && statements.length === 0,
+                }));
+            }
+            statements.push(createVariableDeclarationStatement(helpers.createVariableDeclarator(declarator.id, lastExpression)));
+        }
+        parentPath.node.init = undefined;
+        if (canReplace) {
+            insertionTarget.insertBefore(statements);
+            return true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        const wrappedStatement = t.blockStatement([
+            ...statements,
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            t.cloneNode(insertionTarget.node, true),
+        ]);
+        insertionTarget.replaceWith(wrappedStatement);
+        return true;
+    }
+    const statements = [];
+    const updatedDeclarators = path.node.declarations.map((declarator) => {
+        const init = declarator.init;
+        if (init?.type !== "SequenceExpression") {
+            return helpers.createVariableDeclarator(declarator.id, init);
+        }
+        const leadingExpressions = init.expressions.slice(0, -1);
+        const lastExpression = init.expressions.at(-1);
+        if (!lastExpression) {
+            return helpers.createVariableDeclarator(declarator.id, init);
+        }
+        for (const expression of leadingExpressions) {
+            statements.push(helpers.createExpressionStatement(expression, {
+                wrapStringLiteralDirective: shouldWrapDirective && statements.length === 0,
+            }));
+        }
+        return helpers.createVariableDeclarator(declarator.id, lastExpression);
+    });
+    if (statements.length === 0)
+        return false;
+    const updatedInit = 
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.variableDeclaration(path.node.kind, updatedDeclarators);
+    if (canReplace) {
+        parentPath.node.init = updatedInit;
+        insertionTarget.insertBefore(statements);
+        return true;
+    }
+    if (!canWrap)
+        return false;
+    parentPath.node.init = updatedInit;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    const wrappedStatement = t.blockStatement([
+        ...statements,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(insertionTarget.node, true),
+    ]);
+    insertionTarget.replaceWith(wrappedStatement);
+    return true;
+};

package/dist/transforms-by-id/remove-redundant-else/does-jump-interrupt-boundary.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { BreakStatement, ContinueStatement, IfStatement } from "@babel/types";
+type JumpPath = NodePath<BreakStatement | ContinueStatement>;
+export declare function doesJumpInterruptBoundary(jumpPath: JumpPath, boundaryIfPath: NodePath<IfStatement>): boolean;
+export {};