gt 2.14.35 → 2.14.37

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

@@ -1,427 +1,343 @@
+import { isStaticExpression } from "../../evaluateJsx.js";
+import { BRANCH_CONTROL_PROPS, DEFAULT_GT_IMPORT_SOURCE, INTERNAL_TRANSLATION_COMPONENT, INTERNAL_VAR_COMPONENT, PLURAL_CONTROL_PROPS, VARIABLE_COMPONENTS } from "../constants.js";
+import * as t from "@babel/types";
+import traverseModule from "@babel/traverse";
+//#region src/react/jsx/utils/jsxParsing/autoInsertion.ts
 /**
- * Auto JSX Insertion for CLI extraction.
- *
- * Inserts <T> and <Var> JSX elements into the AST so the extraction pipeline
- * can process them as if the user wrote them. This operates on raw JSX syntax
- * (JSXElement, JSXText, JSXExpressionContainer) — NOT compiled jsx() calls.
- *
- * Rules follow JSX_INSERTION_RULES.md from the compiler package.
- */
-import * as t from '@babel/types';
-import traverseModule from '@babel/traverse';
+* Auto JSX Insertion for CLI extraction.
+*
+* Inserts <T> and <Var> JSX elements into the AST so the extraction pipeline
+* can process them as if the user wrote them. This operates on raw JSX syntax
+* (JSXElement, JSXText, JSXExpressionContainer) — NOT compiled jsx() calls.
+*
+* Rules follow JSX_INSERTION_RULES.md from the compiler package.
+*/
 const traverse = traverseModule.default || traverseModule;
-import { isStaticExpression } from '../../evaluateJsx.js';
-import { TRANSLATION_COMPONENT, INTERNAL_TRANSLATION_COMPONENT, INTERNAL_VAR_COMPONENT, VARIABLE_COMPONENTS, BRANCH_COMPONENT, PLURAL_COMPONENT, DEFAULT_GT_IMPORT_SOURCE, DERIVE_COMPONENT, STATIC_COMPONENT, BRANCH_CONTROL_PROPS, PLURAL_CONTROL_PROPS, } from '../constants.js';
 /** Tracks which AST nodes were auto-inserted by this module */
-const autoInsertedNodes = new WeakSet();
+const autoInsertedNodes = /* @__PURE__ */ new WeakSet();
 /** Check if a node was auto-inserted */
