gt 2.14.35 → 2.14.36

package/dist/react/jsx/utils/stringParsing/derivation/handleDerivation.js

@@ -1,595 +1,428 @@
-import * as t from '@babel/types';
-import { parseStringExpression, nodeToStrings } from '../../parseString.js';
-import { buildImportMap } from '../../buildImportMap.js';
-import { resolveImportPath } from '../../resolveImportPath.js';
-import { parse } from '@babel/parser';
-import fs from 'node:fs';
-import { warnFunctionNotFoundSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, warnAutoderiveNoResultsSync, } from '../../../../../console/index.js';
-import traverseModule from '@babel/traverse';
-import generateModule from '@babel/generator';
-import { isDeriveCall } from './isDeriveCall.js';
-// Handle CommonJS/ESM interop
+import { warnAutoderiveNoResultsSync, warnDeriveFunctionNoResultsSync, warnDeriveFunctionNotWrappedSync, warnFunctionNotFoundSync } from "../../../../../console/index.js";
+import { resolveImportPath } from "../../resolveImportPath.js";
+import { buildImportMap } from "../../buildImportMap.js";
+import { nodeToStrings, parseStringExpression } from "../../parseString.js";
+import { isDeriveCall } from "./isDeriveCall.js";
+import fs from "node:fs";
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import generateModule from "@babel/generator";
+import traverseModule from "@babel/traverse";
+//#region src/react/jsx/utils/stringParsing/derivation/handleDerivation.ts
 const traverse = traverseModule.default || traverseModule;
 const generate = generateModule.default || generateModule;
 /**
- * Cache for resolved import paths to avoid redundant I/O operations.
- * Key: `${currentFile}::${importPath}`
- * Value: resolved absolute path or null
- */
-const resolveImportPathCache = new Map();
+* Cache for resolved import paths to avoid redundant I/O operations.
+* Key: `${currentFile}::${importPath}`
+* Value: resolved absolute path or null
+*/
+const resolveImportPathCache = /* @__PURE__ */ new Map();
 /**
- * Cache for processed functions to avoid re-parsing the same files.
- * Key: `${filePath}::${functionName}`
- * Value: Node result or null
- */
-const processFunctionCache = new Map();
+* Cache for processed functions to avoid re-parsing the same files.
+* Key: `${filePath}::${functionName}`
+* Value: Node result or null
+*/
+const processFunctionCache = /* @__PURE__ */ new Map();
 /**
- * Extracts content if an expression is derivable (statically analyzable) or uses derive()
- * Returns a Node representing the parsed expression
- * @param expr - The expression to check
- * @param tPath - NodePath for scope resolution
- * @param file - Current file path
- * @param parsingOptions - Parsing configuration
- * @param errors - Errors to add to
- * @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
- * @param skipDeriveInvocation - If true, skip derive invocation check
- * @returns Node | null - The parsed node, or null if invalid
- *
- * @note runtimeInterpolationState
- *  - Only provide at entry for template macros, otherwise omit
- *  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
- *
- */
-export function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, skipDeriveInvocation, }) {
-    if (!expr) {
-        return null;
-    }
-    // Handle expressions
-    if (t.isCallExpression(expr)) {
-        if (isDeriveCall({ expr, tPath })) {
-            const variants = getDeriveVariants({
-                call: expr,
-                tPath,
-                file,
-                parsingOptions,
-                errors,
-                warnings,
-            });
-            if (variants) {
-                return {
-                    type: 'choice',
-                    nodes: variants.map((v) => ({ type: 'text', text: v })),
-                };
-            }
-            // derive() had no resolvable results
-            const code = expr.arguments.length > 0
-                ? generate(expr.arguments[0]).code
-                : 'no arguments';
-            errors.push(warnDeriveFunctionNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-            return null;
-        }
-        // Non-derive call
-        if (runtimeInterpolationState) {
-            return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };
-        }
-        const calleeName = t.isIdentifier(expr.callee)
-            ? expr.callee.name
-            : generate(expr.callee).code;
-        errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${expr.callee.loc?.start?.line}:${expr.callee.loc?.start?.column}`));
-        return null;
-    }
-    // Handle direct string literals
-    if (t.isStringLiteral(expr)) {
-        return { type: 'text', text: expr.value };
-    }
-    // Handle template literals
-    if (t.isTemplateLiteral(expr)) {
-        const parts = [];
-        for (let index = 0; index < expr.quasis.length; index++) {
-            const quasi = expr.quasis[index];
-            const text = quasi.value.cooked ?? quasi.value.raw ?? '';
-            if (text) {
-                parts.push({ type: 'text', text });
-            }
-            const exprNode = expr.expressions[index];
-            if (exprNode && t.isExpression(exprNode)) {
-                if (isDeriveCall({ expr: exprNode, tPath })) {
-                    // Derive — resolve fully (no runtime interpolation forwarding)
-                    const result = handleDerivation({
-                        expr: exprNode,
-                        tPath,
-                        file,
-                        parsingOptions,
-                        errors,
-                        warnings,
-                    });
-                    if (result === null)
-                        return null;
-                    parts.push(result);
-                }
-                else {
-                    // Non-derive — recurse with runtime interpolation forwarded
-                    const result = handleDerivation({
-                        expr: exprNode,
-                        tPath,
-                        file,
-                        parsingOptions,
-                        errors,
-                        warnings,
-                        runtimeInterpolationState,
-                        skipDeriveInvocation,
-                    });
-                    if (result === null)
-                        return null;
-                    parts.push(result);
-                }
-            }
-        }
-        if (parts.length === 0) {
-            return { type: 'text', text: '' };
-        }
-        if (parts.length === 1) {
-            return parts[0];
-        }
-        return { type: 'sequence', nodes: parts };
-    }
-    // Handle binary expressions
-    if (t.isBinaryExpression(expr) && expr.operator === '+') {
-        if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) {
-            return null;
-        }
-        const leftResult = handleDerivation({
-            expr: expr.left,
-            tPath,
-            file,
-            parsingOptions,
-            errors,
-            warnings,
-            runtimeInterpolationState,
-            skipDeriveInvocation,
-        });
-        const rightResult = handleDerivation({
-            expr: expr.right,
-            tPath,
-            file,
-            parsingOptions,
-            errors,
-            warnings,
-            runtimeInterpolationState,
-            skipDeriveInvocation,
-        });
-        if (leftResult === null || rightResult === null) {
-            return null;
-        }
-        return { type: 'sequence', nodes: [leftResult, rightResult] };
-    }
-    // Handle parenthesized expressions
-    if (t.isParenthesizedExpression(expr)) {
-        return handleDerivation({
-            expr: expr.expression,
-            tPath,
-            file,
-            parsingOptions,
-            errors,
-            warnings,
-            runtimeInterpolationState,
-            skipDeriveInvocation,
-        });
-    }
-    // Handle numeric literals by converting them to strings
-    if (t.isNumericLiteral(expr)) {
-        return { type: 'text', text: String(expr.value) };
-    }
-    // Handle unary expressions by converting them to strings
-    if (t.isUnaryExpression(expr)) {
-        let operator = '';
-        if (expr.operator === '-') {
-            operator = expr.operator;
-        }
-        if (t.isNumericLiteral(expr.argument)) {
-            if (expr.argument.value === 0) {
-                return { type: 'text', text: '0' };
-            }
-            else {
-                return {
-                    type: 'text',
-                    text: operator + expr.argument.value.toString(),
-                };
-            }
-        }
-        else {
-            // invalid
-            return null;
-        }
-    }
-    // Handle boolean literals by converting them to strings
-    if (t.isBooleanLiteral(expr)) {
-        return { type: 'text', text: String(expr.value) };
-    }
-    // Handle null literal
-    if (t.isNullLiteral(expr)) {
-        return { type: 'text', text: 'null' };
-    }
-    // Non-static expression
-    if (skipDeriveInvocation) {
-        // Skip pass a `derive()` invocation to do derivation
-        const variants = resolveCallStringVariants(expr, tPath, file, parsingOptions, errors, warnings);
-        if (variants) {
-            return {
-                type: 'choice',
-                nodes: variants.map((v) => ({ type: 'text', text: v })),
-            };
-        }
-        // Autoderive had no resolvable results
-        const code = generate(expr).code;
-        errors.push(warnAutoderiveNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
-        return null;
-    }
-    // Not a derivable expression
-    if (runtimeInterpolationState) {
-        return { type: 'text', text: `{${runtimeInterpolationState.index++}}` };
-    }
-    return null;
+* Extracts content if an expression is derivable (statically analyzable) or uses derive()
+* Returns a Node representing the parsed expression
+* @param expr - The expression to check
+* @param tPath - NodePath for scope resolution
+* @param file - Current file path
+* @param parsingOptions - Parsing configuration
+* @param errors - Errors to add to
+* @param runtimeInterpolationState - When provided, non-derive dynamic expressions become {n} placeholders instead of errors. Pass { index: 0 } at the entry point for template macros.
+* @param skipDeriveInvocation - If true, skip derive invocation check
+* @returns Node | null - The parsed node, or null if invalid
+*
+* @note runtimeInterpolationState
+*  - Only provide at entry for template macros, otherwise omit
+*  - t`Hello {nonDerivableValue}` -> t`Hello {0}`
+*
+*/
+function handleDerivation({ expr, tPath, file, parsingOptions, errors, warnings, runtimeInterpolationState, skipDeriveInvocation }) {
+	if (!expr) return null;
+	if (t.isCallExpression(expr)) {
+		if (isDeriveCall({
+			expr,
+			tPath
+		})) {
+			const variants = getDeriveVariants({
+				call: expr,
+				tPath,
+				file,
+				parsingOptions,
+				errors,
+				warnings
+			});
+			if (variants) return {
+				type: "choice",
+				nodes: variants.map((v) => ({
+					type: "text",
+					text: v
+				}))
+			};
+			const code = expr.arguments.length > 0 ? generate(expr.arguments[0]).code : "no arguments";
+			errors.push(warnDeriveFunctionNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+			return null;
+		}
+		if (runtimeInterpolationState) return {
+			type: "text",
+			text: `{${runtimeInterpolationState.index++}}`
+		};
+		const calleeName = t.isIdentifier(expr.callee) ? expr.callee.name : generate(expr.callee).code;
+		errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${expr.callee.loc?.start?.line}:${expr.callee.loc?.start?.column}`));
+		return null;
+	}
+	if (t.isStringLiteral(expr)) return {
+		type: "text",
+		text: expr.value
+	};
+	if (t.isTemplateLiteral(expr)) {
+		const parts = [];
+		for (let index = 0; index < expr.quasis.length; index++) {
+			const quasi = expr.quasis[index];
+			const text = quasi.value.cooked ?? quasi.value.raw ?? "";
+			if (text) parts.push({
+				type: "text",
+				text
+			});
+			const exprNode = expr.expressions[index];
+			if (exprNode && t.isExpression(exprNode)) if (isDeriveCall({
+				expr: exprNode,
+				tPath
+			})) {
+				const result = handleDerivation({
+					expr: exprNode,
+					tPath,
+					file,
+					parsingOptions,
+					errors,
+					warnings
+				});
+				if (result === null) return null;
+				parts.push(result);
+			} else {
+				const result = handleDerivation({
+					expr: exprNode,
+					tPath,
+					file,
+					parsingOptions,
+					errors,
+					warnings,
+					runtimeInterpolationState,
+					skipDeriveInvocation
+				});
+				if (result === null) return null;
+				parts.push(result);
+			}
+		}
+		if (parts.length === 0) return {
+			type: "text",
+			text: ""
+		};
+		if (parts.length === 1) return parts[0];
+		return {
+			type: "sequence",
+			nodes: parts
+		};
+	}
+	if (t.isBinaryExpression(expr) && expr.operator === "+") {
+		if (!t.isExpression(expr.left) || !t.isExpression(expr.right)) return null;
+		const leftResult = handleDerivation({
+			expr: expr.left,
+			tPath,
+			file,
+			parsingOptions,
+			errors,
+			warnings,
+			runtimeInterpolationState,
+			skipDeriveInvocation
+		});
+		const rightResult = handleDerivation({
+			expr: expr.right,
+			tPath,
+			file,
+			parsingOptions,
+			errors,
+			warnings,
+			runtimeInterpolationState,
+			skipDeriveInvocation
+		});
+		if (leftResult === null || rightResult === null) return null;
+		return {
+			type: "sequence",
+			nodes: [leftResult, rightResult]
+		};
+	}
+	if (t.isParenthesizedExpression(expr)) return handleDerivation({
+		expr: expr.expression,
+		tPath,
+		file,
+		parsingOptions,
+		errors,
+		warnings,
+		runtimeInterpolationState,
+		skipDeriveInvocation
+	});
+	if (t.isNumericLiteral(expr)) return {
+		type: "text",
+		text: String(expr.value)
+	};
+	if (t.isUnaryExpression(expr)) {
+		let operator = "";
+		if (expr.operator === "-") operator = expr.operator;
+		if (t.isNumericLiteral(expr.argument)) if (expr.argument.value === 0) return {
+			type: "text",
+			text: "0"
+		};
+		else return {
+			type: "text",
+			text: operator + expr.argument.value.toString()
+		};
+		else return null;
+	}
+	if (t.isBooleanLiteral(expr)) return {
+		type: "text",
+		text: String(expr.value)
+	};
+	if (t.isNullLiteral(expr)) return {
+		type: "text",
+		text: "null"
+	};
+	if (skipDeriveInvocation) {
+		const variants = resolveCallStringVariants(expr, tPath, file, parsingOptions, errors, warnings);
+		if (variants) return {
+			type: "choice",
+			nodes: variants.map((v) => ({
+				type: "text",
+				text: v
+			}))
+		};
+		const code = generate(expr).code;
+		errors.push(warnAutoderiveNoResultsSync(file, code, `${expr.loc?.start?.line}:${expr.loc?.start?.column}`));
+		return null;
+	}
+	if (runtimeInterpolationState) return {
+		type: "text",
+		text: `{${runtimeInterpolationState.index++}}`
+	};
+	return null;
 }
 /**
- * Given a CallExpression, if it is derive(<call>) or derive(await <call>),
- * return all possible string outcomes of that argument call as an array of strings.
- *
- * Examples:
- *   derive(time()) -> ["day", "night"]
- *   derive(await time()) -> ["day", "night"]
- *
- * Returns null if it can't be resolved.
- */
-function getDeriveVariants({ call, tPath, file, parsingOptions, errors, warnings, }) {
-    // --- Validate Callee --- //
-    // Must be a derive(...) call or an alias of it
-    if (!isDeriveCall({ expr: call, tPath })) {
-        const calleeName = t.isIdentifier(call.callee)
-            ? call.callee.name
-            : generate(call.callee).code;
-        errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
-        return null;
-    }
-    // --- Validate Arguments --- //
-    if (call.arguments.length !== 1)
-        return null;
-    const arg = call.arguments[0];
-    if (!t.isExpression(arg))
-        return null;
-    // Handle await expression: derive(await time())
-    if (t.isAwaitExpression(arg)) {
-        // Resolve the inner call's possible string outcomes
-        return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors, warnings);
-    }
-    // Handle call expression: derive(time())
-    if (t.isCallExpression(arg)) {
-        return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors, warnings);
-    }
-    // Handle other expressions (ternary, string literal, etc.) by recursing into handleDerivation
-    const node = handleDerivation({
-        expr: arg,
-        tPath,
-        file,
-        parsingOptions,
-        errors,
-        warnings,
-        skipDeriveInvocation: true,
-    });
-    if (node) {
-        return nodeToStrings(node);
-    }
-    return null;
+* Given a CallExpression, if it is derive(<call>) or derive(await <call>),
+* return all possible string outcomes of that argument call as an array of strings.
+*
+* Examples:
+*   derive(time()) -> ["day", "night"]
+*   derive(await time()) -> ["day", "night"]
+*
+* Returns null if it can't be resolved.
+*/
+function getDeriveVariants({ call, tPath, file, parsingOptions, errors, warnings }) {
+	if (!isDeriveCall({
+		expr: call,
+		tPath
+	})) {
+		const calleeName = t.isIdentifier(call.callee) ? call.callee.name : generate(call.callee).code;
+		errors.push(warnDeriveFunctionNotWrappedSync(file, calleeName, `${call.callee.loc?.start?.line}:${call.callee.loc?.start?.column}`));
+		return null;
+	}
+	if (call.arguments.length !== 1) return null;
+	const arg = call.arguments[0];
+	if (!t.isExpression(arg)) return null;
+	if (t.isAwaitExpression(arg)) return resolveCallStringVariants(arg.argument, tPath, file, parsingOptions, errors, warnings);
+	if (t.isCallExpression(arg)) return resolveCallStringVariants(arg, tPath, file, parsingOptions, errors, warnings);
+	const node = handleDerivation({
+		expr: arg,
+		tPath,
+		file,
+		parsingOptions,
+		errors,
+		warnings,
+		skipDeriveInvocation: true
+	});
+	if (node) return nodeToStrings(node);
+	return null;
 }
 function resolveCallStringVariants(expression, tPath, file, parsingOptions, errors, warnings) {
-    // Handle function identifier calls: derive(time())
-    if (t.isCallExpression(expression) && t.isIdentifier(expression.callee)) {
-        const functionName = expression.callee.name;
-        // Use Binding to resolve the function
-        const calleeBinding = tPath.scope.getBinding(functionName);
-        if (calleeBinding) {
-            // Check if the binding itself is an import (not just if the name exists in imports)
-            const isImportBinding = calleeBinding.path.isImportSpecifier() ||
-                calleeBinding.path.isImportDefaultSpecifier() ||
-                calleeBinding.path.isImportNamespaceSpecifier();
-            if (isImportBinding) {
-                // Function is imported - resolve cross-file
-                const importedFunctionsMap = buildImportMap(tPath.scope.getProgramParent().path);
-                let originalName;
-                if (calleeBinding.path.isImportSpecifier()) {
-                    originalName = t.isIdentifier(calleeBinding.path.node.imported)
-                        ? calleeBinding.path.node.imported.name
-                        : calleeBinding.path.node.imported.value;
-                }
-                else if (calleeBinding.path.isImportDefaultSpecifier()) {
-                    originalName = calleeBinding.path.node.local.name;
-                }
-                else if (calleeBinding.path.isImportNamespaceSpecifier()) {
-                    originalName = calleeBinding.path.node.local.name;
-                }
-                const importPath = importedFunctionsMap.get(functionName);
-                if (importPath) {
-                    const filePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
-                    if (filePath && originalName) {
-                        const node = resolveFunctionInFile(filePath, originalName, parsingOptions, errors, warnings);
-                        if (node) {
-                            return nodeToStrings(node);
-                        }
-                    }
-                }
-            }
-            else {
-                // Function is local - use parseStringExpression with resolveFunctionCall
-                const node = resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions, warnings, errors);
-                if (node) {
-                    return nodeToStrings(node);
-                }
-            }
-        }
-        else {
-            // Function not found in scope
-            errors.push(warnFunctionNotFoundSync(file, functionName, `${expression.callee.loc?.start?.line}:${expression.callee.loc?.start?.column}`));
-            return null;
-        }
-    }
-    // If we get here: analyze this call as derivable (statically analyzable)
-    const node = parseStringExpression(expression, tPath, file, parsingOptions, warnings, errors);
-    if (node) {
-        return nodeToStrings(node);
-    }
-    return null;
+	if (t.isCallExpression(expression) && t.isIdentifier(expression.callee)) {
+		const functionName = expression.callee.name;
+		const calleeBinding = tPath.scope.getBinding(functionName);
+		if (calleeBinding) if (calleeBinding.path.isImportSpecifier() || calleeBinding.path.isImportDefaultSpecifier() || calleeBinding.path.isImportNamespaceSpecifier()) {
+			const importedFunctionsMap = buildImportMap(tPath.scope.getProgramParent().path);
+			let originalName;
+			if (calleeBinding.path.isImportSpecifier()) originalName = t.isIdentifier(calleeBinding.path.node.imported) ? calleeBinding.path.node.imported.name : calleeBinding.path.node.imported.value;
+			else if (calleeBinding.path.isImportDefaultSpecifier()) originalName = calleeBinding.path.node.local.name;
+			else if (calleeBinding.path.isImportNamespaceSpecifier()) originalName = calleeBinding.path.node.local.name;
+			const importPath = importedFunctionsMap.get(functionName);
+			if (importPath) {
+				const filePath = resolveImportPath(file, importPath, parsingOptions, resolveImportPathCache);
+				if (filePath && originalName) {
+					const node = resolveFunctionInFile(filePath, originalName, parsingOptions, errors, warnings);
+					if (node) return nodeToStrings(node);
+				}
+			}
+		} else {
+			const node = resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions, warnings, errors);
+			if (node) return nodeToStrings(node);
+		}
+		else {
+			errors.push(warnFunctionNotFoundSync(file, functionName, `${expression.callee.loc?.start?.line}:${expression.callee.loc?.start?.column}`));
+			return null;
+		}
+	}
+	const node = parseStringExpression(expression, tPath, file, parsingOptions, warnings, errors);
+	if (node) return nodeToStrings(node);
+	return null;
 }
 /**
- * Resolves a function from a binding (local function) using parseStringExpression logic
- */
+* Resolves a function from a binding (local function) using parseStringExpression logic
+*/
 function resolveFunctionCallFromBinding(calleeBinding, tPath, file, parsingOptions, warnings, errors) {
-    if (!calleeBinding) {
-        return null;
-    }
-    const bindingPath = calleeBinding.path;
-    const branches = [];
-    // Handle function declarations: function time() { return "day"; }
-    if (bindingPath.isFunctionDeclaration()) {
-        bindingPath.traverse({
-            ReturnStatement(returnPath) {
-                // Only process return statements that are direct children of this function
-                const parentFunction = returnPath.getFunctionParent();
-                if (parentFunction?.node !== bindingPath.node) {
-                    return;
-                }
-                const returnArg = returnPath.node.argument;
-                if (!returnArg || !t.isExpression(returnArg)) {
-                    return;
-                }
-                const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
-                if (returnResult !== null) {
-                    branches.push(returnResult);
-                }
-            },
-        });
-    }
-    // Handle arrow functions: const time = () => "day"
-    else if (bindingPath.isVariableDeclarator()) {
-        const init = bindingPath.get('init');
-        if (!init.isArrowFunctionExpression()) {
-            return null;
-        }
-        const body = init.get('body');
-        // Handle expression body: () => "day"
-        if (body.isExpression()) {
-            const bodyResult = parseStringExpression(body.node, body, file, parsingOptions, warnings, errors);
-            if (bodyResult !== null) {
-                branches.push(bodyResult);
-            }
-        }
-        // Handle block body: () => { return "day"; }
-        else if (body.isBlockStatement()) {
-            const arrowFunction = init.node;
-            body.traverse({
-                ReturnStatement(returnPath) {
-                    // Only process return statements that are direct children of this function
-                    const parentFunction = returnPath.getFunctionParent();
-                    if (parentFunction?.node !== arrowFunction) {
-                        return;
-                    }
-                    const returnArg = returnPath.node.argument;
-                    if (!returnArg || !t.isExpression(returnArg)) {
-                        return;
-                    }
-                    const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
-                    if (returnResult !== null) {
-                        branches.push(returnResult);
-                    }
-                },
-            });
-        }
-    }
-    if (branches.length === 0) {
-        return null;
-    }
-    if (branches.length === 1) {
-        return branches[0];
-    }
-    return { type: 'choice', nodes: branches };
+	if (!calleeBinding) return null;
+	const bindingPath = calleeBinding.path;
+	const branches = [];
+	if (bindingPath.isFunctionDeclaration()) bindingPath.traverse({ ReturnStatement(returnPath) {
+		if (returnPath.getFunctionParent()?.node !== bindingPath.node) return;
+		const returnArg = returnPath.node.argument;
+		if (!returnArg || !t.isExpression(returnArg)) return;
+		const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
+		if (returnResult !== null) branches.push(returnResult);
+	} });
+	else if (bindingPath.isVariableDeclarator()) {
+		const init = bindingPath.get("init");
+		if (!init.isArrowFunctionExpression()) return null;
+		const body = init.get("body");
+		if (body.isExpression()) {
+			const bodyResult = parseStringExpression(body.node, body, file, parsingOptions, warnings, errors);
+			if (bodyResult !== null) branches.push(bodyResult);
+		} else if (body.isBlockStatement()) {
+			const arrowFunction = init.node;
+			body.traverse({ ReturnStatement(returnPath) {
+				if (returnPath.getFunctionParent()?.node !== arrowFunction) return;
+				const returnArg = returnPath.node.argument;
+				if (!returnArg || !t.isExpression(returnArg)) return;
+				const returnResult = parseStringExpression(returnArg, returnPath, file, parsingOptions, warnings, errors);
+				if (returnResult !== null) branches.push(returnResult);
+			} });
+		}
+	}
+	if (branches.length === 0) return null;
+	if (branches.length === 1) return branches[0];
+	return {
+		type: "choice",
+		nodes: branches
+	};
 }
 /**
- * Resolves a function definition in an external file
- */
+* Resolves a function definition in an external file
+*/
 function resolveFunctionInFile(filePath, functionName, parsingOptions, errors, warnings) {
-    // Check cache first
-    const cacheKey = `${filePath}::${functionName}`;
-    if (processFunctionCache.has(cacheKey)) {
-        return processFunctionCache.get(cacheKey) ?? null;
-    }
-    let result = null;
-    try {
-        const code = fs.readFileSync(filePath, 'utf8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        traverse(ast, {
-            // Handle re-exports: export * from './utils'
-            ExportAllDeclaration(path) {
-                // Only follow re-exports if we haven't found the function yet
-                if (result !== null)
-                    return;
-                if (t.isStringLiteral(path.node.source)) {
-                    const reexportPath = path.node.source.value;
-                    const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
-                    if (resolvedPath) {
-                        // Recursively resolve in the re-exported file
-                        const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, errors, warnings);
-                        if (reexportResult) {
-                            result = reexportResult;
-                        }
-                    }
-                }
-            },
-            // Handle named re-exports: export { fn1 } from './utils'
-            ExportNamedDeclaration(path) {
-                // Only follow re-exports if we haven't found the function yet
-                if (result !== null)
-                    return;
-                // Check if this is a re-export with a source
-                if (path.node.source && t.isStringLiteral(path.node.source)) {
-                    // Check if any of the exported specifiers match our function name
-                    const hasMatchingExport = path.node.specifiers.some((spec) => {
-                        if (t.isExportSpecifier(spec)) {
-                            const exportedName = t.isIdentifier(spec.exported)
-                                ? spec.exported.name
-                                : spec.exported.value;
-                            return exportedName === functionName;
-                        }
-                        return false;
-                    });
-                    if (hasMatchingExport) {
-                        const reexportPath = path.node.source.value;
-                        const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
-                        if (resolvedPath) {
-                            // Find the original name in case it was renamed
-                            const specifier = path.node.specifiers.find((spec) => {
-                                if (t.isExportSpecifier(spec)) {
-                                    const exportedName = t.isIdentifier(spec.exported)
-                                        ? spec.exported.name
-                                        : spec.exported.value;
-                                    return exportedName === functionName;
-                                }
-                                return false;
-                            });
-                            let originalName = functionName;
-                            if (specifier &&
-                                t.isExportSpecifier(specifier) &&
-                                t.isIdentifier(specifier.local)) {
-                                originalName = specifier.local.name;
-                            }
-                            // Recursively resolve in the re-exported file
-                            const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, errors, warnings);
-                            if (reexportResult) {
-                                result = reexportResult;
-                            }
-                        }
-                    }
-                }
-            },
-            // Handle function declarations: function woah() { ... }
-            FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName && result === null) {
-                    const branches = [];
-                    path.traverse({
-                        Function(innerPath) {
-                            // Skip nested functions
-                            innerPath.skip();
-                        },
-                        ReturnStatement(returnPath) {
-                            if (!t.isReturnStatement(returnPath.node)) {
-                                return;
-                            }
-                            const returnArg = returnPath.node.argument;
-                            if (!returnArg || !t.isExpression(returnArg)) {
-                                return;
-                            }
-                            const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
-                            if (returnResult !== null) {
-                                branches.push(returnResult);
-                            }
-                        },
-                    });
-                    if (branches.length === 1) {
-                        result = branches[0];
-                    }
-                    else if (branches.length > 1) {
-                        result = { type: 'choice', nodes: branches };
-                    }
-                }
-            },
-            // Handle variable declarations: const woah = () => { ... }
-            VariableDeclarator(path) {
-                if (t.isIdentifier(path.node.id) &&
-                    path.node.id.name === functionName &&
-                    path.node.init &&
-                    (t.isArrowFunctionExpression(path.node.init) ||
-                        t.isFunctionExpression(path.node.init)) &&
-                    result === null) {
-                    const init = path.get('init');
-                    if (!init.isArrowFunctionExpression() &&
-                        !init.isFunctionExpression()) {
-                        return;
-                    }
-                    const bodyPath = init.get('body');
-                    const branches = [];
-                    // Handle expression body: () => "day"
-                    if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {
-                        const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions, warnings, errors);
-                        if (bodyResult !== null) {
-                            branches.push(bodyResult);
-                        }
-                    }
-                    // Handle block body: () => { return "day"; }
-                    else if (!Array.isArray(bodyPath) &&
-                        t.isBlockStatement(bodyPath.node)) {
-                        const arrowFunction = init.node;
-                        bodyPath.traverse({
-                            Function(innerPath) {
-                                // Skip nested functions
-                                innerPath.skip();
-                            },
-                            ReturnStatement(returnPath) {
-                                // Only process return statements that are direct children of this function
-                                const parentFunction = returnPath.getFunctionParent();
-                                if (parentFunction?.node !== arrowFunction) {
-                                    return;
-                                }
-                                if (!t.isReturnStatement(returnPath.node)) {
-                                    return;
-                                }
-                                const returnArg = returnPath.node.argument;
-                                if (!returnArg || !t.isExpression(returnArg)) {
-                                    return;
-                                }
-                                const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
-                                if (returnResult !== null) {
-                                    branches.push(returnResult);
-                                }
-                            },
-                        });
-                    }
-                    if (branches.length === 1) {
-                        result = branches[0];
-                    }
-                    else if (branches.length > 1) {
-                        result = { type: 'choice', nodes: branches };
-                    }
-                }
-            },
-        });
-    }
-    catch (error) {
-        // File read or parse error - return null
-        errors.push(warnDeriveFunctionNoResultsSync(filePath, functionName, 'file read/parse error: ' + error));
-        result = null;
-    }
-    // Cache the result
-    processFunctionCache.set(cacheKey, result);
-    return result;
+	const cacheKey = `${filePath}::${functionName}`;
+	if (processFunctionCache.has(cacheKey)) return processFunctionCache.get(cacheKey) ?? null;
+	let result = null;
+	try {
+		traverse(parse(fs.readFileSync(filePath, "utf8"), {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		}), {
+			ExportAllDeclaration(path) {
+				if (result !== null) return;
+				if (t.isStringLiteral(path.node.source)) {
+					const reexportPath = path.node.source.value;
+					const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
+					if (resolvedPath) {
+						const reexportResult = resolveFunctionInFile(resolvedPath, functionName, parsingOptions, errors, warnings);
+						if (reexportResult) result = reexportResult;
+					}
+				}
+			},
+			ExportNamedDeclaration(path) {
+				if (result !== null) return;
+				if (path.node.source && t.isStringLiteral(path.node.source)) {
+					if (path.node.specifiers.some((spec) => {
+						if (t.isExportSpecifier(spec)) return (t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === functionName;
+						return false;
+					})) {
+						const reexportPath = path.node.source.value;
+						const resolvedPath = resolveImportPath(filePath, reexportPath, parsingOptions, resolveImportPathCache);
+						if (resolvedPath) {
+							const specifier = path.node.specifiers.find((spec) => {
+								if (t.isExportSpecifier(spec)) return (t.isIdentifier(spec.exported) ? spec.exported.name : spec.exported.value) === functionName;
+								return false;
+							});
+							let originalName = functionName;
+							if (specifier && t.isExportSpecifier(specifier) && t.isIdentifier(specifier.local)) originalName = specifier.local.name;
+							const reexportResult = resolveFunctionInFile(resolvedPath, originalName, parsingOptions, errors, warnings);
+							if (reexportResult) result = reexportResult;
+						}
+					}
+				}
+			},
+			FunctionDeclaration(path) {
+				if (path.node.id?.name === functionName && result === null) {
+					const branches = [];
+					path.traverse({
+						Function(innerPath) {
+							innerPath.skip();
+						},
+						ReturnStatement(returnPath) {
+							if (!t.isReturnStatement(returnPath.node)) return;
+							const returnArg = returnPath.node.argument;
+							if (!returnArg || !t.isExpression(returnArg)) return;
+							const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
+							if (returnResult !== null) branches.push(returnResult);
+						}
+					});
+					if (branches.length === 1) result = branches[0];
+					else if (branches.length > 1) result = {
+						type: "choice",
+						nodes: branches
+					};
+				}
+			},
+			VariableDeclarator(path) {
+				if (t.isIdentifier(path.node.id) && path.node.id.name === functionName && path.node.init && (t.isArrowFunctionExpression(path.node.init) || t.isFunctionExpression(path.node.init)) && result === null) {
+					const init = path.get("init");
+					if (!init.isArrowFunctionExpression() && !init.isFunctionExpression()) return;
+					const bodyPath = init.get("body");
+					const branches = [];
+					if (!Array.isArray(bodyPath) && t.isExpression(bodyPath.node)) {
+						const bodyResult = parseStringExpression(bodyPath.node, bodyPath, filePath, parsingOptions, warnings, errors);
+						if (bodyResult !== null) branches.push(bodyResult);
+					} else if (!Array.isArray(bodyPath) && t.isBlockStatement(bodyPath.node)) {
+						const arrowFunction = init.node;
+						bodyPath.traverse({
+							Function(innerPath) {
+								innerPath.skip();
+							},
+							ReturnStatement(returnPath) {
+								if (returnPath.getFunctionParent()?.node !== arrowFunction) return;
+								if (!t.isReturnStatement(returnPath.node)) return;
+								const returnArg = returnPath.node.argument;
+								if (!returnArg || !t.isExpression(returnArg)) return;
+								const returnResult = parseStringExpression(returnArg, returnPath, filePath, parsingOptions, warnings, errors);
+								if (returnResult !== null) branches.push(returnResult);
+							}
+						});
+					}
+					if (branches.length === 1) result = branches[0];
+					else if (branches.length > 1) result = {
+						type: "choice",
+						nodes: branches
+					};
+				}
+			}
+		});
+	} catch (error) {
+		errors.push(warnDeriveFunctionNoResultsSync(filePath, functionName, "file read/parse error: " + error));
+		result = null;
+	}
+	processFunctionCache.set(cacheKey, result);
+	return result;
 }
+//#endregion
+export { handleDerivation };
+
+//# sourceMappingURL=handleDerivation.js.map