@lotics/docx 0.1.0

package/src/pm/table_convert.ts

@@ -0,0 +1,541 @@
+import type { Node as PMNode } from "prosemirror-model";
+import {
+  getAttr,
+  getChildren,
+  getTagName,
+  type XmlElement,
+} from "@lotics/ooxml/xml";
+import { docxSchema } from "./schema";
+
+export type ConvertBlockToPM = (xml: XmlElement) => PMNode | null;
+
+function parseIntOrNull(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * Read the `w:tblW` element's `w:type` attribute. Word recognizes "auto",
+ * "dxa" (fixed twentieths-of-a-point), "pct" (percentage of available
+ * width), and "nil". We treat anything that isn't "auto" as fixed-width
+ * for column-sizing purposes.
+ */
+function readTableWidthType(
+  tblPr: XmlElement | null,
+): "auto" | "fixed" | "nil" | null {
+  if (!tblPr) return null;
+  for (const child of getChildren(tblPr)) {
+    if (getTagName(child) !== "w:tblW") continue;
+    const type = getAttr(child, "w:type");
+    if (type === "auto") return "auto";
+    if (type === "nil") return "nil";
+    return "fixed";
+  }
+  return null;
+}
+
+function parseGridWidths(tblGrid: XmlElement | null): number[] {
+  if (!tblGrid) return [];
+  const widths: number[] = [];
+  for (const child of getChildren(tblGrid)) {
+    if (getTagName(child) !== "w:gridCol") continue;
+    const w = parseIntOrNull(getAttr(child, "w:w"));
+    if (w !== null) widths.push(w);
+  }
+  return widths;
+}
+
+type CellXml = {
+  tcXml: XmlElement;
+  gridSpan: number;
+  vMerge: "restart" | "continue" | null;
+};
+
+function readCellXml(tc: XmlElement): CellXml {
+  let gridSpan = 1;
+  let vMerge: "restart" | "continue" | null = null;
+  for (const child of getChildren(tc)) {
+    if (getTagName(child) !== "w:tcPr") continue;
+    for (const propChild of getChildren(child)) {
+      const tag = getTagName(propChild);
+      if (tag === "w:gridSpan") {
+        const v = parseIntOrNull(getAttr(propChild, "w:val"));
+        if (v !== null && v > 0) gridSpan = v;
+      } else if (tag === "w:vMerge") {
+        const v = getAttr(propChild, "w:val");
+        vMerge = v === "restart" ? "restart" : "continue";
+      }
+    }
+    break;
+  }
+  return { tcXml: tc, gridSpan, vMerge };
+}
+
+type CellAttrInputs = {
+  colspan: number;
+  rowspan: number;
+  colwidth: number[] | null;
+  gridSpan: number | null;
+  vMerge: "restart" | null;
+  borders: unknown;
+  shading: unknown;
+  vAlign: unknown;
+  cellWidth: unknown;
+  background: string | null;
+};
+
+function readBorder(el: XmlElement | null): unknown {
+  if (!el) return null;
+  const styleVal = getAttr(el, "w:val") ?? "single";
+  const colorRaw = getAttr(el, "w:color");
+  const color = !colorRaw || colorRaw === "auto" ? null : colorRaw;
+  const sizeAttr = getAttr(el, "w:sz");
+  const sizePts = sizeAttr
+    ? Number.parseInt(sizeAttr, 10) / 8
+    : 0.5;
+  return { style: styleVal, color, sizePts: Number.isFinite(sizePts) ? sizePts : 0.5 };
+}
+
+function readBorders(tcPr: XmlElement | null): unknown {
+  if (!tcPr) return null;
+  let borders: XmlElement | null = null;
+  for (const child of getChildren(tcPr)) {
+    if (getTagName(child) === "w:tcBorders") {
+      borders = child;
+      break;
+    }
+  }
+  if (!borders) return null;
+  const out: Record<string, unknown> = {};
+  for (const child of getChildren(borders)) {
+    const tag = getTagName(child);
+    if (tag === "w:top") out.top = readBorder(child);
+    else if (tag === "w:bottom") out.bottom = readBorder(child);
+    else if (tag === "w:left") out.left = readBorder(child);
+    else if (tag === "w:right") out.right = readBorder(child);
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+function readShading(tcPr: XmlElement | null): unknown {
+  if (!tcPr) return null;
+  for (const child of getChildren(tcPr)) {
+    if (getTagName(child) !== "w:shd") continue;
+    const fill = getAttr(child, "w:fill");
+    if (!fill) return null;
+    const pattern = getAttr(child, "w:val") ?? undefined;
+    const colorRaw = getAttr(child, "w:color");
+    const color = !colorRaw || colorRaw === "auto" ? null : colorRaw;
+    return pattern ? { fill, pattern, color } : { fill, color };
+  }
+  return null;
+}
+
+function readVAlign(tcPr: XmlElement | null): unknown {
+  if (!tcPr) return null;
+  for (const child of getChildren(tcPr)) {
+    if (getTagName(child) !== "w:vAlign") continue;
+    const v = getAttr(child, "w:val");
+    if (v === "top" || v === "center" || v === "bottom") return v;
+  }
+  return null;
+}
+
+function readCellWidth(tcPr: XmlElement | null): unknown {
+  if (!tcPr) return null;
+  for (const child of getChildren(tcPr)) {
+    if (getTagName(child) !== "w:tcW") continue;
+    const value = parseIntOrNull(getAttr(child, "w:w"));
+    const typeRaw = getAttr(child, "w:type") ?? "dxa";
+    if (value === null) return null;
+    if (typeRaw === "dxa" || typeRaw === "pct" || typeRaw === "auto" || typeRaw === "nil") {
+      return { value, type: typeRaw };
+    }
+    return { value, type: "dxa" };
+  }
+  return null;
+}
+
+function tcPrOf(tc: XmlElement): XmlElement | null {
+  for (const child of getChildren(tc)) {
+    if (getTagName(child) === "w:tcPr") return child;
+  }
+  return null;
+}
+
+function buildCellAttrs(
+  cell: CellXml,
+  rowspan: number,
+  colwidth: number[] | null,
+): CellAttrInputs {
+  const tcPr = tcPrOf(cell.tcXml);
+  return {
+    colspan: cell.gridSpan,
+    rowspan,
+    colwidth,
+    gridSpan: cell.gridSpan > 1 ? cell.gridSpan : null,
+    vMerge: cell.vMerge === "restart" && rowspan > 1 ? "restart" : null,
+    borders: readBorders(tcPr),
+    shading: readShading(tcPr),
+    vAlign: readVAlign(tcPr),
+    cellWidth: readCellWidth(tcPr),
+    background: null,
+  };
+}
+
+function cellContentNodes(
+  cell: XmlElement,
+  convertBlock: ConvertBlockToPM,
+): PMNode[] {
+  const out: PMNode[] = [];
+  for (const child of getChildren(cell)) {
+    const tag = getTagName(child);
+    if (tag === "w:tcPr") continue;
+    const node = convertBlock(child);
+    if (node) out.push(node);
+  }
+  if (out.length === 0) {
+    out.push(docxSchema.nodes.paragraph.create());
+  }
+  return out;
+}
+
+export function xmlToTableNode(
+  tableXml: XmlElement,
+  convertBlock: ConvertBlockToPM,
+): PMNode | null {
+  if (getTagName(tableXml) !== "w:tbl") return null;
+
+  let tblPr: XmlElement | null = null;
+  let tblGrid: XmlElement | null = null;
+  const trXmls: XmlElement[] = [];
+  for (const child of getChildren(tableXml)) {
+    const tag = getTagName(child);
+    if (tag === "w:tblPr") tblPr = child;
+    else if (tag === "w:tblGrid") tblGrid = child;
+    else if (tag === "w:tr") trXmls.push(child);
+  }
+
+  const rawGridWidths = parseGridWidths(tblGrid);
+  // OOXML `tblPr > w:tblW` describes the table's overall width. "auto"
+  // and "nil" (no width specified) both mean "shrink/grow to content" —
+  // Word renders both at content's natural width. We drop colwidths so
+  // CSS `table-layout: auto` sizes cells. "dxa" and "pct" are honored
+  // via the gridCol widths.
+  const tableWidthType = readTableWidthType(tblPr);
+  const gridWidths =
+    tableWidthType === "auto" || tableWidthType === "nil"
+      ? []
+      : rawGridWidths;
+
+  const rowsCells: CellXml[][] = trXmls.map((tr) => {
+    const cells: CellXml[] = [];
+    for (const child of getChildren(tr)) {
+      if (getTagName(child) !== "w:tc") continue;
+      cells.push(readCellXml(child));
+    }
+    return cells;
+  });
+
+  const rowSpans: number[][] = rowsCells.map((row) => row.map(() => 1));
+
+  for (let r = 0; r < rowsCells.length; r++) {
+    let colIdx = 0;
+    for (let c = 0; c < rowsCells[r].length; c++) {
+      const cell = rowsCells[r][c];
+      if (cell.vMerge === "restart") {
+        let span = 1;
+        const startCol = colIdx;
+        for (let nr = r + 1; nr < rowsCells.length; nr++) {
+          let nextColIdx = 0;
+          let matched = false;
+          for (let nc = 0; nc < rowsCells[nr].length; nc++) {
+            const nextCell = rowsCells[nr][nc];
+            if (nextColIdx === startCol && nextCell.vMerge === "continue") {
+              span += 1;
+              matched = true;
+              break;
+            }
+            nextColIdx += nextCell.gridSpan;
+          }
+          if (!matched) break;
+        }
+        rowSpans[r][c] = span;
+      }
+      colIdx += cell.gridSpan;
+    }
+  }
+
+  const tableRowNodes: PMNode[] = [];
+  for (let r = 0; r < rowsCells.length; r++) {
+    let colIdx = 0;
+    const cellNodes: PMNode[] = [];
+    for (let c = 0; c < rowsCells[r].length; c++) {
+      const cell = rowsCells[r][c];
+      if (cell.vMerge === "continue") {
+        colIdx += cell.gridSpan;
+        continue;
+      }
+
+      const startCol = colIdx;
+      const endCol = colIdx + cell.gridSpan;
+      const colwidth =
+        gridWidths.length >= endCol
+          ? gridWidths.slice(startCol, endCol)
+          : null;
+
+      const attrs = buildCellAttrs(cell, rowSpans[r][c], colwidth);
+      const content = cellContentNodes(cell.tcXml, convertBlock);
+      cellNodes.push(
+        docxSchema.nodes.table_cell.create(attrs, content),
+      );
+      colIdx += cell.gridSpan;
+    }
+    if (cellNodes.length === 0) {
+      cellNodes.push(
+        docxSchema.nodes.table_cell.create(null, [
+          docxSchema.nodes.paragraph.create(),
+        ]),
+      );
+    }
+    tableRowNodes.push(
+      docxSchema.nodes.table_row.create(
+        { rowProperties: null },
+        cellNodes,
+      ),
+    );
+  }
+
+  return docxSchema.nodes.table.create(
+    {
+      tableProperties: tblPr ?? null,
+      columnGrid: tblGrid ?? null,
+    },
+    tableRowNodes,
+  );
+}
+
+export type PMNodeToBlockXml = (node: PMNode) => XmlElement[];
+
+function buildBordersXml(borders: unknown): XmlElement | null {
+  if (!borders || typeof borders !== "object") return null;
+  const sides: Array<["w:top" | "w:right" | "w:bottom" | "w:left", string]> = [
+    ["w:top", "top"],
+    ["w:right", "right"],
+    ["w:bottom", "bottom"],
+    ["w:left", "left"],
+  ];
+  const children: XmlElement[] = [];
+  const obj = borders as Record<string, unknown>;
+  for (const [tag, key] of sides) {
+    const side = obj[key];
+    if (!side || typeof side !== "object") continue;
+    const sideObj = side as Record<string, unknown>;
+    const style =
+      typeof sideObj.style === "string" ? sideObj.style : "single";
+    const color =
+      typeof sideObj.color === "string" ? sideObj.color : "auto";
+    const sizePts =
+      typeof sideObj.sizePts === "number" ? sideObj.sizePts : 0.5;
+    children.push({
+      [tag]: [],
+      ":@": {
+        "@_w:val": style,
+        "@_w:sz": String(Math.round(sizePts * 8)),
+        "@_w:space": "0",
+        "@_w:color": color,
+      },
+    });
+  }
+  if (children.length === 0) return null;
+  return { "w:tcBorders": children };
+}
+
+function buildShadingXml(shading: unknown): XmlElement | null {
+  if (!shading || typeof shading !== "object") return null;
+  const obj = shading as Record<string, unknown>;
+  if (typeof obj.fill !== "string") return null;
+  const attrs: Record<string, string> = {
+    "@_w:val": typeof obj.pattern === "string" ? obj.pattern : "clear",
+    "@_w:fill": obj.fill,
+  };
+  if (typeof obj.color === "string" && obj.color) {
+    attrs["@_w:color"] = obj.color;
+  } else {
+    attrs["@_w:color"] = "auto";
+  }
+  return { "w:shd": [], ":@": attrs };
+}
+
+function buildCellWidthXml(cellWidth: unknown): XmlElement | null {
+  if (!cellWidth || typeof cellWidth !== "object") return null;
+  const obj = cellWidth as Record<string, unknown>;
+  if (typeof obj.value !== "number") return null;
+  const type =
+    obj.type === "dxa" || obj.type === "pct" || obj.type === "auto" || obj.type === "nil"
+      ? obj.type
+      : "dxa";
+  return {
+    "w:tcW": [],
+    ":@": { "@_w:w": String(obj.value), "@_w:type": type },
+  };
+}
+
+function buildTcPrXml(cell: PMNode): XmlElement | null {
+  const children: XmlElement[] = [];
+  const cw = buildCellWidthXml(cell.attrs.cellWidth);
+  if (cw) children.push(cw);
+  const span = cell.attrs.colspan as number | undefined;
+  if (typeof span === "number" && span > 1) {
+    children.push({ "w:gridSpan": [], ":@": { "@_w:val": String(span) } });
+  }
+  const vMergeKind = cell.attrs.vMerge as string | null | undefined;
+  if (vMergeKind === "restart") {
+    children.push({ "w:vMerge": [], ":@": { "@_w:val": "restart" } });
+  } else if (vMergeKind === "continue") {
+    children.push({ "w:vMerge": [] });
+  }
+  const borders = buildBordersXml(cell.attrs.borders);
+  if (borders) children.push(borders);
+  const shading = buildShadingXml(cell.attrs.shading);
+  if (shading) children.push(shading);
+  const vAlign = cell.attrs.vAlign as string | null | undefined;
+  if (vAlign === "top" || vAlign === "center" || vAlign === "bottom") {
+    children.push({ "w:vAlign": [], ":@": { "@_w:val": vAlign } });
+  }
+  return children.length > 0 ? { "w:tcPr": children } : null;
+}
+
+type RowCell = {
+  origin: PMNode;
+  colspan: number;
+  rowspan: number;
+  rowOffset: number;
+};
+
+type GridSlot = RowCell | null;
+
+function buildLogicalGrid(table: PMNode): GridSlot[][] {
+  const rows: GridSlot[][] = [];
+  table.forEach((row, _offset, rowIdx) => {
+    if (row.type.name !== "table_row") return;
+    if (!rows[rowIdx]) rows[rowIdx] = [];
+    let colIdx = 0;
+    row.forEach((cell) => {
+      if (cell.type.name !== "table_cell" && cell.type.name !== "table_header") return;
+      while (rows[rowIdx][colIdx]) colIdx += 1;
+      const colspan = (cell.attrs.colspan as number | undefined) ?? 1;
+      const rowspan = (cell.attrs.rowspan as number | undefined) ?? 1;
+      for (let dr = 0; dr < rowspan; dr++) {
+        const r = rowIdx + dr;
+        if (!rows[r]) rows[r] = [];
+        for (let dc = 0; dc < colspan; dc++) {
+          rows[r][colIdx + dc] = { origin: cell, colspan, rowspan, rowOffset: dr };
+        }
+      }
+      colIdx += colspan;
+    });
+  });
+  return rows;
+}
+
+function buildContinuationCellXml(originCell: PMNode): XmlElement {
+  const tcPr: XmlElement = { "w:tcPr": [{ "w:vMerge": [] }] };
+  const colspan = (originCell.attrs.colspan as number | undefined) ?? 1;
+  if (colspan > 1) {
+    (tcPr["w:tcPr"] as XmlElement[]).push({
+      "w:gridSpan": [],
+      ":@": { "@_w:val": String(colspan) },
+    });
+  }
+  return { "w:tc": [tcPr, { "w:p": [] }] };
+}
+
+function buildOriginCellXml(
+  cell: PMNode,
+  isVMergeOrigin: boolean,
+  convertParagraphToXml: PMNodeToBlockXml,
+): XmlElement {
+  const tcChildren: XmlElement[] = [];
+
+  const tcPr = buildTcPrXml(cell);
+  if (tcPr) {
+    if (isVMergeOrigin) {
+      const tcPrChildren = tcPr["w:tcPr"] as XmlElement[];
+      const hasVMerge = tcPrChildren.some((c) => getTagName(c) === "w:vMerge");
+      if (!hasVMerge) {
+        tcPrChildren.push({
+          "w:vMerge": [],
+          ":@": { "@_w:val": "restart" },
+        });
+      }
+    }
+    tcChildren.push(tcPr);
+  } else if (isVMergeOrigin) {
+    tcChildren.push({
+      "w:tcPr": [{ "w:vMerge": [], ":@": { "@_w:val": "restart" } }],
+    });
+  }
+
+  cell.forEach((blockNode) => {
+    if (blockNode.type.name === "table") {
+      tcChildren.push(tableNodeToXml(blockNode, convertParagraphToXml));
+      return;
+    }
+    const blockXmls = convertParagraphToXml(blockNode);
+    for (const xml of blockXmls) tcChildren.push(xml);
+  });
+
+  if (tcChildren.every((c) => getTagName(c) === "w:tcPr")) {
+    tcChildren.push({ "w:p": [] });
+  }
+
+  return { "w:tc": tcChildren };
+}
+
+export function tableNodeToXml(
+  table: PMNode,
+  convertParagraphToXml: PMNodeToBlockXml,
+): XmlElement {
+  const children: XmlElement[] = [];
+
+  const tblPr = table.attrs.tableProperties as XmlElement | null;
+  if (tblPr) children.push(tblPr);
+
+  const tblGrid = table.attrs.columnGrid as XmlElement | null;
+  if (tblGrid) children.push(tblGrid);
+
+  const grid = buildLogicalGrid(table);
+
+  for (let r = 0; r < grid.length; r++) {
+    const row = grid[r];
+    const trChildren: XmlElement[] = [];
+    let c = 0;
+    while (c < row.length) {
+      const slot = row[c];
+      if (!slot) {
+        c += 1;
+        continue;
+      }
+      const isOriginRow = slot.rowOffset === 0;
+      const prevSlot = c > 0 ? row[c - 1] : null;
+      const isFirstColOfCell = !prevSlot || prevSlot.origin !== slot.origin;
+      if (!isFirstColOfCell) {
+        c += 1;
+        continue;
+      }
+      if (isOriginRow) {
+        trChildren.push(
+          buildOriginCellXml(slot.origin, slot.rowspan > 1, convertParagraphToXml),
+        );
+      } else {
+        trChildren.push(buildContinuationCellXml(slot.origin));
+      }
+      c += slot.colspan;
+    }
+    children.push({ "w:tr": trChildren.length > 0 ? trChildren : [{ "w:tc": [{ "w:p": [] }] }] });
+  }
+
+  return { "w:tbl": children };
+}

package/src/pm/table_decorations.ts

@@ -0,0 +1,132 @@
+import { Plugin, PluginKey } from "prosemirror-state";
+import { Decoration, DecorationSet } from "prosemirror-view";
+import type { Node as PMNode } from "prosemirror-model";
+import type { XmlElement } from "@lotics/ooxml/xml";
+import {
+  borderToCss,
+  DEFAULT_TABLE_BORDERS,
+  tableBordersFromTblPr,
+  type Border,
+  type TableBorders,
+} from "./table_borders";
+import type {
+  TableCellBorders,
+  TableCellShading,
+  VAlignKind,
+} from "./table_attrs";
+
+/**
+ * Decoration plugin that paints OOXML-aware table styling onto cells.
+ *
+ * The plugin walks every `table` node in the doc and emits a `Decoration.node`
+ * per cell with an inline `style` carrying border / background-color /
+ * vertical-align values resolved against:
+ *   - the cell's own `borders` / `shading` / `vAlign` attrs
+ *   - the table's `tableProperties` (parsed `<w:tblBorders>`)
+ *   - Word's TableGrid default (single 0.5pt black) when neither specifies
+ *
+ * Decorations leave the editor's contentDOM tree untouched — `prosemirror-
+ * tables` continues to own the &lt;table&gt; / &lt;tr&gt; / &lt;td&gt; DOM.
+ * That avoids the NodeView / contentDOM conflicts that crash the editor.
+ *
+ * Border resolution order per cell edge:
+ *   cell.borders.top  >  table.tblBorders.top   (first row)
+ *                     >  table.tblBorders.insideH (interior row)
+ *   cell.borders.left >  table.tblBorders.left  (first col)
+ *                     >  table.tblBorders.insideV (interior col)
+ *   …mirror for bottom / right.
+ */
+export function tableDecorationsPlugin(): Plugin {
+  return new Plugin({
+    key: new PluginKey("docx-table-decorations"),
+    props: {
+      decorations(state) {
+        const decorations: Decoration[] = [];
+        state.doc.descendants((node, pos) => {
+          if (node.type.name !== "table") return true;
+          collectTableDecorations(node, pos, decorations);
+          return false;
+        });
+        return DecorationSet.create(state.doc, decorations);
+      },
+    },
+  });
+}
+
+function collectTableDecorations(
+  table: PMNode,
+  tablePos: number,
+  out: Decoration[],
+): void {
+  const tblPr = table.attrs.tableProperties as XmlElement | null;
+  const parsed = tableBordersFromTblPr(tblPr);
+  const tblBorders =
+    Object.keys(parsed).length > 0 ? parsed : DEFAULT_TABLE_BORDERS;
+  const rowCount = table.childCount;
+
+  // PM table layout: table → row → cell → block content. Walk by index.
+  let rowOffset = 1; // skip the table opening token
+  table.forEach((row, _r, rowIndex) => {
+    const isFirstRow = rowIndex === 0;
+    const isLastRow = rowIndex === rowCount - 1;
+    const colCount = row.childCount;
+    let colOffset = rowOffset + 1; // skip the row opening token
+    row.forEach((cell, _c, colIndex) => {
+      const isFirstCol = colIndex === 0;
+      const isLastCol = colIndex === colCount - 1;
+      const cellAbsPos = tablePos + colOffset;
+
+      const cellBorders = (cell.attrs.borders as TableCellBorders | null) ?? null;
+      const shading = cell.attrs.shading as TableCellShading | null;
+      const background = cell.attrs.background as string | null;
+      const vAlign = cell.attrs.vAlign as VAlignKind | null;
+
+      const top =
+        cellBorders?.top ??
+        (isFirstRow ? tblBorders.top : tblBorders.insideH);
+      const bottom =
+        cellBorders?.bottom ??
+        (isLastRow ? tblBorders.bottom : tblBorders.insideH);
+      const left =
+        cellBorders?.left ??
+        (isFirstCol ? tblBorders.left : tblBorders.insideV);
+      const right =
+        cellBorders?.right ??
+        (isLastCol ? tblBorders.right : tblBorders.insideV);
+
+      const styleParts: string[] = [];
+      if (top) styleParts.push(`border-top: ${borderToCss(top as Border)}`);
+      if (bottom) styleParts.push(`border-bottom: ${borderToCss(bottom as Border)}`);
+      if (left) styleParts.push(`border-left: ${borderToCss(left as Border)}`);
+      if (right) styleParts.push(`border-right: ${borderToCss(right as Border)}`);
+
+      if (shading?.fill && shading.fill !== "auto") {
+        styleParts.push(`background-color: #${shading.fill}`);
+      } else if (background) {
+        styleParts.push(`background-color: ${background}`);
+      }
+
+      if (vAlign) {
+        styleParts.push(
+          `vertical-align: ${vAlign === "center" ? "middle" : vAlign}`,
+        );
+      }
+
+      if (styleParts.length > 0) {
+        out.push(
+          Decoration.node(cellAbsPos, cellAbsPos + cell.nodeSize, {
+            style: styleParts.join("; "),
+          }),
+        );
+      }
+      colOffset += cell.nodeSize;
+    });
+    rowOffset += row.nodeSize;
+  });
+  void [tblBorders];
+}
+
+// Suppress unused-warning — `TableBorders` is used as an *implicit* return
+// type via tableBordersFromTblPr; keep the explicit re-export so external
+// callers can construct expected fixtures.
+export type { TableBorders };