miniread 1.91.0 → 1.93.0

package/dist/transforms/_generated/manifest.js

@@ -216,6 +216,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 } },
@@ -240,10 +244,16 @@ const manifestData = {
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:06:13.642Z", "changedLines": 15823, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 99.99622028196697 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99622028196697, "evaluatedAt": "2026-01-25T23:23:32.785Z", "changedLines": 15823, "durationSeconds": 56.566717458, "stableNames": 1357 } },
     },
     "rename-parameters-to-match-properties-v2": {
-        recommended: true,
+        recommended: false,
         notes: "Extends v1 to also handle this.property = param assignments.",
+        supersededBy: "rename-parameters-to-match-properties-v3",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:07:10.063Z", "changedLines": 20493, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 99.99244056393393 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99244056393393, "evaluatedAt": "2026-01-25T23:24:32.608Z", "changedLines": 20493, "durationSeconds": 56.743425875, "stableNames": 1357 } },
     },
+    "rename-parameters-to-match-properties-v3": {
+        recommended: true,
+        notes: "Extends v2 to rename parameters assigned with nullish defaulting patterns.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99244056393393, "evaluatedAt": "2026-02-07T08:43:16.376Z", "changedLines": 20493, "durationSeconds": 39.466395625, "stableNames": 1357 } },
+    },
     "rename-platform-win32-flags": {
         recommended: true,
         evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.99623032701913, "evaluatedAt": "2026-02-06T14:58:00.533Z", "changedLines": 42, "durationSeconds": 224.696743585, "stableNames": 1358 } },
