miniread 1.117.0 → 1.118.0

package/README.md

@@ -109,6 +109,22 @@ Development workflow/tooling documentation lives under `development-workflows/`:
 - `development-workflows/improve-transform-performance.md` — runtime performance optimization workflow
 - `development-workflows/improve-transform-coverage.md` — coverage improvement workflow
 
+When you update transforms and want fresh recommended preset metrics, rerun the
+recommended-preset evaluation:
+
+```bash
+pnpm run miniread-evaluate -- --compare claude-code-2.1.10:claude-code-2.1.11 --baseline none --test recommended --update-manifest
+```
+
+This updates `src/transforms/preset-stats.json` (look for
+`Updated preset-stats.json` in CLI output).
+
+Optional verification:
+
+```bash
+git diff -- src/transforms/preset-stats.json
+```
+
 ## License
 
 MIT

package/dist/transforms/preset-stats.json

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

package/dist/transforms-by-id/rename-add-event-listener-parameters/is-add-event-listener-key.d.ts

@@ -1,3 +1,3 @@
 import type { NodePath } from "@babel/traverse";
-import type { ObjectMethod, ObjectProperty } from "@babel/types";
-export declare const isAddEventListenerKey: (path: NodePath<ObjectMethod | ObjectProperty>) => boolean;
+import type { ClassMethod, ClassProperty, ObjectMethod, ObjectProperty } from "@babel/types";
+export declare const isAddEventListenerKey: (path: NodePath<ClassMethod | ClassProperty | ObjectMethod | ObjectProperty>) => boolean;

package/dist/transforms-by-id/rename-add-event-listener-parameters/manifest.json

@@ -2,9 +2,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-10T06:04:51.282Z",
-            "changedLines": 36,
-            "durationSeconds": 29.137589833,
+            "evaluatedAt": "2026-02-21T17:39:30.353Z",
+            "changedLines": 44,
+            "durationSeconds": 145.734591643,
             "stableNames": 1359
         }
     },

package/dist/transforms-by-id/rename-add-event-listener-parameters/rename-add-event-listener-parameters-transform.js

@@ -67,6 +67,24 @@ export const renameAddEventListenerParametersTransform = {
         for (const fileInfo of getFilesToProcess(context)) {
             const group = new RenameGroup();
             traverse(fileInfo.ast, {
+                ClassMethod(path) {
+                    nodesVisited++;
+                    if (!isAddEventListenerKey(path))
+                        return;
+                    collectAddEventListenerRename(path, group);
+                },
+                ClassProperty(path) {
+                    nodesVisited++;
+                    if (!isAddEventListenerKey(path))
+                        return;
+                    const valuePath = path.get("value");
+                    if (valuePath.isFunctionExpression()) {
+                        collectAddEventListenerRename(valuePath, group);
+                    }
+                    else if (valuePath.isArrowFunctionExpression()) {
+                        collectAddEventListenerRename(valuePath, group);
+                    }
+                },
                 ObjectMethod(path) {
                     nodesVisited++;
                     if (!isAddEventListenerKey(path))

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

@@ -1,14 +1,14 @@
 {
-    "recommended": true,
-    "recommendedOrder": 100,
     "notes": "Auto-added by evaluation script.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.92083686740175,
-            "evaluatedAt": "2026-02-07T21:14:17.031Z",
-            "changedLines": 7138,
-            "durationSeconds": 150.31010159399997,
+            "diffSizePercent": 99.91495634425672,
+            "evaluatedAt": "2026-02-21T18:42:32.506Z",
+            "changedLines": 8006,
+            "durationSeconds": 57.912832917,
             "stableNames": 1359
         }
-    }
+    },
+    "recommended": true,
+    "recommendedOrder": 100
 }

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

@@ -1,16 +1,23 @@
 import { createRequire } from "node:module";
+import { getBindingIdentifiers, isIdentifier } from "@babel/types";
 import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
+import { renamePromiseCatchParametersTransform } from "../rename-promise-catch-parameters/rename-promise-catch-parameters-transform.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 = "caughtError";
+const getCatchParameterBindingIdentifiers = (parameter) => {
+    if (isIdentifier(parameter))
+        return [parameter];
+    return Object.values(getBindingIdentifiers(parameter));
+};
 export const renameCatchParametersTransform = {
     id: "rename-catch-parameters",
     description: "Renames catch clause parameters to $caughtError/$caughtError2/...",
     scope: "file",
     parallelizable: true,
-    transform(context) {
+    async transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
@@ -21,24 +28,26 @@ export const renameCatchParametersTransform = {
                     const parameter = path.node.param;
                     if (!parameter)
                         return;
-                    if (parameter.type !== "Identifier")
-                        return;
-                    const currentName = parameter.name;
-                    // Skip already-stable names
-                    if (isStableRenamed(currentName))
-                        return;
-                    group.add({
-                        scope: path.scope,
-                        currentName,
-                        baseName: BASE_NAME,
-                    });
+                    const parameterIdentifiers = getCatchParameterBindingIdentifiers(parameter);
+                    for (const parameterIdentifier of parameterIdentifiers) {
+                        const currentName = parameterIdentifier.name;
+                        // Skip already-stable names
+                        if (isStableRenamed(currentName))
+                            continue;
+                        group.add({
+                            scope: path.scope,
+                            currentName,
+                            baseName: BASE_NAME,
+                        });
+                    }
                 },
             });
             transformationsApplied += group.apply();
         }
-        return Promise.resolve({
-            nodesVisited,
-            transformationsApplied,
-        });
+        const promiseCatchStats = await renamePromiseCatchParametersTransform.transform(context);
+        return {
+            nodesVisited: nodesVisited + promiseCatchStats.nodesVisited,
+            transformationsApplied: transformationsApplied + promiseCatchStats.transformationsApplied,
+        };
     },
 };

