@generaltranslation/compiler 1.3.22 → 1.3.23

package/dist/processing/jsx-insertion/processCallExpression.js

@@ -1,424 +1,315 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processCallExpression = processCallExpression;
-const t = __importStar(require("@babel/types"));
-const constants_1 = require("../../utils/constants/gt/constants");
-const constants_2 = require("../../utils/constants/other/constants");
-const constants_3 = require("../../utils/constants/react/constants");
-const isReactJsxFunction_1 = require("../../utils/constants/resolveIdentifier/isReactJsxFunction");
-const isGTComponent_1 = require("../../utils/constants/resolveIdentifier/isGTComponent");
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_utils_constants_gt_constants = require("../../utils/constants/gt/constants.js");
+require("../../utils/constants/react/constants.js");
+require("../../utils/constants/other/constants.js");
+const require_utils_constants_resolveIdentifier_isReactJsxFunction = require("../../utils/constants/resolveIdentifier/isReactJsxFunction.js");
+const require_utils_constants_resolveIdentifier_isGTComponent = require("../../utils/constants/resolveIdentifier/isGTComponent.js");
+let _babel_types = require("@babel/types");
+_babel_types = require_runtime.__toESM(_babel_types);
+//#region src/processing/jsx-insertion/processCallExpression.ts
 /**
- * Babel visitor entry point for the JSX insertion pass.
- *
- * All internal functions use NodePath-based traversal via .get() so that
- * Babel binding lookups (scope.getBinding) work correctly at every depth.
- * This handles aliased imports like `import { jsxDEV as _jsxDEV }`.
- */
+* Babel visitor entry point for the JSX insertion pass.
+*
+* All internal functions use NodePath-based traversal via .get() so that
+* Babel binding lookups (scope.getBinding) work correctly at every depth.
+* This handles aliased imports like `import { jsxDEV as _jsxDEV }`.
+*/
 function processCallExpression(state, calleeInfo) {
-    const jsxState = Object.assign(Object.assign({}, state), { processedNodes: new WeakSet(), calleeInfo, insideUserVarDepth: 0 });
-    return {
-        enter: (path) => {
-            // Check jsx callee first — needed for both user Var detection and processing
-            const calleePath = path.get('callee');
-            if ((!calleePath.isIdentifier() && !calleePath.isMemberExpression()) ||
-                !(0, isReactJsxFunction_1.isReactJsxFunction)(calleePath)) {
-                return;
-            }
-            // Check if this is a user Var/Num/Currency/DateTime — suppress transforms inside.
-            // This must happen BEFORE the processedNodes check, because user T's
-            // markDescendantJsxCalls may have already added the Var call to processedNodes,
-            // but we still need to increment the depth counter so children are suppressed.
-            const firstArg = path.get('arguments')[0];
-            if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression()) && (0, isGTComponent_1.isUserVariableComponent)(firstArg)) {
-                jsxState.insideUserVarDepth++;
-                return;
-            }
-            // Skip all processing when inside a user variable component
-            if (jsxState.insideUserVarDepth > 0)
-                return;
-            if (jsxState.processedNodes.has(path.node))
-                return;
-            processJsxNode({ path, insideAutoT: false, state: jsxState });
-        },
-        exit: (path) => {
-            // Decrement depth when exiting a user Var/Num/Currency/DateTime
-            const calleePath = path.get('callee');
-            if ((!calleePath.isIdentifier() && !calleePath.isMemberExpression()) ||
-                !(0, isReactJsxFunction_1.isReactJsxFunction)(calleePath)) {
-                return;
-            }
-            const firstArg = path.get('arguments')[0];
-            if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression()) && (0, isGTComponent_1.isUserVariableComponent)(firstArg)) {
-                jsxState.insideUserVarDepth--;
-            }
-        },
-    };
+	const jsxState = {
+		...state,
+		processedNodes: /* @__PURE__ */ new WeakSet(),
+		calleeInfo,
+		insideUserVarDepth: 0
+	};
+	return {
+		enter: (path) => {
+			const calleePath = path.get("callee");
+			if (!calleePath.isIdentifier() && !calleePath.isMemberExpression() || !require_utils_constants_resolveIdentifier_isReactJsxFunction.isReactJsxFunction(calleePath)) return;
+			const firstArg = path.get("arguments")[0];
+			if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression()) && require_utils_constants_resolveIdentifier_isGTComponent.isUserVariableComponent(firstArg)) {
+				jsxState.insideUserVarDepth++;
+				return;
+			}
+			if (jsxState.insideUserVarDepth > 0) return;
+			if (jsxState.processedNodes.has(path.node)) return;
+			processJsxNode({
+				path,
+				insideAutoT: false,
+				state: jsxState
+			});
+		},
+		exit: (path) => {
+			const calleePath = path.get("callee");
+			if (!calleePath.isIdentifier() && !calleePath.isMemberExpression() || !require_utils_constants_resolveIdentifier_isReactJsxFunction.isReactJsxFunction(calleePath)) return;
+			const firstArg = path.get("arguments")[0];
+			if ((firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression()) && require_utils_constants_resolveIdentifier_isGTComponent.isUserVariableComponent(firstArg)) jsxState.insideUserVarDepth--;
+		}
+	};
 }
