miniread 1.121.1 → 1.121.2

package/dist/presets/recommended/manifest.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 22.779415655592093,
-        "notes": "Measured with baseline none: 22.78% of original diff."
+        "diffSizePercent": 23.382280681861133,
+        "notes": "Measured with baseline none: 23.38% of original diff."
     }
 }

package/dist/transforms/shared/default-options-parameter-names/collect-default-options-parameter-names.js

@@ -25,6 +25,56 @@ const getDefaultOptionsParameterNamesFromChain = (statement, parameterNames, all
     }
     return matchedParameterName;
 };
+const isEmptyObjectLiteral = (expression) => {
+    if (!t.isObjectExpression(expression))
+        return false;
+    return expression.properties.length === 0;
+};
+const getExpressionStatementDefaultedParameterName = (statement, parameterNames) => {
+    if (!t.isExpressionStatement(statement))
+        return undefined;
+    const { expression } = statement;
+    if (t.isAssignmentExpression(expression) &&
+        (expression.operator === "||=" || expression.operator === "??=")) {
+        if (!t.isIdentifier(expression.left))
+            return undefined;
+        if (!parameterNames.has(expression.left.name))
+            return undefined;
+        if (!isEmptyObjectLiteral(expression.right))
+            return undefined;
+        return expression.left.name;
+    }
+    if (t.isAssignmentExpression(expression) &&
+        expression.operator === "=" &&
+        t.isIdentifier(expression.left) &&
+        t.isLogicalExpression(expression.right) &&
+        (expression.right.operator === "||" || expression.right.operator === "??")) {
+        const { left, right } = expression.right;
+        if (!t.isIdentifier(left, { name: expression.left.name }))
+            return undefined;
+        if (!parameterNames.has(expression.left.name))
+            return undefined;
+        if (!isEmptyObjectLiteral(right))
+            return undefined;
+        return expression.left.name;
+    }
+    if (t.isLogicalExpression(expression) &&
+        (expression.operator === "||" || expression.operator === "??")) {
+        if (!t.isIdentifier(expression.left))
+            return undefined;
+        if (!parameterNames.has(expression.left.name))
+            return undefined;
+        const right = expression.right;
+        if (!t.isAssignmentExpression(right, { operator: "=" }))
+            return undefined;
+        if (!t.isIdentifier(right.left, { name: expression.left.name }))
+            return undefined;
+        if (!isEmptyObjectLiteral(right.right))
+            return undefined;
+        return expression.left.name;
+    }
+    return undefined;
+};
 export const collectDefaultOptionsParameterNames = (path) => {
     // Intentionally includes parent scopes, so an outer `function(undefined){...}`
     // disables identifier-based undefined checks for nested functions too.
@@ -42,13 +92,24 @@ export const collectDefaultOptionsParameterNames = (path) => {
             parameterNames.add(parameter.left.name);
         }
     }
-    let sawIfStatement = false;
-    let matchedParameterName;
+    let sawDefaultingStatement = false;
+    const matchedParameterNames = new Set();
     for (const statement of body.body) {
         if (t.isExpressionStatement(statement) &&
             t.isStringLiteral(statement.expression)) {
             continue;
         }
+        if (!sawDefaultingStatement &&
+            t.isVariableDeclaration(statement) &&
+            statement.declarations.every((declarator) => t.isIdentifier(declarator.id) && declarator.init === null)) {
+            continue;
+        }
+        const expressionStatementMatch = getExpressionStatementDefaultedParameterName(statement, parameterNames);
+        if (expressionStatementMatch) {
+            sawDefaultingStatement = true;
+            matchedParameterNames.add(expressionStatementMatch);
+            continue;
+        }
         // Intentionally only match chains at the top of the function body.
         // This keeps matches deterministic and avoids deeper control-flow guesses.
         if (!t.isIfStatement(statement))
@@ -56,17 +117,12 @@ export const collectDefaultOptionsParameterNames = (path) => {
         const chainMatch = getDefaultOptionsParameterNamesFromChain(statement, parameterNames, allowUndefinedCheck);
         if (!chainMatch)
             break;
-        sawIfStatement = true;
-        if (!matchedParameterName) {
-            matchedParameterName = chainMatch;
-            continue;
-        }
-        if (matchedParameterName !== chainMatch)
-            return [];
+        sawDefaultingStatement = true;
+        matchedParameterNames.add(chainMatch);
     }
-    if (!sawIfStatement)
+    if (!sawDefaultingStatement)
         return [];
-    if (!matchedParameterName)
+    if (matchedParameterNames.size === 0)
         return [];
-    return [matchedParameterName];
+    return [...matchedParameterNames];
 };