package/dist/transforms-by-id/rename-comparison-flags-v2/get-comparison-flag-base-name.d.ts

@@ -0,0 +1,6 @@
+import type { Binding } from "@babel/traverse";
+import type { Expression } from "@babel/types";
+export declare const getComparisonFlagBaseName: (options: {
+    binding: Binding;
+    init: Expression;
+}) => string | undefined;

package/dist/transforms-by-id/rename-comparison-flags-v2/get-comparison-flag-base-name.js

@@ -0,0 +1,93 @@
+import { getStringComparisonDetails, } from "./get-string-comparison-details.js";
+const toCapitalizedComparisonValue = (stringValue) => {
+    const parts = stringValue.split(/[^\dA-Za-z]+/u).filter(Boolean);
+    if (parts.length === 0) {
+        return stringValue === "" ? "EmptyString" : "Flag";
+    }
+    return parts
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join("");
+};
+const getSpecificComparisonBaseName = (comparison) => {
+    const capitalizedValue = toCapitalizedComparisonValue(comparison.stringValue);
+    switch (comparison.operator) {
+        case "===": {
+            return `is${capitalizedValue}`;
+        }
+        case "!==": {
+            return `isNot${capitalizedValue}`;
+        }
+        case "==": {
+            return `equals${capitalizedValue}`;
+        }
+        case "!=": {
+            return `notEquals${capitalizedValue}`;
+        }
+    }
+};
+const collectComparisonWrites = (binding, initialComparison) => {
+    const comparisonWrites = [initialComparison];
+    if (binding.constant) {
+        return comparisonWrites;
+    }
+    for (const violationPath of binding.constantViolations) {
+        if (!violationPath.isAssignmentExpression()) {
+            return undefined;
+        }
+        const assignment = violationPath.node;
+        if (assignment.operator !== "=" ||
+            assignment.left.type !== "Identifier" ||
+            assignment.left.name !== binding.identifier.name) {
+            return undefined;
+        }
+        const reassignmentComparison = getStringComparisonDetails(assignment.right);
+        if (!reassignmentComparison) {
+            return undefined;
+        }
+        comparisonWrites.push(reassignmentComparison);
+    }
+    return comparisonWrites;
+};
+const getBaseNameForComparisonWrites = (comparisonWrites) => {
+    const firstWrite = comparisonWrites[0];
+    if (!firstWrite) {
+        return undefined;
+    }
+    if (comparisonWrites.every((comparison) => comparison.operator === firstWrite.operator &&
+        comparison.stringValue === firstWrite.stringValue)) {
+        // Keep name derivation aligned with rename-comparison-flags so v1/v2
+        // produce identical flag names for equivalent comparisons.
+        return getSpecificComparisonBaseName(firstWrite);
+    }
+    const allEqualityComparisons = comparisonWrites.every((comparison) => comparison.operator === "===" || comparison.operator === "==");
+    const allInequalityComparisons = comparisonWrites.every((comparison) => comparison.operator === "!==" || comparison.operator === "!=");
+    if (!allEqualityComparisons && !allInequalityComparisons) {
+        return undefined;
+    }
+    const singleStringValue = comparisonWrites.every((comparison) => comparison.stringValue === firstWrite.stringValue);
+    if (singleStringValue) {
+        const capitalizedValue = toCapitalizedComparisonValue(firstWrite.stringValue);
+        if (allEqualityComparisons) {
+            return `matches${capitalizedValue}`;
+        }
+        return `doesNotMatch${capitalizedValue}`;
+    }
+    if (allEqualityComparisons) {
+        return "matchesString";
+    }
+    return "doesNotMatchString";
+};
+export const getComparisonFlagBaseName = (options) => {
+    const { binding, init } = options;
+    const comparisonDetails = getStringComparisonDetails(init);
+    if (!comparisonDetails) {
+        return undefined;
+    }
+    if (binding.constant) {
+        return getSpecificComparisonBaseName(comparisonDetails);
+    }
+    const comparisonWrites = collectComparisonWrites(binding, comparisonDetails);
+    return comparisonWrites
+        ? (getBaseNameForComparisonWrites(comparisonWrites) ?? "comparisonResult")
+        : "comparisonResult";
+};

