miniread 1.118.0 → 1.119.0

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 26.024303586952414,
-        "notes": "Measured with baseline none: 26.02% of original diff."
+        "diffSizePercent": 26.01296443285331,
+        "notes": "Measured with baseline none: 26.01% of original diff."
     }
 }

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

@@ -21,7 +21,14 @@ export const expandTypeofUndefinedComparisonsTransform = {
                     nodesVisited++;
                     const strictEquality = getStrictTypeofEquality(path.node);
                     if (strictEquality) {
-                        const replacement = t.binaryExpression(strictEquality.operator, t.cloneNode(strictEquality.typeofExpression, true), t.cloneNode(strictEquality.literal, true));
+                        const directTarget = strictEquality.literal.value === "undefined"
+                            ? getDirectUndefinedComparisonTarget(path, strictEquality.typeofExpression)
+                            : undefined;
+                        const replacement = t.binaryExpression(strictEquality.operator, directTarget
+                            ? t.cloneNode(directTarget, true)
+                            : t.cloneNode(strictEquality.typeofExpression, true), directTarget
+                            ? getUndefinedExpression(path)
+                            : t.cloneNode(strictEquality.literal, true));
                         path.replaceWith(replacement);
                         transformationsApplied++;
                         return;

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Improves readability by expanding minified typeof comparisons; expected to be diff-neutral.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-09T07:16:31.721Z",
+            "evaluatedAt": "2026-02-22T07:02:45.911Z",
             "changedLines": 1388,
-            "durationSeconds": 37.124273,
+            "durationSeconds": 187.91025176099998,
             "stableNames": 1357
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

package/dist/transforms-by-id/expand-typeof-undefined-comparisons/resolve-typeof-equality.js

@@ -7,15 +7,25 @@ const isTypeofExpression = (expression) => isExpression(expression) &&
 const getStringLiteral = (expression) => {
     if (!isExpression(expression))
         return undefined;
-    if (!t.isStringLiteral(expression))
-        return undefined;
-    return expression;
+    if (t.isStringLiteral(expression))
+        return expression;
+    if (t.isTemplateLiteral(expression) &&
+        expression.expressions.length === 0 &&
+        expression.quasis.length === 1) {
+        return t.stringLiteral(expression.quasis[0]?.value.cooked ?? "");
+    }
+    return undefined;
 };
 export const getStrictTypeofEquality = (expression) => {
-    if (expression.operator !== "==" && expression.operator !== "!=") {
+    if (expression.operator !== "==" &&
+        expression.operator !== "!=" &&
+        expression.operator !== "===" &&
+        expression.operator !== "!==") {
         return undefined;
     }
-    const operator = expression.operator === "==" ? "===" : "!==";
+    const operator = expression.operator === "==" || expression.operator === "==="
+        ? "==="
+        : "!==";
     const leftTypeof = isTypeofExpression(expression.left)
         ? expression.left
         : undefined;
@@ -25,6 +35,9 @@ export const getStrictTypeofEquality = (expression) => {
     const leftLiteral = getStringLiteral(expression.left);
     const rightLiteral = getStringLiteral(expression.right);
     if (leftTypeof && rightLiteral) {
+        if (expression.operator === "===" || expression.operator === "!==") {
+            return undefined;
+        }
         return {
             typeofExpression: leftTypeof,
             operator,

package/dist/transforms-by-id/expand-typeof-undefined-comparisons/resolve-typeof-undefined-comparison.js

@@ -7,10 +7,17 @@ const isTypeofExpression = (expression) => isExpression(expression) &&
 const getTypeofLiteralValue = (expression) => {
     if (!isExpression(expression))
         return undefined;
-    if (!t.isStringLiteral(expression))
+    const literalValue = t.isStringLiteral(expression)
+        ? expression.value
+        : t.isTemplateLiteral(expression) &&
+            expression.expressions.length === 0 &&
+            expression.quasis.length === 1
+            ? expression.quasis[0]?.value.cooked
+            : undefined;
+    if (!literalValue)
         return undefined;
-    if (expression.value === "u" || expression.value === "undefined") {
-        return expression.value;
+    if (literalValue === "u" || literalValue === "undefined") {
+        return literalValue;
     }
     return undefined;
 };

package/dist/transforms-by-id/rename-arguments-length-flags/arguments-length-condition-types.d.ts

@@ -0,0 +1,17 @@
+export type ArgumentsLengthCondition = {
+    kind: "atLeast";
+    count: number;
+} | {
+    kind: "fewerThan";
+    count: number;
+} | {
+    kind: "exactly";
+    count: number;
+} | {
+    kind: "notExactly";
+    count: number;
+};
+export type ArgumentsLengthMatch = {
+    condition: ArgumentsLengthCondition;
+    hasAdditionalCondition: boolean;
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/transforms-by-id/rename-arguments-length-flags/arguments-length-expression.d.ts

@@ -0,0 +1,4 @@
+import type { Expression, PrivateName } from "@babel/types";
+export declare const isArgumentsLengthExpression: (expression: Expression) => boolean;
+export declare const getExpression: (node: Expression | PrivateName) => Expression | undefined;
+export declare const getNumericLiteralValue: (node: Expression) => number | undefined;

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

@@ -0,0 +1,26 @@
+import { isIdentifier, isMemberExpression, isNumericLiteral, isPrivateName, isStringLiteral, } from "@babel/types";
+export const isArgumentsLengthExpression = (expression) => {
+    if (!isMemberExpression(expression))
+        return false;
+    if (!isIdentifier(expression.object))
+        return false;
+    if (expression.object.name !== "arguments")
+        return false;
+    if (expression.computed) {
+        return (isStringLiteral(expression.property) &&
+            expression.property.value === "length");
+    }
+    return (isIdentifier(expression.property) && expression.property.name === "length");
+};
+export const getExpression = (node) => {
+    if (isPrivateName(node))
+        return undefined;
+    return node;
+};
+export const getNumericLiteralValue = (node) => {
+    if (!isNumericLiteral(node))
+        return undefined;
+    if (!Number.isInteger(node.value))
+        return undefined;
+    return node.value;
+};

package/dist/transforms-by-id/rename-arguments-length-flags/get-arguments-length-base-name.d.ts

@@ -0,0 +1,2 @@
+import type { ArgumentsLengthMatch } from "./arguments-length-condition-types.js";
+export declare const getArgumentsLengthBaseName: (match: ArgumentsLengthMatch) => string;

package/dist/transforms-by-id/rename-arguments-length-flags/get-arguments-length-base-name.js

@@ -0,0 +1,33 @@
+export const getArgumentsLengthBaseName = (match) => {
+    const { condition } = match;
+    if (condition.kind === "fewerThan") {
+        const base = condition.count === 1
+            ? "hasNoArgs"
+            : `hasFewerThan${condition.count}Args`;
+        if (!match.hasAdditionalCondition)
+            return base;
+        return `${base}AndCondition`;
+    }
+    if (condition.kind === "exactly") {
+        const base = condition.count === 1
+            ? "hasExactly1Arg"
+            : `hasExactly${condition.count}Args`;
+        if (!match.hasAdditionalCondition)
+            return base;
+        return `${base}AndCondition`;
+    }
+    if (condition.kind === "notExactly") {
+        const base = condition.count === 1
+            ? "doesNotHaveExactly1Arg"
+            : `doesNotHaveExactly${condition.count}Args`;
+        if (!match.hasAdditionalCondition)
+            return base;
+        return `${base}AndCondition`;
+    }
+    const base = condition.count === 1
+        ? "hasAtLeast1Arg"
+        : `hasAtLeast${condition.count}Args`;
+    if (!match.hasAdditionalCondition)
+        return base;
+    return `${base}AndCondition`;
+};

package/dist/transforms-by-id/rename-arguments-length-flags/get-arguments-length-condition-from-binary.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryExpression } from "@babel/types";
+import type { ArgumentsLengthMatch } from "./arguments-length-condition-types.js";
+export declare const getArgumentsLengthConditionFromBinary: (init: BinaryExpression) => ArgumentsLengthMatch | undefined;

package/dist/transforms-by-id/rename-arguments-length-flags/get-arguments-length-condition-from-binary.js

@@ -0,0 +1,124 @@
+import { getExpression, getNumericLiteralValue, isArgumentsLengthExpression, } from "./arguments-length-expression.js";
+export const getArgumentsLengthConditionFromBinary = (init) => {
+    const left = getExpression(init.left);
+    const right = getExpression(init.right);
+    if (!left || !right)
+        return undefined;
+    if (init.operator === ">" || init.operator === ">=") {
+        if (isArgumentsLengthExpression(left)) {
+            const value = getNumericLiteralValue(right);
+            if (value === undefined)
+                return undefined;
+            return {
+                condition: {
+                    kind: "atLeast",
+                    count: init.operator === ">" ? value + 1 : value,
+                },
+                hasAdditionalCondition: false,
+            };
+        }
+        if (isArgumentsLengthExpression(right)) {
+            const value = getNumericLiteralValue(left);
+            if (value === undefined)
+                return undefined;
+            return {
+                condition: {
+                    kind: "fewerThan",
+                    count: init.operator === ">" ? value : value + 1,
+                },
+                hasAdditionalCondition: false,
+            };
+        }
+    }
+    if (init.operator === "<" || init.operator === "<=") {
+        if (isArgumentsLengthExpression(left)) {
+            const value = getNumericLiteralValue(right);
+            if (value === undefined)
+                return undefined;
+            return {
+                condition: {
+                    kind: "fewerThan",
+                    count: init.operator === "<" ? value : value + 1,
+                },
+                hasAdditionalCondition: false,
+            };
+        }
+        if (isArgumentsLengthExpression(right)) {
+            const value = getNumericLiteralValue(left);
+            if (value === undefined)
+                return undefined;
+            return {
+                condition: {
+                    kind: "atLeast",
+                    count: init.operator === "<" ? value + 1 : value,
+                },
+                hasAdditionalCondition: false,
+            };
+        }
+    }
+    if (init.operator === "!=" || init.operator === "!==") {
+        if (isArgumentsLengthExpression(left)) {
+            const value = getNumericLiteralValue(right);
+            if (value === undefined || value < 0)
+                return undefined;
+            if (value === 0) {
+                return {
+                    condition: { kind: "atLeast", count: 1 },
+                    hasAdditionalCondition: false,
+                };
+            }
+            return {
+                condition: { kind: "notExactly", count: value },
+                hasAdditionalCondition: false,
+            };
+        }
+        if (isArgumentsLengthExpression(right)) {
+            const value = getNumericLiteralValue(left);
+            if (value === undefined || value < 0)
+                return undefined;
+            if (value === 0) {
+                return {
+                    condition: { kind: "atLeast", count: 1 },
+                    hasAdditionalCondition: false,
+                };
+            }
+            return {
+                condition: { kind: "notExactly", count: value },
+                hasAdditionalCondition: false,
+            };
+        }
+    }
+    if (init.operator === "==" || init.operator === "===") {
+        if (isArgumentsLengthExpression(left)) {
+            const value = getNumericLiteralValue(right);
+            if (value === undefined || value < 0)
+                return undefined;
+            if (value === 0) {
+                return {
+                    condition: { kind: "fewerThan", count: 1 },
+                    hasAdditionalCondition: false,
+                };
+            }
+            return {
+                condition: { kind: "exactly", count: value },
+                hasAdditionalCondition: false,
+            };
+        }
+        if (isArgumentsLengthExpression(right)) {
+            const value = getNumericLiteralValue(left);
+            if (value === undefined || value < 0)
+                return undefined;
+            if (value === 0) {
+                return {
+                    condition: { kind: "fewerThan", count: 1 },
+                    hasAdditionalCondition: false,
+                };
+            }
+            return {
+                condition: { kind: "exactly", count: value },
+                hasAdditionalCondition: false,
+            };
+        }
+    }
+    return undefined;
+};

package/dist/transforms-by-id/rename-arguments-length-flags/get-arguments-length-match.d.ts

@@ -0,0 +1,3 @@
+import type { Expression } from "@babel/types";
+import type { ArgumentsLengthMatch } from "./arguments-length-condition-types.js";
+export declare const getArgumentsLengthMatch: (init: Expression) => ArgumentsLengthMatch | undefined;

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

@@ -0,0 +1,41 @@
+import { isUnaryExpression } from "@babel/types";
+import { isArgumentsLengthExpression } from "./arguments-length-expression.js";
+import { getArgumentsLengthConditionFromBinary } from "./get-arguments-length-condition-from-binary.js";
+export const getArgumentsLengthMatch = (init) => {
+    if (init.type === "LogicalExpression" && init.operator === "&&") {
+        const leftMatch = getArgumentsLengthMatch(init.left);
+        if (leftMatch) {
+            return {
+                condition: leftMatch.condition,
+                hasAdditionalCondition: true,
+            };
+        }
+        const rightMatch = getArgumentsLengthMatch(init.right);
+        if (!rightMatch)
+            return undefined;
+        return {
+            condition: rightMatch.condition,
+            hasAdditionalCondition: true,
+        };
+    }
+    if (isUnaryExpression(init) && init.operator === "!") {
+        if (isArgumentsLengthExpression(init.argument)) {
+            return {
+                condition: { kind: "fewerThan", count: 1 },
+                hasAdditionalCondition: false,
+            };
+        }
+        if (isUnaryExpression(init.argument) &&
+            init.argument.operator === "!" &&
+            isArgumentsLengthExpression(init.argument.argument)) {
+            return {
+                condition: { kind: "atLeast", count: 1 },
+                hasAdditionalCondition: false,
+            };
+        }
+        return undefined;
+    }
+    if (init.type !== "BinaryExpression")
+        return undefined;
+    return getArgumentsLengthConditionFromBinary(init);
+};

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-09T07:29:29.102Z",
-            "changedLines": 32,
-            "durationSeconds": 34.273026958,
+            "evaluatedAt": "2026-02-22T05:46:09.337Z",
+            "changedLines": 42,
+            "durationSeconds": 37.382712167,
             "stableNames": 1360
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

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

@@ -1,93 +1,12 @@
 import { createRequire } from "node:module";
-import { isIdentifier, isMemberExpression, isNumericLiteral, isPrivateName, isStringLiteral, } 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";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
-const isArgumentsLengthExpression = (expression) => {
-    if (!isMemberExpression(expression))
-        return false;
-    if (!isIdentifier(expression.object))
-        return false;
-    if (expression.object.name !== "arguments")
-        return false;
-    if (expression.computed) {
-        return (isStringLiteral(expression.property) &&
-            expression.property.value === "length");
-    }
-    return (isIdentifier(expression.property) && expression.property.name === "length");
-};
-const getExpression = (node) => {
-    if (isPrivateName(node))
-        return undefined;
-    return node;
-};
-const getNumericLiteralValue = (node) => {
-    if (!isNumericLiteral(node))
-        return undefined;
-    if (!Number.isInteger(node.value))
-        return undefined;
-    return node.value;
-};
-const getArgumentsLengthCondition = (init) => {
-    const left = getExpression(init.left);
-    const right = getExpression(init.right);
-    if (!left || !right)
-        return undefined;
-    if (init.operator === ">" || init.operator === ">=") {
-        if (isArgumentsLengthExpression(left)) {
-            const value = getNumericLiteralValue(right);
-            if (value === undefined)
-                return undefined;
-            return {
-                kind: "atLeast",
-                count: init.operator === ">" ? value + 1 : value,
-            };
-        }
-        if (isArgumentsLengthExpression(right)) {
-            const value = getNumericLiteralValue(left);
-            if (value === undefined)
-                return undefined;
-            return {
-                kind: "fewerThan",
-                count: init.operator === ">" ? value : value + 1,
-            };
-        }
-    }
-    if (init.operator === "<" || init.operator === "<=") {
-        if (isArgumentsLengthExpression(left)) {
-            const value = getNumericLiteralValue(right);
-            if (value === undefined)
-                return undefined;
-            return {
-                kind: "fewerThan",
-                count: init.operator === "<" ? value : value + 1,
-            };
-        }
-        if (isArgumentsLengthExpression(right)) {
-            const value = getNumericLiteralValue(left);
-            if (value === undefined)
-                return undefined;
-            return {
-                kind: "atLeast",
-                count: init.operator === "<" ? value + 1 : value,
-            };
-        }
-    }
-    return undefined;
-};
-const getBaseName = (condition) => {
-    if (condition.kind === "fewerThan") {
-        if (condition.count === 1)
-            return "hasNoArgs";
-        return `hasFewerThan${condition.count}Args`;
-    }
-    if (condition.count === 1)
-        return "hasAtLeast1Arg";
-    return `hasAtLeast${condition.count}Args`;
-};
 export const renameArgumentsLengthFlagsTransform = {
     id: "rename-arguments-length-flags",
     description: "Rename arguments.length guards (>= N, < N) to $hasAtLeastNArgs/$hasFewerThanNArgs when stable",
@@ -107,12 +26,12 @@ export const renameArgumentsLengthFlagsTransform = {
                     if (isStableRenamed(id.name))
                         return;
                     const init = path.node.init;
-                    if (init?.type !== "BinaryExpression")
+                    if (!init)
                         return;
                     if (hasShadowedArgumentsBinding(path))
                         return;
-                    const condition = getArgumentsLengthCondition(init);
-                    if (!condition || condition.count < 1)
+                    const match = getArgumentsLengthMatch(init);
+                    if (!match || match.condition.count < 1)
                         return;
                     const binding = path.scope.getBinding(id.name);
                     if (!binding?.constant)
@@ -120,7 +39,7 @@ export const renameArgumentsLengthFlagsTransform = {
                     renameGroup.add({
                         scope: binding.scope,
                         currentName: id.name,
-                        baseName: getBaseName(condition),
+                        baseName: getArgumentsLengthBaseName(match),
                     });
                 },
             });

package/dist/transforms-by-id/rename-awaiter-parameters/awaiter-pattern.js

@@ -5,6 +5,13 @@ const isIdentifierParameters = (parameters) => {
     return parameters.every((parameter) => parameter.type === "Identifier");
 };
 const isIdentifierNamed = (node, name) => isIdentifier(node) && node.name === name;
+const isStringLiteralNamed = (node, value) => node?.type === "StringLiteral" && node.value === value;
+const isMemberPropertyNamed = (memberExpression, propertyName) => {
+    if (!memberExpression.computed) {
+        return isIdentifierNamed(memberExpression.property, propertyName);
+    }
+    return isStringLiteralNamed(memberExpression.property, propertyName);
+};
 const isEmptyArrayExpression = (node) => node.elements.length === 0;
 const isArgumentsFallback = (node, argumentsName) => node.operator === "||" &&
     isIdentifierNamed(node.left, argumentsName) &&
@@ -14,11 +21,9 @@ const isGeneratorApplyCall = (node, generatorName, thisArgumentName, argumentsNa
     const callee = node.callee;
     if (callee.type !== "MemberExpression")
         return false;
-    if (callee.computed)
-        return false;
     if (!isIdentifierNamed(callee.object, generatorName))
         return false;
-    if (!isIdentifierNamed(callee.property, "apply"))
+    if (!isMemberPropertyNamed(callee, "apply"))
         return false;
     if (node.arguments.length !== 2)
         return false;
@@ -27,6 +32,9 @@ const isGeneratorApplyCall = (node, generatorName, thisArgumentName, argumentsNa
         return false;
     if (!isIdentifierNamed(thisArgument, thisArgumentName))
         return false;
+    if (argumentsValue.type === "ArrayExpression") {
+        return isEmptyArrayExpression(argumentsValue);
+    }
     if (argumentsValue.type === "Identifier") {
         return argumentsValue.name === argumentsName;
     }
@@ -38,11 +46,9 @@ const isGeneratorMethodCall = (node, generatorName, methodName) => {
     const callee = node.callee;
     if (callee.type !== "MemberExpression")
         return false;
-    if (callee.computed)
-        return false;
     if (!isIdentifierNamed(callee.object, generatorName))
         return false;
-    return isIdentifierNamed(callee.property, methodName);
+    return isMemberPropertyNamed(callee, methodName);
 };
 const isPromiseCtorNewExpression = (node, promiseCtorName) => {
     const callee = node.callee;

package/dist/transforms-by-id/rename-awaiter-parameters/manifest.json

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Measured with baseline none: 0.00%. Added to recommended for readability.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-07T21:09:14.149Z",
-            "changedLines": 196,
-            "durationSeconds": 154.025962677,
-            "stableNames": 1361
+            "evaluatedAt": "2026-02-22T10:26:55.132Z",
+            "changedLines": 280,
+            "durationSeconds": 31.154270667000002,
+            "stableNames": 1363
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }