@beyondwork/docx-react-component 1.0.37 → 1.0.39

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

@@ -69,6 +69,25 @@ export interface ParsedTableLook {
   noVBand?: boolean;
 }
 
+export interface ParsedTableIndent {
+  value: number;
+  type: "dxa" | "auto" | "pct" | "nil";
+}
+
+export interface ParsedTableFloating {
+  horizontalAnchor?: "margin" | "page" | "text";
+  verticalAnchor?: "margin" | "page" | "text";
+  horizontalAlign?: "left" | "center" | "right" | "inside" | "outside";
+  horizontalOffset?: number;
+  verticalAlign?: "top" | "center" | "bottom" | "inside" | "outside";
+  verticalOffset?: number;
+  leftFromText?: number;
+  rightFromText?: number;
+  topFromText?: number;
+  bottomFromText?: number;
+  overlap?: boolean;
+}
+
 export interface ParsedTableDocument {
   tables: ParsedTable[];
 }
@@ -85,6 +104,13 @@ export interface ParsedTable {
   borders?: ParsedTableBorders;
   cellMargins?: ParsedCellMargins;
   tblLook?: ParsedTableLook;
+  indent?: ParsedTableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: ParsedTableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: ParsedTableFloating;
 }
 
 export interface ParsedTableRow {
@@ -94,6 +120,9 @@ export interface ParsedTableRow {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
 }
 
 export interface ParsedTableCell {
@@ -106,6 +135,11 @@ export interface ParsedTableCell {
   borders?: ParsedTableCellBorders;
   shading?: ParsedCellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: ParsedCellMargins;
+  cnfStyle?: string;
 }
 
 export function parseTablesFromDocumentXml(xml: string): ParsedTableDocument {
@@ -133,6 +167,13 @@ function parseTable(node: XmlElementNode, sourceXml: string): ParsedTable {
   const borders = propertiesNode ? readTableBorders(propertiesNode) : undefined;
   const cellMargins = propertiesNode ? readTableCellMargins(propertiesNode) : undefined;
   const tblLook = propertiesNode ? readTableLook(propertiesNode) : undefined;
+  const indent = propertiesNode ? readTableIndent(propertiesNode) : undefined;
+  const layoutMode = propertiesNode ? readTableLayoutMode(propertiesNode) : undefined;
+  const cellSpacing = propertiesNode ? readTableCellSpacing(propertiesNode) : undefined;
+  const caption = propertiesNode ? readTableCaption(propertiesNode) : undefined;
+  const description = propertiesNode ? readTableDescription(propertiesNode) : undefined;
+  const bidiVisual = propertiesNode ? readTableBidiVisual(propertiesNode) : undefined;
+  const floating = propertiesNode ? readTableFloating(propertiesNode) : undefined;
 
   return {
     type: "table",
@@ -146,6 +187,13 @@ function parseTable(node: XmlElementNode, sourceXml: string): ParsedTable {
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
     ...(tblLook ? { tblLook } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
   };
 }
 
@@ -154,6 +202,9 @@ function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
   const height = propertiesNode ? readRowHeight(propertiesNode) : undefined;
   const heightRule = propertiesNode ? readRowHeightRule(propertiesNode) : undefined;
   const isHeader = propertiesNode ? readRowIsHeader(propertiesNode) : undefined;
+  const cantSplit = propertiesNode ? readRowCantSplit(propertiesNode) : undefined;
+  const horizontalAlignment = propertiesNode ? readRowHorizontalAlignment(propertiesNode) : undefined;
+  const cnfStyle = propertiesNode ? readRowCnfStyle(propertiesNode) : undefined;
 
   return {
     ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
@@ -164,6 +215,9 @@ function parseRow(node: XmlElementNode, sourceXml: string): ParsedTableRow {
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
   };
 }
 
@@ -179,6 +233,11 @@ function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
   const borders = propertiesNode ? readCellBorders(propertiesNode) : undefined;
   const shading = propertiesNode ? readCellShading(propertiesNode) : undefined;
   const verticalAlign = propertiesNode ? readCellVerticalAlign(propertiesNode) : undefined;
+  const textDirection = propertiesNode ? readCellTextDirection(propertiesNode) : undefined;
+  const noWrap = propertiesNode ? readCellNoWrap(propertiesNode) : undefined;
+  const fitText = propertiesNode ? readCellFitText(propertiesNode) : undefined;
+  const margins = propertiesNode ? readCellMargins(propertiesNode) : undefined;
+  const cnfStyle = propertiesNode ? readCellCnfStyle(propertiesNode) : undefined;
 
   return {
     ...(propertiesNode ? { propertiesXml: sourceXml.slice(propertiesNode.start, propertiesNode.end) } : {}),
@@ -190,6 +249,11 @@ function parseCell(node: XmlElementNode, sourceXml: string): ParsedTableCell {
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
   };
 }
 
@@ -606,6 +670,191 @@ export function readRowIsHeader(propertiesNode: XmlElementNode): boolean | undef
   return val !== "false" && val !== "0";
 }
 
+export function readTableIndent(propertiesNode: XmlElementNode): ParsedTableIndent | undefined {
+  const indentNode = findFirstChild(propertiesNode, "tblInd");
+  if (!indentNode) return undefined;
+  const valueRaw = indentNode.attributes["w:w"] ?? indentNode.attributes.w;
+  const value = valueRaw !== undefined ? Number.parseInt(valueRaw, 10) : 0;
+  if (!Number.isFinite(value)) return undefined;
+  const rawType = (indentNode.attributes["w:type"] ?? indentNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableIndent["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+export function readTableLayoutMode(propertiesNode: XmlElementNode): "fixed" | "autofit" | undefined {
+  const layoutNode = findFirstChild(propertiesNode, "tblLayout");
+  if (!layoutNode) return undefined;
+  const raw = (layoutNode.attributes["w:type"] ?? layoutNode.attributes.type ?? "").toLowerCase();
+  if (raw === "fixed") return "fixed";
+  if (raw === "autofit") return "autofit";
+  return undefined;
+}
+
+export function readTableCellSpacing(propertiesNode: XmlElementNode): ParsedTableWidth | undefined {
+  const spacingNode = findFirstChild(propertiesNode, "tblCellSpacing");
+  if (!spacingNode) return undefined;
+  const valueRaw = spacingNode.attributes["w:w"] ?? spacingNode.attributes.w;
+  const value = valueRaw !== undefined ? Number.parseInt(valueRaw, 10) : 0;
+  if (!Number.isFinite(value)) return undefined;
+  const rawType = (spacingNode.attributes["w:type"] ?? spacingNode.attributes.type ?? "dxa").toLowerCase();
+  const type: ParsedTableWidth["type"] =
+    rawType === "auto" ? "auto" : rawType === "pct" ? "pct" : rawType === "nil" ? "nil" : "dxa";
+  return { value, type };
+}
+
+export function readTableCaption(propertiesNode: XmlElementNode): string | undefined {
+  const captionNode = findFirstChild(propertiesNode, "tblCaption");
+  if (!captionNode) return undefined;
+  return captionNode.attributes["w:val"] ?? captionNode.attributes.val;
+}
+
+export function readTableDescription(propertiesNode: XmlElementNode): string | undefined {
+  const descriptionNode = findFirstChild(propertiesNode, "tblDescription");
+  if (!descriptionNode) return undefined;
+  return descriptionNode.attributes["w:val"] ?? descriptionNode.attributes.val;
+}
+
+export function readTableBidiVisual(propertiesNode: XmlElementNode): boolean | undefined {
+  const bidiNode = findFirstChild(propertiesNode, "bidiVisual");
+  if (!bidiNode) return undefined;
+  const val = bidiNode.attributes["w:val"] ?? bidiNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readTableFloating(propertiesNode: XmlElementNode): ParsedTableFloating | undefined {
+  const tblpPrNode = findFirstChild(propertiesNode, "tblpPr");
+  const overlapNode = findFirstChild(propertiesNode, "tblOverlap");
+  if (!tblpPrNode && !overlapNode) return undefined;
+
+  const floating: ParsedTableFloating = {};
+
+  if (tblpPrNode) {
+    const attr = (name: string): string | undefined =>
+      tblpPrNode.attributes[`w:${name}`] ?? tblpPrNode.attributes[name];
+    const num = (raw: string | undefined): number | undefined => {
+      if (raw === undefined) return undefined;
+      const parsed = Number.parseInt(raw, 10);
+      return Number.isFinite(parsed) ? parsed : undefined;
+    };
+    const anchor = (raw: string | undefined): ParsedTableFloating["horizontalAnchor"] | undefined => {
+      if (raw === "margin" || raw === "page" || raw === "text") return raw;
+      return undefined;
+    };
+    const hAlign = (raw: string | undefined): ParsedTableFloating["horizontalAlign"] | undefined => {
+      if (raw === "left" || raw === "center" || raw === "right" || raw === "inside" || raw === "outside") return raw;
+      return undefined;
+    };
+    const vAlign = (raw: string | undefined): ParsedTableFloating["verticalAlign"] | undefined => {
+      if (raw === "top" || raw === "center" || raw === "bottom" || raw === "inside" || raw === "outside") return raw;
+      return undefined;
+    };
+
+    const hAnc = anchor(attr("horzAnchor"));
+    if (hAnc) floating.horizontalAnchor = hAnc;
+    const vAnc = anchor(attr("vertAnchor"));
+    if (vAnc) floating.verticalAnchor = vAnc;
+    const hA = hAlign(attr("tblpXSpec"));
+    if (hA) floating.horizontalAlign = hA;
+    const hOff = num(attr("tblpX"));
+    if (hOff !== undefined) floating.horizontalOffset = hOff;
+    const vA = vAlign(attr("tblpYSpec"));
+    if (vA) floating.verticalAlign = vA;
+    const vOff = num(attr("tblpY"));
+    if (vOff !== undefined) floating.verticalOffset = vOff;
+    const left = num(attr("leftFromText"));
+    if (left !== undefined) floating.leftFromText = left;
+    const right = num(attr("rightFromText"));
+    if (right !== undefined) floating.rightFromText = right;
+    const top = num(attr("topFromText"));
+    if (top !== undefined) floating.topFromText = top;
+    const bottom = num(attr("bottomFromText"));
+    if (bottom !== undefined) floating.bottomFromText = bottom;
+  }
+
+  if (overlapNode) {
+    const val = (overlapNode.attributes["w:val"] ?? overlapNode.attributes.val ?? "overlap").toLowerCase();
+    floating.overlap = val === "overlap";
+  }
+
+  return Object.keys(floating).length > 0 ? floating : undefined;
+}
+
+export function readRowCantSplit(propertiesNode: XmlElementNode): boolean | undefined {
+  const cantSplitNode = findFirstChild(propertiesNode, "cantSplit");
+  if (!cantSplitNode) return undefined;
+  const val = cantSplitNode.attributes["w:val"] ?? cantSplitNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readRowHorizontalAlignment(propertiesNode: XmlElementNode): "left" | "center" | "right" | undefined {
+  const jcNode = findFirstChild(propertiesNode, "jc");
+  if (!jcNode) return undefined;
+  const val = jcNode.attributes["w:val"] ?? jcNode.attributes.val;
+  if (val === "left" || val === "center" || val === "right") return val;
+  return undefined;
+}
+
+export function readRowCnfStyle(propertiesNode: XmlElementNode): string | undefined {
+  const cnfNode = findFirstChild(propertiesNode, "cnfStyle");
+  if (!cnfNode) return undefined;
+  return cnfNode.attributes["w:val"] ?? cnfNode.attributes.val;
+}
+
+export function readCellTextDirection(propertiesNode: XmlElementNode): "lrTb" | "tbRl" | "btLr" | undefined {
+  const dirNode = findFirstChild(propertiesNode, "textDirection");
+  if (!dirNode) return undefined;
+  const val = dirNode.attributes["w:val"] ?? dirNode.attributes.val;
+  if (val === "lrTb" || val === "tbRl" || val === "btLr") return val;
+  return undefined;
+}
+
+export function readCellNoWrap(propertiesNode: XmlElementNode): boolean | undefined {
+  const noWrapNode = findFirstChild(propertiesNode, "noWrap");
+  if (!noWrapNode) return undefined;
+  const val = noWrapNode.attributes["w:val"] ?? noWrapNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readCellFitText(propertiesNode: XmlElementNode): boolean | undefined {
+  const fitNode = findFirstChild(propertiesNode, "tcFitText");
+  if (!fitNode) return undefined;
+  const val = fitNode.attributes["w:val"] ?? fitNode.attributes.val;
+  return val !== "false" && val !== "0" && val !== "off";
+}
+
+export function readCellMargins(propertiesNode: XmlElementNode): ParsedCellMargins | undefined {
+  const marginsNode = findFirstChild(propertiesNode, "tcMar");
+  if (!marginsNode) return undefined;
+  const readSide = (name: string): number | undefined => {
+    const sideNode = findFirstChild(marginsNode, name);
+    if (!sideNode) return undefined;
+    const raw = sideNode.attributes["w:w"] ?? sideNode.attributes.w;
+    if (raw === undefined) return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  };
+  const top = readSide("top");
+  const bottom = readSide("bottom");
+  const left = readSide("start") ?? readSide("left");
+  const right = readSide("end") ?? readSide("right");
+  if (top === undefined && bottom === undefined && left === undefined && right === undefined) {
+    return undefined;
+  }
+  return {
+    ...(top !== undefined ? { top } : {}),
+    ...(bottom !== undefined ? { bottom } : {}),
+    ...(left !== undefined ? { left } : {}),
+    ...(right !== undefined ? { right } : {}),
+  };
+}
+
+export function readCellCnfStyle(propertiesNode: XmlElementNode): string | undefined {
+  const cnfNode = findFirstChild(propertiesNode, "cnfStyle");
+  if (!cnfNode) return undefined;
+  return cnfNode.attributes["w:val"] ?? cnfNode.attributes.val;
+}
+
 function parseBorderSpec(child: XmlElementNode): ParsedBorderSpec | undefined {
   const value = child.attributes["w:val"] ?? child.attributes.val;
   const sizeRaw = child.attributes["w:sz"] ?? child.attributes.sz;

package/src/io/ooxml/xml-attr-helpers.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared XML helpers for OOXML parsers.
+ *
+ * These functions factor out the common pattern of reading namespaced-prefixed
+ * attributes (e.g., `w:val`) with fallback to the unprefixed form, handling
+ * the OOXML `ST_OnOff` toggle semantics (missing child = undefined, present
+ * with no val = true, `val="0"|"false"|"off"` = false), and reading integers.
+ *
+ * Used by parse-run-formatting.ts, parse-paragraph-formatting.ts, and (later)
+ * parse-styles.ts, parse-numbering.ts.
+ */
+
+import type { XmlElementNode } from "./xml-element.ts";
+
+export function localName(name: string): string {
+  const sep = name.indexOf(":");
+  return sep >= 0 ? name.slice(sep + 1) : name;
+}
+
+export function findChildOptional(
+  node: XmlElementNode,
+  local: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (c): c is XmlElementNode => c.type === "element" && localName(c.name) === local,
+  );
+}
+
+/** ST_OnOff: missing child → undefined; present bare or w:val="1|true|on" → true; w:val="0|false|off" → false. */
+export function readOnOff(node: XmlElementNode | undefined): boolean | undefined {
+  if (!node) return undefined;
+  const raw = node.attributes["w:val"] ?? node.attributes.val;
+  if (raw === undefined) return true;
+  const n = raw.toLowerCase();
+  if (n === "0" || n === "false" || n === "off") return false;
+  if (n === "1" || n === "true" || n === "on") return true;
+  return true;
+}
+
+/** Read the child's `w:val` attribute as an int. Returns undefined if missing or not a finite integer. */
+export function readIntVal(node: XmlElementNode | undefined): number | undefined {
+  if (!node) return undefined;
+  const raw = node.attributes["w:val"] ?? node.attributes.val;
+  if (raw === undefined) return undefined;
+  const v = Number.parseInt(raw, 10);
+  return Number.isFinite(v) ? v : undefined;
+}
+
+/** Read an arbitrary attribute from a node as an int, with namespace fallback. */
+export function readIntAttr(node: XmlElementNode, attr: string): number | undefined {
+  const raw = node.attributes[attr] ?? node.attributes[attr.replace(/^w:/, "")];
+  if (raw === undefined) return undefined;
+  const v = Number.parseInt(raw, 10);
+  return Number.isFinite(v) ? v : undefined;
+}
+
+/** Read an arbitrary attribute from a node as a string, with namespace fallback. */
+export function readStringAttr(node: XmlElementNode, attr: string): string | undefined {
+  return node.attributes[attr] ?? node.attributes[attr.replace(/^w:/, "")];
+}

package/src/io/ooxml/xml-element.ts

@@ -0,0 +1,19 @@
+export interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: Array<XmlElementNode | XmlTextNode>;
+  /** Optional source offset (start) — parsers that track offsets may populate. */
+  start?: number;
+  /** Optional source offset (end) — parsers that track offsets may populate. */
+  end?: number;
+}
+
+export interface XmlTextNode {
+  type: "text";
+  text: string;
+  start?: number;
+  end?: number;
+}
+
+export type XmlNode = XmlElementNode | XmlTextNode;

package/src/model/canonical-document.ts

@@ -83,6 +83,7 @@ export interface StylesCatalog {
   tables: Record<string, TableStyleDefinition>;
   latentStyles?: Record<string, LatentStyleDefinition>;
   fromPackage?: boolean;
+  docDefaults?: DocumentDefaults;
 }
 
 export interface ParagraphStyleDefinition {
@@ -94,6 +95,8 @@ export interface ParagraphStyleDefinition {
   displayName: string;
   kind: "paragraph";
   isDefault: boolean;
+  paragraphProperties?: CanonicalParagraphFormatting;
+  runProperties?: CanonicalRunFormatting;
 }
 
 export interface ParagraphStyleNumberingReference {
@@ -107,6 +110,7 @@ export interface CharacterStyleDefinition {
   displayName: string;
   kind: "character";
   isDefault: boolean;
+  runProperties?: CanonicalRunFormatting;
 }
 
 export interface TableStyleDefinition {
@@ -136,6 +140,12 @@ export interface NumberingCatalog {
 export interface AbstractNumberingDefinition {
   abstractNumberingId: string;
   levels: NumberingLevelDefinition[];
+  nsid?: string;
+  multiLevelType?: "singleLevel" | "multilevel" | "hybridMultilevel";
+  /** ECMA-376 17.9.26 `<w:tmpl>` — template code identifying the abstractNum's origin template (ST_LongHexNumber). Preserved for round-trip. */
+  tplc?: string;
+  styleLink?: string;
+  numStyleLink?: string;
 }
 
 export interface NumberingLevelParagraphGeometry {
@@ -154,6 +164,8 @@ export interface NumberingLevelDefinition {
   isLegalNumbering?: boolean;
   suffix?: "tab" | "space" | "nothing";
   paragraphGeometry?: NumberingLevelParagraphGeometry;
+  runProperties?: CanonicalRunFormatting;
+  restartAfterLevel?: number;
 }
 
 export interface NumberingLevelOverrideDefinition {
@@ -165,6 +177,8 @@ export interface NumberingLevelOverrideDefinition {
   isLegalNumbering?: boolean;
   suffix?: "tab" | "space" | "nothing";
   paragraphGeometry?: NumberingLevelParagraphGeometry;
+  runProperties?: CanonicalRunFormatting;
+  restartAfterLevel?: number;
 }
 
 export interface NumberingInstance {
@@ -350,6 +364,68 @@ export interface ParagraphShading {
   val?: string;
 }
 
+/** Body of an OOXML `<w:rPr>` (run properties). All fields optional; absence = "not specified at this level". */
+export interface CanonicalRunFormatting {
+  bold?: boolean;
+  italic?: boolean;
+  underline?: "single" | "double" | "thick" | "dotted" | "dash" | "wave" | "none";
+  strikethrough?: boolean;
+  doubleStrikethrough?: boolean;
+  vanish?: boolean;
+  allCaps?: boolean;
+  smallCaps?: boolean;
+  verticalAlign?: "baseline" | "superscript" | "subscript";
+  /**
+   * Convenience alias for the primary font family — the first non-empty of
+   * `fontFamilyAscii` → `fontFamilyHAnsi` → `fontFamilyEastAsia` → `fontFamilyCs`.
+   * Script-aware consumers should read the specific `fontFamily{Ascii,HAnsi,EastAsia,Cs}`
+   * fields directly.
+   */
+  fontFamily?: string;
+  fontFamilyAscii?: string;
+  fontFamilyHAnsi?: string;
+  fontFamilyEastAsia?: string;
+  fontFamilyCs?: string;
+  fontSizeHalfPoints?: number;
+  fontSizeCsHalfPoints?: number;
+  /**
+   * Color value from `<w:color w:val>`. Either an OOXML hex (e.g., `"2E74B5"`)
+   * or the sentinel `"auto"` (which serializers must round-trip verbatim).
+   */
+  colorHex?: string;
+  colorThemeSlot?: string;
+  highlight?: string;
+  characterSpacingTwips?: number;
+  characterStyleId?: string;
+  languageCode?: string;
+}
+
+/** Body of an OOXML `<w:pPr>` (paragraph properties). All fields optional; absence = "not specified at this level". */
+export interface CanonicalParagraphFormatting {
+  spacing?: ParagraphSpacing;
+  indentation?: ParagraphIndentation;
+  alignment?: "left" | "center" | "right" | "both" | "distribute" | "start" | "end";
+  borders?: ParagraphBorders;
+  shading?: ParagraphShading;
+  tabStops?: TabStop[];
+  contextualSpacing?: boolean;
+  keepNext?: boolean;
+  keepLines?: boolean;
+  widowControl?: boolean;
+  pageBreakBefore?: boolean;
+  outlineLevel?: number;
+  bidi?: boolean;
+  suppressLineNumbers?: boolean;
+  suppressAutoHyphens?: boolean;
+  paragraphMarkRunProperties?: CanonicalRunFormatting;
+}
+
+/** Body of an OOXML `<w:docDefaults>` — baseline formatting applied before style chain. */
+export interface DocumentDefaults {
+  paragraph?: CanonicalParagraphFormatting;
+  run?: CanonicalRunFormatting;
+}
+
 export interface ParagraphNode {
   type: "paragraph";
   styleId?: string;
@@ -416,6 +492,25 @@ export interface TableWidth {
   type: "dxa" | "auto" | "pct" | "nil";
 }
 
+export interface TableIndent {
+  value: number;
+  type: "dxa" | "auto" | "pct" | "nil";
+}
+
+export interface TableFloatingProperties {
+  horizontalAnchor?: "margin" | "page" | "text";
+  verticalAnchor?: "margin" | "page" | "text";
+  horizontalAlign?: "left" | "center" | "right" | "inside" | "outside";
+  horizontalOffset?: number;
+  verticalAlign?: "top" | "center" | "bottom" | "inside" | "outside";
+  verticalOffset?: number;
+  leftFromText?: number;
+  rightFromText?: number;
+  topFromText?: number;
+  bottomFromText?: number;
+  overlap?: boolean;
+}
+
 export interface CellShading {
   fill?: string;
   color?: string;
@@ -481,6 +576,13 @@ export interface TableNode {
   borders?: TableBorders;
   cellMargins?: TableCellMargins;
   tblLook?: TableLook;
+  indent?: TableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: TableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: TableFloatingProperties;
 }
 
 export interface TableRowNode {
@@ -494,6 +596,9 @@ export interface TableRowNode {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
 }
 
 export interface TableCellNode {
@@ -506,6 +611,11 @@ export interface TableCellNode {
   borders?: TableCellBorders;
   shading?: CellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: TableCellMargins;
+  cnfStyle?: string;
 }
 
 export interface SdtCheckboxState {
@@ -560,15 +670,19 @@ export interface AltChunkNode {
  * These families have stable registry IDs, dependency metadata, and
  * runtime-owned refresh behavior.
  */
-export type SupportedFieldFamily = "REF" | "PAGEREF" | "NOTEREF" | "TOC";
+export type SupportedFieldFamily =
+  | "REF"
+  | "PAGEREF"
+  | "NOTEREF"
+  | "TOC"
+  | "PAGE"
+  | "NUMPAGES";
 
 /**
  * Unsupported field families that remain preserve-only.
  * They survive round-trip but do not participate in runtime refresh.
  */
 export type PreserveOnlyFieldFamily =
-  | "PAGE"
-  | "NUMPAGES"
   | "DATE"
   | "TIME"
   | "AUTHOR"