package/dist/transforms-by-id/rename-comparison-flags-v2/get-string-comparison-details.d.ts

@@ -0,0 +1,7 @@
+import type { Expression } from "@babel/types";
+export type ComparisonOperator = "===" | "!==" | "==" | "!=";
+export type StringComparisonDetails = {
+    operator: ComparisonOperator;
+    stringValue: string;
+};
+export declare const getStringComparisonDetails: (expression: Expression) => StringComparisonDetails | undefined;

package/dist/transforms-by-id/rename-comparison-flags-v2/get-string-comparison-details.js

@@ -0,0 +1,37 @@
+const isSupportedComparisonSide = (expression) => {
+    if (expression.type === "PrivateName") {
+        return false;
+    }
+    if (expression.type === "TemplateLiteral") {
+        return expression.expressions.length > 0;
+    }
+    if (expression.type.endsWith("Literal")) {
+        return false;
+    }
+    return true;
+};
+export const getStringComparisonDetails = (expression) => {
+    if (expression.type !== "BinaryExpression") {
+        return undefined;
+    }
+    const operator = expression.operator;
+    if (operator !== "===" &&
+        operator !== "!==" &&
+        operator !== "==" &&
+        operator !== "!=") {
+        return undefined;
+    }
+    const leftValue = expression.left.type === "StringLiteral"
+        ? expression.left.value
+        : undefined;
+    const rightValue = expression.right.type === "StringLiteral"
+        ? expression.right.value
+        : undefined;
+    if (leftValue !== undefined && isSupportedComparisonSide(expression.right)) {
+        return { operator, stringValue: leftValue };
+    }
+    if (rightValue !== undefined && isSupportedComparisonSide(expression.left)) {
+        return { operator, stringValue: rightValue };
+    }
+    return undefined;
+};

package/dist/transforms-by-id/rename-comparison-flags-v2/manifest.json

