@beyondwork/docx-react-component 1.0.56 → 1.0.58

package/src/io/export/table-properties-xml.ts

@@ -1,5 +1,7 @@
 import { twip } from "./twip.ts";
 import { escapeXmlAttribute } from "./escape-xml-attribute.ts";
+import { emitPropertyGrabBag } from "../ooxml/property-grab-bag.ts";
+import type { UnknownPropertyChild } from "../../model/canonical-document.ts";
 
 interface TableWidthLike {
   value: number;
@@ -66,6 +68,7 @@ interface TableFloatingPropertiesLike {
 
 interface TablePropertiesLike {
   propertiesXml?: string;
+  unknownPropertyChildren?: UnknownPropertyChild[];
   styleId?: string;
   width?: TableWidthLike;
   alignment?: string;
@@ -83,6 +86,7 @@ interface TablePropertiesLike {
 
 interface TableRowPropertiesLike {
   propertiesXml?: string;
+  unknownPropertyChildren?: UnknownPropertyChild[];
   gridBefore?: number;
   widthBefore?: TableWidthLike;
   gridAfter?: number;
@@ -97,6 +101,7 @@ interface TableRowPropertiesLike {
 
 interface TableCellPropertiesLike {
   propertiesXml?: string;
+  unknownPropertyChildren?: UnknownPropertyChild[];
   width?: TableWidthLike;
   gridSpan?: number;
   verticalMerge?: "restart" | "continue";
@@ -166,6 +171,7 @@ export function serializeTablePropertiesXml(table: TablePropertiesLike): string
   return mergePropertiesXml(
     "w:tblPr",
     table.propertiesXml,
+    table.unknownPropertyChildren,
     buildTablePropertiesInnerXml(table),
     TABLE_PROPERTY_STRIP_SPEC,
   );
@@ -175,6 +181,7 @@ export function serializeTableRowPropertiesXml(row: TableRowPropertiesLike): str
   return mergePropertiesXml(
     "w:trPr",
     row.propertiesXml,
+    row.unknownPropertyChildren,
     buildTableRowPropertiesInnerXml(row),
     ROW_PROPERTY_STRIP_SPEC,
   );
@@ -184,21 +191,29 @@ export function serializeTableCellPropertiesXml(cell: TableCellPropertiesLike):
   return mergePropertiesXml(
     "w:tcPr",
     cell.propertiesXml,
+    cell.unknownPropertyChildren,
     buildTableCellPropertiesInnerXml(cell),
     CELL_PROPERTY_STRIP_SPEC,
   );
 }
 
+// Phase 7 Slice A — `unknownPropertyChildren` (typed grab-bag) is the
+// preferred path. The legacy `existingXml` regex-strip fallback only fires
+// for snapshots that pre-date the typed retrofit (no `unknownPropertyChildren`
+// captured). Once persisted snapshots are migrated and tests no longer
+// reference `propertiesXml`, the fallback branch and `stripKnownProperties`
+// helper can be retired entirely.
 function mergePropertiesXml(
   tagName: "w:tblPr" | "w:trPr" | "w:tcPr",
   existingXml: string | undefined,
+  unknownPropertyChildren: readonly UnknownPropertyChild[] | undefined,
   supportedInnerXml: string,
   stripSpec: PropertyStripSpec,
 ): string {
-  const preservedInnerXml = stripKnownProperties(
-    extractWrappedChildren(tagName, existingXml),
-    stripSpec,
-  );
+  const preservedInnerXml =
+    unknownPropertyChildren !== undefined
+      ? emitPropertyGrabBag(unknownPropertyChildren)
+      : stripKnownProperties(extractWrappedChildren(tagName, existingXml), stripSpec);
   const mergedInnerXml = [supportedInnerXml, preservedInnerXml]
     .filter((part) => part.length > 0)
     .join("");

package/src/io/normalize/normalize-text.ts

@@ -287,6 +287,7 @@ function normalizeTable(
     type: "table",
     ...(table.styleId ? { styleId: table.styleId } : {}),
     ...(table.propertiesXml ? { propertiesXml: table.propertiesXml } : {}),
+    ...(table.unknownPropertyChildren ? { unknownPropertyChildren: table.unknownPropertyChildren } : {}),
     gridColumns: table.gridColumns,
     rows,
     ...(table.width ? { width: table.width } : {}),
@@ -313,6 +314,7 @@ function normalizeTableRow(
   return {
     type: "table_row",
     ...(row.propertiesXml ? { propertiesXml: row.propertiesXml } : {}),
+    ...(row.unknownPropertyChildren ? { unknownPropertyChildren: row.unknownPropertyChildren } : {}),
     ...(row.gridBefore !== undefined ? { gridBefore: row.gridBefore } : {}),
     ...(row.widthBefore ? { widthBefore: row.widthBefore } : {}),
     ...(row.gridAfter !== undefined ? { gridAfter: row.gridAfter } : {}),
@@ -343,6 +345,7 @@ function normalizeTableCell(
   return {
     type: "table_cell",
     ...(cell.propertiesXml ? { propertiesXml: cell.propertiesXml } : {}),
+    ...(cell.unknownPropertyChildren ? { unknownPropertyChildren: cell.unknownPropertyChildren } : {}),
     ...(cell.gridSpan ? { gridSpan: cell.gridSpan } : {}),
     ...(cell.verticalMerge ? { verticalMerge: cell.verticalMerge } : {}),
     ...(cell.width ? { width: cell.width } : {}),
@@ -454,6 +457,10 @@ function normalizeInlineChildren(
         normalized.push(normalizeImageNode(node, state));
         state.cursor += 1;
         break;
+      case "drawing_frame":
+        normalized.push(normalizeDrawingFrameNode(node, state));
+        state.cursor += 1;
+        break;
       case "hyperlink":
         normalized.push(normalizeHyperlink(node));
         state.cursor += measureHyperlink(node);
@@ -617,6 +624,32 @@ function normalizeImageNode(
   };
 }
 
+function normalizeDrawingFrameNode(
+  node: Extract<ParsedInlineNode, { type: "drawing_frame" }>,
+  state: NormalizationState,
+): InlineNode {
+  if (node.content.type === "picture" && node.content.mediaId) {
+    const existingMediaItem = state.media.items[node.content.mediaId];
+    const packagePartName =
+      typeof node.content.packagePartName === "string" && node.content.packagePartName.length > 0
+        ? node.content.packagePartName
+        : `/${node.content.mediaId.slice("media:".length)}`;
+    const filename = packagePartName.slice(packagePartName.lastIndexOf("/") + 1) || "image.bin";
+    state.media.items[node.content.mediaId] = {
+      mediaId: node.content.mediaId,
+      contentType: existingMediaItem?.contentType ?? "application/octet-stream",
+      filename,
+      packagePartName,
+      relationshipId: node.content.blipRef,
+      ...(node.anchor.docPr?.descr ? { altText: node.anchor.docPr.descr } : {}),
+      widthEmu: node.anchor.extent.widthEmu,
+      heightEmu: node.anchor.extent.heightEmu,
+    };
+  }
+
+  return node;
+}
+
 /**
  * Register a chart/SmartArt preview bitmap in the media catalog so the
  * surface renderer can resolve `previewMediaId` → `previewSrc` the same

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

@@ -0,0 +1,182 @@
+import type { AnchorGeometry } from "../../model/canonical-document.ts";
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+export function parseAnchorGeometry(container: XmlElementNode): AnchorGeometry {
+  const tag = localName(container.name);
+  const display: "inline" | "floating" = tag === "anchor" ? "floating" : "inline";
+
+  const extent = readExtent(container);
+
+  const wrapMode = readWrapMode(container);
+
+  const positionHEl = findFirstChild(container, "positionH");
+  const positionVEl = findFirstChild(container, "positionV");
+
+  const effectExtentEl = findFirstChild(container, "effectExtent");
+  const distMargins = effectExtentEl
+    ? {
+        top: readIntAttr(effectExtentEl, "t") ?? 0,
+        bottom: readIntAttr(effectExtentEl, "b") ?? 0,
+        left: readIntAttr(effectExtentEl, "l") ?? 0,
+        right: readIntAttr(effectExtentEl, "r") ?? 0,
+      }
+    : undefined;
+
+  const relativeHeight =
+    display === "floating" ? readIntAttr(container, "relativeHeight") : undefined;
+
+  const behindDoc =
+    display === "floating" ? readBoolAttr(container, "behindDoc") : undefined;
+  const layoutInCell =
+    display === "floating" ? readBoolAttr(container, "layoutInCell") : undefined;
+  const allowOverlap =
+    display === "floating" ? readBoolAttr(container, "allowOverlap") : undefined;
+  const simplePos =
+    display === "floating" ? readBoolAttr(container, "simplePos") : undefined;
+
+  const docPrEl = findFirstChild(container, "docPr");
+  const docPr = docPrEl
+    ? {
+        id: docPrEl.attributes.id ?? "",
+        ...(docPrEl.attributes.name ? { name: docPrEl.attributes.name } : {}),
+        ...(docPrEl.attributes.descr ? { descr: docPrEl.attributes.descr } : {}),
+      }
+    : undefined;
+
+  const geometry: AnchorGeometry = {
+    display,
+    extent,
+    wrapMode,
+  };
+
+  if (positionHEl) geometry.positionH = readAxisPosition(positionHEl);
+  if (positionVEl) geometry.positionV = readAxisPosition(positionVEl);
+  if (distMargins) geometry.distMargins = distMargins;
+  if (relativeHeight !== undefined) geometry.relativeHeight = relativeHeight;
+  if (behindDoc !== undefined) geometry.behindDoc = behindDoc;
+  if (layoutInCell !== undefined) geometry.layoutInCell = layoutInCell;
+  if (allowOverlap !== undefined) geometry.allowOverlap = allowOverlap;
+  if (simplePos !== undefined) geometry.simplePos = simplePos;
+  if (docPr) geometry.docPr = docPr;
+
+  return geometry;
+}
+
+function readExtent(container: XmlElementNode): AnchorGeometry["extent"] {
+  const extentEl = findFirstChild(container, "extent");
+  if (extentEl) {
+    return {
+      widthEmu: readIntAttr(extentEl, "cx") ?? 0,
+      heightEmu: readIntAttr(extentEl, "cy") ?? 0,
+    };
+  }
+
+  const transform = findFirstDescendant(container, "xfrm");
+  const shapeExtent = transform ? findFirstDescendant(transform, "ext") : undefined;
+  return {
+    widthEmu: shapeExtent ? readIntAttr(shapeExtent, "cx") ?? 0 : 0,
+    heightEmu: shapeExtent ? readIntAttr(shapeExtent, "cy") ?? 0 : 0,
+  };
+}
+
+function readWrapMode(
+  container: XmlElementNode,
+): AnchorGeometry["wrapMode"] {
+  for (const child of container.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+    if (name === "wrapNone") return "none";
+    if (name === "wrapSquare") return "square";
+    if (name === "wrapTight") return "tight";
+    if (name === "wrapThrough") return "through";
+    if (name === "wrapTopAndBottom") return "topAndBottom";
+  }
+  return "none";
+}
+
+function readAxisPosition(
+  el: XmlElementNode,
+): { relativeFrom: string; align?: string; offset?: number } {
+  const relativeFrom =
+    el.attributes.relativeFrom ?? el.attributes["wp:relativeFrom"] ?? "";
+  const alignEl = findFirstChild(el, "align");
+  const posOffsetEl = findFirstChild(el, "posOffset");
+
+  const result: { relativeFrom: string; align?: string; offset?: number } = {
+    relativeFrom,
+  };
+  if (alignEl) {
+    const text = extractText(alignEl).trim();
+    if (text) result.align = text;
+  }
+  if (posOffsetEl) {
+    const val = parseInt(extractText(posOffsetEl).trim(), 10);
+    if (Number.isFinite(val)) result.offset = val;
+  }
+  return result;
+}
+
+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 extractText(node: XmlElementNode): string {
+  return node.children
+    .map((c) => (c.type === "text" ? c.text : extractText(c as XmlElementNode)))
+    .join("");
+}
+
+function readIntAttr(node: XmlElementNode, name: string): number | undefined {
+  const v = node.attributes[name] ?? node.attributes[`wp:${name}`];
+  if (v === undefined) return undefined;
+  const n = parseInt(v, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function readBoolAttr(node: XmlElementNode, name: string): boolean | undefined {
+  const v =
+    node.attributes[name] ??
+    node.attributes[`wp:${name}`] ??
+    node.attributes[`w:${name}`];
+  if (v === undefined) return undefined;
+  return v !== "0" && v !== "false";
+}
+
+export { type XmlElementNode as AnchorXmlElement };

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

@@ -0,0 +1,319 @@
+import type { OpcRelationship } from "./part-manifest.ts";
+import { normalizePartPath, resolveRelationshipTarget } from "./part-manifest.ts";
+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 { parseShapeContent, type TxbxBlockParser } from "./parse-shapes.ts";
+
+const PICTURE_GRAPHIC_URI =
+  "http://schemas.openxmlformats.org/drawingml/2006/picture";
+const CHART_GRAPHIC_URI =
+  "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const CHART_GRAPHIC_URI_ALT =
+  "http://schemas.microsoft.com/office/drawing/2007/8/2/chart";
+const SMARTART_GRAPHIC_URI =
+  "http://schemas.microsoft.com/office/drawing/2007/8/2/diagram";
+const SMARTART_GRAPHIC_URI_ALT =
+  "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+const WPS_SHAPE_GRAPHIC_URI =
+  "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
+
+export interface ParseDrawingOpts {
+  relationships: readonly OpcRelationship[];
+  mediaParts?: ReadonlyMap<string, InlineMediaPart>;
+  sourcePartPath?: string;
+  chartPartLookup?: ChartPartLookup;
+  /**
+   * CO4 F3.3 — optional recursive parser for `w:txbxContent`. When supplied,
+   * parseDrawingFrame forwards it to parseShapeContent so shape text-boxes
+   * get fully-parsed block structure on `ShapeContent.txbxBlocks`. Without it
+   * only `txbxContentXml` raw preservation is populated.
+   */
+  blockParser?: TxbxBlockParser;
+}
+
+export function parseDrawingFrame(
+  drawingXml: string,
+  opts: ParseDrawingOpts,
+): 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);
+
+  // Find wp:anchor or wp:inline in the chosen branch
+  const anchor = findFirstDescendant(searchRoot, "anchor");
+  const inline = findFirstDescendant(searchRoot, "inline");
+  const container = anchor ?? inline;
+  if (!container) return null;
+
+  const geometry: AnchorGeometry = parseAnchorGeometry(container as never);
+
+  // Locate a:graphicData to determine content type
+  const graphicData = findFirstDescendant(searchRoot, "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.
+  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);
+
+  return { type: "drawing_frame", anchor: geometry, content };
+}
+
+function isKnownUri(uri: string): boolean {
+  return (
+    uri === PICTURE_GRAPHIC_URI ||
+    uri === CHART_GRAPHIC_URI ||
+    uri === CHART_GRAPHIC_URI_ALT ||
+    uri === SMARTART_GRAPHIC_URI ||
+    uri === SMARTART_GRAPHIC_URI_ALT ||
+    uri === WPS_SHAPE_GRAPHIC_URI
+  );
+}
+
+function isWordArtGraphicData(graphicData: XmlElementNode | undefined): boolean {
+  if (!graphicData) return false;
+  const wsp = findFirstDescendant(graphicData, "wsp");
+  const spPr = wsp ? findFirstChild(wsp, "spPr") : undefined;
+  const prstGeom = spPr ? findFirstChild(spPr, "prstGeom") : undefined;
+  const geometry = prstGeom?.attributes.prst ?? "";
+  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,
+  graphicData: XmlElementNode | undefined,
+  rawXml: string,
+  opts: ParseDrawingOpts,
+): DrawingFrameNode["content"] {
+  if (uri === PICTURE_GRAPHIC_URI) {
+    if (graphicData) {
+      const pic = parsePicture(graphicData as PictureXmlElement);
+      if (pic) {
+        // Resolve mediaId from the relationship map
+        const relMap = new Map(opts.relationships.map((r) => [r.id, r]));
+        const rel = relMap.get(pic.blipRef);
+        if (rel?.type.endsWith("/image")) {
+          const partPath = normalizePartPath(
+            resolveRelationshipTarget(opts.sourcePartPath ?? "/word/document.xml", rel),
+          );
+          pic.packagePartName = partPath;
+          pic.mediaId = `media:${partPath.slice(1)}`;
+        }
+        // F4.1 — preserve outer drawing XML for lossless round-trip serialization
+        pic.rawXml = rawXml;
+        return pic;
+      }
+    }
+    return { type: "opaque", rawXml };
+  }
+  if (uri === CHART_GRAPHIC_URI || uri === CHART_GRAPHIC_URI_ALT) {
+    return { type: "chart_preview", rawXml };
+  }
+  if (uri === SMARTART_GRAPHIC_URI || uri === SMARTART_GRAPHIC_URI_ALT) {
+    return { type: "smartart_preview", rawXml };
+  }
+  if (uri === WPS_SHAPE_GRAPHIC_URI) {
+    if (graphicData) {
+      const shape = parseShapeContent(
+        graphicData as PictureXmlElement,
+        rawXml,
+        opts.blockParser,
+      );
+      if (shape) return shape;
+    }
+    return { type: "opaque", rawXml };
+  }
+  void graphicData;
+  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};`;
+  });
+}