-export function isAutoInserted(node) {
-    return autoInsertedNodes.has(node);
+function isAutoInserted(node) {
+	return autoInsertedNodes.has(node);
 }
-// ===== Public API ===== //
 /**
- * Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST.
- * Always adds: import { GtInternalTranslateJsx, GtInternalVar } from 'gt-react/browser';
- * These are distinct from user T/Var so there's no ambiguity.
- *
- * Updates importAliases in-place.
- */
-export function ensureTAndVarImported(ast, importAliases) {
-    // Check if internal components are already imported
-    const hasInternalT = Object.values(importAliases).includes(INTERNAL_TRANSLATION_COMPONENT);
-    const hasInternalVar = Object.values(importAliases).includes(INTERNAL_VAR_COMPONENT);
-    if (hasInternalT && hasInternalVar)
-        return;
-    const specifiers = [];
-    if (!hasInternalT) {
-        specifiers.push(t.importSpecifier(t.identifier(INTERNAL_TRANSLATION_COMPONENT), t.identifier(INTERNAL_TRANSLATION_COMPONENT)));
-        importAliases[INTERNAL_TRANSLATION_COMPONENT] =
-            INTERNAL_TRANSLATION_COMPONENT;
-    }
-    if (!hasInternalVar) {
-        specifiers.push(t.importSpecifier(t.identifier(INTERNAL_VAR_COMPONENT), t.identifier(INTERNAL_VAR_COMPONENT)));
-        importAliases[INTERNAL_VAR_COMPONENT] = INTERNAL_VAR_COMPONENT;
-    }
-    const importDecl = t.importDeclaration(specifiers, t.stringLiteral(DEFAULT_GT_IMPORT_SOURCE));
-    traverse(ast, {
-        Program(path) {
-            path.unshiftContainer('body', importDecl);
-            path.stop();
-        },
-    });
+* Ensure GtInternalTranslateJsx and GtInternalVar are imported in the AST.
+* Always adds: import { GtInternalTranslateJsx, GtInternalVar } from 'gt-react/browser';
+* These are distinct from user T/Var so there's no ambiguity.
+*
+* Updates importAliases in-place.
+*/
+function ensureTAndVarImported(ast, importAliases) {
+	const hasInternalT = Object.values(importAliases).includes(INTERNAL_TRANSLATION_COMPONENT);
+	const hasInternalVar = Object.values(importAliases).includes(INTERNAL_VAR_COMPONENT);
+	if (hasInternalT && hasInternalVar) return;
+	const specifiers = [];
+	if (!hasInternalT) {
+		specifiers.push(t.importSpecifier(t.identifier(INTERNAL_TRANSLATION_COMPONENT), t.identifier(INTERNAL_TRANSLATION_COMPONENT)));
+		importAliases[INTERNAL_TRANSLATION_COMPONENT] = INTERNAL_TRANSLATION_COMPONENT;
+	}
+	if (!hasInternalVar) {
+		specifiers.push(t.importSpecifier(t.identifier(INTERNAL_VAR_COMPONENT), t.identifier(INTERNAL_VAR_COMPONENT)));
+		importAliases[INTERNAL_VAR_COMPONENT] = INTERNAL_VAR_COMPONENT;
+	}
+	const importDecl = t.importDeclaration(specifiers, t.stringLiteral(DEFAULT_GT_IMPORT_SOURCE));
+	traverse(ast, { Program(path) {
+		path.unshiftContainer("body", importDecl);
+		path.stop();
+	} });
 }
 /**
- * Traverse the AST and insert GtInternalTranslateJsx and GtInternalVar JSX elements following
- * the insertion rules. Uses deliberate children traversal.
- *
- * Every inserted node gets node._autoInserted = true.
- */
-export function autoInsertJsxComponents(ast, importAliases) {
-    const processedNodes = new WeakSet();
-    const tLocalName = getLocalName(importAliases, INTERNAL_TRANSLATION_COMPONENT);
-    const varLocalName = getLocalName(importAliases, INTERNAL_VAR_COMPONENT);
-    traverse(ast, {
-        JSXElement(path) {
-            if (processedNodes.has(path.node))
-                return;
-            processJsxElement({
-                path,
-                insideAutoT: false,
-                importAliases,
-                processedNodes,
-                tLocalName,
-                varLocalName,
-            });
-        },
-        JSXFragment(path) {
-            if (processedNodes.has(path.node))
-                return;
-            processJsxFragment({
-                path,
-                insideAutoT: false,
-                importAliases,
-                processedNodes,
-                tLocalName,
-                varLocalName,
-            });
-        },
-    });
+* Traverse the AST and insert GtInternalTranslateJsx and GtInternalVar JSX elements following
+* the insertion rules. Uses deliberate children traversal.
+*
+* Every inserted node gets node._autoInserted = true.
+*/
+function autoInsertJsxComponents(ast, importAliases) {
+	const processedNodes = /* @__PURE__ */ new WeakSet();
+	const tLocalName = getLocalName(importAliases, INTERNAL_TRANSLATION_COMPONENT);
+	const varLocalName = getLocalName(importAliases, INTERNAL_VAR_COMPONENT);
+	traverse(ast, {
+		JSXElement(path) {
+			if (processedNodes.has(path.node)) return;
+			processJsxElement({
+				path,
+				insideAutoT: false,
+				importAliases,
+				processedNodes,
+				tLocalName,
+				varLocalName
+			});
+		},
+		JSXFragment(path) {
+			if (processedNodes.has(path.node)) return;
+			processJsxFragment({
+				path,
+				insideAutoT: false,
+				importAliases,
+				processedNodes,
+				tLocalName,
+				varLocalName
+			});
+		}
+	});
 }
-function processJsxElement({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
-    processedNodes.add(path.node);
-    // Get component type
-    const typeName = getElementTypeName(path.node);
-    const canonicalName = typeName ? importAliases[typeName] : undefined;
-    // User T → mark all descendants, hands off
-    if (canonicalName === TRANSLATION_COMPONENT) {
-        markDescendantJsx(path, processedNodes);
-        return;
-    }
-    // Branch/Plural/Derive/Static → opaque, process props for dynamic Var
-    // Must be checked BEFORE user variable check because Derive/Static are in VARIABLE_COMPONENTS
-    if (canonicalName === BRANCH_COMPONENT ||
-        canonicalName === PLURAL_COMPONENT ||
-        canonicalName === DERIVE_COMPONENT ||
-        canonicalName === STATIC_COMPONENT) {
-        if (!insideAutoT) {
-            // Root-level opaque component — wrap in _T
-            const tWrapper = createTWrapper([path.node], tLocalName);
-            processedNodes.add(tWrapper);
-            path.replaceWith(tWrapper);
-        }
-        processOpaqueComponentProps({
-            path,
-            insideAutoT: true,
-            importAliases,
-            processedNodes,
-            tLocalName,
-            varLocalName,
-            canonicalName,
-        });
-        return;
-    }
-    // User Var/Num/Currency/DateTime → mark descendants, hands off
-    if (canonicalName && VARIABLE_COMPONENTS.includes(canonicalName)) {
-        markDescendantJsx(path, processedNodes);
-        return;
-    }
-    // Process children
-    processElementChildren({
-        path,
-        insideAutoT,
-        importAliases,
-        processedNodes,
-        tLocalName,
-        varLocalName,
-    });
+function processJsxElement({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName }) {
+	processedNodes.add(path.node);
+	const typeName = getElementTypeName(path.node);
+	const canonicalName = typeName ? importAliases[typeName] : void 0;
+	if (canonicalName === "T") {
+		markDescendantJsx(path, processedNodes);
+		return;
+	}
+	if (canonicalName === "Branch" || canonicalName === "Plural" || canonicalName === "Derive" || canonicalName === "Static") {
+		if (!insideAutoT) {
+			const tWrapper = createTWrapper([path.node], tLocalName);
+			processedNodes.add(tWrapper);
+			path.replaceWith(tWrapper);
+		}
+		processOpaqueComponentProps({
+			path,
+			insideAutoT: true,
+			importAliases,
+			processedNodes,
+			tLocalName,
+			varLocalName,
+			canonicalName
+		});
+		return;
+	}
+	if (canonicalName && VARIABLE_COMPONENTS.includes(canonicalName)) {
+		markDescendantJsx(path, processedNodes);
+		return;
+	}
+	processElementChildren({
+		path,
+		insideAutoT,
+		importAliases,
+		processedNodes,
+		tLocalName,
+		varLocalName
+	});
 }
-function processJsxFragment({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
-    processedNodes.add(path.node);
-    // Fragments are treated like regular elements
-    processFragmentChildren({
-        path,
-        insideAutoT,
-        importAliases,
-        processedNodes,
-        tLocalName,
-        varLocalName,
-    });
+function processJsxFragment({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName }) {
+	processedNodes.add(path.node);
+	processFragmentChildren({
+		path,
+		insideAutoT,
+		importAliases,
+		processedNodes,
+		tLocalName,
+		varLocalName
+	});
 }
-// ===== Children processing ===== //
-function processElementChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
-    const children = path.node.children;
-    const ctx = {
-        insideAutoT,
-        importAliases,
-        processedNodes,
-        tLocalName,
-        varLocalName,
-    };
-    const hasText = hasTranslatableText(children);
-    const hasOpaque = hasOpaqueGTChild(children, importAliases);
-    const shouldClaimT = !insideAutoT && (hasText || hasOpaque);
-    if (shouldClaimT) {
-        // Process children: wrap dynamic expressions in Var, recurse into child elements
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            processChild(childPath, { ...ctx, insideAutoT: true });
-        }
-        // Wrap all children in <T>
-        wrapChildrenInT(path, tLocalName, processedNodes);
-    }
-    else if (insideAutoT) {
-        // Inside a T region: wrap dynamic expressions, recurse
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            processChild(childPath, ctx);
-        }
-    }
-    else {
-        // No text, no opaque, not inside T: just recurse into child elements
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) {
-                processJsxElement({ path: childPath, ...ctx });
-            }
-            else if (childPath.isJSXFragment() &&
-                !processedNodes.has(childPath.node)) {
-                processJsxFragment({ path: childPath, ...ctx });
-            }
-        }
-    }
+function processElementChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName }) {
+	const children = path.node.children;
+	const ctx = {
+		insideAutoT,
+		importAliases,
+		processedNodes,
+		tLocalName,
+		varLocalName
+	};
+	const hasText = hasTranslatableText(children);
+	const hasOpaque = hasOpaqueGTChild(children, importAliases);
+	if (!insideAutoT && (hasText || hasOpaque)) {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) processChild(childPath, {
+			...ctx,
+			insideAutoT: true
+		});
+		wrapChildrenInT(path, tLocalName, processedNodes);
+	} else if (insideAutoT) {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) processChild(childPath, ctx);
+	} else {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) processJsxElement({
+			path: childPath,
+			...ctx
+		});
+		else if (childPath.isJSXFragment() && !processedNodes.has(childPath.node)) processJsxFragment({
+			path: childPath,
+			...ctx
+		});
+	}
 }