@@ -2,11 +2,11 @@
     "notes": "Supersedes rename-comparison-flags in the recommended preset and extends comparison flag renaming to member expressions like 'client.config.type === \"sse\"'.",
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
-            "diffSizePercent": 99.98869098105739,
-            "evaluatedAt": "2026-02-09T14:01:54.339Z",
-            "changedLines": 550,
-            "durationSeconds": 240.26302797699998,
-            "stableNames": 1416
+            "diffSizePercent": 99.98299126885134,
+            "evaluatedAt": "2026-02-21T18:28:53.452Z",
+            "changedLines": 810,
+            "durationSeconds": 41.915363875,
+            "stableNames": 1429
         }
     },
     "recommended": true,

package/dist/transforms-by-id/rename-comparison-flags-v2/rename-comparison-flags-v2-transform.js

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { RenameGroup, isStableRenamed } from "../../core/stable-naming.js";
 import { getFilesToProcess } from "../../core/types.js";
+import { getComparisonFlagBaseName } from "./get-comparison-flag-base-name.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
@@ -21,86 +22,18 @@ export const renameComparisonFlagsV2Transform = {
                     if (!init || id.type !== "Identifier") {
                         return;
                     }
-                    if (init.type !== "BinaryExpression" ||
-                        (init.operator !== "===" &&
-                            init.operator !== "!==" &&
-                            init.operator !== "==" &&
-                            init.operator !== "!=")) {
-                        return;
-                    }
-                    let stringValue;
-                    let otherSide;
-                    if (init.left.type === "StringLiteral") {
-                        stringValue = init.left.value;
-                        otherSide = init.right;
-                    }
-                    else if (init.right.type === "StringLiteral") {
-                        stringValue = init.right.value;
-                        otherSide = init.left;
-                    }
-                    if (!otherSide || stringValue === undefined) {
-                        return;
-                    }
-                    let isSupportedComparisonSide = false;
-                    if (otherSide.type === "Identifier") {
-                        isSupportedComparisonSide = true;
-                    }
-                    else if (otherSide.type === "MemberExpression" ||
-                        otherSide.type === "OptionalMemberExpression") {
-                        const hasLiteralComputedProperty = otherSide.computed &&
-                            (otherSide.property.type === "StringLiteral" ||
-                                otherSide.property.type === "NumericLiteral");
-                        isSupportedComparisonSide =
-                            // Allow dot access and literal bracket access (e.g. obj["type"]).
-                            !otherSide.computed || hasLiteralComputedProperty;
-                    }
-                    // Also excludes constant string-vs-string comparisons (e.g. "a" === "b"),
-                    // which are not variable flag checks.
-                    if (!isSupportedComparisonSide) {
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName)) {
                         return;
                     }
-                    const currentName = id.name;
                     const binding = path.scope.getBinding(currentName);
