@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/io/export/table-properties-xml.ts

@@ -1,3 +1,5 @@
+import { twip } from "./twip.ts";
+
 interface TableWidthLike {
   value: number;
   type: string;
@@ -42,6 +44,25 @@ interface CellShadingLike {
   fill?: string;
 }
 
+interface TableIndentLike {
+  value: number;
+  type: string;
+}
+
+interface TableFloatingPropertiesLike {
+  horizontalAnchor?: string;
+  verticalAnchor?: string;
+  horizontalAlign?: string;
+  horizontalOffset?: number;
+  verticalAlign?: string;
+  verticalOffset?: number;
+  leftFromText?: number;
+  rightFromText?: number;
+  topFromText?: number;
+  bottomFromText?: number;
+  overlap?: boolean;
+}
+
 interface TablePropertiesLike {
   propertiesXml?: string;
   styleId?: string;
@@ -50,6 +71,13 @@ interface TablePropertiesLike {
   borders?: TableBordersLike;
   cellMargins?: TableCellMarginsLike;
   tblLook?: TableLookLike;
+  indent?: TableIndentLike;
+  layoutMode?: string;
+  cellSpacing?: TableWidthLike;
+  caption?: string;
+  description?: string;
+  bidiVisual?: boolean;
+  floating?: TableFloatingPropertiesLike;
 }
 
 interface TableRowPropertiesLike {
@@ -61,6 +89,9 @@ interface TableRowPropertiesLike {
   height?: number;
   heightRule?: string;
   isHeader?: boolean;
+  cantSplit?: boolean;
+  horizontalAlignment?: string;
+  cnfStyle?: string;
 }
 
 interface TableCellPropertiesLike {
@@ -71,6 +102,11 @@ interface TableCellPropertiesLike {
   borders?: TableBordersLike;
   shading?: CellShadingLike;
   verticalAlign?: string;
+  textDirection?: string;
+  noWrap?: boolean;
+  fitText?: boolean;
+  margins?: TableCellMarginsLike;
+  cnfStyle?: string;
 }
 
 interface PropertyStripSpec {
@@ -80,16 +116,49 @@ interface PropertyStripSpec {
 
 const TABLE_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
   pairedTags: ["w:tblBorders", "w:tblCellMar"],
-  selfClosingTags: ["w:tblStyle", "w:tblW", "w:jc", "w:tblLook"],
+  selfClosingTags: [
+    "w:tblStyle",
+    "w:tblW",
+    "w:jc",
+    "w:tblLook",
+    "w:tblInd",
+    "w:tblLayout",
+    "w:tblCellSpacing",
+    "w:tblCaption",
+    "w:tblDescription",
+    "w:bidiVisual",
+    "w:tblpPr",
+    "w:tblOverlap",
+  ],
 };
 
 const ROW_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
-  selfClosingTags: ["w:gridBefore", "w:wBefore", "w:gridAfter", "w:wAfter", "w:trHeight", "w:tblHeader"],
+  selfClosingTags: [
+    "w:gridBefore",
+    "w:wBefore",
+    "w:gridAfter",
+    "w:wAfter",
+    "w:trHeight",
+    "w:tblHeader",
+    "w:cantSplit",
+    "w:jc",
+    "w:cnfStyle",
+  ],
 };
 
 const CELL_PROPERTY_STRIP_SPEC: PropertyStripSpec = {
-  pairedTags: ["w:tcBorders"],
-  selfClosingTags: ["w:tcW", "w:gridSpan", "w:vMerge", "w:shd", "w:vAlign"],
+  pairedTags: ["w:tcBorders", "w:tcMar"],
+  selfClosingTags: [
+    "w:tcW",
+    "w:gridSpan",
+    "w:vMerge",
+    "w:shd",
+    "w:vAlign",
+    "w:textDirection",
+    "w:noWrap",
+    "w:tcFitText",
+    "w:cnfStyle",
+  ],
 };
 
 export function serializeTablePropertiesXml(table: TablePropertiesLike): string {
@@ -172,6 +241,28 @@ function buildTablePropertiesInnerXml(table: TablePropertiesLike): string {
   if (table.alignment) {
     children.push(`<w:jc w:val="${escapeAttribute(table.alignment)}"/>`);
   }
+  if (table.indent) {
+    children.push(`<w:tblInd w:w="${table.indent.value}" w:type="${escapeAttribute(table.indent.type)}"/>`);
+  }
+  if (table.layoutMode) {
+    children.push(`<w:tblLayout w:type="${escapeAttribute(table.layoutMode)}"/>`);
+  }
+  if (table.cellSpacing) {
+    children.push(`<w:tblCellSpacing w:w="${table.cellSpacing.value}" w:type="${escapeAttribute(table.cellSpacing.type)}"/>`);
+  }
+  if (table.bidiVisual !== undefined) {
+    children.push(table.bidiVisual ? `<w:bidiVisual/>` : `<w:bidiVisual w:val="0"/>`);
+  }
+  if (table.caption !== undefined) {
+    children.push(`<w:tblCaption w:val="${escapeAttribute(table.caption)}"/>`);
+  }
+  if (table.description !== undefined) {
+    children.push(`<w:tblDescription w:val="${escapeAttribute(table.description)}"/>`);
+  }
+  if (table.floating) {
+    const floatingXml = serializeTableFloating(table.floating);
+    if (floatingXml) children.push(floatingXml);
+  }
   if (table.borders) {
     const bordersXml = serializeBorders(table.borders);
     if (bordersXml) {
@@ -193,37 +284,80 @@ function buildTablePropertiesInnerXml(table: TablePropertiesLike): string {
   return children.join("");
 }
 
+function serializeTableFloating(floating: TableFloatingPropertiesLike): string {
+  const attrs: string[] = [];
+  if (floating.horizontalAnchor) attrs.push(`w:horzAnchor="${escapeAttribute(floating.horizontalAnchor)}"`);
+  if (floating.verticalAnchor) attrs.push(`w:vertAnchor="${escapeAttribute(floating.verticalAnchor)}"`);
+  if (floating.horizontalAlign) attrs.push(`w:tblpXSpec="${escapeAttribute(floating.horizontalAlign)}"`);
+  if (floating.horizontalOffset !== undefined) attrs.push(`w:tblpX="${floating.horizontalOffset}"`);
+  if (floating.verticalAlign) attrs.push(`w:tblpYSpec="${escapeAttribute(floating.verticalAlign)}"`);
+  if (floating.verticalOffset !== undefined) attrs.push(`w:tblpY="${floating.verticalOffset}"`);
+  if (floating.leftFromText !== undefined) attrs.push(`w:leftFromText="${floating.leftFromText}"`);
+  if (floating.rightFromText !== undefined) attrs.push(`w:rightFromText="${floating.rightFromText}"`);
+  if (floating.topFromText !== undefined) attrs.push(`w:topFromText="${floating.topFromText}"`);
+  if (floating.bottomFromText !== undefined) attrs.push(`w:bottomFromText="${floating.bottomFromText}"`);
+  const tblpPr = attrs.length > 0 ? `<w:tblpPr ${attrs.join(" ")}/>` : "";
+  const overlap = floating.overlap !== undefined
+    ? `<w:tblOverlap w:val="${floating.overlap ? "overlap" : "never"}"/>`
+    : "";
+  return `${tblpPr}${overlap}`;
+}
+
 function buildTableRowPropertiesInnerXml(row: TableRowPropertiesLike): string {
   const children: string[] = [];
+  if (row.cnfStyle) {
+    children.push(`<w:cnfStyle w:val="${escapeAttribute(row.cnfStyle)}"/>`);
+  }
   if (row.gridBefore !== undefined) {
-    children.push(`<w:gridBefore w:val="${row.gridBefore}"/>`);
+    children.push(`<w:gridBefore w:val="${twip(row.gridBefore)}"/>`);
   }
   if (row.widthBefore) {
-    children.push(`<w:wBefore w:w="${row.widthBefore.value}" w:type="${row.widthBefore.type}"/>`);
+    children.push(
+      `<w:wBefore w:w="${twip(row.widthBefore.value)}" w:type="${row.widthBefore.type}"/>`,
+    );
   }
   if (row.gridAfter !== undefined) {
-    children.push(`<w:gridAfter w:val="${row.gridAfter}"/>`);
+    children.push(`<w:gridAfter w:val="${twip(row.gridAfter)}"/>`);
   }
   if (row.widthAfter) {
-    children.push(`<w:wAfter w:w="${row.widthAfter.value}" w:type="${row.widthAfter.type}"/>`);
+    children.push(
+      `<w:wAfter w:w="${twip(row.widthAfter.value)}" w:type="${row.widthAfter.type}"/>`,
+    );
+  }
+  if (row.cantSplit !== undefined) {
+    children.push(row.cantSplit ? `<w:cantSplit/>` : `<w:cantSplit w:val="0"/>`);
   }
   if (row.height !== undefined) {
     const hRuleAttr = row.heightRule ? ` w:hRule="${escapeAttribute(row.heightRule)}"` : "";
-    children.push(`<w:trHeight w:val="${row.height}"${hRuleAttr}/>`);
+    children.push(`<w:trHeight w:val="${twip(row.height)}"${hRuleAttr}/>`);
   }
-  if (row.isHeader !== undefined) {
-    children.push(row.isHeader ? `<w:tblHeader/>` : `<w:tblHeader w:val="0"/>`);
+  // ST_OnOff element (A.3):
+  // - true  → <w:tblHeader/> (element-only form = implicit true).
+  // - false → <w:tblHeader w:val="false"/> (explicit override — canonical
+  //            carries an explicit false because the source distinguished it
+  //            from "missing" at import time; never emit "0"/"1" per A.3).
+  // - undefined → omit (no element).
+  if (row.isHeader === true) {
+    children.push(`<w:tblHeader/>`);
+  } else if (row.isHeader === false) {
+    children.push(`<w:tblHeader w:val="false"/>`);
+  }
+  if (row.horizontalAlignment) {
+    children.push(`<w:jc w:val="${escapeAttribute(row.horizontalAlignment)}"/>`);
   }
   return children.join("");
 }
 
 function buildTableCellPropertiesInnerXml(cell: TableCellPropertiesLike): string {
   const children: string[] = [];
+  if (cell.cnfStyle) {
+    children.push(`<w:cnfStyle w:val="${escapeAttribute(cell.cnfStyle)}"/>`);
+  }
   if (cell.width) {
     children.push(serializeWidth("tcW", cell.width));
   }
   if (cell.gridSpan && cell.gridSpan > 1) {
-    children.push(`<w:gridSpan w:val="${cell.gridSpan}"/>`);
+    children.push(`<w:gridSpan w:val="${twip(cell.gridSpan)}"/>`);
   }
   if (cell.verticalMerge) {
     children.push(
@@ -244,6 +378,21 @@ function buildTableCellPropertiesInnerXml(cell: TableCellPropertiesLike): string
       children.push(shadingXml);
     }
   }
+  if (cell.margins) {
+    const marginsXml = serializeTableCellMargins(cell.margins);
+    if (marginsXml) {
+      children.push(`<w:tcMar>${marginsXml}</w:tcMar>`);
+    }
+  }
+  if (cell.noWrap !== undefined) {
+    children.push(cell.noWrap ? `<w:noWrap/>` : `<w:noWrap w:val="0"/>`);
+  }
+  if (cell.fitText !== undefined) {
+    children.push(cell.fitText ? `<w:tcFitText/>` : `<w:tcFitText w:val="0"/>`);
+  }
+  if (cell.textDirection) {
+    children.push(`<w:textDirection w:val="${escapeAttribute(cell.textDirection)}"/>`);
+  }
   if (cell.verticalAlign) {
     children.push(`<w:vAlign w:val="${escapeAttribute(cell.verticalAlign)}"/>`);
   }
@@ -251,7 +400,9 @@ function buildTableCellPropertiesInnerXml(cell: TableCellPropertiesLike): string
 }
 
 function serializeWidth(elementName: "tblW" | "tcW", width: TableWidthLike): string {
-  return `<w:${elementName} w:w="${width.value}" w:type="${escapeAttribute(width.type)}"/>`;
+  // OOXML allows w:w to be percentage (pct) or twentieths-of-a-percent too, but
+  // both are integer-typed in the schema. Always round at the authoring edge.
+  return `<w:${elementName} w:w="${twip(width.value)}" w:type="${escapeAttribute(width.type)}"/>`;
 }
 
 function serializeBorders(borders: TableBordersLike): string {
@@ -265,18 +416,18 @@ function serializeBorders(borders: TableBordersLike): string {
 function serializeBorderSpec(elementName: string, border: BorderSpecLike): string {
   const attrs: string[] = [];
   if (border.value) attrs.push(`w:val="${escapeAttribute(border.value)}"`);
-  if (border.size !== undefined) attrs.push(`w:sz="${border.size}"`);
-  if (border.space !== undefined) attrs.push(`w:space="${border.space}"`);
+  if (border.size !== undefined) attrs.push(`w:sz="${twip(border.size)}"`);
+  if (border.space !== undefined) attrs.push(`w:space="${twip(border.space)}"`);
   if (border.color) attrs.push(`w:color="${escapeAttribute(border.color)}"`);
   return attrs.length > 0 ? `<w:${elementName} ${attrs.join(" ")}/>` : "";
 }
 
 function serializeTableCellMargins(margins: TableCellMarginsLike): string {
   const parts: string[] = [];
-  if (margins.top !== undefined) parts.push(`<w:top w:w="${margins.top}" w:type="dxa"/>`);
-  if (margins.left !== undefined) parts.push(`<w:left w:w="${margins.left}" w:type="dxa"/>`);
-  if (margins.bottom !== undefined) parts.push(`<w:bottom w:w="${margins.bottom}" w:type="dxa"/>`);
-  if (margins.right !== undefined) parts.push(`<w:right w:w="${margins.right}" w:type="dxa"/>`);
+  if (margins.top !== undefined) parts.push(`<w:top w:w="${twip(margins.top)}" w:type="dxa"/>`);
+  if (margins.left !== undefined) parts.push(`<w:left w:w="${twip(margins.left)}" w:type="dxa"/>`);
+  if (margins.bottom !== undefined) parts.push(`<w:bottom w:w="${twip(margins.bottom)}" w:type="dxa"/>`);
+  if (margins.right !== undefined) parts.push(`<w:right w:w="${twip(margins.right)}" w:type="dxa"/>`);
   return parts.join("");
 }
 
@@ -295,7 +446,10 @@ function serializeTableLook(tblLook: TableLookLike): string {
   ] as const) {
     const value = tblLook[key];
     if (value !== undefined) {
-      attrs.push(`${attr}="${value ? "1" : "0"}"`);
+      // tblLook individual attributes are ST_OnOff per ECMA-376 2nd Ed.
+      // Emit the string form ("true"/"false"); the "1"/"0" form is rejected
+      // by DocumentFormat.OpenXml's enumeration validator.
+      attrs.push(`${attr}="${value ? "true" : "false"}"`);
     }
   }
   return attrs.length > 0 ? `<w:tblLook ${attrs.join(" ")}/>` : "";

package/src/io/export/twip.ts

@@ -0,0 +1,66 @@
+/**
+ * Integer-twip guard for OOXML numeric attributes.
+ *
+ * OOXML twip-based attributes (w:ind.left, w:pgSz.w, w:tblW.w, w:tcW.w,
+ * w:gridCol.w, w:trHeight.val, border w:sz, tab-stop w:pos, etc.) are
+ * schema-typed as ST_TwipsMeasure / ST_SignedTwipsMeasure / ST_MeasurementOrPercent
+ * or plain xsd:int variants. The OpenXML SDK validates these as Int32. Emitting
+ * a fractional value like "566.9999999999999" triggers the SDK
+ * "invalid 'Int32' value" finding, even when the numeric result is only off
+ * by float-rounding noise.
+ *
+ * These helpers normalise every numeric attribute write through `Math.round`
+ * and reject non-finite inputs at the authoring boundary so the serializer
+ * cannot accidentally emit NaN, Infinity, or fractional values.
+ *
+ * Callers should route through:
+ *   twip(value)         — optional numeric: undefined passes through; returns integer.
+ *   requireTwip(value)  — mandatory numeric: throws on non-finite input.
+ *
+ * Source:
+ *   docs/plans/close-render-fidelity.md §2 A.2
+ */
+
+/**
+ * Normalise a numeric twip attribute to an integer. Returns undefined when
+ * the input is undefined, preserving existing "omit attribute" semantics.
+ * Throws when the numeric input is NaN or non-finite — this indicates a
+ * bug in whichever authoring path produced the value and must never reach
+ * the serialized XML buffer.
+ */
+export function twip(value: number | undefined | null): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  if (!Number.isFinite(value)) {
+    throw new RangeError(
+      `twip(): expected finite number, received ${String(value)}`,
+    );
+  }
+  return Math.round(value);
+}
+
+/**
+ * Normalise a mandatory numeric twip attribute to an integer. Throws when
+ * the input is not a finite number.
+ */
+export function requireTwip(value: number): number {
+  if (!Number.isFinite(value)) {
+    throw new RangeError(
+      `requireTwip(): expected finite number, received ${String(value)}`,
+    );
+  }
+  return Math.round(value);
+}
+
+/**
+ * Parse a numeric attribute from an OOXML document. Accepts whatever the
+ * raw string carries — Word sometimes emits floats from scaling math — and
+ * returns either an integer or `undefined` when the input is missing /
+ * unparseable. This symmetric helper is used on the parser side so the
+ * canonical model never holds a fractional twip.
+ */
+export function parseTwipAttribute(raw: string | undefined): number | undefined {
+  if (raw === undefined || raw === null || raw === "") return undefined;
+  const parsed = Number.parseFloat(raw);
+  if (!Number.isFinite(parsed)) return undefined;
+  return Math.round(parsed);
+}

package/src/io/normalize/normalize-text.ts

@@ -182,6 +182,11 @@ function normalizeParagraph(
     ...(paragraph.bidi ? { bidi: paragraph.bidi } : {}),
     ...(paragraph.borders ? { borders: paragraph.borders } : {}),
     ...(paragraph.shading ? { shading: paragraph.shading } : {}),
+    // A.7: preserve w14:paraId / w14:textId across import → export so
+    // downstream tools that diff documents by paragraph id stay stable.
+    ...(paragraph.wordExtensionIds
+      ? { wordExtensionIds: paragraph.wordExtensionIds }
+      : {}),
     children,
   };
 }
@@ -204,6 +209,13 @@ function normalizeTable(
     ...(table.borders ? { borders: table.borders } : {}),
     ...(table.cellMargins ? { cellMargins: table.cellMargins } : {}),
     ...(table.tblLook ? { tblLook: table.tblLook } : {}),
+    ...(table.indent ? { indent: table.indent } : {}),
+    ...(table.layoutMode ? { layoutMode: table.layoutMode } : {}),
+    ...(table.cellSpacing ? { cellSpacing: table.cellSpacing } : {}),
+    ...(table.caption !== undefined ? { caption: table.caption } : {}),
+    ...(table.description !== undefined ? { description: table.description } : {}),
+    ...(table.bidiVisual !== undefined ? { bidiVisual: table.bidiVisual } : {}),
+    ...(table.floating ? { floating: table.floating } : {}),
   };
 }
 
@@ -223,6 +235,9 @@ function normalizeTableRow(
     ...(row.height !== undefined ? { height: row.height } : {}),
     ...(row.heightRule ? { heightRule: row.heightRule } : {}),
     ...(row.isHeader !== undefined ? { isHeader: row.isHeader } : {}),
+    ...(row.cantSplit !== undefined ? { cantSplit: row.cantSplit } : {}),
+    ...(row.horizontalAlignment ? { horizontalAlignment: row.horizontalAlignment } : {}),
+    ...(row.cnfStyle ? { cnfStyle: row.cnfStyle } : {}),
     cells,
   };
 }
@@ -249,6 +264,11 @@ function normalizeTableCell(
     ...(cell.borders ? { borders: cell.borders } : {}),
     ...(cell.shading ? { shading: cell.shading } : {}),
     ...(cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {}),
+    ...(cell.textDirection ? { textDirection: cell.textDirection } : {}),
+    ...(cell.noWrap !== undefined ? { noWrap: cell.noWrap } : {}),
+    ...(cell.fitText !== undefined ? { fitText: cell.fitText } : {}),
+    ...(cell.margins ? { margins: cell.margins } : {}),
+    ...(cell.cnfStyle ? { cnfStyle: cell.cnfStyle } : {}),
     children,
   };
 }

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

@@ -14,16 +14,31 @@ import type {
 import { classifyFieldInstruction } from "./parse-fields.ts";
 import {
   readCellBorders,
+  readCellCnfStyle,
+  readCellFitText,
+  readCellMargins,
+  readCellNoWrap,
   readCellShading,
+  readCellTextDirection,
   readCellVerticalAlign,
   readCellWidth,
   readGridColumns as readSharedGridColumns,
+  readRowCantSplit,
+  readRowCnfStyle,
   readRowHeight,
   readRowHeightRule,
+  readRowHorizontalAlignment,
   readRowIsHeader,
   readTableAlignment,
+  readTableBidiVisual,
   readTableBorders,
+  readTableCaption,
   readTableCellMargins,
+  readTableCellSpacing,
+  readTableDescription,
+  readTableFloating,
+  readTableIndent,
+  readTableLayoutMode,
   readTableLook,
   readTableStyleId,
   readTableWidth,
@@ -546,7 +561,8 @@ function parseRunProperties(rElement: XmlElementNode): TextMark[] {
       }
       case "color": {
         const colorVal = child.attributes["w:val"] ?? child.attributes.val;
-        if (colorVal && colorVal !== "auto") marks.push({ type: "textColor", color: colorVal });
+        // A.9: preserve "auto" verbatim for round-trip.
+        if (colorVal) marks.push({ type: "textColor", color: colorVal });
         break;
       }
       case "smallCaps":
@@ -671,6 +687,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
   let borders: TableNode["borders"];
   let cellMargins: TableNode["cellMargins"];
   let tblLook: TableNode["tblLook"];
+  let indent: TableNode["indent"];
+  let layoutMode: TableNode["layoutMode"];
+  let cellSpacing: TableNode["cellSpacing"];
+  let caption: TableNode["caption"];
+  let description: TableNode["description"];
+  let bidiVisual: TableNode["bidiVisual"];
+  let floating: TableNode["floating"];
 
   for (const child of tblElement.children) {
     if (child.type !== "element") continue;
@@ -684,6 +707,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
       borders = readTableBorders(child);
       cellMargins = readTableCellMargins(child);
       tblLook = readTableLook(child);
+      indent = readTableIndent(child);
+      layoutMode = readTableLayoutMode(child);
+      cellSpacing = readTableCellSpacing(child);
+      caption = readTableCaption(child);
+      description = readTableDescription(child);
+      bidiVisual = readTableBidiVisual(child);
+      floating = readTableFloating(child);
     } else if (name === "tblGrid") {
       gridColumns = readGridColumns(child);
     } else if (name === "tr") {
@@ -702,6 +732,13 @@ function parseSimpleTableElement(tblElement: XmlElementNode): TableNode {
     ...(borders ? { borders } : {}),
     ...(cellMargins ? { cellMargins } : {}),
     ...(tblLook ? { tblLook } : {}),
+    ...(indent ? { indent } : {}),
+    ...(layoutMode ? { layoutMode } : {}),
+    ...(cellSpacing ? { cellSpacing } : {}),
+    ...(caption !== undefined ? { caption } : {}),
+    ...(description !== undefined ? { description } : {}),
+    ...(bidiVisual !== undefined ? { bidiVisual } : {}),
+    ...(floating ? { floating } : {}),
   };
 }
 
@@ -715,6 +752,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
   let height: TableRowNode["height"];
   let heightRule: TableRowNode["heightRule"];
   let isHeader: TableRowNode["isHeader"];
+  let cantSplit: TableRowNode["cantSplit"];
+  let horizontalAlignment: TableRowNode["horizontalAlignment"];
+  let cnfStyle: TableRowNode["cnfStyle"];
 
   for (const child of trElement.children) {
     if (child.type !== "element") continue;
@@ -725,6 +765,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
       height = readRowHeight(child);
       heightRule = readRowHeightRule(child);
       isHeader = readRowIsHeader(child);
+      cantSplit = readRowCantSplit(child);
+      horizontalAlignment = readRowHorizontalAlignment(child);
+      cnfStyle = readRowCnfStyle(child);
     } else if (name === "tc") {
       cells.push(parseSimpleTableCell(child));
     }
@@ -736,6 +779,9 @@ function parseSimpleTableRow(trElement: XmlElementNode): TableRowNode {
     ...(height !== undefined ? { height } : {}),
     ...(heightRule ? { heightRule } : {}),
     ...(isHeader !== undefined ? { isHeader } : {}),
+    ...(cantSplit !== undefined ? { cantSplit } : {}),
+    ...(horizontalAlignment ? { horizontalAlignment } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     cells,
   };
 }
@@ -749,6 +795,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
   let borders: TableCellNode["borders"];
   let shading: TableCellNode["shading"];
   let verticalAlign: TableCellNode["verticalAlign"];
+  let textDirection: TableCellNode["textDirection"];
+  let noWrap: TableCellNode["noWrap"];
+  let fitText: TableCellNode["fitText"];
+  let margins: TableCellNode["margins"];
+  let cnfStyle: TableCellNode["cnfStyle"];
 
   for (const child of tcElement.children) {
     if (child.type !== "element") continue;
@@ -769,6 +820,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
       borders = readCellBorders(child);
       shading = readCellShading(child);
       verticalAlign = readCellVerticalAlign(child);
+      textDirection = readCellTextDirection(child);
+      noWrap = readCellNoWrap(child);
+      fitText = readCellFitText(child);
+      margins = readCellMargins(child);
+      cnfStyle = readCellCnfStyle(child);
     } else if (name === "p") {
       children.push(parseParagraphElement(child));
     }
@@ -783,6 +839,11 @@ function parseSimpleTableCell(tcElement: XmlElementNode): TableCellNode {
     ...(borders ? { borders } : {}),
     ...(shading ? { shading } : {}),
     ...(verticalAlign ? { verticalAlign } : {}),
+    ...(textDirection ? { textDirection } : {}),
+    ...(noWrap !== undefined ? { noWrap } : {}),
+    ...(fitText !== undefined ? { fitText } : {}),
+    ...(margins ? { margins } : {}),
+    ...(cnfStyle ? { cnfStyle } : {}),
     children: children.length > 0 ? children : [{ type: "paragraph", children: [] }],
   };
 }