@beyondwork/docx-react-component 1.0.37 → 1.0.38

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

@@ -10,6 +10,8 @@ import type {
   TableBorders,
   TableCellBorders,
   TableCellMargins,
+  TableFloatingProperties,
+  TableIndent,
   TableLook,
   TableWidth,
   SectionProperties,
@@ -35,16 +37,31 @@ import { classifyFieldInstruction } from "./parse-fields.ts";
 import { resolveHighlightColor } from "./highlight-colors.ts";
 import {
   readCellBorders as readSharedCellBorders,
+  readCellCnfStyle as readSharedCellCnfStyle,
+  readCellFitText as readSharedCellFitText,
+  readCellMargins as readSharedCellMargins,
+  readCellNoWrap as readSharedCellNoWrap,
   readCellShading as readSharedCellShading,
+  readCellTextDirection as readSharedCellTextDirection,
   readCellVerticalAlign as readSharedCellVerticalAlign,
   readCellWidth as readSharedCellWidth,
   readGridColumns as readSharedGridColumns,
+  readRowCantSplit as readSharedRowCantSplit,
+  readRowCnfStyle as readSharedRowCnfStyle,
   readRowHeight as readSharedRowHeight,
   readRowHeightRule as readSharedRowHeightRule,
+  readRowHorizontalAlignment as readSharedRowHorizontalAlignment,
   readRowIsHeader as readSharedRowIsHeader,
   readTableAlignment as readSharedTableAlignment,
+  readTableBidiVisual as readSharedTableBidiVisual,
   readTableBorders as readSharedTableBorders,
+  readTableCaption as readSharedTableCaption,
   readTableCellMargins as readSharedTableCellMargins,
+  readTableCellSpacing as readSharedTableCellSpacing,
+  readTableDescription as readSharedTableDescription,
+  readTableFloating as readSharedTableFloating,
+  readTableIndent as readSharedTableIndent,
+  readTableLayoutMode as readSharedTableLayoutMode,
   readTableLook as readSharedTableLook,
   readTableStyleId as readSharedTableStyleId,
   readTableWidth as readSharedTableWidth,
@@ -332,6 +349,13 @@ export interface ParsedTableBlockNode {
   alignment?: "left" | "center" | "right";
   borders?: TableBorders;
   cellMargins?: TableCellMargins;
+  indent?: TableIndent;
+  layoutMode?: "fixed" | "autofit";
+  cellSpacing?: TableWidth;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: TableFloatingProperties;
   rawXml: string;
 }
 
@@ -346,6 +370,9 @@ export interface ParsedTableRowNode {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: "left" | "center" | "right";
+  cnfStyle?: string;
   rawXml: string;
 }
 
@@ -359,6 +386,11 @@ export interface ParsedTableCellNode {
   borders?: TableCellBorders;
   shading?: CellShading;
   verticalAlign?: "top" | "center" | "bottom";
+  textDirection?: "lrTb" | "tbRl" | "btLr";
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: TableCellMargins;
+  cnfStyle?: string;
   rawXml: string;
 }
 
@@ -857,6 +889,13 @@ function parseTableElement(
   let alignment: ParsedTableBlockNode["alignment"];
   let borders: TableBorders | undefined;
   let cellMargins: TableCellMargins | undefined;
+  let indent: TableIndent | undefined;
+  let layoutMode: ParsedTableBlockNode["layoutMode"];
+  let cellSpacing: TableWidth | undefined;
+  let caption: string | undefined;
+  let description: string | undefined;
+  let bidiVisual: boolean | undefined;
+  let floating: TableFloatingProperties | undefined;
   const rows: ParsedTableRowNode[] = [];
 
   for (const child of node.children) {
@@ -871,6 +910,13 @@ function parseTableElement(
         alignment = readTableAlignment(child);
         borders = readTableBorders(child);
         cellMargins = readTableCellMargins(child);
+        indent = readTableIndent(child);
+        layoutMode = readTableLayoutMode(child);
+        cellSpacing = readTableCellSpacing(child);
+        caption = readTableCaption(child);
+        description = readTableDescription(child);
+        bidiVisual = readTableBidiVisual(child);
+        floating = readTableFloating(child);
         break;
       }
       case "tblGrid": {
@@ -895,6 +941,13 @@ function parseTableElement(
     ...(alignment ? { alignment } : {}),
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
     rawXml: sourceXml.slice(node.start, node.end),
   };
 }
@@ -915,6 +968,9 @@ function parseTableRowElement(
   let height: number | undefined;
   let heightRule: ParsedTableRowNode["heightRule"];
   let isHeader: boolean | undefined;
+  let cantSplit: boolean | undefined;
+  let horizontalAlignment: ParsedTableRowNode["horizontalAlignment"];
+  let cnfStyle: string | undefined;
   const cells: ParsedTableCellNode[] = [];
 
   for (const child of node.children) {
@@ -930,6 +986,9 @@ function parseTableRowElement(
         height = readRowHeight(child);
         heightRule = readRowHeightRule(child);
         isHeader = readRowIsHeader(child);
+        cantSplit = readRowCantSplit(child);
+        horizontalAlignment = readRowHorizontalAlignment(child);
+        cnfStyle = readRowCnfStyle(child);
         break;
       case "tc":
         cells.push(parseTableCellElement(child, sourceXml, relationshipMap, relationships, mediaParts, sourcePartPath));
@@ -947,6 +1006,9 @@ function parseTableRowElement(
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     cells,
     rawXml: sourceXml.slice(node.start, node.end),
   };
@@ -967,6 +1029,11 @@ function parseTableCellElement(
   let borders: TableCellBorders | undefined;
   let shading: CellShading | undefined;
   let verticalAlign: ParsedTableCellNode["verticalAlign"];
+  let textDirection: ParsedTableCellNode["textDirection"];
+  let noWrap: boolean | undefined;
+  let fitText: boolean | undefined;
+  let margins: TableCellMargins | undefined;
+  let cnfStyle: string | undefined;
   const children: ParsedBlockNode[] = [];
 
   for (const child of node.children) {
@@ -981,6 +1048,11 @@ function parseTableCellElement(
         borders = readCellBorders(child);
         shading = readCellShading(child);
         verticalAlign = readCellVerticalAlign(child);
+        textDirection = readCellTextDirection(child);
+        noWrap = readCellNoWrap(child);
+        fitText = readCellFitText(child);
+        margins = readCellMargins(child);
+        cnfStyle = readCellCnfStyle(child);
         break;
       }
       default: {
@@ -1001,6 +1073,11 @@ function parseTableCellElement(
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     rawXml: sourceXml.slice(node.start, node.end),
   };
 }
@@ -1274,6 +1351,66 @@ function readCellVerticalAlign(node: XmlElementNode): ParsedTableCellNode["verti
   return readSharedCellVerticalAlign(node);
 }
 
+function readTableIndent(node: XmlElementNode): TableIndent | undefined {
+  return readSharedTableIndent(node);
+}
+
+function readTableLayoutMode(node: XmlElementNode): ParsedTableBlockNode["layoutMode"] {
+  return readSharedTableLayoutMode(node);
+}
+
+function readTableCellSpacing(node: XmlElementNode): TableWidth | undefined {
+  return readSharedTableCellSpacing(node);
+}
+
+function readTableCaption(node: XmlElementNode): string | undefined {
+  return readSharedTableCaption(node);
+}
+
+function readTableDescription(node: XmlElementNode): string | undefined {
+  return readSharedTableDescription(node);
+}
+
+function readTableBidiVisual(node: XmlElementNode): boolean | undefined {
+  return readSharedTableBidiVisual(node);
+}
+
+function readTableFloating(node: XmlElementNode): TableFloatingProperties | undefined {
+  return readSharedTableFloating(node);
+}
+
+function readRowCantSplit(node: XmlElementNode): boolean | undefined {
+  return readSharedRowCantSplit(node);
+}
+
+function readRowHorizontalAlignment(node: XmlElementNode): ParsedTableRowNode["horizontalAlignment"] {
+  return readSharedRowHorizontalAlignment(node);
+}
+
+function readRowCnfStyle(node: XmlElementNode): string | undefined {
+  return readSharedRowCnfStyle(node);
+}
+
+function readCellTextDirection(node: XmlElementNode): ParsedTableCellNode["textDirection"] {
+  return readSharedCellTextDirection(node);
+}
+
+function readCellNoWrap(node: XmlElementNode): boolean | undefined {
+  return readSharedCellNoWrap(node);
+}
+
+function readCellFitText(node: XmlElementNode): boolean | undefined {
+  return readSharedCellFitText(node);
+}
+
+function readCellMargins(node: XmlElementNode): TableCellMargins | undefined {
+  return readSharedCellMargins(node);
+}
+
+function readCellCnfStyle(node: XmlElementNode): string | undefined {
+  return readSharedCellCnfStyle(node);
+}
+
 /**
  * Check if a table's raw XML contains content that cannot safely round-trip
  * through the parsed table path yet. This includes:

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/model/canonical-document.ts

@@ -416,6 +416,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 +500,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 +520,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 +535,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 {

package/src/runtime/document-layout.ts

@@ -15,6 +15,7 @@ import type {
   SubPartsCatalog,
 } from "../model/canonical-document.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+import { resolveDefaultPageSizeTwips } from "./layout/default-page-format.ts";
 import {
   resolveSectionVariants,
   sectionSupportsStoryTarget,
@@ -88,9 +89,10 @@ export function buildPageLayoutSnapshot(
   properties: SectionProperties | undefined,
   subParts: SubPartsCatalog | undefined,
 ): PageLayoutSnapshot {
+  const defaultSize = resolveDefaultPageSizeTwips();
   const pageSize = properties?.pageSize ?? {
-    width: 12240,
-    height: 15840,
+    width: defaultSize.widthTwips,
+    height: defaultSize.heightTwips,
     orientation: "portrait" as const,
   };
   const margins = properties?.pageMargins ?? {

package/src/runtime/document-navigation.ts

@@ -206,7 +206,7 @@ function headingLevelFromStyleId(styleId?: string): number | null {
   return null;
 }
 
-function buildHeadingOutline(
+export function buildHeadingOutline(
   document: CanonicalDocumentEnvelope,
   mainSurface: EditorSurfaceSnapshot,
   sections: ResolvedDocumentSection[],