@@ -506,6 +516,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",
@@ -536,7 +547,7 @@ export const recommendedTransformIds = [
     "rename-object-keys-iterator-variables",
     "rename-object-keys-reducer-parameters",
     "rename-object-entries-parameters",
-    "rename-parameters-to-match-properties-v2",
+    "rename-parameters-to-match-properties-v3",
     "rename-invalid-parameter-arguments",
     "rename-promise-executor-parameters-v2",
     "rename-range-parameters",

package/dist/transforms/_generated/registry.js

@@ -44,12 +44,14 @@ 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";
 import { renameObjectKeysVariablesTransform } from "../rename-object-keys-variables/rename-object-keys-variables-transform.js";
 import { renameParametersToMatchPropertiesTransform } from "../rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
+import { renameParametersToMatchPropertiesV3Transform } from "../rename-parameters-to-match-properties-v3/rename-parameters-to-match-properties-v3-transform.js";
 import { renamePlatformWin32FlagsTransform } from "../rename-platform-win32-flags/rename-platform-win32-flags-transform.js";
 import { renameProcessStdoutHandlersTransform } from "../rename-process-stdout-handlers/rename-process-stdout-handlers-transform.js";
 import { renamePromiseCatchParametersTransform } from "../rename-promise-catch-parameters/rename-promise-catch-parameters-transform.js";
@@ -142,12 +144,14 @@ export const transformRegistry = {
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renameLoopLengthVariablesTransform.id]: renameLoopLengthVariablesTransform,
+    [renameMemoizedInstanceVariablesTransform.id]: renameMemoizedInstanceVariablesTransform,
     [renameObjectEntriesParametersTransform.id]: renameObjectEntriesParametersTransform,
     [renameObjectKeysIteratorVariablesTransform.id]: renameObjectKeysIteratorVariablesTransform,
     [renameObjectKeysReducerParametersTransform.id]: renameObjectKeysReducerParametersTransform,
     [renameObjectKeysVariablesTransform.id]: renameObjectKeysVariablesTransform,
     [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
+    [renameParametersToMatchPropertiesV3Transform.id]: renameParametersToMatchPropertiesV3Transform,
     [renamePlatformWin32FlagsTransform.id]: renamePlatformWin32FlagsTransform,
     [renameProcessStdoutHandlersTransform.id]: renameProcessStdoutHandlersTransform,
     [renamePromiseCatchParametersTransform.id]: renamePromiseCatchParametersTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 30.510828892164643,
-        "notes": "Measured with baseline none: 30.51% of original diff."
+        "diffSizePercent": 30.501379597082057,
+        "notes": "Measured with baseline none: 30.50% of original diff."
     }
 }

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-v2", "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-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",
@@ -70,7 +71,7 @@ export const recommendedTransformOrder = [
     "rename-object-keys-iterator-variables",
     "rename-object-keys-reducer-parameters",
     "rename-object-entries-parameters",
-    "rename-parameters-to-match-properties-v2",
+    "rename-parameters-to-match-properties-v3",
     "rename-invalid-parameter-arguments",
     "rename-promise-executor-parameters-v2",
     "rename-range-parameters",

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-parameters-to-match-properties-v2/manifest.json

@@ -1,5 +1,5 @@
 {
-    "recommended": true,
+    "recommended": false,
     "evaluations": {
         "legacy:evaluation": {
             "evaluatedAt": "2026-01-25T20:07:10.063Z",
@@ -16,5 +16,6 @@
             "stableNames": 1357
         }
     },
-    "notes": "Extends v1 to also handle this.property = param assignments."
+    "notes": "Extends v1 to also handle this.property = param assignments.",
+    "supersededBy": "rename-parameters-to-match-properties-v3"
 }

package/dist/transforms/rename-parameters-to-match-properties-v3/get-assignment-property-name.d.ts

@@ -0,0 +1,2 @@
+import type { NodePath, Scope } from "@babel/traverse";
+export declare const getAssignmentPropertyName: (referencePath: NodePath, scope: Scope, currentName: string) => string | undefined;

package/dist/transforms/rename-parameters-to-match-properties-v3/get-assignment-property-name.js

@@ -0,0 +1,33 @@
+import { isNullishDefaultExpression } from "./nullish-default-expression.js";
+export const getAssignmentPropertyName = (referencePath, scope, currentName) => {
+    const parent = referencePath.parentPath;
+    if (parent?.isObjectProperty()) {
+        if (parent.node.value !== referencePath.node)
+            return undefined;
+        const key = parent.node.key;
+        if (key.type === "Identifier" && !parent.node.computed) {
+            return key.name;
+        }
+        return undefined;
+    }
+    const assignment = referencePath.findParent((ancestor) => ancestor.isAssignmentExpression());
+    if (assignment?.node.operator !== "=")
+        return undefined;
+    const left = assignment.node.left;
+    if (left.type === "MemberExpression" &&
+        !left.computed &&
+        left.object.type === "ThisExpression" &&
+        left.property.type === "Identifier") {
+        const right = assignment.node.right;
+        // This upward search is safe because we only accept assignments where the RHS
+        // is the same parameter binding (direct identifier or supported nullish-default
+        // expression). Any unrelated ancestor assignment is rejected by these checks.
+        if (right.type === "Identifier" && right.name === currentName) {
+            return left.property.name;
+        }
+        if (isNullishDefaultExpression(right, currentName, scope)) {
+            return left.property.name;
+        }
+    }
+    return undefined;
+};

package/dist/transforms/rename-parameters-to-match-properties-v3/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.99244056393393,
+            "evaluatedAt": "2026-02-07T08:43:16.376Z",
+            "changedLines": 20493,
+            "durationSeconds": 39.466395625,
+            "stableNames": 1357
+        }
+    },
+    "notes": "Extends v2 to rename parameters assigned with nullish defaulting patterns."
+}

package/dist/transforms/rename-parameters-to-match-properties-v3/nullish-default-expression.d.ts

@@ -0,0 +1,3 @@
+import type { Scope } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+export declare const isNullishDefaultExpression: (expression: Expression, name: string, scope: Scope) => boolean;

package/dist/transforms/rename-parameters-to-match-properties-v3/nullish-default-expression.js

