@beyondwork/docx-react-component 1.0.58 → 1.0.59

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

@@ -4,8 +4,15 @@ import type { InlineMediaPart } from "./parse-inline-media.ts";
 import type { ChartPartLookup } from "./parse-complex-content.ts";
 import type { DrawingFrameNode, AnchorGeometry } from "../../model/canonical-document.ts";
 import { parseAnchorGeometry } from "./parse-anchor.ts";
-import { parsePicture, type PictureXmlElement } from "./parse-picture.ts";
+import { parsePicture } from "./parse-picture.ts";
 import { parseShapeContent, type TxbxBlockParser } from "./parse-shapes.ts";
+import {
+  type XmlElementNode,
+  findFirstChild,
+  findFirstDescendant,
+  localName,
+  parseXml,
+} from "./_mini-xml.ts";
 
 const PICTURE_GRAPHIC_URI =
   "http://schemas.openxmlformats.org/drawingml/2006/picture";
@@ -40,34 +47,102 @@ export function parseDrawingFrame(
 ): DrawingFrameNode | null {
   const root = parseXml(drawingXml);
 
-  // F3.1: unwrap mc:AlternateContent to its Choice branch (preferred) or Fallback.
-  // Real-world Word output wraps nearly every w:drawing in AlternateContent. The
-  // branch we pick determines which anchor/graphicData we descend into.
-  const searchRoot = pickAlternateContentBranch(root);
+  // F3.1 / Phase-1.1 B1: mc:AlternateContent handling moved from "pick one branch"
+  // to "try branches in order, keep first that yields non-opaque content".
+  // This fixes the case where Choice advertises a known graphicData URI but its
+  // body is empty / unparseable, and Fallback carries the actual usable content.
+  const alt = findFirstDescendant(root, "AlternateContent");
+  if (alt) {
+    return resolveFromAlternateContent(alt, drawingXml, opts);
+  }
+  return resolveFromBranch(root, drawingXml, opts);
+}
+
+// Phase 4.1 G2 — namespaces whose Choice branches we can parse. An
+// mc:Choice element's Requires="ns1 ns2 …" is considered supported when
+// every listed namespace appears here. Unknown Requires tokens reject
+// the Choice. Expand as CO4 / downstream lanes add coverage.
+const SUPPORTED_REQUIRES_NAMESPACES = new Set<string>([
+  "",        // no Requires attr = accept
+  "c14",     // Word chart Choice wrappers still resolve to chart_preview
+  "dgm2009", // SmartArt Choice wrappers still resolve to smartart_preview
+  "wps",     // WordprocessingShape (we parse)
+  "wpg",     // WordprocessingGroup (wpg is preserved via opaque; Choice-level acceptance is fine)
+  "w14",     // WordML 2010 extensions
+  "w15",     // WordML 2012 extensions
+  "w16se",   // WordML 2016 SE
+  "a14",     // DrawingML 2010
+  "v",       // VML (preserved as opaque)
+  "o",       // VML office extensions (preserved as opaque)
+  "wp14",    // DrawingML wordproc 2010
+]);
+
+function resolveFromAlternateContent(
+  alt: XmlElementNode,
+  outerRawXml: string,
+  opts: ParseDrawingOpts,
+): DrawingFrameNode | null {
+  // Enumerate ALL Choice elements in document order; ignore ones whose
+  // Requires= lists a namespace we don't know how to parse.
+  const supportedChoices = alt.children.filter(
+    (c): c is XmlElementNode =>
+      c.type === "element" && localName(c.name) === "Choice" && isChoiceSupported(c),
+  );
+  const fallback = findFirstChild(alt, "Fallback");
+
+  // Try each supported Choice in order; return first that yields non-opaque
+  // typed content. This is the mc:AlternateContent spec: readers process
+  // Choice elements in order, selecting the first whose Requires is satisfied.
+  for (const choice of supportedChoices) {
+    const frame = resolveFromBranch(choice, outerRawXml, opts);
+    if (frame && frame.content.type !== "opaque") return frame;
+  }
+
+  // Phase 1.1 B1 — no Choice produced typed content; try Fallback.
+  const fallbackFrame = fallback ? resolveFromBranch(fallback, outerRawXml, opts) : null;
+  if (fallbackFrame && fallbackFrame.content.type !== "opaque") return fallbackFrame;
+
+  // All branches opaque — preserve whichever typed result exists. First
+  // supported Choice takes precedence over Fallback to match Word's
+  // declared-order semantic.
+  for (const choice of supportedChoices) {
+    const frame = resolveFromBranch(choice, outerRawXml, opts);
+    if (frame) return frame;
+  }
+  return fallbackFrame ?? null;
+}
+
+function isChoiceSupported(choice: XmlElementNode): boolean {
+  const requires = (choice.attributes.Requires ?? "").trim();
+  if (!requires) return true;
+  return requires.split(/\s+/).every((ns) => SUPPORTED_REQUIRES_NAMESPACES.has(ns));
+}
 
