miniread 1.118.1 → 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-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
 }

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

@@ -5,6 +5,83 @@ const PARAM_BASE_NAMES = {
     promiseCtor: "promiseCtor",
     generator: "generator",
 };
+const EXECUTOR_PARAM_BASE_NAMES = {
+    resolve: "resolve",
+    reject: "reject",
+};
+const isPromiseCtorNewExpression = (node, promiseCtorName) => {
+    const callee = node.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === promiseCtorName;
+    }
+    if (callee.type !== "LogicalExpression")
+        return false;
+    if (callee.operator !== "||")
+        return false;
+    if (callee.left.type !== "Identifier")
+        return false;
+    if (callee.left.name !== promiseCtorName)
+        return false;
+    const right = callee.right;
+    if (right.type !== "AssignmentExpression")
+        return false;
+    if (right.operator !== "=")
+        return false;
+    if (right.left.type !== "Identifier")
+        return false;
+    if (right.left.name !== promiseCtorName)
+        return false;
+    if (right.right.type !== "Identifier")
+        return false;
+    return right.right.name === "Promise";
+};
+const renameAwaiterPromiseExecutorParameters = (path, names) => {
+    let renamed = 0;
+    path.traverse({
+        NewExpression(innerPath) {
+            if (!isPromiseCtorNewExpression(innerPath.node, names.promiseCtor)) {
+                return;
+            }
+            const argumentPaths = innerPath.get("arguments");
+            const firstArgumentPath = argumentPaths[0];
+            if (!firstArgumentPath)
+                return;
+            if (!firstArgumentPath.isFunctionExpression() &&
+                !firstArgumentPath.isArrowFunctionExpression()) {
+                return;
+            }
+            const executorPath = firstArgumentPath;
+            const [resolveParameter, rejectParameter] = executorPath.node.params;
+            if (!resolveParameter || !rejectParameter)
+                return;
+            if (resolveParameter.type !== "Identifier" ||
+                rejectParameter.type !== "Identifier") {
+                return;
+            }
+            const resolveBinding = executorPath.scope.getBinding(resolveParameter.name);
+            const rejectBinding = executorPath.scope.getBinding(rejectParameter.name);
+            if (!resolveBinding || !rejectBinding)
+                return;
+            if (resolveBinding.scope !== executorPath.scope ||
+                rejectBinding.scope !== executorPath.scope) {
+                return;
+            }
+            const executorRenameGroup = new RenameGroup();
+            executorRenameGroup.add({
+                scope: executorPath.scope,
+                currentName: resolveParameter.name,
+                baseName: EXECUTOR_PARAM_BASE_NAMES.resolve,
+            });
+            executorRenameGroup.add({
+                scope: executorPath.scope,
+                currentName: rejectParameter.name,
+                baseName: EXECUTOR_PARAM_BASE_NAMES.reject,
+            });
+            renamed += executorRenameGroup.apply();
+        },
+    });
+    return renamed;
+};
 const renameAwaiterParameters = (path, names) => {
     const thisArgumentBinding = path.scope.getBinding(names.thisArg);
     const argumentsBinding = path.scope.getBinding(names.args);
@@ -44,6 +121,8 @@ const renameAwaiterParameters = (path, names) => {
         currentName: names.generator,
         baseName: PARAM_BASE_NAMES.generator,
     });
-    return group.apply();
+    const renamedExecutorParameters = renameAwaiterPromiseExecutorParameters(path, names);
+    const renamedAwaiterParameters = group.apply();
+    return renamedAwaiterParameters + renamedExecutorParameters;
 };
 export { renameAwaiterParameters };

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

@@ -28,9 +28,9 @@ export const renameAwaiterParametersTransform = {
                         promiseCtor: promiseCtor.name,
                         generator: generator.name,
                     };