-// ===== Core recursive function =====
-function processJsxNode({ path, insideAutoT, state, }) {
-    var _a, _b;
-    state.processedNodes.add(path.node);
-    const firstArgPath = path.get('arguments')[0];
-    if (!(firstArgPath === null || firstArgPath === void 0 ? void 0 : firstArgPath.isExpression()))
-        return;
-    // User T → mark all descendant jsx calls as processed, hands off
-    if ((0, isGTComponent_1.isUserTranslationComponent)(firstArgPath)) {
-        markDescendantJsxCalls({ jsxCallPath: path, state });
-        return;
-    }
-    // User Var/Num/Currency/DateTime → mark descendants, hands off
-    if ((0, isGTComponent_1.isUserVariableComponent)(firstArgPath)) {
-        markDescendantJsxCalls({ jsxCallPath: path, state });
-        return;
-    }
-    // Already auto-inserted → skip
-    const gtName = (0, isGTComponent_1.resolveFirstArgGTName)(firstArgPath);
-    if (gtName === constants_1.GT_COMPONENT_TYPES.GtInternalTranslateJsx ||
-        gtName === constants_1.GT_COMPONENT_TYPES.GtInternalVar) {
-        return;
-    }
-    // Branch/Plural/Derive/Static → opaque for static JSX, dynamic props get _Var
-    if ((0, isGTComponent_1.isGTBranchComponent)(firstArgPath) || (0, isGTComponent_1.isGTDeriveComponent)(firstArgPath)) {
-        // Process props BEFORE wrapping — path still points to the opaque component
-        processOpaqueComponentProps({
-            jsxCallPath: path,
-            insideAutoT: !insideAutoT ? true : insideAutoT,
-            state,
-        });
-        if (!insideAutoT) {
-            // Root-level opaque component — wrap in _T (single child → use singleCallee)
-            const callee = (_b = (_a = state.calleeInfo.singleCallee) !== null && _a !== void 0 ? _a : state.calleeInfo.multiCallee) !== null && _b !== void 0 ? _b : constants_3.REACT_FUNTIONS.jsx;
-            const tWrapped = wrapInT(path.node, t.identifier(callee), state.calleeInfo);
-            state.processedNodes.add(tWrapped);
-            path.replaceWith(tWrapped);
-            state.statistics.jsxInsertionsCount++;
-        }
-        return;
-    }
-    // --- Get children prop path ---
-    const childrenPropPath = getChildrenPropPath(path);
-    if (!childrenPropPath)
-        return;
-    const childrenPath = childrenPropPath.get('value');
-    if (!childrenPath.isExpression())
-        return;
-    // --- Determine if this level should claim T ---
-    const shouldClaimT = !insideAutoT &&
-        (hasNonWhitespaceText(childrenPath) || hasOpaqueGTChild(childrenPath));
-    if (shouldClaimT) {
-        processChildren({ childrenPath, insideAutoT: true, state });
-        const currentChildren = childrenPropPath.get('value').node;
-        const tCallee = t.isArrayExpression(currentChildren)
-            ? state.calleeInfo.multiCallee
-            : state.calleeInfo.singleCallee;
-        const tWrapped = wrapInT(currentChildren, t.identifier(tCallee !== null && tCallee !== void 0 ? tCallee : 'jsx'), state.calleeInfo);
-        state.processedNodes.add(tWrapped);
-        childrenPropPath.get('value').replaceWith(tWrapped);
-        updateCalleeToSingle({ jsxCallPath: path, state });
-        state.statistics.jsxInsertionsCount++;
-    }
-    else if (insideAutoT) {
-        processChildren({ childrenPath, insideAutoT: true, state });
-    }
-    else {
-        recurseChildJsxCalls({ childrenPath, insideAutoT: false, state });
-    }
+function processJsxNode({ path, insideAutoT, state }) {
+	state.processedNodes.add(path.node);
+	const firstArgPath = path.get("arguments")[0];
+	if (!(firstArgPath === null || firstArgPath === void 0 ? void 0 : firstArgPath.isExpression())) return;
+	if (require_utils_constants_resolveIdentifier_isGTComponent.isUserTranslationComponent(firstArgPath)) {
+		markDescendantJsxCalls({
+			jsxCallPath: path,
+			state
+		});
+		return;
+	}
+	if (require_utils_constants_resolveIdentifier_isGTComponent.isUserVariableComponent(firstArgPath)) {
+		markDescendantJsxCalls({
+			jsxCallPath: path,
+			state
+		});
+		return;
+	}
+	const gtName = require_utils_constants_resolveIdentifier_isGTComponent.resolveFirstArgGTName(firstArgPath);
+	if (gtName === "GtInternalTranslateJsx" || gtName === "GtInternalVar") return;
+	if (require_utils_constants_resolveIdentifier_isGTComponent.isGTBranchComponent(firstArgPath) || require_utils_constants_resolveIdentifier_isGTComponent.isGTDeriveComponent(firstArgPath)) {
+		processOpaqueComponentProps({
+			jsxCallPath: path,
+			insideAutoT: !insideAutoT ? true : insideAutoT,
+			state
+		});
+		if (!insideAutoT) {
+			const callee = state.calleeInfo.singleCallee ?? state.calleeInfo.multiCallee ?? "jsx";
+			const tWrapped = wrapInT(path.node, _babel_types.identifier(callee), state.calleeInfo);
+			state.processedNodes.add(tWrapped);
+			path.replaceWith(tWrapped);
+			state.statistics.jsxInsertionsCount++;
+		}
+		return;
+	}
+	const childrenPropPath = getChildrenPropPath(path);
+	if (!childrenPropPath) return;
+	const childrenPath = childrenPropPath.get("value");
+	if (!childrenPath.isExpression()) return;
+	if (!insideAutoT && (hasNonWhitespaceText(childrenPath) || hasOpaqueGTChild(childrenPath))) {
+		processChildren({
+			childrenPath,
+			insideAutoT: true,
+			state
+		});
+		const currentChildren = childrenPropPath.get("value").node;
+		const tCallee = _babel_types.isArrayExpression(currentChildren) ? state.calleeInfo.multiCallee : state.calleeInfo.singleCallee;
+		const tWrapped = wrapInT(currentChildren, _babel_types.identifier(tCallee ?? "jsx"), state.calleeInfo);
+		state.processedNodes.add(tWrapped);
+		childrenPropPath.get("value").replaceWith(tWrapped);
+		updateCalleeToSingle({
+			jsxCallPath: path,
+			state
+		});
+		state.statistics.jsxInsertionsCount++;
+	} else if (insideAutoT) processChildren({
+		childrenPath,
+		insideAutoT: true,
+		state
+	});
+	else recurseChildJsxCalls({
+		childrenPath,
+		insideAutoT: false,
+		state
+	});
 }
-// ===== Children processing ===== //
-function processChildren({ childrenPath, insideAutoT, state, }) {
-    if (childrenPath.isArrayExpression()) {
-        for (const elPath of childrenPath.get('elements')) {
-            if (elPath.isExpression()) {
-                processSingleChild({ childPath: elPath, insideAutoT, state });
-            }
-        }
-        return;
-    }
-    processSingleChild({ childPath: childrenPath, insideAutoT, state });
+function processChildren({ childrenPath, insideAutoT, state }) {
+	if (childrenPath.isArrayExpression()) {
+		for (const elPath of childrenPath.get("elements")) if (elPath.isExpression()) processSingleChild({
+			childPath: elPath,
+			insideAutoT,
+			state
+		});
+		return;
+	}
+	processSingleChild({
+		childPath: childrenPath,
+		insideAutoT,
+		state
+	});
 }
-function processSingleChild({ childPath, insideAutoT, state, }) {
-    var _a;
-    if (childPath.isCallExpression() && isJsxCallPath(childPath)) {
-        processJsxNode({ path: childPath, insideAutoT, state });
-        return;
-    }
-    // _Var always has a single child → use singleCallee
-    if (insideAutoT && needsVarWrapping(childPath)) {
-        const callee = (_a = state.calleeInfo.singleCallee) !== null && _a !== void 0 ? _a : constants_3.REACT_FUNTIONS.jsx;
-        const wrapped = wrapInVar(childPath.node, t.identifier(callee), state.calleeInfo);
-        state.processedNodes.add(wrapped);
-        childPath.replaceWith(wrapped);
-    }
+function processSingleChild({ childPath, insideAutoT, state }) {
+	if (childPath.isCallExpression() && isJsxCallPath(childPath)) {
+		processJsxNode({
+			path: childPath,
+			insideAutoT,
+			state
+		});
+		return;
+	}
+	if (insideAutoT && needsVarWrapping(childPath)) {
+		const callee = state.calleeInfo.singleCallee ?? "jsx";
+		const wrapped = wrapInVar(childPath.node, _babel_types.identifier(callee), state.calleeInfo);
+		state.processedNodes.add(wrapped);
+		childPath.replaceWith(wrapped);
+	}
 }
-function recurseChildJsxCalls({ childrenPath, insideAutoT, state, }) {
-    if (childrenPath.isArrayExpression()) {
-        for (const elPath of childrenPath.get('elements')) {
-            if (elPath.isCallExpression() && isJsxCallPath(elPath)) {
-                processJsxNode({ path: elPath, insideAutoT, state });
-            }
-        }
-    }
-    else if (childrenPath.isCallExpression() && isJsxCallPath(childrenPath)) {
-        processJsxNode({ path: childrenPath, insideAutoT, state });
-    }
+function recurseChildJsxCalls({ childrenPath, insideAutoT, state }) {
+	if (childrenPath.isArrayExpression()) {
+		for (const elPath of childrenPath.get("elements")) if (elPath.isCallExpression() && isJsxCallPath(elPath)) processJsxNode({
+			path: elPath,
+			insideAutoT,
+			state
+		});
+	} else if (childrenPath.isCallExpression() && isJsxCallPath(childrenPath)) processJsxNode({
+		path: childrenPath,
+		insideAutoT,
+		state
+	});
 }
-// ===== Helper functions =====
 function getChildrenPropPath(jsxCallPath) {
-    const args = jsxCallPath.get('arguments');
-    const propsArg = args[1];
-    if (!(propsArg === null || propsArg === void 0 ? void 0 : propsArg.isObjectExpression()))
-        return undefined;
-    for (const propPath of propsArg.get('properties')) {
-        if (propPath.isObjectProperty() &&
-            t.isIdentifier(propPath.node.key, { name: 'children' })) {
-            return propPath;
-        }
-    }
-    return undefined;
+	const propsArg = jsxCallPath.get("arguments")[1];
+	if (!(propsArg === null || propsArg === void 0 ? void 0 : propsArg.isObjectExpression())) return void 0;
+	for (const propPath of propsArg.get("properties")) if (propPath.isObjectProperty() && _babel_types.isIdentifier(propPath.node.key, { name: "children" })) return propPath;
 }
 function isJsxCallPath(callPath) {
-    const callee = callPath.get('callee');
-    if (!callee.isIdentifier() && !callee.isMemberExpression())
-        return false;
-    return (0, isReactJsxFunction_1.isReactJsxFunction)(callee);
+	const callee = callPath.get("callee");
+	if (!callee.isIdentifier() && !callee.isMemberExpression()) return false;
+	return require_utils_constants_resolveIdentifier_isReactJsxFunction.isReactJsxFunction(callee);
 }
 function hasNonWhitespaceText(childrenPath) {
-    const isText = (p) => {
-        var _a, _b;
-        if (p.isStringLiteral())
-            return p.node.value.trim().length > 0;
-        if (p.isTemplateLiteral()) {
-            return (p.node.expressions.length === 0 &&
-                ((_b = (_a = p.node.quasis[0]) === null || _a === void 0 ? void 0 : _a.value.cooked) !== null && _b !== void 0 ? _b : '').trim().length > 0);
-        }
-        return false;
-    };
-    if (childrenPath.isArrayExpression()) {
-        return childrenPath
-            .get('elements')
-            .some((el) => el.isExpression() && isText(el));
-    }
-    return isText(childrenPath);
+	const isText = (p) => {
+		if (p.isStringLiteral()) return p.node.value.trim().length > 0;
+		if (p.isTemplateLiteral()) {
+			var _p$node$quasis$;
+			return p.node.expressions.length === 0 && (((_p$node$quasis$ = p.node.quasis[0]) === null || _p$node$quasis$ === void 0 ? void 0 : _p$node$quasis$.value.cooked) ?? "").trim().length > 0;
+		}
+		return false;
+	};
+	if (childrenPath.isArrayExpression()) return childrenPath.get("elements").some((el) => el.isExpression() && isText(el));
+	return isText(childrenPath);
 }
 function hasOpaqueGTChild(childrenPath) {
-    const isOpaque = (elPath) => {
-        if (!elPath.isCallExpression() || !isJsxCallPath(elPath))
-            return false;
-        const firstArg = elPath.get('arguments')[0];
-        if (!(firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression()))
-            return false;
-        return (0, isGTComponent_1.isGTBranchComponent)(firstArg) || (0, isGTComponent_1.isGTDeriveComponent)(firstArg);
-    };
-    if (childrenPath.isArrayExpression()) {
-        return childrenPath
-            .get('elements')
-            .some((el) => el.isExpression() && isOpaque(el));
-    }
-    return isOpaque(childrenPath);
+	const isOpaque = (elPath) => {
+		if (!elPath.isCallExpression() || !isJsxCallPath(elPath)) return false;
+		const firstArg = elPath.get("arguments")[0];
+		if (!(firstArg === null || firstArg === void 0 ? void 0 : firstArg.isExpression())) return false;
+		return require_utils_constants_resolveIdentifier_isGTComponent.isGTBranchComponent(firstArg) || require_utils_constants_resolveIdentifier_isGTComponent.isGTDeriveComponent(firstArg);
+	};
+	if (childrenPath.isArrayExpression()) return childrenPath.get("elements").some((el) => el.isExpression() && isOpaque(el));
+	return isOpaque(childrenPath);
 }
 function needsVarWrapping(exprPath) {
-    if (exprPath.isStringLiteral())
-        return false;
-    if (exprPath.isNumericLiteral())
-        return false;
-    if (exprPath.isBooleanLiteral())
-        return false;
-    if (exprPath.isNullLiteral())
-        return false;
-    if (exprPath.isTemplateLiteral() && exprPath.node.expressions.length === 0) {
-        return false;
-    }
-    if (exprPath.isUnaryExpression() &&
-        exprPath.node.operator === '-' &&
-        t.isNumericLiteral(exprPath.node.argument)) {
-        return false;
-    }
-    if (exprPath.isIdentifier()) {
-        return ![
-            constants_2.OTHER_IDENTIFIERS_ENUM.UNDEFINED,
-            constants_2.OTHER_IDENTIFIERS_ENUM.NAN,
-            constants_2.OTHER_IDENTIFIERS_ENUM.INFINITY,
-        ].includes(exprPath.node.name);
-    }
-    if (exprPath.isCallExpression() && isJsxCallPath(exprPath)) {
-        return false;
-    }
-    return true;
+	if (exprPath.isStringLiteral()) return false;
+	if (exprPath.isNumericLiteral()) return false;
+	if (exprPath.isBooleanLiteral()) return false;
+	if (exprPath.isNullLiteral()) return false;
+	if (exprPath.isTemplateLiteral() && exprPath.node.expressions.length === 0) return false;
+	if (exprPath.isUnaryExpression() && exprPath.node.operator === "-" && _babel_types.isNumericLiteral(exprPath.node.argument)) return false;
+	if (exprPath.isIdentifier()) return ![
+		"undefined",
+		"NaN",
+		"Infinity"
+	].includes(exprPath.node.name);
+	if (exprPath.isCallExpression() && isJsxCallPath(exprPath)) return false;
+	return true;
 }
 /**
- * After wrapping children in _T, the parent now has a single child.
- * Update its callee from jsxs → jsx if needed.
- */
-function updateCalleeToSingle({ jsxCallPath, state, }) {
-    const { singleCallee, multiCallee } = state.calleeInfo;
-    // Production (jsx/jsxs): update callee name jsxs → jsx
-    if (singleCallee && multiCallee && singleCallee !== multiCallee) {
-        const callee = jsxCallPath.get('callee');
-        if (callee.isIdentifier() && callee.node.name === multiCallee) {
-            callee.node.name = singleCallee;
-        }
-    }
-    // Dev (jsxDEV): update isStaticChildren (4th arg, index 3) to false
-    const args = jsxCallPath.get('arguments');
-    const isStaticArg = args[3];
-    if (isStaticArg === null || isStaticArg === void 0 ? void 0 : isStaticArg.isBooleanLiteral({ value: true })) {
-        isStaticArg.replaceWith(t.booleanLiteral(false));
-    }
+* After wrapping children in _T, the parent now has a single child.
+* Update its callee from jsxs → jsx if needed.
+*/
+function updateCalleeToSingle({ jsxCallPath, state }) {
+	const { singleCallee, multiCallee } = state.calleeInfo;
+	if (singleCallee && multiCallee && singleCallee !== multiCallee) {
+		const callee = jsxCallPath.get("callee");
+		if (callee.isIdentifier() && callee.node.name === multiCallee) callee.node.name = singleCallee;
+	}
+	const isStaticArg = jsxCallPath.get("arguments")[3];
+	if (isStaticArg === null || isStaticArg === void 0 ? void 0 : isStaticArg.isBooleanLiteral({ value: true })) isStaticArg.replaceWith(_babel_types.booleanLiteral(false));
 }
-// ===== AST construction =====
 function wrapInVar(expr, callee, calleeInfo) {
-    const args = [
-        t.identifier(constants_1.GT_COMPONENT_TYPES.GtInternalVar),
-        t.objectExpression([t.objectProperty(t.identifier('children'), expr)]),
-    ];
-    if (isDevMode(calleeInfo)) {
-        args.push(t.unaryExpression('void', t.numericLiteral(0)), t.booleanLiteral(false));
-    }
-    return t.callExpression(t.cloneNode(callee), args);
+	const args = [_babel_types.identifier("GtInternalVar"), _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("children"), expr)])];
+	if (isDevMode(calleeInfo)) args.push(_babel_types.unaryExpression("void", _babel_types.numericLiteral(0)), _babel_types.booleanLiteral(false));
+	return _babel_types.callExpression(_babel_types.cloneNode(callee), args);
 }
 function wrapInT(children, callee, calleeInfo) {
-    const args = [
-        t.identifier(constants_1.GT_COMPONENT_TYPES.GtInternalTranslateJsx),
-        t.objectExpression([t.objectProperty(t.identifier('children'), children)]),
-    ];
-    if (isDevMode(calleeInfo)) {
-        args.push(t.unaryExpression('void', t.numericLiteral(0)), t.booleanLiteral(t.isArrayExpression(children)));
-    }
-    return t.callExpression(t.cloneNode(callee), args);
+	const args = [_babel_types.identifier("GtInternalTranslateJsx"), _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("children"), children)])];
+	if (isDevMode(calleeInfo)) args.push(_babel_types.unaryExpression("void", _babel_types.numericLiteral(0)), _babel_types.booleanLiteral(_babel_types.isArrayExpression(children)));
+	return _babel_types.callExpression(_babel_types.cloneNode(callee), args);
 }
 function isDevMode(calleeInfo) {
-    return (calleeInfo.singleCallee != null &&
-        calleeInfo.singleCallee === calleeInfo.multiCallee);
+	return calleeInfo.singleCallee != null && calleeInfo.singleCallee === calleeInfo.multiCallee;
 }