package/dist/transforms/shared/default-options-parameter-names/get-defaulted-parameter-name.js

@@ -30,6 +30,24 @@ const getVoidZeroCheckedParameterName = (test) => {
     }
     return undefined;
 };
+const getNullishCheckedParameterName = (test) => {
+    if (!t.isBinaryExpression(test, { operator: "==" }))
+        return undefined;
+    const { left, right } = test;
+    if (t.isIdentifier(left) && t.isNullLiteral(right)) {
+        return left.name;
+    }
+    if (t.isNullLiteral(left) && t.isIdentifier(right)) {
+        return right.name;
+    }
+    if (t.isIdentifier(left) && isCanonicalUndefinedLiteral(right)) {
+        return left.name;
+    }
+    if (isCanonicalUndefinedLiteral(left) && t.isIdentifier(right)) {
+        return right.name;
+    }
+    return undefined;
+};
 const getFalsyCheckedParameterName = (test) => {
     if (!t.isUnaryExpression(test, { operator: "!" }))
         return undefined;
@@ -95,6 +113,15 @@ export const getDefaultedParameterName = (statement, parameterNames, options) =>
         }
         return voidZeroCheckedName;
     }
+    const nullishCheckedName = getNullishCheckedParameterName(statement.test);
+    if (nullishCheckedName) {
+        if (!parameterNames.has(nullishCheckedName))
+            return undefined;
+        if (!hasEmptyObjectAssignment(statement.consequent, nullishCheckedName)) {
+            return undefined;
+        }
+        return nullishCheckedName;
+    }
     const falsyCheckedName = getFalsyCheckedParameterName(statement.test);
     if (falsyCheckedName) {
         if (!parameterNames.has(falsyCheckedName))

package/dist/transforms-by-id/rename-arguments-length-flags/has-shadowed-arguments-binding.js

@@ -1,8 +1,11 @@
 export const hasShadowedArgumentsBinding = (path) => {
     const functionScope = path.scope.getFunctionParent();
-    if (!functionScope)
-        return false;
     const argumentsBinding = path.scope.getBinding("arguments");
+    if (!functionScope) {
+        if (!argumentsBinding)
+            return false;
+        return argumentsBinding.scope.path.isProgram();
+    }
     if (!argumentsBinding)
         return false;
     if (functionScope.path.isArrowFunctionExpression()) {

package/dist/transforms-by-id/rename-arguments-length-flags/manifest.json

@@ -3,10 +3,10 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-22T05:46:09.337Z",
-            "changedLines": 42,
-            "durationSeconds": 37.382712167,
-            "stableNames": 1360
+            "evaluatedAt": "2026-02-28T11:36:51.668Z",
+            "changedLines": 258,
+            "durationSeconds": 102.80917774999999,
+            "stableNames": 1363
         }
     },
     "recommended": true,

package/dist/transforms-by-id/rename-arguments-length-flags/rename-arguments-length-flags-transform.js

@@ -1,12 +1,76 @@
 import { createRequire } from "node:module";
+import { VISITOR_KEYS, isNode, isPrivateName, isFunction, } from "@babel/types";
 import { RenameGroup, isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 import { getArgumentsLengthBaseName } from "./get-arguments-length-base-name.js";
 import { getArgumentsLengthMatch } from "./get-arguments-length-match.js";
 import { hasShadowedArgumentsBinding } from "./has-shadowed-arguments-binding.js";
+import { getExpression, isArgumentsLengthExpression, } from "./arguments-length-expression.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const getArgumentsLengthOffsetBaseName = (init) => {
+    const left = getExpression(init.left);
+    const right = getExpression(init.right);
+    if (!left || !right)
+        return undefined;
+    if (!isArgumentsLengthExpression(left))
+        return undefined;
+    if (right.type !== "NumericLiteral")
+        return undefined;
+    if (!Number.isInteger(right.value))
+        return undefined;
+    if (init.operator === "-") {
+        if (right.value < 1)
+            return undefined;
+        return `argCountMinus${right.value}`;
+    }
+    if (init.operator === "+") {
+        if (right.value < 1)
+            return undefined;
+        return `argCountPlus${right.value}`;
+    }
+    return undefined;
+};
+const hasArgumentsLengthReference = (expression) => {
+    const stack = [expression];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        if (isArgumentsLengthExpression(current))
+            return true;
+        if (isFunction(current))
+            continue;
+        const visitorKeys = VISITOR_KEYS[current.type];
+        if (!visitorKeys)
+            continue;
+        for (const key of visitorKeys) {
+            const value = current[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (!isNode(child))
+                        continue;
+                    if (!isExpression(child))
+                        continue;
+                    stack.push(child);
+                }
+                continue;
+            }
+            if (!isNode(value) || isPrivateName(value))
+                continue;
+            if (!isExpression(value))
+                continue;
+            stack.push(value);
+        }
+    }
+    return false;
+};
+const isExpression = (value) => {
+    if (!isNode(value))
+        return false;
+    return !isPrivateName(value);
+};
 export const renameArgumentsLengthFlagsTransform = {
     id: "rename-arguments-length-flags",
     description: "Rename arguments.length guards (>= N, < N) to $hasAtLeastNArgs/$hasFewerThanNArgs when stable",
@@ -28,18 +92,47 @@ export const renameArgumentsLengthFlagsTransform = {
                     const init = path.node.init;
                     if (!init)
                         return;
-                    if (hasShadowedArgumentsBinding(path))
+                    if (!isExpression(init))
                         return;
-                    const match = getArgumentsLengthMatch(init);
-                    if (!match || match.condition.count < 1)
+                    if (hasShadowedArgumentsBinding(path))
                         return;
                     const binding = path.scope.getBinding(id.name);
                     if (!binding?.constant)
                         return;
+                    if (isArgumentsLengthExpression(init)) {
+                        renameGroup.add({
+                            scope: binding.scope,
+                            currentName: id.name,
+                            baseName: "argCount",
+                        });
+                        return;
+                    }
+                    if (init.type === "BinaryExpression") {
+                        const offsetBaseName = getArgumentsLengthOffsetBaseName(init);
+                        if (offsetBaseName) {
+                            renameGroup.add({
+                                scope: binding.scope,
+                                currentName: id.name,
+                                baseName: offsetBaseName,
+                            });
+                            return;
+                        }
+                    }
+                    const match = getArgumentsLengthMatch(init);
+                    if (match && match.condition.count >= 1) {
+                        renameGroup.add({
+                            scope: binding.scope,
+                            currentName: id.name,
+                            baseName: getArgumentsLengthBaseName(match),
+                        });
+                        return;
+                    }
+                    if (!hasArgumentsLengthReference(init))
+                        return;
                     renameGroup.add({
                         scope: binding.scope,
                         currentName: id.name,
-                        baseName: getArgumentsLengthBaseName(match),
+                        baseName: "argLengthValue",
                     });
                 },
             });

