@beyondwork/docx-react-component 1.0.18 → 1.0.20

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

@@ -1,4 +1,5 @@
 import type {
+  BorderSpec,
   TextMark,
   ParagraphBorders,
   ParagraphShading,
@@ -6,6 +7,16 @@ import type {
   ParagraphIndentation,
   TabStop,
   TableLook,
+  SectionProperties,
+  PageSize,
+  PageMargins,
+  ColumnProperties,
+  PageNumbering,
+  HeaderFooterReference,
+  HeaderFooterVariant,
+  SectionDocumentGrid,
+  SectionLineNumbering,
+  SectionPageBorders,
 } from "../../model/canonical-document.ts";
 import type { OpcRelationship } from "./part-manifest.ts";
 import {
@@ -15,9 +26,12 @@ import {
 import { toCanonicalNumberingInstanceId } from "./parse-numbering.ts";
 import { parseComplexContentXml } from "./parse-complex-content.ts";
 import { parseShapeXml, parseVmlXml } from "./parse-shapes.ts";
+import { classifyFieldInstruction } from "./parse-fields.ts";
+import { resolveHighlightColor } from "./highlight-colors.ts";
 
 export interface ParsedMainDocument {
   blocks: ParsedBlockNode[];
+  finalSectionProperties?: SectionProperties;
 }
 
 export type ParsedBlockNode =
@@ -26,8 +40,15 @@ export type ParsedBlockNode =
   | ParsedSdtNode
   | ParsedCustomXmlNode
   | ParsedAltChunkNode
+  | ParsedSectionBreakNode
   | ParsedOpaqueBlockNode;
 
+export interface ParsedSectionBreakNode {
+  type: "section_break";
+  sectionPropertiesXml: string;
+  sectionProperties: SectionProperties;
+}
+
 export interface ParsedParagraphNode {
   type: "paragraph";
   styleId?: string;
@@ -37,6 +58,7 @@ export interface ParsedParagraphNode {
   };
   alignment?: "left" | "center" | "right" | "both" | "distribute";
   spacing?: ParagraphSpacing;
+  contextualSpacing?: boolean;
   indentation?: ParagraphIndentation;
   tabStops?: TabStop[];
   keepNext?: boolean;
@@ -49,6 +71,8 @@ export interface ParsedParagraphNode {
   bidi?: boolean;
   suppressLineNumbers?: boolean;
   cnfStyle?: string;
+  sectionProperties?: SectionProperties;
+  sectionPropertiesXml?: string;
   children: ParsedInlineNode[];
   rawXml: string;
 }
@@ -69,7 +93,10 @@ export type ParsedInlineNode =
   | ParsedVmlShapeInlineNode
   | ParsedBookmarkStartInlineNode
   | ParsedBookmarkEndInlineNode
-  | ParsedFieldInlineNode;
+  | ParsedFootnoteRefInlineNode
+  | ParsedFieldInlineNode
+  | ParsedPermStartInlineNode
+  | ParsedPermEndInlineNode;
 
 export interface ParsedTextNode {
   type: "text";
@@ -104,6 +131,8 @@ export interface ParsedImageNode {
   contentType?: string;
   filename?: string;
   altText?: string;
+  widthEmu?: number;
+  heightEmu?: number;
   placementXml?: string;
   display?: "inline" | "floating";
   floating?: {
@@ -152,6 +181,7 @@ export interface ParsedShapeInlineNode {
   type: "shape";
   text?: string;
   geometry?: string;
+  isTextBox?: boolean;
   rawXml: string;
 }
 
@@ -182,11 +212,32 @@ export interface ParsedBookmarkEndInlineNode {
   rawXml: string;
 }
 
+export interface ParsedFootnoteRefInlineNode {
+  type: "footnote_ref";
+  noteId: string;
+  noteKind: "footnote" | "endnote";
+}
+
 export interface ParsedFieldInlineNode {
   type: "field";
-  fieldType: "simple";
+  fieldType: "simple" | "complex";
   instruction: string;
-  contentXml: string;
+  contentXml?: string;
+  children?: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
+  rawXml: string;
+}
+
+export interface ParsedPermStartInlineNode {
+  type: "perm_start";
+  rangeId: string;
+  editorGroup?: string;
+  editor?: string;
+  rawXml: string;
+}
+
+export interface ParsedPermEndInlineNode {
+  type: "perm_end";
+  rangeId: string;
   rawXml: string;
 }
 
@@ -195,6 +246,23 @@ export interface ParsedOpaqueBlockNode {
   rawXml: string;
 }
 
+export interface ParsedSdtCheckboxState {
+  checked: boolean;
+  checkedChar?: string;
+  uncheckedChar?: string;
+}
+
+export interface ParsedSdtDatePickerState {
+  fullDate?: string;
+  dateFormat?: string;
+  lid?: string;
+}
+
+export interface ParsedSdtDropdownListItem {
+  displayText?: string;
+  value: string;
+}
+
 export interface ParsedSdtNode {
   type: "sdt";
   properties: {
@@ -203,6 +271,11 @@ export interface ParsedSdtNode {
     tag?: string;
     lock?: string;
     propertiesXml?: string;
+    checkbox?: ParsedSdtCheckboxState;
+    datePicker?: ParsedSdtDatePickerState;
+    dropdownList?: ParsedSdtDropdownListItem[];
+    comboBox?: ParsedSdtDropdownListItem[];
+    showingPlcHdr?: boolean;
   };
   children: ParsedBlockNode[];
   rawXml: string;
@@ -290,11 +363,24 @@ export function parseMainDocumentXml(
   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)),
-  };
+  const allBlocks = bodyElement.children
+    .filter((node): node is XmlElementNode => node.type === "element")
+    .map((node) => parseBodyChild(node, xml, relationshipMap, relationships, mediaParts, sourcePartPath));
+
+  // The last body-level sectPr is the final section properties (not an intermediate section break).
+  // Extract it from the blocks list and store it separately.
+  let finalSectionProperties: SectionProperties | undefined;
+  const blocks: ParsedBlockNode[] = [];
+  for (let i = 0; i < allBlocks.length; i++) {
+    const block = allBlocks[i];
+    if (block.type === "section_break" && i === allBlocks.length - 1) {
+      finalSectionProperties = block.sectionProperties;
+    } else {
+      blocks.push(block);
+    }
+  }
+
+  return { blocks, finalSectionProperties };
 }
 
 function parseBodyChild(
@@ -340,6 +426,10 @@ function parseBodyChild(
     return parseAltChunkElement(node, sourceXml);
   }
 
+  if (nodeType === "sectPr") {
+    return parseSectionBreakElement(node, sourceXml);
+  }
+
   if (nodeType !== "p") {
     return {
       type: "opaque_block",
@@ -351,6 +441,7 @@ function parseBodyChild(
   let numbering: ParsedParagraphNode["numbering"];
   let alignment: ParsedParagraphNode["alignment"];
   let spacing: ParsedParagraphNode["spacing"];
+  let contextualSpacing: ParsedParagraphNode["contextualSpacing"];
   let indentation: ParsedParagraphNode["indentation"];
   let tabStops: ParsedParagraphNode["tabStops"];
   let keepNext: ParsedParagraphNode["keepNext"];
@@ -363,8 +454,15 @@ function parseBodyChild(
   let bidi: ParsedParagraphNode["bidi"];
   let suppressLineNumbers: ParsedParagraphNode["suppressLineNumbers"];
   let cnfStyle: ParsedParagraphNode["cnfStyle"];
+  let sectionProperties: SectionProperties | undefined;
+  let sectionPropertiesXml: string | undefined;
   let paragraphSupported = true;
   const children: ParsedInlineNode[] = [];
+  let activeComplexField: {
+    instruction: string;
+    children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
+    mode: "instruction" | "result";
+  } | null = null;
 
   for (const child of node.children) {
     if (child.type !== "element") {
@@ -377,6 +475,7 @@ function parseBodyChild(
         numbering = readParagraphNumbering(child);
         alignment = readParagraphAlignment(child);
         spacing = readParagraphSpacing(child);
+        contextualSpacing = readOptionalOnOffParagraphProperty(child, "contextualSpacing");
         indentation = readParagraphIndentation(child);
         tabStops = readParagraphTabStops(child);
         keepNext = readOnOffParagraphProperty(child, "keepNext");
@@ -389,36 +488,153 @@ function parseBodyChild(
         bidi = readOnOffParagraphProperty(child, "bidi");
         suppressLineNumbers = readOnOffParagraphProperty(child, "suppressLineNumbers");
         cnfStyle = readParagraphCnfStyle(child);
+        sectionProperties = readSectionPropertiesFromPPr(child);
+        sectionPropertiesXml = readSectionPropertiesXmlFromPPr(child, sourceXml);
         paragraphSupported = paragraphSupported && supportsParagraphProperties(child);
         break;
       case "r":
-        children.push(...parseRun(child, sourceXml, relationships, mediaParts, sourcePartPath));
+        activeComplexField = appendParagraphRunNodes(
+          child,
+          children,
+          activeComplexField,
+          sourceXml,
+          relationships,
+          mediaParts,
+          sourcePartPath,
+        );
         break;
       case "hyperlink": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
         const hyperlink = parseHyperlink(child, sourceXml, relationshipMap);
         children.push(hyperlink);
         break;
       }
       case "ins":
       case "del": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
         children.push(...parseRevisionContainer(child, sourceXml, relationshipMap));
         break;
       }
       case "commentRangeStart":
       case "commentRangeEnd":
         break;
-      case "bookmarkStart":
-      case "bookmarkEnd":
-      case "fldSimple":
-      case "permStart":
-      case "permEnd":
+      case "bookmarkStart": {
+        const bkId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        const bkName = child.attributes["w:name"] ?? child.attributes.name ?? "";
+        if (bkId) {
+          const bookmarkNode = {
+            type: "bookmark_start",
+            bookmarkId: bkId,
+            name: bkName,
+            rawXml: sourceXml.slice(child.start, child.end),
+          } as ParsedBookmarkStartInlineNode;
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push(bookmarkNode);
+        } else {
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push({ type: "opaque_inline", rawXml: sourceXml.slice(child.start, child.end) });
+        }
+        break;
+      }
+      case "bookmarkEnd": {
+        const bkEndId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (bkEndId) {
+          const bookmarkNode = {
+            type: "bookmark_end",
+            bookmarkId: bkEndId,
+            rawXml: sourceXml.slice(child.start, child.end),
+          } as ParsedBookmarkEndInlineNode;
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push(bookmarkNode);
+        } else {
+          flushActiveComplexField(children, () => {
+            activeComplexField = null;
+          }, activeComplexField);
+          children.push({ type: "opaque_inline", rawXml: sourceXml.slice(child.start, child.end) });
+        }
+        break;
+      }
+      case "fldSimple": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const fieldInstr = child.attributes["w:instr"] ?? child.attributes.instr ?? "";
+        const fieldContentXml = child.children
+          .filter((c): c is XmlElementNode => c.type === "element")
+          .map((c) => sourceXml.slice(c.start, c.end))
+          .join("");
+        children.push({
+          type: "field",
+          fieldType: "simple",
+          instruction: fieldInstr,
+          contentXml: fieldContentXml,
+          rawXml: sourceXml.slice(child.start, child.end),
+        } as ParsedFieldInlineNode);
+        break;
+      }
       case "proofErr":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
         children.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
         });
         break;
+      case "permStart":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push(parsePermStartNode(child, sourceXml));
+        break;
+      case "permEnd":
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        children.push(parsePermEndNode(child, sourceXml));
+        break;
+      case "footnoteReference": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          children.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "footnote",
+          });
+        }
+        break;
+      }
+      case "endnoteReference": {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          children.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "endnote",
+          });
+        }
+        break;
+      }
       default:
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
         children.push({
           type: "opaque_inline",
           rawXml: sourceXml.slice(child.start, child.end),
@@ -427,6 +643,10 @@ function parseBodyChild(
     }
   }
 
+  flushActiveComplexField(children, () => {
+    activeComplexField = null;
+  }, activeComplexField);
+
   if (!paragraphSupported) {
     return {
       type: "opaque_block",
@@ -440,6 +660,7 @@ function parseBodyChild(
     ...(numbering ? { numbering } : {}),
     ...(alignment ? { alignment } : {}),
     ...(spacing ? { spacing } : {}),
+    ...(contextualSpacing !== undefined ? { contextualSpacing } : {}),
     ...(indentation ? { indentation } : {}),
     ...(tabStops && tabStops.length > 0 ? { tabStops } : {}),
     ...(keepNext ? { keepNext } : {}),
@@ -452,11 +673,121 @@ function parseBodyChild(
     ...(bidi ? { bidi } : {}),
     ...(suppressLineNumbers ? { suppressLineNumbers } : {}),
     ...(cnfStyle ? { cnfStyle } : {}),
+    ...(sectionProperties ? { sectionProperties } : {}),
+    ...(sectionPropertiesXml ? { sectionPropertiesXml } : {}),
     children,
     rawXml: sourceXml.slice(node.start, node.end),
   };
 }
 
+function appendParagraphRunNodes(
+  node: XmlElementNode,
+  children: ParsedInlineNode[],
+  activeComplexField: {
+    instruction: string;
+    children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
+    mode: "instruction" | "result";
+  } | null,
+  sourceXml: string,
+  relationships: readonly OpcRelationship[],
+  mediaParts: ReadonlyMap<string, InlineMediaPart>,
+  sourcePartPath: string,
+): {
+  instruction: string;
+  children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
+  mode: "instruction" | "result";
+} | null {
+  const hasFieldMarkers = node.children.some(
+    (child) =>
+      child.type === "element" &&
+      (localName(child.name) === "fldChar" || localName(child.name) === "instrText"),
+  );
+
+  if (activeComplexField?.mode === "result" && !hasFieldMarkers) {
+    const run = parseRunContentOnly(node, sourceXml);
+    if (
+      run.supported &&
+      run.nodes.every(
+        (child) =>
+          child.type === "text" || child.type === "hard_break" || child.type === "tab",
+      )
+    ) {
+      activeComplexField.children.push(...run.nodes);
+      return activeComplexField;
+    }
+  }
+
+  if (!hasFieldMarkers) {
+    children.push(...parseRun(node, sourceXml, relationships, mediaParts, sourcePartPath));
+    return activeComplexField;
+  }
+
+  for (const child of node.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+    if (name === "fldChar") {
+      const fldType = child.attributes["w:fldCharType"] ?? child.attributes.fldCharType;
+      if (fldType === "begin") {
+        activeComplexField = { instruction: "", children: [], mode: "instruction" };
+      } else if (fldType === "separate" && activeComplexField) {
+        activeComplexField.mode = "result";
+      } else if (fldType === "end" && activeComplexField) {
+        flushActiveComplexField(children, () => {
+          activeComplexField = null;
+        }, activeComplexField);
+      }
+      continue;
+    }
+
+    if (name === "instrText") {
+      const instruction = child.children
+        .filter((entry): entry is XmlTextNode => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("");
+      if (activeComplexField) {
+        activeComplexField.instruction += instruction;
+      } else if (instruction.trim().length > 0) {
+        children.push({
+          type: "field",
+          fieldType: "complex",
+          instruction,
+          children: [],
+          rawXml: sourceXml.slice(node.start, node.end),
+        });
+      }
+      continue;
+    }
+  }
+
+  return activeComplexField;
+}
+
+function flushActiveComplexField(
+  children: ParsedInlineNode[],
+  reset: () => void,
+  activeComplexField: {
+    instruction: string;
+    children: Array<ParsedTextNode | ParsedBreakNode | ParsedTabNode>;
+    mode: "instruction" | "result";
+  } | null,
+): void {
+  if (!activeComplexField || activeComplexField.instruction.trim().length === 0) {
+    return;
+  }
+
+  children.push({
+    type: "field",
+    fieldType: "complex",
+    instruction: activeComplexField.instruction,
+    children: activeComplexField.children,
+    rawXml: "",
+  });
+  reset();
+}
+
 function parseTableElement(
   node: XmlElementNode,
   sourceXml: string,
@@ -692,7 +1023,68 @@ function readSdtProperties(
       properties.lock = readOptionalAttribute(child, "val");
       continue;
     }
-    if (!properties.sdtType && name !== "id" && name !== "placeholder" && name !== "showingPlcHdr") {
+    if (name === "showingPlcHdr") {
+      const val = readOptionalAttribute(child, "val");
+      properties.showingPlcHdr = val !== "false" && val !== "0";
+      continue;
+    }
+
+    // Checkbox (w14:checkbox)
+    if (name === "checkbox") {
+      properties.sdtType = "checkbox";
+      const checkedNode = findFirstDescendant(child, "checked");
+      const checkedVal = checkedNode ? (readOptionalAttribute(checkedNode, "val") ?? "0") : "0";
+      const checkedCharNode = findFirstDescendant(child, "checkedState");
+      const uncheckedCharNode = findFirstDescendant(child, "uncheckedState");
+      properties.checkbox = {
+        checked: checkedVal === "1" || checkedVal === "true",
+        ...(checkedCharNode ? { checkedChar: readOptionalAttribute(checkedCharNode, "val") } : {}),
+        ...(uncheckedCharNode ? { uncheckedChar: readOptionalAttribute(uncheckedCharNode, "val") } : {}),
+      };
+      continue;
+    }
+
+    // Date picker
+    if (name === "date") {
+      properties.sdtType = "date";
+      const fullDate = readOptionalAttribute(child, "fullDate");
+      const dateFormatNode = findFirstChild(child, "dateFormat");
+      const lidNode = findFirstChild(child, "lid");
+      properties.datePicker = {
+        ...(fullDate ? { fullDate } : {}),
+        ...(dateFormatNode ? { dateFormat: readOptionalAttribute(dateFormatNode, "val") } : {}),
+        ...(lidNode ? { lid: readOptionalAttribute(lidNode, "val") } : {}),
+      };
+      continue;
+    }
+
+    // Dropdown list
+    if (name === "dropDownList") {
+      properties.sdtType = "dropDownList";
+      properties.dropdownList = readSdtListItems(child);
+      continue;
+    }
+
+    // Combo box
+    if (name === "comboBox") {
+      properties.sdtType = "comboBox";
+      properties.comboBox = readSdtListItems(child);
+      continue;
+    }
+
+    // Plain text
+    if (name === "text") {
+      properties.sdtType = "plainText";
+      continue;
+    }
+
+    // Rich text (richText element is the default, but if explicitly present, tag it)
+    if (name === "richText") {
+      properties.sdtType = "richText";
+      continue;
+    }
+
+    if (!properties.sdtType && name !== "id" && name !== "placeholder" && name !== "showingPlcHdr" && name !== "rPr") {
       properties.sdtType = name;
     }
   }
@@ -700,6 +1092,34 @@ function readSdtProperties(
   return properties;
 }
 
+function readSdtListItems(node: XmlElementNode): ParsedSdtDropdownListItem[] {
+  const items: ParsedSdtDropdownListItem[] = [];
+  for (const child of node.children) {
+    if (child.type !== "element" || localName(child.name) !== "listItem") continue;
+    const value = readOptionalAttribute(child, "value") ?? "";
+    const displayText = readOptionalAttribute(child, "displayText");
+    items.push({ value, ...(displayText ? { displayText } : {}) });
+  }
+  return items;
+}
+
+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 nested = findFirstDescendant(child, local);
+    if (nested) return nested;
+  }
+  return undefined;
+}
+
 function readTableStyleId(node: XmlElementNode): string | undefined {
   for (const child of node.children) {
     if (child.type !== "element" || localName(child.name) !== "tblStyle") continue;
@@ -762,9 +1182,35 @@ function readTableGridColumns(node: XmlElementNode): number[] {
  */
 function tableRequiresOpaquePreservation(rawXml: string): boolean {
   // Safe table-local content now includes hyperlinks, bookmarks, comments,
-  // nested tables, floating images, and VML preview atoms because the parser
-  // and serializer can preserve them without degrading the whole table.
-  return /<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|fldChar|fldSimple|smartTag|gridAfter|gridBefore|tblCellSpacing)\b/.test(rawXml);
+  // nested tables, floating images, VML preview atoms, and bounded field
+  // families already owned by the current field slice. Risky table-local
+  // semantics still fail closed to preserve-only.
+  if (/<w:(ins|del|rPrChange|pPrChange|tblPrChange|trPrChange|tcPrChange|sectPrChange|cellIns|cellDel|cellMerge|smartTag|gridAfter|gridBefore|tblCellSpacing)\b/.test(rawXml)) {
+    return true;
+  }
+
+  const fldSimpleInstructions = [...rawXml.matchAll(/\bw:instr="([^"]*)"/g)].map((match) => match[1] ?? "");
+  const complexInstructions = [...rawXml.matchAll(/<(?:\w+:)?instrText\b[^>]*>([\s\S]*?)<\/(?:\w+:)?instrText>/gu)]
+    .map((match) => decodeXmlEntities(match[1] ?? ""));
+  for (const instruction of [...fldSimpleInstructions, ...complexInstructions]) {
+    const classification = classifyFieldInstruction(instruction);
+    if (!isSafeMainStoryTableFieldFamily(classification.family)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function isSafeMainStoryTableFieldFamily(family: string): boolean {
+  return (
+    family === "REF" ||
+    family === "PAGEREF" ||
+    family === "NOTEREF" ||
+    family === "TOC" ||
+    family === "PAGE" ||
+    family === "NUMPAGES"
+  );
 }
 
 function readCellGridSpan(node: XmlElementNode): number | undefined {
@@ -935,6 +1381,18 @@ function readOnOffParagraphProperty(node: XmlElementNode, name: string): boolean
   return val !== "false" && val !== "0" && val !== "off" ? true : undefined;
 }
 
+function readOptionalOnOffParagraphProperty(
+  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";
+}
+
 function readParagraphOutlineLevel(node: XmlElementNode): number | undefined {
   const propNode = node.children.find(
     (child): child is XmlElementNode => child.type === "element" && localName(child.name) === "outlineLvl",
@@ -1199,6 +1657,8 @@ function parseRun(
             contentType: media.contentType,
             filename: media.filename,
             ...(media.altText ? { altText: media.altText } : {}),
+            ...(media.widthEmu !== undefined ? { widthEmu: media.widthEmu } : {}),
+            ...(media.heightEmu !== undefined ? { heightEmu: media.heightEmu } : {}),
             placementXml,
             ...(media.display ? { display: media.display } : {}),
             ...(media.floating ? { floating: media.floating } : {}),
@@ -1231,6 +1691,28 @@ function parseRun(
       }
       case "commentReference":
         break;
+      case "footnoteReference": {
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          result.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "footnote",
+          });
+        }
+        break;
+      }
+      case "endnoteReference": {
+        const noteId = child.attributes["w:id"] ?? child.attributes.id ?? "";
+        if (noteId) {
+          result.push({
+            type: "footnote_ref",
+            noteId,
+            noteKind: "endnote",
+          });
+        }
+        break;
+      }
       case "lastRenderedPageBreak":
       case "proofErr":
         result.push({
@@ -1310,8 +1792,6 @@ function parseRevisionContainer(
       case "commentRangeEnd":
       case "bookmarkStart":
       case "bookmarkEnd":
-      case "permStart":
-      case "permEnd":
       case "proofErr":
       case "lastRenderedPageBreak":
         return [
@@ -1320,6 +1800,10 @@ function parseRevisionContainer(
             rawXml: sourceXml.slice(node.start, node.end),
           },
         ];
+      case "permStart":
+        return [parsePermStartNode(node, sourceXml)];
+      case "permEnd":
+        return [parsePermEndNode(node, sourceXml)];
       default:
         return [
           {
@@ -1541,6 +2025,11 @@ function readRunMarks(node: XmlElementNode, sourceXml: string): MarksParseResult
     marks.push(backgroundColorMark);
   }
 
+  const highlightMark = readRunHighlight(properties);
+  if (highlightMark) {
+    marks.push(highlightMark);
+  }
+
   const charSpacingMark = readNumericRunMark(properties, "spacing", "charSpacing");
   if (charSpacingMark) {
     marks.push(charSpacingMark);
@@ -1653,6 +2142,28 @@ function readRunBackgroundColor(properties: XmlElementNode): TextMark | undefine
   return { type: "backgroundColor", color: fill };
 }
 
+function readRunHighlight(properties: XmlElementNode): TextMark | undefined {
+  const highlightNode = properties.children.find(
+    (child): child is XmlElementNode =>
+      child.type === "element" && localName(child.name) === "highlight",
+  );
+  if (!highlightNode) {
+    return undefined;
+  }
+
+  const highlightValue = highlightNode.attributes["w:val"] ?? highlightNode.attributes.val;
+  const resolvedHighlight = resolveHighlightColor(highlightValue);
+  if (!resolvedHighlight) {
+    return undefined;
+  }
+
+  return {
+    type: "highlight",
+    color: resolvedHighlight.color,
+    val: resolvedHighlight.val,
+  };
+}
+
 function readNumericRunMark(
   properties: XmlElementNode,
   elementName: "spacing" | "kern" | "position",
@@ -2007,3 +2518,279 @@ function decodeXmlEntities(value: string): string {
     }
   });
 }
+
+// ---- Section properties parsing ----
+
+function parseSectionBreakElement(
+  node: XmlElementNode,
+  sourceXml: string,
+): ParsedSectionBreakNode {
+  const props = parseSectionPropertiesFromElement(node);
+  return {
+    type: "section_break",
+    sectionPropertiesXml: sourceXml.slice(node.start, node.end),
+    sectionProperties: props,
+  };
+}
+
+function readSectionPropertiesFromPPr(
+  pPrNode: XmlElementNode,
+): SectionProperties | undefined {
+  for (const child of pPrNode.children) {
+    if (child.type === "element" && localName(child.name) === "sectPr") {
+      return parseSectionPropertiesFromElement(child);
+    }
+  }
+  return undefined;
+}
+
+function readSectionPropertiesXmlFromPPr(
+  pPrNode: XmlElementNode,
+  sourceXml: string,
+): string | undefined {
+  for (const child of pPrNode.children) {
+    if (child.type === "element" && localName(child.name) === "sectPr") {
+      return sourceXml.slice(child.start, child.end);
+    }
+  }
+  return undefined;
+}
+
+export function parseSectionPropertiesFromElement(
+  node: XmlElementNode,
+): SectionProperties {
+  const props: SectionProperties = {};
+
+  for (const child of node.children) {
+    if (child.type !== "element") continue;
+    const name = localName(child.name);
+
+    switch (name) {
+      case "pgSz": {
+        const w = safeParseInt(child.attributes["w:w"]);
+        const h = safeParseInt(child.attributes["w:h"]);
+        if (w !== undefined && h !== undefined) {
+          const pageSize: PageSize = { width: w, height: h };
+          const orient = child.attributes["w:orient"];
+          if (orient === "landscape" || orient === "portrait") {
+            pageSize.orientation = orient;
+          }
+          props.pageSize = pageSize;
+        }
+        break;
+      }
+      case "pgMar": {
+        const top = safeParseInt(child.attributes["w:top"]);
+        const right = safeParseInt(child.attributes["w:right"]);
+        const bottom = safeParseInt(child.attributes["w:bottom"]);
+        const left = safeParseInt(child.attributes["w:left"]);
+        if (top !== undefined && right !== undefined && bottom !== undefined && left !== undefined) {
+          const margins: PageMargins = { top, right, bottom, left };
+          const header = safeParseInt(child.attributes["w:header"]);
+          const footer = safeParseInt(child.attributes["w:footer"]);
+          const gutter = safeParseInt(child.attributes["w:gutter"]);
+          if (header !== undefined) margins.header = header;
+          if (footer !== undefined) margins.footer = footer;
+          if (gutter !== undefined) margins.gutter = gutter;
+          props.pageMargins = margins;
+        }
+        break;
+      }
+      case "cols": {
+        const columns: ColumnProperties = {};
+        const num = safeParseInt(child.attributes["w:num"]);
+        const space = safeParseInt(child.attributes["w:space"]);
+        const equalWidth = child.attributes["w:equalWidth"];
+        const sep = child.attributes["w:sep"];
+        if (num !== undefined) columns.count = num;
+        if (space !== undefined) columns.space = space;
+        if (equalWidth !== undefined) columns.equalWidth = equalWidth !== "0" && equalWidth !== "false";
+        if (sep === "1" || sep === "true") columns.separator = true;
+        const colDefs: Array<{ width: number; space?: number }> = [];
+        for (const colChild of child.children) {
+          if (colChild.type === "element" && localName(colChild.name) === "col") {
+            const colW = safeParseInt(colChild.attributes["w:w"]);
+            const colSpace = safeParseInt(colChild.attributes["w:space"]);
+            if (colW !== undefined) {
+              colDefs.push(colSpace !== undefined ? { width: colW, space: colSpace } : { width: colW });
+            }
+          }
+        }
+        if (colDefs.length > 0) columns.columns = colDefs;
+        if (Object.keys(columns).length > 0) props.columns = columns;
+        break;
+      }
+      case "pgNumType": {
+        const numbering: PageNumbering = {};
+        const fmt = child.attributes["w:fmt"];
+        const start = safeParseInt(child.attributes["w:start"]);
+        const chapStyle = child.attributes["w:chapStyle"];
+        const chapSep = child.attributes["w:chapSep"];
+        if (fmt) numbering.format = fmt;
+        if (start !== undefined) numbering.start = start;
+        if (chapStyle) numbering.chapStyle = chapStyle;
+        if (chapSep) numbering.chapSep = chapSep;
+        if (Object.keys(numbering).length > 0) props.pageNumbering = numbering;
+        break;
+      }
+      case "lnNumType": {
+        const lineNumbering: SectionLineNumbering = {};
+        const countBy = safeParseInt(child.attributes["w:countBy"]);
+        const start = safeParseInt(child.attributes["w:start"]);
+        const distance = safeParseInt(child.attributes["w:distance"]);
+        const restart = child.attributes["w:restart"];
+        if (countBy !== undefined) lineNumbering.countBy = countBy;
+        if (start !== undefined) lineNumbering.start = start;
+        if (distance !== undefined) lineNumbering.distance = distance;
+        if (
+          restart === "newPage" ||
+          restart === "newSection" ||
+          restart === "continuous"
+        ) {
+          lineNumbering.restart = restart;
+        }
+        if (Object.keys(lineNumbering).length > 0) {
+          props.lineNumbering = lineNumbering;
+        }
+        break;
+      }
+      case "pgBorders": {
+        const pageBorders: SectionPageBorders = {};
+        const offsetFrom = child.attributes["w:offsetFrom"];
+        const display = child.attributes["w:display"];
+        const zOrder = child.attributes["w:zOrder"];
+        if (offsetFrom === "page" || offsetFrom === "text") {
+          pageBorders.offsetFrom = offsetFrom;
+        }
+        if (
+          display === "allPages" ||
+          display === "firstPage" ||
+          display === "notFirstPage"
+        ) {
+          pageBorders.display = display;
+        }
+        if (zOrder === "front" || zOrder === "back") {
+          pageBorders.zOrder = zOrder;
+        }
+        for (const borderChild of child.children) {
+          if (borderChild.type !== "element") continue;
+          const borderName = localName(borderChild.name);
+          const border = parseBorderSpec(borderChild);
+          if (!border) continue;
+          if (
+            borderName === "top" ||
+            borderName === "left" ||
+            borderName === "bottom" ||
+            borderName === "right"
+          ) {
+            pageBorders[borderName] = border;
+          }
+        }
+        if (Object.keys(pageBorders).length > 0) {
+          props.pageBorders = pageBorders;
+        }
+        break;
+      }
+      case "docGrid": {
+        const documentGrid: SectionDocumentGrid = {};
+        const type = child.attributes["w:type"];
+        const linePitch = safeParseInt(child.attributes["w:linePitch"]);
+        const charSpace = safeParseInt(child.attributes["w:charSpace"]);
+        if (
+          type === "default" ||
+          type === "lines" ||
+          type === "linesAndChars" ||
+          type === "snapToChars"
+        ) {
+          documentGrid.type = type;
+        }
+        if (linePitch !== undefined) documentGrid.linePitch = linePitch;
+        if (charSpace !== undefined) documentGrid.charSpace = charSpace;
+        if (Object.keys(documentGrid).length > 0) {
+          props.documentGrid = documentGrid;
+        }
+        break;
+      }
+      case "headerReference": {
+        const variant = child.attributes["w:type"] as HeaderFooterVariant | undefined;
+        const rId = child.attributes["r:id"];
+        if (variant && rId) {
+          if (!props.headerReferences) props.headerReferences = [];
+          props.headerReferences.push({ variant, relationshipId: rId });
+        }
+        break;
+      }
+      case "footerReference": {
+        const variant = child.attributes["w:type"] as HeaderFooterVariant | undefined;
+        const rId = child.attributes["r:id"];
+        if (variant && rId) {
+          if (!props.footerReferences) props.footerReferences = [];
+          props.footerReferences.push({ variant, relationshipId: rId });
+        }
+        break;
+      }
+      case "type": {
+        const val = child.attributes["w:val"];
+        if (val === "continuous" || val === "nextPage" || val === "evenPage" || val === "oddPage" || val === "nextColumn") {
+          props.sectionType = val;
+        }
+        break;
+      }
+      case "titlePg": {
+        const val = child.attributes["w:val"];
+        props.titlePage = val !== "false" && val !== "0";
+        break;
+      }
+    }
+  }
+
+  return props;
+}
+
+function safeParseInt(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function parseBorderSpec(node: XmlElementNode): BorderSpec | undefined {
+  const border: BorderSpec = {};
+  const value = node.attributes["w:val"];
+  const size = safeParseInt(node.attributes["w:sz"]);
+  const space = safeParseInt(node.attributes["w:space"]);
+  const color = node.attributes["w:color"];
+
+  if (value) border.value = value;
+  if (size !== undefined) border.size = size;
+  if (space !== undefined) border.space = space;
+  if (color) border.color = color;
+
+  return Object.keys(border).length > 0 ? border : undefined;
+}
+
+function parsePermStartNode(
+  node: XmlElementNode,
+  sourceXml: string,
+): ParsedPermStartInlineNode {
+  const rangeId = node.attributes["w:id"] ?? node.attributes.id ?? "";
+  const edGrp = node.attributes["w:edGrp"] ?? node.attributes.edGrp;
+  const ed = node.attributes["w:ed"] ?? node.attributes.ed;
+  return {
+    type: "perm_start",
+    rangeId,
+    ...(edGrp ? { editorGroup: edGrp } : {}),
+    ...(ed ? { editor: ed } : {}),
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}
+
+function parsePermEndNode(
+  node: XmlElementNode,
+  sourceXml: string,
+): ParsedPermEndInlineNode {
+  return {
+    type: "perm_end",
+    rangeId: node.attributes["w:id"] ?? node.attributes.id ?? "",
+    rawXml: sourceXml.slice(node.start, node.end),
+  };
+}