gt 2.14.35 → 2.14.36

package/dist/react/jsx/utils/jsxParsing/parseJsx.js

@@ -1,1125 +1,778 @@
-import { randomUUID } from 'node:crypto';
-import generateModule from '@babel/generator';
-// Handle CommonJS/ESM interop
+import "../../../../utils/constants.js";
+import { isStaticExpression } from "../../evaluateJsx.js";
+import { VARIABLE_COMPONENTS } from "../constants.js";
+import { warnDataAttrOnBranch, warnDeriveDestructuringSync, warnDeriveNonConstVariableSync, warnDuplicateFunctionDefinitionSync, warnFunctionNotFoundSync, warnHasUnwrappedExpressionSync, warnInvalidDeriveInitSync, warnMissingReturnSync, warnNestedInternalTComponent, warnNestedTComponent, warnRecursiveFunctionCallSync } from "../../../../console/index.js";
+import addGTIdentifierToSyntaxTree from "./addGTIdentifierToSyntaxTree.js";
+import { resolveImportPath } from "../resolveImportPath.js";
+import { buildImportMap } from "../buildImportMap.js";
+import { getPathsAndAliases } from "../getPathsAndAliases.js";
+import { parseTProps } from "./parseTProps.js";
+import { isElementNode } from "./types.js";
+import { handleChildrenWhitespace } from "./handleChildrenWhitespace.js";
+import { multiplyJsxTree } from "./multiplication/multiplyJsxTree.js";
+import { removeNullChildrenFields } from "./removeNullChildrenFields.js";
+import { autoInsertJsxComponents, ensureTAndVarImported } from "./autoInsertion.js";
+import { extractSourceCode } from "../extractSourceCode.js";
+import { nodeToStrings, parseStringExpression } from "../parseString.js";
+import { handleDerivation } from "../stringParsing/derivation/handleDerivation.js";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import fs from "node:fs";
+import * as t from "@babel/types";
+import { parse } from "@babel/parser";
+import generateModule from "@babel/generator";
+import { HTML_CONTENT_PROPS } from "@generaltranslation/format/types";
+import { isAcceptedPluralForm } from "generaltranslation/internal";
+import traverseModule from "@babel/traverse";
+//#region src/react/jsx/utils/jsxParsing/parseJsx.ts
 const generate = generateModule.default || generateModule;
-import * as t from '@babel/types';
-import fs from 'node:fs';
-import { parse } from '@babel/parser';
-import addGTIdentifierToSyntaxTree from './addGTIdentifierToSyntaxTree.js';
-import { warnHasUnwrappedExpressionSync, warnNestedTComponent, warnFunctionNotFoundSync, warnMissingReturnSync, warnDuplicateFunctionDefinitionSync, warnInvalidDeriveInitSync, warnRecursiveFunctionCallSync, warnDataAttrOnBranch, warnNestedInternalTComponent, warnDeriveNonConstVariableSync, warnDeriveDestructuringSync, } from '../../../../console/index.js';
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { isStaticExpression } from '../../evaluateJsx.js';
-import { DATA_ATTR_PREFIX, STATIC_COMPONENT, DERIVE_COMPONENT, TRANSLATION_COMPONENT, INTERNAL_TRANSLATION_COMPONENT, VARIABLE_COMPONENTS, } from '../constants.js';
-import { HTML_CONTENT_PROPS, } from '@generaltranslation/format/types';
-import { resolveImportPath } from '../resolveImportPath.js';
-import traverseModule from '@babel/traverse';
-import { buildImportMap } from '../buildImportMap.js';
-import { getPathsAndAliases } from '../getPathsAndAliases.js';
-import { parseTProps } from './parseTProps.js';
-import { handleChildrenWhitespace } from './handleChildrenWhitespace.js';
-import { isElementNode } from './types.js';
-import { multiplyJsxTree } from './multiplication/multiplyJsxTree.js';
-import { removeNullChildrenFields } from './removeNullChildrenFields.js';
-import { ensureTAndVarImported, autoInsertJsxComponents, } from './autoInsertion.js';
-import path from 'node:path';
-import { extractSourceCode } from '../extractSourceCode.js';
-import { SURROUNDING_LINE_COUNT } from '../../../../utils/constants.js';
-import { handleDerivation } from '../stringParsing/derivation/handleDerivation.js';
-import { parseStringExpression, nodeToStrings } from '../parseString.js';
-// Handle CommonJS/ESM interop
 const traverse = traverseModule.default || traverseModule;