@@ -0,0 +1,67 @@
+const isIdentifierReference = (node, name) => {
+    return node.type === "Identifier" && node.name === name;
+};
+const isNullLiteral = (node) => {
+    return node.type === "NullLiteral";
+};
+const isUndefinedIdentifier = (node, scope) => {
+    return (node.type === "Identifier" &&
+        node.name === "undefined" &&
+        !scope.hasBinding("undefined", true));
+};
+const isStrictNullCheck = (node, name, operator) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    if (node.operator !== operator)
+        return false;
+    return ((isIdentifierReference(node.left, name) && isNullLiteral(node.right)) ||
+        (isNullLiteral(node.left) && isIdentifierReference(node.right, name)));
+};
+const isStrictUndefinedCheck = (node, name, operator, scope) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    if (node.operator !== operator)
+        return false;
+    return ((isIdentifierReference(node.left, name) &&
+        isUndefinedIdentifier(node.right, scope)) ||
+        (isUndefinedIdentifier(node.left, scope) &&
+            isIdentifierReference(node.right, name)));
+};
+const isNullishGuard = (node, name, scope) => {
+    if (node.type !== "LogicalExpression" || node.operator !== "&&") {
+        return false;
+    }
+    return ((isStrictNullCheck(node.left, name, "!==") &&
+        isStrictUndefinedCheck(node.right, name, "!==", scope)) ||
+        (isStrictNullCheck(node.right, name, "!==") &&
+            isStrictUndefinedCheck(node.left, name, "!==", scope)));
+};
+const isNullishFallbackCheck = (node, name, scope) => {
+    if (node.type !== "LogicalExpression" || node.operator !== "||") {
+        return false;
+    }
+    return ((isStrictNullCheck(node.left, name, "===") &&
+        isStrictUndefinedCheck(node.right, name, "===", scope)) ||
+        (isStrictNullCheck(node.right, name, "===") &&
+            isStrictUndefinedCheck(node.left, name, "===", scope)));
+};
+export const isNullishDefaultExpression = (expression, name, scope) => {
+    if (expression.type === "LogicalExpression" && expression.operator === "??") {
+        return (isIdentifierReference(expression.left, name) &&
+            isNullLiteral(expression.right));
+    }
+    if (expression.type !== "ConditionalExpression")
+        return false;
+    const condition = expression.test;
+    if (isNullishGuard(condition, name, scope) &&
+        isIdentifierReference(expression.consequent, name) &&
+        isNullLiteral(expression.alternate)) {
+        return true;
+    }
+    if (isNullishFallbackCheck(condition, name, scope) &&
+        isNullLiteral(expression.consequent) &&
+        isIdentifierReference(expression.alternate, name)) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms/rename-parameters-to-match-properties-v3/rename-parameters-to-match-properties-v3-transform.d.ts

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

package/dist/transforms/rename-parameters-to-match-properties-v3/rename-parameters-to-match-properties-v3-transform.js

@@ -0,0 +1,77 @@
+import { createRequire } from "node:module";
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+import { getFilesToProcess, } from "../../core/types.js";
+import { isStableRenamed } from "../../core/stable-naming.js";
+import { getAssignmentPropertyName } from "./get-assignment-property-name.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const renameParametersToMatchPropertiesV3Transform = {
+    id: "rename-parameters-to-match-properties-v3",
+    description: "Renames parameters assigned to object properties or this.property (including nullish defaulting patterns)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const parameters = path.get("params");
+                    for (const parameterPath of parameters) {
+                        if (!parameterPath.isIdentifier())
+                            continue;
+                        const currentName = parameterPath.node.name;
+                        if (isStableRenamed(currentName))
+                            continue;
+                        const binding = path.scope.getBinding(currentName);
+                        if (!binding)
+                            continue;
+                        let candidateName;
+                        let isConsistent = true;
+                        for (const referencePath of binding.referencePaths) {
+                            const propertyName = getAssignmentPropertyName(referencePath, referencePath.scope, currentName);
+                            if (!propertyName)
+                                continue;
+                            if (candidateName === undefined) {
+                                candidateName = propertyName;
+                            }
+                            else if (candidateName !== propertyName) {
+                                isConsistent = false;
+                                break;
+                            }
+                        }
+                        if (candidateName) {
+                            const programScope = path.scope.getProgramParent();
+                            if (Object.hasOwn(programScope.globals, candidateName)) {
+                                isConsistent = false;
+                            }
+                            const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== path.scope &&
+                                referencePath.scope.hasBinding(candidateName));
+                            if (wouldBeShadowed) {
+                                isConsistent = false;
+                            }
+                        }
+                        if (isConsistent &&
+                            candidateName &&
+                            candidateName !== currentName &&
+                            (candidateName.length > currentName.length ||
+                                currentName.length <= 2) &&
+                            isIdentifierName(candidateName) &&
+                            !isKeyword(candidateName) &&
+                            !isStrictBindReservedWord(candidateName, true) &&
+                            !path.scope.hasBinding(candidateName)) {
+                            path.scope.rename(currentName, candidateName);
+                            transformationsApplied++;
+                        }
+                    }
+                },
+            });
+        }
+        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.91.0",
+  "version": "1.93.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",