miniread 1.120.0 → 1.120.2

package/dist/transforms/get-url-construction-kind.js

@@ -1,4 +1,5 @@
 import { isAllowedUrlNamespaceBindingInScope } from "./is-allowed-url-namespace-binding-in-scope.js";
+const globalUrlNamespaceObjects = new Set(["globalThis", "window", "self"]);
 export const getUrlConstructionKind = (scope, node, constructorName) => {
     if (node?.type !== "NewExpression")
         return undefined;
@@ -40,7 +41,13 @@ export const getUrlConstructionKind = (scope, node, constructorName) => {
         return undefined;
     if (callee.object.type !== "Identifier")
         return undefined;
-    if (!isAllowedUrlNamespaceBindingInScope(scope, callee.object.name)) {
+    if (isAllowedUrlNamespaceBindingInScope(scope, callee.object.name)) {
+        return "member";
+    }
+    if (!globalUrlNamespaceObjects.has(callee.object.name)) {
+        return undefined;
+    }
+    if (scope.getBinding(callee.object.name)) {
         return undefined;
     }
     return "member";

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 23.705446573685602,
-        "notes": "Measured with baseline none: 23.71% of original diff."
+        "diffSizePercent": 23.180065767093776,
+        "notes": "Measured with baseline none: 23.18% of original diff."
     }
 }

package/dist/transforms/url-usage-heuristics.js

@@ -38,13 +38,13 @@ export const hasUrlDestructure = (referencePath) => {
     if (parent.isVariableDeclarator() &&
         parent.node.init === referencePath.node &&
         parent.node.id.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.id) >= 2;
+        return countUrlProperties(parent.node.id) >= 1;
     }
     if (parent.isAssignmentExpression() &&
         parent.node.operator === "=" &&
         parent.node.right === referencePath.node &&
         parent.node.left.type === "ObjectPattern") {
-        return countUrlProperties(parent.node.left) >= 2;
+        return countUrlProperties(parent.node.left) >= 1;
     }
     return false;
 };

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

@@ -6,6 +6,36 @@ const require = createRequire(import.meta.url);
 const traverse = require("@babel/traverse").default;
 const VOID_OPERATOR = "void";
 const UNDEFINED_NAME = "undefined";