-                    // Prefer high-certainty names over wider coverage: non-constant flags
-                    // can later hold unrelated values, making semantic renames misleading.
-                    if (!binding?.constant) {
+                    if (!binding) {
                         return;
                     }
-                    if (isStableRenamed(currentName)) {
+                    const baseName = getComparisonFlagBaseName({ binding, init });
+                    if (!baseName) {
                         return;
                     }
-                    const operator = init.operator;
-                    // Keep name derivation aligned with rename-comparison-flags so v1/v2
-                    // produce identical flag names for equivalent comparisons.
-                    const parts = stringValue
-                        .split(/[^\dA-Za-z]+/u)
-                        .filter(Boolean);
-                    const capitalizedValue = parts.length === 0
-                        ? stringValue === ""
-                            ? "EmptyString"
-                            : "Flag"
-                        : parts
-                            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-                            .join("");
-                    let baseName;
-                    switch (operator) {
-                        case "===": {
-                            baseName = `is${capitalizedValue}`;
-                            break;
-                        }
-                        case "!==": {
-                            baseName = `isNot${capitalizedValue}`;
-                            break;
-                        }
-                        case "==": {
-                            baseName = `equals${capitalizedValue}`;
-                            break;
-                        }
-                        case "!=": {
-                            baseName = `notEquals${capitalizedValue}`;
-                            break;
-                        }
-                    }
                     renameGroup.add({
                         scope: binding.scope,
                         currentName,

package/dist/transforms-by-id/rename-promise-catch-parameters/get-function-callback-from-identifier.d.ts

@@ -0,0 +1,7 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, Identifier } from "@babel/types";
+type FunctionCallbackPath = NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>;
+type IdentifierPath = NodePath<Identifier>;
+type VisitedNames = Set<string>;
+export declare const getFunctionCallbackFromIdentifier: (argumentPath: IdentifierPath, callSiteStart?: number, visitedNames?: VisitedNames) => FunctionCallbackPath | undefined;
+export {};

package/dist/transforms-by-id/rename-promise-catch-parameters/get-function-callback-from-identifier.js

@@ -0,0 +1,78 @@
+import { unwrapExpressionPath } from "./unwrap-expression-path.js";
+const getFunctionCallbackFromAssignment = (assignmentPath, identifierName, callSiteStart, visitedNames) => {
+    if (assignmentPath.node.operator !== "=")
+        return;
+    const leftPath = assignmentPath.get("left");
+    if (Array.isArray(leftPath))
+        return;
+    if (!leftPath.isIdentifier({ name: identifierName }))
+        return;
+    const rightPath = assignmentPath.get("right");
+    if (Array.isArray(rightPath))
+        return;
+    const callbackPath = unwrapExpressionPath(rightPath);
+    if (!callbackPath)
+        return;
+    if (!callbackPath.isFunctionExpression() &&
+        !callbackPath.isArrowFunctionExpression()) {
+        if (!callbackPath.isIdentifier())
+            return;
+        return getFunctionCallbackFromIdentifier(callbackPath, callSiteStart, visitedNames);
+    }
+    return callbackPath;
+};
+const isIdentifierReassignment = (assignmentPath, identifierName) => {
+    if (assignmentPath.node.operator !== "=")
+        return false;
+    const leftPath = assignmentPath.get("left");
+    if (Array.isArray(leftPath))
+        return false;
+    return leftPath.isIdentifier({ name: identifierName });
+};
+export const getFunctionCallbackFromIdentifier = (argumentPath, callSiteStart, visitedNames = new Set()) => {
+    const identifierName = argumentPath.node.name;
+    if (visitedNames.has(identifierName))
+        return;
+    const nextVisitedNames = new Set(visitedNames);
+    nextVisitedNames.add(identifierName);
+    const binding = argumentPath.scope.getBinding(argumentPath.node.name);
+    if (!binding)
+        return;
+    const bindingPath = binding.path;
+    if (bindingPath.isFunctionDeclaration()) {
+        return bindingPath;
+    }
+    if (!bindingPath.isVariableDeclarator())
+        return;
+    const initPath = bindingPath.get("init");
+    if (Array.isArray(initPath))
+        return;
+    let candidateCallbackPath;
+    const initCallbackPath = unwrapExpressionPath(initPath);
+    if (initCallbackPath &&
+        (initCallbackPath.isFunctionExpression() ||
+            initCallbackPath.isArrowFunctionExpression())) {
+        const initStart = initCallbackPath.node.start;
+        if (typeof callSiteStart !== "number" ||
+            typeof initStart !== "number" ||
+            initStart < callSiteStart) {
+            candidateCallbackPath = initCallbackPath;
+        }
+    }
+    for (const violationPath of binding.constantViolations) {
+        if (!violationPath.isAssignmentExpression())
+            continue;
+        const violationStart = violationPath.node.start;
+        if (typeof callSiteStart === "number" &&
+            typeof violationStart === "number" &&
+            violationStart >= callSiteStart) {
+            continue;
+        }
+        if (!isIdentifierReassignment(violationPath, argumentPath.node.name)) {
+            continue;
+        }
+        const assignedCallbackPath = getFunctionCallbackFromAssignment(violationPath, argumentPath.node.name, violationStart ?? callSiteStart, nextVisitedNames);
+        candidateCallbackPath = assignedCallbackPath;
+    }
+    return candidateCallbackPath;
+};

package/dist/transforms-by-id/rename-promise-catch-parameters/get-promise-handler-callback-parameter-path.d.ts

@@ -0,0 +1,6 @@
+import type { NodePath } from "@babel/traverse";
+import type { CallExpression, Identifier, OptionalCallExpression } from "@babel/types";
+type IdentifierPath = NodePath<Identifier>;
+type CatchCallPath = NodePath<CallExpression> | NodePath<OptionalCallExpression>;
+export declare const getPromiseHandlerCallbackParameterPath: (path: CatchCallPath) => IdentifierPath | undefined;
+export {};

package/dist/transforms-by-id/rename-promise-catch-parameters/get-promise-handler-callback-parameter-path.js

@@ -0,0 +1,73 @@
+import { getFunctionCallbackFromIdentifier } from "./get-function-callback-from-identifier.js";
+import { getThisPropertyCallbackPath } from "./get-this-property-callback-path.js";
+import { unwrapExpressionPath } from "./unwrap-expression-path.js";
+const getPromiseHandlerName = (callee) => {
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") {
+        return;
+    }
+    const property = callee.property;
+    if (callee.computed) {
+        if (property.type !== "StringLiteral")
+            return;
+        if (property.value === "catch" || property.value === "then") {
+            return property.value;
+        }
+        return;
+    }
+    if (property.type !== "Identifier")
+        return;
+    if (property.name === "catch" || property.name === "then") {
+        return property.name;
+    }
+};
+const getFirstCallbackParameterPath = (callbackPath) => {
+    if (callbackPath.node.params.length === 0)
+        return;
+    const parameterPath = callbackPath.get("params.0");
+    if (Array.isArray(parameterPath))
+        return;
+    if (parameterPath.isIdentifier()) {
+        return parameterPath;
+    }
+    if (!parameterPath.isAssignmentPattern())
+        return;
+    const leftPath = parameterPath.get("left");
+    if (Array.isArray(leftPath))
+        return;
+    if (!leftPath.isIdentifier())
+        return;
+    return leftPath;
+};
+export const getPromiseHandlerCallbackParameterPath = (path) => {
+    const handlerName = getPromiseHandlerName(path.node.callee);
+    if (!handlerName)
+        return;
+    const argumentIndex = handlerName === "catch" ? 0 : 1;
+    const argument = path.node.arguments[argumentIndex];
+    if (!argument)
+        return;
+    const argumentPath = path.get(`arguments.${argumentIndex}`);
+    if (Array.isArray(argumentPath))
+        return;
+    const callbackPath = unwrapExpressionPath(argumentPath);
+    if (!callbackPath)
+        return;
+    if (callbackPath.isFunctionExpression() ||
+        callbackPath.isArrowFunctionExpression()) {
+        return getFirstCallbackParameterPath(callbackPath);
+    }
+    const callSiteStart = path.node.start ?? undefined;
+    if (callbackPath.isIdentifier()) {
+        const referencedCallbackPath = getFunctionCallbackFromIdentifier(callbackPath, callSiteStart);
+        if (!referencedCallbackPath)
+            return;
+        return getFirstCallbackParameterPath(referencedCallbackPath);
+    }
+    if (!callbackPath.isMemberExpression())
+        return;
+    const thisPropertyCallbackPath = getThisPropertyCallbackPath(callbackPath, callSiteStart);
+    if (!thisPropertyCallbackPath)
+        return;
+    return getFirstCallbackParameterPath(thisPropertyCallbackPath);
+};

package/dist/transforms-by-id/rename-promise-catch-parameters/get-this-property-callback-path.d.ts

@@ -0,0 +1,5 @@
+import type { NodePath } from "@babel/traverse";
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression, MemberExpression } from "@babel/types";
+type FunctionCallbackPath = NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>;
+export declare const getThisPropertyCallbackPath: (argumentPath: NodePath<MemberExpression>, callSiteStart?: number) => FunctionCallbackPath | undefined;
+export {};