-function processFragmentChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, }) {
-    const children = path.node.children;
-    const ctx = {
-        insideAutoT,
-        importAliases,
-        processedNodes,
-        tLocalName,
-        varLocalName,
-    };
-    const hasText = hasTranslatableText(children);
-    const hasOpaque = hasOpaqueGTChild(children, importAliases);
-    const shouldClaimT = !insideAutoT && (hasText || hasOpaque);
-    if (shouldClaimT) {
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            processChild(childPath, { ...ctx, insideAutoT: true });
-        }
-        wrapFragmentChildrenInT(path, tLocalName, processedNodes);
-    }
-    else if (insideAutoT) {
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            processChild(childPath, ctx);
-        }
-    }
-    else {
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) {
-                processJsxElement({ path: childPath, ...ctx });
-            }
-            else if (childPath.isJSXFragment() &&
-                !processedNodes.has(childPath.node)) {
-                processJsxFragment({ path: childPath, ...ctx });
-            }
-        }
-    }
+function processFragmentChildren({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName }) {
+	const children = path.node.children;
+	const ctx = {
+		insideAutoT,
+		importAliases,
+		processedNodes,
+		tLocalName,
+		varLocalName
+	};
+	const hasText = hasTranslatableText(children);
+	const hasOpaque = hasOpaqueGTChild(children, importAliases);
+	if (!insideAutoT && (hasText || hasOpaque)) {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) processChild(childPath, {
+			...ctx,
+			insideAutoT: true
+		});
+		wrapFragmentChildrenInT(path, tLocalName, processedNodes);
+	} else if (insideAutoT) {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) processChild(childPath, ctx);
+	} else {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) if (childPath.isJSXElement() && !processedNodes.has(childPath.node)) processJsxElement({
+			path: childPath,
+			...ctx
+		});
+		else if (childPath.isJSXFragment() && !processedNodes.has(childPath.node)) processJsxFragment({
+			path: childPath,
+			...ctx
+		});
+	}
 }
 function processChild(childPath, ctx) {
-    if (childPath.isJSXElement() && !ctx.processedNodes.has(childPath.node)) {
-        processJsxElement({ path: childPath, ...ctx });
-    }
-    else if (childPath.isJSXFragment() &&
-        !ctx.processedNodes.has(childPath.node)) {
-        processJsxFragment({ path: childPath, ...ctx });
-    }
-    else if (childPath.isJSXExpressionContainer() &&
-        ctx.insideAutoT &&
-        needsVarWrapping(childPath.node)) {
-        // Wrap dynamic expression in <Var>
-        const varWrapper = createVarWrapper(childPath.node, ctx.varLocalName, ctx.processedNodes);
-        childPath.replaceWith(varWrapper);
-        ctx.processedNodes.add(varWrapper);
-    }
+	if (childPath.isJSXElement() && !ctx.processedNodes.has(childPath.node)) processJsxElement({
+		path: childPath,
+		...ctx
+	});
+	else if (childPath.isJSXFragment() && !ctx.processedNodes.has(childPath.node)) processJsxFragment({
+		path: childPath,
+		...ctx
+	});
+	else if (childPath.isJSXExpressionContainer() && ctx.insideAutoT && needsVarWrapping(childPath.node)) {
+		const varWrapper = createVarWrapper(childPath.node, ctx.varLocalName, ctx.processedNodes);
+		childPath.replaceWith(varWrapper);
+		ctx.processedNodes.add(varWrapper);
+	}
 }