+const isWithinWithStatement = (path) => {
+    return path.findParent((parentPath) => parentPath.isWithStatement()) !== null;
+};
+const isSafeVoidArgument = (node) => {
+    if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+        return true;
+    }
+    return (node.type === "NumericLiteral" ||
+        node.type === "StringLiteral" ||
+        node.type === "BooleanLiteral" ||
+        node.type === "NullLiteral" ||
+        node.type === "BigIntLiteral" ||
+        node.type === "RegExpLiteral" ||
+        node.type === "FunctionExpression" ||
+        node.type === "ArrowFunctionExpression" ||
+        node.type === "ClassExpression");
+};
+const isSafeIdentifierVoidArgument = (path) => {
+    if (isWithinWithStatement(path))
+        return false;
+    const argument = path.node.argument;
+    if (argument.type !== "Identifier")
+        return false;
+    const binding = path.scope.getBinding(argument.name);
+    if (!binding)
+        return false;
+    return (binding.kind === "param" ||
+        binding.kind === "hoisted" ||
+        binding.kind === "var");
+};
 const hasVoidOperator = (ast) => {
     const nodesToVisit = [ast.program];
     while (nodesToVisit.length > 0) {
@@ -36,13 +66,14 @@ const hasVoidOperator = (ast) => {
 };
 export const expandUndefinedLiteralsTransform = {
     id: "expand-undefined-literals",
-    description: "Expands void 0 to undefined (when undefined is not shadowed)",
+    description: "Expands side-effect-free void expressions to undefined",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const injectedVoidZeroSentinels = new WeakSet();
             // This string precheck intentionally allows false positives for speed.
             // `hasVoidOperator` on the current AST prevents false negatives.
             if (!fileInfo.content.includes(VOID_OPERATOR) &&
@@ -55,9 +86,18 @@ export const expandUndefinedLiteralsTransform = {
                     const { operator, argument } = path.node;
                     if (operator !== VOID_OPERATOR)
                         return;
-                    if (argument.type !== "NumericLiteral")
+                    if (injectedVoidZeroSentinels.has(path.node) &&
+                        isWithinWithStatement(path))
+                        return;
+                    if (!path.get("argument").isPure()) {
+                        const voidZeroSentinel = t.unaryExpression(VOID_OPERATOR, t.numericLiteral(0), true);
+                        injectedVoidZeroSentinels.add(voidZeroSentinel);
+                        path.replaceWith(t.sequenceExpression([argument, voidZeroSentinel]));
+                        transformationsApplied++;
                         return;
-                    if (argument.value !== 0)
+                    }
+                    if (!isSafeVoidArgument(argument) &&
+                        !isSafeIdentifierVoidArgument(path))
                         return;
                     if (path.scope.hasBinding(UNDEFINED_NAME, true))
                         return;

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

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-11T07:19:35.922Z",
-            "changedLines": 12668,
-            "durationSeconds": 40.302393417,
+            "evaluatedAt": "2026-02-23T06:04:26.719Z",
+            "changedLines": 12700,
+            "durationSeconds": 63.882494208000004,
             "stableNames": 1357
         }
     },

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

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { IfStatement, Statement } from "@babel/types";
+type InterruptingBranchCheck = (statementPath: NodePath<Statement>, boundaryIfPath: NodePath<IfStatement>) => boolean;
+export declare function doesSwitchInterruptBoundary(switchPath: NodePath<Statement>, boundaryIfPath: NodePath<IfStatement>, isInterruptingBranch: InterruptingBranchCheck): boolean;
+export {};

package/dist/transforms-by-id/remove-redundant-else/does-switch-interrupt-boundary.js

@@ -0,0 +1,39 @@
+import { getGuaranteedSwitchCaseIndex } from "./get-guaranteed-switch-case-index.js";
+import { getLastNonEmptyStatementIndex } from "./get-last-non-empty-statement-index.js";
+import { hasNonInterruptingSwitchExitBeforeIndex } from "./has-non-interrupting-switch-exit.js";
+export function doesSwitchInterruptBoundary(switchPath, boundaryIfPath, isInterruptingBranch) {
+    if (!switchPath.isSwitchStatement())
+        return false;
+    const casePaths = switchPath.get("cases");
+    if (casePaths.length === 0)
+        return false;
+    const caseInterrupts = getCaseInterruptions(casePaths, boundaryIfPath, isInterruptingBranch);
+    const hasDefaultCase = casePaths.some((casePath) => casePath.node.test === null);
+    if (hasDefaultCase)
+        return caseInterrupts.every(Boolean);
+    const guaranteedCaseIndex = getGuaranteedSwitchCaseIndex(switchPath);
+    if (guaranteedCaseIndex === undefined)
+        return false;
+    return caseInterrupts[guaranteedCaseIndex] === true;
+}
+function getCaseInterruptions(casePaths, boundaryIfPath, isInterruptingBranch) {
+    const caseInterrupts = Array.from({ length: casePaths.length }).fill(false);
+    for (let index = casePaths.length - 1; index >= 0; index -= 1) {
+        const casePath = casePaths[index];
+        if (!casePath)
+            continue;
+        const consequentPaths = casePath.get("consequent");
+        const lastStatementIndex = getLastNonEmptyStatementIndex(consequentPaths);
+        if (lastStatementIndex !== undefined &&
+            isInterruptingBranch(consequentPaths[lastStatementIndex], boundaryIfPath) &&
+            !hasNonInterruptingSwitchExitBeforeIndex(consequentPaths, lastStatementIndex, boundaryIfPath, isInterruptingBranch)) {
+            caseInterrupts[index] = true;
+            continue;
+        }
+        if (caseInterrupts[index + 1] &&
+            !hasNonInterruptingSwitchExitBeforeIndex(consequentPaths, consequentPaths.length, boundaryIfPath, isInterruptingBranch)) {
+            caseInterrupts[index] = true;
+        }
+    }
+    return caseInterrupts;
+}

package/dist/transforms-by-id/remove-redundant-else/get-guaranteed-switch-case-index.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { SwitchStatement } from "@babel/types";
+export declare function getGuaranteedSwitchCaseIndex(switchPath: NodePath<SwitchStatement>): number | undefined;

package/dist/transforms-by-id/remove-redundant-else/get-guaranteed-switch-case-index.js

@@ -0,0 +1,58 @@
+export function getGuaranteedSwitchCaseIndex(switchPath) {
+    const discriminantValue = getStaticExpressionValue(switchPath.get("discriminant"));
+    if (discriminantValue === undefined)
+        return undefined;
+    const casePaths = switchPath.get("cases");
+    for (const [index, casePath] of casePaths.entries()) {
+        const testPath = casePath.get("test");
+        if (!testPath.node)
+            continue;
+        const testValue = getStaticExpressionValue(testPath);
+        if (testValue !== discriminantValue)
+            continue;
+        return index;
+    }
+    return undefined;
+}
+function getStaticExpressionValue(expressionPath) {
+    try {
+        const evaluation = expressionPath.evaluate();
+        if (evaluation.confident) {
+            if (typeof evaluation.value === "string")
+                return evaluation.value;
+            if (typeof evaluation.value === "number")
+                return evaluation.value;
+            if (typeof evaluation.value === "boolean")
+                return evaluation.value;
+        }
+    }
+    catch {
+        // Some expressions cannot be statically evaluated by Babel.
+    }
+    const expression = expressionPath.node;
+    if (expression.type === "StringLiteral")
+        return expression.value;
+    if (expression.type === "NumericLiteral")
+        return expression.value;
+    if (expression.type === "BooleanLiteral")
+        return expression.value;
+    if (expression.type === "NullLiteral")
+        return undefined;
+    if (expression.type !== "UnaryExpression")
+        return undefined;
+    if (expression.operator === "void")
+        return undefined;
+    const argumentValue = getStaticExpressionValue(expressionPath.get("argument"));
+    if (argumentValue === undefined)
+        return undefined;
+    if (expression.operator === "+" && typeof argumentValue === "number") {
+        return argumentValue;
+    }
+    if (expression.operator === "-" && typeof argumentValue === "number") {
+        return -argumentValue;
+    }
+    if (expression.operator === "!" && typeof argumentValue === "boolean") {
+        return !argumentValue;
+    }
+    return undefined;
+}

package/dist/transforms-by-id/remove-redundant-else/get-last-non-empty-statement-index.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Statement } from "@babel/types";
+export declare function getLastNonEmptyStatementIndex(statements: NodePath<Statement>[]): number | undefined;

package/dist/transforms-by-id/remove-redundant-else/get-last-non-empty-statement-index.js

@@ -0,0 +1,28 @@
+export function getLastNonEmptyStatementIndex(statements) {
+    for (let index = statements.length - 1; index >= 0; index -= 1) {
+        const statementPath = statements[index];
+        if (!statementPath?.node)
+            continue;
+        if (statementPath.isEmptyStatement())
+            continue;
+        if (isIgnorableTrailingStatement(statementPath))
+            continue;
+        return index;
+    }
+    return undefined;
+}
+function isIgnorableTrailingStatement(statementPath) {
+    if (statementPath.isVariableDeclaration())
+        return true;
+    if (statementPath.isClassDeclaration())
+        return true;
+    if (statementPath.isFunctionDeclaration())
+        return true;
+    if (statementPath.isTSDeclareFunction())
+        return true;
+    if (statementPath.isTSTypeAliasDeclaration())
+        return true;
+    if (statementPath.isTSInterfaceDeclaration())
+        return true;
+    return false;
+}

package/dist/transforms-by-id/remove-redundant-else/has-non-interrupting-switch-exit.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { IfStatement, Statement } from "@babel/types";
+type InterruptingBranchCheck = (statementPath: NodePath<Statement>, boundaryIfPath: NodePath<IfStatement>) => boolean;
+export declare function hasNonInterruptingSwitchExitBeforeIndex(statements: NodePath<Statement>[], stopIndex: number, boundaryIfPath: NodePath<IfStatement>, isInterruptingBranch: InterruptingBranchCheck): boolean;
+export {};

package/dist/transforms-by-id/remove-redundant-else/has-non-interrupting-switch-exit.js

@@ -0,0 +1,44 @@
+export function hasNonInterruptingSwitchExitBeforeIndex(statements, stopIndex, boundaryIfPath, isInterruptingBranch) {
+    for (let index = 0; index < stopIndex; index += 1) {
+        const statementPath = statements[index];
+        if (!statementPath?.node)
+            continue;
+        if (statementPath.isEmptyStatement())
+            continue;
+        if (hasPotentialNonInterruptingSwitchExit(statementPath, boundaryIfPath, isInterruptingBranch)) {
+            return true;
+        }
+        if (isInterruptingBranch(statementPath, boundaryIfPath))
+            return false;
+    }
+    return false;
+}
+function hasPotentialNonInterruptingSwitchExit(statementPath, boundaryIfPath, isInterruptingBranch) {
+    if (statementPath.isBreakStatement() || statementPath.isContinueStatement()) {
+        return !isInterruptingBranch(statementPath, boundaryIfPath);
+    }
+    if (statementPath.isIfStatement()) {
+        const consequentPath = statementPath.get("consequent");
+        if (hasPotentialNonInterruptingSwitchExit(consequentPath, boundaryIfPath, isInterruptingBranch)) {
+            return true;
+        }
+        const alternatePath = statementPath.get("alternate");
+        if (!alternatePath.node)
+            return false;
+        return hasPotentialNonInterruptingSwitchExit(alternatePath, boundaryIfPath, isInterruptingBranch);
+    }
+    if (statementPath.isLabeledStatement()) {
+        return hasPotentialNonInterruptingSwitchExit(statementPath.get("body"), boundaryIfPath, isInterruptingBranch);
+    }
+    if (statementPath.isBlockStatement()) {
+        const bodyPaths = statementPath.get("body");
+        for (const bodyPath of bodyPaths) {
+            if (hasPotentialNonInterruptingSwitchExit(bodyPath, boundaryIfPath, isInterruptingBranch)) {
+                return true;
+            }
+            if (isInterruptingBranch(bodyPath, boundaryIfPath))
+                return false;
+        }
+    }
+    return false;
+}

package/dist/transforms-by-id/remove-redundant-else/is-interrupting-branch.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { IfStatement, Statement } from "@babel/types";
+export declare function isInterruptingBranch(statementPath: NodePath<Statement>, boundaryIfPath: NodePath<IfStatement>): boolean;

package/dist/transforms-by-id/remove-redundant-else/is-interrupting-branch.js

@@ -0,0 +1,124 @@
+import { doesJumpInterruptBoundary } from "./does-jump-interrupt-boundary.js";
+import { doesSwitchInterruptBoundary } from "./does-switch-interrupt-boundary.js";
+export function isInterruptingBranch(statementPath, boundaryIfPath) {
+    if (isInterruptingStatement(statementPath, boundaryIfPath))
+        return true;
+    if (statementPath.isIfStatement()) {
+        const alternatePath = statementPath.get("alternate");
+        if (!alternatePath.node)
+            return false;
+        return (isInterruptingBranch(statementPath.get("consequent"), boundaryIfPath) &&
+            isInterruptingBranch(alternatePath, boundaryIfPath));
+    }
+    if (statementPath.isTryStatement()) {
+        const blockPath = statementPath.get("block");
+        const finalizerPath = statementPath.get("finalizer");
+        if (finalizerPath.node &&
+            isInterruptingBranch(finalizerPath, boundaryIfPath)) {
+            return true;
+        }
+        if (!isInterruptingBranch(blockPath, boundaryIfPath)) {
+            return false;
+        }
+        const handlerPath = statementPath.get("handler");
+        if (!handlerPath.node)
+            return true;
+        return isInterruptingBranch(handlerPath.get("body"), boundaryIfPath);
+    }
+    if (statementPath.isSwitchStatement()) {
+        return doesSwitchInterruptBoundary(statementPath, boundaryIfPath, isInterruptingBranch);
+    }
+    if (statementPath.isLabeledStatement()) {
+        return isInterruptingBranch(statementPath.get("body"), boundaryIfPath);
+    }
+    if (!statementPath.isBlockStatement())
+        return false;
+    const firstPath = getFirstNonEmptyStatementPath(statementPath.get("body"));
+    if (firstPath && isInterruptingBranch(firstPath, boundaryIfPath)) {
+        return true;
+    }
+    const linearInterruptingPath = getInterruptingPathAfterLinearPrefix(statementPath.get("body"), boundaryIfPath);
+    if (linearInterruptingPath)
+        return true;
+    const lastPath = getLastNonEmptyStatementPath(statementPath.get("body"));
+    if (!lastPath)
+        return false;
+    return isInterruptingBranch(lastPath, boundaryIfPath);
+}
+function isInterruptingStatement(statementPath, boundaryIfPath) {
+    if (statementPath.isReturnStatement())
+        return true;
+    if (statementPath.isThrowStatement())
+        return true;
+    if (statementPath.isBreakStatement() || statementPath.isContinueStatement()) {
+        return doesJumpInterruptBoundary(statementPath, boundaryIfPath);
+    }
+    return false;
+}
+function getLastNonEmptyStatementPath(statements) {
+    for (let index = statements.length - 1; index >= 0; index -= 1) {
+        const statementPath = statements[index];
+        if (!statementPath?.node)
+            continue;
+        if (statementPath.isEmptyStatement())
+            continue;
+        if (isIgnorableTrailingStatement(statementPath))
+            continue;
+        return statementPath;
+    }
+    return undefined;
+}
+function getFirstNonEmptyStatementPath(statements) {
+    for (const statementPath of statements) {
+        if (statementPath.isEmptyStatement())
+            continue;
+        return statementPath;
+    }
+    return undefined;
+}
+function getInterruptingPathAfterLinearPrefix(statements, boundaryIfPath) {
+    for (const statementPath of statements) {
+        if (statementPath.isEmptyStatement())
+            continue;
+        if (isInterruptingBranch(statementPath, boundaryIfPath))
+            return statementPath;
+        if (isStatementGuaranteedToContinue(statementPath))
+            continue;
+        return undefined;
+    }
+    return undefined;
+}
+function isStatementGuaranteedToContinue(statementPath) {
+    if (statementPath.isExpressionStatement())
+        return true;
+    if (statementPath.isDebuggerStatement())
+        return true;
+    if (statementPath.isVariableDeclaration())
+        return true;
+    if (statementPath.isClassDeclaration())
+        return true;
+    if (statementPath.isFunctionDeclaration())
+        return true;
+    if (statementPath.isTSDeclareFunction())
+        return true;
+    if (statementPath.isTSTypeAliasDeclaration())
+        return true;
+    if (statementPath.isTSInterfaceDeclaration())
+        return true;
+    return false;
+}
+function isIgnorableTrailingStatement(statementPath) {
+    if (statementPath.isVariableDeclaration())
+        return true;
+    if (statementPath.isClassDeclaration())
+        return true;
+    if (statementPath.isFunctionDeclaration())
+        return true;
+    if (statementPath.isTSDeclareFunction())
+        return true;
+    if (statementPath.isTSTypeAliasDeclaration())
+        return true;
+    if (statementPath.isTSInterfaceDeclaration())
+        return true;
+    return false;
+}

package/dist/transforms-by-id/remove-redundant-else/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-12T09:41:18.443Z",
-            "changedLines": 6643,
-            "durationSeconds": 44.4973085,
+            "evaluatedAt": "2026-02-23T06:47:04.680Z",
+            "changedLines": 6872,
+            "durationSeconds": 40.238378,
             "stableNames": 1357
         }
     },

package/dist/transforms-by-id/remove-redundant-else/remove-redundant-else-transform.js

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
 import { getBindingIdentifiers } from "@babel/types";
 import { getFilesToProcess, } from "../../core/types.js";
-import { doesJumpInterruptBoundary } from "./does-jump-interrupt-boundary.js";
+import { isInterruptingBranch } from "./is-interrupting-branch.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -21,7 +21,7 @@ export const removeRedundantElseTransform = {
                     if (!alternate)
                         return;
                     const interrupts = isInterruptingBranch(path.get("consequent"), path);
-                    if (!interrupts)
+                    if (!interrupts && !isRedundantElseIfChain(path.node))
                         return;
                     // Remove alternate
                     // eslint-disable-next-line unicorn/no-null
@@ -48,53 +48,65 @@ export const removeRedundantElseTransform = {
         });
     },
 };
-function isInterruptingBranch(statementPath, boundaryIfPath) {
-    if (isInterruptingStatement(statementPath, boundaryIfPath))
-        return true;
-    if (statementPath.isIfStatement()) {
-        const alternatePath = statementPath.get("alternate");
-        if (!alternatePath.node)
+function isRedundantElseIfChain(ifNode) {
+    const outerTest = getStrictIdentifierLiteralEquality(ifNode.test);
+    if (!outerTest)
+        return false;
+    const outerLiteralValue = outerTest.literalValue;
+    let alternateNode = ifNode.alternate;
+    if (!alternateNode)
+        return false;
+    for (;;) {
+        if (alternateNode.type !== "IfStatement")
             return false;
-        return (isInterruptingBranch(statementPath.get("consequent"), boundaryIfPath) &&
-            isInterruptingBranch(alternatePath, boundaryIfPath));
-    }
-    if (statementPath.isTryStatement()) {
-        const blockPath = statementPath.get("block");
-        if (!isInterruptingBranch(blockPath, boundaryIfPath)) {
+        const alternateTest = getStrictIdentifierLiteralEquality(alternateNode.test);
+        if (!alternateTest)
             return false;
-        }
-        const handlerPath = statementPath.get("handler");
-        if (!handlerPath.node)
+        if (alternateTest.identifierName !== outerTest.identifierName)
+            return false;
+        if (Object.is(alternateTest.literalValue, outerLiteralValue))
+            return false;
+        if (!alternateNode.alternate)
             return true;
-        return isInterruptingBranch(handlerPath.get("body"), boundaryIfPath);
+        alternateNode = alternateNode.alternate;
     }
-    if (!statementPath.isBlockStatement())
-        return false;
-    const lastPath = getLastNonEmptyStatementPath(statementPath.get("body"));
-    if (!lastPath)
-        return false;
-    return isInterruptingBranch(lastPath, boundaryIfPath);
 }
-function isInterruptingStatement(statementPath, boundaryIfPath) {
-    if (statementPath.isReturnStatement())
+function getStrictIdentifierLiteralEquality(testExpression) {
+    if (testExpression.type !== "BinaryExpression")
+        return undefined;
+    if (testExpression.operator !== "===")
+        return undefined;
+    const left = testExpression.left;
+    const right = testExpression.right;
+    if (left.type === "Identifier" && isLiteralExpression(right)) {
+        return {
+            identifierName: left.name,
+            literalValue: getLiteralValue(right),
+        };
+    }
+    if (right.type === "Identifier" && isLiteralExpression(left)) {
+        return {
+            identifierName: right.name,
+            literalValue: getLiteralValue(left),
+        };
+    }
+    return undefined;
+}
+function isLiteralExpression(expression) {
+    if (expression.type === "StringLiteral")
         return true;
-    if (statementPath.isThrowStatement())
+    if (expression.type === "NumericLiteral")
+        return true;
+    if (expression.type === "BooleanLiteral")
+        return true;
+    if (expression.type === "NullLiteral")
         return true;
-    if (statementPath.isBreakStatement() || statementPath.isContinueStatement()) {
-        return doesJumpInterruptBoundary(statementPath, boundaryIfPath);
-    }
     return false;
 }
-function getLastNonEmptyStatementPath(statements) {
-    for (let index = statements.length - 1; index >= 0; index -= 1) {
-        const statementPath = statements[index];
-        if (!statementPath?.node)
-            continue;
-        if (statementPath.isEmptyStatement())
-            continue;
-        return statementPath;
-    }
-    return undefined;
+function getLiteralValue(literal) {
+    if (literal.type === "NullLiteral")
+        return undefined;
+    return literal.value;
 }
 function shouldPreserveAlternateBlockScope(ifPath, alternate) {
     const lexicalNames = getTopLevelLexicalNames(alternate);

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/deferred-executor-heuristics.js

@@ -1,15 +1,9 @@
 import { isAssignedToOnHandlerProperty, isCatchRejectionHandlerArgument, isDirectCallOfBinding, isErrorEventHandlerArgument, isErrorEventHandlerRemovalArgument, isThenFulfillmentHandlerArgument, isThenRejectionHandlerArgument, } from "../rename-promise-executor-parameters-v2/promise-executor-heuristics.js";
-import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
-const isExecutorParameterEligible = (parameter) => {
-    if (!isValidBindingIdentifier(parameter.name))
-        return false;
-    return true;
-};
 export const getExecutorFunctionIfEligible = (path) => {
     // Intentionally does not require `new Promise(...)`: minified bundles often alias
     // Promise constructors, and matching `new X((a, b) => ...)` keeps this transform aligned
     // with v1/v2 promise-executor heuristics elsewhere in the codebase.
-    if (path.node.arguments.length !== 1)
+    if (path.node.arguments.length === 0)
         return;
     const executor = path.get("arguments.0");
     if (!executor.isFunctionExpression() &&
@@ -26,10 +20,6 @@ export const getExecutorFunctionIfEligible = (path) => {
         return;
     if (secondParameter.type !== "Identifier")
         return;
-    if (!isExecutorParameterEligible(firstParameter))
-        return;
-    if (!isExecutorParameterEligible(secondParameter))
-        return;
     return executor;
 };
 const isArrayElementReference = (referencePath) => {

package/dist/transforms-by-id/rename-deferred-resolve-parameters-v2/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 99.99246065403827,
-            "evaluatedAt": "2026-02-17T13:40:54.302Z",
-            "changedLines": 1682,
-            "durationSeconds": 217.667605528,
+            "evaluatedAt": "2026-02-22T17:56:04.941Z",
+            "changedLines": 1740,
+            "durationSeconds": 238.50724275000002,
             "stableNames": 1359
         }
     },