-// TODO: currently we cover VariableDeclaration and FunctionDeclaration nodes, but are there others we should cover as well?
 /**
- * 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}::${argIndex}`
- * Value: boolean indicating whether the function was found and processed
- */
-const processFunctionCache = new Map();
+* Cache for processed functions to avoid re-parsing the same files.
+* Key: `${filePath}::${functionName}::${argIndex}`
+* Value: boolean indicating whether the function was found and processed
+*/
+const processFunctionCache = /* @__PURE__ */ new Map();
 /**
- * Entry point for JSX parsing
- */
-export function parseTranslationComponent({ originalName, localName, path, updates, config, output, }) {
-    // First, collect all imports in this file to track cross-file function calls
-    const importedFunctionsMap = buildImportMap(path.scope.getProgramParent().path);
-    const referencePaths = path.scope.bindings[localName]?.referencePaths || [];
-    for (const refPath of referencePaths) {
-        // Only start at opening tag
-        if (!t.isJSXOpeningElement(refPath.parent) ||
-            !refPath.parentPath?.parentPath) {
-            continue;
-        }
-        // Get the JSX element NodePath
-        const jsxElementPath = refPath.parentPath
-            ?.parentPath;
-        // Parse <T> component
-        parseJSXElement({
-            scopeNode: jsxElementPath,
-            node: jsxElementPath.node,
-            originalName,
-            updates,
-            config,
-            state: {
-                visited: null,
-                callStack: [],
-                derivableTracker: { isDerivable: false },
-                importedFunctionsMap,
-            },
-            output,
-        });
-    }
+* Entry point for JSX parsing
+*/
+function parseTranslationComponent({ originalName, localName, path, updates, config, output }) {
+	const importedFunctionsMap = buildImportMap(path.scope.getProgramParent().path);
+	const referencePaths = path.scope.bindings[localName]?.referencePaths || [];
+	for (const refPath of referencePaths) {
+		if (!t.isJSXOpeningElement(refPath.parent) || !refPath.parentPath?.parentPath) continue;
+		const jsxElementPath = refPath.parentPath?.parentPath;
+		parseJSXElement({
+			scopeNode: jsxElementPath,
+			node: jsxElementPath.node,
+			originalName,
+			updates,
+			config,
+			state: {
+				visited: null,
+				callStack: [],
+				derivableTracker: { isDerivable: false },
+				importedFunctionsMap
+			},
+			output
+		});
+	}
 }
 /**
- * Builds a JSX tree from a given node, recursively handling children.
- * @param node - The node to build the tree from
- * @param helperPath - NodePath for AST traversal
- * @param scopeNode - Scope node for binding resolution
- * @param insideT - Whether the current node is inside a <T> component
- * @param inDerive - Whether we're inside a <Derive> component
- * @param config - Immutable configuration options
- * @param state - Mutable state tracking
- * @param output - Error/warning collectors
- * @returns The built JSX tree
- */
-function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config, state, output, }) {
-    if (t.isJSXExpressionContainer(node)) {
-        // Skip JSX comments
-        if (t.isJSXEmptyExpression(node.expression)) {
-            return null;
-        }
-        if (inDerive) {
-            return processDeriveExpression({
-                config,
-                state,
-                output,
-                expressionNodePath: helperPath.get('expression'),
-                scopeNode,
-            });
-        }
-        const expr = node.expression;
-        if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
-            return buildJSXTree({
-                node: expr,
-                insideT,
-                inDerive: inDerive,
-                scopeNode,
-                helperPath: helperPath.get('expression'),
-                config,
-                state,
-                output,
-            });
-        }
-        const staticAnalysis = isStaticExpression(expr, true);
-        if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-            // Preserve the exact whitespace for static string expressions
-            return {
-                nodeType: 'expression',
-                result: staticAnalysis.value,
-            };
-        }
-        // Keep existing behavior for non-static expressions
-        const code = generate(node).code;
-        output.unwrappedExpressions.push(code); // Keep track of unwrapped expressions for error reporting
-        return code;
-    }
-    else if (t.isJSXText(node)) {
-        // Updated JSX Text handling
-        // JSX Text handling following React's rules
-        const text = node.value;
-        return text;
-    }
-    else if (t.isJSXElement(node)) {
-        const element = node;
-        const elementName = element.openingElement.name;
-        let typeName;
-        if (t.isJSXIdentifier(elementName)) {
-            typeName = elementName.name;
-        }
-        else if (t.isJSXMemberExpression(elementName)) {
-            typeName = generate(elementName).code;
-        }
-        else {
-            typeName = null;
-        }
-        // Convert from alias to original name
-        const componentType = config.importAliases[typeName ?? ''];
-        // When enableAutoJsxInjection is on and we're inside a Derive context,
-        // any auto-inserted T component will be stripped at runtime by
-        // removeInjectedT. Unwrap it transparently — process the T's children
-        // as if the T wasn't there. Check this BEFORE the nested-T warning
-        // so we don't emit spurious errors for expected auto-inserted nesting.
-        if (componentType === INTERNAL_TRANSLATION_COMPONENT &&
-            inDerive &&
-            config.enableAutoJsxInjection) {
-            const childResults = [];
-            const helperChildren = helperPath.get('children');
-            for (let i = 0; i < element.children.length; i++) {
-                const child = element.children[i];
-                const helperChild = helperChildren[i];
-                const result = buildJSXTree({
-                    node: child,
-                    helperPath: helperChild,
-                    scopeNode,
-                    insideT: true,
-                    inDerive: true,
-                    config,
-                    state,
-                    output,
-                });
-                if (result !== null) {
-                    if (Array.isArray(result)) {
-                        childResults.push(...result);
-                    }
-                    else {
-                        childResults.push(result);
-                    }
-                }
-            }
-            if (childResults.length === 0)
-                return null;
-            if (childResults.length === 1)
-                return childResults[0];
-            // Return array — callers flatten this into parent's children
-            return childResults;
-        }
-        if ((componentType === TRANSLATION_COMPONENT ||
-            componentType === INTERNAL_TRANSLATION_COMPONENT) &&
-            insideT) {
-            // Add warning: Nested <T> components are allowed, but they are advised against
-            output.warnings.add(warnNestedTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
-            if (componentType === INTERNAL_TRANSLATION_COMPONENT) {
-                output.errors.push(warnNestedInternalTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
-            }
-        }
-        // If this JSXElement is one of the recognized variable components,
-        const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
-        const props = {};
-        const elementIsPlural = componentType === 'Plural';
-        const elementIsBranch = componentType === 'Branch';
-        element.openingElement.attributes.forEach((attr, index) => {
-            const helperAttribute = helperPath
-                .get('openingElement')
-                .get('attributes')[index];
-            if (t.isJSXAttribute(attr)) {
-                const attrName = typeof attr.name.name === 'string'
-                    ? attr.name.name
-                    : attr.name.name.name;
-                let attrValue = null;
-                if (elementIsBranch && attrName.startsWith(DATA_ATTR_PREFIX)) {
-                    const location = `${attr.loc?.start?.line}:${attr.loc?.start?.column}`;
-                    output.errors.push(warnDataAttrOnBranch(config.file, attrName, location));
-                }
-                if (attr.value) {
-                    if (t.isStringLiteral(attr.value)) {
-                        attrValue = attr.value.value;
-                    }
-                    else if (t.isJSXExpressionContainer(attr.value)) {
-                        const helperValue = helperAttribute.get('value');
-                        // Check if this is an HTML content prop (title, placeholder, alt, etc.)
-                        const isHtmlContentProp = Object.values(HTML_CONTENT_PROPS).includes(attrName);
-                        // If its a plural or branch prop
-                        if ((elementIsPlural && isAcceptedPluralForm(attrName)) ||
-                            (elementIsBranch &&
-                                attrName !== 'branch' &&
-                                !attrName.startsWith(DATA_ATTR_PREFIX))) {
-                            // Make sure that variable strings like {`I have ${count} book`} are invalid!
-                            if (t.isTemplateLiteral(attr.value.expression) &&
-                                !isStaticExpression(attr.value.expression, true).isStatic) {
-                                output.unwrappedExpressions.push(generate(attr.value).code);
-                            }
-                            // If it's an array, flag as an unwrapped expression
-                            if (t.isArrayExpression(attr.value.expression)) {
-                                output.unwrappedExpressions.push(generate(attr.value.expression).code);
-                            }
-                            attrValue = buildJSXTree({
-                                node: attr.value,
-                                insideT: true,
-                                inDerive: inDerive,
-                                scopeNode,
-                                helperPath: helperValue,
-                                config,
-                                state,
-                                output,
-                            });
-                        }
-                        // For HTML content props, only accept static string expressions
-                        else if (isHtmlContentProp) {
-                            const staticAnalysis = isStaticExpression(attr.value.expression, true);
-                            if (staticAnalysis.isStatic &&
-                                staticAnalysis.value !== undefined) {
-                                attrValue = staticAnalysis.value;
-                            }
-                            // Otherwise attrValue stays null and won't be included
-                        }
-                    }
-                }
-                props[attrName] = attrValue;
-            }
-        });
-        if (elementIsVariable) {
-            if (componentType === STATIC_COMPONENT ||
-                componentType === DERIVE_COMPONENT) {
-                const helperElement = helperPath.get('children');
-                const results = {
-                    nodeType: 'element',
-                    type: componentType,
-                    props,
-                };
-                // Create children array if necessary
-                const childrenArray = [];
-                if (state.visited === null) {
-                    state.visited = new Set();
-                }
-                for (let index = 0; index < element.children.length; index++) {
-                    const helperChild = helperElement[index];
-                    const result = buildJSXTree({
-                        node: helperChild.node,
-                        insideT: true,
-                        inDerive: true,
-                        scopeNode,
-                        helperPath: helperChild,
-                        config,
-                        state,
-                        output,
-                    });
-                    // Flatten array results from _T transparency unwrap inside Derive
-                    if (Array.isArray(result)) {
-                        childrenArray.push(...result);
-                    }
-                    else {
-                        childrenArray.push(result);
-                    }
-                }
-                if (childrenArray.length) {
-                    results.props.children = childrenArray;
-                }
-                return results;
-            }
-            return {
-                nodeType: 'element',
-                // if componentType is undefined, use typeName
-                // Basically, if componentType is not a GT component, use typeName such as <div>
-                type: componentType ?? typeName ?? '',
-                props,
-            };
-        }
-        const children = element.children
-            .flatMap((child, index) => {
-            const result = buildJSXTree({
-                node: child,
-                insideT: true,
-                inDerive: inDerive,
-                scopeNode,
-                helperPath: helperPath.get('children')[index],
-                config,
-                state,
-                output,
-            });
-            // Flatten array results from _T transparency unwrap inside Derive
-            if (Array.isArray(result))
-                return result;
-            return [result];
-        })
-            .filter((child) => child !== null && child !== '');
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            nodeType: 'element',
-            // if componentType is undefined, use typeName
-            // Basically, if componentType is not a GT component, use typeName such as <div>
-            type: componentType ?? typeName,
-            props,
-        };
-    }
-    // If it's a JSX fragment
-    else if (t.isJSXFragment(node)) {
-        const children = node.children
-            .flatMap((child, index) => {
-            const result = buildJSXTree({
-                node: child,
-                insideT: true,
-                inDerive: inDerive,
-                scopeNode,
-                helperPath: helperPath.get('children')[index],
-                config,
-                state,
-                output,
-            });
-            // Flatten array results from _T transparency unwrap inside Derive
-            if (Array.isArray(result))
-                return result;
-            return [result];
-        })
-            .filter((child) => child !== null && child !== '');
-        const props = {};
-        if (children.length === 1) {
-            props.children = children[0];
-        }
-        else if (children.length > 1) {
-            props.children = children;
-        }
-        return {
-            nodeType: 'element',
-            type: '',
-            props,
-        };
-    }
-    // If it's a string literal (standalone)
-    else if (t.isStringLiteral(node)) {
-        return node.value;
-    }
-    // If it's a template literal
-    else if (t.isTemplateLiteral(node)) {
-        // We've already checked that it's derivable, and and added a warning if it's not, this check is just for fallback behavior
-        if (!isStaticExpression(node, true).isStatic ||
-            node.quasis[0].value.cooked === undefined) {
-            return generate(node).code;
-        }
-        return node.quasis[0].value.cooked;
-    }
-    else if (t.isNullLiteral(node)) {
-        // If it's null, return null
-        return null;
-    }
-    else if (t.isBooleanLiteral(node)) {
-        // If it's a boolean, return the boolean
-        return node.value;
-    }
-    else if (t.isNumericLiteral(node)) {
-        // If it's a number, return the number
-        return node.value.toString();
-    }
-    // Negative
-    else if (t.isUnaryExpression(node)) {
-        // If it's a unary expression, return the expression
-        const staticAnalysis = isStaticExpression(node, true);
-        if (staticAnalysis.isStatic && staticAnalysis.value !== undefined) {
-            return staticAnalysis.value;
-        }
-        return generate(node).code;
-    }
-    else if ((t.isCallExpression(node) && t.isIdentifier(node.callee)) ||
-        (t.isAwaitExpression(node) &&
-            t.isCallExpression(node.argument) &&
-            t.isIdentifier(node.argument.callee))) {
-        if (inDerive) {
-            const callExpression = (node.type === 'AwaitExpression' ? node.argument : node);
-            const callee = callExpression.callee;
-            const calleeBinding = scopeNode.scope.getBinding(callee.name);
-            if (!calleeBinding) {
-                output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
-                return null;
-            }
-            return resolveDeriveFunctionInvocationFromBinding({
-                calleeBinding,
-                callee,
-                config,
-                state,
-                output,
-            });
-        }
-        else {
-            output.unwrappedExpressions.push(generate(node).code);
-        }
-    }
-    else if (t.isParenthesizedExpression(node)) {
-        const child = node.expression;
-        return buildJSXTree({
-            node: child,
-            insideT,
-            inDerive: inDerive,
-            scopeNode,
-            helperPath: helperPath.get('expression'),
-            config,
-            state,
-            output,
-        });
-    }
-    // If it's some other JS expression
-    else if (t.isIdentifier(node) ||
-        t.isMemberExpression(node) ||
-        t.isCallExpression(node) ||
-        t.isBinaryExpression(node) ||
-        t.isLogicalExpression(node) ||
-        t.isConditionalExpression(node)) {
-        output.unwrappedExpressions.push(generate(node).code);
-    }
-    else {
-        if (node === undefined || node === null) {
-            output.unwrappedExpressions.push(String(node));
-        }
-        else {
-            output.unwrappedExpressions.push(generate(node).code);
-        }
-    }
-    return null;
+* Builds a JSX tree from a given node, recursively handling children.
+* @param node - The node to build the tree from
+* @param helperPath - NodePath for AST traversal
+* @param scopeNode - Scope node for binding resolution
+* @param insideT - Whether the current node is inside a <T> component
+* @param inDerive - Whether we're inside a <Derive> component
+* @param config - Immutable configuration options
+* @param state - Mutable state tracking
+* @param output - Error/warning collectors
+* @returns The built JSX tree
+*/
+function buildJSXTree({ node, helperPath, scopeNode, insideT, inDerive, config, state, output }) {
+	if (t.isJSXExpressionContainer(node)) {
+		if (t.isJSXEmptyExpression(node.expression)) return null;
+		if (inDerive) return processDeriveExpression({
+			config,
+			state,
+			output,
+			expressionNodePath: helperPath.get("expression"),
+			scopeNode
+		});
+		const expr = node.expression;
+		if (t.isJSXElement(expr) || t.isJSXFragment(expr)) return buildJSXTree({
+			node: expr,
+			insideT,
+			inDerive,
+			scopeNode,
+			helperPath: helperPath.get("expression"),
+			config,
+			state,
+			output
+		});
+		const staticAnalysis = isStaticExpression(expr, true);
+		if (staticAnalysis.isStatic && staticAnalysis.value !== void 0) return {
+			nodeType: "expression",
+			result: staticAnalysis.value
+		};
+		const code = generate(node).code;
+		output.unwrappedExpressions.push(code);
+		return code;
+	} else if (t.isJSXText(node)) return node.value;
+	else if (t.isJSXElement(node)) {
+		const element = node;
+		const elementName = element.openingElement.name;
+		let typeName;
+		if (t.isJSXIdentifier(elementName)) typeName = elementName.name;
+		else if (t.isJSXMemberExpression(elementName)) typeName = generate(elementName).code;
+		else typeName = null;
+		const componentType = config.importAliases[typeName ?? ""];
+		if (componentType === "GtInternalTranslateJsx" && inDerive && config.enableAutoJsxInjection) {
+			const childResults = [];
+			const helperChildren = helperPath.get("children");
+			for (let i = 0; i < element.children.length; i++) {
+				const child = element.children[i];
+				const helperChild = helperChildren[i];
+				const result = buildJSXTree({
+					node: child,
+					helperPath: helperChild,
+					scopeNode,
+					insideT: true,
+					inDerive: true,
+					config,
+					state,
+					output
+				});
+				if (result !== null) if (Array.isArray(result)) childResults.push(...result);
+				else childResults.push(result);
+			}
+			if (childResults.length === 0) return null;
+			if (childResults.length === 1) return childResults[0];
+			return childResults;
+		}
+		if ((componentType === "T" || componentType === "GtInternalTranslateJsx") && insideT) {
+			output.warnings.add(warnNestedTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
+			if (componentType === "GtInternalTranslateJsx") output.errors.push(warnNestedInternalTComponent(config.file, `${element.loc?.start?.line}:${element.loc?.start?.column}`));
+		}
+		const elementIsVariable = VARIABLE_COMPONENTS.includes(componentType);
+		const props = {};
+		const elementIsPlural = componentType === "Plural";
+		const elementIsBranch = componentType === "Branch";
+		element.openingElement.attributes.forEach((attr, index) => {
+			const helperAttribute = helperPath.get("openingElement").get("attributes")[index];
+			if (t.isJSXAttribute(attr)) {
+				const attrName = typeof attr.name.name === "string" ? attr.name.name : attr.name.name.name;
+				let attrValue = null;
+				if (elementIsBranch && attrName.startsWith("data-")) {
+					const location = `${attr.loc?.start?.line}:${attr.loc?.start?.column}`;
+					output.errors.push(warnDataAttrOnBranch(config.file, attrName, location));
+				}
+				if (attr.value) {
+					if (t.isStringLiteral(attr.value)) attrValue = attr.value.value;
+					else if (t.isJSXExpressionContainer(attr.value)) {
+						const helperValue = helperAttribute.get("value");
+						const isHtmlContentProp = Object.values(HTML_CONTENT_PROPS).includes(attrName);
+						if (elementIsPlural && isAcceptedPluralForm(attrName) || elementIsBranch && attrName !== "branch" && !attrName.startsWith("data-")) {
+							if (t.isTemplateLiteral(attr.value.expression) && !isStaticExpression(attr.value.expression, true).isStatic) output.unwrappedExpressions.push(generate(attr.value).code);
+							if (t.isArrayExpression(attr.value.expression)) output.unwrappedExpressions.push(generate(attr.value.expression).code);
+							attrValue = buildJSXTree({
+								node: attr.value,
+								insideT: true,
+								inDerive,
+								scopeNode,
+								helperPath: helperValue,
+								config,
+								state,
+								output
+							});
+						} else if (isHtmlContentProp) {
+							const staticAnalysis = isStaticExpression(attr.value.expression, true);
+							if (staticAnalysis.isStatic && staticAnalysis.value !== void 0) attrValue = staticAnalysis.value;
+						}
+					}
+				}
+				props[attrName] = attrValue;
+			}
+		});
+		if (elementIsVariable) {
+			if (componentType === "Static" || componentType === "Derive") {
+				const helperElement = helperPath.get("children");
+				const results = {
+					nodeType: "element",
+					type: componentType,
+					props
+				};
+				const childrenArray = [];
+				if (state.visited === null) state.visited = /* @__PURE__ */ new Set();
+				for (let index = 0; index < element.children.length; index++) {
+					const helperChild = helperElement[index];
+					const result = buildJSXTree({
+						node: helperChild.node,
+						insideT: true,
+						inDerive: true,
+						scopeNode,
+						helperPath: helperChild,
+						config,
+						state,
+						output
+					});
+					if (Array.isArray(result)) childrenArray.push(...result);
+					else childrenArray.push(result);
+				}
+				if (childrenArray.length) results.props.children = childrenArray;
+				return results;
+			}
+			return {
+				nodeType: "element",
+				type: componentType ?? typeName ?? "",
+				props
+			};
+		}
+		const children = element.children.flatMap((child, index) => {
+			const result = buildJSXTree({
+				node: child,
+				insideT: true,
+				inDerive,
+				scopeNode,
+				helperPath: helperPath.get("children")[index],
+				config,
+				state,
+				output
+			});
+			if (Array.isArray(result)) return result;
+			return [result];
+		}).filter((child) => child !== null && child !== "");
+		if (children.length === 1) props.children = children[0];
+		else if (children.length > 1) props.children = children;
+		return {
+			nodeType: "element",
+			type: componentType ?? typeName,
+			props
+		};
+	} else if (t.isJSXFragment(node)) {
+		const children = node.children.flatMap((child, index) => {
+			const result = buildJSXTree({
+				node: child,
+				insideT: true,
+				inDerive,
+				scopeNode,
+				helperPath: helperPath.get("children")[index],
+				config,
+				state,
+				output
+			});
+			if (Array.isArray(result)) return result;
+			return [result];
+		}).filter((child) => child !== null && child !== "");
+		const props = {};
+		if (children.length === 1) props.children = children[0];
+		else if (children.length > 1) props.children = children;
+		return {
+			nodeType: "element",
+			type: "",
+			props
+		};
+	} else if (t.isStringLiteral(node)) return node.value;
+	else if (t.isTemplateLiteral(node)) {
+		if (!isStaticExpression(node, true).isStatic || node.quasis[0].value.cooked === void 0) return generate(node).code;
+		return node.quasis[0].value.cooked;
+	} else if (t.isNullLiteral(node)) return null;
+	else if (t.isBooleanLiteral(node)) return node.value;
+	else if (t.isNumericLiteral(node)) return node.value.toString();
+	else if (t.isUnaryExpression(node)) {
+		const staticAnalysis = isStaticExpression(node, true);
+		if (staticAnalysis.isStatic && staticAnalysis.value !== void 0) return staticAnalysis.value;
+		return generate(node).code;
+	} else if (t.isCallExpression(node) && t.isIdentifier(node.callee) || t.isAwaitExpression(node) && t.isCallExpression(node.argument) && t.isIdentifier(node.argument.callee)) if (inDerive) {
+		const callee = (node.type === "AwaitExpression" ? node.argument : node).callee;
+		const calleeBinding = scopeNode.scope.getBinding(callee.name);
+		if (!calleeBinding) {
+			output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
+			return null;
+		}
+		return resolveDeriveFunctionInvocationFromBinding({
+			calleeBinding,
+			callee,
+			config,
+			state,
+			output
+		});
+	} else output.unwrappedExpressions.push(generate(node).code);
+	else if (t.isParenthesizedExpression(node)) {
+		const child = node.expression;
+		return buildJSXTree({
+			node: child,
+			insideT,
+			inDerive,
+			scopeNode,
+			helperPath: helperPath.get("expression"),
+			config,
+			state,
+			output
+		});
+	} else if (t.isIdentifier(node) || t.isMemberExpression(node) || t.isCallExpression(node) || t.isBinaryExpression(node) || t.isLogicalExpression(node) || t.isConditionalExpression(node)) output.unwrappedExpressions.push(generate(node).code);
+	else if (node === void 0 || node === null) output.unwrappedExpressions.push(String(node));
+	else output.unwrappedExpressions.push(generate(node).code);
+	return null;
 }
-// end buildJSXTree
-// Parses a JSX element and adds it to the updates array
-function parseJSXElement({ node, originalName, scopeNode, updates, config, state, output, }) {
-    const openingElement = node.openingElement;
-    const name = openingElement.name;
-    // Only proceed if it's <T> ...
-    // TODO: i don't think this condition is needed anymore
-    if (!(name.type === 'JSXIdentifier' &&
-        (originalName === TRANSLATION_COMPONENT ||
-            originalName === INTERNAL_TRANSLATION_COMPONENT))) {
-        return;
-    }
-    const componentErrors = [];
-    const componentWarnings = new Set();
-    const metadata = {};
-    const relativeFilepath = path.relative(process.cwd(), config.file);
-    metadata.filePaths = [relativeFilepath];
-    // Extract surrounding lines from source file
-    const startLine = node.loc?.start?.line;
-    const endLine = node.loc?.end?.line;
-    if (config.includeSourceCodeContext && startLine && endLine) {
-        const entry = extractSourceCode(config.file, startLine, endLine, SURROUNDING_LINE_COUNT);
-        if (entry && relativeFilepath) {
-            metadata.sourceCode = { [relativeFilepath]: [entry] };
-        }
-    }
-    // We'll track this flag to know if any unwrapped {variable} is found in children
-    const unwrappedExpressions = [];
-    // Gather <T>'s props
-    parseTProps({
-        openingElement,
-        metadata,
-        componentErrors,
-        file: config.file,
-    });
-    // Flag for if contains derivable content
-    const derivableTracker = {
-        isDerivable: false,
-    };
-    // Build the JSX tree for this component
-    const treeResult = buildJSXTree({
-        node,
-        scopeNode,
-        insideT: false,
-        inDerive: config.autoderive ?? false,
-        helperPath: scopeNode,
-        config,
-        state: {
-            visited: null,
-            callStack: [],
-            derivableTracker: derivableTracker,
-            importedFunctionsMap: state.importedFunctionsMap,
-        },
-        output: {
-            unwrappedExpressions,
-            errors: componentErrors,
-            warnings: componentWarnings,
-        },
-    });
-    // Strip the outer <T> component if necessary
-    const jsxTree = isElementNode(treeResult) && treeResult.props?.children
-        ? // We know this b/c the direct children of <T> will never be a multiplication node
-            treeResult.props.children
-        : treeResult;
-    // Update warnings
-    if (componentWarnings.size > 0) {
-        componentWarnings.forEach((warning) => output.warnings.add(warning));
-    }
-    // Update errors
-    if (componentErrors.length > 0) {
-        output.errors.push(...componentErrors);
-        return;
-    }
-    // Handle whitespace in children
-    const whitespaceHandledTree = handleChildrenWhitespace(jsxTree);
-    // Multiply the tree
-    const multipliedTrees = multiplyJsxTree(whitespaceHandledTree);
-    // Add GT identifiers to the tree
-    // TODO: do this in parallel
-    const minifiedTress = [];
-    for (const multipliedTree of multipliedTrees) {
-        // Build set of confirmed GT variable names from importAliases.
-        // Only pass when enableAutoJsxInjection is on, to avoid breaking
-        // existing behavior where importAliases may be incomplete.
-        const gtVariableNames = config.enableAutoJsxInjection
-            ? new Set(Object.values(config.importAliases).filter((name) => VARIABLE_COMPONENTS.includes(name) &&
-                name !== DERIVE_COMPONENT &&
-                name !== STATIC_COMPONENT))
-            : undefined;
-        const minifiedTree = addGTIdentifierToSyntaxTree(multipliedTree, 0, gtVariableNames);
-        minifiedTress.push(Array.isArray(minifiedTree) && minifiedTree.length === 1
-            ? minifiedTree[0]
-            : minifiedTree);
-    }
-    // If we found an unwrapped expression, skip
-    if (unwrappedExpressions.length > 0) {
-        output.errors.push(warnHasUnwrappedExpressionSync(config.file, unwrappedExpressions, metadata.id, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
-        return;
-    }
-    // Create a temporary unique flag for derivable content
-    const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
-    // Resolve derive context variants if present
-    let contextVariants;
-    if (metadata._contextDeriveExpr) {
-        const contextExpr = metadata._contextDeriveExpr;
-        delete metadata._contextDeriveExpr;
-        const contextNode = handleDerivation({
-            expr: contextExpr,
-            tPath: scopeNode,
-            file: config.file,
-            parsingOptions: config.parsingOptions,
-            errors: componentErrors,
-            warnings: componentWarnings,
-        });
-        if (contextNode) {
-            contextVariants = nodeToStrings(contextNode);
-        }
-    }
-    // <T> is valid here
-    for (const minifiedTree of minifiedTress) {
-        // Clean the tree by removing null 'c' fields from JsxElements
-        const cleanedTree = removeNullChildrenFields(minifiedTree);
-        if (contextVariants) {
-            for (const context of contextVariants) {
-                updates.push({
-                    dataFormat: 'JSX',
-                    source: cleanedTree,
-                    metadata: {
-                        ...structuredClone(metadata),
-                        context,
-                        staticId: temporaryDeriveId,
-                    },
-                });
-            }
-        }
-        else {
-            updates.push({
-                dataFormat: 'JSX',
-                source: cleanedTree,
-                metadata: {
-                    ...structuredClone(metadata),
-                    ...(derivableTracker.isDerivable && { staticId: temporaryDeriveId }),
-                },
-            });
-        }
-    }
+function parseJSXElement({ node, originalName, scopeNode, updates, config, state, output }) {
+	const openingElement = node.openingElement;
+	if (!(openingElement.name.type === "JSXIdentifier" && (originalName === "T" || originalName === "GtInternalTranslateJsx"))) return;
+	const componentErrors = [];
+	const componentWarnings = /* @__PURE__ */ new Set();
+	const metadata = {};
+	const relativeFilepath = path.relative(process.cwd(), config.file);
+	metadata.filePaths = [relativeFilepath];
+	const startLine = node.loc?.start?.line;
+	const endLine = node.loc?.end?.line;
+	if (config.includeSourceCodeContext && startLine && endLine) {
+		const entry = extractSourceCode(config.file, startLine, endLine, 5);
+		if (entry && relativeFilepath) metadata.sourceCode = { [relativeFilepath]: [entry] };
+	}
+	const unwrappedExpressions = [];
+	parseTProps({
+		openingElement,
+		metadata,
+		componentErrors,
+		file: config.file
+	});
+	const derivableTracker = { isDerivable: false };
+	const treeResult = buildJSXTree({
+		node,
+		scopeNode,
+		insideT: false,
+		inDerive: config.autoderive ?? false,
+		helperPath: scopeNode,
+		config,
+		state: {
+			visited: null,
+			callStack: [],
+			derivableTracker,
+			importedFunctionsMap: state.importedFunctionsMap
+		},
+		output: {
+			unwrappedExpressions,
+			errors: componentErrors,
+			warnings: componentWarnings
+		}
+	});
+	const jsxTree = isElementNode(treeResult) && treeResult.props?.children ? treeResult.props.children : treeResult;
+	if (componentWarnings.size > 0) componentWarnings.forEach((warning) => output.warnings.add(warning));
+	if (componentErrors.length > 0) {
+		output.errors.push(...componentErrors);
+		return;
+	}
+	const multipliedTrees = multiplyJsxTree(handleChildrenWhitespace(jsxTree));
+	const minifiedTress = [];
+	for (const multipliedTree of multipliedTrees) {
+		const minifiedTree = addGTIdentifierToSyntaxTree(multipliedTree, 0, config.enableAutoJsxInjection ? new Set(Object.values(config.importAliases).filter((name) => VARIABLE_COMPONENTS.includes(name) && name !== "Derive" && name !== "Static")) : void 0);
+		minifiedTress.push(Array.isArray(minifiedTree) && minifiedTree.length === 1 ? minifiedTree[0] : minifiedTree);
+	}
+	if (unwrappedExpressions.length > 0) {
+		output.errors.push(warnHasUnwrappedExpressionSync(config.file, unwrappedExpressions, metadata.id, `${node.loc?.start?.line}:${node.loc?.start?.column}`));
+		return;
+	}
+	const temporaryDeriveId = `derive-temp-id-${randomUUID()}`;
+	let contextVariants;
+	if (metadata._contextDeriveExpr) {
+		const contextExpr = metadata._contextDeriveExpr;
+		delete metadata._contextDeriveExpr;
+		const contextNode = handleDerivation({
+			expr: contextExpr,
+			tPath: scopeNode,
+			file: config.file,
+			parsingOptions: config.parsingOptions,
+			errors: componentErrors,
+			warnings: componentWarnings
+		});
+		if (contextNode) contextVariants = nodeToStrings(contextNode);
+	}
+	for (const minifiedTree of minifiedTress) {
+		const cleanedTree = removeNullChildrenFields(minifiedTree);
+		if (contextVariants) for (const context of contextVariants) updates.push({
+			dataFormat: "JSX",
+			source: cleanedTree,
+			metadata: {
+				...structuredClone(metadata),
+				context,
+				staticId: temporaryDeriveId
+			}
+		});
+		else updates.push({
+			dataFormat: "JSX",
+			source: cleanedTree,
+			metadata: {
+				...structuredClone(metadata),
+				...derivableTracker.isDerivable && { staticId: temporaryDeriveId }
+			}
+		});
+	}
 }
-function resolveDeriveFunctionInvocationFromBinding({ calleeBinding, callee, config, state, output, }) {
-    function withRecusionGuard({ cb, filename, functionName, }) {
-        const cacheKey = `${filename}::${functionName}`;
-        if (state.callStack.includes(cacheKey)) {
-            output.errors.push(warnRecursiveFunctionCallSync(config.file, functionName));
-            return null;
-        }
-        state.callStack.push(cacheKey);
-        const result = cb();
-        state.callStack.pop();
-        return result;
-    }
-    // check for recursive calls
-    if (calleeBinding.path.isFunctionDeclaration()) {
-        // Handle function declarations: function getSubject() { ... }
-        const functionName = callee.name;
-        const path = calleeBinding.path;
-        return withRecusionGuard({
-            filename: config.file,
-            functionName,
-            cb: () => processFunctionDeclarationNodePath({
-                config,
-                state,
-                output,
-                path,
-            }),
-        });
-    }
-    else if (calleeBinding.path.isVariableDeclarator() &&
-        calleeBinding.path.node.init &&
-        (t.isArrowFunctionExpression(calleeBinding.path.node.init) ||
-            t.isFunctionExpression(calleeBinding.path.node.init))) {
-        // Handle arrow functions assigned to variables: const getData = (t) => {...}
-        const functionName = callee.name;
-        const path = calleeBinding.path;
-        return withRecusionGuard({
-            filename: config.file,
-            functionName,
-            cb: () => processVariableDeclarationNodePath({
-                config,
-                state,
-                output,
-                functionName,
-                path,
-            }),
-        });
-    }
-    else if (state.importedFunctionsMap.has(callee.name)) {
-        // Get the original function name
-        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;
-        }
-        // Function is being imported
-        const importPath = state.importedFunctionsMap.get(callee.name);
-        const filePath = resolveImportPath(config.file, importPath, config.parsingOptions, resolveImportPathCache);
-        if (filePath && originalName) {
-            const result = withRecusionGuard({
-                filename: filePath,
-                functionName: originalName,
-                cb: () => processFunctionInFile({
-                    config,
-                    state,
-                    output,
-                    filePath,
-                    functionName: originalName,
-                }),
-            });
-            if (result !== null) {
-                return result;
-            }
-        }
-    }
-    output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
-    return null;
+function resolveDeriveFunctionInvocationFromBinding({ calleeBinding, callee, config, state, output }) {
+	function withRecusionGuard({ cb, filename, functionName }) {
+		const cacheKey = `${filename}::${functionName}`;
+		if (state.callStack.includes(cacheKey)) {
+			output.errors.push(warnRecursiveFunctionCallSync(config.file, functionName));
+			return null;
+		}
+		state.callStack.push(cacheKey);
+		const result = cb();
+		state.callStack.pop();
+		return result;
+	}
+	if (calleeBinding.path.isFunctionDeclaration()) {
+		const functionName = callee.name;
+		const path = calleeBinding.path;
+		return withRecusionGuard({
+			filename: config.file,
+			functionName,
+			cb: () => processFunctionDeclarationNodePath({
+				config,
+				state,
+				output,
+				path
+			})
+		});
+	} else if (calleeBinding.path.isVariableDeclarator() && calleeBinding.path.node.init && (t.isArrowFunctionExpression(calleeBinding.path.node.init) || t.isFunctionExpression(calleeBinding.path.node.init))) {
+		const functionName = callee.name;
+		const path = calleeBinding.path;
+		return withRecusionGuard({
+			filename: config.file,
+			functionName,
+			cb: () => processVariableDeclarationNodePath({
+				config,
+				state,
+				output,
+				functionName,
+				path
+			})
+		});
+	} else if (state.importedFunctionsMap.has(callee.name)) {
+		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 = state.importedFunctionsMap.get(callee.name);
+		const filePath = resolveImportPath(config.file, importPath, config.parsingOptions, resolveImportPathCache);
+		if (filePath && originalName) {
+			const result = withRecusionGuard({
+				filename: filePath,
+				functionName: originalName,
+				cb: () => processFunctionInFile({
+					config,
+					state,
+					output,
+					filePath,
+					functionName: originalName
+				})
+			});
+			if (result !== null) return result;
+		}
+	}
+	output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
+	return null;
 }
 /**
- * Searches for a specific user-defined function in a file.
- * This is the resolution logic
- *
- * Handles multiple function declaration patterns:
- * - function getInfo() { ... }
- * - export function getInfo() { ... }
- * - const getInfo = () => { ... }
- *
- * If the function is not found in the file, follows re-exports (export * from './other')
- */
-function processFunctionInFile({ config, state, output, filePath, functionName, }) {
-    // Create a custom key for the function call
-    const cacheKey = `${filePath}::${functionName}`;
-    // Check cache first to avoid redundant parsing
-    if (processFunctionCache.has(cacheKey)) {
-        return processFunctionCache.get(cacheKey) ?? null;
-    }
-    // Prevent infinite loops from circular re-exports
-    if (state.visited && state.visited.has(filePath)) {
-        return null;
-    }
-    if (state.visited) {
-        state.visited.add(filePath);
-    }
-    let result = undefined;
-    try {
-        const code = fs.readFileSync(filePath, 'utf8');
-        const ast = parse(code, {
-            sourceType: 'module',
-            plugins: ['jsx', 'typescript'],
-        });
-        const pathsResult = getPathsAndAliases(ast, config.pkgs);
-        const importAliases = { ...pathsResult.importAliases };
-        // Merge translation component names into importAliases so
-        // autoInsertJsxComponents can recognize user T/Var and skip them
-        for (const { localName, originalName, } of pathsResult.translationComponentPaths) {
-            importAliases[localName] = originalName;
-        }
-        // Auto-inject T/Var into the cross-file AST when enabled,
-        // so that Derive extraction sees the same structure as same-file
-        if (config.enableAutoJsxInjection) {
-            ensureTAndVarImported(ast, importAliases);
-            autoInsertJsxComponents(ast, importAliases);
-        }
-        // Collect all imports in this file to track cross-file function calls
-        let importedFunctionsMap = new Map();
-        traverse(ast, {
-            Program(path) {
-                importedFunctionsMap = buildImportMap(path);
-            },
-        });
-        const reExports = [];
-        const warnDuplicateFuncDef = (path) => {
-            output.warnings.add(warnDuplicateFunctionDefinitionSync(filePath, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
-        };
-        traverse(ast, {
-            // Handle function declarations: function getInfo() { ... }
-            FunctionDeclaration(path) {
-                if (path.node.id?.name === functionName) {
-                    if (result !== undefined)
-                        return warnDuplicateFuncDef(path);
-                    result = processFunctionDeclarationNodePath({
-                        config: {
-                            importAliases,
-                            parsingOptions: config.parsingOptions,
-                            pkgs: config.pkgs,
-                            file: filePath,
-                            enableAutoJsxInjection: config.enableAutoJsxInjection,
-                        },
-                        state: {
-                            ...state,
-                            importedFunctionsMap,
-                        },
-                        output,
-                        path,
-                    });
-                }
-            },
-            // Handle variable declarations: const getInfo = () => { ... }
-            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))) {
-                    if (result !== undefined)
-                        return warnDuplicateFuncDef(path);
-                    result = processVariableDeclarationNodePath({
-                        config: {
-                            importAliases,
-                            parsingOptions: config.parsingOptions,
-                            pkgs: config.pkgs,
-                            file: filePath,
-                            enableAutoJsxInjection: config.enableAutoJsxInjection,
-                        },
-                        state: {
-                            ...state,
-                            importedFunctionsMap,
-                        },
-                        output,
-                        functionName,
-                        path,
-                    });
-                }
-            },
-            // Collect re-exports: export * from './other'
-            ExportAllDeclaration(path) {
-                if (t.isStringLiteral(path.node.source)) {
-                    reExports.push(path.node.source.value);
-                }
-            },
-            // Collect named re-exports: export { foo } from './other'
-            ExportNamedDeclaration(path) {
-                if (path.node.source && t.isStringLiteral(path.node.source)) {
-                    // Check if this export includes our function
-                    const exportsFunction = 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 (exportsFunction) {
-                        reExports.push(path.node.source.value);
-                    }
-                }
-            },
-        });
-        // If function not found, follow re-exports
-        if (result === undefined && reExports.length > 0) {
-            for (const reExportPath of reExports) {
-                const resolvedPath = resolveImportPath(filePath, reExportPath, config.parsingOptions, resolveImportPathCache);
-                if (resolvedPath) {
-                    const foundResult = processFunctionInFile({
-                        config: {
-                            importAliases,
-                            parsingOptions: config.parsingOptions,
-                            pkgs: config.pkgs,
-                            file: filePath,
-                            enableAutoJsxInjection: config.enableAutoJsxInjection,
-                        },
-                        state: {
-                            ...state,
-                            importedFunctionsMap,
-                        },
-                        output,
-                        filePath: resolvedPath,
-                        functionName,
-                    });
-                    if (foundResult != null) {
-                        result = foundResult;
-                        break;
-                    }
-                }
-            }
-        }
-        // Mark this function search as processed in the cache
-        processFunctionCache.set(cacheKey, result !== undefined ? result : null);
-    }
-    catch {
-        // Silently skip files that can't be parsed or accessed
-        // Still mark as processed to avoid retrying failed parses
-        processFunctionCache.set(cacheKey, null);
-    }
-    return result !== undefined ? result : null;
+* Searches for a specific user-defined function in a file.
+* This is the resolution logic
+*
+* Handles multiple function declaration patterns:
+* - function getInfo() { ... }
+* - export function getInfo() { ... }
+* - const getInfo = () => { ... }
+*
+* If the function is not found in the file, follows re-exports (export * from './other')
+*/
+function processFunctionInFile({ config, state, output, filePath, functionName }) {
+	const cacheKey = `${filePath}::${functionName}`;
+	if (processFunctionCache.has(cacheKey)) return processFunctionCache.get(cacheKey) ?? null;
+	if (state.visited && state.visited.has(filePath)) return null;
+	if (state.visited) state.visited.add(filePath);
+	let result = void 0;
+	try {
+		const ast = parse(fs.readFileSync(filePath, "utf8"), {
+			sourceType: "module",
+			plugins: ["jsx", "typescript"]
+		});
+		const pathsResult = getPathsAndAliases(ast, config.pkgs);
+		const importAliases = { ...pathsResult.importAliases };
+		for (const { localName, originalName } of pathsResult.translationComponentPaths) importAliases[localName] = originalName;
+		if (config.enableAutoJsxInjection) {
+			ensureTAndVarImported(ast, importAliases);
+			autoInsertJsxComponents(ast, importAliases);
+		}
+		let importedFunctionsMap = /* @__PURE__ */ new Map();
+		traverse(ast, { Program(path) {
+			importedFunctionsMap = buildImportMap(path);
+		} });
+		const reExports = [];
+		const warnDuplicateFuncDef = (path) => {
+			output.warnings.add(warnDuplicateFunctionDefinitionSync(filePath, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
+		};
+		traverse(ast, {
+			FunctionDeclaration(path) {
+				if (path.node.id?.name === functionName) {
+					if (result !== void 0) return warnDuplicateFuncDef(path);
+					result = processFunctionDeclarationNodePath({
+						config: {
+							importAliases,
+							parsingOptions: config.parsingOptions,
+							pkgs: config.pkgs,
+							file: filePath,
+							enableAutoJsxInjection: config.enableAutoJsxInjection
+						},
+						state: {
+							...state,
+							importedFunctionsMap
+						},
+						output,
+						path
+					});
+				}
+			},
+			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))) {
+					if (result !== void 0) return warnDuplicateFuncDef(path);
+					result = processVariableDeclarationNodePath({
+						config: {
+							importAliases,
+							parsingOptions: config.parsingOptions,
+							pkgs: config.pkgs,
+							file: filePath,
+							enableAutoJsxInjection: config.enableAutoJsxInjection
+						},
+						state: {
+							...state,
+							importedFunctionsMap
+						},
+						output,
+						functionName,
+						path
+					});
+				}
+			},
+			ExportAllDeclaration(path) {
+				if (t.isStringLiteral(path.node.source)) reExports.push(path.node.source.value);
+			},
+			ExportNamedDeclaration(path) {
+				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;
+					})) reExports.push(path.node.source.value);
+				}
+			}
+		});
+		if (result === void 0 && reExports.length > 0) for (const reExportPath of reExports) {
+			const resolvedPath = resolveImportPath(filePath, reExportPath, config.parsingOptions, resolveImportPathCache);
+			if (resolvedPath) {
+				const foundResult = processFunctionInFile({
+					config: {
+						importAliases,
+						parsingOptions: config.parsingOptions,
+						pkgs: config.pkgs,
+						file: filePath,
+						enableAutoJsxInjection: config.enableAutoJsxInjection
+					},
+					state: {
+						...state,
+						importedFunctionsMap
+					},
+					output,
+					filePath: resolvedPath,
+					functionName
+				});
+				if (foundResult != null) {
+					result = foundResult;
+					break;
+				}
+			}
+		}
+		processFunctionCache.set(cacheKey, result !== void 0 ? result : null);
+	} catch {
+		processFunctionCache.set(cacheKey, null);
+	}
+	return result !== void 0 ? result : null;
 }
 /**
- * Process a function declaration
- * function getInfo() { ... }
- */
-function processFunctionDeclarationNodePath({ config, state, output, path, }) {
-    const result = {
-        nodeType: 'multiplication',
-        branches: [],
-    };
-    path.traverse({
-        Function(path) {
-            path.skip();
-        },
-        ReturnStatement(returnPath) {
-            const returnNodePath = returnPath.get('argument');
-            if (!returnNodePath.isExpression()) {
-                return;
-            }
-            const deriveResult = processDeriveExpression({
-                config,
-                state,
-                output,
-                expressionNodePath: returnNodePath,
-                scopeNode: returnPath,
-            });
-            if (Array.isArray(deriveResult)) {
-                result.branches.push(...deriveResult);
-            }
-            else {
-                result.branches.push(deriveResult);
-            }
-        },
-    });
-    if (result.branches.length === 0) {
-        return null;
-    }
-    return result;
+* Process a function declaration
+* function getInfo() { ... }
+*/
+function processFunctionDeclarationNodePath({ config, state, output, path }) {
+	const result = {
+		nodeType: "multiplication",
+		branches: []
+	};
+	path.traverse({
+		Function(path) {
+			path.skip();
+		},
+		ReturnStatement(returnPath) {
+			const returnNodePath = returnPath.get("argument");
+			if (!returnNodePath.isExpression()) return;
+			const deriveResult = processDeriveExpression({
+				config,
+				state,
+				output,
+				expressionNodePath: returnNodePath,
+				scopeNode: returnPath
+			});
+			if (Array.isArray(deriveResult)) result.branches.push(...deriveResult);
+			else result.branches.push(deriveResult);
+		}
+	});
+	if (result.branches.length === 0) return null;
+	return result;
 }
 /**
- * Process a variable declaration of a function
- * const getInfo = () => { ... }
- *
- * IMPORTANT: the RHand value must be the function definition, or this will fail
- */
-function processVariableDeclarationNodePath({ config, state, output, functionName, path, }) {
-    const result = {
-        nodeType: 'multiplication',
-        branches: [],
-    };
-    // Enforce the Rhand is a function definition
-    const arrowFunctionPath = path.get('init');
-    if (!arrowFunctionPath.isArrowFunctionExpression()) {
-        output.errors.push(warnInvalidDeriveInitSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
-        return null;
-    }
-    const bodyNodePath = arrowFunctionPath.get('body');
-    if (bodyNodePath.isExpression()) {
-        // process expression return
-        const deriveResult = processDeriveExpression({
-            config,
-            state,
-            output,
-            expressionNodePath: bodyNodePath,
-            scopeNode: arrowFunctionPath,
-        });
-        if (Array.isArray(deriveResult)) {
-            result.branches.push(...deriveResult);
-        }
-        else {
-            result.branches.push(deriveResult);
-        }
-    }
-    else {
-        // search for a return statement
-        bodyNodePath.traverse({
-            Function(path) {
-                path.skip();
-            },
-            ReturnStatement(returnPath) {
-                const returnNodePath = returnPath.get('argument');
-                if (!returnNodePath.isExpression()) {
-                    return;
-                }
-                const deriveResult = processDeriveExpression({
-                    config,
-                    state,
-                    output,
-                    expressionNodePath: returnNodePath,
-                    scopeNode: returnPath,
-                });
-                if (Array.isArray(deriveResult)) {
-                    result.branches.push(...deriveResult);
-                }
-                else {
-                    result.branches.push(deriveResult);
-                }
-            },
-        });
-    }
-    if (result.branches.length === 0) {
-        output.errors.push(warnMissingReturnSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
-        return null;
-    }
-    return result;
+* Process a variable declaration of a function
+* const getInfo = () => { ... }
+*
+* IMPORTANT: the RHand value must be the function definition, or this will fail
+*/
+function processVariableDeclarationNodePath({ config, state, output, functionName, path }) {
+	const result = {
+		nodeType: "multiplication",
+		branches: []
+	};
+	const arrowFunctionPath = path.get("init");
+	if (!arrowFunctionPath.isArrowFunctionExpression()) {
+		output.errors.push(warnInvalidDeriveInitSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
+		return null;
+	}
+	const bodyNodePath = arrowFunctionPath.get("body");
+	if (bodyNodePath.isExpression()) {
+		const deriveResult = processDeriveExpression({
+			config,
+			state,
+			output,
+			expressionNodePath: bodyNodePath,
+			scopeNode: arrowFunctionPath
+		});
+		if (Array.isArray(deriveResult)) result.branches.push(...deriveResult);
+		else result.branches.push(deriveResult);
+	} else bodyNodePath.traverse({
+		Function(path) {
+			path.skip();
+		},
+		ReturnStatement(returnPath) {
+			const returnNodePath = returnPath.get("argument");
+			if (!returnNodePath.isExpression()) return;
+			const deriveResult = processDeriveExpression({
+				config,
+				state,
+				output,
+				expressionNodePath: returnNodePath,
+				scopeNode: returnPath
+			});
+			if (Array.isArray(deriveResult)) result.branches.push(...deriveResult);
+			else result.branches.push(deriveResult);
+		}
+	});
+	if (result.branches.length === 0) {
+		output.errors.push(warnMissingReturnSync(config.file, functionName, `${path.node.loc?.start?.line}:${path.node.loc?.start?.column}`));
+		return null;
+	}
+	return result;
 }
 /**
- * Process a <Derive> expression
- */
-function processDeriveExpression({ config, state, output, expressionNodePath, scopeNode, }) {
-    // Mark the derivable tracker as true
-    state.derivableTracker.isDerivable = true;
-    // Remove parentheses if they exist
-    if (t.isParenthesizedExpression(expressionNodePath.node)) {
-        // ex: return (value)
-        return processDeriveExpression({
-            config,
-            state,
-            output,
-            scopeNode,
-            expressionNodePath: expressionNodePath.get('expression'),
-        });
-    }
-    else if (t.isCallExpression(expressionNodePath.node) &&
-        t.isIdentifier(expressionNodePath.node.callee)) {
-        // ex: return someFunc()
-        const callee = expressionNodePath.node.callee;
-        const calleeBinding = scopeNode.scope.getBinding(callee.name);
-        if (!calleeBinding) {
-            output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
-            return null;
-        }
-        // Function is found
-        return resolveDeriveFunctionInvocationFromBinding({
-            calleeBinding,
-            callee,
-            config,
-            state,
-            output,
-        });
-    }
-    else if (t.isAwaitExpression(expressionNodePath.node) &&
-        t.isCallExpression(expressionNodePath.node.argument) &&
-        t.isIdentifier(expressionNodePath.node.argument.callee)) {
-        // ex: return await someFunc()
-        const callee = expressionNodePath.node.argument.callee;
-        const calleeBinding = scopeNode.scope.getBinding(callee.name);
-        if (!calleeBinding) {
-            output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
-            return null;
-        }
-        // Function is found
-        return resolveDeriveFunctionInvocationFromBinding({
-            calleeBinding,
-            callee,
-            config,
-            state,
-            output,
-        });
-    }
-    else if (t.isJSXElement(expressionNodePath.node) ||
-        t.isJSXFragment(expressionNodePath.node)) {
-        // ex: return <div>Jsx content</div>
-        return buildJSXTree({
-            node: expressionNodePath.node,
-            helperPath: expressionNodePath,
-            scopeNode,
-            insideT: true,
-            inDerive: true,
-            config,
-            state,
-            output,
-        });
-    }
-    else if (t.isConditionalExpression(expressionNodePath.node)) {
-        // ex: return condition ? <div>Jsx content</div> : <div>Jsx content</div>
-        // since two options here we must construct a new multiplication node
-        const consequentNodePath = expressionNodePath.get('consequent');
-        const alternateNodePath = expressionNodePath.get('alternate');
-        const result = {
-            nodeType: 'multiplication',
-            branches: [consequentNodePath, alternateNodePath].flatMap((expressionNodePath) => {
-                const r = processDeriveExpression({
-                    config,
-                    state,
-                    output,
-                    scopeNode,
-                    expressionNodePath,
-                });
-                return Array.isArray(r) ? r : [r];
-            }),
-        };
-        return result;
-    }
-    else if (t.isIdentifier(expressionNodePath.node)) {
-        // Resolve variable declarations: const label = cond ? "boy" : "girl"
-        const name = expressionNodePath.node.name;
-        const binding = scopeNode.scope.getBinding(name);
-        if (binding &&
-            binding.path.isVariableDeclarator() &&
-            binding.path.node.init) {
-            // Reject destructuring patterns
-            if (t.isObjectPattern(binding.path.node.id) ||
-                t.isArrayPattern(binding.path.node.id)) {
-                output.errors.push(warnDeriveDestructuringSync(config.file, name, `${expressionNodePath.node.loc?.start?.line}:${expressionNodePath.node.loc?.start?.column}`));
-                return null;
-            }
-            // Enforce const-only
-            const declaration = binding.path.parentPath;
-            if (declaration?.isVariableDeclaration() &&
-                declaration.node.kind !== 'const') {
-                output.warnings.add(warnDeriveNonConstVariableSync(config.file, name, declaration.node.kind, `${expressionNodePath.node.loc?.start?.line}:${expressionNodePath.node.loc?.start?.column}`));
-                return null;
-            }
-            // Resolve via parseStringExpression (handles all derivable expression types)
-            const errorsBefore = output.errors.length;
-            const stringNode = parseStringExpression(binding.path.node.init, binding.path, config.file, config.parsingOptions, output.warnings, output.errors);
-            if (stringNode) {
-                const strings = nodeToStrings(stringNode);
-                if (strings.length === 0) {
-                    return null;
-                }
-                if (strings.length === 1) {
-                    return strings[0];
-                }
-                return {
-                    nodeType: 'multiplication',
-                    branches: strings.map((s) => s),
-                };
-            }
-            // parseStringExpression returned null — if it already pushed errors,
-            // avoid double-reporting by skipping the buildJSXTree fallthrough.
-            if (output.errors.length > errorsBefore) {
-                return null;
-            }
-        }
-        // Not resolvable — fall through to existing buildJSXTree behavior
-        return buildJSXTree({
-            node: expressionNodePath.node,
-            helperPath: expressionNodePath,
-            scopeNode,
-            insideT: true,
-            inDerive: true,
-            config,
-            state,
-            output,
-        });
-    }
-    else {
-        return buildJSXTree({
-            node: expressionNodePath.node,
-            helperPath: expressionNodePath,
-            scopeNode,
-            insideT: true,
-            inDerive: true,
-            config,
-            state,
-            output,
-        });
-    }
+* Process a <Derive> expression
+*/
+function processDeriveExpression({ config, state, output, expressionNodePath, scopeNode }) {
+	state.derivableTracker.isDerivable = true;
+	if (t.isParenthesizedExpression(expressionNodePath.node)) return processDeriveExpression({
+		config,
+		state,
+		output,
+		scopeNode,
+		expressionNodePath: expressionNodePath.get("expression")
+	});
+	else if (t.isCallExpression(expressionNodePath.node) && t.isIdentifier(expressionNodePath.node.callee)) {
+		const callee = expressionNodePath.node.callee;
+		const calleeBinding = scopeNode.scope.getBinding(callee.name);
+		if (!calleeBinding) {
+			output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
+			return null;
+		}
+		return resolveDeriveFunctionInvocationFromBinding({
+			calleeBinding,
+			callee,
+			config,
+			state,
+			output
+		});
+	} else if (t.isAwaitExpression(expressionNodePath.node) && t.isCallExpression(expressionNodePath.node.argument) && t.isIdentifier(expressionNodePath.node.argument.callee)) {
+		const callee = expressionNodePath.node.argument.callee;
+		const calleeBinding = scopeNode.scope.getBinding(callee.name);
+		if (!calleeBinding) {
+			output.warnings.add(warnFunctionNotFoundSync(config.file, callee.name, `${callee.loc?.start?.line}:${callee.loc?.start?.column}`));
+			return null;
+		}
+		return resolveDeriveFunctionInvocationFromBinding({
+			calleeBinding,
+			callee,
+			config,
+			state,
+			output
+		});
+	} else if (t.isJSXElement(expressionNodePath.node) || t.isJSXFragment(expressionNodePath.node)) return buildJSXTree({
+		node: expressionNodePath.node,
+		helperPath: expressionNodePath,
+		scopeNode,
+		insideT: true,
+		inDerive: true,
+		config,
+		state,
+		output
+	});
+	else if (t.isConditionalExpression(expressionNodePath.node)) return {
+		nodeType: "multiplication",
+		branches: [expressionNodePath.get("consequent"), expressionNodePath.get("alternate")].flatMap((expressionNodePath) => {
+			const r = processDeriveExpression({
+				config,
+				state,
+				output,
+				scopeNode,
+				expressionNodePath
+			});
+			return Array.isArray(r) ? r : [r];
+		})
+	};
+	else if (t.isIdentifier(expressionNodePath.node)) {
+		const name = expressionNodePath.node.name;
+		const binding = scopeNode.scope.getBinding(name);
+		if (binding && binding.path.isVariableDeclarator() && binding.path.node.init) {
+			if (t.isObjectPattern(binding.path.node.id) || t.isArrayPattern(binding.path.node.id)) {
+				output.errors.push(warnDeriveDestructuringSync(config.file, name, `${expressionNodePath.node.loc?.start?.line}:${expressionNodePath.node.loc?.start?.column}`));
+				return null;
+			}
+			const declaration = binding.path.parentPath;
+			if (declaration?.isVariableDeclaration() && declaration.node.kind !== "const") {
+				output.warnings.add(warnDeriveNonConstVariableSync(config.file, name, declaration.node.kind, `${expressionNodePath.node.loc?.start?.line}:${expressionNodePath.node.loc?.start?.column}`));
+				return null;
+			}
+			const errorsBefore = output.errors.length;
+			const stringNode = parseStringExpression(binding.path.node.init, binding.path, config.file, config.parsingOptions, output.warnings, output.errors);
+			if (stringNode) {
+				const strings = nodeToStrings(stringNode);
+				if (strings.length === 0) return null;
+				if (strings.length === 1) return strings[0];
+				return {
+					nodeType: "multiplication",
+					branches: strings.map((s) => s)
+				};
+			}
+			if (output.errors.length > errorsBefore) return null;
+		}
+		return buildJSXTree({
+			node: expressionNodePath.node,
+			helperPath: expressionNodePath,
+			scopeNode,
+			insideT: true,
+			inDerive: true,
+			config,
+			state,
+			output
+		});
+	} else return buildJSXTree({
+		node: expressionNodePath.node,
+		helperPath: expressionNodePath,
+		scopeNode,
+		insideT: true,
+		inDerive: true,
+		config,
+		state,
+		output
+	});
 }
+//#endregion
+export { parseTranslationComponent };
+
+//# sourceMappingURL=parseJsx.js.map