+function resolveFromBranch(
+  branch: XmlElementNode,
+  outerRawXml: string,
+  opts: ParseDrawingOpts,
+): DrawingFrameNode | null {
   // Find wp:anchor or wp:inline in the chosen branch
-  const anchor = findFirstDescendant(searchRoot, "anchor");
-  const inline = findFirstDescendant(searchRoot, "inline");
+  const anchor = findFirstDescendant(branch, "anchor");
+  const inline = findFirstDescendant(branch, "inline");
   const container = anchor ?? inline;
   if (!container) return null;
 
-  const geometry: AnchorGeometry = parseAnchorGeometry(container as never);
+  const geometry: AnchorGeometry = parseAnchorGeometry(container);
 
   // Locate a:graphicData to determine content type
-  const graphicData = findFirstDescendant(searchRoot, "graphicData");
+  const graphicData = findFirstDescendant(branch, "graphicData");
   const uri = graphicData?.attributes.uri ?? "";
 
   // F3.5: if we don't recognise the graphicData URI, return null and let the
-  // legacy parse chain (parseComplexContentXml / parseShapeXml / parseVmlXml /
-  // parseInlineMediaXml) handle it. The new DrawingFrameNode path only
-  // short-circuits for known URIs.
+  // legacy parse chain handle it.
   if (!isKnownUri(uri)) return null;
   // WordArt remains on the dedicated legacy `wordart` node path. Only
   // non-WordArt WPS drawings are promoted into DrawingFrame shape content.
   if (uri === WPS_SHAPE_GRAPHIC_URI && isWordArtGraphicData(graphicData)) return null;
 
-  const content = resolveContent(uri, graphicData, drawingXml, opts);
-
+  const content = resolveContent(uri, graphicData, outerRawXml, opts);
   return { type: "drawing_frame", anchor: geometry, content };
 }
 
@@ -91,34 +166,6 @@ function isWordArtGraphicData(graphicData: XmlElementNode | undefined): boolean
   return /^text/i.test(geometry);
 }
 
