i18next-cli 1.24.12 → 1.24.14

package/src/extractor/parsers/jsx-parser.ts

@@ -1,1463 +0,0 @@
-import type { Expression, JSXAttribute, JSXElement, JSXExpression, ObjectExpression } from '@swc/core'
-import type { I18nextToolkitConfig } from '../../types'
-import { getObjectPropValue, getObjectPropValueExpression, isSimpleTemplateLiteral } from './ast-utils'
-
-export interface ExtractedJSXAttributes {
-  /** holds the raw key expression from the AST */
-  keyExpression?: Expression;
-
-  /** holds the serialized JSX children from the AST */
-  serializedChildren: string;
-
-  /** Default value to use in the primary language */
-  defaultValue?: string;
-
-  /** Namespace this key belongs to (if defined on <Trans />) */
-  ns?: string;
-
-  /** Whether this key is used with pluralization (count parameter) */
-  hasCount?: boolean;
-
-  /** Whether this key is used with ordinal pluralization */
-  isOrdinal?: boolean;
-
-  /** AST node for options object, used for advanced plural handling in Trans */
-  optionsNode?: ObjectExpression;
-
-  /** hold the raw context expression from the AST */
-  contextExpression?: Expression;
-
-  /** Whether the defaultValue was explicitly provided on the <Trans /> (defaults prop or tOptions defaultValue*) */
-  explicitDefault?: boolean;
-}
-
-function getStringLiteralFromExpression (expression: JSXExpression | null): string | undefined {
-  if (!expression) return undefined
-
-  if (expression.type === 'StringLiteral') {
-    return expression.value
-  }
-
-  if (expression.type === 'TemplateLiteral' && isSimpleTemplateLiteral(expression)) {
-    return expression.quasis[0].cooked
-  }
-
-  return undefined
-}
-
-function getStringLiteralFromAttribute (attr: JSXAttribute): string | undefined {
-  if (attr.value?.type === 'StringLiteral') {
-    return attr.value.value
-  }
-
-  if (attr.value?.type === 'JSXExpressionContainer') {
-    return getStringLiteralFromExpression(attr.value.expression)
-  }
-
-  return undefined
-}
-
-/**
- * Extracts translation keys from JSX Trans components.
- *
- * This function handles various Trans component patterns:
- * - Explicit i18nKey prop: `<Trans i18nKey="my.key">content</Trans>`
- * - Implicit keys from children: `<Trans>Hello World</Trans>`
- * - Namespace specification: `<Trans ns="common">content</Trans>`
- * - Default values: `<Trans defaults="Default text">content</Trans>`
- * - Pluralization: `<Trans count={count}>content</Trans>`
- * - HTML preservation: `<Trans>Hello <strong>world</strong></Trans>`
- *
- * @param node - The JSX element node to process
- * @param config - The toolkit configuration containing extraction settings
- * @returns Extracted key information or null if no valid key found
- *
- * @example
- * ```typescript
- * // Input JSX:
- * // <Trans i18nKey="welcome.title" ns="home" defaults="Welcome!">
- * //   Welcome to our <strong>amazing</strong> app!
- * // </Trans>
- *
- * const result = extractFromTransComponent(jsxNode, config)
- * // Returns: {
- * //   key: 'welcome.title',
- * //   keyExpression: { ... },
- * //   ns: 'home',
- * //   defaultValue: 'Welcome!',
- * //   hasCount: false
- * // }
- * ```
- */
-export function extractFromTransComponent (node: JSXElement, config: I18nextToolkitConfig): ExtractedJSXAttributes | null {
-  const i18nKeyAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-      attr.name.type === 'Identifier' &&
-      attr.name.value === 'i18nKey'
-  )
-
-  const defaultsAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-      attr.name.type === 'Identifier' &&
-      attr.name.value === 'defaults'
-  )
-
-  const countAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-      attr.name.type === 'Identifier' &&
-      attr.name.value === 'count'
-  )
-
-  const valuesAttr = node.opening.attributes?.find(
-    (attr) => attr.type === 'JSXAttribute' && attr.name.type === 'Identifier' && attr.name.value === 'values'
-  )
-
-  // Find the 'count' property in the 'values' object if count={...} is not defined
-  let valuesCountProperty: Expression | undefined
-  if (
-    !countAttr &&
-    valuesAttr?.type === 'JSXAttribute' &&
-    valuesAttr.value?.type === 'JSXExpressionContainer' &&
-    valuesAttr.value.expression.type === 'ObjectExpression'
-  ) {
-    valuesCountProperty = getObjectPropValueExpression(valuesAttr.value.expression, 'count')
-  }
-
-  const hasCount = !!countAttr || !!valuesCountProperty
-
-  const tOptionsAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-      attr.name.type === 'Identifier' &&
-      attr.name.value === 'tOptions'
-  )
-  const optionsNode = (tOptionsAttr?.type === 'JSXAttribute' && tOptionsAttr.value?.type === 'JSXExpressionContainer' && tOptionsAttr.value.expression.type === 'ObjectExpression')
-    ? tOptionsAttr.value.expression
-    : undefined
-
-  // Find isOrdinal prop on the <Trans> component
-  const ordinalAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-            attr.name.type === 'Identifier' &&
-            attr.name.value === 'ordinal'
-  )
-  const isOrdinal = !!ordinalAttr
-
-  const contextAttr = node.opening.attributes?.find(
-    (attr) =>
-      attr.type === 'JSXAttribute' &&
-        attr.name.type === 'Identifier' &&
-        attr.name.value === 'context'
-  )
-  let contextExpression = (contextAttr?.type === 'JSXAttribute' && contextAttr.value?.type === 'JSXExpressionContainer')
-    ? contextAttr.value.expression
-    : (contextAttr?.type === 'JSXAttribute' && contextAttr.value?.type === 'StringLiteral')
-        ? contextAttr.value
-        : undefined
-
-  // 1. Prioritize direct props for 'ns' and 'context'
-  const nsAttr = node.opening.attributes?.find(attr => attr.type === 'JSXAttribute' && attr.name.type === 'Identifier' && attr.name.value === 'ns')
-  let ns: string | undefined
-  if (nsAttr?.type === 'JSXAttribute') {
-    ns = getStringLiteralFromAttribute(nsAttr)
-  } else {
-    ns = undefined
-  }
-
-  // 2. If not found, fall back to looking inside tOptions
-  if (optionsNode) {
-    if (ns === undefined) {
-      ns = getObjectPropValue(optionsNode, 'ns') as string | undefined
-    }
-    if (contextExpression === undefined) {
-      contextExpression = getObjectPropValueExpression(optionsNode, 'context')
-    }
-  }
-
-  const serialized = serializeJSXChildren(node.children, config)
-
-  // Handle default value properly
-  let defaultValue: string
-
-  const defaultAttributeLiteral = defaultsAttr?.type === 'JSXAttribute' ? getStringLiteralFromAttribute(defaultsAttr) : undefined
-  if (defaultAttributeLiteral !== undefined) {
-    // Explicit defaults attribute takes precedence
-    defaultValue = defaultAttributeLiteral
-  } else {
-    // Use the configured default value or fall back to empty string
-    const configuredDefault = config.extract.defaultValue
-    if (typeof configuredDefault === 'string') {
-      defaultValue = configuredDefault
-    } else {
-      // For function-based defaults or undefined, use empty string as placeholder
-      // The translation manager will handle function resolution with proper context
-      defaultValue = ''
-    }
-  }
-
-  let keyExpression: Expression | undefined
-  let processedKeyValue: string | undefined
-
-  if (i18nKeyAttr?.type === 'JSXAttribute') {
-    if (i18nKeyAttr.value?.type === 'StringLiteral') {
-      keyExpression = i18nKeyAttr.value
-      processedKeyValue = keyExpression.value
-
-      // Validate that the key is not empty
-      if (!processedKeyValue || processedKeyValue.trim() === '') {
-        return null
-      }
-
-      // Handle namespace prefix removal when both ns and i18nKey are provided
-      if (ns && keyExpression.type === 'StringLiteral') {
-        const nsSeparator = config.extract.nsSeparator ?? ':'
-        const keyValue = keyExpression.value
-
-        // If the key starts with the namespace followed by the separator, remove the prefix
-        if (nsSeparator && keyValue.startsWith(`${ns}${nsSeparator}`)) {
-          processedKeyValue = keyValue.slice(`${ns}${nsSeparator}`.length)
-
-          // Validate processed key is not empty
-          if (!processedKeyValue || processedKeyValue.trim() === '') {
-            return null
-          }
-
-          // Create a new StringLiteral with the namespace prefix removed
-          keyExpression = {
-            ...keyExpression,
-            value: processedKeyValue
-          }
-        }
-      }
-    } else if (
-      i18nKeyAttr.value?.type === 'JSXExpressionContainer' &&
-      i18nKeyAttr.value.expression.type !== 'JSXEmptyExpression'
-    ) {
-      keyExpression = i18nKeyAttr.value.expression
-    }
-
-    if (!keyExpression) return null
-  }
-
-  // If no explicit defaults provided and we have a processed key, use it as default value
-  // This matches the behavior of other similar tests in the codebase
-  if (!defaultsAttr && processedKeyValue && !serialized.trim()) {
-    defaultValue = processedKeyValue
-  } else if (!defaultsAttr && serialized.trim()) {
-    defaultValue = serialized
-  }
-
-  // Determine if tOptions contained explicit defaultValue* properties
-  const optionsHasDefaultProps = (opts?: ObjectExpression) => {
-    if (!opts || !Array.isArray((opts as any).properties)) return false
-    for (const p of (opts as any).properties) {
-      if (p && p.type === 'KeyValueProperty' && p.key) {
-        const keyName = (p.key.type === 'Identifier' && p.key.value) || (p.key.type === 'StringLiteral' && p.key.value)
-        if (typeof keyName === 'string' && keyName.startsWith('defaultValue')) return true
-      }
-    }
-    return false
-  }
-
-  const explicitDefault = defaultAttributeLiteral !== undefined || optionsHasDefaultProps(optionsNode)
-
-  return {
-    keyExpression,
-    serializedChildren: serialized,
-    ns,
-    defaultValue,
-    hasCount,
-    isOrdinal,
-    contextExpression,
-    optionsNode,
-    explicitDefault
-  }
-}
-
-/**
- * Serializes JSX children into a string, correctly indexing component placeholders.
- * This version correctly calculates an element's index based on its position
- * among its sibling *elements*, ignoring text nodes for indexing purposes.
- */
-function serializeJSXChildren (children: any[], config: I18nextToolkitConfig): string {
-  if (!children || children.length === 0) return ''
-
-  const allowedTags = new Set(config.extract.transKeepBasicHtmlNodesFor ?? ['br', 'strong', 'i', 'p'])
-
-  const isFormattingWhitespace = (n: any) =>
-    n &&
-    n.type === 'JSXText' &&
-    /^\s*$/.test(n.value) &&
-    n.value.includes('\n')
-
-  // Build deterministic global slot list (pre-order)
-  function collectSlots (nodes: any[], slots: any[], parentIsNonPreserved = false, isRootLevel = false) {
-    if (!nodes || !nodes.length) return
-
-    // Check if there are multiple <p> elements at root level
-    const multiplePAtRoot = isRootLevel && nodes.filter((n: any) =>
-      n && n.type === 'JSXElement' && n.opening?.name?.value === 'p'
-    ).length > 1
-
-    // First, identify boundary whitespace nodes (start and end of sibling list)
-    // We trim ONLY pure-whitespace JSXText nodes from the boundaries
-    let startIdx = 0
-    let endIdx = nodes.length - 1
-
-    // Skip leading boundary whitespace (pure whitespace JSXText only)
-    while (startIdx <= endIdx && isFormattingWhitespace(nodes[startIdx])) {
-      startIdx++
-    }
-
-    // Skip trailing boundary whitespace (pure whitespace JSXText only)
-    while (endIdx >= startIdx && isFormattingWhitespace(nodes[endIdx])) {
-      endIdx--
-    }
-
-    // Now process all nodes in the range [startIdx, endIdx] - this includes interior whitespace
-    const meaningfulNodes = startIdx <= endIdx ? nodes.slice(startIdx, endIdx + 1) : []
-
-    // If the parent is non-preserved but it contains element/fragment children,
-    // we want to keep meaningful text & simple expressions so inline-tags inside
-    // a single wrapper (e.g. <span>.. <code/> ..</span>) preserve sibling ordering.
-    // If there are NO element children (e.g. <pre>some text</pre>) then all inner
-    // text/expressions should be treated as part of the parent and NOT create slots.
-    const parentHasElementChildren = meaningfulNodes.some(
-      (n) => n && (n.type === 'JSXElement' || n.type === 'JSXFragment')
-    )
-
-    for (let i = 0; i < meaningfulNodes.length; i++) {
-      const n = meaningfulNodes[i]
-      if (!n) continue
-
-      if (n.type === 'JSXText') {
-        // When inside a non-preserved parent that has no element children (e.g. <pre>),
-        // skip all inner text nodes — they're part of the parent and must not shift indexes.
-        if (parentIsNonPreserved && !parentHasElementChildren) {
-          continue
-        }
-
-        // For non-preserved parents that DO have element children, only skip pure
-        // formatting whitespace; keep meaningful text so inline sibling indexes stay correct.
-        if (parentIsNonPreserved && isFormattingWhitespace(n)) {
-          continue
-        }
-
-        // Otherwise, preserve previous behavior for boundary/formatting merging.
-        if (isFormattingWhitespace(n)) {
-          // If this formatting whitespace sits between two element/fragment nodes
-          // (e.g. <br />\n  <small>...), treat it as layout-only and skip it so it
-          // doesn't become its own slot and shift subsequent element indexes.
-          const prevOrig = meaningfulNodes[i - 1]
-          const nextOrig = meaningfulNodes[i + 1]
-          if (
-            prevOrig &&
-            (prevOrig.type === 'JSXElement' || prevOrig.type === 'JSXFragment') &&
-            nextOrig &&
-            (nextOrig.type === 'JSXElement' || nextOrig.type === 'JSXFragment')
-          ) {
-            continue
-          }
-
-          const prevSlot = slots[slots.length - 1]
-          const prevOriginal = meaningfulNodes[i - 1]
-
-          if (prevSlot) {
-            // If the previous original sibling is an expression container, treat
-            // this formatting whitespace as formatting after an expression and skip it.
-            if (prevOriginal && prevOriginal.type === 'JSXExpressionContainer') {
-              continue
-            }
-            // Only merge into previous text when the previous original sibling was also JSXText.
-            if (prevSlot.type === 'JSXText' && prevOriginal && prevOriginal.type === 'JSXText') {
-              prevSlot.value = String(prevSlot.value) + n.value
-              continue
-            }
-          }
-        }
-
-        // Don't treat the FIRST meaningful text node inside a non-preserved parent
-        // that also contains element children as an independent global slot.
-        // This preserves expected placeholder indexing for inline tags wrapped
-        // inside a single container (e.g. <span>text <code/> more <code/> ...</span>).
-        if (parentIsNonPreserved && parentHasElementChildren && i === 0) {
-          continue
-        }
-
-        // Add all other JSXText nodes
-        slots.push(n)
-        continue
-      }
-
-      if (n.type === 'JSXExpressionContainer') {
-        // If this expression is inside a non-preserved parent element that has NO
-        // element children (e.g. <pre>{'foo'}</pre>), treat common simple expressions
-        // as part of the parent and do NOT add them as separate sibling/global slots.
-        if (parentIsNonPreserved && !parentHasElementChildren && n.expression) {
-          const exprType = n.expression.type
-          // ObjectExpression placeholders ({{ key: value }}) should be treated
-          // as part of the parent.
-          if (exprType === 'ObjectExpression') {
-            const prop = n.expression.properties && n.expression.properties[0]
-            if (prop && prop.type === 'KeyValueProperty') {
-              continue
-            }
-          }
-
-          // For common simple content expressions, don't allocate a separate slot.
-          // However, if it's a pure-space StringLiteral ({" "}) we want to keep the
-          // special-space handling below, so only skip non-whitespace string literals.
-          const textVal = getStringLiteralFromExpression(n.expression)
-          if (textVal !== undefined) {
-            const isPureSpaceNoNewline = /^\s*$/.test(textVal) && !textVal.includes('\n')
-            if (!isPureSpaceNoNewline) {
-              continue
-            }
-            // otherwise fall through to the pure-space handling below
-          } else if (exprType === 'Identifier' || exprType === 'MemberExpression' || exprType === 'CallExpression') {
-            continue
-          }
-        }
-
-        // Handle pure-string expression containers (e.g. {" "}):
-        // - If it's pure space (no newline) and it directly follows a non-text sibling
-        //   (element/fragment), treat it as formatting and skip it.
-        // - Otherwise, count it as a slot (do NOT merge it into previous JSXText).
-        const textVal = getStringLiteralFromExpression(n.expression)
-        if (textVal !== undefined) {
-          const isPureSpaceNoNewline = /^\s*$/.test(textVal) && !textVal.includes('\n')
-          const prevOriginal = meaningfulNodes[i - 1]
-          const nextOriginal = meaningfulNodes[i + 1]
-
-          if (isPureSpaceNoNewline) {
-            // If the explicit {" "} is followed by a newline-only JSXText which
-            // itself is followed by an element/fragment, treat the {" "}
-            // as layout-only and skip it. This covers cases where the space
-            // precedes a newline-only separator before an element (fixes index
-            // shifting in object-expression span tests).
-            const nextNextOriginal = meaningfulNodes[i + 2]
-            if (
-              nextOriginal &&
-              nextOriginal.type === 'JSXText' &&
-              isFormattingWhitespace(nextOriginal) &&
-              nextNextOriginal &&
-              (nextNextOriginal.type === 'JSXElement' || nextNextOriginal.type === 'JSXFragment')
-            ) {
-              const prevOriginalCandidate = meaningfulNodes[i - 1]
-              const prevPrevOriginal = meaningfulNodes[i - 2]
-              const shouldSkip =
-                !prevOriginalCandidate ||
-                (prevOriginalCandidate.type !== 'JSXText' && prevPrevOriginal && prevPrevOriginal.type === 'JSXExpressionContainer')
-
-              if (shouldSkip) {
-                continue
-              }
-            }
-
-            // Only treat {" "} as pure formatting to skip when it sits between
-            // an element/fragment and a newline-only JSXText. In that specific
-            // boundary case the explicit space is merely layout and must be ignored.
-            if (
-              prevOriginal &&
-              (prevOriginal.type === 'JSXElement' || prevOriginal.type === 'JSXFragment') &&
-              nextOriginal &&
-              nextOriginal.type === 'JSXText' &&
-              isFormattingWhitespace(nextOriginal)
-            ) {
-              continue
-            }
-
-            // 1) Merge into previous text when the previous original sibling is JSXText
-            //    and the next original sibling is either missing or a non-formatting JSXText.
-            //    This preserves "foo{' '}bar" as a single text node but avoids merging
-            //    when the {" "} is followed by newline-only formatting before an element.
-            const nextIsTextNonFormatting = !nextOriginal || (nextOriginal.type === 'JSXText' && !isFormattingWhitespace(nextOriginal))
-            if (prevOriginal && prevOriginal.type === 'JSXText' && nextIsTextNonFormatting) {
-              const prevSlot = slots[slots.length - 1]
-              if (prevSlot && prevSlot.type === 'JSXText') {
-                prevSlot.value = String(prevSlot.value) + n.expression.value
-                continue
-              }
-            }
-
-            // 2) Skip when this explicit space sits between an element/fragment
-            //    and a newline-only formatting JSXText (boundary formatting).
-            if (
-              prevOriginal &&
-              (prevOriginal.type === 'JSXElement' || prevOriginal.type === 'JSXFragment') &&
-              nextOriginal &&
-              nextOriginal.type === 'JSXText' &&
-              isFormattingWhitespace(nextOriginal)
-            ) {
-              continue
-            }
-            // 3) Otherwise fallthrough and count this expression as a slot.
-          }
-        }
-
-        // All JSXExpressionContainers count as slots for indexing.
-        slots.push(n)
-        continue
-      }
-
-      if (n.type === 'JSXElement') {
-        const tagName = n.opening && n.opening.name && n.opening.name.type === 'Identifier'
-          ? n.opening.name.value
-          : undefined
-        if (tagName && allowedTags.has(tagName)) {
-          // Check if this preserved tag will actually be preserved as literal HTML
-          // or if it will be indexed (has complex children or attributes)
-          const hasAttrs =
-            n.opening &&
-            Array.isArray((n.opening as any).attributes) &&
-            (n.opening as any).attributes.length > 0
-          const children = n.children || []
-          // Check for single PURE text child (JSXText OR simple string expression)
-          const isSinglePureTextChild =
-            children.length === 1 && (
-              children[0]?.type === 'JSXText' ||
-              (children[0]?.type === 'JSXExpressionContainer' &&
-                getStringLiteralFromExpression(children[0].expression) !== undefined)
-            )
-
-          // Self-closing tags (no children) should be added to slots but rendered as literal HTML
-          // Tags with single pure text child should NOT be added to slots and rendered as literal HTML
-          const isSelfClosing = !children.length
-          const hasTextContent = isSinglePureTextChild
-
-          if (hasAttrs && !isSinglePureTextChild) {
-            // Has attributes AND complex children -> will be indexed, add to slots
-            slots.push(n)
-            collectSlots(n.children || [], slots, true)
-          } else if (isSelfClosing) {
-            // Self-closing tag with no attributes: add to slots (affects indexes) but will render as literal
-            slots.push(n)
-          } else if (!hasTextContent) {
-            // Has complex children but no attributes
-            // For <p> tags at root level with multiple <p> siblings, index them
-            // For other preserved tags, preserve as literal (don't add to slots)
-            if (tagName === 'p' && multiplePAtRoot) {
-              slots.push(n)
-              collectSlots(n.children || [], slots, true, false)
-            } else {
-              // Other preserved tags: preserve as literal, don't add to slots
-              // But DO process children to add them to slots
-              collectSlots(n.children || [], slots, false, false)
-            }
-          } else {
-            // Has single pure text child and no attributes: preserve as literal, don't add to slots
-            // Don't process children either - they're part of the preserved tag
-          }
-          continue
-        } else {
-          // non-preserved element: the element itself is a single slot.
-          // Pre-order: allocate the parent's slot first, then descend into its
-          // children. While descending, mark parentIsNonPreserved so
-          // KeyValueProperty-style object-expression placeholders are not added
-          // as separate sibling slots.
-          slots.push(n)
-          collectSlots(n.children || [], slots, true)
-        }
-        continue
-      }
-
-      if (n.type === 'JSXFragment') {
-        collectSlots(n.children || [], slots, parentIsNonPreserved)
-        continue
-      }
-
-      // ignore unknown node types
-    }
-  }
-
-  // prepare the global slot list for the whole subtree
-  const globalSlots: any[] = []
-  collectSlots(children, globalSlots, false, true)
-
-  // Helper: more precise detection whether children contain non-element global
-  // slots that should force the parent to use global indexing. This mirrors
-  // the later inlined logic and avoids counting trailing text as forcing global.
-  function hasNonElementGlobalSlotsAmongChildren (childrenList: any[]) {
-    if (!childrenList || !childrenList.length) return false
-    let foundElement = false
-    for (const ch of childrenList) {
-      if (!ch) continue
-      if (ch.type === 'JSXElement') {
-        foundElement = true
-        continue
-      }
-      if (ch.type === 'JSXExpressionContainer' && globalSlots.indexOf(ch) !== -1) {
-        // Only count an expression as forcing global indexing when it appears
-        // after at least one element (i.e. between elements), not if it's before.
-        return foundElement
-      }
-      if (ch.type === 'JSXText' && globalSlots.indexOf(ch) !== -1) {
-        // Exclude pure formatting whitespace
-        if (isFormattingWhitespace(ch)) continue
-
-        // If text appears before the first element -> force global indexing
-        if (!foundElement) return true
-
-        // If text is between elements -> force global indexing
-        const idx = childrenList.indexOf(ch)
-        const remaining = childrenList.slice(idx + 1)
-        const hasMoreElements = remaining.some((n: any) => n && n.type === 'JSXElement')
-        if (hasMoreElements) return true
-        // Trailing text after last element does not force global indexing
-      }
-    }
-    return false
-  }
-
-  // Track ELEMENT NODES that MUST be tight (no spaces) because the element splits a word across a newline.
-  // We'll map these node refs to numeric global indices later before string cleanup.
-  const tightNoSpaceNodes = new Set<any>()
-
-  // Trim only newline-only indentation at the edges of serialized inner text.
-  // This preserves single leading/trailing spaces which are meaningful between inline placeholders.
-  const trimFormattingEdges = (s: string) =>
-    String(s)
-      // remove leading newline-only indentation
-      .replace(/^\s*\n\s*/g, '')
-      // remove trailing newline-only indentation
-      .replace(/\s*\n\s*$/g, '')
-
-  function visitNodes (nodes: any[], localIndexMap?: Map<any, number>, isRootLevel = false): string {
-    if (!nodes || nodes.length === 0) return ''
-    let out = ''
-
-    // Resolve a numeric index for a node using localIndexMap when possible.
-    // Some AST node references may not match by identity in maps (e.g. after cloning),
-    // so also attempt to match by span positions as a fallback.
-    const resolveIndex = (n: any) => {
-      if (!n) return -1
-      if (localIndexMap && localIndexMap.has(n)) return localIndexMap.get(n)
-      if (localIndexMap) {
-        for (const [k, v] of localIndexMap.entries()) {
-          try {
-            if (k && n && k.span && n.span && k.span.start === n.span.start && k.span.end === n.span.end) return v
-          } catch (e) { /* ignore */ }
-        }
-      }
-      return globalSlots.indexOf(n)
-    }
-
-    // At root level, build index based on element position among siblings
-    let rootElementIndex = 0
-
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i]
-      if (!node) continue
-
-      if (node.type === 'JSXText') {
-        if (isFormattingWhitespace(node)) continue
-
-        const nextNode = nodes[i + 1]
-        const prevNode = nodes[i - 1]
-
-        // If this text follows a preserved tag and starts with newline+whitespace, trim it
-        if (prevNode && prevNode.type === 'JSXElement') {
-          const prevTag = prevNode.opening?.name?.type === 'Identifier' ? prevNode.opening.name.value : undefined
-          const prevIsPreservedTag = prevTag && allowedTags.has(prevTag)
-
-          // Only trim leading whitespace after SELF-CLOSING preserved tags (like <br />)
-          // Block tags like <p> or inline tags like <strong> need surrounding spaces
-          const prevChildren = prevNode.children || []
-          const prevIsSelfClosing = prevChildren.length === 0
-
-          if (prevIsPreservedTag && prevIsSelfClosing && /^\s*\n\s*/.test(node.value)) {
-            // Text starts with newline after a self-closing preserved tag - trim leading formatting
-            const trimmedValue = node.value.replace(/^\s*\n\s*/, '')
-            if (trimmedValue) {
-              out += trimmedValue
-              continue
-            }
-            // If nothing left after trimming, skip this node
-            continue
-          }
-
-          // If previous node is a non-preserved element (an indexed placeholder)
-          // and the current text starts with a formatting newline, detect
-          // the "word-split" scenario: previous meaningful text (before the element)
-          // ends with an alnum char and this trimmed text starts with alnum.
-          // In that case do NOT insert any separating space — the inline element
-          // split a single word across lines.
-          if (!prevIsPreservedTag && /^\s*\n\s*/.test(node.value)) {
-            const trimmedValue = node.value.replace(/^\s*\n\s*/, '')
-            if (trimmedValue) {
-              // If the previous element is a self-closing non-preserved element,
-              // do not insert an extra separating space — common for inline
-              // components like <NumberInput/>days
-              if (prevNode && prevNode.type === 'JSXElement' && Array.isArray(prevNode.children) && prevNode.children.length === 0) {
-                out += trimmedValue
-                continue
-              }
-
-              const prevPrev = nodes[i - 2]
-              if (prevPrev && prevPrev.type === 'JSXText') {
-                const prevPrevTrimmed = prevPrev.value.replace(/\n\s*$/, '')
-                const prevEndsAlnum = /[A-Za-z0-9]$/.test(prevPrevTrimmed)
-                const nextStartsAlnum = /^[A-Za-z0-9]/.test(trimmedValue)
-                const nextStartsLowercase = /^[a-z]/.test(trimmedValue)
-                if (prevEndsAlnum && nextStartsAlnum && nextStartsLowercase) {
-                  // word-split: do NOT insert a space
-                  out += trimmedValue
-                  continue
-                }
-              }
-              // non-word-split: insert a separating space before the trimmed text
-              out += ' ' + trimmedValue
-              continue
-            }
-            continue
-          }
-        }
-
-        // If this text node ends with newline+whitespace and is followed by an element,
-        if (/\n\s*$/.test(node.value) && nextNode && nextNode.type === 'JSXElement') {
-          const textWithoutTrailingNewline = node.value.replace(/\n\s*$/, '')
-          if (textWithoutTrailingNewline.trim()) {
-            // Check if the next element is a preserved tag
-            const nextTag = nextNode.opening?.name?.type === 'Identifier' ? nextNode.opening.name.value : undefined
-            const isPreservedTag = nextTag && allowedTags.has(nextTag)
-
-            // Check if the preserved tag has children (not self-closing)
-            const nextChildren = nextNode.children || []
-            const nextHasChildren = nextChildren.length > 0
-
-            // Check if there was a space BEFORE the newline in the source
-            const hasSpaceBeforeNewline = /\s\n/.test(node.value)
-
-            // Check if there's text content AFTER the next element
-            const nodeAfterNext = nodes[i + 2]
-            const hasTextAfter = nodeAfterNext &&
-              nodeAfterNext.type === 'JSXText' &&
-              !isFormattingWhitespace(nodeAfterNext) &&
-              /[a-zA-Z0-9]/.test(nodeAfterNext.value)
-
-            // Does the next element have attributes? (helps decide spacing for tags like <a href="...">)
-            const nextHasAttrs = !!(nextNode.opening && Array.isArray((nextNode.opening as any).attributes) && (nextNode.opening as any).attributes.length > 0)
-
-            // Preserve leading whitespace
-            // Only treat a real leading space (not a leading newline + indentation) as "leading space"
-            const hasLeadingSpace = /^\s/.test(textWithoutTrailingNewline) && !/^\n/.test(textWithoutTrailingNewline)
-
-            const trimmed = textWithoutTrailingNewline.trim()
-            const withLeading = hasLeadingSpace ? ' ' + trimmed : trimmed
-
-            // Add trailing space only if:
-            // 1. There was an explicit space before the newline, OR
-            // 2. The next element is NOT a preserved tag AND has text after (word boundary)
-            //    Preserved tags like <br />, <p>, etc. provide their own separation
-            // Require an explicit leading space for the "non-preserved + hasTextAfter" case
-            // Detect "word-split" case more strictly:
-            // - previous trimmed ends with alnum
-            // - the text after the element starts with alnum
-            // - there was no explicit space before the newline and no explicit leading space,
-            // - AND the text-after does NOT itself start with an explicit space.
-            const prevEndsWithAlnum = /[A-Za-z0-9]$/.test(trimmed)
-            const nextStartsWithAlnum = nodeAfterNext && typeof nodeAfterNext.value === 'string' && /^[A-Za-z0-9]/.test(nodeAfterNext.value.trim())
-            const nextStartsWithLowercase = nodeAfterNext && typeof nodeAfterNext.value === 'string' && /^[a-z]/.test(nodeAfterNext.value.trim())
-            // Treat newline-leading indentation as NOT an explicit leading space.
-            const nextHasLeadingSpace = nodeAfterNext && typeof nodeAfterNext.value === 'string' && /^\s/.test(nodeAfterNext.value) && !/^\n/.test(nodeAfterNext.value)
-
-            // Only treat as a word-split (no space) when the following word begins
-            // with a lowercase letter — this avoids removing spaces between separate
-            // capitalized / distinct words like "First <1>Second".
-            const shouldInsertForNextWithAttrs = nextHasAttrs && nextHasChildren && hasTextAfter && !(
-              prevEndsWithAlnum &&
-              nextStartsWithAlnum &&
-              nextStartsWithLowercase &&
-              !hasSpaceBeforeNewline &&
-              !hasLeadingSpace &&
-              !nextHasLeadingSpace
-            )
-            // If the text after the next element begins with punctuation, do not insert a space
-            const nextStartsWithPunctuation = nodeAfterNext && typeof nodeAfterNext.value === 'string' && /^[,;:!?.]/.test(nodeAfterNext.value.trim())
-            const shouldInsertForNextWithAttrsFinal = shouldInsertForNextWithAttrs && !nextStartsWithPunctuation
-
-            // Persist a "tight" decision so post-normalization can remove any artificial
-            // spaces that were introduced by whitespace collapsing/newline handling.
-            // This ensures cases like "word\n  <1>link</1>\n  word" become "word<1>link</1>word".
-            const isWordSplitStrict = prevEndsWithAlnum && nextStartsWithAlnum && nextStartsWithLowercase && !hasSpaceBeforeNewline && !hasLeadingSpace && !nextHasLeadingSpace
-            if (isWordSplitStrict) {
-              // mark the actual element node; map to numeric index later
-              tightNoSpaceNodes.add(nextNode)
-            }
-
-            if (
-              hasSpaceBeforeNewline ||
-              (isPreservedTag && nextHasChildren) ||
-              // non-preserved with text after must have an explicit leading space
-              (!isPreservedTag && hasTextAfter && hasLeadingSpace) ||
-              // next element with attrs: only when not a word-split (see above)
-              shouldInsertForNextWithAttrsFinal
-            ) {
-              out += withLeading + ' '
-            } else {
-              out += withLeading
-            }
-            continue
-          }
-        }
-
-        out += node.value
-        continue
-      }
-
-      if (node.type === 'JSXExpressionContainer') {
-        const expr = node.expression
-        if (!expr) continue
-
-        const textVal = getStringLiteralFromExpression(expr)
-        if (textVal !== undefined) {
-          out += textVal
-        } else if (expr.type === 'Identifier') {
-          out += `{{${expr.value}}}`
-        } else if (expr.type === 'ObjectExpression') {
-          const prop = expr.properties[0]
-          if (prop && prop.type === 'KeyValueProperty' && prop.key && prop.key.type === 'Identifier') {
-            out += `{{${prop.key.value}}}`
-          } else if (prop && prop.type === 'Identifier') {
-            out += `{{${prop.value}}}`
-          } else {
-            out += '{{value}}'
-          }
-        } else if (expr.type === 'MemberExpression' && expr.property && expr.property.type === 'Identifier') {
-          out += `{{${expr.property.value}}}`
-        } else if (expr.type === 'CallExpression' && expr.callee?.type === 'Identifier') {
-          out += `{{${expr.callee.value}}}`
-        } else {
-          out += '{{value}}'
-        }
-        continue
-      }
-
-      if (node.type === 'JSXElement') {
-        let tag: string | undefined
-        if (node.opening && node.opening.name && node.opening.name.type === 'Identifier') {
-          tag = node.opening.name.value
-        }
-
-        // Track root element index for root-level elements
-        const myRootIndex = isRootLevel ? rootElementIndex : undefined
-        if (isRootLevel && node.type === 'JSXElement') {
-          rootElementIndex++
-        }
-
-        if (tag && allowedTags.has(tag)) {
-          // Match react-i18next behavior: only preserve as literal HTML when:
-          // 1. No children (!childChildren) AND no attributes (!childPropsCount)
-          // 2. OR: Has children but only the children prop (childPropsCount === 1) AND children is a simple string (isString(childChildren))
-
-          const hasAttrs =
-            node.opening &&
-            Array.isArray((node.opening as any).attributes) &&
-            (node.opening as any).attributes.length > 0
-
-          const children = node.children || []
-          const hasChildren = children.length > 0
-
-          // Check if children is a single PURE text node (JSXText OR simple string expression)
-          const isSinglePureTextChild =
-            children.length === 1 && (
-              children[0]?.type === 'JSXText' ||
-              (children[0]?.type === 'JSXExpressionContainer' &&
-                getStringLiteralFromExpression(children[0].expression) !== undefined)
-            )
-
-          // Preserve as literal HTML in two cases:
-          // 1. No children and no attributes: <br />
-          // 2. Single pure text child (with or without attributes): <strong>text</strong> or <strong title="...">text</strong>
-          if ((!hasChildren || isSinglePureTextChild)) {
-            const inner = isSinglePureTextChild ? visitNodes(children, undefined) : ''
-            const hasMeaningfulChildren = String(inner).trim() !== ''
-
-            if (!hasMeaningfulChildren) {
-              // Self-closing
-              const prevOriginal = nodes[i - 1]
-              if (prevOriginal && prevOriginal.type === 'JSXText' && /\n\s*$/.test(prevOriginal.value)) {
-                out = out.replace(/\s+$/, '')
-              }
-              out += `<${tag} />`
-            } else {
-              // Preserve with content: <strong>text</strong>
-              // trim formatting-only edges inside preserved tags so surrounding
-              // newline/indentation doesn't leak into the preserved-inner text
-              out += `<${tag}>${trimFormattingEdges(inner)}</${tag}>`
-            }
-          } else if (hasAttrs && !isSinglePureTextChild) {
-            // Has attributes -> treat as indexed element with numeric placeholder
-            const childrenLocal = children
-            // determine this element's numeric index once for all branches
-            const idx = resolveIndex(node)
-            // Use precise detection so trailing text doesn't force global indexing
-            const hasNonElementGlobalSlots = hasNonElementGlobalSlotsAmongChildren(childrenLocal)
-
-            if (hasNonElementGlobalSlots) {
-              // Build a local index map for inner children so nested placeholders
-              // restart locally instead of using global indices.
-              const childrenLocalMap = new Map<any, number>()
-              // always restart local child indices at 1
-              let localIdxCounter = 1
-              for (const ch of childrenLocal) {
-                if (!ch) continue
-                if (ch.type === 'JSXElement') {
-                  const chTag = ch.opening && ch.opening.name && ch.opening.name.type === 'Identifier'
-                    ? ch.opening.name.value
-                    : undefined
-                  if (chTag && allowedTags.has(chTag)) {
-                    const chHasAttrs =
-                      ch.opening &&
-                      Array.isArray((ch.opening as any).attributes) &&
-                      (ch.opening as any).attributes.length > 0
-                    const chChildren = ch.children || []
-                    const chIsSinglePureText =
-                      chChildren.length === 1 && (
-                        chChildren[0]?.type === 'JSXText' ||
-                        (chChildren[0]?.type === 'JSXExpressionContainer' &&
-                          getStringLiteralFromExpression(chChildren[0].expression) !== undefined)
-                      )
-                    const chWillBePreserved = !chHasAttrs && (!chChildren.length || chIsSinglePureText)
-                    if (!chWillBePreserved) {
-                      childrenLocalMap.set(ch, localIdxCounter++)
-                    }
-                  } else {
-                    childrenLocalMap.set(ch, localIdxCounter++)
-                  }
-                }
-              }
-              const inner = visitNodes(childrenLocal, childrenLocalMap.size ? childrenLocalMap : undefined)
-              out += `<${idx}>${trimFormattingEdges(inner)}</${idx}>`
-            } else {
-              const childrenLocalMap = new Map<any, number>()
-              // Local child indexes always restart at 1 for the inner mapping.
-              let localIdxCounter = 1
-
-              for (const ch of children) {
-                if (!ch) continue
-                if (ch.type === 'JSXElement') {
-                  const chTag = ch.opening && ch.opening.name && ch.opening.name.type === 'Identifier'
-                    ? ch.opening.name.value
-                    : undefined
-                  if (chTag && allowedTags.has(chTag)) {
-                    // Check if this child will be preserved as literal HTML
-                    const chHasAttrs =
-                      ch.opening &&
-                      Array.isArray((ch.opening as any).attributes) &&
-                      (ch.opening as any).attributes.length > 0
-                    const chChildren = ch.children || []
-                    const chIsSinglePureText =
-                      chChildren.length === 1 && (
-                        chChildren[0]?.type === 'JSXText' ||
-                        (chChildren[0]?.type === 'JSXExpressionContainer' &&
-                          getStringLiteralFromExpression(chChildren[0].expression) !== undefined)
-                      )
-                    const chWillBePreserved = !chHasAttrs && (!chChildren.length || chIsSinglePureText)
-                    if (!chWillBePreserved) {
-                      // Will be indexed, add to local map
-                      childrenLocalMap.set(ch, localIdxCounter++)
-                    }
-                  } else {
-                    childrenLocalMap.set(ch, localIdxCounter++)
-                  }
-                }
-              }
-
-              const inner = visitNodes(children, childrenLocalMap.size ? childrenLocalMap : undefined)
-              out += `<${idx}>${trimFormattingEdges(inner)}</${idx}>`
-            }
-          } else {
-            // Has complex children but no attributes -> preserve tag as literal but index children
-            // Check if this tag is in globalSlots - if so, index it
-            const idx = globalSlots.indexOf(node)
-            if (idx !== -1) {
-              // This tag is in globalSlots, so index it
-              // At root level, use the element's position among root elements
-              const indexToUse = myRootIndex !== undefined ? myRootIndex : idx
-
-              // Check if children have text/expression nodes in globalSlots
-              // that appear BEFORE or BETWEEN element children (not just trailing)
-              // Exclude formatting whitespace (newline-only text) from this check
-              const hasNonElementGlobalSlots = (() => {
-                let foundElement = false
-
-                for (const ch of children) {
-                  if (!ch) continue
-
-                  if (ch.type === 'JSXElement') {
-                    foundElement = true
-                    continue
-                  }
-
-                  if (ch.type === 'JSXExpressionContainer' && globalSlots.indexOf(ch) !== -1) {
-                    // Only count if before/between elements, not trailing
-                    return foundElement  // false if before first element, true if after
-                  }
-
-                  if (ch.type === 'JSXText' && globalSlots.indexOf(ch) !== -1) {
-                    // Exclude formatting whitespace
-                    if (isFormattingWhitespace(ch)) continue
-
-                    // Only count text that appears BEFORE the first element
-                    // Trailing text after all elements should not force global indexing
-                    if (!foundElement) {
-                      // Text before first element - counts
-                      return true
-                    }
-                    // Text after an element - check if there are more elements after this text
-                    const remainingNodes = children.slice(children.indexOf(ch) + 1)
-                    const hasMoreElements = remainingNodes.some((n: any) => n && n.type === 'JSXElement')
-                    if (hasMoreElements) {
-                      // Text between elements - counts
-                      return true
-                    }
-                    // Trailing text after last element - doesn't count
-                  }
-                }
-
-                return false
-              })()
-
-              // If children have non-element global slots, use global indexes
-              // Otherwise use local indexes starting from parent's index + 1
-              if (hasNonElementGlobalSlots) {
-                // For non-root parents we compact child indexes locally.
-                // For root-level parents (index 0) preserve global indexes so tests
-                // that expect global numbering (1,3,5...) keep working.
-                if (indexToUse === 0) {
-                  const inner = visitNodes(children, undefined, false)
-                  out += `<${indexToUse}>${trimFormattingEdges(inner)}</${indexToUse}>`
-                  continue
-                }
-
-                // Build a local index map for the inner children so nested placeholders
-                // restart locally (avoids leaking global indices into the parent's inner string).
-                const childrenLocalMap = new Map<any, number>()
-                // local children numbering should start at 1
-                let localIdxCounter = 1
-                for (const ch of children) {
-                  if (!ch) continue
-                  if (ch.type === 'JSXElement') {
-                    const chTag = ch.opening && ch.opening.name && ch.opening.name.type === 'Identifier'
-                      ? ch.opening.name.value
-                      : undefined
-                    if (chTag && allowedTags.has(chTag)) {
-                      const chHasAttrs =
-                        ch.opening &&
-                        Array.isArray((ch.opening as any).attributes) &&
-                        (ch.opening as any).attributes.length > 0
-                      const chChildren = ch.children || []
-                      const chIsSinglePureText =
-                        chChildren.length === 1 && (
-                          chChildren[0]?.type === 'JSXText' ||
-                          (chChildren[0]?.type === 'JSXExpressionContainer' &&
-                            getStringLiteralFromExpression(chChildren[0].expression) !== undefined)
-                        )
-                      const chWillBePreserved = !chHasAttrs && (!chChildren.length || chIsSinglePureText)
-                      if (!chWillBePreserved) {
-                        childrenLocalMap.set(ch, localIdxCounter++)
-                      }
-                    } else {
-                      childrenLocalMap.set(ch, localIdxCounter++)
-                    }
-                  }
-                }
-
-                const inner = visitNodes(children, childrenLocalMap.size ? childrenLocalMap : undefined, false)
-                out += `<${indexToUse}>${trimFormattingEdges(inner)}</${indexToUse}>`
-                continue
-              }
-
-              // Build local index map for children of this indexed element
-              const childrenLocalMap = new Map<any, number>()
-              // Local child indexes restart at 1 inside this element (do not start from parent index)
-              let localIdxCounter = 1
-              for (const ch of children) {
-                if (!ch) continue
-                if (ch.type === 'JSXElement') {
-                  const chTag = ch.opening && ch.opening.name && ch.opening.name.type === 'Identifier'
-                    ? ch.opening.name.value
-                    : undefined
-
-                  if (chTag && allowedTags.has(chTag)) {
-                    // Check if this child will be preserved as literal HTML
-                    const chHasAttrs =
-                      ch.opening &&
-                      Array.isArray((ch.opening as any).attributes) &&
-                      (ch.opening as any).attributes.length > 0
-                    const chChildren = ch.children || []
-                    const chIsSinglePureText =
-                      chChildren.length === 1 && (
-                        chChildren[0]?.type === 'JSXText' ||
-                        (chChildren[0]?.type === 'JSXExpressionContainer' &&
-                          getStringLiteralFromExpression(chChildren[0].expression) !== undefined)
-                      )
-                    const chWillBePreserved = !chHasAttrs && (!chChildren.length || chIsSinglePureText)
-                    if (!chWillBePreserved) {
-                      // Will be indexed, add to local map
-                      childrenLocalMap.set(ch, localIdxCounter++)
-                    }
-                  } else {
-                    // Non-preserved tag, always indexed
-                    childrenLocalMap.set(ch, localIdxCounter++)
-                  }
-                }
-              }
-              const inner = visitNodes(children, childrenLocalMap.size > 0 ? childrenLocalMap : undefined, false)
-              out += `<${indexToUse}>${trimFormattingEdges(inner)}</${indexToUse}>`
-            } else {
-              // Not in globalSlots, preserve as literal HTML
-              const inner = visitNodes(children, undefined, false)
-              out += `<${tag}>${trimFormattingEdges(inner)}</${tag}>`
-            }
-          }
-        } else {
-          // Decide whether to use local (restarted) indexes for this element's
-          // immediate children or fall back to the global pre-order indexes.
-          // If the element's children contain non-element slots (JSXText /
-          // JSXExpressionContainer) that were collected as global slots, we must
-          // use the global indexes so those text slots keep their positions.
-          const children = node.children || []
-          const hasNonElementGlobalSlots = children.some((ch: any) =>
-            ch && (ch.type === 'JSXText' || ch.type === 'JSXExpressionContainer') && globalSlots.indexOf(ch) !== -1
-          )
-
-          // If there are non-element global slots among the children, render using
-          // global indexes. Otherwise build a compact local index map so nested
-          // placeholders restart at 0 inside this parent element.
-          if (hasNonElementGlobalSlots) {
-            const idx = globalSlots.indexOf(node)
-            const inner = visitNodes(children, undefined)
-            out += `<${idx}>${trimFormattingEdges(inner)}</${idx}>`
-          } else {
-            const childrenLocalMap = new Map<any, number>()
-            const idx = resolveIndex(node)
-            // Local child indexes: restart at 0 when parent idx === 0, otherwise at 1
-            let localIdxCounter = 1
-
-            for (const ch of children) {
-              if (!ch) continue
-              if (ch.type === 'JSXElement') {
-                const chTag = ch.opening && ch.opening.name && ch.opening.name.type === 'Identifier'
-                  ? ch.opening.name.value
-                  : undefined
-                if (chTag && allowedTags.has(chTag)) {
-                  // Check if this child will be preserved as literal HTML
-                  const chHasAttrs =
-                    ch.opening &&
-                    Array.isArray((ch.opening as any).attributes) &&
-                    (ch.opening as any).attributes.length > 0
-                  const chChildren = ch.children || []
-                  const chIsSinglePureText = chChildren.length === 1 && chChildren[0]?.type === 'JSXText'
-                  const chWillBePreserved = !chHasAttrs && (!chChildren.length || chIsSinglePureText)
-                  if (!chWillBePreserved) {
-                    // Will be indexed, add to local map
-                    childrenLocalMap.set(ch, localIdxCounter++)
-                  }
-                } else {
-                  childrenLocalMap.set(ch, localIdxCounter++)
-                }
-              }
-            }
-
-            const inner = visitNodes(children, childrenLocalMap.size ? childrenLocalMap : undefined)
-            out += `<${idx}>${trimFormattingEdges(inner)}</${idx}>`
-          }
-        }
-        continue
-      }
-
-      if (node.type === 'JSXFragment') {
-        out += visitNodes(node.children || [])
-        continue
-      }
-
-      // unknown node types: ignore
-    }
-
-    return out
-  }
-
-  const result = visitNodes(children, undefined, true)
-
-  // console.log('[serializeJSXChildren] result before cleanup:', JSON.stringify(result))
-  // console.log('[serializeJSXChildren] tightNoSpaceNodes:', Array.from(tightNoSpaceNodes || []))
-  // console.log('[serializeJSXChildren] globalSlots:', JSON.stringify(globalSlots, null, 2))
-  // const slotContexts = globalSlots.map((s, idx) => {
-  //   const prev = globalSlots[idx - 1]
-  //   const next = globalSlots[idx + 1]
-  //   return {
-  //     idx,
-  //     type: s ? s.type : null,
-  //     tag: s && s.type === 'JSXElement' ? s.opening?.name?.value : undefined,
-  //     preview: s && s.type === 'JSXText' ? String(s.value).slice(0, 40) : undefined,
-  //     prevType: prev ? prev.type : null,
-  //     prevPreview: prev && prev.type === 'JSXText' ? String(prev.value).slice(0, 40) : undefined,
-  //     nextType: next ? next.type : null,
-  //     nextPreview: next && next.type === 'JSXText' ? String(next.value).slice(0, 40) : undefined
-  //   }
-  // })
-  // console.log('[serializeJSXChildren] slotContexts:', JSON.stringify(slotContexts, null, 2))
-
-  // Final cleanup in correct order:
-  // 1. First, handle <br /> followed by whitespace+newline (boundary formatting)
-  const afterBrCleanup = String(result).replace(/<br \/>\s*\n\s*/g, '<br />')
-
-  const raw = String(afterBrCleanup)
-
-  const tightNoSpaceIndices = new Set<number>()
-
-  // Map node-based tight markers into numeric global-slot indices (used by later regex passes).
-  if (tightNoSpaceNodes && tightNoSpaceNodes.size > 0) {
-    for (let i = 0; i < globalSlots.length; i++) {
-      if (tightNoSpaceNodes.has(globalSlots[i])) tightNoSpaceIndices.add(i)
-    }
-  }
-
-  // 1) Remove spaces around explicitly-marked tight indices (word-splits)
-  let tmp = String(raw)
-  if (tightNoSpaceIndices && tightNoSpaceIndices.size > 0) {
-    for (const id of tightNoSpaceIndices) {
-      try {
-        tmp = tmp.replace(new RegExp('\\s+<' + id + '>', 'g'), '<' + id + '>')
-        tmp = tmp.replace(new RegExp('<\\/' + id + '>\\s+', 'g'), '</' + id + '>')
-      } catch (e) { /* ignore */ }
-    }
-  }
-
-  // 2) For non-tight placeholders, if there was a newline boundary between
-  //    a closing tag and following text OR between preceding text and an
-  //    opening tag, ensure a single separating space. This recovers spaces
-  //    that are semantically meaningful when the source had newline
-  //    boundaries but not a word-split.
-  tmp = tmp.replace(/<\/(\d+)>\s*\n\s*(\S)/g, (m, idx, after) => {
-    const id = Number(idx)
-    return tightNoSpaceIndices.has(id) ? `</${idx}>${after}` : `</${idx}> ${after}`
-  })
-  tmp = tmp.replace(/(\S)\s*\n\s*<(\d+)/g, (m, before, idx) => {
-    const id = Number(idx)
-    return tightNoSpaceIndices.has(id) ? `${before}<${idx}` : `${before} <${idx}`
-  })
-
-  // 3) Collapse remaining newlines/indentation and whitespace to single spaces,
-  //    remove space before period and trim.
-  tmp = tmp.replace(/\s*\n\s*/g, ' ')
-  tmp = tmp.replace(/\s+/g, ' ')
-  // remove spaces before common punctuation (comma, semicolon, colon, question, exclamation, period)
-  tmp = tmp.replace(/\s+([,;:!?.])/g, '$1')
-  const finalResult = tmp.trim()
-
-  // Final guaranteed cleanup for tight (word-split) placeholders:
-  // remove any spaces (including NBSP) left before opening or after closing numeric placeholders
-  // to ensure "word <1>link</1>word" -> "word<1>link</1>word" when marked tight.
-  let postFinal = String(finalResult)
-  if (tightNoSpaceIndices && tightNoSpaceIndices.size > 0) {
-    for (const id of tightNoSpaceIndices) {
-      try {
-        // remove ordinary whitespace and non-breaking space variants
-        postFinal = postFinal.replace(new RegExp('[\\s\\u00A0]+<' + id + '>', 'g'), '<' + id + '>')
-        postFinal = postFinal.replace(new RegExp('<\\/' + id + '>[\\s\\u00A0]+', 'g'), '</' + id + '>')
-      } catch (e) { /* ignore */ }
-    }
-  }
-
-  // Additional deterministic pass:
-  // If globalSlots show an element whose previous slot is JSXText ending with alnum
-  // and next slot is JSXText starting with alnum, and the original previous text did
-  // not have an explicit space-before-newline nor the next text a leading space,
-  // remove any single space left before the opening placeholder in the final string.
-  try {
-    for (let idx = 0; idx < globalSlots.length; idx++) {
-      const s = globalSlots[idx]
-      if (!s || s.type !== 'JSXElement') continue
-      const prev = globalSlots[idx - 1]
-      const next = globalSlots[idx + 1]
-      if (!prev || !next) continue
-      if (prev.type !== 'JSXText' || next.type !== 'JSXText') continue
-
-      const prevRaw = String(prev.value)
-      const nextRaw = String(next.value)
-      const prevTrimmed = prevRaw.replace(/\n\s*$/, '')
-      const prevEndsAlnum = /[A-Za-z0-9]$/.test(prevTrimmed)
-      const nextStartsAlnum = /^[A-Za-z0-9]/.test(nextRaw.trim())
-      const nextStartsLowercase = /^[a-z]/.test(nextRaw.trim())
-      const hasSpaceBeforeNewline = /\s\n/.test(prevRaw)
-      // Treat newline-leading indentation as NOT an explicit leading space.
-      const nextHasLeadingSpace = nextRaw && /^\s/.test(nextRaw) && !/^\n/.test(nextRaw)
-
-      // Only collapse the space for true word-splits where the next token starts lowercase.
-      if (prevEndsAlnum && nextStartsAlnum && nextStartsLowercase && !hasSpaceBeforeNewline && !nextHasLeadingSpace) {
-        const id = idx
-        postFinal = postFinal.replace(new RegExp('\\s+<' + id + '>', 'g'), '<' + id + '>')
-      }
-    }
-  } catch (e) { /* ignore */ }
-
-  // Remap numeric placeholders to compact local indices inside each parent placeholder.
-  // This fixes cases where global pre-order indices leak into a parent's inner string
-  // (e.g. "<4>...<6>...</6></4>") — we want the inner child placeholders to restart
-  // locally (1,2...) when appropriate.
-  function remapNumericPlaceholders (input: string) {
-    if (!input || !input.includes('<')) return input
-
-    type Node = { type: 'text'; text: string } | { type: 'ph'; idx: number; children: Node[] }
-
-    // Parse into a simple tree of numeric-placeholder nodes and text nodes.
-    function parse (s: string): Node[] {
-      const nodes: Node[] = []
-      const stack: { node: Node; idx: number }[] = []
-      let lastIndex = 0
-      const re = /<\/?(\d+)>|<[^>]+>/g
-      let m: RegExpExecArray | null
-      while ((m = re.exec(s))) {
-        const match = m[0]
-        const matchIndex = m.index
-        if (matchIndex > lastIndex) {
-          const text = s.slice(lastIndex, matchIndex)
-          const textNode: Node = { type: 'text', text }
-          if (stack.length) (stack[stack.length - 1].node as any).children.push(textNode)
-          else nodes.push(textNode)
-        }
-
-        const closingNumeric = /^<\/(\d+)>$/.exec(match)
-        const openingNumeric = /^<(\d+)>$/.exec(match)
-
-        if (openingNumeric) {
-          const idx = Number(openingNumeric[1])
-          const ph: Node = { type: 'ph', idx, children: [] }
-          if (stack.length) (stack[stack.length - 1].node as any).children.push(ph)
-          else nodes.push(ph)
-          stack.push({ node: ph, idx })
-        } else if (closingNumeric) {
-          // pop matching numeric placeholder; if mismatch, just pop last
-          if (stack.length) {
-            stack.pop()
-          }
-        } else {
-          // non-numeric tag (preserved HTML like <br /> or <strong>) -> treat as text
-          const textNode: Node = { type: 'text', text: match }
-          if (stack.length) (stack[stack.length - 1].node as any).children.push(textNode)
-          else nodes.push(textNode)
-        }
-
-        lastIndex = re.lastIndex
-      }
-      if (lastIndex < s.length) {
-        const text = s.slice(lastIndex)
-        const textNode: Node = { type: 'text', text }
-        if (stack.length) (stack[stack.length - 1].node as any).children.push(textNode)
-        else nodes.push(textNode)
-      }
-      return nodes
-    }
-
-    // Reconstruct string with remapped local indices.
-    function build (nodes: Node[], parentIdx: number | null = null): string {
-      let out = ''
-      for (const n of nodes) {
-        if (n.type === 'text') {
-          out += n.text
-        } else {
-          // Map direct child placeholder indices to local sequence
-          const childPhs = (n as any).children.filter((c: any) => c.type === 'ph') as { type: 'ph'; idx: number; children: Node[] }[]
-          // If the child's original global indices are NOT contiguous (i.e. gaps),
-          // do not remap — emit original numbers to preserve tests that expect
-          // global pre-order indices like 1,3,5.
-          const origIndices = childPhs.map(c => c.idx)
-          const isContiguous = origIndices.length <= 1 || origIndices.every((v, i) => i === 0 || v === origIndices[i - 1] + 1)
-          // Do not remap when original child indices are non-contiguous.
-          if (!isContiguous) {
-            const innerNoRemap = (n as any).children.map((child: any) => {
-              if (child.type === 'text') return child.text
-              return `<${child.idx}>${build(child.children, child.idx)}</${child.idx}>`
-            }).join('')
-            out += `<${n.idx}>${innerNoRemap}</${n.idx}>`
-            continue
-          }
-          const map = new Map<number, number>()
-          // Determine start index: if this parent AST node contains N non-element global slots
-          // inside its span, then the first indexed child should be (N + 1). This mirrors
-          // how local indexing must account for explicit expression/text slots that appear
-          // before an element child inside the same parent.
-          let start = (n.idx === 0) ? 0 : 1
-          try {
-            const parentAst = globalSlots[n.idx]
-            if (parentAst && parentAst.span) {
-              const parentStart = parentAst.span.start
-              const parentEnd = parentAst.span.end
-              // Find the first element child (by globalSlots index) that lies inside this parent.
-              let firstElementGIdx = -1
-              for (let gIdx = n.idx + 1; gIdx < globalSlots.length; gIdx++) {
-                const s = globalSlots[gIdx]
-                if (!s || !s.span) continue
-                if (s.span.start >= parentStart && s.span.end <= parentEnd && s.type === 'JSXElement') {
-                  firstElementGIdx = gIdx
-                  break
-                }
-              }
-
-              // Count only non-element global slots that appear before the first element child
-              // (these shift the local numbering of element children).
-              let nonElementBefore = 0
-              if (firstElementGIdx !== -1) {
-                for (let gIdx = n.idx + 1; gIdx < firstElementGIdx; gIdx++) {
-                  const s = globalSlots[gIdx]
-                  if (!s || !s.span) continue
-                  if (s.span.start >= parentStart && s.span.end <= parentEnd) {
-                    if (s.type === 'JSXText' || s.type === 'JSXExpressionContainer') nonElementBefore++
-                  }
-                }
-              } else {
-                // No element child found: count non-element slots inside parent (fallback)
-                for (let gIdx = n.idx + 1; gIdx < globalSlots.length; gIdx++) {
-                  const s = globalSlots[gIdx]
-                  if (!s || !s.span) continue
-                  if (s.span.start >= parentStart && s.span.end <= parentEnd) {
-                    if (s.type === 'JSXText' || s.type === 'JSXExpressionContainer') nonElementBefore++
-                  }
-                }
-              }
-
-              if (typeof n.idx === 'number') {
-                start = n.idx === 0 ? 0 : Math.max(1, nonElementBefore + 1)
-              }
-            }
-          } catch (e) { /* ignore and fall back to default start */ }
-          // assign new numbers in order of appearance among direct children
-          for (const c of childPhs) {
-            if (!map.has(c.idx)) {
-              map.set(c.idx, start++)
-            }
-          }
-
-          // recursively build children, but when emitting child ph tags replace indices
-          const inner = (n as any).children.map((child: any) => {
-            if (child.type === 'text') return child.text
-            const orig = child.idx
-            const newIdx = map.has(orig) ? map.get(orig)! : orig
-            return `<${newIdx}>${build(child.children, newIdx)}</${newIdx}>`
-          }).join('')
-
-          out += `<${n.idx}>${inner}</${n.idx}>`
-        }
-      }
-      return out
-    }
-
-    try {
-      const parsed = parse(input)
-      return build(parsed)
-    } catch (e) {
-      return input
-    }
-  }
-
-  postFinal = remapNumericPlaceholders(postFinal)
-
-  return postFinal.trim()
-}