-// ===== Marking descendants as processed =====
-function markDescendantJsxCalls({ jsxCallPath, state, }) {
-    const childrenPropPath = getChildrenPropPath(jsxCallPath);
-    if (!childrenPropPath)
-        return;
-    const valuePath = childrenPropPath.get('value');
-    if (valuePath.isExpression()) {
-        walkAndMark({ exprPath: valuePath, state });
-    }
+function markDescendantJsxCalls({ jsxCallPath, state }) {
+	const childrenPropPath = getChildrenPropPath(jsxCallPath);
+	if (!childrenPropPath) return;
+	const valuePath = childrenPropPath.get("value");
+	if (valuePath.isExpression()) walkAndMark({
+		exprPath: valuePath,
+		state
+	});
 }
-function processOpaqueComponentProps({ jsxCallPath, insideAutoT, state, }) {
-    var _a;
-    const args = jsxCallPath.get('arguments');
-    const propsArg = args[1];
-    if (!(propsArg === null || propsArg === void 0 ? void 0 : propsArg.isObjectExpression()))
-        return;
-    // Resolve component type to filter control props
-    const firstArgPath = args[0];
-    const gtName = (firstArgPath === null || firstArgPath === void 0 ? void 0 : firstArgPath.isExpression())
-        ? (0, isGTComponent_1.resolveFirstArgGTName)(firstArgPath)
-        : null;
-    for (const propPath of propsArg.get('properties')) {
-        if (!propPath.isObjectProperty())
-            continue;
-        // Determine prop name and skip control props
-        const key = propPath.node.key;
-        const propName = t.isIdentifier(key)
-            ? key.name
-            : t.isStringLiteral(key)
-                ? key.value
-                : null;
-        if (isControlProp(gtName, propName))
-            continue;
-        const valuePath = propPath.get('value');
-        if (!valuePath.isExpression())
-            continue;
-        // children is fallback content for Branch/Plural — process element-by-element
-        // For Derive/Static, children is opaque — skip entirely
-        if (propName === 'children') {
-            if (insideAutoT &&
-                (gtName === constants_1.GT_COMPONENT_TYPES.Branch ||
-                    gtName === constants_1.GT_COMPONENT_TYPES.Plural)) {
-                processChildren({ childrenPath: valuePath, insideAutoT: true, state });
-            }
-            continue;
-        }
-        if (valuePath.isCallExpression() && isJsxCallPath(valuePath)) {
-            // Content prop with JSX value — recurse into children for Var-wrapping
-            if (insideAutoT) {
-                const childrenPropPath = getChildrenPropPath(valuePath);
-                if (childrenPropPath) {
-                    const childrenPath = childrenPropPath.get('value');
-                    if (childrenPath.isExpression()) {
-                        processChildren({ childrenPath, insideAutoT: true, state });
-                    }
-                }
-            }
-            state.processedNodes.add(valuePath.node);
-            walkAndMark({ exprPath: valuePath, state });
-        }
-        else if (insideAutoT && needsVarWrapping(valuePath)) {
-            const callee = (_a = state.calleeInfo.singleCallee) !== null && _a !== void 0 ? _a : constants_3.REACT_FUNTIONS.jsx;
-            const wrapped = wrapInVar(valuePath.node, t.identifier(callee), state.calleeInfo);
-            state.processedNodes.add(wrapped);
-            valuePath.replaceWith(wrapped);
-        }
-    }
+function processOpaqueComponentProps({ jsxCallPath, insideAutoT, state }) {
+	const args = jsxCallPath.get("arguments");
+	const propsArg = args[1];
+	if (!(propsArg === null || propsArg === void 0 ? void 0 : propsArg.isObjectExpression())) return;
+	const firstArgPath = args[0];
+	const gtName = (firstArgPath === null || firstArgPath === void 0 ? void 0 : firstArgPath.isExpression()) ? require_utils_constants_resolveIdentifier_isGTComponent.resolveFirstArgGTName(firstArgPath) : null;
+	for (const propPath of propsArg.get("properties")) {
+		if (!propPath.isObjectProperty()) continue;
+		const key = propPath.node.key;
+		const propName = _babel_types.isIdentifier(key) ? key.name : _babel_types.isStringLiteral(key) ? key.value : null;
+		if (isControlProp(gtName, propName)) continue;
+		const valuePath = propPath.get("value");
+		if (!valuePath.isExpression()) continue;
+		if (propName === "children") {
+			if (insideAutoT && (gtName === "Branch" || gtName === "Plural")) processChildren({
+				childrenPath: valuePath,
+				insideAutoT: true,
+				state
+			});
+			continue;
+		}
+		if (valuePath.isCallExpression() && isJsxCallPath(valuePath)) {
+			if (insideAutoT) {
+				const childrenPropPath = getChildrenPropPath(valuePath);
+				if (childrenPropPath) {
+					const childrenPath = childrenPropPath.get("value");
+					if (childrenPath.isExpression()) processChildren({
+						childrenPath,
+						insideAutoT: true,
+						state
+					});
+				}
+			}
+			state.processedNodes.add(valuePath.node);
+			walkAndMark({
+				exprPath: valuePath,
+				state
+			});
+		} else if (insideAutoT && needsVarWrapping(valuePath)) {
+			const callee = state.calleeInfo.singleCallee ?? "jsx";
+			const wrapped = wrapInVar(valuePath.node, _babel_types.identifier(callee), state.calleeInfo);
+			state.processedNodes.add(wrapped);
+			valuePath.replaceWith(wrapped);
+		}
+	}
 }
 function isControlProp(gtName, propName) {
-    if (!propName)
-        return false;
-    if (gtName === constants_1.GT_COMPONENT_TYPES.Branch) {
-        return constants_1.BRANCH_CONTROL_PROPS.has(propName) || propName.startsWith('data-');
-    }
-    if (gtName === constants_1.GT_COMPONENT_TYPES.Plural) {
-        return constants_1.PLURAL_CONTROL_PROPS.has(propName);
-    }
-    return false;
+	if (!propName) return false;
+	if (gtName === "Branch") return require_utils_constants_gt_constants.BRANCH_CONTROL_PROPS.has(propName) || propName.startsWith("data-");
+	if (gtName === "Plural") return require_utils_constants_gt_constants.PLURAL_CONTROL_PROPS.has(propName);
+	return false;
 }
-function walkAndMark({ exprPath, state, }) {
-    if (exprPath.isCallExpression() && isJsxCallPath(exprPath)) {
-        state.processedNodes.add(exprPath.node);
-        const childrenPropPath = getChildrenPropPath(exprPath);
-        if (childrenPropPath) {
-            const valuePath = childrenPropPath.get('value');
-            if (valuePath.isExpression()) {
-                walkAndMark({ exprPath: valuePath, state });
-            }
-        }
-    }
-    else if (exprPath.isArrayExpression()) {
-        for (const elPath of exprPath.get('elements')) {
-            if (elPath.isExpression()) {
-                walkAndMark({ exprPath: elPath, state });
-            }
-        }
-    }
+function walkAndMark({ exprPath, state }) {
+	if (exprPath.isCallExpression() && isJsxCallPath(exprPath)) {
+		state.processedNodes.add(exprPath.node);
+		const childrenPropPath = getChildrenPropPath(exprPath);
+		if (childrenPropPath) {
+			const valuePath = childrenPropPath.get("value");
+			if (valuePath.isExpression()) walkAndMark({
+				exprPath: valuePath,
+				state
+			});
+		}
+	} else if (exprPath.isArrayExpression()) {
+		for (const elPath of exprPath.get("elements")) if (elPath.isExpression()) walkAndMark({
+			exprPath: elPath,
+			state
+		});
+	}
 }
+//#endregion
+exports.processCallExpression = processCallExpression;
+
 //# sourceMappingURL=processCallExpression.js.map