@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/src/io/ooxml/parse-fields.ts

@@ -1,834 +0,0 @@
-/**
- * parse-fields.ts
- *
- * Standalone parsers for OOXML field codes (w:fldSimple, complex fldChar sequences)
- * and bookmarks (w:bookmarkStart / w:bookmarkEnd).
- *
- * These types mirror the canonical FieldNode / BookmarkStartNode / BookmarkEndNode
- * shapes from canonical-document.ts, but carry raw XML for preservation and are
- * pre-normalization (no fragmentId / warningId yet).
- *
- * Usage: call parseFieldsFromParagraphXml() or parseBookmarksFromXml() for
- * independent field/bookmark extraction.  The functions are designed to be
- * imported by parse-main-document.ts when full pipeline integration is ready.
- */
-
-// ─── Parsed types ────────────────────────────────────────────────────────────
-
-export interface ParsedSimpleFieldNode {
-  type: "field";
-  fieldType: "simple";
-  instruction: string;
-  /** Raw XML of the content runs inside <w:fldSimple>. */
-  contentXml: string;
-  rawXml: string;
-}
-
-export interface ParsedComplexFieldNode {
-  type: "field";
-  fieldType: "complex";
-  instruction: string;
-  /** Raw XML of the content runs between the "separate" and "end" fldChar. */
-  contentXml: string;
-  /** Start index in the source document XML. */
-  start: number;
-  /** End index (exclusive) in the source document XML. */
-  end: number;
-}
-
-export type ParsedFieldNode = ParsedSimpleFieldNode | ParsedComplexFieldNode;
-
-export interface ParsedBookmarkStartNode {
-  type: "bookmark_start";
-  bookmarkId: string;
-  name: string;
-  rawXml: string;
-}
-
-export interface ParsedBookmarkEndNode {
-  type: "bookmark_end";
-  bookmarkId: string;
-  rawXml: string;
-}
-
-export type ParsedBookmarkNode = ParsedBookmarkStartNode | ParsedBookmarkEndNode;
-
-// ─── Internal XML types ───────────────────────────────────────────────────────
-
-interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-  start: number;
-  end: number;
-}
-
-interface XmlTextNode {
-  type: "text";
-  text: string;
-  start: number;
-  end: number;
-}
-
-type XmlNode = XmlElementNode | XmlTextNode;
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-/**
- * Parse all simple fields and bookmarks from the XML of a single paragraph
- * element.  Complex fields that span paragraphs are not fully resolved here;
- * use extractComplexFieldsFromBodyXml for body-level extraction.
- *
- * @param paragraphXml  Raw XML string of a <w:p> element.
- */
-export function parseFieldsFromParagraphXml(paragraphXml: string): {
-  simpleFields: ParsedSimpleFieldNode[];
-  bookmarks: ParsedBookmarkNode[];
-} {
-  const root = parseXml(paragraphXml);
-  const pEl = findFirstChild(root, "p");
-  const target = pEl ?? root;
-
-  const simpleFields: ParsedSimpleFieldNode[] = [];
-  const bookmarks: ParsedBookmarkNode[] = [];
-
-  for (const child of target.children) {
-    if (child.type !== "element") continue;
-    const name = localName(child.name);
-
-    if (name === "fldSimple") {
-      const field = parseFldSimple(child, paragraphXml);
-      if (field) simpleFields.push(field);
-    } else if (name === "bookmarkStart") {
-      const bk = parseBookmarkStart(child, paragraphXml);
-      if (bk) bookmarks.push(bk);
-    } else if (name === "bookmarkEnd") {
-      const bk = parseBookmarkEnd(child, paragraphXml);
-      if (bk) bookmarks.push(bk);
-    }
-  }
-
-  return { simpleFields, bookmarks };
-}
-
-/**
- * Extract complex field sequences from a body element XML string.
- * A complex field is a begin / instrText* / separate / content / end sequence
- * spread across multiple <w:r> siblings.
- *
- * @param bodyXml  Raw XML string of a <w:body> element (or full document).
- */
-export function extractComplexFieldsFromBodyXml(bodyXml: string): ParsedComplexFieldNode[] {
-  const root = parseXml(bodyXml);
-  const results: ParsedComplexFieldNode[] = [];
-
-  // Walk all <w:p> children of the body
-  const bodyEl = findFirstChild(root, "body") ?? findFirstChild(root, "document");
-  const scanTarget = bodyEl ?? root;
-
-  for (const block of scanTarget.children) {
-    if (block.type !== "element") continue;
-    if (localName(block.name) !== "p") continue;
-    extractComplexFieldsFromParagraph(block, bodyXml, results);
-  }
-
-  return results;
-}
-
-/**
- * Parse all bookmark start/end nodes from a full document or body XML.
- */
-export function extractBookmarksFromBodyXml(bodyXml: string): ParsedBookmarkNode[] {
-  const root = parseXml(bodyXml);
-  const results: ParsedBookmarkNode[] = [];
-  collectBookmarks(root, bodyXml, results);
-  return results;
-}
-
-// ─── Element-level parsers (exported for unit testing) ────────────────────────
-
-export function parseFldSimple(
-  element: { attributes: Record<string, string>; children: XmlNode[]; start: number; end: number },
-  sourceXml: string,
-): ParsedSimpleFieldNode | undefined {
-  const instruction = (element.attributes["w:instr"] ?? element.attributes.instr ?? "").trim();
-  const contentXml = element.children
-    .filter((c): c is XmlElementNode => c.type === "element")
-    .map((c) => sourceXml.slice(c.start, c.end))
-    .join("");
-  return {
-    type: "field",
-    fieldType: "simple",
-    instruction,
-    contentXml,
-    rawXml: sourceXml.slice(element.start, element.end),
-  };
-}
-
-export function parseBookmarkStart(
-  element: { attributes: Record<string, string>; start: number; end: number },
-  sourceXml: string,
-): ParsedBookmarkStartNode | undefined {
-  const bookmarkId = element.attributes["w:id"] ?? element.attributes.id ?? "";
-  const name = element.attributes["w:name"] ?? element.attributes.name ?? "";
-  if (!bookmarkId) return undefined;
-  return {
-    type: "bookmark_start",
-    bookmarkId,
-    name,
-    rawXml: sourceXml.slice(element.start, element.end),
-  };
-}
-
-export function parseBookmarkEnd(
-  element: { attributes: Record<string, string>; start: number; end: number },
-  sourceXml: string,
-): ParsedBookmarkEndNode | undefined {
-  const bookmarkId = element.attributes["w:id"] ?? element.attributes.id ?? "";
-  if (!bookmarkId) return undefined;
-  return {
-    type: "bookmark_end",
-    bookmarkId,
-    rawXml: sourceXml.slice(element.start, element.end),
-  };
-}
-
-// ─── Field family classification ─────────────────────────────────────────────
-
-import type {
-  CanonicalDocument,
-  DocumentNode,
-  FieldFamily,
-  FieldNode,
-  FieldRegistry,
-  FieldRegistryEntry,
-  FieldRefreshStatus,
-  InlineNode,
-  ParagraphNode,
-  SubPartsCatalog,
-  SupportedFieldFamily,
-  TocEntry,
-  TocStructure,
-} from "../../model/canonical-document.ts";
-
-const FIELD_FAMILY_PATTERN =
-  /^\s*(REF|PAGEREF|NOTEREF|TOC|PAGE|NUMPAGES|DATE|TIME|AUTHOR|FILENAME|MERGEFIELD|IF|SEQ|INDEX|TC|STYLEREF)\b/i;
-
-const SUPPORTED_FAMILIES = new Set<string>(["REF", "PAGEREF", "NOTEREF", "TOC"]);
-
-/**
- * Classify a field instruction into its field family.
- * Returns the family enum value and whether it is in the supported slice.
- */
-export function classifyFieldInstruction(instruction: string): {
-  family: FieldFamily;
-  supported: boolean;
-  target?: string;
-} {
-  const trimmed = instruction.trim();
-  const match = FIELD_FAMILY_PATTERN.exec(trimmed);
-  if (!match) {
-    return { family: "UNKNOWN", supported: false };
-  }
-
-  const family = match[1].toUpperCase() as FieldFamily;
-  const supported = SUPPORTED_FAMILIES.has(family);
-
-  let target: string | undefined;
-  if (family === "REF" || family === "PAGEREF" || family === "NOTEREF") {
-    const targetMatch = /^\s*(?:REF|PAGEREF|NOTEREF)\s+(?:"([^"]+)"|(\S+))/i.exec(trimmed);
-    target = (targetMatch?.[1] ?? targetMatch?.[2])?.trim();
-  }
-
-  return { family, supported, target };
-}
-
-/**
- * Returns true if the given field family is in the supported refresh slice.
- */
-export function isSupportedFieldFamily(family: FieldFamily): family is SupportedFieldFamily {
-  return SUPPORTED_FAMILIES.has(family);
-}
-
-// ─── Field registry builder ─────────────────────────────────────────────────
-
-/**
- * Build a field registry from a canonical document, cataloging every field
- * instance with its classification, dependency metadata, and refresh status.
- *
- * The registry partitions fields into `supported` (REF, PAGEREF, NOTEREF, TOC)
- * and `preserveOnly` (all others) slices.
- */
-export function buildFieldRegistry(
-  document: Pick<CanonicalDocument, "content" | "styles"> & {
-    subParts?: SubPartsCatalog;
-  },
-): FieldRegistry {
-  const root = document.content;
-  const supported: FieldRegistryEntry[] = [];
-  const preserveOnly: FieldRegistryEntry[] = [];
-  let fieldIndex = 0;
-  let paragraphIndex = -1;
-  let tocInstruction: string | undefined;
-
-  walkFieldDocument(root, (node, pIdx) => {
-    paragraphIndex = pIdx;
-    if (node.type === "field") {
-      const classification = node.fieldFamily
-        ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget }
-        : classifyFieldInstruction(node.instruction);
-      const displayText = flattenFieldText(node.children);
-      const entry: FieldRegistryEntry = {
-        fieldIndex,
-        fieldFamily: classification.family,
-        supported: classification.supported,
-        instruction: node.instruction,
-        ...(classification.target ? { fieldTarget: classification.target } : {}),
-        displayText,
-        paragraphIndex,
-        refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
-      };
-      if (classification.supported) {
-        supported.push(entry);
-        if (classification.family === "TOC" && !tocInstruction) {
-          tocInstruction = node.instruction;
-        }
-      } else {
-        preserveOnly.push(entry);
-      }
-      fieldIndex += 1;
-    }
-  });
-  if (document.subParts) {
-    walkSubPartFields(document.subParts, (node, pIdx) => {
-      paragraphIndex = pIdx;
-      if (node.type === "field") {
-        const classification = node.fieldFamily
-          ? { family: node.fieldFamily, supported: isSupportedFieldFamily(node.fieldFamily), target: node.fieldTarget }
-          : classifyFieldInstruction(node.instruction);
-        const displayText = flattenFieldText(node.children);
-        const entry: FieldRegistryEntry = {
-          fieldIndex,
-          fieldFamily: classification.family,
-          supported: classification.supported,
-          instruction: node.instruction,
-          ...(classification.target ? { fieldTarget: classification.target } : {}),
-          displayText,
-          paragraphIndex,
-          refreshStatus: node.refreshStatus ?? (classification.supported ? "stale" : "preserve-only"),
-        };
-        if (classification.supported) {
-          supported.push(entry);
-        } else {
-          preserveOnly.push(entry);
-        }
-        fieldIndex += 1;
-      }
-    });
-  }
-
-  const tocStructure = tocInstruction
-    ? buildTocStructure(document, tocInstruction)
-    : undefined;
-
-  return {
-    supported,
-    preserveOnly,
-    ...(tocStructure ? { tocStructure } : {}),
-  };
-}
-
-/**
- * Parse the heading level range from a TOC field instruction.
- * The \\o switch specifies the outline level range (e.g. \\o "1-3").
- * Defaults to 1-9 if no \\o switch is present.
- */
-export function parseTocLevelRange(instruction: string): { from: number; to: number } {
-  const match = /\\o\s+"(\d+)-(\d+)"/.exec(instruction);
-  if (match) {
-    return { from: Number.parseInt(match[1], 10), to: Number.parseInt(match[2], 10) };
-  }
-  return { from: 1, to: 9 };
-}
-
-/**
- * Build a TocStructure from the document's heading paragraphs and the
- * TOC field instruction.  This produces a deterministic, package-backed
- * TOC model that the runtime can use for refresh without DOM recomputation.
- */
-export function buildTocStructure(
-  document: Pick<CanonicalDocument, "content" | "styles">,
-  instruction: string,
-): TocStructure {
-  const levelRange = parseTocLevelRange(instruction);
-  const entries: TocEntry[] = [];
-  let paragraphIndex = -1;
-
-  walkFieldDocument(document.content, (node, pIdx) => {
-    paragraphIndex = pIdx;
-    if (node.type !== "paragraph") return;
-    const paragraph = node as ParagraphNode;
-
-    // Determine heading level from outlineLevel or style
-    let level: number | undefined = paragraph.outlineLevel;
-    if (level === undefined && paragraph.styleId) {
-      const style = document.styles.paragraphs[paragraph.styleId];
-      if (style?.outlineLevel !== undefined) {
-        level = style.outlineLevel;
-      }
-    }
-
-    if (level === undefined) return;
-    // TOC outline levels are 0-based internally, 1-based in TOC notation
-    const tocLevel = level + 1;
-    if (tocLevel < levelRange.from || tocLevel > levelRange.to) return;
-
-    const text = flattenParagraphInlineText(paragraph.children);
-    if (text.trim().length === 0) return;
-
-    // Find bookmark anchoring this heading
-    let bookmarkName: string | undefined;
-    for (const child of paragraph.children) {
-      if (child.type === "bookmark_start" && child.name) {
-        bookmarkName = child.name;
-        break;
-      }
-    }
-
-    entries.push({
-      text: text.trim(),
-      level: tocLevel,
-      paragraphIndex,
-      ...(paragraph.styleId ? { styleId: paragraph.styleId } : {}),
-      ...(bookmarkName ? { bookmarkName } : {}),
-    });
-  });
-
-  return {
-    instruction,
-    levelRange,
-    entries,
-    status: "stale",
-  };
-}
-
-/**
- * Deterministic refresh helper for REF fields.
- * Given a bookmark name map and the document content, resolves the display
- * text for a REF field by extracting text from the bookmarked paragraph.
- *
- * Returns the resolved text, or undefined if the bookmark is not found.
- */
-export function resolveRefFieldText(
-  document: Pick<CanonicalDocument, "content">,
-  bookmarkNameMap: Map<string, { bookmarkId: string; paragraphIndex: number }>,
-  fieldTarget: string,
-): { text: string; refreshStatus: "current" | "unresolvable" } | undefined {
-  const bookmark = bookmarkNameMap.get(fieldTarget);
-  if (!bookmark) {
-    return { text: "", refreshStatus: "unresolvable" };
-  }
-
-  // Find the paragraph at bookmarkIndex and extract its text content
-  let paragraphIndex = -1;
-  let resolvedText: string | undefined;
-
-  walkFieldDocument(document.content, (node, pIdx) => {
-    if (node.type !== "paragraph") return;
-    paragraphIndex = pIdx;
-    if (paragraphIndex === bookmark.paragraphIndex) {
-      resolvedText = flattenBookmarkContent(node as ParagraphNode, bookmark.bookmarkId);
-    }
-  });
-
-  if (resolvedText !== undefined) {
-    return { text: resolvedText, refreshStatus: "current" };
-  }
-  return { text: "", refreshStatus: "unresolvable" };
-}
-
-/**
- * Deterministic refresh helper that updates all supported field entries
- * in a registry with their current resolved status.
- *
- * This does NOT mutate the document nodes — it returns a new registry
- * with updated refresh statuses.  A3 owns the runtime wiring that
- * applies these to the live document.
- */
-export function refreshFieldRegistry(
-  registry: FieldRegistry,
-  bookmarkNameMap: Map<string, { bookmarkId: string; paragraphIndex: number }>,
-): FieldRegistry {
-  const refreshed: FieldRegistryEntry[] = registry.supported.map((entry) => {
-    if (entry.fieldFamily === "TOC") {
-      // TOC refresh is handled through tocStructure, not individual entries
-      return { ...entry, refreshStatus: registry.tocStructure ? "current" : "stale" as FieldRefreshStatus };
-    }
-    if (!entry.fieldTarget) {
-      return { ...entry, refreshStatus: "unresolvable" as FieldRefreshStatus };
-    }
-    const bookmark = bookmarkNameMap.get(entry.fieldTarget);
-    if (!bookmark) {
-      return { ...entry, refreshStatus: "unresolvable" as FieldRefreshStatus };
-    }
-    return { ...entry, refreshStatus: "current" as FieldRefreshStatus };
-  });
-
-  return {
-    supported: refreshed,
-    preserveOnly: registry.preserveOnly,
-    ...(registry.tocStructure ? { tocStructure: registry.tocStructure } : {}),
-  };
-}
-
-// ─── Field registry internal helpers ────────────────────────────────────────
-
-function walkFieldDocument(
-  node: DocumentNode,
-  visit: (node: DocumentNode, paragraphIndex: number) => void,
-  paragraphIndex = -1,
-): number {
-  if (node.type === "paragraph") {
-    paragraphIndex += 1;
-  }
-  visit(node, paragraphIndex);
-
-  if ("children" in node && Array.isArray(node.children)) {
-    for (const child of node.children) {
-      paragraphIndex = walkFieldDocument(child as DocumentNode, visit, paragraphIndex);
-    }
-  }
-  if (node.type === "table") {
-    for (const row of node.rows) {
-      paragraphIndex = walkFieldDocument(row, visit, paragraphIndex);
-    }
-  } else if (node.type === "table_row") {
-    for (const cell of node.cells) {
-      paragraphIndex = walkFieldDocument(cell, visit, paragraphIndex);
-    }
-  }
-  return paragraphIndex;
-}
-
-function walkSubPartFields(
-  subParts: SubPartsCatalog,
-  visit: (node: DocumentNode, paragraphIndex: number) => void,
-): void {
-  for (const header of subParts.headers) {
-    for (const block of header.blocks) {
-      walkFieldDocument(block, visit);
-    }
-  }
-  for (const footer of subParts.footers) {
-    for (const block of footer.blocks) {
-      walkFieldDocument(block, visit);
-    }
-  }
-  if (subParts.footnoteCollection) {
-    for (const note of Object.values(subParts.footnoteCollection.footnotes)) {
-      for (const block of note.blocks) {
-        walkFieldDocument(block, visit);
-      }
-    }
-    for (const note of Object.values(subParts.footnoteCollection.endnotes)) {
-      for (const block of note.blocks) {
-        walkFieldDocument(block, visit);
-      }
-    }
-  }
-}
-
-function flattenFieldText(children: InlineNode[]): string {
-  return children
-    .map((child) => {
-      if (child.type === "text") return child.text;
-      if (child.type === "tab") return "\t";
-      if (child.type === "hard_break" || child.type === "column_break") return "\n";
-      return "";
-    })
-    .join("");
-}
-
-function flattenParagraphInlineText(children: InlineNode[]): string {
-  return children
-    .map((child) => {
-      if (child.type === "text") return child.text;
-      if (child.type === "tab") return "\t";
-      if (child.type === "hard_break" || child.type === "column_break") return "\n";
-      if (child.type === "hyperlink") return flattenFieldText(child.children);
-      if (child.type === "field") return flattenFieldText(child.children);
-      return "";
-    })
-    .join("");
-}
-
-function flattenBookmarkContent(
-  paragraph: ParagraphNode,
-  bookmarkId: string,
-): string {
-  let inside = false;
-  const parts: string[] = [];
-  for (const child of paragraph.children) {
-    if (child.type === "bookmark_start" && child.bookmarkId === bookmarkId) {
-      inside = true;
-      continue;
-    }
-    if (child.type === "bookmark_end" && child.bookmarkId === bookmarkId) {
-      break;
-    }
-    if (inside) {
-      if (child.type === "text") parts.push(child.text);
-      else if (child.type === "tab") parts.push("\t");
-      else if (child.type === "hard_break") parts.push("\n");
-    }
-  }
-  // If no bookmark boundaries found in this paragraph, return full paragraph text
-  if (!inside) {
-    return flattenParagraphInlineText(paragraph.children);
-  }
-  return parts.join("");
-}
-
-// ─── Internal helpers ─────────────────────────────────────────────────────────
-
-function extractComplexFieldsFromParagraph(
-  paragraph: XmlElementNode,
-  sourceXml: string,
-  results: ParsedComplexFieldNode[],
-): void {
-  type FieldState = "idle" | "in-instr" | "in-content";
-  let state: FieldState = "idle";
-  let instrParts: string[] = [];
-  let contentStart = -1;
-  let contentEnd = -1;
-  let fieldStart = -1;
-
-  for (const child of paragraph.children) {
-    if (child.type !== "element" || localName(child.name) !== "r") continue;
-
-    const fldChar = findFirstChildEl(child, "fldChar");
-    const instrText = findFirstChildEl(child, "instrText");
-
-    if (fldChar) {
-      const charType = (
-        fldChar.attributes["w:fldCharType"] ??
-        fldChar.attributes.fldCharType ??
-        ""
-      ).toLowerCase();
-
-      if (charType === "begin") {
-        state = "in-instr";
-        instrParts = [];
-        fieldStart = child.start;
-        contentStart = -1;
-        contentEnd = -1;
-      } else if (charType === "separate" && state === "in-instr") {
-        state = "in-content";
-        contentStart = child.end;
-      } else if (charType === "end") {
-        if (state === "in-content" || state === "in-instr") {
-          if (state === "in-content") {
-            contentEnd = child.start;
-          }
-          const instruction = instrParts.join("").trim();
-          const contentXml =
-            contentStart >= 0 && contentEnd >= contentStart
-              ? sourceXml.slice(contentStart, contentEnd)
-              : "";
-          results.push({
-            type: "field",
-            fieldType: "complex",
-            instruction,
-            contentXml,
-            start: fieldStart,
-            end: child.end,
-          });
-        }
-        state = "idle";
-        instrParts = [];
-      }
-    } else if (instrText && state === "in-instr") {
-      const text = instrText.children
-        .filter((c): c is XmlTextNode => c.type === "text")
-        .map((c) => c.text)
-        .join("");
-      instrParts.push(text);
-    }
-  }
-}
-
-function collectBookmarks(
-  node: XmlElementNode,
-  sourceXml: string,
-  results: ParsedBookmarkNode[],
-): void {
-  for (const child of node.children) {
-    if (child.type !== "element") continue;
-    const name = localName(child.name);
-    if (name === "bookmarkStart") {
-      const bk = parseBookmarkStart(child, sourceXml);
-      if (bk) results.push(bk);
-    } else if (name === "bookmarkEnd") {
-      const bk = parseBookmarkEnd(child, sourceXml);
-      if (bk) results.push(bk);
-    } else {
-      collectBookmarks(child, sourceXml, results);
-    }
-  }
-}
-
-function findFirstChild(node: XmlElementNode, childLocalName: string): XmlElementNode | undefined {
-  return node.children.find(
-    (c): c is XmlElementNode => c.type === "element" && localName(c.name) === childLocalName,
-  );
-}
-
-function findFirstChildEl(node: XmlElementNode, childLocalName: string): XmlElementNode | undefined {
-  return node.children.find(
-    (c): c is XmlElementNode => c.type === "element" && localName(c.name) === childLocalName,
-  );
-}
-
-function localName(name: string): string {
-  const sep = name.indexOf(":");
-  return sep >= 0 ? name.slice(sep + 1) : name;
-}
-
-// ─── Minimal XML parser (same pattern as parse-tables.ts) ────────────────────
-
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-    start: 0,
-    end: xml.length,
-  };
-  const stack: XmlElementNode[] = [root];
-  let cursor = 0;
-
-  while (cursor < xml.length) {
-    if (xml.startsWith("<!--", cursor)) {
-      const end = xml.indexOf("-->", cursor);
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-    if (xml.startsWith("<?", cursor)) {
-      const end = xml.indexOf("?>", cursor);
-      cursor = end >= 0 ? end + 2 : xml.length;
-      continue;
-    }
-    if (xml.startsWith("<![CDATA[", cursor)) {
-      const end = xml.indexOf("]]>", cursor);
-      const textEnd = end >= 0 ? end : xml.length;
-      stack[stack.length - 1]?.children.push({
-        type: "text",
-        text: xml.slice(cursor + 9, textEnd),
-        start: cursor,
-        end: end >= 0 ? end + 3 : xml.length,
-      });
-      cursor = end >= 0 ? end + 3 : xml.length;
-      continue;
-    }
-    if (xml[cursor] !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      const end = nextTag >= 0 ? nextTag : xml.length;
-      const text = decodeXmlEntities(xml.slice(cursor, end));
-      if (text.length > 0) {
-        stack[stack.length - 1]?.children.push({ type: "text", text, start: cursor, end });
-      }
-      cursor = end;
-      continue;
-    }
-    if (xml[cursor + 1] === "/") {
-      const end = xml.indexOf(">", cursor);
-      if (end < 0) throw new Error("Malformed XML: missing >.");
-      const name = xml.slice(cursor + 2, end).trim();
-      const current = stack.pop();
-      if (!current || localName(current.name) !== localName(name)) {
-        throw new Error(`Malformed XML: unexpected closing tag </${name}>.`);
-      }
-      current.end = end + 1;
-      cursor = end + 1;
-      continue;
-    }
-    const tagEnd = findTagEnd(xml, cursor);
-    const tagBody = xml.slice(cursor + 1, tagEnd);
-    const selfClosing = /\/\s*$/.test(tagBody);
-    const { name, attributes } = parseTag(tagBody.replace(/\/\s*$/, "").trim());
-    const element: XmlElementNode = {
-      type: "element",
-      name,
-      attributes,
-      children: [],
-      start: cursor,
-      end: tagEnd + 1,
-    };
-    stack[stack.length - 1]?.children.push(element);
-    if (!selfClosing) stack.push(element);
-    cursor = tagEnd + 1;
-  }
-
-  if (stack.length !== 1) throw new Error("Malformed XML: unclosed element.");
-  return root;
-}
-
-function parseTag(tagBody: string): { name: string; attributes: Record<string, string> } {
-  let cursor = 0;
-  while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor += 1;
-  const nameStart = cursor;
-  while (cursor < tagBody.length && !/\s/.test(tagBody[cursor] ?? "")) cursor += 1;
-  const name = tagBody.slice(nameStart, cursor);
-  const attributes: Record<string, string> = {};
-
-  while (cursor < tagBody.length) {
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor += 1;
-    if (cursor >= tagBody.length) break;
-    const keyStart = cursor;
-    while (cursor < tagBody.length && !/[\s=]/.test(tagBody[cursor] ?? "")) cursor += 1;
-    const key = tagBody.slice(keyStart, cursor);
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor += 1;
-    if (tagBody[cursor] !== "=") { attributes[key] = ""; continue; }
-    cursor += 1;
-    while (cursor < tagBody.length && /\s/.test(tagBody[cursor] ?? "")) cursor += 1;
-    const quote = tagBody[cursor];
-    if (quote !== `"` && quote !== `'`) throw new Error(`Malformed XML attribute ${key}.`);
-    cursor += 1;
-    const valueStart = cursor;
-    while (cursor < tagBody.length && tagBody[cursor] !== quote) cursor += 1;
-    attributes[key] = decodeXmlEntities(tagBody.slice(valueStart, cursor));
-    cursor += 1;
-  }
-  return { name, attributes };
-}
-
-function findTagEnd(xml: string, start: number): number {
-  let cursor = start + 1;
-  let quote: string | null = null;
-  while (cursor < xml.length) {
-    const c = xml[cursor];
-    if (quote) { if (c === quote) quote = null; cursor += 1; continue; }
-    if (c === `"` || c === `'`) { quote = c; cursor += 1; continue; }
-    if (c === ">") return cursor;
-    cursor += 1;
-  }
-  throw new Error("Malformed XML: missing >.");
-}
-
-function decodeXmlEntities(value: string): string {
-  return value.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (match, entity) => {
-    switch (entity) {
-      case "amp": return "&";
-      case "lt": return "<";
-      case "gt": return ">";
-      case "quot": return `"`;
-      case "apos": return `'`;
-      default:
-        if (entity.startsWith("#x")) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16));
-        if (entity.startsWith("#")) return String.fromCodePoint(Number.parseInt(entity.slice(1), 10));
-        return match;
-    }
-  });
-}