-                    if (isStableRenamed(names.thisArg) ||
-                        isStableRenamed(names.args) ||
-                        isStableRenamed(names.promiseCtor) ||
+                    if (isStableRenamed(names.thisArg) &&
+                        isStableRenamed(names.args) &&
+                        isStableRenamed(names.promiseCtor) &&
                         isStableRenamed(names.generator)) {
                         return;
                     }

package/dist/transforms-by-id/rename-buffer-variables/is-allowed-buffer-binding.js

@@ -89,17 +89,53 @@ const isAllowedBufferModuleRequireBinding = (binding) => {
     }
     return propertyPath.isStringLiteral({ value: "Buffer" });
 };
-export const isAllowedBufferNamespaceBinding = (binding) => {
-    const bindingPath = binding.path;
-    if (!bindingPath.isImportNamespaceSpecifier()) {
+const isAllowedBufferWrappedRequireNamespaceBinding = (binding) => {
+    if (!binding.path.isVariableDeclarator()) {
         return false;
     }
-    const importDeclarationPath = bindingPath.parentPath;
-    if (!importDeclarationPath.isImportDeclaration()) {
+    const idPath = binding.path.get("id");
+    if (!idPath.isIdentifier()) {
         return false;
     }
-    const source = importDeclarationPath.node.source.value;
-    return source === "buffer" || source === "node:buffer";
+    const initPath = binding.path.get("init");
+    if (Array.isArray(initPath) || !initPath.isCallExpression()) {
+        return false;
+    }
+    if (initPath.node.arguments.length !== 1) {
+        return false;
+    }
+    const [firstArgument] = initPath.node.arguments;
+    if (firstArgument?.type !== "CallExpression") {
+        return false;
+    }
+    return isRequireCallOfBufferModule(initPath.get("arguments")[0]);
+};
+const isAllowedBufferModuleRequireNamespaceBinding = (binding) => {
+    if (!binding.path.isVariableDeclarator()) {
+        return false;
+    }
+    const idPath = binding.path.get("id");
+    if (!idPath.isIdentifier()) {
+        return false;
+    }
+    const initPath = binding.path.get("init");
+    if (Array.isArray(initPath)) {
+        return false;
+    }
+    return isRequireCallOfBufferModule(initPath);
+};
+export const isAllowedBufferNamespaceBinding = (binding) => {
+    const bindingPath = binding.path;
+    if (bindingPath.isImportNamespaceSpecifier()) {
+        const importDeclarationPath = bindingPath.parentPath;
+        if (!importDeclarationPath.isImportDeclaration()) {
+            return false;
+        }
+        const source = importDeclarationPath.node.source.value;
+        return source === "buffer" || source === "node:buffer";
+    }
+    return (isAllowedBufferModuleRequireNamespaceBinding(binding) ||
+        isAllowedBufferWrappedRequireNamespaceBinding(binding));
 };
 export const isAllowedBufferBinding = (binding) => {
     return (isAllowedBufferModuleImportBinding(binding) ||

package/dist/transforms-by-id/rename-buffer-variables/is-allowed-buffer-factory-call.js

@@ -13,6 +13,25 @@ const globalBufferNamespaceNames = new Set([
     "window",
     "self",
 ]);
+const isRequireBufferCall = (expression) => {
+    if (expression.type !== "CallExpression") {
+        return false;
+    }
+    if (expression.callee.type !== "Identifier") {
+        return false;
+    }
+    if (expression.callee.name !== "require") {
+        return false;
+    }
+    if (expression.arguments.length !== 1) {
+        return false;
+    }
+    const [firstArgument] = expression.arguments;
+    if (firstArgument?.type !== "StringLiteral") {
+        return false;
+    }
+    return (firstArgument.value === "buffer" || firstArgument.value === "node:buffer");
+};
 const getBufferFactoryReceiverIdentifierName = (callExpression) => {
     const { callee } = callExpression;
     if (callee.type !== "MemberExpression") {
@@ -28,24 +47,33 @@ const getBufferFactoryReceiverIdentifierName = (callExpression) => {
     if (receiver.type !== "MemberExpression") {
         return undefined;
     }
-    if (receiver.object.type !== "Identifier") {
-        return undefined;
-    }
     if (!receiver.computed && receiver.property.type === "Identifier") {
         if (receiver.property.name !== "Buffer")
             return undefined;
-        return {
-            receiverKind: "namespace-buffer-member",
-            receiverName: receiver.object.name,
-        };
+        if (receiver.object.type === "Identifier") {
+            return {
+                receiverKind: "namespace-buffer-member",
+                receiverName: receiver.object.name,
+            };
+        }
+        if (isRequireBufferCall(receiver.object)) {
+            return { receiverKind: "require-buffer-member" };
+        }
+        return undefined;
     }
     if (receiver.computed && receiver.property.type === "StringLiteral") {
         if (receiver.property.value !== "Buffer")
             return undefined;
-        return {
-            receiverKind: "namespace-buffer-member",
-            receiverName: receiver.object.name,
-        };
+        if (receiver.object.type === "Identifier") {
+            return {
+                receiverKind: "namespace-buffer-member",
+                receiverName: receiver.object.name,
+            };
+        }
+        if (isRequireBufferCall(receiver.object)) {
+            return { receiverKind: "require-buffer-member" };
+        }
+        return undefined;
     }
     return undefined;
 };
@@ -66,6 +94,9 @@ const hasKnownFactoryName = (callExpression) => {
     return bufferFactoryNames.has(callee.property.name);
 };
 const isAllowedBufferFactoryReceiver = (scope, receiver) => {
+    if (receiver.receiverKind === "require-buffer-member") {
+        return true;
+    }
     const receiverBinding = scope.getBinding(receiver.receiverName);
     if (!receiverBinding) {
         if (receiver.receiverKind === "namespace-buffer-member" &&

package/dist/transforms-by-id/rename-buffer-variables/manifest.json

@@ -3,10 +3,10 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 99.97543183278528,
-            "evaluatedAt": "2026-02-10T20:28:21.707Z",
-            "changedLines": 382,
-            "durationSeconds": 40.716609209000005,
-            "stableNames": 1359
+            "evaluatedAt": "2026-02-22T11:24:48.718Z",
+            "changedLines": 644,
+            "durationSeconds": 44.056725334,
+            "stableNames": 1360
         }
     },
     "recommended": true,

package/dist/transforms-by-id/rename-buffer-variables/rename-buffer-variables-transform.js

@@ -5,6 +5,24 @@ import { isAllowedBufferFactoryCall } from "./is-allowed-buffer-factory-call.js"
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
+const addBufferRenameCandidate = (renameGroup, seenBindings, scope, currentName) => {
+    if (isStableRenamed(currentName)) {
+        return;
+    }
+    const binding = scope.getBinding(currentName);
+    if (!binding) {
+        return;
+    }
+    if (seenBindings.has(binding)) {
+        return;
+    }
+    seenBindings.add(binding);
+    renameGroup.add({
+        scope,
+        currentName,
+        baseName: "buffer",
+    });
+};
 export const renameBufferVariablesTransform = {
     id: "rename-buffer-variables",
     description: "Rename variables assigned from Buffer factory calls to buffer",
@@ -15,6 +33,7 @@ export const renameBufferVariablesTransform = {
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
             const renameGroup = new RenameGroup();
+            const seenBufferBindings = new WeakSet();
             traverse(fileInfo.ast, {
                 VariableDeclarator(path) {
                     nodesVisited++;
@@ -25,19 +44,21 @@ export const renameBufferVariablesTransform = {
                     if (!isAllowedBufferFactoryCall(path.scope, init)) {
                         return;
                     }
-                    const currentName = id.name;
-                    if (isStableRenamed(currentName)) {
+                    addBufferRenameCandidate(renameGroup, seenBufferBindings, path.scope, id.name);
+                },
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    const { left, operator, right } = path.node;
+                    if (operator !== "=") {
+                        return;
+                    }
+                    if (left.type !== "Identifier") {
                         return;
                     }
-                    const binding = path.scope.getBinding(currentName);
-                    if (!binding) {
+                    if (!isAllowedBufferFactoryCall(path.scope, right)) {
                         return;
                     }
-                    renameGroup.add({
-                        scope: path.scope,
-                        currentName,
-                        baseName: "buffer",
-                    });
+                    addBufferRenameCandidate(renameGroup, seenBufferBindings, path.scope, left.name);
                 },
             });
             transformationsApplied += renameGroup.apply();

package/dist/transforms-by-id/rename-default-options-parameters-v3/collect-options-like-reference-signals.d.ts

@@ -0,0 +1,7 @@
+import type { Binding } from "@babel/traverse";
+type OptionsLikeReferenceSignals = {
+    allReferencesAreMemberAccesses: boolean;
+    destructuredPropertyNames: Set<string>;
+};
+export declare const collectOptionsLikeReferenceSignals: (binding: Binding) => OptionsLikeReferenceSignals;
+export {};

package/dist/transforms-by-id/rename-default-options-parameters-v3/collect-options-like-reference-signals.js

@@ -0,0 +1,65 @@
+export const collectOptionsLikeReferenceSignals = (binding) => {
+    const destructuredPropertyNames = new Set();
+    const allReferencesAreMemberAccesses = binding.referencePaths.every((referencePath) => isOptionsLikeReference(referencePath, destructuredPropertyNames));
+    return { allReferencesAreMemberAccesses, destructuredPropertyNames };
+};
+const isOptionsLikeReference = (referencePath, destructuredPropertyNames) => {
+    if (!referencePath.isIdentifier())
+        return false;
+    let wrappedObject = referencePath.node;
+    let parent = referencePath.parentPath;
+    while (parent.isTSNonNullExpression() ||
+        parent.isTSAsExpression() ||
+        parent.isTSTypeAssertion() ||
+        parent.isParenthesizedExpression()) {
+        wrappedObject = parent.node;
+        // Babel type packages differ on whether `parentPath` can be null.
+        const nextParent = parent.parentPath;
+        if (!nextParent)
+            return false;
+        parent = nextParent;
+    }
+    if (parent.isMemberExpression() && parent.node.object === wrappedObject)
+        return true;
+    if (parent.isOptionalMemberExpression() &&
+        parent.node.object === wrappedObject)
+        return true;
+    if (parent.isVariableDeclarator() &&
+        isObjectPatternDestructureOf(parent, wrappedObject)) {
+        addObjectPatternPropertyNames(parent.node.id, destructuredPropertyNames);
+        return true;
+    }
+    if (parent.isAssignmentExpression() &&
+        isObjectPatternAssignmentOf(parent, wrappedObject)) {
+        addObjectPatternPropertyNames(parent.node.left, destructuredPropertyNames);
+        return true;
+    }
+    return false;
+};
+const isObjectPatternDestructureOf = (path, wrappedObject) => {
+    if (!path.get("id").isObjectPattern())
+        return false;
+    return path.node.init === wrappedObject;
+};
+const isObjectPatternAssignmentOf = (path, wrappedObject) => {
+    if (!path.get("left").isObjectPattern())
+        return false;
+    return path.node.right === wrappedObject;
+};
+const addObjectPatternPropertyNames = (pattern, propertyNames) => {
+    for (const property of pattern.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        if (property.computed)
+            continue;
+        if (property.key.type === "Identifier") {
+            propertyNames.add(property.key.name);
+        }
+        else if (property.key.type === "StringLiteral") {
+            propertyNames.add(property.key.value);
+        }
+        if (property.value.type === "ObjectPattern") {
+            addObjectPatternPropertyNames(property.value, propertyNames);
+        }
+    }
+};

package/dist/transforms-by-id/rename-default-options-parameters-v3/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 97.17466077030653,
-            "evaluatedAt": "2026-02-10T06:08:59.846Z",
-            "changedLines": 54815,
-            "durationSeconds": 51.764200458,
+            "evaluatedAt": "2026-02-22T11:20:28.909Z",
+            "changedLines": 56345,
+            "durationSeconds": 45.11951500000001,
             "stableNames": 1361
         }
     },