package/dist/transforms-by-id/rename-asap-wrappers/get-asap-wrapper-details.d.ts

@@ -1,5 +1,5 @@
-import type { ArrowFunctionExpression, FunctionExpression } from "@babel/types";
-export declare const getAsapWrapperDetails: (init: ArrowFunctionExpression | FunctionExpression) => {
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+export declare const getAsapWrapperDetails: (init: ArrowFunctionExpression | FunctionExpression | FunctionDeclaration) => {
     outerParameterName: string;
     innerParameterName: string | undefined;
 } | undefined;

package/dist/transforms-by-id/rename-asap-wrappers/get-asap-wrapper-details.js

@@ -1,19 +1,7 @@
+import { getDirectScheduledCallbackName } from "./get-direct-scheduled-callback-name.js";
 import { getForwardedArgumentsIdentifier } from "./get-forwarded-arguments-identifier.js";
 import { hasExactlyOneLexicalReturnStatement } from "./has-exactly-one-lexical-return-statement.js";
-const SCHEDULER_METHOD_NAMES = new Set(["asap", "nextTick", "queueMicrotask"]);
-const isAsapCallee = (call) => {
-    const callee = call.callee;
-    if (callee.type === "Identifier") {
-        return SCHEDULER_METHOD_NAMES.has(callee.name);
-    }
-    if (callee.type === "MemberExpression") {
-        if (callee.computed)
-            return false;
-        return (callee.property.type === "Identifier" &&
-            SCHEDULER_METHOD_NAMES.has(callee.property.name));
-    }
-    return false;
-};
+import { isAsapCallee } from "./is-asap-callee.js";
 const getIdentifierName = (node) => {
     if (node.type === "Identifier")
         return node.name;
@@ -81,11 +69,22 @@ const getInnerParameterName = (inner) => {
     return getIdentifierName(innerParameter);
 };
 export const getAsapWrapperDetails = (init) => {
-    if (init.params.length !== 1)
+    if (init.params.length === 0)
         return undefined;
     const outerParameter = init.params[0];
     if (outerParameter?.type !== "Identifier")
         return undefined;
+    if (init.body.type === "BlockStatement") {
+        const directScheduledCallbackName = getDirectScheduledCallbackName(init.body);
+        if (directScheduledCallbackName) {
+            if (directScheduledCallbackName !== outerParameter.name)
+                return undefined;
+            return {
+                outerParameterName: outerParameter.name,
+                innerParameterName: undefined,
+            };
+        }
+    }
     const inner = getInnerWrapperFunction(init);
     if (!inner)
         return undefined;
@@ -100,8 +99,20 @@ export const getAsapWrapperDetails = (init) => {
     if (innerCallExpression.arguments.length === 0)
         return undefined;
     const callback = innerCallExpression.arguments[0];
-    if (callback?.type !== "ArrowFunctionExpression" &&
-        callback?.type !== "FunctionExpression") {
+    if (!callback)
+        return undefined;
+    if (callback.type === "Identifier") {
+        if (callback.name !== outerParameter.name)
+            return undefined;
+        if (inner.params.length > 0)
+            return undefined;
+        return {
+            outerParameterName: outerParameter.name,
+            innerParameterName,
+        };
+    }
+    if (callback.type !== "ArrowFunctionExpression" &&
+        callback.type !== "FunctionExpression") {
         return undefined;
     }
     if (callback.params.length > 0)
@@ -109,21 +120,15 @@ export const getAsapWrapperDetails = (init) => {
     const callbackCallExpression = getFunctionCallExpression(callback);
     if (!callbackCallExpression)
         return undefined;
-    const forwardedArgumentsName = getForwardedArgumentsIdentifier(callbackCallExpression, outerParameter.name);
-    if (!forwardedArgumentsName)
-        return undefined;
-    if (innerParameterName) {
-        if (forwardedArgumentsName !== innerParameterName)
-            return undefined;
-    }
-    else {
-        if (forwardedArgumentsName !== "arguments")
-            return undefined;
+    if (innerParameterName === undefined) {
         if (callback.type !== "ArrowFunctionExpression")
             return undefined;
         if (inner.type !== "FunctionExpression")
             return undefined;
     }
+    const forwardedArgumentsName = getForwardedArgumentsIdentifier(callbackCallExpression, outerParameter.name);
+    if (!forwardedArgumentsName)
+        return undefined;
     return {
         outerParameterName: outerParameter.name,
         innerParameterName,

package/dist/transforms-by-id/rename-asap-wrappers/get-direct-scheduled-callback-name.d.ts

@@ -0,0 +1,2 @@
+import type { BlockStatement } from "@babel/types";
+export declare const getDirectScheduledCallbackName: (body: BlockStatement) => string | undefined;

package/dist/transforms-by-id/rename-asap-wrappers/get-direct-scheduled-callback-name.js

@@ -0,0 +1,62 @@
+const getStatementCallExpression = (statement) => {
+    if (statement.type === "ExpressionStatement" &&
+        statement.expression.type === "CallExpression") {
+        return statement.expression;
+    }
+    if (statement.type === "ReturnStatement") {
+        if (statement.argument?.type !== "CallExpression")
+            return undefined;
+        return statement.argument;
+    }
+    if (statement.type === "BlockStatement") {
+        const firstStatement = statement.body[0];
+        if (!firstStatement || statement.body.length !== 1)
+            return undefined;
+        return getStatementCallExpression(firstStatement);
+    }
+    return undefined;
+};
+export const getDirectScheduledCallbackName = (body) => {
+    const maybeIf = body.body.at(-1);
+    if (!maybeIf)
+        return undefined;
+    if (maybeIf.type !== "IfStatement")
+        return undefined;
+    if (!maybeIf.alternate)
+        return undefined;
+    if (maybeIf.test.type !== "Identifier")
+        return undefined;
+    const schedulerName = maybeIf.test.name;
+    const schedulerCall = getStatementCallExpression(maybeIf.consequent);
+    if (!schedulerCall)
+        return undefined;
+    if (schedulerCall.callee.type !== "Identifier")
+        return undefined;
+    if (schedulerCall.callee.name !== schedulerName)
+        return undefined;
+    const schedulerCallback = schedulerCall.arguments[0];
+    if (schedulerCall.arguments.length !== 1)
+        return undefined;
+    if (schedulerCallback?.type !== "Identifier")
+        return undefined;
+    const fallbackCall = getStatementCallExpression(maybeIf.alternate);
+    if (!fallbackCall)
+        return undefined;
+    if (fallbackCall.callee.type !== "Identifier")
+        return undefined;
+    if (fallbackCall.callee.name !== "setTimeout")
+        return undefined;
+    if (fallbackCall.arguments.length !== 2)
+        return undefined;
+    const fallbackCallback = fallbackCall.arguments[0];
+    const fallbackDelay = fallbackCall.arguments[1];
+    if (fallbackCallback?.type !== "Identifier")
+        return undefined;
+    if (fallbackCallback.name !== schedulerCallback.name)
+        return undefined;
+    if (fallbackDelay?.type !== "NumericLiteral")
+        return undefined;
+    if (fallbackDelay.value !== 0)
+        return undefined;
+    return schedulerCallback.name;
+};

package/dist/transforms-by-id/rename-asap-wrappers/get-forwarded-arguments-identifier.js

@@ -3,14 +3,13 @@ export const getForwardedArgumentsIdentifier = (callbackCallExpression, outerPar
     if (callee.type === "Identifier") {
         if (callee.name !== outerParameterName)
             return undefined;
-        if (callbackCallExpression.arguments.length !== 1)
-            return undefined;
-        const spreadArgument = callbackCallExpression.arguments[0];
-        if (spreadArgument?.type !== "SpreadElement")
-            return undefined;
-        if (spreadArgument.argument.type !== "Identifier")
-            return undefined;
-        return spreadArgument.argument.name;
+        const firstArgument = callbackCallExpression.arguments[0];
+        if (callbackCallExpression.arguments.length === 1 &&
+            firstArgument?.type === "SpreadElement" &&
+            firstArgument.argument.type === "Identifier") {
+            return firstArgument.argument.name;
+        }
+        return "$invoked";
     }
     if (callee.type !== "MemberExpression" ||
         callee.computed ||
@@ -21,21 +20,22 @@ export const getForwardedArgumentsIdentifier = (callbackCallExpression, outerPar
     }
     if (callee.property.name === "apply") {
         if (callbackCallExpression.arguments.length !== 2)
-            return undefined;
-        const spreadArgument = callbackCallExpression.arguments[1];
-        if (spreadArgument?.type !== "Identifier")
-            return undefined;
-        return spreadArgument.name;
+            return "$invoked";
+        const argumentsValue = callbackCallExpression.arguments[1];
+        if (argumentsValue?.type === "Identifier") {
+            return argumentsValue.name;
+        }
+        return "$invoked";
     }
     if (callee.property.name === "call") {
         if (callbackCallExpression.arguments.length !== 2)
-            return undefined;
+            return "$invoked";
         const spreadArgument = callbackCallExpression.arguments[1];
-        if (spreadArgument?.type !== "SpreadElement")
-            return undefined;
-        if (spreadArgument.argument.type !== "Identifier")
-            return undefined;
-        return spreadArgument.argument.name;
+        if (spreadArgument?.type === "SpreadElement" &&
+            spreadArgument.argument.type === "Identifier") {
+            return spreadArgument.argument.name;
+        }
+        return "$invoked";
     }
     return undefined;
 };

package/dist/transforms-by-id/rename-asap-wrappers/is-asap-callee.d.ts

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

package/dist/transforms-by-id/rename-asap-wrappers/is-asap-callee.js

@@ -0,0 +1,26 @@
+const SCHEDULER_METHOD_NAMES = new Set([
+    "asap",
+    "nextTick",
+    "queueMicrotask",
+    "setImmediate",
+]);
+export const isAsapCallee = (call) => {
+    const callee = call.callee;
+    if (callee.type === "Identifier") {
+        return SCHEDULER_METHOD_NAMES.has(callee.name);
+    }
+    if (callee.type === "MemberExpression") {
+        if (!callee.computed &&
+            callee.property.type === "Identifier" &&
+            SCHEDULER_METHOD_NAMES.has(callee.property.name)) {
+            return true;
+        }
+        if (callee.computed &&
+            callee.property.type === "StringLiteral" &&
+            SCHEDULER_METHOD_NAMES.has(callee.property.value)) {
+            return true;
+        }
+        return false;
+    }
+    return false;
+};

package/dist/transforms-by-id/rename-asap-wrappers/manifest.json

@@ -2,10 +2,10 @@
     "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.99811014098348,
-            "evaluatedAt": "2026-02-22T15:48:34.214Z",
-            "changedLines": 10,
-            "durationSeconds": 31.124323875,
+            "diffSizePercent": 99.99433042295045,
+            "evaluatedAt": "2026-02-28T11:41:18.249Z",
+            "changedLines": 14,
+            "durationSeconds": 39.792677125000004,
             "stableNames": 1358
         }
     },