@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/io/ooxml/parse-main-document.ts

@@ -0,0 +1,1846 @@
+import type {
+  TextMark,
+  ParagraphBorders,
+  ParagraphShading,
+  ParagraphSpacing,
+  ParagraphIndentation,
+  TabStop,
+  TableLook,
+} from "../../model/canonical-document.ts";
+import type { OpcRelationship } from "./part-manifest.ts";
+import {
+  parseInlineMediaXml,
+  type InlineMediaPart,
+} from "./parse-inline-media.ts";
+import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
+
+export interface ParsedMainDocument {
+  blocks: ParsedBlockNode[];
+}
+
+export type ParsedBlockNode =
+  | ParsedParagraphNode
+  | ParsedTableBlockNode
+  | ParsedSdtNode
+  | ParsedCustomXmlNode
+  | ParsedAltChunkNode
+  | ParsedOpaqueBlockNode;
+
+export interface ParsedParagraphNode {
+  type: "paragraph";
+  styleId?: string;
+  numbering?: {
+    numberingInstanceId: string;
+    level: number;
+  };
+  alignment?: "left" | "center" | "right" | "both" | "distribute";
+  spacing?: ParagraphSpacing;
+  indentation?: ParagraphIndentation;
+  tabStops?: TabStop[];
+  keepNext?: boolean;
+  keepLines?: boolean;
+  outlineLevel?: number;
+  pageBreakBefore?: boolean;
+  widowControl?: boolean;
+  borders?: ParagraphBorders;
+  shading?: ParagraphShading;
+  bidi?: boolean;
+  suppressLineNumbers?: boolean;
+  cnfStyle?: string;
+  children: ParsedInlineNode[];
+  rawXml: string;
+}
+
+export type ParsedInlineNode =
+  | ParsedTextNode
+  | ParsedBreakNode
+  | ParsedColumnBreakNode
+  | ParsedTabNode
+  | ParsedSymbolNode
+  | ParsedImageNode
+  | ParsedHyperlinkNode
+  | ParsedOpaqueInlineNode;
+
+export interface ParsedTextNode {
+  type: "text";
+  text: string;
+  marks?: TextMark[];
+}
+
+export interface ParsedBreakNode {
+  type: "hard_break";
+}
+
+export interface ParsedColumnBreakNode {
+  type: "column_break";
+}
+
+export interface ParsedTabNode {
+  type: "tab";
+}
+
+export interface ParsedSymbolNode {
+  type: "symbol";
+  char: string;
+  font?: string;
+  marks?: TextMark[];
+}
+
+export interface ParsedImageNode {
+  type: "image";
+  mediaId: string;
+  relationshipId?: string;
+  packagePartName?: string;
+  contentType?: string;
+  filename?: string;
+  altText?: string;
+  placementXml?: string;
+  display?: "inline" | "floating";
+  floating?: {
+    horizontalPosition?: {
+      relativeFrom?: string;
+      align?: string;
+      offset?: number;
+    };
+    verticalPosition?: {
+      relativeFrom?: string;
+      align?: string;
+      offset?: number;
+    };
+    wrap?: "none" | "square" | "tight" | "through" | "topAndBottom";
+    behindDoc?: boolean;
+    layoutInCell?: boolean;
+    allowOverlap?: boolean;
+  };
+}
+
+export interface ParsedHyperlinkNode {
+  type: "hyperlink";
+  href: string;
+  children: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  rawXml: string;
+}
+
+export interface ParsedOpaqueInlineNode {
+  type: "opaque_inline";
+  rawXml: string;
+}
+
+export interface ParsedOpaqueBlockNode {
+  type: "opaque_block";
+  rawXml: string;
+}
+
+export interface ParsedSdtNode {
+  type: "sdt";
+  properties: {
+    sdtType?: string;
+    alias?: string;
+    tag?: string;
+    lock?: string;
+    propertiesXml?: string;
+  };
+  children: ParsedBlockNode[];
+  rawXml: string;
+}
+
+export interface ParsedCustomXmlNode {
+  type: "custom_xml";
+  uri?: string;
+  element?: string;
+  children: ParsedBlockNode[];
+  rawXml: string;
+}
+
+export interface ParsedAltChunkNode {
+  type: "alt_chunk";
+  relationshipId: string;
+  rawXml: string;
+}
+
+export interface ParsedTableBlockNode {
+  type: "table";
+  styleId?: string;
+  tblLook?: TableLook;
+  propertiesXml?: string;
+  gridColumns: number[];
+  rows: ParsedTableRowNode[];
+  rawXml: string;
+}
+
+export interface ParsedTableRowNode {
+  type: "table_row";
+  propertiesXml?: string;
+  cells: ParsedTableCellNode[];
+  rawXml: string;
+}
+
+export interface ParsedTableCellNode {
+  type: "table_cell";
+  propertiesXml?: string;
+  gridSpan?: number;
+  verticalMerge?: "restart" | "continue";
+  children: ParsedBlockNode[];
+  rawXml: string;
+}
+
+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;
+
+interface RunParseResult {
+  nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode>;
+  supported: boolean;
+}
+
+interface MarksParseResult {
+  marks: TextMark[];
+  supported: boolean;
+}
+
+const HYPERLINK_RELATIONSHIP_TYPE =
+  "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+
+export function parseMainDocumentXml(
+  xml: string,
+  relationships: readonly OpcRelationship[] = [],
+  mediaParts: ReadonlyMap<string, InlineMediaPart> = new Map(),
+  sourcePartPath = "/word/document.xml",
+): ParsedMainDocument {
+  const root = parseXml(xml);
+  const documentElement = findChildElement(root, "document");
+  const bodyElement = findChildElement(documentElement, "body");
+  const relationshipMap = new Map(relationships.map((relationship) => [relationship.id, relationship]));
+
+  return {
+    blocks: bodyElement.children
+      .filter((node): node is XmlElementNode => node.type === "element")
+      .map((node) => parseBodyChild(node, xml, relationshipMap, relationships, mediaParts, sourcePartPath)),
+  };
+}
+
+function parseBodyChild(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedBlockNode {
+  const nodeType = localName(node.name);
+
+  if (nodeType === "tbl") {
+    // Tables with revision markup (tracked changes inside cells) stay opaque
+    // to preserve fidelity until revision-aware table editing is implemented
+    const rawTableXml = sourceXml.slice(node.start, node.end);
+    if (tableRequiresOpaquePreservation(rawTableXml)) {
+      return {
+        type: "opaque_block",
+        rawXml: rawTableXml,
+      };
+    }
+    try {
+      return parseTableElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+    } catch {
+      // If table parsing fails for any reason, fall back to opaque preservation
+      return {
+        type: "opaque_block",
+        rawXml: rawTableXml,
+      };
+    }
+  }
+
+  if (nodeType === "sdt") {
+    return parseSdtElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+  }
+
+  if (nodeType === "customXml") {
+    return parseCustomXmlElement(node, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath);
+  }
+
+  if (nodeType === "altChunk") {
+    return parseAltChunkElement(node, sourceXml);
+  }
+
+  if (nodeType !== "p") {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  let styleId: string | undefined;
+  let numbering: ParsedParagraphNode["numbering"];
+  let alignment: ParsedParagraphNode["alignment"];
+  let spacing: ParsedParagraphNode["spacing"];
+  let indentation: ParsedParagraphNode["indentation"];
+  let tabStops: ParsedParagraphNode["tabStops"];
+  let keepNext: ParsedParagraphNode["keepNext"];
+  let keepLines: ParsedParagraphNode["keepLines"];
+  let outlineLevel: ParsedParagraphNode["outlineLevel"];
+  let pageBreakBefore: ParsedParagraphNode["pageBreakBefore"];
+  let widowControl: ParsedParagraphNode["widowControl"];
+  let borders: ParsedParagraphNode["borders"];
+  let shading: ParsedParagraphNode["shading"];
+  let bidi: ParsedParagraphNode["bidi"];
+  let suppressLineNumbers: ParsedParagraphNode["suppressLineNumbers"];
+  let cnfStyle: ParsedParagraphNode["cnfStyle"];
+  let paragraphSupported = true;
+  const children: ParsedInlineNode[] = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    switch (localName(child.name)) {
+      case "pPr":
+        styleId = readParagraphStyleId(child);
+        numbering = readParagraphNumbering(child);
+        alignment = readParagraphAlignment(child);
+        spacing = readParagraphSpacing(child);
+        indentation = readParagraphIndentation(child);
+        tabStops = readParagraphTabStops(child);
+        keepNext = readOnOffParagraphProperty(child, "keepNext");
+        keepLines = readOnOffParagraphProperty(child, "keepLines");
+        outlineLevel = readParagraphOutlineLevel(child);
+        pageBreakBefore = readOnOffParagraphProperty(child, "pageBreakBefore");
+        widowControl = readOnOffParagraphProperty(child, "widowControl");
+        borders = readParagraphBorders(child);
+        shading = readParagraphShading(child);
+        bidi = readOnOffParagraphProperty(child, "bidi");
+        suppressLineNumbers = readOnOffParagraphProperty(child, "suppressLineNumbers");
+        cnfStyle = readParagraphCnfStyle(child);
+        paragraphSupported = paragraphSupported && supportsParagraphProperties(child);
+        break;
+      case "r":
+        children.push(...parseRun(child, sourceXml, relationships, mediaParts, sourcePartPath));
+        break;
+      case "hyperlink": {
+        const hyperlink = parseHyperlink(child, sourceXml, relationshipMap);
+        children.push(hyperlink);
+        break;
+      }
+      case "ins":
+      case "del": {
+        children.push(...parseRevisionContainer(child, sourceXml, relationshipMap));
+        break;
+      }
+      case "commentRangeStart":
+      case "commentRangeEnd":
+        break;
+      case "bookmarkStart":
+      case "bookmarkEnd":
+      case "permStart":
+      case "permEnd":
+      case "proofErr":
+        children.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end),
+        });
+        break;
+      default:
+        children.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end),
+        });
+        break;
+    }
+  }
+
+  if (!paragraphSupported) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  return {
+    type: "paragraph",
+    styleId,
+    ...(numbering ? { numbering } : {}),
+    ...(alignment ? { alignment } : {}),
+    ...(spacing ? { spacing } : {}),
+    ...(indentation ? { indentation } : {}),
+    ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
+    ...(keepNext ? { keepNext } : {}),
+    ...(keepLines ? { keepLines } : {}),
+    ...(outlineLevel !== undefined ? { outlineLevel } : {}),
+    ...(pageBreakBefore ? { pageBreakBefore } : {}),
+    ...(widowControl ? { widowControl } : {}),
+    ...(borders ? { borders } : {}),
+    ...(shading ? { shading } : {}),
+    ...(bidi ? { bidi } : {}),
+    ...(suppressLineNumbers ? { suppressLineNumbers } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
+    children,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseTableElement(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedTableBlockNode {
+  let styleId: string | undefined;
+  let tblLook: TableLook | undefined;
+  let propertiesXml: string | undefined;
+  let gridColumns: number[] = [];
+  const rows: ParsedTableRowNode[] = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+
+    switch (localName(child.name)) {
+      case "tblPr": {
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        styleId = readTableStyleId(child);
+        tblLook = readTableLook(child);
+        break;
+      }
+      case "tblGrid": {
+        gridColumns = readTableGridColumns(child);
+        break;
+      }
+      case "tr": {
+        rows.push(parseTableRowElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+      }
+    }
+  }
+
+  return {
+    type: "table",
+    ...(styleId ? { styleId } : {}),
+    ...(tblLook ? { tblLook } : {}),
+    ...(propertiesXml ? { propertiesXml } : {}),
+    gridColumns,
+    rows,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseTableRowElement(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedTableRowNode {
+  let propertiesXml: string | undefined;
+  const cells: ParsedTableCellNode[] = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+
+    switch (localName(child.name)) {
+      case "trPr":
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        break;
+      case "tc":
+        cells.push(parseTableCellElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+    }
+  }
+
+  return {
+    type: "table_row",
+    ...(propertiesXml ? { propertiesXml } : {}),
+    cells,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseTableCellElement(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedTableCellNode {
+  let propertiesXml: string | undefined;
+  let gridSpan: number | undefined;
+  let verticalMerge: "restart" | "continue" | undefined;
+  const children: ParsedBlockNode[] = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+
+    switch (localName(child.name)) {
+      case "tcPr": {
+        propertiesXml = sourceXml.slice(child.start, child.end);
+        gridSpan = readCellGridSpan(child);
+        verticalMerge = readCellVerticalMerge(child);
+        break;
+      }
+      default: {
+        // Everything else in a cell is a block child (paragraphs, nested tables, etc.)
+        children.push(parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+        break;
+      }
+    }
+  }
+
+  return {
+    type: "table_cell",
+    ...(propertiesXml ? { propertiesXml } : {}),
+    ...(gridSpan ? { gridSpan } : {}),
+    ...(verticalMerge ? { verticalMerge } : {}),
+    children,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseSdtElement(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedBlockNode {
+  const propertiesNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "sdtPr",
+  );
+  const contentNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "sdtContent",
+  );
+
+  if (!contentNode) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  const children = contentNode.children
+    .filter((child): child is XmlElementNode => child.type === "element")
+    .map((child) => parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+
+  return {
+    type: "sdt",
+    properties: readSdtProperties(propertiesNode, sourceXml),
+    children,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseCustomXmlElement(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedBlockNode {
+  const uri = readOptionalAttribute(node, "uri");
+  const element = readOptionalAttribute(node, "element");
+  if (!uri && !element) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  const children = node.children
+    .filter(
+      (child): child is XmlElementNode =>
+        child.type === "element" && localName(child.name) !== "customXmlPr",
+    )
+    .map((child) => parseBodyChild(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
+
+  return {
+    type: "custom_xml",
+    ...(uri ? { uri } : {}),
+    ...(element ? { element } : {}),
+    children,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseAltChunkElement(
+  node: XmlElementNode,
+  sourceXml: string,
+): ParsedBlockNode {
+  const relationshipId = readOptionalAttribute(node, "id");
+  if (!relationshipId) {
+    return {
+      type: "opaque_block",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  return {
+    type: "alt_chunk",
+    relationshipId,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function readSdtProperties(
+  node: XmlElementNode | undefined,
+  sourceXml: string,
+): ParsedSdtNode["properties"] {
+  if (!node) {
+    return {};
+  }
+
+  const properties: ParsedSdtNode["properties"] = {
+    propertiesXml: sourceXml.slice(node.start, node.end),
+  };
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "alias") {
+      properties.alias = readOptionalAttribute(child, "val");
+      continue;
+    }
+    if (name === "tag") {
+      properties.tag = readOptionalAttribute(child, "val");
+      continue;
+    }
+    if (name === "lock") {
+      properties.lock = readOptionalAttribute(child, "val");
+      continue;
+    }
+    if (!properties.sdtType && name !== "id" && name !== "placeholder" && name !== "showingPlcHdr") {
+      properties.sdtType = name;
+    }
+  }
+
+  return properties;
+}
+
+function readTableStyleId(node: XmlElementNode): string | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element" || localName(child.name) !== "tblStyle") continue;
+    const styleId = child.attributes["w:val"] ?? child.attributes.val;
+    if (styleId) return styleId;
+  }
+  return undefined;
+}
+
+function readTableLook(node: XmlElementNode): TableLook | undefined {
+  const tblLookNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "tblLook",
+  );
+  if (!tblLookNode) {
+    return undefined;
+  }
+
+  const tableLook: TableLook = {};
+  const val = tblLookNode.attributes["w:val"] ?? tblLookNode.attributes.val;
+  if (val) {
+    tableLook.val = val;
+  }
+  for (const [attribute, key] of [
+    ["w:firstRow", "firstRow"],
+    ["w:lastRow", "lastRow"],
+    ["w:firstColumn", "firstColumn"],
+    ["w:lastColumn", "lastColumn"],
+    ["w:noHBand", "noHBand"],
+    ["w:noVBand", "noVBand"],
+  ] as const) {
+    const fallback = attribute.replace("w:", "");
+    const raw = tblLookNode.attributes[attribute] ?? tblLookNode.attributes[fallback];
+    if (raw !== undefined) {
+      tableLook[key] = raw !== "0" && raw !== "false" && raw !== "off";
+    }
+  }
+
+  return Object.keys(tableLook).length > 0 ? tableLook : undefined;
+}
+
+function readTableGridColumns(node: XmlElementNode): number[] {
+  return node.children
+    .filter((child): child is XmlElementNode => child.type === "element" && localName(child.name) === "gridCol")
+    .map((child) => {
+      const raw = child.attributes["w:w"] ?? child.attributes.w ?? "0";
+      const value = Number.parseInt(raw, 10);
+      return Number.isFinite(value) && value > 0 ? value : 0;
+    });
+}
+
+/**
+ * Check if a table's raw XML contains content that cannot safely round-trip
+ * through the parsed table path yet. This includes:
+ * - Revision markup (tracked changes inside cells)
+ * - Hyperlink relationships (original relationship IDs would be lost)
+ * - Comment ranges, bookmarks, and other annotation markup
+ *
+ * Tables matching this check stay opaque until the respective features
+ * are implemented in the table editing path.
+ */
+function tableRequiresOpaquePreservation(rawXml: string): boolean {
+  // For now, only parse tables that contain exclusively simple content
+  // (plain text, basic formatting). Any complex OOXML stays opaque.
+  // This list will shrink as the table editing path gains feature coverage.
+  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|hyperlink|commentRangeStart|commentRangeEnd|commentReference|bookmarkStart|bookmarkEnd|rStyle|pict|fldChar|fldSimple|smartTag|gridAfter|gridBefore|hideMark|tblHeader|tblCellSpacing|bCs)\b/.test(rawXml);
+}
+
+function readCellGridSpan(node: XmlElementNode): number | undefined {
+  const gridSpanNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "gridSpan",
+  );
+  if (!gridSpanNode) return undefined;
+  const raw = gridSpanNode.attributes["w:val"] ?? gridSpanNode.attributes.val;
+  const value = Number.parseInt(raw ?? "0", 10);
+  return Number.isFinite(value) && value > 1 ? value : undefined;
+}
+
+function readCellVerticalMerge(node: XmlElementNode): "restart" | "continue" | undefined {
+  const vMergeNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "vMerge",
+  );
+  if (!vMergeNode) return undefined;
+  const raw = (vMergeNode.attributes["w:val"] ?? vMergeNode.attributes.val ?? "continue").toLowerCase();
+  return raw === "restart" ? "restart" : "continue";
+}
+
+function readParagraphAlignment(node: XmlElementNode): ParsedParagraphNode["alignment"] {
+  const jcNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "jc",
+  );
+  if (!jcNode) return undefined;
+  const val = (jcNode.attributes["w:val"] ?? jcNode.attributes.val ?? "").toLowerCase();
+  if (val === "left" || val === "center" || val === "right" || val === "both" || val === "distribute") {
+    return val;
+  }
+  return undefined;
+}
+
+function readParagraphSpacing(node: XmlElementNode): ParagraphSpacing | undefined {
+  const spacingNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "spacing",
+  );
+  if (!spacingNode) return undefined;
+
+  const spacing: ParagraphSpacing = {};
+  const before = spacingNode.attributes["w:before"] ?? spacingNode.attributes.before;
+  const after = spacingNode.attributes["w:after"] ?? spacingNode.attributes.after;
+  const line = spacingNode.attributes["w:line"] ?? spacingNode.attributes.line;
+  const lineRule = spacingNode.attributes["w:lineRule"] ?? spacingNode.attributes.lineRule;
+
+  if (before !== undefined) {
+    const v = Number.parseInt(before, 10);
+    if (Number.isFinite(v)) spacing.before = v;
+  }
+  if (after !== undefined) {
+    const v = Number.parseInt(after, 10);
+    if (Number.isFinite(v)) spacing.after = v;
+  }
+  if (line !== undefined) {
+    const v = Number.parseInt(line, 10);
+    if (Number.isFinite(v)) spacing.line = v;
+  }
+  if (lineRule !== undefined) {
+    const lr = lineRule.toLowerCase();
+    if (lr === "auto" || lr === "exact") {
+      spacing.lineRule = lr;
+    } else if (lr === "atleast") {
+      spacing.lineRule = "atLeast";
+    }
+  }
+
+  if (
+    spacing.before === undefined &&
+    spacing.after === undefined &&
+    spacing.line === undefined &&
+    spacing.lineRule === undefined
+  ) {
+    return undefined;
+  }
+  return spacing;
+}
+
+function readParagraphIndentation(node: XmlElementNode): ParagraphIndentation | undefined {
+  const indNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "ind",
+  );
+  if (!indNode) return undefined;
+
+  const indentation: ParagraphIndentation = {};
+  const left = indNode.attributes["w:left"] ?? indNode.attributes.left;
+  const right = indNode.attributes["w:right"] ?? indNode.attributes.right;
+  const firstLine = indNode.attributes["w:firstLine"] ?? indNode.attributes.firstLine;
+  const hanging = indNode.attributes["w:hanging"] ?? indNode.attributes.hanging;
+
+  if (left !== undefined) {
+    const v = Number.parseInt(left, 10);
+    if (Number.isFinite(v)) indentation.left = v;
+  }
+  if (right !== undefined) {
+    const v = Number.parseInt(right, 10);
+    if (Number.isFinite(v)) indentation.right = v;
+  }
+  if (firstLine !== undefined) {
+    const v = Number.parseInt(firstLine, 10);
+    if (Number.isFinite(v)) indentation.firstLine = v;
+  }
+  if (hanging !== undefined) {
+    const v = Number.parseInt(hanging, 10);
+    if (Number.isFinite(v)) indentation.hanging = v;
+  }
+
+  if (
+    indentation.left === undefined &&
+    indentation.right === undefined &&
+    indentation.firstLine === undefined &&
+    indentation.hanging === undefined
+  ) {
+    return undefined;
+  }
+  return indentation;
+}
+
+function readParagraphTabStops(node: XmlElementNode): TabStop[] | undefined {
+  const tabsNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "tabs",
+  );
+  if (!tabsNode) return undefined;
+
+  const tabStops: TabStop[] = [];
+  for (const child of tabsNode.children) {
+    if (child.type !== "element" || localName(child.name) !== "tab") continue;
+    const pos = child.attributes["w:pos"] ?? child.attributes.pos;
+    const val = (child.attributes["w:val"] ?? child.attributes.val ?? "left").toLowerCase();
+    const leader = (child.attributes["w:leader"] ?? child.attributes.leader ?? "none").toLowerCase();
+
+    if (pos === undefined) continue;
+    const position = Number.parseInt(pos, 10);
+    if (!Number.isFinite(position)) continue;
+
+    const align = (["left", "center", "right", "decimal", "bar", "clear"] as const).includes(
+      val as "left" | "center" | "right" | "decimal" | "bar" | "clear",
+    )
+      ? (val as TabStop["align"])
+      : "left";
+
+    const leaderValue =
+      leader === "none" ||
+      leader === "dot" ||
+      leader === "hyphen" ||
+      leader === "underscore" ||
+      leader === "heavy"
+        ? (leader as Exclude<TabStop["leader"], "middleDot">)
+        : leader === "middledot"
+          ? "middleDot"
+          : undefined;
+
+    tabStops.push({
+      position,
+      align,
+      ...(leaderValue && leaderValue !== "none" ? { leader: leaderValue } : {}),
+    });
+  }
+
+  return tabStops.length > 0 ? tabStops : undefined;
+}
+
+function readOnOffParagraphProperty(node: XmlElementNode, name: string): boolean | undefined {
+  const propNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === name,
+  );
+  if (!propNode) return undefined;
+  const val = (propNode.attributes["w:val"] ?? propNode.attributes.val ?? "true").toLowerCase();
+  return val !== "false" && val !== "0" && val !== "off" ? true : undefined;
+}
+
+function readParagraphOutlineLevel(node: XmlElementNode): number | undefined {
+  const propNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "outlineLvl",
+  );
+  if (!propNode) return undefined;
+  const val = propNode.attributes["w:val"] ?? propNode.attributes.val;
+  if (val === undefined) return undefined;
+  const level = Number.parseInt(val, 10);
+  return Number.isFinite(level) ? level : undefined;
+}
+
+function readParagraphBorders(node: XmlElementNode): ParagraphBorders | undefined {
+  const borderContainer = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "pBdr",
+  );
+  if (!borderContainer) {
+    return undefined;
+  }
+
+  const borders: ParagraphBorders = {};
+  for (const [name, key] of [
+    ["top", "top"],
+    ["left", "left"],
+    ["bottom", "bottom"],
+    ["right", "right"],
+    ["bar", "bar"],
+    ["between", "between"],
+  ] as const) {
+    const borderNode = borderContainer.children.find(
+      (child): child is XmlElementNode => child.type === "element" && localName(child.name) === name,
+    );
+    if (borderNode) {
+      const border = readBorder(borderNode);
+      if (border) {
+        borders[key] = border;
+      }
+    }
+  }
+
+  return Object.keys(borders).length > 0 ? borders : undefined;
+}
+
+function readParagraphShading(node: XmlElementNode): ParagraphShading | undefined {
+  const shadingNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "shd",
+  );
+  if (!shadingNode) {
+    return undefined;
+  }
+
+  const shading: ParagraphShading = {};
+  const fill = shadingNode.attributes["w:fill"] ?? shadingNode.attributes.fill;
+  const color = shadingNode.attributes["w:color"] ?? shadingNode.attributes.color;
+  const val = shadingNode.attributes["w:val"] ?? shadingNode.attributes.val;
+  if (fill) shading.fill = fill;
+  if (color) shading.color = color;
+  if (val) shading.val = val;
+  return Object.keys(shading).length > 0 ? shading : undefined;
+}
+
+function readParagraphCnfStyle(node: XmlElementNode): string | undefined {
+  const cnfStyleNode = node.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "cnfStyle",
+  );
+  return cnfStyleNode?.attributes["w:val"] ?? cnfStyleNode?.attributes.val;
+}
+
+function readBorder(node: XmlElementNode): ParagraphBorders[keyof ParagraphBorders] {
+  const border: NonNullable<ParagraphBorders[keyof ParagraphBorders]> = {};
+  const value = node.attributes["w:val"] ?? node.attributes.val;
+  const size = node.attributes["w:sz"] ?? node.attributes.sz;
+  const space = node.attributes["w:space"] ?? node.attributes.space;
+  const color = node.attributes["w:color"] ?? node.attributes.color;
+  if (value) border.value = value;
+  if (size !== undefined) {
+    const parsedSize = Number.parseInt(size, 10);
+    if (Number.isFinite(parsedSize)) border.size = parsedSize;
+  }
+  if (space !== undefined) {
+    const parsedSpace = Number.parseInt(space, 10);
+    if (Number.isFinite(parsedSpace)) border.space = parsedSpace;
+  }
+  if (color) border.color = color;
+  return Object.keys(border).length > 0 ? border : undefined;
+}
+
+function readParagraphStyleId(node: XmlElementNode): string | undefined {
+  for (const child of node.children) {
+    if (child.type !== "element" || localName(child.name) !== "pStyle") {
+      continue;
+    }
+
+    const styleId = child.attributes["w:val"] ?? child.attributes.val;
+    if (styleId) {
+      return styleId;
+    }
+  }
+
+  return undefined;
+}
+
+function readParagraphNumbering(
+  node: XmlElementNode,
+): ParsedParagraphNode["numbering"] | undefined {
+  const numberingProperties = node.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "numPr",
+  );
+  if (!numberingProperties) {
+    return undefined;
+  }
+
+  const levelNode = numberingProperties.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "ilvl",
+  );
+  const instanceNode = numberingProperties.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "numId",
+  );
+  const rawLevel = levelNode?.attributes["w:val"] ?? levelNode?.attributes.val;
+  const rawInstanceId = instanceNode?.attributes["w:val"] ?? instanceNode?.attributes.val;
+  if (!rawInstanceId || rawLevel === undefined || !/^-?\d+$/.test(rawLevel)) {
+    return undefined;
+  }
+
+  return {
+    numberingInstanceId: toCanonicalNumberingInstanceId(rawInstanceId),
+    level: Number.parseInt(rawLevel, 10),
+  };
+}
+
+function parseRun(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): ParsedInlineNode[] {
+  const marksResult = readRunMarks(node, sourceXml);
+  if (!marksResult.supported) {
+    return [
+      {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end),
+      },
+    ];
+  }
+
+  const marks = marksResult.marks;
+  const result: ParsedInlineNode[] = [];
+  let encounteredUnsupportedChild = false;
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    switch (localName(child.name)) {
+      case "rPr":
+        break;
+      case "t": {
+        const text = child.children
+          .filter((entry): entry is XmlTextNode => entry.type === "text")
+          .map((entry) => entry.text)
+          .join("");
+        result.push({
+          type: "text",
+          text,
+          ...(marks.length > 0 ? { marks } : {}),
+        });
+        break;
+      }
+      case "tab":
+        result.push({ type: "tab" });
+        break;
+      case "sym": {
+        const symbol = parseSymbolNode(child, marks);
+        if (!symbol) {
+          encounteredUnsupportedChild = true;
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(child.start, child.end),
+          });
+          break;
+        }
+        result.push(symbol);
+        break;
+      }
+      case "br":
+        if (isColumnBreak(child)) {
+          result.push({ type: "column_break" });
+        } else if (isSimpleLineBreak(child)) {
+          result.push({ type: "hard_break" });
+        } else {
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(child.start, child.end),
+          });
+        }
+        break;
+      case "drawing": {
+        const parsedMedia = parseInlineMediaXml(
+          sourceXml.slice(child.start, child.end),
+          relationships,
+          mediaParts,
+          sourcePartPath,
+        );
+        if (parsedMedia.length === 0) {
+          encounteredUnsupportedChild = true;
+          result.push({
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end),
+          });
+          break;
+        }
+
+        const semanticChildren = node.children.filter(
+          (entry): entry is XmlElementNode =>
+            entry.type === "element" && localName(entry.name) !== "rPr",
+        );
+        const placementXml =
+          semanticChildren.length === 1
+            ? sourceXml.slice(node.start, node.end)
+            : sourceXml.slice(child.start, child.end);
+
+        result.push(
+          ...parsedMedia.map((media) => ({
+            type: "image" as const,
+            mediaId: media.mediaId,
+            relationshipId: media.relationshipId,
+            packagePartName: media.packagePartName,
+            contentType: media.contentType,
+            filename: media.filename,
+            ...(media.altText ? { altText: media.altText } : {}),
+            placementXml,
+            ...(media.display ? { display: media.display } : {}),
+            ...(media.floating ? { floating: media.floating } : {}),
+          })),
+        );
+        break;
+      }
+      case "commentReference":
+        break;
+      case "lastRenderedPageBreak":
+      case "proofErr":
+        result.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end),
+        });
+        break;
+      default:
+        encounteredUnsupportedChild = true;
+        result.push({
+          type: "opaque_inline",
+          rawXml: sourceXml.slice(child.start, child.end),
+        });
+        break;
+    }
+  }
+
+  if (encounteredUnsupportedChild && result.every((child) => child.type === "opaque_inline")) {
+    return [
+      {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end),
+      },
+    ];
+  }
+
+  return result;
+}
+
+function parseRevisionContainer(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+): ParsedInlineNode[] {
+  const result: ParsedInlineNode[] = [];
+  const allowsDeletedText = localName(node.name) === "del";
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    switch (localName(child.name)) {
+      case "r": {
+        const run = parseRunContentOnly(child, sourceXml, {
+          allowDeletedText: allowsDeletedText,
+          preserveUnsupportedReviewMarkup: true,
+        });
+        if (!run.supported) {
+          return [
+            {
+              type: "opaque_inline",
+              rawXml: sourceXml.slice(node.start, node.end),
+            },
+          ];
+        }
+        result.push(...run.nodes);
+        break;
+      }
+      case "hyperlink": {
+        const hyperlink = parseHyperlink(child, sourceXml, relationshipMap, {
+          allowDeletedText: allowsDeletedText,
+          preserveUnsupportedReviewMarkup: true,
+        });
+        if (hyperlink.type === "opaque_inline") {
+          return [
+            {
+              type: "opaque_inline",
+              rawXml: sourceXml.slice(node.start, node.end),
+            },
+          ];
+        }
+        result.push(hyperlink);
+        break;
+      }
+      case "commentRangeStart":
+      case "commentRangeEnd":
+      case "bookmarkStart":
+      case "bookmarkEnd":
+      case "permStart":
+      case "permEnd":
+      case "proofErr":
+      case "lastRenderedPageBreak":
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end),
+          },
+        ];
+      default:
+        return [
+          {
+            type: "opaque_inline",
+            rawXml: sourceXml.slice(node.start, node.end),
+          },
+        ];
+    }
+  }
+
+  return result;
+}
+
+function parseHyperlink(
+  node: XmlElementNode,
+  sourceXml: string,
+  relationshipMap: Map<string, OpcRelationship>,
+  options: {
+    allowDeletedText?: boolean;
+    preserveUnsupportedReviewMarkup?: boolean;
+  } = {},
+): ParsedHyperlinkNode | ParsedOpaqueInlineNode {
+  const relationshipId = node.attributes["r:id"] ?? node.attributes.id;
+  const anchor = node.attributes["w:anchor"] ?? node.attributes.anchor;
+  let href: string | undefined;
+
+  if (relationshipId) {
+    const relationship = relationshipMap.get(relationshipId);
+    if (
+      relationship &&
+      relationship.type === HYPERLINK_RELATIONSHIP_TYPE &&
+      relationship.targetMode === "external"
+    ) {
+      href = relationship.target;
+    }
+  } else if (anchor) {
+    href = `#${anchor}`;
+  }
+
+  if (!href) {
+    return {
+      type: "opaque_inline",
+      rawXml: sourceXml.slice(node.start, node.end),
+    };
+  }
+
+  const children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode> = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    if (localName(child.name) !== "r") {
+      return {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end),
+      };
+    }
+
+    const run = parseRunContentOnly(child, sourceXml, {
+      allowDeletedText: options.allowDeletedText,
+      preserveUnsupportedReviewMarkup: options.preserveUnsupportedReviewMarkup,
+    });
+    if (!run.supported) {
+      return {
+        type: "opaque_inline",
+        rawXml: sourceXml.slice(node.start, node.end),
+      };
+    }
+
+    children.push(...run.nodes);
+  }
+
+  return {
+    type: "hyperlink",
+    href,
+    children,
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parseRunContentOnly(
+  node: XmlElementNode,
+  _sourceXml: string,
+  options: {
+    allowDeletedText?: boolean;
+    preserveUnsupportedReviewMarkup?: boolean;
+  } = {},
+): RunParseResult {
+  const marksResult = readRunMarks(node, _sourceXml);
+  if (!marksResult.supported) {
+    return { nodes: [], supported: false };
+  }
+
+  const marks = marksResult.marks;
+  const nodes: Array<ParsedTextNode | ParsedBreakNode | ParsedColumnBreakNode | ParsedTabNode | ParsedSymbolNode> = [];
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    switch (localName(child.name)) {
+      case "rPr":
+        break;
+      case "t": {
+        const text = child.children
+          .filter((entry): entry is XmlTextNode => entry.type === "text")
+          .map((entry) => entry.text)
+          .join("");
+        nodes.push({
+          type: "text",
+          text,
+          ...(marks.length > 0 ? { marks } : {}),
+        });
+        break;
+      }
+      case "delText":
+      case "delInstrText":
+        if (!options.allowDeletedText) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push({
+          type: "text",
+          text: child.children
+            .filter((entry): entry is XmlTextNode => entry.type === "text")
+            .map((entry) => entry.text)
+            .join(""),
+          ...(marks.length > 0 ? { marks } : {}),
+        });
+        break;
+      case "tab":
+        nodes.push({ type: "tab" });
+        break;
+      case "sym": {
+        const symbol = parseSymbolNode(child, marks);
+        if (!symbol) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push(symbol);
+        break;
+      }
+      case "br":
+        if (isColumnBreak(child)) {
+          nodes.push({ type: "column_break" });
+          break;
+        }
+        if (!isSimpleLineBreak(child)) {
+          return { nodes: [], supported: false };
+        }
+        nodes.push({ type: "hard_break" });
+        break;
+      case "commentReference":
+      case "lastRenderedPageBreak":
+      case "proofErr":
+        if (options.preserveUnsupportedReviewMarkup) {
+          return { nodes: [], supported: false };
+        }
+        break;
+      default:
+        return { nodes: [], supported: false };
+    }
+  }
+
+  return { nodes, supported: true };
+}
+
+function readRunMarks(node: XmlElementNode, sourceXml: string): MarksParseResult {
+  const properties = node.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "rPr",
+  );
+
+  if (!properties) {
+    return { marks: [], supported: true };
+  }
+
+  if (
+    properties.children.some(
+      (child) =>
+        child.type === "element" &&
+        DISALLOWED_RUN_PROPERTY_NAMES.has(localName(child.name)),
+    )
+  ) {
+    return {
+      marks: [],
+      supported: false,
+    };
+  }
+
+  const marks: TextMark[] = [];
+  if (hasOnOffProperty(properties, "b")) {
+    marks.push({ type: "bold" });
+  }
+  if (hasOnOffProperty(properties, "i")) {
+    marks.push({ type: "italic" });
+  }
+  if (hasUnderlineProperty(properties)) {
+    marks.push({ type: "underline" });
+  }
+  if (hasOnOffProperty(properties, "strike")) {
+    marks.push({ type: "strikethrough" });
+  }
+  if (hasOnOffProperty(properties, "dstrike")) {
+    marks.push({ type: "doubleStrikethrough" });
+  }
+  if (hasOnOffProperty(properties, "vanish")) {
+    marks.push({ type: "vanish" });
+  }
+
+  const langMark = readRunLang(properties);
+  if (langMark) {
+    marks.push(langMark);
+  }
+
+  const backgroundColorMark = readRunBackgroundColor(properties);
+  if (backgroundColorMark) {
+    marks.push(backgroundColorMark);
+  }
+
+  const charSpacingMark = readNumericRunMark(properties, "spacing", "charSpacing");
+  if (charSpacingMark) {
+    marks.push(charSpacingMark);
+  }
+
+  const kerningMark = readNumericRunMark(properties, "kern", "kerning");
+  if (kerningMark) {
+    marks.push(kerningMark);
+  }
+
+  const positionMark = readNumericRunMark(properties, "position", "position");
+  if (positionMark) {
+    marks.push(positionMark);
+  }
+
+  if (hasOnOffProperty(properties, "emboss")) {
+    marks.push({ type: "emboss" });
+  }
+  if (hasOnOffProperty(properties, "imprint")) {
+    marks.push({ type: "imprint" });
+  }
+  if (hasOnOffProperty(properties, "shadow")) {
+    marks.push({ type: "shadow" });
+  }
+
+  const textFillMark = readRunTextFill(properties, sourceXml);
+  if (textFillMark) {
+    marks.push(textFillMark);
+  }
+
+  return {
+    marks,
+    supported: true,
+  };
+}
+
+function readRunLang(properties: XmlElementNode): TextMark | undefined {
+  const langNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "lang",
+  );
+  if (!langNode) return undefined;
+  const val =
+    langNode.attributes["w:val"] ??
+    langNode.attributes.val ??
+    langNode.attributes["w:bidi"] ??
+    langNode.attributes.bidi;
+  if (!val) return undefined;
+  return { type: "lang", val };
+}
+
+function readRunBackgroundColor(properties: XmlElementNode): TextMark | undefined {
+  const shadingNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "shd",
+  );
+  if (!shadingNode) {
+    return undefined;
+  }
+
+  const fill = shadingNode.attributes["w:fill"] ?? shadingNode.attributes.fill;
+  if (!fill || fill === "auto") {
+    return undefined;
+  }
+
+  return { type: "backgroundColor", color: fill };
+}
+
+function readNumericRunMark(
+  properties: XmlElementNode,
+  elementName: "spacing" | "kern" | "position",
+  markType: "charSpacing" | "kerning" | "position",
+): TextMark | undefined {
+  const propertyNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === elementName,
+  );
+  if (!propertyNode) {
+    return undefined;
+  }
+  const rawValue = propertyNode.attributes["w:val"] ?? propertyNode.attributes.val;
+  if (rawValue === undefined) {
+    return undefined;
+  }
+  const value = Number.parseInt(rawValue, 10);
+  if (!Number.isFinite(value)) {
+    return undefined;
+  }
+  return { type: markType, val: value };
+}
+
+function readRunTextFill(properties: XmlElementNode, sourceXml: string): TextMark | undefined {
+  const textFillNode = properties.children.find(
+    (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "textFill",
+  );
+  if (!textFillNode) {
+    return undefined;
+  }
+  return {
+    type: "textFill",
+    xml: sourceXml.slice(textFillNode.start, textFillNode.end),
+  };
+}
+
+function parseSymbolNode(
+  node: XmlElementNode,
+  marks: TextMark[],
+): ParsedSymbolNode | undefined {
+  const char = node.attributes["w:char"] ?? node.attributes.char;
+  if (!char) {
+    return undefined;
+  }
+  const font = node.attributes["w:font"] ?? node.attributes.font;
+  return {
+    type: "symbol",
+    char,
+    ...(font ? { font } : {}),
+    ...(marks.length > 0 ? { marks } : {}),
+  };
+}
+
+function supportsParagraphProperties(node: XmlElementNode): boolean {
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "pPrChange") {
+      return false;
+    }
+
+    if (name === "rPr") {
+      if (
+        child.children.some(
+          (entry) =>
+            entry.type === "element" &&
+            DISALLOWED_PARAGRAPH_PROPERTY_NAMES.has(localName(entry.name)),
+        )
+      ) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+const DISALLOWED_RUN_PROPERTY_NAMES = new Set(["rPrChange"]);
+const DISALLOWED_PARAGRAPH_PROPERTY_NAMES = new Set(["pPrChange", "rPrChange"]);
+
+function hasOnOffProperty(properties: XmlElementNode, propertyName: string): boolean {
+  const property = properties.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === propertyName,
+  );
+  if (!property) {
+    return false;
+  }
+
+  const value = (property.attributes["w:val"] ?? property.attributes.val ?? "true").toLowerCase();
+  return value !== "false" && value !== "0" && value !== "off";
+}
+
+function hasUnderlineProperty(properties: XmlElementNode): boolean {
+  const property = properties.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "u",
+  );
+  if (!property) {
+    return false;
+  }
+
+  const value = (property.attributes["w:val"] ?? property.attributes.val ?? "single").toLowerCase();
+  return value !== "none";
+}
+
+function isSimpleLineBreak(node: XmlElementNode): boolean {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "textWrapping").toLowerCase();
+  return value === "textwrapping" || value === "line";
+}
+
+function isColumnBreak(node: XmlElementNode): boolean {
+  const value = (node.attributes["w:type"] ?? node.attributes.type ?? "").toLowerCase();
+  return value === "column";
+}
+
+function findChildElement(node: XmlElementNode, childLocalName: string): XmlElementNode {
+  const child = node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+
+  if (!child) {
+    throw new Error(`Expected <${childLocalName}> element in main document XML.`);
+  }
+
+  return child;
+}
+
+function localName(name: string): string {
+  const separatorIndex = name.indexOf(":");
+  return separatorIndex >= 0 ? name.slice(separatorIndex + 1) : name;
+}
+
+function readOptionalAttribute(node: XmlElementNode, name: string): string | undefined {
+  return node.attributes[`w:${name}`]
+    ?? node.attributes[`r:${name}`]
+    ?? node.attributes[name];
+}
+
+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;
+    }
+
+    const currentChar = xml[cursor];
+    if (currentChar !== "<") {
+      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 closing >.");
+      }
+
+      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 in main document XML.");
+  }
+
+  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;
+    }
+    const rawValue = tagBody.slice(valueStart, cursor);
+    attributes[key] = decodeXmlEntities(rawValue);
+    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 current = xml[cursor];
+    if (quote) {
+      if (current === quote) {
+        quote = null;
+      }
+      cursor += 1;
+      continue;
+    }
+
+    if (current === `"` || current === `'`) {
+      quote = current;
+      cursor += 1;
+      continue;
+    }
+
+    if (current === ">") {
+      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;
+    }
+  });
+}