miniread 1.43.0 → 1.45.0

package/dist/transforms/_generated/manifest.js

@@ -216,6 +216,13 @@ const manifestData = {
         notes: "Auto-added by evaluation script.",
         changedLines: 970,
     },
+    "rename-range-parameters": {
+        diffReductionImpact: 0,
+        recommended: true,
+        evaluatedAt: "2026-01-25T09:40:26.000Z",
+        notes: "Renames range-style parameters when the count defaults to the start value and start resets to 0.",
+        changedLines: 0,
+    },
     "rename-regex-builders": {
         diffReductionImpact: 0,
         recommended: true,
@@ -236,6 +243,13 @@ const manifestData = {
         evaluatedAt: "2026-01-25T20:11:03.532Z",
         changedLines: 1300,
     },
+    "rename-safe-property-accessor-parameters": {
+        diffReductionImpact: -0.000018848364904400228,
+        recommended: false,
+        evaluatedAt: "2026-01-25T10:04:22.417Z",
+        notes: "Negative diff reduction in evaluation; keep optional.",
+        changedLines: 0,
+    },
     "rename-this-aliases": {
         diffReductionImpact: 0.00003779718033036783,
         recommended: true,

package/dist/transforms/_generated/registry.js

@@ -30,9 +30,11 @@ import { renameParametersToMatchPropertiesTransform } from "../rename-parameters
 import { renameParametersToMatchPropertiesV2Transform } from "../rename-parameters-to-match-properties-v2/rename-parameters-to-match-properties-v2-transform.js";
 import { renameProcessStdoutHandlersTransform } from "../rename-process-stdout-handlers/rename-process-stdout-handlers-transform.js";
 import { renamePromiseExecutorParametersTransform } from "../rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
+import { renameRangeParametersTransform } from "../rename-range-parameters/rename-range-parameters-transform.js";
 import { renameRegexBuildersTransform } from "../rename-regex-builders/rename-regex-builders-transform.js";
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
+import { renameSafePropertyAccessorParametersTransform } from "../rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutDurationParametersTransform } from "../rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
@@ -79,9 +81,11 @@ export const transformRegistry = {
     [renameParametersToMatchPropertiesV2Transform.id]: renameParametersToMatchPropertiesV2Transform,
     [renameProcessStdoutHandlersTransform.id]: renameProcessStdoutHandlersTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
+    [renameRangeParametersTransform.id]: renameRangeParametersTransform,
     [renameRegexBuildersTransform.id]: renameRegexBuildersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
+    [renameSafePropertyAccessorParametersTransform.id]: renameSafePropertyAccessorParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,

package/dist/transforms/rename-range-parameters/get-first-non-directive-statement.d.ts

@@ -0,0 +1,2 @@
+import * as t from "@babel/types";
+export declare const getFirstNonDirectiveStatement: (body: t.BlockStatement) => t.Statement | undefined;

package/dist/transforms/rename-range-parameters/get-first-non-directive-statement.js

@@ -0,0 +1,16 @@
+import * as t from "@babel/types";
+const isDirectivePrologueStatement = (statement) => {
+    if (!t.isExpressionStatement(statement))
+        return false;
+    return t.isStringLiteral(statement.expression);
+};
+export const getFirstNonDirectiveStatement = (body) => {
+    for (const statement of body.body) {
+        if (t.isEmptyStatement(statement))
+            continue;
+        if (isDirectivePrologueStatement(statement))
+            continue;
+        return statement;
+    }
+    return undefined;
+};

package/dist/transforms/rename-range-parameters/get-range-parameter-default-assignments.d.ts

@@ -0,0 +1,4 @@
+import * as t from "@babel/types";
+type AssignmentPair = [t.AssignmentExpression, t.AssignmentExpression];
+export declare const getRangeParameterDefaultAssignments: (consequent: t.Statement) => AssignmentPair | undefined;
+export {};

package/dist/transforms/rename-range-parameters/get-range-parameter-default-assignments.js

@@ -0,0 +1,57 @@
+import * as t from "@babel/types";
+const getSequenceAssignments = (expression) => {
+    if (!t.isSequenceExpression(expression))
+        return undefined;
+    if (expression.expressions.length !== 2)
+        return undefined;
+    const firstExpression = expression.expressions[0];
+    const secondExpression = expression.expressions[1];
+    if (!firstExpression || !secondExpression)
+        return undefined;
+    if (!t.isAssignmentExpression(firstExpression, { operator: "=" })) {
+        return undefined;
+    }
+    if (!t.isAssignmentExpression(secondExpression, { operator: "=" })) {
+        return undefined;
+    }
+    return [firstExpression, secondExpression];
+};
+export const getRangeParameterDefaultAssignments = (consequent) => {
+    if (t.isExpressionStatement(consequent)) {
+        return getSequenceAssignments(consequent.expression);
+    }
+    if (!t.isBlockStatement(consequent))
+        return undefined;
+    const statements = consequent.body.filter((statement) => !t.isEmptyStatement(statement));
+    if (statements.length === 2) {
+        const [firstStatement, secondStatement] = statements;
+        if (!firstStatement || !secondStatement)
+            return undefined;
+        if (!t.isExpressionStatement(firstStatement))
+            return undefined;
+        if (!t.isExpressionStatement(secondStatement))
+            return undefined;
+        const firstAssignment = t.isAssignmentExpression(firstStatement.expression, {
+            operator: "=",
+        })
+            ? firstStatement.expression
+            : undefined;
+        const secondAssignment = t.isAssignmentExpression(secondStatement.expression, {
+            operator: "=",
+        })
+            ? secondStatement.expression
+            : undefined;
+        if (!firstAssignment || !secondAssignment)
+            return undefined;
+        return [firstAssignment, secondAssignment];
+    }
+    if (statements.length === 1) {
+        const [onlyStatement] = statements;
+        if (!onlyStatement)
+            return undefined;
+        if (!t.isExpressionStatement(onlyStatement))
+            return undefined;
+        return getSequenceAssignments(onlyStatement.expression);
+    }
+    return undefined;
+};

package/dist/transforms/rename-range-parameters/get-range-parameter-names.d.ts

@@ -0,0 +1,8 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+type RangeParameterNames = {
+    startName: string;
+    countName: string;
+};
+export declare const getRangeParameterNames: (path: NodePath<BabelFunction>) => RangeParameterNames | undefined;
+export {};

package/dist/transforms/rename-range-parameters/get-range-parameter-names.js

@@ -0,0 +1,54 @@
+import * as t from "@babel/types";
+import { getFirstNonDirectiveStatement } from "./get-first-non-directive-statement.js";
+import { getRangeParameterDefaultAssignments } from "./get-range-parameter-default-assignments.js";
+import { hasCountNonPositiveGuard } from "./has-count-non-positive-guard.js";
+import { hasStartCountSum } from "./has-start-count-sum.js";
+const isNullishParameterCheck = (test, parameterName) => {
+    if (!t.isBinaryExpression(test, { operator: "==" }))
+        return false;
+    const { left, right } = test;
+    return ((t.isIdentifier(left, { name: parameterName }) && t.isNullLiteral(right)) ||
+        (t.isIdentifier(right, { name: parameterName }) && t.isNullLiteral(left)));
+};
+export const getRangeParameterNames = (path) => {
+    const { params, body } = path.node;
+    if (!t.isBlockStatement(body))
+        return undefined;
+    const startParameter = params[0];
+    const countParameter = params[1];
+    if (!startParameter || !countParameter)
+        return undefined;
+    if (!t.isIdentifier(startParameter))
+        return undefined;
+    if (!t.isIdentifier(countParameter))
+        return undefined;
+    const firstStatement = getFirstNonDirectiveStatement(body);
+    if (!firstStatement || !t.isIfStatement(firstStatement))
+        return undefined;
+    if (firstStatement.alternate)
+        return undefined;
+    if (!isNullishParameterCheck(firstStatement.test, countParameter.name)) {
+        return undefined;
+    }
+    const assignments = getRangeParameterDefaultAssignments(firstStatement.consequent);
+    if (!assignments)
+        return undefined;
+    const [firstAssignment, secondAssignment] = assignments;
+    if (!t.isIdentifier(firstAssignment.left, { name: countParameter.name }) ||
+        !t.isIdentifier(firstAssignment.right, { name: startParameter.name })) {
+        return undefined;
+    }
+    if (!t.isIdentifier(secondAssignment.left, { name: startParameter.name }) ||
+        !t.isNumericLiteral(secondAssignment.right, { value: 0 })) {
+        return undefined;
+    }
+    if (!hasCountNonPositiveGuard(path, countParameter.name))
+        return undefined;
+    if (!hasStartCountSum(path, startParameter.name, countParameter.name)) {
+        return undefined;
+    }
+    return {
+        startName: startParameter.name,
+        countName: countParameter.name,
+    };
+};

package/dist/transforms/rename-range-parameters/has-count-non-positive-guard.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+export declare const hasCountNonPositiveGuard: (path: NodePath<BabelFunction>, countName: string) => boolean;

package/dist/transforms/rename-range-parameters/has-count-non-positive-guard.js

@@ -0,0 +1,49 @@
+import * as t from "@babel/types";
+const isEarlyExit = (statement) => {
+    if (t.isReturnStatement(statement))
+        return true;
+    if (t.isThrowStatement(statement))
+        return true;
+    if (!t.isBlockStatement(statement))
+        return false;
+    for (const innerStatement of statement.body) {
+        if (t.isEmptyStatement(innerStatement))
+            continue;
+        return isEarlyExit(innerStatement);
+    }
+    return false;
+};
+export const hasCountNonPositiveGuard = (path, countName) => {
+    const countBinding = path.scope.getBinding(countName);
+    if (!countBinding)
+        return false;
+    let hasGuard = false;
+    path.traverse({
+        Function(innerPath) {
+            innerPath.skip();
+        },
+        IfStatement(innerPath) {
+            if (innerPath.node.alternate)
+                return;
+            if (!isEarlyExit(innerPath.node.consequent))
+                return;
+            const test = innerPath.node.test;
+            if (!t.isBinaryExpression(test))
+                return;
+            const { left, right, operator } = test;
+            const hasCountLteZero = operator === "<=" &&
+                t.isIdentifier(left, { name: countName }) &&
+                t.isNumericLiteral(right, { value: 0 }) &&
+                innerPath.scope.getBinding(countName) === countBinding;
+            const hasZeroGteCount = operator === ">=" &&
+                t.isNumericLiteral(left, { value: 0 }) &&
+                t.isIdentifier(right, { name: countName }) &&
+                innerPath.scope.getBinding(countName) === countBinding;
+            if (hasCountLteZero || hasZeroGteCount) {
+                hasGuard = true;
+                innerPath.stop();
+            }
+        },
+    });
+    return hasGuard;
+};

package/dist/transforms/rename-range-parameters/has-start-count-sum.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+export declare const hasStartCountSum: (path: NodePath<BabelFunction>, startName: string, countName: string) => boolean;

package/dist/transforms/rename-range-parameters/has-start-count-sum.js

@@ -0,0 +1,55 @@
+import * as t from "@babel/types";
+export const hasStartCountSum = (path, startName, countName) => {
+    const startBinding = path.scope.getBinding(startName);
+    const countBinding = path.scope.getBinding(countName);
+    if (!startBinding || !countBinding)
+        return false;
+    const isStartCountSumExpression = (expression, scope) => {
+        if (!t.isBinaryExpression(expression, { operator: "+" }))
+            return false;
+        const { left, right } = expression;
+        const leftIsStart = t.isIdentifier(left, { name: startName }) &&
+            scope.getBinding(startName) === startBinding;
+        const leftIsCount = t.isIdentifier(left, { name: countName }) &&
+            scope.getBinding(countName) === countBinding;
+        const rightIsStart = t.isIdentifier(right, { name: startName }) &&
+            scope.getBinding(startName) === startBinding;
+        const rightIsCount = t.isIdentifier(right, { name: countName }) &&
+            scope.getBinding(countName) === countBinding;
+        return (leftIsStart && rightIsCount) || (leftIsCount && rightIsStart);
+    };
+    let hasSum = false;
+    path.traverse({
+        Function(innerPath) {
+            innerPath.skip();
+        },
+        VariableDeclarator(innerPath) {
+            const init = innerPath.node.init;
+            if (!init)
+                return;
+            if (!isStartCountSumExpression(init, innerPath.scope))
+                return;
+            hasSum = true;
+            innerPath.stop();
+        },
+        AssignmentExpression(innerPath) {
+            if (innerPath.node.operator !== "=")
+                return;
+            if (!isStartCountSumExpression(innerPath.node.right, innerPath.scope)) {
+                return;
+            }
+            hasSum = true;
+            innerPath.stop();
+        },
+        ReturnStatement(innerPath) {
+            const argument = innerPath.node.argument;
+            if (!argument)
+                return;
+            if (!isStartCountSumExpression(argument, innerPath.scope))
+                return;
+            hasSum = true;
+            innerPath.stop();
+        },
+    });
+    return hasSum;
+};

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

@@ -0,0 +1,7 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true,
+    "evaluatedAt": "2026-01-25T09:40:26.000Z",
+    "notes": "Renames range-style parameters when the count defaults to the start value and start resets to 0.",
+    "changedLines": 0
+}

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

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

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

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { getRangeParameterNames } from "./get-range-parameter-names.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const START_BASE_NAME = "start";
+const COUNT_BASE_NAME = "count";
+export const renameRangeParametersTransform = {
+    id: "rename-range-parameters",
+    description: "Renames optional range parameters to stable $start/$count based on nullish count defaults",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const rangeParameters = getRangeParameterNames(path);
+                    if (!rangeParameters)
+                        return;
+                    const { startName, countName } = rangeParameters;
+                    if (!isStableRenamed(startName)) {
+                        group.add({
+                            scope: path.scope,
+                            currentName: startName,
+                            baseName: START_BASE_NAME,
+                        });
+                    }
+                    if (!isStableRenamed(countName)) {
+                        group.add({
+                            scope: path.scope,
+                            currentName: countName,
+                            baseName: COUNT_BASE_NAME,
+                        });
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/dist/transforms/rename-safe-property-accessor-parameters/get-return-expression.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Expression, Function as BabelFunction } from "@babel/types";
+export declare const getReturnExpression: (path: NodePath<BabelFunction>) => Expression | undefined;

package/dist/transforms/rename-safe-property-accessor-parameters/get-return-expression.js

@@ -0,0 +1,21 @@
+export const getReturnExpression = (path) => {
+    const body = path.get("body");
+    if (body.isBlockStatement()) {
+        const statements = body.get("body");
+        if (statements.length !== 1)
+            return;
+        const [statement] = statements;
+        if (!statement)
+            return;
+        if (!statement.isReturnStatement())
+            return;
+        const argument = statement.get("argument");
+        if (!argument.isExpression())
+            return;
+        return argument.node;
+    }
+    if (body.isExpression()) {
+        return body.node;
+    }
+    return;
+};

package/dist/transforms/rename-safe-property-accessor-parameters/get-returned-function.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+export declare const getReturnedFunction: (path: NodePath<BabelFunction>) => NodePath<BabelFunction> | undefined;

package/dist/transforms/rename-safe-property-accessor-parameters/get-returned-function.js

@@ -0,0 +1,22 @@
+export const getReturnedFunction = (path) => {
+    const body = path.get("body");
+    if (body.isBlockStatement()) {
+        const statements = body.get("body");
+        if (statements.length !== 1)
+            return;
+        const [statement] = statements;
+        if (!statement)
+            return;
+        if (!statement.isReturnStatement())
+            return;
+        const argument = statement.get("argument");
+        if (!argument.isFunctionExpression() &&
+            !argument.isArrowFunctionExpression())
+            return;
+        return argument;
+    }
+    if (body.isFunctionExpression() || body.isArrowFunctionExpression()) {
+        return body;
+    }
+    return;
+};

package/dist/transforms/rename-safe-property-accessor-parameters/is-member-access.d.ts

@@ -0,0 +1,2 @@
+import type { Expression, MemberExpression } from "@babel/types";
+export declare const isMemberAccess: (value: Expression, objectName: string, keyName: string) => value is MemberExpression;

package/dist/transforms/rename-safe-property-accessor-parameters/is-member-access.js

@@ -0,0 +1,24 @@
+import { unwrapParentheses } from "./unwrap-parentheses.js";
+export const isMemberAccess = (value, objectName, keyName) => {
+    if (value.type !== "MemberExpression")
+        return false;
+    if (!value.computed)
+        return false;
+    const object = value.object;
+    if (object.type === "Super")
+        return false;
+    const unwrappedObject = unwrapParentheses(object);
+    if (unwrappedObject.type !== "Identifier")
+        return false;
+    if (unwrappedObject.name !== objectName)
+        return false;
+    const property = value.property;
+    if (property.type === "PrivateName")
+        return false;
+    const unwrappedProperty = unwrapParentheses(property);
+    if (unwrappedProperty.type !== "Identifier")
+        return false;
+    if (unwrappedProperty.name !== keyName)
+        return false;
+    return true;
+};

package/dist/transforms/rename-safe-property-accessor-parameters/is-nullish-check.d.ts

@@ -0,0 +1,4 @@
+import type { NodePath } from "@babel/traverse";
+import type { Expression, Function as BabelFunction } from "@babel/types";
+export declare const isUndefinedExpression: (expression: Expression, path: NodePath<BabelFunction>) => boolean;
+export declare const isNullishCheck: (test: Expression, identifierName: string, path: NodePath<BabelFunction>) => boolean;

package/dist/transforms/rename-safe-property-accessor-parameters/is-nullish-check.js

@@ -0,0 +1,74 @@
+import { unwrapParentheses } from "./unwrap-parentheses.js";
+const hasLocalBinding = (path, name) => path.scope.hasBinding(name, { noGlobals: true, noUids: true });
+export const isUndefinedExpression = (expression, path) => {
+    const unwrapped = unwrapParentheses(expression);
+    if (unwrapped.type === "Identifier" &&
+        unwrapped.name === "undefined" &&
+        !hasLocalBinding(path, "undefined")) {
+        return true;
+    }
+    if (unwrapped.type === "UnaryExpression" && unwrapped.operator === "void") {
+        const argument = unwrapParentheses(unwrapped.argument);
+        return argument.type === "NumericLiteral" && argument.value === 0;
+    }
+    return false;
+};
+const noCoverage = {
+    coversNull: false,
+    coversUndefined: false,
+};
+const mergeCoverage = (left, right) => {
+    return {
+        coversNull: left.coversNull || right.coversNull,
+        coversUndefined: left.coversUndefined || right.coversUndefined,
+    };
+};
+const getNullishCoverage = (test, identifierName, path) => {
+    const unwrapped = unwrapParentheses(test);
+    if (unwrapped.type === "BinaryExpression") {
+        if (unwrapped.operator !== "==" && unwrapped.operator !== "===") {
+            return noCoverage;
+        }
+        const getValueCoverage = (value) => {
+            if (value.type === "PrivateName")
+                return noCoverage;
+            const unwrappedValue = unwrapParentheses(value);
+            if (unwrappedValue.type === "NullLiteral") {
+                return unwrapped.operator === "=="
+                    ? { coversNull: true, coversUndefined: true }
+                    : { coversNull: true, coversUndefined: false };
+            }
+            if (isUndefinedExpression(unwrappedValue, path)) {
+                return unwrapped.operator === "=="
+                    ? { coversNull: true, coversUndefined: true }
+                    : { coversNull: false, coversUndefined: true };
+            }
+            return noCoverage;
+        };
+        const left = unwrapped.left;
+        const right = unwrapped.right;
+        if (left.type === "Identifier" && left.name === identifierName) {
+            return getValueCoverage(right);
+        }
+        if (right.type === "Identifier" && right.name === identifierName) {
+            return getValueCoverage(left);
+        }
+        return noCoverage;
+    }
+    if (unwrapped.type === "LogicalExpression" && unwrapped.operator === "||") {
+        const leftCoverage = getNullishCoverage(unwrapped.left, identifierName, path);
+        if (!leftCoverage.coversNull && !leftCoverage.coversUndefined) {
+            return noCoverage;
+        }
+        const rightCoverage = getNullishCoverage(unwrapped.right, identifierName, path);
+        if (!rightCoverage.coversNull && !rightCoverage.coversUndefined) {
+            return noCoverage;
+        }
+        return mergeCoverage(leftCoverage, rightCoverage);
+    }
+    return noCoverage;
+};
+export const isNullishCheck = (test, identifierName, path) => {
+    const coverage = getNullishCoverage(test, identifierName, path);
+    return coverage.coversNull && coverage.coversUndefined;
+};

package/dist/transforms/rename-safe-property-accessor-parameters/manifest.json

@@ -0,0 +1,7 @@
+{
+    "diffReductionImpact": -0.000018848364904400228,
+    "recommended": false,
+    "evaluatedAt": "2026-01-25T10:04:22.417Z",
+    "notes": "Negative diff reduction in evaluation; keep optional.",
+    "changedLines": 0
+}

package/dist/transforms/rename-safe-property-accessor-parameters/match-safe-property-accessor-factory.d.ts

@@ -0,0 +1,9 @@
+import type { NodePath } from "@babel/traverse";
+import type { Function as BabelFunction } from "@babel/types";
+type SafePropertyAccessorFactoryMatch = {
+    outerParameterName: string;
+    innerParameterName: string;
+    innerPath: NodePath<BabelFunction>;
+};
+declare const matchSafePropertyAccessorFactory: (outerPath: NodePath<BabelFunction>) => SafePropertyAccessorFactoryMatch | undefined;
+export { matchSafePropertyAccessorFactory };

package/dist/transforms/rename-safe-property-accessor-parameters/match-safe-property-accessor-factory.js

@@ -0,0 +1,44 @@
+import { getReturnExpression } from "./get-return-expression.js";
+import { getReturnedFunction } from "./get-returned-function.js";
+import { isMemberAccess } from "./is-member-access.js";
+import { isNullishCheck, isUndefinedExpression } from "./is-nullish-check.js";
+import { unwrapParentheses } from "./unwrap-parentheses.js";
+const matchSafePropertyAccessorFactory = (outerPath) => {
+    const parameters = outerPath.node.params;
+    if (parameters.length !== 1)
+        return;
+    const outerParameter = parameters[0];
+    if (outerParameter?.type !== "Identifier")
+        return;
+    const innerPath = getReturnedFunction(outerPath);
+    if (!innerPath)
+        return;
+    const innerParameters = innerPath.node.params;
+    if (innerParameters.length !== 1)
+        return;
+    const innerParameter = innerParameters[0];
+    if (innerParameter?.type !== "Identifier")
+        return;
+    if (innerParameter.name === outerParameter.name)
+        return;
+    const returnExpression = getReturnExpression(innerPath);
+    if (!returnExpression)
+        return;
+    const unwrappedReturnExpression = unwrapParentheses(returnExpression);
+    if (unwrappedReturnExpression.type !== "ConditionalExpression")
+        return;
+    if (!isNullishCheck(unwrappedReturnExpression.test, outerParameter.name, innerPath))
+        return;
+    if (!isUndefinedExpression(unwrappedReturnExpression.consequent, innerPath))
+        return;
+    const alternate = unwrapParentheses(unwrappedReturnExpression.alternate);
+    if (!isMemberAccess(alternate, outerParameter.name, innerParameter.name)) {
+        return;
+    }
+    return {
+        outerParameterName: outerParameter.name,
+        innerParameterName: innerParameter.name,
+        innerPath,
+    };
+};
+export { matchSafePropertyAccessorFactory };

package/dist/transforms/rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.d.ts

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

package/dist/transforms/rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js

@@ -0,0 +1,56 @@
+import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+import { matchSafePropertyAccessorFactory } from "./match-safe-property-accessor-factory.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const OBJECT_BASE_NAME = "object";
+const KEY_BASE_NAME = "key";
+const renameSafePropertyAccessorParametersTransform = {
+    id: "rename-safe-property-accessor-parameters",
+    description: "Renames parameters in safe property accessor factories to $object/$key",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                Function(path) {
+                    nodesVisited++;
+                    const match = matchSafePropertyAccessorFactory(path);
+                    if (!match)
+                        return;
+                    const outerBinding = path.scope.getBinding(match.outerParameterName);
+                    if (!outerBinding?.constant)
+                        return;
+                    const innerBinding = match.innerPath.scope.getBinding(match.innerParameterName);
+                    if (!innerBinding?.constant)
+                        return;
+                    if (!isStableRenamed(match.innerParameterName)) {
+                        group.add({
+                            scope: match.innerPath.scope,
+                            currentName: match.innerParameterName,
+                            baseName: KEY_BASE_NAME,
+                        });
+                    }
+                    if (!isStableRenamed(match.outerParameterName)) {
+                        group.add({
+                            scope: path.scope,
+                            currentName: match.outerParameterName,
+                            baseName: OBJECT_BASE_NAME,
+                        });
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+export { renameSafePropertyAccessorParametersTransform };

package/dist/transforms/rename-safe-property-accessor-parameters/unwrap-parentheses.d.ts

@@ -0,0 +1,2 @@
+import type { Expression } from "@babel/types";
+export declare const unwrapParentheses: (expression: Expression) => Expression;

package/dist/transforms/rename-safe-property-accessor-parameters/unwrap-parentheses.js

@@ -0,0 +1,7 @@
+export const unwrapParentheses = (expression) => {
+    let unwrapped = expression;
+    while (unwrapped.type === "ParenthesizedExpression") {
+        unwrapped = unwrapped.expression;
+    }
+    return unwrapped;
+};

package/package.json

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