-// ===== Opaque component props ===== //
-function processOpaqueComponentProps({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, canonicalName, }) {
-    // Branch/Plural children (fallback content) — process element-by-element before marking
-    if (insideAutoT &&
-        (canonicalName === BRANCH_COMPONENT || canonicalName === PLURAL_COMPONENT)) {
-        const childPaths = path.get('children');
-        for (const childPath of childPaths) {
-            processChild(childPath, {
-                insideAutoT: true,
-                importAliases,
-                processedNodes,
-                tLocalName,
-                varLocalName,
-            });
-        }
-    }
-    if (!insideAutoT) {
-        markDescendantJsx(path, processedNodes);
-        return;
-    }
-    const ctx = {
-        insideAutoT: true,
-        importAliases,
-        processedNodes,
-        tLocalName,
-        varLocalName,
-    };
-    // Wrap dynamic prop values in <Var>, skipping control props.
-    // This must happen BEFORE markDescendantJsx so that JSX inside auto-inserted
-    // _Var wrappers stays unmarked for the top-level visitor to process independently.
-    const attrs = path.get('openingElement').get('attributes');
-    for (const attrPath of attrs) {
-        if (!attrPath.isJSXAttribute())
-            continue;
-        // Determine prop name and skip control props
-        const nameNode = attrPath.node.name;
-        const propName = t.isJSXIdentifier(nameNode) ? nameNode.name : null;
-        if (isControlProp(canonicalName, propName))
-            continue;
-        const valuePath = attrPath.get('value');
-        if (!valuePath.isJSXExpressionContainer())
-            continue;
-        const expr = valuePath.node.expression;
-        // Content prop with JSX value — recurse into children for Var-wrapping
-        if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
-            const exprPath = valuePath.get('expression');
-            if (exprPath.isJSXElement() || exprPath.isJSXFragment()) {
-                const childPaths = exprPath.get('children');
-                for (const childPath of childPaths) {
-                    processChild(childPath, ctx);
-                }
-            }
-            continue;
-        }
-        // Non-JSX dynamic value — wrap in Var
-        if (needsVarWrapping(valuePath.node)) {
-            const varWrapper = createVarWrapper(valuePath.node, varLocalName, processedNodes);
-            valuePath.replaceWith(varWrapper);
-            processedNodes.add(varWrapper);
-        }
-    }
-    // Mark remaining descendant JSX as processed, but skip auto-inserted nodes
-    // so the top-level visitor can still discover JSX inside _Var wrappers.
-    // For Derive/Static, only mark props — leave children unmarked so the
-    // top-level visitor can independently process them (e.g. Branch/Plural
-    // inside Derive should get their own _T, matching compiler behavior).
-    if (canonicalName === DERIVE_COMPONENT ||
-        canonicalName === STATIC_COMPONENT) {
-        for (const attrPath of path.get('openingElement').get('attributes')) {
-            attrPath.traverse({
-                JSXElement(childPath) {
-                    processedNodes.add(childPath.node);
-                },
-                JSXFragment(childPath) {
-                    processedNodes.add(childPath.node);
-                },
-            });
-        }
-    }
-    else {
-        markDescendantJsx(path, processedNodes);
-    }
+function processOpaqueComponentProps({ path, insideAutoT, importAliases, processedNodes, tLocalName, varLocalName, canonicalName }) {
+	if (insideAutoT && (canonicalName === "Branch" || canonicalName === "Plural")) {
+		const childPaths = path.get("children");
+		for (const childPath of childPaths) processChild(childPath, {
+			insideAutoT: true,
+			importAliases,
+			processedNodes,
+			tLocalName,
+			varLocalName
+		});
+	}
+	if (!insideAutoT) {
+		markDescendantJsx(path, processedNodes);
+		return;
+	}
+	const ctx = {
+		insideAutoT: true,
+		importAliases,
+		processedNodes,
+		tLocalName,
+		varLocalName
+	};
+	const attrs = path.get("openingElement").get("attributes");
+	for (const attrPath of attrs) {
+		if (!attrPath.isJSXAttribute()) continue;
+		const nameNode = attrPath.node.name;
+		if (isControlProp(canonicalName, t.isJSXIdentifier(nameNode) ? nameNode.name : null)) continue;
+		const valuePath = attrPath.get("value");
+		if (!valuePath.isJSXExpressionContainer()) continue;
+		const expr = valuePath.node.expression;
+		if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+			const exprPath = valuePath.get("expression");
+			if (exprPath.isJSXElement() || exprPath.isJSXFragment()) {
+				const childPaths = exprPath.get("children");
+				for (const childPath of childPaths) processChild(childPath, ctx);
+			}
+			continue;
+		}
+		if (needsVarWrapping(valuePath.node)) {
+			const varWrapper = createVarWrapper(valuePath.node, varLocalName, processedNodes);
+			valuePath.replaceWith(varWrapper);
+			processedNodes.add(varWrapper);
+		}
+	}
+	if (canonicalName === "Derive" || canonicalName === "Static") for (const attrPath of path.get("openingElement").get("attributes")) attrPath.traverse({
+		JSXElement(childPath) {
+			processedNodes.add(childPath.node);
+		},
+		JSXFragment(childPath) {
+			processedNodes.add(childPath.node);
+		}
+	});
+	else markDescendantJsx(path, processedNodes);
 }
 function isControlProp(canonicalName, propName) {
-    if (!propName)
-        return false;
-    if (canonicalName === BRANCH_COMPONENT) {
-        return BRANCH_CONTROL_PROPS.has(propName) || propName.startsWith('data-');
-    }
-    if (canonicalName === PLURAL_COMPONENT) {
-        return PLURAL_CONTROL_PROPS.has(propName);
-    }
-    return false;
+	if (!propName) return false;
+	if (canonicalName === "Branch") return BRANCH_CONTROL_PROPS.has(propName) || propName.startsWith("data-");
+	if (canonicalName === "Plural") return PLURAL_CONTROL_PROPS.has(propName);
+	return false;
 }
