gt 2.14.35 → 2.14.37

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

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

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

@@ -1,201 +1,130 @@
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { isElementNode, isExpressionNode, isMultiplicationNode, } from './types.js';
-// JSX whitespace characters (space, tab, newline, carriage return)
-// Does NOT include non-breaking space (U+00A0) which should be preserved
+import { isElementNode, isExpressionNode, isMultiplicationNode } from "./types.js";
+import { isAcceptedPluralForm } from "generaltranslation/internal";
+//#region src/react/jsx/utils/jsxParsing/handleChildrenWhitespace.ts
 const isJsxWhitespace = (char) => {
-    return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+	return char === " " || char === "	" || char === "\n" || char === "\r";
 };
-const trimJsxWhitespace = (str, side = 'both') => {
-    let start = 0;
-    let end = str.length;
-    if (side === 'start' || side === 'both') {
-        while (start < end && isJsxWhitespace(str[start])) {
-            start++;
-        }
-    }
-    if (side === 'end' || side === 'both') {
-        while (end > start && isJsxWhitespace(str[end - 1])) {
-            end--;
-        }
-    }
-    return str.slice(start, end);
+const trimJsxWhitespace = (str, side = "both") => {
+	let start = 0;
+	let end = str.length;
+	if (side === "start" || side === "both") while (start < end && isJsxWhitespace(str[start])) start++;
+	if (side === "end" || side === "both") while (end > start && isJsxWhitespace(str[end - 1])) end--;
+	return str.slice(start, end);
 };
 const hasNonJsxWhitespace = (str) => {
-    for (const char of str) {
-        if (!isJsxWhitespace(char))
-            return true;
-    }
-    return false;
+	for (const char of str) if (!isJsxWhitespace(char)) return true;
+	return false;
 };
-export function trimJsxStringChild(child) {
-    if (!child.includes('\n') && !child.includes('\r')) {
-        return child;
-    }
-    // Normalize line endings to \n for consistency across platforms
-    let result = child.replace(/\r\n|\r/g, '\n');
-    // Collapse multiple spaces/tabs into a single space (but not nbsp)
-    result = result.replace(/[\t ]+/g, ' ');
-    let newResult = '';
-    let newline = false;
-    for (const char of result) {
-        if (char === '\n') {
-            if (hasNonJsxWhitespace(newResult))
-                newResult += ' ';
-            else
-                newResult = '';
-            newline = true;
-            continue;
-        }
-        if (!newline) {
-            newResult += char;
-            continue;
-        }
-        if (isJsxWhitespace(char))
-            continue;
-        newResult += char;
-        newline = false;
-    }
-    if (newline)
-        newResult = trimJsxWhitespace(newResult, 'end');
-    result = newResult;
-    // Collapse multiple spaces/tabs into a single space (but not nbsp)
-    result = result.replace(/[\t ]+/g, ' ');
-    return result;
+function trimJsxStringChild(child) {
+	if (!child.includes("\n") && !child.includes("\r")) return child;
+	let result = child.replace(/\r\n|\r/g, "\n");
+	result = result.replace(/[\t ]+/g, " ");
+	let newResult = "";
+	let newline = false;
+	for (const char of result) {
+		if (char === "\n") {
+			if (hasNonJsxWhitespace(newResult)) newResult += " ";
+			else newResult = "";
+			newline = true;
+			continue;
+		}
+		if (!newline) {
+			newResult += char;
+			continue;
+		}
+		if (isJsxWhitespace(char)) continue;
+		newResult += char;
+		newline = false;
+	}
+	if (newline) newResult = trimJsxWhitespace(newResult, "end");
+	result = newResult;
+	result = result.replace(/[\t ]+/g, " ");
+	return result;
 }
 /**
- * Handles whitespace in children of a JSX element, and strips elements
- * @param currentTree - The current tree to handle
- * @returns The processed tree with whitespace handled
- *
- * For unresolved functions, we just make it so that Derive has no children
- *
- * The typing was so much worse before this. Don't come for me. All I did was enforce the typing.
- */
-export function handleChildrenWhitespace(currentTree, parentNodeType = undefined) {
-    if (Array.isArray(currentTree)) {
-        const childrenTypes = currentTree.map((child) => {
-            if (typeof child === 'string')
-                return 'text';
-            if (isExpressionNode(child))
-                return 'expression';
-            if (isElementNode(child))
-                return 'element';
-            if (isMultiplicationNode(child))
-                return 'multiplication';
-            return 'other';
-        });
-        const newChildren = [];
-        currentTree.forEach((child, index) => {
-            switch (childrenTypes[index]) {
-                case 'text':
-                    const textNode = child;
-                    if (parentNodeType === 'multiplication') {
-                        // This should be treated like a new tree (no parent here b/c its a new tree)
-                        const result = handleChildrenWhitespace(textNode);
-                        if (result)
-                            newChildren.push(result);
-                    }
-                    else {
-                        const string = trimJsxStringChild(textNode);
-                        if (string)
-                            newChildren.push(string);
-                    }
-                    break;
-                case 'expression':
-                    // Strip expressions
-                    const result = child.result;
-                    if (isMultiplicationNode(result)) {
-                        newChildren.push(handleChildrenWhitespace(result));
-                    }
-                    else if (typeof result === 'string') {
-                        newChildren.push(result);
-                    }
-                    else {
-                        // other case
-                        newChildren.push(result);
-                    }
-                    break;
-                case 'element':
-                    const newElement = handleChildrenWhitespace(child);
-                    newChildren.push(newElement);
-                    break;
-                case 'multiplication':
-                    newChildren.push({
-                        nodeType: 'multiplication',
-                        branches: handleChildrenWhitespace(child.branches, 'multiplication'),
-                    });
-                    break;
-                case 'other':
-                    // Return number or boolean or null
-                    newChildren.push(child);
-                    break;
-            }
-        });
-        if (parentNodeType === 'multiplication') {
-            // Return the branches as an array
-            return newChildren;
-        }
-        return newChildren.length === 1 ? newChildren[0] : newChildren;
-    }
-    else if (isElementNode(currentTree)) {
-        // Process all props recursively
-        // What if there is a different component sharing the same name?
-        const elementIsPlural = currentTree.type === 'Plural';
-        const elementIsBranch = currentTree.type === 'Branch';
-        const processedProps = !currentTree.props
-            ? undefined
-            : Object.fromEntries(Object.entries(currentTree.props).map(([key, value]) => {
-                let shouldProcess = false;
-                // Process children
-                if (key === 'children')
-                    shouldProcess = true;
-                // Process plural children
-                if (elementIsPlural && isAcceptedPluralForm(key))
-                    shouldProcess = true;
-                // Process branch children
-                if (elementIsBranch && key !== 'branch')
-                    shouldProcess = true;
-                // Do not process raw strings
-                if (typeof value === 'string' && key !== 'children')
-                    shouldProcess = false;
-                // Process props
-                if (!shouldProcess) {
-                    return [key, value];
-                }
-                const processChild = handleChildrenWhitespace;
-                return [
-                    key,
-                    processChild(value),
-                ];
-            }));
-        return {
-            nodeType: 'element',
-            type: currentTree.type,
-            ...(processedProps ? { props: processedProps } : {}),
-        };
-    }
-    else if (isExpressionNode(currentTree)) {
-        // Strip expression
-        const result = currentTree.result;
-        if (isMultiplicationNode(result)) {
-            return handleChildrenWhitespace(result);
-        }
-        else if (typeof result === 'string') {
-            return result;
-        }
-        else {
-            return result;
-        }
-    }
-    else if (isMultiplicationNode(currentTree)) {
-        return {
-            nodeType: 'multiplication',
-            branches: handleChildrenWhitespace(currentTree.branches, 'multiplication'),
-        };
-    }
-    else if (typeof currentTree === 'string') {
-        return trimJsxStringChild(currentTree);
-    }
-    // null or number or boolean
-    return currentTree;
+* Handles whitespace in children of a JSX element, and strips elements
+* @param currentTree - The current tree to handle
+* @returns The processed tree with whitespace handled
+*
+* For unresolved functions, we just make it so that Derive has no children
+*
+* The typing was so much worse before this. Don't come for me. All I did was enforce the typing.
+*/
+function handleChildrenWhitespace(currentTree, parentNodeType = void 0) {
+	if (Array.isArray(currentTree)) {
+		const childrenTypes = currentTree.map((child) => {
+			if (typeof child === "string") return "text";
+			if (isExpressionNode(child)) return "expression";
+			if (isElementNode(child)) return "element";
+			if (isMultiplicationNode(child)) return "multiplication";
+			return "other";
+		});
+		const newChildren = [];
+		currentTree.forEach((child, index) => {
+			switch (childrenTypes[index]) {
+				case "text":
+					const textNode = child;
+					if (parentNodeType === "multiplication") {
+						const result = handleChildrenWhitespace(textNode);
+						if (result) newChildren.push(result);
+					} else {
+						const string = trimJsxStringChild(textNode);
+						if (string) newChildren.push(string);
+					}
+					break;
+				case "expression":
+					const result = child.result;
+					if (isMultiplicationNode(result)) newChildren.push(handleChildrenWhitespace(result));
+					else if (typeof result === "string") newChildren.push(result);
+					else newChildren.push(result);
+					break;
+				case "element":
+					const newElement = handleChildrenWhitespace(child);
+					newChildren.push(newElement);
+					break;
+				case "multiplication":
+					newChildren.push({
+						nodeType: "multiplication",
+						branches: handleChildrenWhitespace(child.branches, "multiplication")
+					});
+					break;
+				case "other":
+					newChildren.push(child);
+					break;
+			}
+		});
+		if (parentNodeType === "multiplication") return newChildren;
+		return newChildren.length === 1 ? newChildren[0] : newChildren;
+	} else if (isElementNode(currentTree)) {
+		const elementIsPlural = currentTree.type === "Plural";
+		const elementIsBranch = currentTree.type === "Branch";
+		const processedProps = !currentTree.props ? void 0 : Object.fromEntries(Object.entries(currentTree.props).map(([key, value]) => {
+			let shouldProcess = false;
+			if (key === "children") shouldProcess = true;
+			if (elementIsPlural && isAcceptedPluralForm(key)) shouldProcess = true;
+			if (elementIsBranch && key !== "branch") shouldProcess = true;
+			if (typeof value === "string" && key !== "children") shouldProcess = false;
+			if (!shouldProcess) return [key, value];
+			return [key, handleChildrenWhitespace(value)];
+		}));
+		return {
+			nodeType: "element",
+			type: currentTree.type,
+			...processedProps ? { props: processedProps } : {}
+		};
+	} else if (isExpressionNode(currentTree)) {
+		const result = currentTree.result;
+		if (isMultiplicationNode(result)) return handleChildrenWhitespace(result);
+		else if (typeof result === "string") return result;
+		else return result;
+	} else if (isMultiplicationNode(currentTree)) return {
+		nodeType: "multiplication",
+		branches: handleChildrenWhitespace(currentTree.branches, "multiplication")
+	};
+	else if (typeof currentTree === "string") return trimJsxStringChild(currentTree);
+	return currentTree;
 }
+//#endregion
+export { handleChildrenWhitespace, trimJsxStringChild };
+
+//# sourceMappingURL=handleChildrenWhitespace.js.map

package/dist/react/jsx/utils/jsxParsing/handleChildrenWhitespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleChildrenWhitespace.js","names":["processChild"],"sources":["../../../../../src/react/jsx/utils/jsxParsing/handleChildrenWhitespace.ts"],"sourcesContent":["import { isAcceptedPluralForm } from 'generaltranslation/internal';\nimport {\n  ElementNode,\n  ExpressionNode,\n  isElementNode,\n  isExpressionNode,\n  isMultiplicationNode,\n  JsxTree,\n  MultiplicationNode,\n  WhitespaceJsxTreeResult,\n  WhitespaceMultiplicationNode,\n} from './types.js';\n\n// JSX whitespace characters (space, tab, newline, carriage return)\n// Does NOT include non-breaking space (U+00A0) which should be preserved\nconst isJsxWhitespace = (char: string) => {\n  return char === ' ' || char === '\\t' || char === '\\n' || char === '\\r';\n};\n\nconst trimJsxWhitespace = (\n  str: string,\n  side: 'start' | 'end' | 'both' = 'both'\n) => {\n  let start = 0;\n  let end = str.length;\n\n  if (side === 'start' || side === 'both') {\n    while (start < end && isJsxWhitespace(str[start])) {\n      start++;\n    }\n  }\n\n  if (side === 'end' || side === 'both') {\n    while (end > start && isJsxWhitespace(str[end - 1])) {\n      end--;\n    }\n  }\n\n  return str.slice(start, end);\n};\n\nconst hasNonJsxWhitespace = (str: string) => {\n  for (const char of str) {\n    if (!isJsxWhitespace(char)) return true;\n  }\n  return false;\n};\n\nexport function trimJsxStringChild(child: string) {\n  if (!child.includes('\\n') && !child.includes('\\r')) {\n    return child;\n  }\n\n  // Normalize line endings to \\n for consistency across platforms\n  let result = child.replace(/\\r\\n|\\r/g, '\\n');\n\n  // Collapse multiple spaces/tabs into a single space (but not nbsp)\n  result = result.replace(/[\\t ]+/g, ' ');\n\n  let newResult = '';\n  let newline = false;\n  for (const char of result) {\n    if (char === '\\n') {\n      if (hasNonJsxWhitespace(newResult)) newResult += ' ';\n      else newResult = '';\n      newline = true;\n      continue;\n    }\n    if (!newline) {\n      newResult += char;\n      continue;\n    }\n    if (isJsxWhitespace(char)) continue;\n    newResult += char;\n    newline = false;\n  }\n  if (newline) newResult = trimJsxWhitespace(newResult, 'end');\n  result = newResult;\n  // Collapse multiple spaces/tabs into a single space (but not nbsp)\n  result = result.replace(/[\\t ]+/g, ' ');\n  return result;\n}\n\n// Overload for when currentTree is an array\nexport function handleChildrenWhitespace(\n  currentTree: MultiplicationNode['branches'],\n  parentNodeType: 'multiplication'\n): (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];\n\n// Overload for when currentTree is an array\nexport function handleChildrenWhitespace(\n  currentTree: MultiplicationNode['branches'],\n  parentNodeType?: 'element' | 'expression' | undefined\n):\n  | WhitespaceJsxTreeResult\n  | WhitespaceMultiplicationNode\n  | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[];\n\n// Overload for when currentTree is not an array\nexport function handleChildrenWhitespace(\n  currentTree: MultiplicationNode | JsxTree,\n  parentNodeType?: 'multiplication' | 'element' | 'expression' | undefined\n): null | WhitespaceJsxTreeResult | WhitespaceMultiplicationNode;\n\n// Overload for entry point\nexport function handleChildrenWhitespace(\n  currentTree: JsxTree | JsxTree[]\n): null | WhitespaceJsxTreeResult | WhitespaceJsxTreeResult[];\n/**\n * Handles whitespace in children of a JSX element, and strips elements\n * @param currentTree - The current tree to handle\n * @returns The processed tree with whitespace handled\n *\n * For unresolved functions, we just make it so that Derive has no children\n *\n * The typing was so much worse before this. Don't come for me. All I did was enforce the typing.\n */\nexport function handleChildrenWhitespace(\n  currentTree: MultiplicationNode | JsxTree | MultiplicationNode['branches'],\n  parentNodeType:\n    | 'multiplication'\n    | 'element'\n    | 'expression'\n    | undefined = undefined\n):\n  | null\n  | WhitespaceJsxTreeResult\n  | WhitespaceMultiplicationNode\n  | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[] {\n  if (Array.isArray(currentTree)) {\n    const childrenTypes: (\n      | 'text'\n      | 'element'\n      | 'expression'\n      | 'multiplication'\n      | 'other'\n    )[] = currentTree.map((child) => {\n      if (typeof child === 'string') return 'text';\n      if (isExpressionNode(child)) return 'expression';\n      if (isElementNode(child)) return 'element';\n      if (isMultiplicationNode(child)) return 'multiplication';\n      return 'other';\n    });\n    const newChildren: (\n      | WhitespaceJsxTreeResult\n      | WhitespaceMultiplicationNode\n    )[] = [];\n    currentTree.forEach((child, index) => {\n      switch (childrenTypes[index]) {\n        case 'text':\n          const textNode = child as string;\n          if (parentNodeType === 'multiplication') {\n            // This should be treated like a new tree (no parent here b/c its a new tree)\n            const result = handleChildrenWhitespace(textNode);\n            if (result) newChildren.push(result);\n          } else {\n            const string = trimJsxStringChild(textNode);\n            if (string) newChildren.push(string);\n          }\n          break;\n        case 'expression':\n          // Strip expressions\n          const result = (child as ExpressionNode).result;\n          if (isMultiplicationNode(result)) {\n            newChildren.push(handleChildrenWhitespace(result));\n          } else if (typeof result === 'string') {\n            newChildren.push(result);\n          } else {\n            // other case\n            newChildren.push(result);\n          }\n          break;\n        case 'element':\n          const newElement = handleChildrenWhitespace(\n            child as ElementNode | null\n          );\n          newChildren.push(newElement);\n          break;\n        case 'multiplication':\n          newChildren.push({\n            nodeType: 'multiplication',\n            branches: handleChildrenWhitespace(\n              (child as MultiplicationNode).branches,\n              'multiplication'\n            ),\n          });\n          break;\n        case 'other':\n          // Return number or boolean or null\n          newChildren.push(child as number | boolean | null);\n          break;\n      }\n    });\n    if (parentNodeType === 'multiplication') {\n      // Return the branches as an array\n      return newChildren;\n    }\n    return newChildren.length === 1 ? newChildren[0] : newChildren;\n  } else if (isElementNode(currentTree)) {\n    // Process all props recursively\n    // What if there is a different component sharing the same name?\n    const elementIsPlural = currentTree.type === 'Plural';\n    const elementIsBranch = currentTree.type === 'Branch';\n    const processedProps = !currentTree.props\n      ? undefined\n      : Object.fromEntries(\n          Object.entries(currentTree.props).map(\n            ([key, value]:\n              | [string, unknown]\n              | [\n                  'children',\n                  (\n                    | JsxTree\n                    | MultiplicationNode\n                    | (JsxTree | MultiplicationNode)[]\n                  ),\n                ]): [string, unknown] => {\n              let shouldProcess = false;\n              // Process children\n              if (key === 'children') shouldProcess = true;\n              // Process plural children\n              if (elementIsPlural && isAcceptedPluralForm(key as string))\n                shouldProcess = true;\n              // Process branch children\n              if (elementIsBranch && key !== 'branch') shouldProcess = true;\n              // Do not process raw strings\n              if (typeof value === 'string' && key !== 'children')\n                shouldProcess = false;\n              // Process props\n              if (!shouldProcess) {\n                return [key, value];\n              }\n              const processChild = handleChildrenWhitespace as (\n                currentTree:\n                  | JsxTree\n                  | MultiplicationNode\n                  | (JsxTree | MultiplicationNode)[]\n              ) => unknown;\n              return [\n                key,\n                processChild(\n                  value as\n                    | JsxTree\n                    | MultiplicationNode\n                    | (JsxTree | MultiplicationNode)[]\n                ),\n              ];\n            }\n          )\n        );\n    return {\n      nodeType: 'element',\n      type: currentTree.type,\n      ...(processedProps ? { props: processedProps } : {}),\n    };\n  } else if (isExpressionNode(currentTree)) {\n    // Strip expression\n    const result = (currentTree as ExpressionNode).result;\n    if (isMultiplicationNode(result)) {\n      return handleChildrenWhitespace(result);\n    } else if (typeof result === 'string') {\n      return result;\n    } else {\n      return result;\n    }\n  } else if (isMultiplicationNode(currentTree)) {\n    return {\n      nodeType: 'multiplication',\n      branches: handleChildrenWhitespace(\n        currentTree.branches,\n        'multiplication'\n      ),\n    };\n  } else if (typeof currentTree === 'string') {\n    return trimJsxStringChild(currentTree);\n  }\n  // null or number or boolean\n  return currentTree;\n}\n"],"mappings":"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"}

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.js

@@ -1,66 +1,52 @@
-import { isWhitespaceMultiplicationNode, isWhitespaceJsxTree, } from '../types.js';
-import { isAcceptedPluralForm } from 'generaltranslation/internal';
-import { PLURAL_COMPONENT, BRANCH_COMPONENT, BRANCH_CONTROL_PROPS, } from '../../constants.js';
+import { BRANCH_COMPONENT, BRANCH_CONTROL_PROPS, PLURAL_COMPONENT } from "../../constants.js";
+import { isWhitespaceJsxTree, isWhitespaceMultiplicationNode } from "../types.js";
+import { isAcceptedPluralForm } from "generaltranslation/internal";
+//#region src/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.ts
 /**
- * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
- * TODO: I am sure there is some optimization to be done here
- *
- * Maybe there is an optimization here with caching used paths btwn calls
- */
-export function findMultiplicationNode(root) {
-    // Entry point
-    return handleChildren(root, undefined, undefined);
-    // Helper function to handle children
-    function handleChildren(curr, parent, key) {
-        if (Array.isArray(curr)) {
-            for (const [index, child] of Object.entries(curr)) {
-                const result = handleChild(child, curr, index);
-                if (result)
-                    return result;
-            }
-            return undefined;
-        }
-        else {
-            return handleChild(curr, parent, key);
-        }
-    }
-    // Helper function to handle a single child
-    function handleChild(curr, parent, key) {
-        if (isWhitespaceMultiplicationNode(curr)) {
-            return { parent, key, node: curr };
-        }
-        else if (isWhitespaceJsxTree(curr)) {
-            if (!curr.props)
-                return undefined;
-            // Check children first
-            if (curr.props.children) {
-                const result = handleChildren(curr.props.children, curr.props, 'children');
-                if (result)
-                    return result;
-            }
-            // For Plural/Branch, also search translatable content props
-            // Mirrors the prop filtering in handleChildrenWhitespace.ts and autoInsertion.ts
-            const elementIsPlural = curr.type === PLURAL_COMPONENT;
-            const elementIsBranch = curr.type === BRANCH_COMPONENT;
-            if (elementIsPlural || elementIsBranch) {
-                for (const [propKey, propValue] of Object.entries(curr.props)) {
-                    if (propKey === 'children')
-                        continue;
-                    if (elementIsPlural && !isAcceptedPluralForm(propKey))
-                        continue;
-                    if (elementIsBranch && BRANCH_CONTROL_PROPS.has(propKey))
-                        continue;
-                    if (propValue && typeof propValue === 'object') {
-                        const result = handleChildren(propValue, curr.props, propKey);
-                        if (result)
-                            return result;
-                    }
-                }
-            }
-            return undefined;
-        }
-        else {
-            return undefined;
-        }
-    }
+* Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)
+* TODO: I am sure there is some optimization to be done here
+*
+* Maybe there is an optimization here with caching used paths btwn calls
+*/
+function findMultiplicationNode(root) {
+	return handleChildren(root, void 0, void 0);
+	function handleChildren(curr, parent, key) {
+		if (Array.isArray(curr)) {
+			for (const [index, child] of Object.entries(curr)) {
+				const result = handleChild(child, curr, index);
+				if (result) return result;
+			}
+			return;
+		} else return handleChild(curr, parent, key);
+	}
+	function handleChild(curr, parent, key) {
+		if (isWhitespaceMultiplicationNode(curr)) return {
+			parent,
+			key,
+			node: curr
+		};
+		else if (isWhitespaceJsxTree(curr)) {
+			if (!curr.props) return void 0;
+			if (curr.props.children) {
+				const result = handleChildren(curr.props.children, curr.props, "children");
+				if (result) return result;
+			}
+			const elementIsPlural = curr.type === PLURAL_COMPONENT;
+			const elementIsBranch = curr.type === BRANCH_COMPONENT;
+			if (elementIsPlural || elementIsBranch) for (const [propKey, propValue] of Object.entries(curr.props)) {
+				if (propKey === "children") continue;
+				if (elementIsPlural && !isAcceptedPluralForm(propKey)) continue;
+				if (elementIsBranch && BRANCH_CONTROL_PROPS.has(propKey)) continue;
+				if (propValue && typeof propValue === "object") {
+					const result = handleChildren(propValue, curr.props, propKey);
+					if (result) return result;
+				}
+			}
+			return;
+		} else return;
+	}
 }
+//#endregion
+export { findMultiplicationNode };
+
+//# sourceMappingURL=findMultiplicationNode.js.map

package/dist/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findMultiplicationNode.js","names":[],"sources":["../../../../../../src/react/jsx/utils/jsxParsing/multiplication/findMultiplicationNode.ts"],"sourcesContent":["import {\n  WhitespaceJsxTreeResult,\n  WhitespaceMultiplicationNode,\n  isWhitespaceMultiplicationNode,\n  isWhitespaceJsxTree,\n} from '../types.js';\nimport { isAcceptedPluralForm } from 'generaltranslation/internal';\nimport {\n  PLURAL_COMPONENT,\n  BRANCH_COMPONENT,\n  BRANCH_CONTROL_PROPS,\n} from '../../constants.js';\n\nexport type MultiplicationNodeResult = {\n  parent: Record<string, unknown> | unknown[] | undefined;\n  key: string | undefined;\n  node: WhitespaceMultiplicationNode;\n};\n\n/**\n * Finds the immediate multiplication node from the given root (eg no nested multiplication nodes)\n * TODO: I am sure there is some optimization to be done here\n *\n * Maybe there is an optimization here with caching used paths btwn calls\n */\nexport function findMultiplicationNode(\n  root:\n    | WhitespaceJsxTreeResult\n    | WhitespaceMultiplicationNode\n    | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[]\n): MultiplicationNodeResult | undefined {\n  // Entry point\n  return handleChildren(root, undefined, undefined);\n\n  // Helper function to handle children\n  function handleChildren(\n    curr:\n      | WhitespaceJsxTreeResult\n      | WhitespaceMultiplicationNode\n      | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[],\n    parent: MultiplicationNodeResult['parent'],\n    key: string | undefined\n  ): MultiplicationNodeResult | undefined {\n    if (Array.isArray(curr)) {\n      for (const [index, child] of Object.entries(curr)) {\n        const result = handleChild(child, curr, index);\n        if (result) return result;\n      }\n      return undefined;\n    } else {\n      return handleChild(curr, parent, key);\n    }\n  }\n\n  // Helper function to handle a single child\n  function handleChild(\n    curr: WhitespaceJsxTreeResult | WhitespaceMultiplicationNode,\n    parent: MultiplicationNodeResult['parent'],\n    key: string | undefined\n  ): MultiplicationNodeResult | undefined {\n    if (isWhitespaceMultiplicationNode(curr)) {\n      return { parent, key, node: curr };\n    } else if (isWhitespaceJsxTree(curr)) {\n      if (!curr.props) return undefined;\n\n      // Check children first\n      if (curr.props.children) {\n        const result = handleChildren(\n          curr.props.children,\n          curr.props,\n          'children'\n        );\n        if (result) return result;\n      }\n\n      // For Plural/Branch, also search translatable content props\n      // Mirrors the prop filtering in handleChildrenWhitespace.ts and autoInsertion.ts\n      const elementIsPlural = curr.type === PLURAL_COMPONENT;\n      const elementIsBranch = curr.type === BRANCH_COMPONENT;\n      if (elementIsPlural || elementIsBranch) {\n        for (const [propKey, propValue] of Object.entries(curr.props)) {\n          if (propKey === 'children') continue;\n          if (elementIsPlural && !isAcceptedPluralForm(propKey)) continue;\n          if (elementIsBranch && BRANCH_CONTROL_PROPS.has(propKey)) continue;\n          if (propValue && typeof propValue === 'object') {\n            const result = handleChildren(\n              propValue as\n                | WhitespaceJsxTreeResult\n                | WhitespaceMultiplicationNode\n                | (WhitespaceJsxTreeResult | WhitespaceMultiplicationNode)[],\n              curr.props,\n              propKey\n            );\n            if (result) return result;\n          }\n        }\n      }\n\n      return undefined;\n    } else {\n      return undefined;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;AAyBA,SAAgB,uBACd,MAIsC;AAEtC,QAAO,eAAe,MAAM,KAAA,GAAW,KAAA,EAAU;CAGjD,SAAS,eACP,MAIA,QACA,KACsC;AACtC,MAAI,MAAM,QAAQ,KAAK,EAAE;AACvB,QAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,KAAK,EAAE;IACjD,MAAM,SAAS,YAAY,OAAO,MAAM,MAAM;AAC9C,QAAI,OAAQ,QAAO;;AAErB;QAEA,QAAO,YAAY,MAAM,QAAQ,IAAI;;CAKzC,SAAS,YACP,MACA,QACA,KACsC;AACtC,MAAI,+BAA+B,KAAK,CACtC,QAAO;GAAE;GAAQ;GAAK,MAAM;GAAM;WACzB,oBAAoB,KAAK,EAAE;AACpC,OAAI,CAAC,KAAK,MAAO,QAAO,KAAA;AAGxB,OAAI,KAAK,MAAM,UAAU;IACvB,MAAM,SAAS,eACb,KAAK,MAAM,UACX,KAAK,OACL,WACD;AACD,QAAI,OAAQ,QAAO;;GAKrB,MAAM,kBAAkB,KAAK,SAAS;GACtC,MAAM,kBAAkB,KAAK,SAAS;AACtC,OAAI,mBAAmB,gBACrB,MAAK,MAAM,CAAC,SAAS,cAAc,OAAO,QAAQ,KAAK,MAAM,EAAE;AAC7D,QAAI,YAAY,WAAY;AAC5B,QAAI,mBAAmB,CAAC,qBAAqB,QAAQ,CAAE;AACvD,QAAI,mBAAmB,qBAAqB,IAAI,QAAQ,CAAE;AAC1D,QAAI,aAAa,OAAO,cAAc,UAAU;KAC9C,MAAM,SAAS,eACb,WAIA,KAAK,OACL,QACD;AACD,SAAI,OAAQ,QAAO;;;AAKzB;QAEA"}