-/**
- * If the drawing is wrapped in mc:AlternateContent, return the chosen branch
- * subtree. Prefer Choice (richer content); use Fallback only when Choice
- * contains no graphicData we can parse.
- */
-function pickAlternateContentBranch(root: XmlElementNode): XmlElementNode {
-  const alt = findFirstDescendant(root, "AlternateContent");
-  if (!alt) return root;
-
-  const choice = findFirstChild(alt, "Choice");
-  const fallback = findFirstChild(alt, "Fallback");
-
-  if (choice) {
-    const choiceGraphicData = findFirstDescendant(choice, "graphicData");
-    const choiceUri = choiceGraphicData?.attributes.uri ?? "";
-    if (isKnownUri(choiceUri)) return choice;
-  }
-
-  if (fallback) {
-    const fallbackGraphicData = findFirstDescendant(fallback, "graphicData");
-    const fallbackUri = fallbackGraphicData?.attributes.uri ?? "";
-    if (isKnownUri(fallbackUri)) return fallback;
-  }
-
-  // Neither branch has a known URI — return Choice (if any) so caller can emit
-  // opaque preservation; otherwise the original root.
-  return choice ?? fallback ?? root;
-}
 
 function resolveContent(
   uri: string,
@@ -128,12 +175,16 @@ function resolveContent(
 ): DrawingFrameNode["content"] {
   if (uri === PICTURE_GRAPHIC_URI) {
     if (graphicData) {
-      const pic = parsePicture(graphicData as PictureXmlElement);
+      const pic = parsePicture(graphicData);
       if (pic) {
-        // Resolve mediaId from the relationship map
+        // Resolve mediaId from the relationship map. For embedded blips
+        // (r:embed) the relationship target is a package-local media part,
+        // so we normalize + register a mediaId. For linked blips (G4 / r:link)
+        // the relationship target is an external URL — we skip mediaId
+        // (leaving it undefined so surface-projection flags state: "missing").
         const relMap = new Map(opts.relationships.map((r) => [r.id, r]));
         const rel = relMap.get(pic.blipRef);
-        if (rel?.type.endsWith("/image")) {
+        if (!pic.isLinked && rel?.type.endsWith("/image")) {
           const partPath = normalizePartPath(
             resolveRelationshipTarget(opts.sourcePartPath ?? "/word/document.xml", rel),
           );
@@ -156,7 +207,7 @@ function resolveContent(
   if (uri === WPS_SHAPE_GRAPHIC_URI) {
     if (graphicData) {
       const shape = parseShapeContent(
-        graphicData as PictureXmlElement,
+        graphicData,
         rawXml,
         opts.blockParser,
       );
@@ -168,152 +219,6 @@ function resolveContent(
   return { type: "opaque", rawXml };
 }
 
-// ── Minimal self-contained XML parser ──────────────────────────────────────
-
-interface XmlElementNode {
-  type: "element";
-  name: string;
-  attributes: Record<string, string>;
-  children: XmlNode[];
-}
-
-interface XmlTextNode {
-  type: "text";
-  text: string;
-}
-
-type XmlNode = XmlElementNode | XmlTextNode;
-
-function findFirstChild(
-  node: XmlElementNode,
-  local: string,
-): XmlElementNode | undefined {
-  for (const child of node.children) {
-    if (child.type === "element" && localName(child.name) === local) return child;
-  }
-  return undefined;
-}
-
-function findFirstDescendant(
-  node: XmlElementNode,
-  local: string,
-): XmlElementNode | undefined {
-  for (const child of node.children) {
-    if (child.type !== "element") continue;
-    if (localName(child.name) === local) return child;
-    const found = findFirstDescendant(child, local);
-    if (found) return found;
-  }
-  return undefined;
-}
-
-function localName(name: string): string {
-  const i = name.indexOf(":");
-  return i >= 0 ? name.slice(i + 1) : name;
-}
-
-function parseXml(xml: string): XmlElementNode {
-  const root: XmlElementNode = {
-    type: "element",
-    name: "__root__",
-    attributes: {},
-    children: [],
-  };
-  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[cursor] !== "<") {
-      const nextTag = xml.indexOf("<", cursor);
-      const end = nextTag >= 0 ? nextTag : xml.length;
-      const text = decodeEntities(xml.slice(cursor, end));
-      if (text) stack[stack.length - 1]?.children.push({ type: "text", text });
-      cursor = end;
-      continue;
-    }
-    if (xml[cursor + 1] === "/") {
-      const end = xml.indexOf(">", cursor);
-      stack.pop();
-      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 el: XmlElementNode = { type: "element", name, attributes, children: [] };
-    stack[stack.length - 1]?.children.push(el);
-    if (!selfClosing) stack.push(el);
-    cursor = tagEnd + 1;
-  }
-
-  return root;
-}
-
-function findTagEnd(xml: string, start: number): number {
-  let cursor = start + 1;
-  let quote: string | null = null;
-  while (cursor < xml.length) {
-    const ch = xml[cursor];
-    if (quote) {
-      if (ch === quote) quote = null;
-    } else if (ch === `"` || ch === `'`) {
-      quote = ch;
-    } else if (ch === ">") {
-      return cursor;
-    }
-    cursor++;
-  }
-  return xml.length - 1;
-}
-
-function parseTag(body: string): { name: string; attributes: Record<string, string> } {
-  let i = 0;
-  while (i < body.length && /\s/.test(body[i] ?? "")) i++;
-  const nameStart = i;
-  while (i < body.length && !/\s/.test(body[i] ?? "")) i++;
-  const name = body.slice(nameStart, i);
-  const attributes: Record<string, string> = {};
-  while (i < body.length) {
-    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
-    if (i >= body.length) break;
-    const kStart = i;
-    while (i < body.length && !/[\s=]/.test(body[i] ?? "")) i++;
-    const key = body.slice(kStart, i);
-    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
-    if (body[i] !== "=") { attributes[key] = ""; continue; }
-    i++;
-    while (i < body.length && /\s/.test(body[i] ?? "")) i++;
-    const q = body[i];
-    if (q !== `"` && q !== `'`) throw new Error(`Bad attr ${key}`);
-    i++;
-    const vStart = i;
-    while (i < body.length && body[i] !== q) i++;
-    attributes[key] = decodeEntities(body.slice(vStart, i));
-    i++;
-  }
-  return { name, attributes };
-}
-
-function decodeEntities(s: string): string {
-  return s.replace(/&(#x[0-9a-fA-F]+|#\d+|amp|lt|gt|quot|apos);/g, (_, e) => {
-    if (e === "amp") return "&";
-    if (e === "lt") return "<";
-    if (e === "gt") return ">";
-    if (e === "quot") return `"`;
-    if (e === "apos") return "'";
-    if (e.startsWith("#x")) return String.fromCodePoint(parseInt(e.slice(2), 16));
-    if (e.startsWith("#")) return String.fromCodePoint(parseInt(e.slice(1), 10));
-    return `&${e};`;
-  });
-}
+// Phase 6 — XML parser helpers imported from ./_mini-xml.ts (previously
+// duplicated inline across four files). See that module for B4 throw-on-
+// unterminated-tag contract and entity-decoding implementation.

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

@@ -0,0 +1,93 @@
+import type { LegacyFormFieldNode } from "../../model/canonical-document.ts";
+import type { XmlElementNode } from "./xml-element.ts";
+import {
+  findChildOptional,
+  localName,
+  readIntAttr,
+  readOnOff,
+  readStringAttr,
+} from "./xml-attr-helpers.ts";
+
+/**
+ * Parse a <w:ffData> child of a <w:fldChar w:fldCharType="begin"> element.
+ *
+ * Returns undefined if no <w:ffData> child is present (most fields don't have one).
+ * Only textInput, checkBox, and ddList kinds are modelled; rawXml preserves
+ * everything verbatim for round-trip fidelity.
+ */
+export function parseFFDataFromFldChar(
+  fldCharEl: XmlElementNode,
+  sourceXml: string,
+): LegacyFormFieldNode | undefined {
+  const ffDataEl = findChildOptional(fldCharEl, "ffData");
+  if (!ffDataEl) return undefined;
+
+  const rawXml = sourceXml.slice(ffDataEl.start, ffDataEl.end);
+
+  const nameEl = findChildOptional(ffDataEl, "name");
+  const name = nameEl ? readStringAttr(nameEl, "w:val") : undefined;
+  const enabledEl = findChildOptional(ffDataEl, "enabled");
+  const enabled = enabledEl !== undefined ? readOnOff(enabledEl) : undefined;
+  const calcOnExitEl = findChildOptional(ffDataEl, "calcOnExit");
+  const calcOnExit = calcOnExitEl !== undefined ? readOnOff(calcOnExitEl) : undefined;
+
+  const base: Pick<LegacyFormFieldNode, "name" | "enabled" | "calcOnExit"> = {
+    ...(name !== undefined ? { name } : {}),
+    ...(enabled !== undefined ? { enabled } : {}),
+    ...(calcOnExit !== undefined ? { calcOnExit } : {}),
+  };
+
+  const textInputEl = findChildOptional(ffDataEl, "textInput");
+  if (textInputEl) {
+    const defaultEl = findChildOptional(textInputEl, "default");
+    const maxLengthEl = findChildOptional(textInputEl, "maxLength");
+    const formatEl = findChildOptional(textInputEl, "format");
+    return {
+      kind: "textInput",
+      ...base,
+      textInput: {
+        ...(defaultEl !== undefined ? { default: readStringAttr(defaultEl, "w:val") } : {}),
+        ...(maxLengthEl !== undefined ? { maxLength: readIntAttr(maxLengthEl, "w:val") } : {}),
+        ...(formatEl !== undefined ? { format: readStringAttr(formatEl, "w:val") } : {}),
+      },
+      rawXml,
+    };
+  }
+
+  const checkBoxEl = findChildOptional(ffDataEl, "checkBox");
+  if (checkBoxEl) {
+    const sizeEl = findChildOptional(checkBoxEl, "size");
+    const defaultEl = findChildOptional(checkBoxEl, "default");
+    const checkedEl = findChildOptional(checkBoxEl, "checked");
+    return {
+      kind: "checkBox",
+      ...base,
+      checkBox: {
+        ...(sizeEl !== undefined ? { size: readIntAttr(sizeEl, "w:val") } : {}),
+        ...(defaultEl !== undefined ? { default: readOnOff(defaultEl) ?? false } : {}),
+        ...(checkedEl !== undefined ? { checked: readOnOff(checkedEl) } : {}),
+      },
+      rawXml,
+    };
+  }
+
+  const ddListEl = findChildOptional(ffDataEl, "ddList");
+  if (ddListEl) {
+    const defaultEl = findChildOptional(ddListEl, "default");
+    const listEntries = ddListEl.children
+      .filter((c): c is XmlElementNode => c.type === "element" && localName(c.name) === "listEntry")
+      .map((c) => readStringAttr(c, "w:val") ?? "");
+    return {
+      kind: "ddList",
+      ...base,
+      ddList: {
+        ...(defaultEl !== undefined ? { default: readIntAttr(defaultEl, "w:val") } : {}),
+        listEntry: listEntries,
+      },
+      rawXml,
+    };
+  }
+
+  // Unknown or empty ffData — preserve via rawXml passthrough
+  return { kind: "textInput", ...base, rawXml };
+}

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

@@ -53,6 +53,9 @@ export interface ParsedBookmarkEndNode {
 
 export type ParsedBookmarkNode = ParsedBookmarkStartNode | ParsedBookmarkEndNode;
 
+import { parseXmlWithOffsets } from "./xml-parser.ts";
+import { localName } from "./xml-attr-helpers.ts";
+
 // ─── Internal XML types ───────────────────────────────────────────────────────
 
 interface XmlElementNode {
@@ -86,7 +89,7 @@ export function parseFieldsFromParagraphXml(paragraphXml: string): {
   simpleFields: ParsedSimpleFieldNode[];
   bookmarks: ParsedBookmarkNode[];
 } {
-  const root = parseXml(paragraphXml);
+  const root = parseXmlWithOffsets(paragraphXml) as XmlElementNode;
   const pEl = findFirstChild(root, "p");
   const target = pEl ?? root;
 
@@ -120,7 +123,7 @@ export function parseFieldsFromParagraphXml(paragraphXml: string): {
  * @param bodyXml  Raw XML string of a <w:body> element (or full document).
  */
 export function extractComplexFieldsFromBodyXml(bodyXml: string): ParsedComplexFieldNode[] {
-  const root = parseXml(bodyXml);
+  const root = parseXmlWithOffsets(bodyXml) as XmlElementNode;
   const results: ParsedComplexFieldNode[] = [];
 
   // Walk all <w:p> children of the body
@@ -140,7 +143,7 @@ export function extractComplexFieldsFromBodyXml(bodyXml: string): ParsedComplexF
  * Parse all bookmark start/end nodes from a full document or body XML.
  */
 export function extractBookmarksFromBodyXml(bodyXml: string): ParsedBookmarkNode[] {
-  const root = parseXml(bodyXml);
+  const root = parseXmlWithOffsets(bodyXml) as XmlElementNode;
   const results: ParsedBookmarkNode[] = [];
   collectBookmarks(root, bodyXml, results);
   return results;
@@ -174,7 +177,7 @@ export interface FieldGroup {
  * Fail-closed: a begin with no matching end is silently dropped.
  */
 export function streamWalkFieldGroups(bodyXml: string): FieldGroup[] {
-  const root = parseXml(bodyXml);
+  const root = parseXmlWithOffsets(bodyXml) as XmlElementNode;
   const bodyEl =
     findFirstChild(root, "body") ??
     findFirstChild(root, "document") ??
@@ -836,145 +839,3 @@ function findFirstChildEl(node: XmlElementNode, childLocalName: string): XmlElem
   );
 }
 
-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;
-    }
-  });
-}