miniread 1.92.0 → 1.94.0

package/dist/transforms/_generated/manifest.js

@@ -131,6 +131,11 @@ const manifestData = {
         notes: "Auto-added by evaluation script. Measured with baseline none: 0.09%.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T19:59:48.188Z", "changedLines": 38927, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 97.80020410477378 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 97.80020410477378, "evaluatedAt": "2026-01-25T23:15:44.243Z", "changedLines": 38927, "durationSeconds": 76.61873741599999, "stableNames": 4505 } },
     },
+    "rename-dirent-parameters": {
+        recommended: true,
+        notes: "stableNames counts unique `$...` identifiers in transformed output for this transform run, so this value can differ across transforms.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T21:03:02.730Z", "changedLines": 518, "durationSeconds": 177.77177340999998, "stableNames": 1360 } },
+    },
     "rename-document-fragment-variables": {
         recommended: true,
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-02T22:12:52.993Z", "changedLines": 20, "durationSeconds": 207.34089557, "stableNames": 1358 } },
@@ -216,6 +221,10 @@ const manifestData = {
         notes: "Measured with baseline none: 0.00%.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:05:17.827Z", "changedLines": 208, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-25T23:22:33.139Z", "changedLines": 208, "durationSeconds": 54.654894917, "stableNames": 1358 } },
     },
+    "rename-memoized-instance-variables": {
+        recommended: true,
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99246065403827, "evaluatedAt": "2026-02-06T21:01:58.503Z", "changedLines": 80, "durationSeconds": 168.58266914, "stableNames": 1359 } },
+    },
     "rename-object-entries-parameters": {
         recommended: true,
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-06T17:39:17.299Z", "changedLines": 248, "durationSeconds": 215.530500649, "stableNames": 1358 } },
@@ -512,6 +521,7 @@ export const recommendedTransformIds = [
     "rename-char-code-at",
     "rename-charcode-variables-v2",
     "rename-client-aliases",
+    "rename-memoized-instance-variables",
     "rename-comparison-flags",
     "rename-platform-win32-flags",
     "rename-date-now-start-times",
@@ -531,6 +541,7 @@ export const recommendedTransformIds = [
     "rename-add-event-listener-parameters",
     "rename-http-server-parameters",
     "rename-fs-sync-variables",
+    "rename-dirent-parameters",
     "rename-http-method-parameters",
     "rename-interval-ids",
     "rename-indexeddb-request-variables",

package/dist/transforms/_generated/registry.js

@@ -26,6 +26,7 @@ import { renameDefaultOptionsParametersV3Transform } from "../rename-default-opt
 import { renameDeferredResolveParametersTransform } from "../rename-deferred-resolve-parameters/rename-deferred-resolve-parameters-transform.js";
 import { renameDeferredResolveParametersV2Transform } from "../rename-deferred-resolve-parameters-v2/rename-deferred-resolve-parameters-v2-transform.js";
 import { renameDestructuredAliasesTransform } from "../rename-destructured-aliases/rename-destructured-aliases-transform.js";
+import { renameDirentParametersTransform } from "../rename-dirent-parameters/rename-dirent-parameters-transform.js";
 import { renameDocumentFragmentVariablesTransform } from "../rename-document-fragment-variables/rename-document-fragment-variables-transform.js";
 import { renameErrorFirstCallbackParametersTransform } from "../rename-error-first-callback-parameters/rename-error-first-callback-parameters-transform.js";
 import { renameErrorFirstCallbackParametersV2Transform } from "../rename-error-first-callback-parameters-v2/rename-error-first-callback-parameters-v2-transform.js";
@@ -44,6 +45,7 @@ import { renameLoopIndexVariablesTransform } from "../rename-loop-index-variable
 import { renameLoopIndexVariablesV2Transform } from "../rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
 import { renameLoopIndexVariablesV3Transform } from "../rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
 import { renameLoopLengthVariablesTransform } from "../rename-loop-length-variables/rename-loop-length-variables-transform.js";
+import { renameMemoizedInstanceVariablesTransform } from "../rename-memoized-instance-variables/rename-memoized-instance-variables-transform.js";
 import { renameObjectEntriesParametersTransform } from "../rename-object-entries-parameters/rename-object-entries-parameters-transform.js";
 import { renameObjectKeysIteratorVariablesTransform } from "../rename-object-keys-iterator-variables/rename-object-keys-iterator-variables-transform.js";
 import { renameObjectKeysReducerParametersTransform } from "../rename-object-keys-reducer-parameters/rename-object-keys-reducer-parameters-transform.js";
@@ -125,6 +127,7 @@ export const transformRegistry = {
     [renameDeferredResolveParametersTransform.id]: renameDeferredResolveParametersTransform,
     [renameDeferredResolveParametersV2Transform.id]: renameDeferredResolveParametersV2Transform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
+    [renameDirentParametersTransform.id]: renameDirentParametersTransform,
     [renameDocumentFragmentVariablesTransform.id]: renameDocumentFragmentVariablesTransform,
     [renameErrorFirstCallbackParametersTransform.id]: renameErrorFirstCallbackParametersTransform,
     [renameErrorFirstCallbackParametersV2Transform.id]: renameErrorFirstCallbackParametersV2Transform,
@@ -143,6 +146,7 @@ export const transformRegistry = {
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renameLoopLengthVariablesTransform.id]: renameLoopLengthVariablesTransform,
+    [renameMemoizedInstanceVariablesTransform.id]: renameMemoizedInstanceVariablesTransform,
     [renameObjectEntriesParametersTransform.id]: renameObjectEntriesParametersTransform,
     [renameObjectKeysIteratorVariablesTransform.id]: renameObjectKeysIteratorVariablesTransform,
     [renameObjectKeysReducerParametersTransform.id]: renameObjectKeysReducerParametersTransform,

package/dist/transforms/recommended-transform-order.d.ts

@@ -6,4 +6,4 @@
  * `recommended` prioritizes readability and includes documented heuristics
  * where edge-case behavioral differences are possible.
  */
-export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-platform-win32-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-default-options-parameters-v3", "rename-deferred-resolve-parameters", "rename-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "rename-error-variables", "rename-event-parameters", "rename-add-event-listener-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-indexeddb-request-variables", "rename-loop-index-variables-v3", "rename-queue-traversal-variables", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-object-keys-reducer-parameters", "rename-object-entries-parameters", "rename-parameters-to-match-properties-v3", "rename-invalid-parameter-arguments", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-exec-results", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-setstate-updater-parameters", "rename-file-extension-variables", "rename-string-split-variables-v2", "rename-queue-entry-variables", "rename-this-aliases", "rename-timeout-promises", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "rename-zod-check-parameters", "simplify-filter-boolean-coercion", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-memoized-instance-variables", "rename-comparison-flags", "rename-platform-win32-flags", "rename-date-now-start-times", "rename-default-options-parameters-v2", "rename-default-options-parameters-v3", "rename-deferred-resolve-parameters", "rename-deferred-resolve-parameters-v2", "rename-destructured-aliases", "rename-rest-parameters", "rename-rest-pop-callbacks", "rename-execfile-arguments", "rename-file-reader-variables", "rename-error-first-callback-parameters", "rename-error-first-callback-parameters-v2", "rename-error-variables", "rename-event-parameters", "rename-add-event-listener-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-dirent-parameters", "rename-http-method-parameters", "rename-interval-ids", "rename-indexeddb-request-variables", "rename-loop-index-variables-v3", "rename-queue-traversal-variables", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-object-keys-reducer-parameters", "rename-object-entries-parameters", "rename-parameters-to-match-properties-v3", "rename-invalid-parameter-arguments", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-regex-exec-results", "rename-regex-source-parameters", "rename-search-parameters-variables", "rename-setstate-updater-parameters", "rename-file-extension-variables", "rename-string-split-variables-v2", "rename-queue-entry-variables", "rename-this-aliases", "rename-timeout-promises", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "rename-zod-check-parameters", "simplify-filter-boolean-coercion", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

package/dist/transforms/recommended-transform-order.js

@@ -37,6 +37,7 @@ export const recommendedTransformOrder = [
     "rename-char-code-at",
     "rename-charcode-variables-v2",
     "rename-client-aliases",
+    "rename-memoized-instance-variables",
     "rename-comparison-flags",
     "rename-platform-win32-flags",
     "rename-date-now-start-times",
@@ -59,6 +60,7 @@ export const recommendedTransformOrder = [
     // are already stable-hashed. This transform gives remaining non-stable `fs` helpers stable
     // `$fs`-style names.
     "rename-fs-sync-variables",
+    "rename-dirent-parameters",
     "rename-http-method-parameters",
     "rename-interval-ids",
     "rename-indexeddb-request-variables",

package/dist/transforms/rename-dirent-parameters/get-member-property-name.d.ts

@@ -0,0 +1,3 @@
+import type { MemberExpression, OptionalMemberExpression } from "@babel/types";
+export type MemberLikeExpression = MemberExpression | OptionalMemberExpression;
+export declare const getMemberPropertyName: (member: MemberLikeExpression) => string | undefined;

package/dist/transforms/rename-dirent-parameters/get-member-property-name.js

@@ -0,0 +1,10 @@
+export const getMemberPropertyName = (member) => {
+    if (member.computed) {
+        if (member.property.type !== "StringLiteral")
+            return;
+        return member.property.value;
+    }
+    if (member.property.type !== "Identifier")
+        return;
+    return member.property.name;
+};

package/dist/transforms/rename-dirent-parameters/is-dirent-callback-parameter-binding.d.ts

@@ -0,0 +1,2 @@
+import type { Binding } from "@babel/traverse";
+export declare const isDirentCallbackParameterBinding: (binding: Binding) => boolean;

package/dist/transforms/rename-dirent-parameters/is-dirent-callback-parameter-binding.js

@@ -0,0 +1,111 @@
+import { getMemberPropertyName } from "./get-member-property-name.js";
+const iterableMethodNames = new Set([
+    "every",
+    "filter",
+    "flatMap",
+    "find",
+    "findLast",
+    "findLastIndex",
+    "findIndex",
+    "forEach",
+    "map",
+    "some",
+]);
+const unwrapTransparentExpressionNode = (expression) => {
+    if (expression.type === "ParenthesizedExpression") {
+        return unwrapTransparentExpressionNode(expression.expression);
+    }
+    if (expression.type === "TSAsExpression") {
+        return unwrapTransparentExpressionNode(expression.expression);
+    }
+    if (expression.type === "TSSatisfiesExpression") {
+        return unwrapTransparentExpressionNode(expression.expression);
+    }
+    if (expression.type === "TSTypeAssertion") {
+        return unwrapTransparentExpressionNode(expression.expression);
+    }
+    if (expression.type === "TSNonNullExpression") {
+        return unwrapTransparentExpressionNode(expression.expression);
+    }
+    return expression;
+};
+const isIterableCallbackCall = (path) => {
+    const callee = path.node.callee;
+    if ((callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") ||
+        !iterableMethodNames.has(getMemberPropertyName(callee) ?? "")) {
+        return false;
+    }
+    const [firstArgument] = path.node.arguments;
+    if (!firstArgument)
+        return false;
+    if (firstArgument.type === "SpreadElement")
+        return false;
+    if (firstArgument.type === "ArgumentPlaceholder")
+        return false;
+    const unwrappedFirstArgument = unwrapTransparentExpressionNode(firstArgument);
+    return (unwrappedFirstArgument.type === "FunctionExpression" ||
+        unwrappedFirstArgument.type === "ArrowFunctionExpression");
+};
+const unwrapTransparentExpressionPath = (path) => {
+    const parentPath = path.parentPath;
+    const parentNode = parentPath.node;
+    if (parentNode.type !== "ParenthesizedExpression" &&
+        parentNode.type !== "TSAsExpression" &&
+        parentNode.type !== "TSSatisfiesExpression" &&
+        parentNode.type !== "TSTypeAssertion" &&
+        parentNode.type !== "TSNonNullExpression") {
+        return path;
+    }
+    if (parentNode.expression !== path.node)
+        return path;
+    return unwrapTransparentExpressionPath(parentPath);
+};
+const hasNamePropertyUsage = (binding) => {
+    return binding.referencePaths.some((referencePath) => {
+        if (!referencePath.isIdentifier())
+            return false;
+        const objectPath = unwrapTransparentExpressionPath(referencePath);
+        const parentPath = objectPath.parentPath;
+        if ((!parentPath.isMemberExpression() &&
+            !parentPath.isOptionalMemberExpression()) ||
+            parentPath.node.object !== objectPath.node) {
+            return false;
+        }
+        return getMemberPropertyName(parentPath.node) === "name";
+    });
+};
+export const isDirentCallbackParameterBinding = (binding) => {
+    const bindingPath = binding.path;
+    if (!bindingPath.isIdentifier())
+        return false;
+    const callbackPath = bindingPath.parentPath;
+    if (!callbackPath.isFunctionExpression() &&
+        !callbackPath.isArrowFunctionExpression()) {
+        return false;
+    }
+    const [firstParameter] = callbackPath.node.params;
+    if (firstParameter?.type !== "Identifier")
+        return false;
+    if (firstParameter !== binding.identifier)
+        return false;
+    const callbackContainerPath = unwrapTransparentExpressionPath(callbackPath);
+    const callbackCallPath = callbackContainerPath.parentPath;
+    if (!callbackCallPath.isCallExpression() &&
+        !callbackCallPath.isOptionalCallExpression()) {
+        return false;
+    }
+    if (!isIterableCallbackCall(callbackCallPath))
+        return false;
+    // Require reading dirent.name somewhere in the callback to avoid Stats-like false positives.
+    if (!hasNamePropertyUsage(binding))
+        return false;
+    const [firstArgument] = callbackCallPath.node.arguments;
+    if (!firstArgument)
+        return false;
+    if (firstArgument.type === "SpreadElement")
+        return false;
+    if (firstArgument.type === "ArgumentPlaceholder")
+        return false;
+    return unwrapTransparentExpressionNode(firstArgument) === callbackPath.node;
+};

package/dist/transforms/rename-dirent-parameters/is-dirent-method-call.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import { type MemberLikeExpression } from "./get-member-property-name.js";
+export declare const isDirentMethodCall: (path: NodePath<MemberLikeExpression>) => boolean;

package/dist/transforms/rename-dirent-parameters/is-dirent-method-call.js

@@ -0,0 +1,26 @@
+import { getMemberPropertyName, } from "./get-member-property-name.js";
+const direntMethodNames = new Set([
+    "isBlockDevice",
+    "isCharacterDevice",
+    "isDirectory",
+    "isFIFO",
+    "isFile",
+    "isSocket",
+    "isSymbolicLink",
+]);
+// Intentional heuristic: these names are a readability signal, not strict type inference.
+// Additional callback-shape guards in is-dirent-callback-parameter-binding keep this conservative.
+const isCallLikePath = (path) => {
+    return path.isCallExpression() || path.isOptionalCallExpression();
+};
+export const isDirentMethodCall = (path) => {
+    const propertyName = getMemberPropertyName(path.node);
+    if (!propertyName)
+        return false;
+    if (!direntMethodNames.has(propertyName))
+        return false;
+    const callPath = path.parentPath;
+    if (!isCallLikePath(callPath))
+        return false;
+    return callPath.node.callee === path.node;
+};

package/dist/transforms/rename-dirent-parameters/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "stableNames counts unique `$...` identifiers in transformed output for this transform run, so this value can differ across transforms.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-02-06T21:03:02.730Z",
+            "changedLines": 518,
+            "durationSeconds": 177.77177340999998,
+            "stableNames": 1360
+        }
+    }
+}

package/dist/transforms/rename-dirent-parameters/rename-dirent-parameters-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameDirentParametersTransform: Transform;

package/dist/transforms/rename-dirent-parameters/rename-dirent-parameters-transform.js

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasDynamicNameLookup } from "../has-dynamic-name-lookup.js";
+import {} from "./get-member-property-name.js";
+import { isDirentCallbackParameterBinding } from "./is-dirent-callback-parameter-binding.js";
+import { isDirentMethodCall } from "./is-dirent-method-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 addDirentBinding = (path, group, seenBindings) => {
+    if (!isDirentMethodCall(path))
+        return;
+    const object = path.node.object;
+    if (object.type !== "Identifier")
+        return;
+    const binding = path.scope.getBinding(object.name);
+    if (!binding)
+        return;
+    // Reassigned parameters may stop representing a dirent in the same scope.
+    if (!binding.constant)
+        return;
+    if (!isDirentCallbackParameterBinding(binding))
+        return;
+    if (seenBindings.has(binding))
+        return;
+    const currentName = binding.identifier.name;
+    if (isStableRenamed(currentName))
+        return;
+    // Keep already-semantic names readable; we avoid adding `$` noise when intent is clear.
+    if (currentName === "dirent")
+        return;
+    group.add({
+        scope: binding.scope,
+        currentName,
+        baseName: "dirent",
+    });
+    seenBindings.add(binding);
+};
+export const renameDirentParametersTransform = {
+    id: "rename-dirent-parameters",
+    description: "Renames iterable callback bindings that call Dirent-style predicate methods and read .name to semantic dirent names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            if (hasDynamicNameLookup(fileInfo.ast))
+                continue;
+            const group = new RenameGroup();
+            const seenBindings = new Set();
+            traverse(fileInfo.ast, {
+                MemberExpression(path) {
+                    nodesVisited++;
+                    addDirentBinding(path, group, seenBindings);
+                },
+                OptionalMemberExpression(path) {
+                    nodesVisited++;
+                    addDirentBinding(path, group, seenBindings);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-memoized-instance-variables/manifest.json

@@ -0,0 +1,12 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99246065403827,
+            "evaluatedAt": "2026-02-06T21:01:58.503Z",
+            "changedLines": 80,
+            "durationSeconds": 168.58266914,
+            "stableNames": 1359
+        }
+    }
+}

package/dist/transforms/rename-memoized-instance-variables/rename-memoized-instance-variables-transform.d.ts

@@ -0,0 +1,2 @@
+import { type Transform } from "../../core/types.js";
+export declare const renameMemoizedInstanceVariablesTransform: Transform;

package/dist/transforms/rename-memoized-instance-variables/rename-memoized-instance-variables-transform.js

@@ -0,0 +1,130 @@
+import { createRequire } from "node:module";
+import { collectExportedNames } from "../../core/collect-exported-names.js";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { hasDynamicNameLookup } from "../has-dynamic-name-lookup.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const BASE_NAME = "memoizedInstance";
+const isNegatedIdentifierTest = (test, name) => {
+    if (test.type !== "UnaryExpression")
+        return false;
+    if (test.operator !== "!")
+        return false;
+    if (test.argument.type !== "Identifier")
+        return false;
+    return test.argument.name === name;
+};
+const isCallbackFunctionPath = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    if (!parentPath.isCallExpression() &&
+        !parentPath.isOptionalCallExpression() &&
+        !parentPath.isNewExpression())
+        return false;
+    const parentArguments = parentPath.node.arguments;
+    const callbackNode = path.node;
+    return parentArguments.includes(callbackNode);
+};
+const isMemoizedNewAssignment = (violationPath, name) => {
+    if (!violationPath.isAssignmentExpression())
+        return false;
+    const assignment = violationPath.node;
+    if (assignment.operator !== "=")
+        return false;
+    if (assignment.left.type !== "Identifier")
+        return false;
+    if (assignment.left.name !== name)
+        return false;
+    if (assignment.right.type !== "NewExpression")
+        return false;
+    const assignmentFunctionParent = violationPath.scope.getFunctionParent();
+    if (assignmentFunctionParent &&
+        isCallbackFunctionPath(assignmentFunctionParent.path))
+        return false;
+    const ifPath = violationPath.findParent((parent) => parent.isIfStatement() &&
+        parent.scope.getFunctionParent() === assignmentFunctionParent);
+    if (!ifPath?.isIfStatement())
+        return false;
+    const test = ifPath.node.test;
+    if (!isNegatedIdentifierTest(test, name))
+        return false;
+    if (ifPath.node.alternate)
+        return false;
+    const assignmentExpressionStatementPath = violationPath.parentPath;
+    if (!assignmentExpressionStatementPath.isExpressionStatement())
+        return false;
+    const consequentPath = ifPath.get("consequent");
+    if (consequentPath.isBlockStatement()) {
+        if (assignmentExpressionStatementPath.parentPath.node !== consequentPath.node)
+            return false;
+        if (consequentPath.node.body.length !== 1)
+            return false;
+        const [onlyConsequentStatement] = consequentPath.node.body;
+        if (onlyConsequentStatement !== assignmentExpressionStatementPath.node)
+            return false;
+    }
+    else if (assignmentExpressionStatementPath.node !== consequentPath.node) {
+        return false;
+    }
+    return true;
+};
+export const renameMemoizedInstanceVariablesTransform = {
+    id: "rename-memoized-instance-variables",
+    description: "Renames memoized instance bindings when every reassignment is a direct `id = new ...` consequent of `if (!id)` (without `else`) to $memoizedInstance/$memoizedInstance2/... or memoizedInstance/memoizedInstance2/... depending on per-scope stability",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            if (hasDynamicNameLookup(fileInfo.ast))
+                continue;
+            const isScript = fileInfo.ast.program.sourceType === "script";
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (isStableRenamed(id.name))
+                        return;
+                    const init = path.node.init;
+                    if (init)
+                        return;
+                    if (!path.parentPath.isVariableDeclaration())
+                        return;
+                    const kind = path.parentPath.node.kind;
+                    if (kind !== "let" && kind !== "var")
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (isScript && binding.scope.block.type === "Program")
+                        return;
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(id.name)) {
+                        return;
+                    }
+                    if (binding.referencePaths.length === 0)
+                        return;
+                    if (binding.constantViolations.length === 0)
+                        return;
+                    if (!binding.constantViolations.every((violationPath) => isMemoizedNewAssignment(violationPath, id.name)))
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-platform-win32-flags/is-safe-process-binding.js

@@ -1,4 +1,4 @@
-import { isNodeRequireInScope } from "../is-require-from-url-module.js";
+import { isNodeRequireInScope } from "../shared/node/is-node-require-in-scope.js";
 const isProcessSpecifier = (value) => value === "process" ||
     value === "node:process" ||
     value === "process/browser" ||

package/dist/transforms/rename-search-parameters-variables/rename-search-parameters-variables-transform.js

@@ -1,8 +1,8 @@
 import { createRequire } from "node:module";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { getUrlConstructionKind } from "../get-url-construction-kind.js";
-import { isAllowedUrlConstructorInScope } from "../is-allowed-url-constructor-in-scope.js";
+import { getUrlConstructionKind } from "../shared/url/get-url-construction-kind.js";
+import { isAllowedUrlConstructorInScope } from "../shared/url/is-allowed-url-constructor-in-scope.js";
 import { isSearchParametersDestructureUsage, isSearchParametersForOfUsage, isSearchParametersPropertyAccess, isSearchParametersSpreadUsage, } from "./search-parameters-usage-heuristics.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access

package/dist/transforms/rename-url-parameters/rename-url-parameters-transform.js

@@ -2,7 +2,7 @@ import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { hasUrlDestructure } from "../url-usage-heuristics.js";
+import { hasUrlDestructure } from "../shared/url/url-usage-heuristics.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;

package/dist/transforms/rename-url-variables/rename-url-variables-transform.js

@@ -1,9 +1,9 @@
 import { createRequire } from "node:module";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
-import { hasUrlDestructure, urlPropertyNames, } from "../url-usage-heuristics.js";
-import { getUrlConstructionKind } from "../get-url-construction-kind.js";
-import { isAllowedUrlConstructorInScope } from "../is-allowed-url-constructor-in-scope.js";
+import { hasUrlDestructure, urlPropertyNames, } from "../shared/url/url-usage-heuristics.js";
+import { getUrlConstructionKind } from "../shared/url/get-url-construction-kind.js";
+import { isAllowedUrlConstructorInScope } from "../shared/url/is-allowed-url-constructor-in-scope.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;

package/dist/transforms/shared/node/is-node-require-in-scope.d.ts

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

package/dist/transforms/{is-require-from-url-module.js → shared/node/is-node-require-in-scope.js}

@@ -1,83 +1,3 @@
-const getRequireFromUrlModuleArgument = (expression) => {
-    if (expression.type !== "CallExpression")
-        return;
-    if (expression.callee.type !== "Identifier")
-        return;
-    if (expression.callee.name !== "require")
-        return;
-    if (expression.arguments.length !== 1)
-        return;
-    const argument = expression.arguments[0];
-    if (!argument)
-        return;
-    if (argument.type === "StringLiteral") {
-        if (argument.value === "url")
-            return "url";
-        if (argument.value === "node:url")
-            return "node:url";
-        return;
-    }
-    if (argument.type === "TemplateLiteral") {
-        if (argument.expressions.length > 0)
-            return;
-        const quasi = argument.quasis[0];
-        if (!quasi)
-            return;
-        const value = quasi.value.cooked ?? quasi.value.raw;
-        if (value === "url")
-            return "url";
-        if (value === "node:url")
-            return "node:url";
-        return;
-    }
-};
-/**
- * Returns `true` for:
- * - `require("url")` / `require("node:url")`
- * - `require("url").URL` / `require("node:url").URL` (or any other `propertyName`),
- *   but only when the `propertyName` argument is provided
- *
- * Note: This helper only checks the shape of the AST. If `require` is locally
- * bound in the current scope (e.g. by a bundler), callers should additionally
- * verify that `require` refers to Node's `require()` (see
- * {@link isNodeRequireInScope}).
- */
-export const isRequireFromUrlModule = (node, propertyName) => {
-    if (!node)
-        return false;
-    if (!propertyName)
-        return Boolean(getRequireFromUrlModuleArgument(node));
-    if (node.type !== "MemberExpression")
-        return false;
-    let memberPropertyName = undefined;
-    if (node.computed) {
-        if (node.property.type === "StringLiteral") {
-            memberPropertyName = node.property.value;
-        }
-        else if (node.property.type === "TemplateLiteral" &&
-            node.property.expressions.length === 0 &&
-            node.property.quasis.length === 1) {
-            const quasi = node.property.quasis[0];
-            memberPropertyName = quasi?.value.cooked ?? quasi?.value.raw;
-        }
-    }
-    else if (node.property.type === "Identifier") {
-        memberPropertyName = node.property.name;
-    }
-    const hasMatchingProperty = memberPropertyName === propertyName;
-    if (!hasMatchingProperty)
-        return false;
-    // We only accept a direct `require("url").X` (or `require("node:url").X`)
-    // member expression; deeper chains like `require("url").X.Y` are not relevant
-    // for our current usage and would fail the base `require("url")` check anyway.
-    if (node.object.type !== "CallExpression")
-        return false;
-    if (node.object.callee.type !== "Identifier")
-        return false;
-    if (node.object.callee.name !== "require")
-        return false;
-    return Boolean(getRequireFromUrlModuleArgument(node.object));
-};
 export const isNodeRequireInScope = (scope) => {
     const requireBinding = scope.getBinding("require");
     if (!requireBinding) {

package/dist/transforms/{is-allowed-url-constructor-in-scope.js → shared/url/is-allowed-url-constructor-in-scope.js}

@@ -1,5 +1,6 @@
+import { isNodeRequireInScope } from "../node/is-node-require-in-scope.js";
 import { isAllowedUrlModuleImportBinding } from "./is-allowed-url-module-import-binding.js";
-import { isNodeRequireInScope, isRequireFromUrlModule, } from "./is-require-from-url-module.js";
+import { isRequireFromUrlModule } from "./is-require-from-url-module.js";
 const doesObjectPatternBindConstructorName = (pattern, constructorName) => {
     for (const property of pattern.properties) {
         if (property.type !== "ObjectProperty")

package/dist/transforms/{is-allowed-url-namespace-binding-in-scope.js → shared/url/is-allowed-url-namespace-binding-in-scope.js}

@@ -1,4 +1,5 @@
-import { isNodeRequireInScope, isRequireFromUrlModule, } from "./is-require-from-url-module.js";
+import { isNodeRequireInScope } from "../node/is-node-require-in-scope.js";
+import { isRequireFromUrlModule } from "./is-require-from-url-module.js";
 export const isAllowedUrlNamespaceBindingInScope = (scope, bindingName) => {
     const binding = scope.getBinding(bindingName);
     if (!binding)

package/dist/transforms/{is-require-from-url-module.d.ts → shared/url/is-require-from-url-module.d.ts}

@@ -1,4 +1,3 @@
-import type { Scope } from "@babel/traverse";
 import type { Expression } from "@babel/types";
 /**
  * Returns `true` for:
@@ -9,7 +8,6 @@ import type { Expression } from "@babel/types";
  * Note: This helper only checks the shape of the AST. If `require` is locally
  * bound in the current scope (e.g. by a bundler), callers should additionally
  * verify that `require` refers to Node's `require()` (see
- * {@link isNodeRequireInScope}).
+ * `isNodeRequireInScope`).
  */
 export declare const isRequireFromUrlModule: (node: Expression | null | undefined, propertyName?: string) => boolean;
-export declare const isNodeRequireInScope: (scope: Scope) => boolean;

package/dist/transforms/shared/url/is-require-from-url-module.js

@@ -0,0 +1,80 @@
+const getRequireFromUrlModuleArgument = (expression) => {
+    if (expression.type !== "CallExpression")
+        return;
+    if (expression.callee.type !== "Identifier")
+        return;
+    if (expression.callee.name !== "require")
+        return;
+    if (expression.arguments.length !== 1)
+        return;
+    const argument = expression.arguments[0];
+    if (!argument)
+        return;
+    if (argument.type === "StringLiteral") {
+        if (argument.value === "url")
+            return "url";
+        if (argument.value === "node:url")
+            return "node:url";
+        return;
+    }
+    if (argument.type === "TemplateLiteral") {
+        if (argument.expressions.length > 0)
+            return;
+        const quasi = argument.quasis[0];
+        if (!quasi)
+            return;
+        const value = quasi.value.cooked ?? quasi.value.raw;
+        if (value === "url")
+            return "url";
+        if (value === "node:url")
+            return "node:url";
+        return;
+    }
+};
+/**
+ * Returns `true` for:
+ * - `require("url")` / `require("node:url")`
+ * - `require("url").URL` / `require("node:url").URL` (or any other `propertyName`),
+ *   but only when the `propertyName` argument is provided
+ *
+ * Note: This helper only checks the shape of the AST. If `require` is locally
+ * bound in the current scope (e.g. by a bundler), callers should additionally
+ * verify that `require` refers to Node's `require()` (see
+ * `isNodeRequireInScope`).
+ */
+export const isRequireFromUrlModule = (node, propertyName) => {
+    if (!node)
+        return false;
+    if (!propertyName)
+        return Boolean(getRequireFromUrlModuleArgument(node));
+    if (node.type !== "MemberExpression")
+        return false;
+    let memberPropertyName = undefined;
+    if (node.computed) {
+        if (node.property.type === "StringLiteral") {
+            memberPropertyName = node.property.value;
+        }
+        else if (node.property.type === "TemplateLiteral" &&
+            node.property.expressions.length === 0 &&
+            node.property.quasis.length === 1) {
+            const quasi = node.property.quasis[0];
+            memberPropertyName = quasi?.value.cooked ?? quasi?.value.raw;
+        }
+    }
+    else if (node.property.type === "Identifier") {
+        memberPropertyName = node.property.name;
+    }
+    const hasMatchingProperty = memberPropertyName === propertyName;
+    if (!hasMatchingProperty)
+        return false;
+    // We only accept a direct `require("url").X` (or `require("node:url").X`)
+    // member expression; deeper chains like `require("url").X.Y` are not relevant
+    // for our current usage and would fail the base `require("url")` check anyway.
+    if (node.object.type !== "CallExpression")
+        return false;
+    if (node.object.callee.type !== "Identifier")
+        return false;
+    if (node.object.callee.name !== "require")
+        return false;
+    return Boolean(getRequireFromUrlModuleArgument(node.object));
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.92.0",
+  "version": "1.94.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",