-// ===== Helper functions ===== //
 function getElementTypeName(element) {
-    const name = element.openingElement.name;
-    if (t.isJSXIdentifier(name))
-        return name.name;
-    return null;
+	const name = element.openingElement.name;
+	if (t.isJSXIdentifier(name)) return name.name;
+	return null;
 }
 function getLocalName(importAliases, canonicalName) {
-    const entry = Object.entries(importAliases).find(([, v]) => v === canonicalName);
-    return entry ? entry[0] : canonicalName;
+	const entry = Object.entries(importAliases).find(([, v]) => v === canonicalName);
+	return entry ? entry[0] : canonicalName;
 }
 function hasTranslatableText(children) {
-    return children.some((child) => t.isJSXText(child) && child.value.trim().length > 0);
+	return children.some((child) => t.isJSXText(child) && child.value.trim().length > 0);
 }
 function hasOpaqueGTChild(children, importAliases) {
-    return children.some((child) => {
-        if (!t.isJSXElement(child))
-            return false;
-        const typeName = getElementTypeName(child);
-        if (!typeName)
-            return false;
-        const canonical = importAliases[typeName];
-        return (canonical === BRANCH_COMPONENT ||
-            canonical === PLURAL_COMPONENT ||
-            canonical === DERIVE_COMPONENT ||
-            canonical === STATIC_COMPONENT);
-    });
+	return children.some((child) => {
+		if (!t.isJSXElement(child)) return false;
+		const typeName = getElementTypeName(child);
+		if (!typeName) return false;
+		const canonical = importAliases[typeName];
+		return canonical === "Branch" || canonical === "Plural" || canonical === "Derive" || canonical === "Static";
+	});
 }
 function needsVarWrapping(container) {
-    const expr = container.expression;
-    if (t.isJSXEmptyExpression(expr))
-        return false;
-    // Use isStaticExpression to check — if static, no wrapping needed
-    const analysis = isStaticExpression(expr, true);
-    if (analysis.isStatic)
-        return false;
-    // JSX elements/fragments inside expressions are not dynamic — they're valid children
-    if (t.isJSXElement(expr) || t.isJSXFragment(expr))
-        return false;
-    return true;
+	const expr = container.expression;
+	if (t.isJSXEmptyExpression(expr)) return false;
+	if (isStaticExpression(expr, true).isStatic) return false;
+	if (t.isJSXElement(expr) || t.isJSXFragment(expr)) return false;
+	return true;
 }
