@beyondwork/docx-react-component 1.0.18 → 1.0.20

package/src/io/export/serialize-headers-footers.ts

@@ -1,8 +1,12 @@
 import type {
+  BlockNode,
   FooterDocument,
   HeaderDocument,
   InlineNode,
   ParagraphNode,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
   TextMark,
 } from "../../model/canonical-document.ts";
 
@@ -13,6 +17,17 @@ export const WORD_FOOTER_CONTENT_TYPE =
 
 const W_NS = `xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"`;
 const R_NS = `xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"`;
+const MC_NS = `xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"`;
+const O_NS = `xmlns:o="urn:schemas-microsoft-com:office:office"`;
+const V_NS = `xmlns:v="urn:schemas-microsoft-com:vml"`;
+const WP_NS = `xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing"`;
+const WPS_NS = `xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"`;
+const A_NS = `xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main"`;
+const W10_NS = `xmlns:w10="urn:schemas-microsoft-com:office:word"`;
+const W14_NS = `xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"`;
+const W15_NS = `xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml"`;
+const WP14_NS = `xmlns:wp14="http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing"`;
+const EXTENDED_ROOT_ATTRS = `${MC_NS} ${O_NS} ${V_NS} ${WP_NS} ${WPS_NS} ${A_NS} ${W10_NS} ${W14_NS} ${W15_NS} ${WP14_NS} mc:Ignorable="wps wp14 w14 w15"`;
 
 /**
  * Serialize a HeaderDocument into a headerN.xml string.
@@ -21,7 +36,7 @@ export function serializeHeaderXml(header: HeaderDocument): string {
   const body = serializeBlocks(header.blocks);
   return [
     `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-    `<w:hdr ${W_NS} ${R_NS}>${body}</w:hdr>`,
+    `<w:hdr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:hdr>`,
   ].join("\n");
 }
 
@@ -32,7 +47,7 @@ export function serializeFooterXml(footer: FooterDocument): string {
   const body = serializeBlocks(footer.blocks);
   return [
     `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-    `<w:ftr ${W_NS} ${R_NS}>${body}</w:ftr>`,
+    `<w:ftr ${W_NS} ${R_NS} ${EXTENDED_ROOT_ATTRS}>${body}</w:ftr>`,
   ].join("\n");
 }
 
@@ -51,6 +66,12 @@ function serializeBlocks(
       if (block.type === "paragraph") {
         return serializeParagraph(block);
       }
+      if (block.type === "table") {
+        return serializeTable(block);
+      }
+      if (block.type === "opaque_block" && typeof block.rawXml === "string") {
+        return block.rawXml;
+      }
       throw new Error(`Cannot safely serialize ${block.type} content in header/footer sub-parts.`);
     })
     .join("");
@@ -73,15 +94,88 @@ function serializeParagraph(paragraph: ParagraphNode): string {
   return xml;
 }
 
+function serializeTable(table: TableNode): string {
+  let xml = "<w:tbl>";
+  if (table.propertiesXml) {
+    xml += table.propertiesXml;
+  }
+  if (table.gridColumns.length > 0) {
+    xml += "<w:tblGrid>";
+    for (const width of table.gridColumns) {
+      xml += `<w:gridCol w:w="${width}"/>`;
+    }
+    xml += "</w:tblGrid>";
+  }
+  for (const row of table.rows) {
+    xml += serializeTableRow(row);
+  }
+  xml += "</w:tbl>";
+  return xml;
+}
+
+function serializeTableRow(row: TableRowNode): string {
+  let xml = "<w:tr>";
+  if (row.propertiesXml) {
+    xml += wrapPropertiesXml("w:trPr", row.propertiesXml);
+  }
+  for (const cell of row.cells) {
+    xml += serializeTableCell(cell);
+  }
+  xml += "</w:tr>";
+  return xml;
+}
+
+function serializeTableCell(cell: TableCellNode): string {
+  let xml = "<w:tc>";
+  const propertiesXml = buildTableCellPropertiesXml(cell);
+  if (propertiesXml) {
+    xml += propertiesXml;
+  }
+  for (const child of cell.children) {
+    if (child.type === "paragraph") {
+      xml += serializeParagraph(child);
+    } else {
+      throw new Error(`Cannot safely serialize ${child.type} content in header/footer table cells.`);
+    }
+  }
+  xml += "</w:tc>";
+  return xml;
+}
+
 function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   const parts: string[] = [];
 
   if (paragraph.styleId) {
     parts.push(`<w:pStyle w:val="${escapeAttribute(paragraph.styleId)}"/>`);
   }
+  if (paragraph.spacing) {
+    const s = paragraph.spacing;
+    const attrs: string[] = [];
+    if (s.before !== undefined) attrs.push(`w:before="${s.before}"`);
+    if (s.after !== undefined) attrs.push(`w:after="${s.after}"`);
+    if (s.line !== undefined) attrs.push(`w:line="${s.line}"`);
+    if (s.lineRule) attrs.push(`w:lineRule="${escapeAttribute(s.lineRule)}"`);
+    if (attrs.length > 0) parts.push(`<w:spacing ${attrs.join(" ")}/>`);
+  }
+  if (paragraph.indentation) {
+    const ind = paragraph.indentation;
+    const attrs: string[] = [];
+    if (ind.left !== undefined) attrs.push(`w:left="${ind.left}"`);
+    if (ind.right !== undefined) attrs.push(`w:right="${ind.right}"`);
+    if (ind.firstLine !== undefined) attrs.push(`w:firstLine="${ind.firstLine}"`);
+    if (ind.hanging !== undefined) attrs.push(`w:hanging="${ind.hanging}"`);
+    if (attrs.length > 0) parts.push(`<w:ind ${attrs.join(" ")}/>`);
+  }
   if (paragraph.alignment) {
     parts.push(`<w:jc w:val="${escapeAttribute(paragraph.alignment)}"/>`);
   }
+  if (paragraph.tabStops && paragraph.tabStops.length > 0) {
+    const tabsXml = paragraph.tabStops.map((tab) => {
+      const leaderAttr = tab.leader ? ` w:leader="${escapeAttribute(tab.leader)}"` : "";
+      return `<w:tab w:val="${tab.align}" w:pos="${tab.position}"${leaderAttr}/>`;
+    }).join("");
+    parts.push(`<w:tabs>${tabsXml}</w:tabs>`);
+  }
 
   return parts.length > 0 ? `<w:pPr>${parts.join("")}</w:pPr>` : "";
 }
@@ -106,25 +200,51 @@ function serializeInlineNode(node: InlineNode): string {
           : `<w:endnoteReference w:id="${escapeAttribute(node.noteId)}"/>`;
       return `<w:r><w:rPr><w:rStyle w:val="${node.noteKind === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr>${refElement}</w:r>`;
     }
-    case "opaque_inline":
-      throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
-    case "hyperlink":
-    case "image":
-    case "field":
     case "bookmark_start":
+      return `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}" w:name="${escapeAttribute(node.name)}"/>`;
     case "bookmark_end":
-    case "column_break":
-    case "symbol":
+      return `<w:bookmarkEnd w:id="${escapeAttribute(node.bookmarkId)}"/>`;
+    case "field":
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
+      if (node.fieldType === "simple") {
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+      }
+      return `<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve">${escapeXml(node.instruction)}</w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r><w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+    case "hyperlink":
+      return serializeHyperlinkNode(node);
     case "chart_preview":
     case "smartart_preview":
     case "shape":
     case "wordart":
     case "vml_shape":
+      return wrapInlineRawXml(node.rawXml);
+    case "opaque_inline":
+      throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
+    case "image":
+    case "column_break":
+    case "symbol":
     default:
       throw new Error(`Cannot safely serialize ${node.type} content in header/footer sub-parts.`);
   }
 }
 
+function wrapInlineRawXml(rawXml: string): string {
+  const trimmed = rawXml.trimStart();
+  return trimmed.startsWith("<w:r") ? rawXml : `<w:r>${rawXml}</w:r>`;
+}
+
 function buildRunPropertiesXml(marks: TextMark[] | undefined): string {
   if (!marks || marks.length === 0) {
     return "";
@@ -148,8 +268,31 @@ function buildRunPropertiesXml(marks: TextMark[] | undefined): string {
       case "doubleStrikethrough":
         parts.push("<w:dstrike/>");
         break;
+      case "fontFamily":
+        parts.push(`<w:rFonts w:ascii="${escapeAttribute(mark.val)}" w:hAnsi="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "fontSize":
+        parts.push(`<w:sz w:val="${mark.val}"/>`);
+        break;
+      case "textColor":
+        parts.push(`<w:color w:val="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "highlight":
+        parts.push(`<w:highlight w:val="${escapeAttribute(mark.val)}"/>`);
+        break;
+      case "backgroundColor":
+        parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttribute(mark.color)}"/>`);
+        break;
+      case "smallCaps":
+        parts.push("<w:smallCaps/>");
+        break;
+      case "allCaps":
+        parts.push("<w:caps/>");
+        break;
       default:
-        throw new Error(`Cannot safely serialize ${mark.type} marks in header/footer sub-parts.`);
+        // Marks outside the secondary-story contract are silently dropped
+        // to avoid export failure on content the parser extracted safely.
+        break;
     }
   }
 
@@ -177,3 +320,53 @@ function escapeAttribute(value: string): string {
     .replace(/>/g, "&gt;")
     .replace(/"/g, "&quot;");
 }
+
+function serializeHyperlinkNode(node: Extract<InlineNode, { type: "hyperlink" }>): string {
+  const childrenXml = node.children.map((child) => serializeInlineNode(child)).join("");
+  if (node.href.startsWith("#")) {
+    return `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">${childrenXml}</w:hyperlink>`;
+  }
+  if (!/^rId[A-Za-z0-9._-]+$/u.test(node.href)) {
+    throw new Error("Cannot safely serialize URL-backed header/footer hyperlinks without relationship context.");
+  }
+  return `<w:hyperlink r:id="${escapeAttribute(node.href)}">${childrenXml}</w:hyperlink>`;
+}
+
+function wrapPropertiesXml(tagName: "w:trPr" | "w:tcPr", xml: string): string {
+  const trimmed = xml.trim();
+  if (trimmed.startsWith(`<${tagName}`)) {
+    return trimmed;
+  }
+  return `<${tagName}>${trimmed}</${tagName}>`;
+}
+
+function extractWrappedChildren(tagName: "w:tcPr", xml: string | undefined): string {
+  if (!xml) {
+    return "";
+  }
+  const trimmed = xml.trim();
+  const wrapped = new RegExp(`^<${tagName}\\b[^>]*>([\\s\\S]*)</${tagName}>$`, "u").exec(trimmed);
+  return wrapped?.[1] ?? trimmed;
+}
+
+function buildTableCellPropertiesXml(cell: TableCellNode): string {
+  const innerXml = extractWrappedChildren("w:tcPr", cell.propertiesXml)
+    .replace(/<w:gridSpan\b[^>]*\/>/gu, "")
+    .replace(/<w:vMerge\b[^>]*\/>/gu, "")
+    .trim();
+  const parts: string[] = [];
+  if (cell.gridSpan && cell.gridSpan > 1) {
+    parts.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+  }
+  if (cell.verticalMerge) {
+    parts.push(
+      cell.verticalMerge === "restart"
+        ? `<w:vMerge w:val="restart"/>`
+        : `<w:vMerge/>`,
+    );
+  }
+  if (innerXml.length > 0) {
+    parts.push(innerXml);
+  }
+  return parts.length > 0 ? `<w:tcPr>${parts.join("")}</w:tcPr>` : "";
+}

package/src/io/export/serialize-main-document.ts

@@ -8,6 +8,7 @@ import type {
   ParagraphNode,
   PreservationStore,
   SdtNode,
+  SectionProperties,
   TableNode,
   TableCellNode,
   TextMark,
@@ -30,6 +31,7 @@ export interface SerializedMainDocument {
 export interface SerializeMainDocumentOptions {
   documentAttributes?: Record<string, string>;
   media?: MediaCatalog;
+  finalSectionProperties?: SectionProperties;
 }
 
 interface SerializationState {
@@ -90,7 +92,9 @@ export function serializeMainDocument(
   const bodyPieces: string[] = [];
   const paragraphBoundaries: RevisionParagraphBoundary[] = [];
   let bodyLength = 0;
-  let sectionPropertiesXml = "<w:sectPr/>";
+  let sectionPropertiesXml = options.finalSectionProperties
+    ? serializeSectionPropertiesXml(options.finalSectionProperties)
+    : "<w:sectPr/>";
   let cursor = 0;
   let paragraphIndex = -1;
   let previousWasParagraph = false;
@@ -154,9 +158,20 @@ export function serializeMainDocument(
     }
 
     if (block.type === "section_break") {
-      if (block.propertiesXml) {
-        sectionPropertiesXml = block.propertiesXml;
+      // Inline section breaks must be emitted as a paragraph with <w:sectPr>
+      // in its <w:pPr> element (OOXML compliance). The body-level <w:sectPr>
+      // is reserved for the final section only.
+      let inlineSectPr: string;
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        inlineSectPr = block.sectionPropertiesXml ?? block.propertiesXml!;
+      } else if (block.sectionProperties) {
+        inlineSectPr = serializeSectionPropertiesXml(block.sectionProperties);
+      } else {
+        inlineSectPr = "<w:sectPr/>";
       }
+      const sectionParagraphXml = `<w:p><w:pPr>${inlineSectPr}</w:pPr></w:p>`;
+      bodyPieces.push(sectionParagraphXml);
+      bodyLength += sectionParagraphXml.length;
       cursor += 1;
       previousWasParagraph = false;
       continue;
@@ -242,7 +257,11 @@ function serializeBlockNode(
     case "opaque_block":
       return lookupOpaqueXml(block.fragmentId, state);
     case "section_break":
-      return block.propertiesXml ?? "<w:sectPr/>";
+      if (block.sectionPropertiesXml ?? block.propertiesXml) {
+        return block.sectionPropertiesXml ?? block.propertiesXml!;
+      }
+      if (block.sectionProperties) return serializeSectionPropertiesXml(block.sectionProperties);
+      return "<w:sectPr/>";
   }
 }
 
@@ -303,7 +322,40 @@ function buildSdtPropertiesXml(block: SdtNode): string {
   if (block.properties.lock) {
     children.push(`<w:lock w:val="${escapeAttribute(block.properties.lock)}"/>`);
   }
-  if (block.properties.sdtType) {
+  if (block.properties.showingPlcHdr) {
+    children.push(`<w:showingPlcHdr/>`);
+  }
+  if (block.properties.checkbox) {
+    const cb = block.properties.checkbox;
+    const cbParts: string[] = [];
+    cbParts.push(`<w14:checked w14:val="${cb.checked ? "1" : "0"}"/>`);
+    if (cb.checkedChar) cbParts.push(`<w14:checkedState w14:val="${escapeAttribute(cb.checkedChar)}"/>`);
+    if (cb.uncheckedChar) cbParts.push(`<w14:uncheckedState w14:val="${escapeAttribute(cb.uncheckedChar)}"/>`);
+    children.push(`<w14:checkbox>${cbParts.join("")}</w14:checkbox>`);
+  } else if (block.properties.datePicker) {
+    const dp = block.properties.datePicker;
+    const dateAttrs = dp.fullDate ? ` w:fullDate="${escapeAttribute(dp.fullDate)}"` : "";
+    const dpParts: string[] = [];
+    if (dp.dateFormat) dpParts.push(`<w:dateFormat w:val="${escapeAttribute(dp.dateFormat)}"/>`);
+    if (dp.lid) dpParts.push(`<w:lid w:val="${escapeAttribute(dp.lid)}"/>`);
+    children.push(dpParts.length > 0 ? `<w:date${dateAttrs}>${dpParts.join("")}</w:date>` : `<w:date${dateAttrs}/>`);
+  } else if (block.properties.dropdownList) {
+    const items = block.properties.dropdownList.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:dropDownList>${items}</w:dropDownList>`);
+  } else if (block.properties.comboBox) {
+    const items = block.properties.comboBox.map((item) => {
+      const dt = item.displayText ? ` w:displayText="${escapeAttribute(item.displayText)}"` : "";
+      return `<w:listItem${dt} w:value="${escapeAttribute(item.value)}"/>`;
+    }).join("");
+    children.push(`<w:comboBox>${items}</w:comboBox>`);
+  } else if (block.properties.sdtType === "plainText") {
+    children.push(`<w:text/>`);
+  } else if (block.properties.sdtType === "richText") {
+    children.push(`<w:richText/>`);
+  } else if (block.properties.sdtType) {
     children.push(`<w:${block.properties.sdtType}/>`);
   }
   return children.length > 0 ? `<w:sdtPr>${children.join("")}</w:sdtPr>` : "<w:sdtPr/>";
@@ -355,7 +407,7 @@ function serializeTableInlineNode(
     case "shape":
     case "wordart":
     case "vml_shape":
-      return node.rawXml;
+      return wrapInlineRawXml(node.rawXml);
     case "hyperlink": {
       const hyperlinkOpen = node.href.startsWith("#")
         ? `<w:hyperlink w:anchor="${escapeAttribute(node.href.slice(1))}">`
@@ -374,8 +426,24 @@ function serializeTableInlineNode(
       const childrenXml = node.children.map((child) => serializeTableInlineNode(child, state)).join("");
       return `${hyperlinkOpen}${childrenXml}</w:hyperlink>`;
     }
-    case "field":
+    case "field": {
+      if (node.children && node.children.length > 0) {
+        const childrenXml = node.children
+          .map((child) => serializeTableInlineNode(child, state))
+          .join("");
+        if (node.fieldType === "complex") {
+          return (
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>` +
+            childrenXml +
+            `<w:r><w:fldChar w:fldCharType="end"/></w:r>`
+          );
+        }
+        return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">${childrenXml}</w:fldSimple>`;
+      }
       return `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
+    }
     case "bookmark_start":
       return (
         `<w:bookmarkStart w:id="${escapeAttribute(node.bookmarkId)}"` +
@@ -432,6 +500,13 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
     if (s.lineRule !== undefined) attrs.push(`w:lineRule="${s.lineRule}"`);
     if (attrs.length > 0) children.push(`<w:spacing ${attrs.join(" ")}/>`);
   }
+  if (paragraph.contextualSpacing !== undefined) {
+    children.push(
+      paragraph.contextualSpacing
+        ? "<w:contextualSpacing/>"
+        : `<w:contextualSpacing w:val="0"/>`,
+    );
+  }
   if (paragraph.indentation) {
     const ind = paragraph.indentation;
     const attrs: string[] = [];
@@ -754,7 +829,7 @@ function serializeInlineNode(
     case "wordart":
     case "vml_shape": {
       // Reattach original XML unchanged for lossless round-trip.
-      const xml = node.rawXml;
+      const xml = wrapInlineRawXml(node.rawXml);
       const boundaries = new Map<number, number>();
       boundaries.set(cursor, xmlOffset);
       boundaries.set(cursor + 1, xmlOffset + xml.length);
@@ -804,6 +879,55 @@ function serializeInlineNode(
       };
     }
     case "field": {
+      if (node.children && node.children.length > 0) {
+        const boundaries = new Map<number, number>();
+        boundaries.set(cursor, xmlOffset);
+        let nextCursor = cursor;
+        let nextOffset = xmlOffset;
+
+        if (node.fieldType === "complex") {
+          const beginXml =
+            `<w:r><w:fldChar w:fldCharType="begin"/></w:r>` +
+            `<w:r><w:instrText xml:space="preserve"> ${escapeXml(node.instruction)} </w:instrText></w:r>` +
+            `<w:r><w:fldChar w:fldCharType="separate"/></w:r>`;
+          nextOffset += beginXml.length;
+
+          const children: string[] = [beginXml];
+          for (const child of node.children) {
+            const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+            children.push(result.xml);
+            for (const [position, index] of result.boundaries) {
+              boundaries.set(position, index);
+            }
+            nextCursor = result.cursor;
+            nextOffset += result.xml.length;
+          }
+          const endXml = `<w:r><w:fldChar w:fldCharType="end"/></w:r>`;
+          children.push(endXml);
+          nextOffset += endXml.length;
+          boundaries.set(nextCursor, nextOffset);
+          return { xml: children.join(""), cursor: nextCursor, boundaries };
+        }
+
+        // Simple field with children
+        const openXml = `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}">`;
+        nextOffset += openXml.length;
+        const children: string[] = [openXml];
+        for (const child of node.children) {
+          const result = serializeInlineNode(child, state, nextCursor, nextOffset);
+          children.push(result.xml);
+          for (const [position, index] of result.boundaries) {
+            boundaries.set(position, index);
+          }
+          nextCursor = result.cursor;
+          nextOffset += result.xml.length;
+        }
+        children.push("</w:fldSimple>");
+        nextOffset += "</w:fldSimple>".length;
+        boundaries.set(nextCursor, nextOffset);
+        return { xml: children.join(""), cursor: nextCursor, boundaries };
+      }
+
       const xml = `<w:fldSimple w:instr="${escapeAttribute(node.instruction)}"/>`;
       const boundaries = new Map<number, number>();
       boundaries.set(cursor, xmlOffset);
@@ -914,6 +1038,9 @@ function serializeRunProperties(marks: TextMark[] | undefined): string {
       case "lang":
         markParts.push(`<w:lang w:val="${escapeAttribute(mark.val)}"/>`);
         break;
+      case "highlight":
+        markParts.push(`<w:highlight w:val="${escapeAttribute(mark.val)}"/>`);
+        break;
       case "backgroundColor":
         markParts.push(
           `<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttribute(mark.color)}"/>`,
@@ -1049,6 +1176,156 @@ function serializeDocumentAttributes(
     .join("");
 }
 
+export function serializeSectionPropertiesXml(props: SectionProperties): string {
+  const children: string[] = [];
+
+  // Header references
+  if (props.headerReferences) {
+    for (const ref of props.headerReferences) {
+      children.push(`<w:headerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Footer references
+  if (props.footerReferences) {
+    for (const ref of props.footerReferences) {
+      children.push(`<w:footerReference w:type="${escapeAttribute(ref.variant)}" r:id="${escapeAttribute(ref.relationshipId)}"/>`);
+    }
+  }
+
+  // Section type
+  if (props.sectionType) {
+    children.push(`<w:type w:val="${escapeAttribute(props.sectionType)}"/>`);
+  }
+
+  // Page size
+  if (props.pageSize) {
+    let pgSz = `<w:pgSz w:w="${props.pageSize.width}" w:h="${props.pageSize.height}"`;
+    if (props.pageSize.orientation) {
+      pgSz += ` w:orient="${props.pageSize.orientation}"`;
+    }
+    pgSz += "/>";
+    children.push(pgSz);
+  }
+
+  // Page margins
+  if (props.pageMargins) {
+    let pgMar = `<w:pgMar w:top="${props.pageMargins.top}" w:right="${props.pageMargins.right}" w:bottom="${props.pageMargins.bottom}" w:left="${props.pageMargins.left}"`;
+    if (props.pageMargins.header !== undefined) pgMar += ` w:header="${props.pageMargins.header}"`;
+    if (props.pageMargins.footer !== undefined) pgMar += ` w:footer="${props.pageMargins.footer}"`;
+    if (props.pageMargins.gutter !== undefined) pgMar += ` w:gutter="${props.pageMargins.gutter}"`;
+    pgMar += "/>";
+    children.push(pgMar);
+  }
+
+  // Columns
+  if (props.columns) {
+    let cols = "<w:cols";
+    if (props.columns.count !== undefined) cols += ` w:num="${props.columns.count}"`;
+    if (props.columns.space !== undefined) cols += ` w:space="${props.columns.space}"`;
+    if (props.columns.equalWidth !== undefined) cols += ` w:equalWidth="${props.columns.equalWidth ? "1" : "0"}"`;
+    if (props.columns.separator) cols += ` w:sep="1"`;
+    if (props.columns.columns && props.columns.columns.length > 0) {
+      cols += ">";
+      for (const col of props.columns.columns) {
+        let colXml = `<w:col w:w="${col.width}"`;
+        if (col.space !== undefined) colXml += ` w:space="${col.space}"`;
+        colXml += "/>";
+        cols += colXml;
+      }
+      cols += "</w:cols>";
+    } else {
+      cols += "/>";
+    }
+    children.push(cols);
+  }
+
+  // Page numbering
+  if (props.pageNumbering) {
+    let pgNum = "<w:pgNumType";
+    if (props.pageNumbering.format) pgNum += ` w:fmt="${escapeAttribute(props.pageNumbering.format)}"`;
+    if (props.pageNumbering.start !== undefined) pgNum += ` w:start="${props.pageNumbering.start}"`;
+    if (props.pageNumbering.chapStyle) pgNum += ` w:chapStyle="${escapeAttribute(props.pageNumbering.chapStyle)}"`;
+    if (props.pageNumbering.chapSep) pgNum += ` w:chapSep="${escapeAttribute(props.pageNumbering.chapSep)}"`;
+    pgNum += "/>";
+    children.push(pgNum);
+  }
+
+  if (props.lineNumbering) {
+    let lineNumbering = "<w:lnNumType";
+    if (props.lineNumbering.countBy !== undefined) {
+      lineNumbering += ` w:countBy="${props.lineNumbering.countBy}"`;
+    }
+    if (props.lineNumbering.start !== undefined) {
+      lineNumbering += ` w:start="${props.lineNumbering.start}"`;
+    }
+    if (props.lineNumbering.distance !== undefined) {
+      lineNumbering += ` w:distance="${props.lineNumbering.distance}"`;
+    }
+    if (props.lineNumbering.restart) {
+      lineNumbering += ` w:restart="${escapeAttribute(props.lineNumbering.restart)}"`;
+    }
+    lineNumbering += "/>";
+    children.push(lineNumbering);
+  }
+
+  if (props.pageBorders) {
+    const attrs: string[] = [];
+    if (props.pageBorders.offsetFrom) {
+      attrs.push(`w:offsetFrom="${escapeAttribute(props.pageBorders.offsetFrom)}"`);
+    }
+    if (props.pageBorders.display) {
+      attrs.push(`w:display="${escapeAttribute(props.pageBorders.display)}"`);
+    }
+    if (props.pageBorders.zOrder) {
+      attrs.push(`w:zOrder="${escapeAttribute(props.pageBorders.zOrder)}"`);
+    }
+    const borderXml = [
+      serializeBorder("top", props.pageBorders.top),
+      serializeBorder("left", props.pageBorders.left),
+      serializeBorder("bottom", props.pageBorders.bottom),
+      serializeBorder("right", props.pageBorders.right),
+    ].filter((entry) => entry.length > 0);
+    if (attrs.length > 0 || borderXml.length > 0) {
+      children.push(
+        `<w:pgBorders${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>${borderXml.join("")}</w:pgBorders>`,
+      );
+    }
+  }
+
+  // Title page
+  if (props.titlePage) {
+    children.push("<w:titlePg/>");
+  }
+
+  if (props.documentGrid) {
+    const attrs: string[] = [];
+    if (props.documentGrid.type) {
+      attrs.push(`w:type="${escapeAttribute(props.documentGrid.type)}"`);
+    }
+    if (props.documentGrid.linePitch !== undefined) {
+      attrs.push(`w:linePitch="${props.documentGrid.linePitch}"`);
+    }
+    if (props.documentGrid.charSpace !== undefined) {
+      attrs.push(`w:charSpace="${props.documentGrid.charSpace}"`);
+    }
+    if (attrs.length > 0) {
+      children.push(`<w:docGrid ${attrs.join(" ")}/>`);
+    }
+  }
+
+  if (children.length === 0) {
+    return "<w:sectPr/>";
+  }
+
+  return `<w:sectPr>${children.join("")}</w:sectPr>`;
+}
+
+function wrapInlineRawXml(rawXml: string): string {
+  const trimmed = rawXml.trimStart();
+  return trimmed.startsWith("<w:r") ? rawXml : `<w:r>${rawXml}</w:r>`;
+}
+
 function documentNeedsW14Namespace(content: DocumentRootNode): boolean {
   const blockQueue = [...content.children];
   while (blockQueue.length > 0) {