-// ===== AST construction ===== //
 function createTWrapper(children, tName) {
-    const element = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(tName), []), t.jsxClosingElement(t.jsxIdentifier(tName)), children);
-    autoInsertedNodes.add(element);
-    return element;
+	const element = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(tName), []), t.jsxClosingElement(t.jsxIdentifier(tName)), children);
+	autoInsertedNodes.add(element);
+	return element;
 }
 function createVarWrapper(child, varName, processedNodes) {
-    const varElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(varName), []), t.jsxClosingElement(t.jsxIdentifier(varName)), [child]);
-    autoInsertedNodes.add(varElement);
-    processedNodes.add(varElement);
-    return t.jsxExpressionContainer(varElement);
+	const varElement = t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(varName), []), t.jsxClosingElement(t.jsxIdentifier(varName)), [child]);
+	autoInsertedNodes.add(varElement);
+	processedNodes.add(varElement);
+	return t.jsxExpressionContainer(varElement);
 }
 function wrapChildrenInT(elementPath, tName, processedNodes) {
-    const children = [...elementPath.node.children];
-    const tWrapper = createTWrapper(children, tName);
-    processedNodes.add(tWrapper);
-    elementPath.node.children = [tWrapper];
+	const tWrapper = createTWrapper([...elementPath.node.children], tName);
+	processedNodes.add(tWrapper);
+	elementPath.node.children = [tWrapper];
 }
 function wrapFragmentChildrenInT(fragmentPath, tName, processedNodes) {
-    const children = [...fragmentPath.node.children];
-    const tWrapper = createTWrapper(children, tName);
-    processedNodes.add(tWrapper);
-    fragmentPath.node.children = [tWrapper];
+	const tWrapper = createTWrapper([...fragmentPath.node.children], tName);
+	processedNodes.add(tWrapper);
+	fragmentPath.node.children = [tWrapper];
 }
-// ===== Marking descendants as processed ===== //
 function markDescendantJsx(path, processedNodes) {
-    path.traverse({
-        JSXElement(childPath) {
-            // Don't mark JSX inside auto-inserted _Var — the top-level visitor
-            // needs to find and process those independently
-            if (autoInsertedNodes.has(childPath.node)) {
-                childPath.skip();
-                return;
-            }
-            processedNodes.add(childPath.node);
-        },
-        JSXFragment(childPath) {
-            if (autoInsertedNodes.has(childPath.node)) {
-                childPath.skip();
-                return;
-            }
-            processedNodes.add(childPath.node);
-        },
-    });
+	path.traverse({
+		JSXElement(childPath) {
+			if (autoInsertedNodes.has(childPath.node)) {
+				childPath.skip();
+				return;
+			}
+			processedNodes.add(childPath.node);
+		},
+		JSXFragment(childPath) {
+			if (autoInsertedNodes.has(childPath.node)) {
+				childPath.skip();
+				return;
+			}
+			processedNodes.add(childPath.node);
+		}
+	});
 }
+//#endregion
+export { autoInsertJsxComponents, ensureTAndVarImported, isAutoInserted };
+
+//# sourceMappingURL=autoInsertion.js.map