ooxml-core 1.9.0 → 1.11.0

package/dist/docx/layout/index.cjs

@@ -4427,6 +4427,12 @@ function appendBreakMarker(tokens, runIndex, sourceStart, kind) {
   tokens.push({ kind: kind === "page" ? "pageBreak" : "columnBreak", runIndex, sourceStart });
 }
 
+// docx/layout/result.ts
+function cellVerticalOffset(geometry, rowHeightPx) {
+  const free = Math.max(0, (geometry.alignmentHeightPx ?? rowHeightPx) - geometry.contentHeightPx);
+  return geometry.verticalAlign === "center" ? free / 2 : geometry.verticalAlign === "bottom" ? free : 0;
+}
+
 // docx/layout/page-fields.ts
 function fieldDisplayText(run, values) {
   if (!run.field || isFieldLocked(run)) return run.text;
@@ -4891,6 +4897,124 @@ function widowControlEnabled(value) {
   return value !== false;
 }
 
+// docx/layout/nested-frame-profile.ts
+var equal = (a, b) => a !== void 0 && b !== void 0 && a.style === b.style && a.color === b.color && Math.abs(a.widthPx - b.widthPx) < 1e-6;
+function nestedFrameProfile(table, tableWidthPx = table.widthPx) {
+  const sides = table.rows.flatMap(
+    (row) => row.cells.flatMap(
+      (cell) => ["top", "right", "bottom", "left"].map((side) => cell.borders?.[side])
+    )
+  );
+  if (sides.every((side) => !side)) return { leftPx: 0, rightPx: 0, bottomPx: 0 };
+  if (!sides.every((side) => side?.style === "solid" && side.widthPx > 0)) return void 0;
+  const first3 = table.rows[0], left = first3.cells[0].borders.left, right = first3.cells.at(-1).borders.right;
+  for (const [index, row] of table.rows.entries()) {
+    if (row.cells.length !== first3.cells.length || !equal(row.cells[0]?.borders?.left, left) || !equal(row.cells.at(-1)?.borders?.right, right))
+      return void 0;
+    for (const [column, cell] of row.cells.entries()) {
+      const sourceWidth = cell.widthPx ?? (tableWidthPx === void 0 ? void 0 : tableWidthPx / row.cells.length);
+      const paintWidth = sourceWidth === void 0 ? void 0 : sourceWidth + (cell.borders.left.widthPx - cell.borders.right.widthPx) / 2 + (column === row.cells.length - 1 ? cell.borders.right.widthPx : 0);
+      if (paintWidth !== void 0 && paintWidth <= 0) return void 0;
+      if (!equal(cell.borders?.top, row.cells[0]?.borders?.top) || !equal(cell.borders?.bottom, row.cells[0]?.borders?.bottom))
+        return void 0;
+      if (column && !equal(row.cells[column - 1]?.borders?.right, cell.borders?.left))
+        return void 0;
+      if (index) {
+        const previous = table.rows[index - 1].cells[column];
+        if (previous.xPx !== cell.xPx || previous.widthPx !== cell.widthPx || !equal(previous.borders?.bottom, cell.borders?.top))
+          return void 0;
+      }
+    }
+  }
+  return {
+    leftPx: left.widthPx,
+    rightPx: right.widthPx,
+    bottomPx: table.rows.at(-1).cells[0].borders.bottom.widthPx
+  };
+}
+
+// docx/layout/nested-fragment-edges.ts
+var plain = (paragraph) => !paragraph.keepLines && !paragraph.keepNext && !paragraph.pageBreakBefore && !paragraph.footnotes?.length && !paragraph.runs.some((run) => run.footnoteReferenceId !== void 0 || run.breakAfter);
+function nestedFragmentEdges(table) {
+  if (table.widthPx === void 0 || !Number.isFinite(table.widthPx) || table.widthPx <= 0 || table.rows.length < 2 || !nestedFrameProfile(table, table.widthPx) || table.rows.some(
+    (row) => row.heightPx !== void 0 || row.cantSplit || row.isHeader || row.cells.length !== 2 || row.cells.some(
+      (cell) => cell.verticalAlign && cell.verticalAlign !== "top" || cell.blocks?.some((block) => block.kind !== "paragraph") || !(cell.blocks ?? cell.paragraphs).every(
+        (block) => block.kind === "paragraph" && plain(block)
+      )
+    )
+  ))
+    return void 0;
+  const top = table.rows[0].cells.map((cell) => cell.borders?.top);
+  const bottom = table.rows.at(-1).cells.map((cell) => cell.borders?.bottom);
+  return top.every(Boolean) && bottom.every(Boolean) ? { top, bottom } : void 0;
+}
+function reflowNestedFragments(row) {
+  if (row.heightPx !== void 0 || row.cantSplit || row.isHeader || row.cells.length !== 2)
+    return false;
+  let tables = 0;
+  for (const cell of row.cells) {
+    if (cell.verticalAlign && cell.verticalAlign !== "top") return false;
+    for (const [index, block] of (cell.blocks ?? cell.paragraphs).entries()) {
+      if (block.kind === "paragraph") {
+        if (!plain(block)) return false;
+      } else {
+        if (index !== 0 || !nestedFragmentEdges(block) || ++tables > 1) return false;
+      }
+    }
+  }
+  return tables === 1;
+}
+
+// docx/layout/table-content.ts
+function cellContentBottom(boxes, paddingBottom = 0) {
+  return Math.max(
+    0,
+    ...boxes.map(
+      (box) => box.yPx + box.heightPx + (box.tableFrameInsets?.bottom ?? 0) + paddingBottom
+    )
+  );
+}
+
+// docx/layout/table-frames.ts
+function clipTableFrames(tables, start, end, inset = 0) {
+  return tables.flatMap((table) => {
+    const top = Math.max(start, table.yPx);
+    const bottom = Math.min(end, table.yPx + table.heightPx);
+    if (bottom <= top) return [];
+    const rows = table.rows.flatMap((row) => {
+      const rowTop = table.yPx + row.yPx;
+      const a = Math.max(top, rowTop), b = Math.min(bottom, rowTop + row.heightPx);
+      if (b <= a) return [];
+      return [
+        {
+          ...row,
+          yPx: a - top,
+          heightPx: b - a,
+          ...row.cellTables ? {
+            cellTables: row.cellTables.map(
+              (nested) => clipTableFrames(nested, a - rowTop, b - rowTop)
+            )
+          } : {}
+        }
+      ];
+    });
+    if (table.fragmentEdges && rows.length) {
+      const edges = table.fragmentEdges;
+      for (const [row, side] of [
+        [rows[0], "top"],
+        [rows.at(-1), "bottom"]
+      ]) {
+        if (row.geometry)
+          row.geometry = row.geometry.map((cell, index) => ({
+            ...cell,
+            borders: { ...cell.borders, [side]: edges[side][index] }
+          }));
+      }
+    }
+    return [{ ...table, yPx: top - start + inset, heightPx: bottom - top, rows }];
+  });
+}
+
 // docx/layout/table-cell-layout.ts
 function cellParagraphs(cell) {
   const walk = (blocks) => blocks.flatMap(
@@ -4898,7 +5022,7 @@ function cellParagraphs(cell) {
   );
   return cell.blocks ? walk(cell.blocks) : cell.paragraphs;
 }
-function stackCellBlocks(cell, width, measurer, note, top, starts) {
+function stackCellBlocks(cell, width, measurer, note, top, starts, physicalFragments = false) {
   if (!cell.blocks)
     return stackParagraphs(
       starts ? cell.paragraphs.filter((p) => starts.has(p.id)) : cell.paragraphs,
@@ -4910,6 +5034,7 @@ function stackCellBlocks(cell, width, measurer, note, top, starts) {
     );
   let y = top;
   const boxes = [];
+  const tables = [];
   for (const block of cell.blocks) {
     if (block.kind === "paragraph") {
       if (starts && !starts.has(block.id)) continue;
@@ -4918,28 +5043,83 @@ function stackCellBlocks(cell, width, measurer, note, top, starts) {
       y = result.heightPx;
       continue;
     }
+    const edges = physicalFragments ? nestedFragmentEdges(block) : void 0;
     const tableWidth = block.widthPx ?? width;
-    const x = block.alignment === "center" ? Math.max(0, (width - tableWidth) / 2) : block.alignment === "right" ? Math.max(0, width - tableWidth) : block.indentPx ?? 0;
+    const profile = nestedFrameProfile(block, tableWidth);
+    const reserveBorders = profile !== void 0;
+    if (!reserveBorders)
+      note(
+        "Nested table border occupancy is approximate for missing edges, non-solid or conflicting shared borders and changing row grids."
+      );
+    const externalRight = profile ? (profile.leftPx + profile.rightPx) / 2 : 0;
+    const paintedWidth = tableWidth + externalRight;
+    const x = block.alignment === "center" ? Math.max(0, (width - paintedWidth) / 2) : block.alignment === "right" ? Math.max(0, width - paintedWidth) : block.indentPx ?? 0;
+    const frame = {
+      kind: "table",
+      blockId: block.id,
+      xPx: x,
+      widthPx: paintedWidth,
+      yPx: y,
+      heightPx: 0,
+      rows: [],
+      ...edges ? { fragmentEdges: edges } : {}
+    };
     for (const row of block.rows) {
       if (starts && !row.cells.some((nested) => cellParagraphs(nested).some((p) => starts.has(p.id))))
         continue;
-      const layout = layoutRow(row, tableWidth, measurer, note, void 0, starts);
+      const visibleRow = edges && starts && !frame.rows.length ? {
+        ...row,
+        cells: row.cells.map((cell2, index) => ({
+          ...cell2,
+          borders: { ...cell2.borders, top: edges.top[index] }
+        }))
+      } : row;
+      const layout = layoutRow(
+        visibleRow,
+        tableWidth,
+        measurer,
+        note,
+        void 0,
+        starts,
+        reserveBorders,
+        profile?.leftPx
+      );
+      frame.rows.push({
+        yPx: y - frame.yPx,
+        heightPx: layout.heightPx,
+        repeated: false,
+        cells: layout.cells,
+        geometry: layout.geometry,
+        ...layout.cellTables ? { cellTables: layout.cellTables } : {}
+      });
       layout.cells.forEach((paragraphs, index) => {
         const geometry = layout.geometry[index];
         for (const paragraph of paragraphs)
           boxes.push({
             ...paragraph,
-            yPx: y + paragraph.yPx,
+            yPx: y + paragraph.yPx + cellVerticalOffset(geometry, layout.heightPx),
             xPx: x + geometry.xPx + geometry.paddingLeftPx + (paragraph.xPx ?? 0),
             widthPx: paragraph.widthPx ?? Math.max(1, geometry.widthPx - geometry.paddingLeftPx - geometry.paddingRightPx),
-            readOnly: true
+            readOnly: true,
+            ...edges ? { tableFragmentBottomPx: edges.bottom[index].widthPx } : {},
+            tableFrameInsets: {
+              top: (paragraph.tableFrameInsets?.top ?? 0) + (reserveBorders ? geometry.borders?.top?.widthPx ?? 0 : 0),
+              bottom: (paragraph.tableFrameInsets?.bottom ?? 0) + (reserveBorders ? geometry.borders?.bottom?.widthPx ?? 0 : 0)
+            }
           });
       });
       y += layout.heightPx;
     }
+    const bottomBorder = profile?.bottomPx ?? 0;
+    if (frame.rows.length) {
+      frame.rows.at(-1).heightPx += bottomBorder;
+      y += bottomBorder;
+      frame.heightPx = y - frame.yPx;
+      tables.push(frame);
+    }
   }
   boxes.sort((a, b) => a.yPx - b.yPx);
-  return { heightPx: y, boxes };
+  return { heightPx: y, boxes, tables };
 }
 
 // docx/layout/table-layout.ts
@@ -4970,7 +5150,7 @@ function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTo
   }
   return { heightPx: y, boxes };
 }
-function layoutRow(row, tableWidthPx, measurer, note, remaining, startTokens) {
+function layoutRow(row, tableWidthPx, measurer, note, remaining, startTokens, frameBorders = false, frameLeftBorderPx, physicalFragments = reflowNestedFragments(row)) {
   const count = row.cells.length || 1;
   let x = 0;
   const geometry = [];
@@ -4978,59 +5158,81 @@ function layoutRow(row, tableWidthPx, measurer, note, remaining, startTokens) {
     const continuation = remaining?.[geometry.length];
     const starts = continuation ? new Map(continuation.map((box) => [box.blockId, box.lines[0]?.firstToken ?? 0])) : startTokens;
     const widthPx = cell.widthPx ?? tableWidthPx / count;
-    const padding = cell.padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+    const margins = cell.padding ?? { top: 0, right: 0, bottom: 0, left: 0 };
+    const leftBorder = frameBorders ? cell.borders?.left?.widthPx ?? 0 : 0;
+    const rightBorder = frameBorders ? cell.borders?.right?.widthPx ?? 0 : 0;
+    const padding = frameBorders ? {
+      top: margins.top + (cell.borders?.top?.widthPx ?? 0),
+      bottom: margins.bottom,
+      left: leftBorder / 2 + Math.max(margins.left, leftBorder / 2),
+      right: Math.max(margins.right, rightBorder / 2) - rightBorder / 2
+    } : margins;
+    const externalRight = frameBorders && geometry.length === row.cells.length - 1 ? rightBorder : 0;
+    const paintWidth = widthPx + (frameBorders ? (leftBorder - rightBorder) / 2 + externalRight : 0);
+    const frameX = frameBorders ? ((frameLeftBorderPx ?? leftBorder) - leftBorder) / 2 : 0;
     const content2 = stackCellBlocks(
       cell,
-      Math.max(1, widthPx - padding.left - padding.right),
+      Math.max(1, paintWidth - padding.left - padding.right - externalRight),
       measurer,
       note,
       padding.top,
-      starts
+      starts,
+      physicalFragments
     );
     const heightPx2 = content2.heightPx + padding.bottom;
     geometry.push({
-      xPx: cell.xPx ?? x,
-      widthPx,
+      xPx: (cell.xPx ?? x) + frameX,
+      widthPx: paintWidth,
+      ...frameBorders ? { borderInsetsReserved: true } : {},
       paddingLeftPx: padding.left,
-      paddingRightPx: padding.right,
+      paddingRightPx: padding.right + externalRight,
       contentHeightPx: heightPx2,
       ...cell.borders ? { borders: cell.borders } : {},
       ...cell.shading ? { shading: cell.shading } : {},
       ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {}
     });
     x = (cell.xPx ?? x) + widthPx;
-    return { heightPx: heightPx2, boxes: content2.boxes };
+    return { heightPx: heightPx2, boxes: content2.boxes, tables: content2.tables ?? [] };
   });
   const content = Math.max(0, ...laidOut.map((cell) => cell.heightPx));
   const heightPx = row.heightPx === void 0 ? content : row.heightRule === "exact" ? row.heightPx : Math.max(content, row.heightPx);
+  if (frameBorders) for (const cell of geometry) cell.alignmentHeightPx = heightPx;
   return {
     heightPx,
     cells: laidOut.map((cell) => cell.boxes),
     geometry,
+    ...laidOut.some((cell) => cell.tables.length) ? { cellTables: laidOut.map((cell) => cell.tables) } : {},
     cellPadding: row.cells.map((cell) => ({
       top: cell.padding?.top ?? 0,
       bottom: cell.padding?.bottom ?? 0
     }))
   };
 }
-function splitCellAtHeight(boxes, cutHeightPx) {
+function splitCellAtHeight(boxes, cutHeightPx, paragraphCuts) {
   const before = [];
   const after = [];
   let beforeHeightPx = 0;
   for (const box of boxes) {
-    if (box.yPx + box.heightPx <= cutHeightPx) {
+    const cut = paragraphCuts?.get(box.blockId) ?? cutHeightPx;
+    if (box.yPx + box.heightPx + (box.tableFragmentBottomPx ?? box.tableFrameInsets?.bottom ?? 0) <= cut) {
       before.push(box);
-      beforeHeightPx = Math.max(beforeHeightPx, box.yPx + box.heightPx);
+      beforeHeightPx = Math.max(
+        beforeHeightPx,
+        box.yPx + box.heightPx + (box.tableFragmentBottomPx ?? box.tableFrameInsets?.bottom ?? 0)
+      );
       continue;
     }
     const beforeLines = box.lines.filter(
-      (line2) => box.yPx + line2.yPx + line2.heightPx <= cutHeightPx
+      (line2) => box.yPx + line2.yPx + line2.heightPx + (box.tableFragmentBottomPx ?? box.tableFrameInsets?.bottom ?? 0) <= cut
     );
     const afterLines = box.lines.slice(beforeLines.length);
     if (beforeLines.length) {
       const bottom = beforeLines.at(-1).yPx + beforeLines.at(-1).heightPx;
       before.push({ ...box, heightPx: bottom, lines: beforeLines });
-      beforeHeightPx = Math.max(beforeHeightPx, box.yPx + bottom);
+      beforeHeightPx = Math.max(
+        beforeHeightPx,
+        box.yPx + bottom + (box.tableFragmentBottomPx ?? box.tableFrameInsets?.bottom ?? 0)
+      );
     }
     if (afterLines.length) {
       const shift = expectDefined(afterLines[0], "first line after split").yPx;
@@ -5042,43 +5244,81 @@ function splitCellAtHeight(boxes, cutHeightPx) {
       });
     }
   }
-  const afterOrigin = Math.min(...after.map((box) => box.yPx));
+  const afterOrigin = Math.min(...after.map((box) => box.yPx - (box.tableFrameInsets?.top ?? 0)));
   for (const box of after) box.yPx -= afterOrigin;
-  return { before, after, beforeHeightPx };
+  return { before, after, beforeHeightPx, ...after.length ? { afterOrigin } : {} };
 }
-function splitRowAtHeight(row, cutHeightPx, cellCuts) {
+function splitRowAtHeight(row, cutHeightPx, cellCuts, paragraphCuts) {
   const splits = row.cells.map((cell, index) => {
     const padding = row.cellPadding?.[index] ?? { top: 0, bottom: 0 };
-    const split = splitCellAtHeight(cell, (cellCuts?.[index] ?? cutHeightPx) - padding.bottom);
+    const cuts = paragraphCuts ? new Map(
+      cell.flatMap((box) => {
+        const cut = paragraphCuts.get(box.blockId);
+        return cut === void 0 ? [] : [[box.blockId, cut - padding.bottom]];
+      })
+    ) : void 0;
+    const split = splitCellAtHeight(
+      cell,
+      (cellCuts?.[index] ?? cutHeightPx) - padding.bottom,
+      cuts
+    );
     if (split.before.length) split.beforeHeightPx += padding.bottom;
     if (split.after.length)
       split.after = split.after.map((box) => ({ ...box, yPx: box.yPx + padding.top }));
     return split;
   });
   const anyAfter = splits.some((split) => split.after.length > 0);
+  const beforeHeightPx = Math.max(0, ...splits.map((split) => split.beforeHeightPx));
   const before = {
-    heightPx: Math.max(0, ...splits.map((split) => split.beforeHeightPx)),
+    heightPx: beforeHeightPx,
     cells: splits.map((split) => split.before),
+    ...row.cellTables ? {
+      cellTables: row.cellTables.map(
+        (tables, index) => clipTableFrames(
+          tables,
+          0,
+          splits[index].beforeHeightPx - (row.cellPadding?.[index]?.bottom ?? 0)
+        )
+      )
+    } : {},
     geometry: row.geometry.map((geometry, index) => ({
       ...geometry,
-      contentHeightPx: splits[index].beforeHeightPx
+      contentHeightPx: splits[index].beforeHeightPx,
+      ...row.borderBottomPx !== void 0 ? { alignmentHeightPx: beforeHeightPx } : {}
     })),
-    ...row.cellPadding ? { cellPadding: row.cellPadding } : {}
+    ...row.cellPadding ? { cellPadding: row.cellPadding } : {},
+    ...row.borderBottomPx !== void 0 ? { borderBottomPx: row.borderBottomPx } : {}
   };
   if (!anyAfter) return { before, after: null };
+  const afterHeightPx = Math.max(
+    0,
+    ...splits.map(
+      (split, index) => cellContentBottom(split.after, row.cellPadding?.[index]?.bottom ?? 0)
+    )
+  );
   const after = {
-    heightPx: Math.max(
-      0,
-      ...splits.map(
-        (split, index) => split.after.length ? split.after.at(-1).yPx + split.after.at(-1).heightPx + (row.cellPadding?.[index]?.bottom ?? 0) : 0
-      )
-    ),
+    heightPx: afterHeightPx,
     cells: splits.map((split) => split.after),
+    ...row.cellTables ? {
+      cellTables: row.cellTables.map(
+        (tables, index) => splits[index].after.length ? clipTableFrames(
+          tables,
+          splits[index].afterOrigin ?? 0,
+          row.heightPx,
+          row.cellPadding?.[index]?.top ?? 0
+        ) : []
+      )
+    } : {},
     geometry: row.geometry.map((geometry, index) => ({
       ...geometry,
-      contentHeightPx: splits[index].after.length ? splits[index].after.at(-1).yPx + splits[index].after.at(-1).heightPx + (row.cellPadding?.[index]?.bottom ?? 0) : 0
+      contentHeightPx: cellContentBottom(
+        splits[index].after,
+        row.cellPadding?.[index]?.bottom ?? 0
+      ),
+      ...row.borderBottomPx !== void 0 ? { alignmentHeightPx: afterHeightPx } : {}
     })),
-    ...row.cellPadding ? { cellPadding: row.cellPadding } : {}
+    ...row.cellPadding ? { cellPadding: row.cellPadding } : {},
+    ...row.borderBottomPx !== void 0 ? { borderBottomPx: row.borderBottomPx } : {}
   };
   return { before, after };
 }
@@ -5139,11 +5379,11 @@ function splitNote(note, budget) {
 // docx/layout/footnote-columns.ts
 function footnoteColumns(page, columns) {
   const width = page.widthPx - page.marginLeftPx - page.marginRightPx;
-  const equal = (width - columns.gapPx * (columns.count - 1)) / columns.count;
+  const equal2 = (width - columns.gapPx * (columns.count - 1)) / columns.count;
   let x = 0;
   return Array.from({ length: columns.count }, (_, index) => {
     const own = columns.widths?.[index];
-    const column = { xPx: x, widthPx: Math.max(1, own?.widthPx ?? equal) };
+    const column = { xPx: x, widthPx: Math.max(1, own?.widthPx ?? equal2) };
     x += column.widthPx + (own?.gapPx ?? columns.gapPx);
     return column;
   });
@@ -5551,6 +5791,10 @@ var PageCursor = class {
       this.page.heightPx - this.page.marginTopPx - this.geometry.marginBottomPx - this.columnTopPx
     );
   }
+  /** Number of independently balanced note columns, distinct from legacy body-column notes. */
+  get footnoteColumnCount() {
+    return this.legacyFootnoteColumns ? 1 : this.noteColumns?.count ?? 1;
+  }
   remainingHeightPx() {
     return this.columnHeightPx - (this.yPx - this.columnTopPx) - this.footnotes.reserved(this.page, this.noteColumnIndex) - this.pendingHeightPx();
   }
@@ -5795,20 +6039,133 @@ function placeParagraph(cursor, placement, note) {
   }
 }
 
+// docx/layout/table-note-stories.ts
+function independentNoteStories(cell) {
+  const first3 = cell.blocks?.[0];
+  if (first3?.kind !== "table" || first3.rows.length !== 1 || cell.verticalAlign && cell.verticalAlign !== "top")
+    return void 0;
+  if (cell.blocks.slice(1).some((block) => block.kind !== "paragraph" || block.footnotes?.length))
+    return void 0;
+  const row = first3.rows[0];
+  if (row.heightPx !== void 0 || row.cantSplit || row.isHeader || !nestedFrameProfile(first3, first3.widthPx))
+    return void 0;
+  if (row.cells.some(
+    (inner) => inner.blocks?.some((block) => block.kind === "table") || cellParagraphs(inner).some(
+      (paragraph) => paragraph.keepLines || paragraph.keepNext || paragraph.pageBreakBefore
+    ) || inner.verticalAlign && inner.verticalAlign !== "top"
+  ))
+    return void 0;
+  if (!measuredNoteReferences(row.cells.flatMap(cellParagraphs))) return void 0;
+  const groups = /* @__PURE__ */ new Map();
+  row.cells.forEach((inner, index) => {
+    for (const paragraph of cellParagraphs(inner)) groups.set(paragraph.id, first3.id + ":" + index);
+  });
+  return groups.size ? groups : void 0;
+}
+function measuredNoteReferences(paragraphs) {
+  const markers = paragraphs.flatMap(
+    (paragraph) => paragraph.runs.flatMap(
+      (run) => run.footnoteReferenceId === void 0 ? [] : [run.footnoteReferenceId]
+    )
+  );
+  const ids = new Set(markers);
+  const unanchored = paragraphs.flatMap(
+    (paragraph) => (paragraph.footnotes ?? []).filter(
+      (note) => !paragraph.runs.some((run) => run.footnoteReferenceId === note.id)
+    )
+  ).length;
+  return markers.length + unanchored <= 3 && ids.size === markers.length && !(markers.length + unanchored > 1 && unanchored);
+}
+
+// docx/layout/table-border-layout.ts
+function layoutBorderedRow(row, width, measurer, note, profile, remaining, physicalFragments) {
+  const reserved = profile !== void 0 && (profile.leftPx > 0 || profile.rightPx > 0 || profile.bottomPx > 0);
+  const layout = layoutRow(
+    row,
+    width,
+    measurer,
+    note,
+    remaining,
+    void 0,
+    reserved,
+    profile?.leftPx,
+    physicalFragments
+  );
+  if (!reserved) return layout;
+  const bottom = Math.max(0, ...layout.geometry.map((cell) => cell.borders?.bottom?.widthPx ?? 0));
+  return {
+    ...layout,
+    heightPx: layout.heightPx + bottom,
+    borderBottomPx: bottom,
+    cellPadding: row.cells.map((cell) => ({
+      top: (cell.padding?.top ?? 0) + (cell.borders?.top?.widthPx ?? 0),
+      bottom: (cell.padding?.bottom ?? 0) + (cell.borders?.bottom?.widthPx ?? 0)
+    }))
+  };
+}
+var TableFragmentBorders = class {
+  bottom = 0;
+  included = true;
+  record(bottom) {
+    this.bottom = bottom ?? 0;
+    this.included = true;
+  }
+  remove(row) {
+    if (!row || !this.included) return 0;
+    row.heightPx -= this.bottom;
+    this.included = false;
+    return -this.bottom;
+  }
+  restore(row) {
+    if (!row || this.included) return 0;
+    row.heightPx += this.bottom;
+    this.included = true;
+    return this.bottom;
+  }
+};
+
+// docx/layout/table-note-completion.ts
+function completedNoteStoryMinimum(row, stories, pendingBlocks, available) {
+  let minimum = 0;
+  for (const [index, cell] of row.cells.entries()) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const box of cell) {
+      const group = stories.get(box.blockId);
+      if (group !== void 0) {
+        const boxes = groups.get(group) ?? [];
+        boxes.push(box);
+        groups.set(group, boxes);
+      }
+    }
+    for (const boxes of groups.values()) {
+      if (boxes.reduce((count, box) => count + box.lines.length, 0) !== 1 || boxes.some((box) => pendingBlocks.has(box.blockId)))
+        continue;
+      const bottom = cellContentBottom(boxes, row.cellPadding?.[index]?.bottom ?? 0);
+      if (bottom <= available + 1e-6) minimum = Math.max(minimum, bottom);
+    }
+  }
+  return minimum;
+}
+
 // docx/layout/table-footnotes.ts
-function prefix(row, cut, cellCuts) {
+function prefix(row, cut, cellCuts, paragraphCuts) {
   const cells = row.cells.map((cell, index) => {
-    const contentCut = (cellCuts?.[index] ?? cut) - (row.cellPadding?.[index]?.bottom ?? 0);
+    const padding = row.cellPadding?.[index]?.bottom ?? 0;
     const boxes = [];
     for (const box of cell) {
-      if (box.yPx >= contentCut + 1e-6) break;
-      if (box.yPx + box.heightPx <= contentCut + 1e-6) {
+      const contentCut = (paragraphCuts?.get(box.blockId) ?? cellCuts?.[index] ?? cut) - padding;
+      if (box.yPx >= contentCut + 1e-6) {
+        if (!paragraphCuts?.size) break;
+        continue;
+      }
+      if (box.yPx + box.heightPx + (box.tableFrameInsets?.bottom ?? 0) <= contentCut + 1e-6) {
         boxes.push(box);
         continue;
       }
       const lines = [];
       for (const line2 of box.lines) {
-        if (box.yPx + line2.yPx + line2.heightPx > contentCut + 1e-6) break;
+        if (box.yPx + line2.yPx + line2.heightPx + (box.tableFrameInsets?.bottom ?? 0) > contentCut + 1e-6)
+          break;
         lines.push(line2);
       }
       if (lines.length)
@@ -5828,9 +6185,7 @@ function prefix(row, cut, cellCuts) {
     cells,
     heightPx: Math.max(
       0,
-      ...cells.flatMap(
-        (cell, index) => cell.map((box) => box.yPx + box.heightPx + (row.cellPadding?.[index]?.bottom ?? 0))
-      )
+      ...cells.map((cell, index) => cellContentBottom(cell, row.cellPadding?.[index]?.bottom ?? 0))
     )
   };
 }
@@ -5840,16 +6195,23 @@ var TableFootnotes = class {
     this.table = table;
     this.height = height;
     this.resolve = resolve;
-    for (const row of table.rows)
-      for (const cell of row.cells)
+    for (const row of table.rows) {
+      const measured = measuredNoteReferences(row.cells.flatMap(cellParagraphs));
+      for (const cell of row.cells) {
         for (const paragraph of cellParagraphs(cell))
           if (paragraph.footnotes?.length) this.paragraphs.set(paragraph.id, paragraph);
+        for (const [id, group] of (measured ? independentNoteStories(cell) : void 0) ?? []) {
+          this.stories.set(id, group);
+        }
+      }
+    }
   }
   cursor;
   table;
   height;
   resolve;
   paragraphs = /* @__PURE__ */ new Map();
+  stories = /* @__PURE__ */ new Map();
   placed = /* @__PURE__ */ new Set();
   fragment = /* @__PURE__ */ new Map();
   references(row) {
@@ -5871,14 +6233,30 @@ var TableFootnotes = class {
           ) ?? box.lines[0];
           const bottom = Math.min(
             row.heightPx,
-            box.yPx + (line2?.yPx ?? 0) + (line2?.heightPx ?? box.heightPx)
+            box.yPx + (line2?.yPx ?? 0) + (line2?.heightPx ?? box.heightPx) + (box.tableFrameInsets?.bottom ?? 0)
           );
           const prior = refs.get(note.id);
-          if (!prior || bottom < prior.bottom) refs.set(note.id, { note, bottom });
+          if (!prior || bottom < prior.bottom)
+            refs.set(note.id, {
+              note,
+              bottom,
+              blockId: box.blockId,
+              before: box.yPx + (line2?.yPx ?? 0) + (box.tableFrameInsets?.bottom ?? 0)
+            });
         }
       }
     return [...refs.values()];
   }
+  /** A consumed marker no longer constrains its story. Deferred markers stop just before
+   * their own line, allowing another pending story to use a different complete prefix. */
+  storyCut(pending, boxes, padding, cut, space, included) {
+    const ids = new Set(boxes.map((box) => box.blockId));
+    const refs = pending.filter((ref) => ids.has(ref.blockId));
+    let limit = refs.some((ref) => included.has(ref.note.id)) ? Math.min(cut, space) : space;
+    for (const ref of refs)
+      if (!included.has(ref.note.id)) limit = Math.min(limit, ref.before + padding);
+    return limit;
+  }
   hold(refs, minimumBody = 0) {
     const referenceBottom = Math.max(0, ...[...refs.values()].map((ref) => ref.bottom));
     const bodyHeight = Math.max(referenceBottom, minimumBody);
@@ -5889,17 +6267,20 @@ var TableFootnotes = class {
       this.cursor.usedColumnHeightPx + referenceBottom
     );
   }
-  holdCandidate(row) {
+  holdCandidate(row, completionMinimum = 0) {
     const refs = new Map(this.fragment);
     for (const ref of this.references(row))
       if (!refs.has(ref.note.id))
         refs.set(ref.note.id, { ...ref, bottom: this.height() + ref.bottom });
     const referenceBottom = Math.max(0, ...[...refs.values()].map((ref) => ref.bottom));
-    const contentBottom = this.height() + Math.max(0, ...row.cells.flatMap((cell) => cell.map((box) => box.yPx + box.heightPx)));
+    const contentBottom = this.height() + Math.max(0, ...row.cells.map((cell) => cellContentBottom(cell)));
     const paddingBottom = Math.max(0, ...(row.cellPadding ?? []).map((padding) => padding.bottom));
     this.hold(
       refs,
-      contentBottom <= referenceBottom + 1e-6 ? this.height() + row.heightPx : referenceBottom + paddingBottom
+      Math.max(
+        completionMinimum,
+        contentBottom <= referenceBottom + 1e-6 ? this.height() + row.heightPx : referenceBottom + paddingBottom
+      )
     );
   }
   /** Largest complete prefix that keeps each new marker with available note content. */
@@ -5912,29 +6293,76 @@ var TableFootnotes = class {
         return { layout: row, cut: row.heightPx };
     }
     if (!atomic) {
+      const independent = row.cells.some(
+        (cell) => cell.some((box) => this.stories.has(box.blockId))
+      );
+      const pending = independent ? this.references(row) : [];
+      const completing = (this.cursor.footnoteColumnCount === 2 || this.cursor.footnoteColumnCount === 3) && pending.length === 1 && !this.stories.has(pending[0].blockId) ? completedNoteStoryMinimum(
+        row,
+        this.stories,
+        new Set(pending.map((ref) => ref.blockId)),
+        available
+      ) : 0;
       const cuts = /* @__PURE__ */ new Set();
       for (const [index, cell] of row.cells.entries())
         for (const box of cell) {
           if (box.yPx > available + 1e-6) break;
           for (const line2 of box.lines) {
-            const bottom = box.yPx + line2.yPx + line2.heightPx + (row.cellPadding?.[index]?.bottom ?? 0);
+            const bottom = box.yPx + line2.yPx + line2.heightPx + (box.tableFrameInsets?.bottom ?? 0) + (row.cellPadding?.[index]?.bottom ?? 0);
             if (bottom > available + 1e-6) break;
             if (bottom > 0) cuts.add(bottom);
           }
         }
       for (const cut of [...cuts].sort((a, b) => b - a)) {
         const candidate = prefix(row, cut);
-        this.holdCandidate(candidate);
+        const included = new Set(this.references(candidate).map((ref) => ref.note.id));
+        const completion = completing > 0 && included.has(pending[0]?.note.id ?? "") ? this.height() + completing : 0;
+        this.holdCandidate(candidate, completion);
         if (candidate.heightPx <= this.cursor.remainingHeightPx() - this.height() + 1e-6) {
           const space = this.cursor.remainingHeightPx() - this.height();
           const cellCuts = row.cells.map(
-            (cell) => cell.some((box) => this.paragraphs.has(box.blockId)) ? cut : space
+            (cell, index) => independent ? this.storyCut(
+              pending,
+              cell,
+              row.cellPadding?.[index]?.bottom ?? 0,
+              cut,
+              space,
+              included
+            ) : cell.some((box) => this.paragraphs.has(box.blockId)) ? cut : space
           );
-          const expanded = prefix(row, cut, cellCuts);
-          this.holdCandidate(expanded);
+          const paragraphCuts = /* @__PURE__ */ new Map();
+          for (const [index, cell] of row.cells.entries()) {
+            const groups = /* @__PURE__ */ new Map();
+            for (const box of cell) {
+              const group = this.stories.get(box.blockId);
+              if (group !== void 0) {
+                const boxes = groups.get(group) ?? [];
+                boxes.push(box);
+                groups.set(group, boxes);
+              }
+            }
+            for (const boxes of groups.values()) {
+              const limit = this.storyCut(
+                pending,
+                boxes,
+                row.cellPadding?.[index]?.bottom ?? 0,
+                cut,
+                space,
+                included
+              );
+              for (const box of boxes) paragraphCuts.set(box.blockId, limit);
+            }
+          }
+          const expanded = prefix(row, cut, cellCuts, paragraphCuts);
+          this.holdCandidate(expanded, completion);
           if (expanded.heightPx <= this.cursor.remainingHeightPx() - this.height() + 1e-6)
-            return { layout: expanded, cut, cellCuts };
-          this.holdCandidate(candidate);
+            return {
+              layout: expanded,
+              cut,
+              cellCuts,
+              ...paragraphCuts.size ? { paragraphCuts } : {}
+            };
+          this.holdCandidate(candidate, completion);
           return { layout: candidate, cut };
         }
       }
@@ -5961,26 +6389,47 @@ var TableFootnotes = class {
 function placeTable(cursor, table, measurer, note, resolveFootnotes) {
   const firstBodyRow = table.rows.findIndex((row) => !row.isHeader);
   const headerRows = table.rows.slice(0, firstBodyRow < 0 ? table.rows.length : firstBodyRow);
+  const nativeFragments = new Map(table.rows.map((row) => [row, reflowNestedFragments(row)]));
   const xPosition = () => {
-    const width = table.widthPx ?? cursor.columnWidthPx;
+    const width = (table.widthPx ?? cursor.columnWidthPx) + (activeBorders ? (profile.leftPx + profile.rightPx) / 2 : 0);
     return table.alignment === "center" ? Math.max(0, (cursor.columnWidthPx - width) / 2) : table.alignment === "right" ? Math.max(0, cursor.columnWidthPx - width) : table.indentPx ?? 0;
   };
+  const profile = nestedFrameProfile(table, table.widthPx ?? cursor.columnWidthPx);
+  const activeBorders = profile !== void 0 && (profile.leftPx > 0 || profile.rightPx > 0 || profile.bottomPx > 0);
+  if (!profile && table.rows.some((row) => row.cells.some((cell) => cell.borders)))
+    note(
+      "Ordinary table border occupancy remains approximate for missing edges, non-solid or conflicting shared borders and changing row grids."
+    );
+  const layoutRow2 = (row, width, m, n2, remaining, sourceRow = row) => layoutBorderedRow(
+    row,
+    activeBorders ? table.widthPx ?? width : width,
+    m,
+    n2,
+    profile,
+    remaining,
+    nativeFragments.get(sourceRow) ?? false
+  );
+  const fragmentBorders = new TableFragmentBorders();
   let fragmentRows = [];
   let fragmentHeight = 0;
   const footnotes = resolveFootnotes ? new TableFootnotes(cursor, table, () => fragmentHeight, resolveFootnotes) : void 0;
   const toRowBox = (layout, repeated) => {
+    fragmentHeight += fragmentBorders.remove(fragmentRows.at(-1));
     footnotes?.add(layout, repeated);
     const box = {
       yPx: fragmentHeight,
       heightPx: layout.heightPx,
       repeated,
       cells: layout.cells,
-      geometry: layout.geometry
+      geometry: layout.geometry,
+      ...layout.cellTables ? { cellTables: layout.cellTables } : {}
     };
     fragmentHeight += layout.heightPx;
+    fragmentBorders.record(layout.borderBottomPx);
     return box;
   };
   function flushFragment() {
+    fragmentHeight += fragmentBorders.restore(fragmentRows.at(-1));
     if (!fragmentRows.length) {
       footnotes?.holdFragment();
       return;
@@ -5988,6 +6437,9 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
     const box = {
       kind: "table",
       blockId: table.id,
+      ...activeBorders ? {
+        widthPx: (table.widthPx ?? cursor.columnWidthPx) + (profile.leftPx + profile.rightPx) / 2
+      } : {},
       ...xPosition() ? { xPx: xPosition() } : {},
       yPx: 0,
       heightPx: fragmentHeight,
@@ -6006,15 +6458,16 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
   }
   function addHeaders() {
     for (const header of headerRows)
-      fragmentRows.push(toRowBox(layoutRow(header, cursor.columnWidthPx, measurer, note), true));
+      fragmentRows.push(toRowBox(layoutRow2(header, cursor.columnWidthPx, measurer, note), true));
   }
   function placeRow(row, initial, cantSplit) {
     let remainingRow = initial;
     while (remainingRow) {
+      fragmentHeight += fragmentBorders.remove(fragmentRows.at(-1));
       const minimum = cantSplit ? Math.min(remainingRow.heightPx, cursor.columnHeightPx) : Math.min(
         ...remainingRow.cells.flatMap(
-          (cell) => cell.map(
-            (paragraph) => paragraph.yPx + (paragraph.lines[0]?.yPx ?? 0) + (paragraph.lines[0]?.heightPx ?? 0)
+          (cell, index) => cell.map(
+            (paragraph) => paragraph.yPx + (paragraph.lines[0]?.yPx ?? 0) + (paragraph.lines[0]?.heightPx ?? 0) + (remainingRow.borderBottomPx !== void 0 ? (remainingRow.cellPadding?.[index]?.bottom ?? 0) + (paragraph.tableFrameInsets?.bottom ?? 0) : 0)
           )
         )
       );
@@ -6022,12 +6475,13 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
         const width = cursor.columnWidthPx;
         cursor.advancePastFootnotes(fragmentHeight + (Number.isFinite(minimum) ? minimum : 0));
         if (width !== cursor.columnWidthPx) {
-          remainingRow = layoutRow(
+          remainingRow = layoutRow2(
             remainingRow === initial ? row : { ...row, heightPx: 0, heightRule: "atLeast" },
             cursor.columnWidthPx,
             measurer,
             note,
-            remainingRow.cells
+            remainingRow.cells,
+            row
           );
           if (fragmentRows.length) {
             fragmentRows = [];
@@ -6048,17 +6502,19 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
           const { before: before2, after: after2 } = splitRowAtHeight(
             remainingRow,
             selected.cut + 1e-6,
-            selected.cellCuts?.map((cut) => cut + 1e-6)
+            selected.cellCuts?.map((cut) => cut + 1e-6),
+            selected.paragraphCuts ? new Map([...selected.paragraphCuts].map(([id, cut]) => [id, cut + 1e-6])) : void 0
           );
           fragmentRows.push(toRowBox(before2, false));
           const previousWidth2 = cursor.columnWidthPx;
           startNewFragment();
-          remainingRow = after2 && previousWidth2 !== cursor.columnWidthPx ? layoutRow(
+          remainingRow = after2 && (selected.paragraphCuts || previousWidth2 !== cursor.columnWidthPx) ? layoutRow2(
             { ...row, heightPx: 0, heightRule: "atLeast" },
             cursor.columnWidthPx,
             measurer,
             note,
-            after2.cells
+            after2.cells,
+            row
           ) : after2;
           continue;
         }
@@ -6066,12 +6522,13 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
           const previousWidth2 = cursor.columnWidthPx;
           startNewFragment();
           if (previousWidth2 !== cursor.columnWidthPx)
-            remainingRow = layoutRow(
+            remainingRow = layoutRow2(
               remainingRow === initial ? row : { ...row, heightPx: 0, heightRule: "atLeast" },
               cursor.columnWidthPx,
               measurer,
               note,
-              remainingRow === initial ? void 0 : remainingRow.cells
+              remainingRow === initial ? void 0 : remainingRow.cells,
+              row
             );
           continue;
         }
@@ -6085,14 +6542,14 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
       if (cantSplit) {
         if (fragmentRows.length || !cursor.atColumnTop) {
           startNewFragment();
-          remainingRow = layoutRow(row, cursor.columnWidthPx, measurer, note);
+          remainingRow = layoutRow2(row, cursor.columnWidthPx, measurer, note);
         }
         const noteWidth = cursor.columnWidthPx;
         cursor.advancePastFootnotes(
           fragmentHeight + Math.min(remainingRow.heightPx, cursor.columnHeightPx)
         );
         if (noteWidth !== cursor.columnWidthPx) {
-          remainingRow = layoutRow(row, cursor.columnWidthPx, measurer, note);
+          remainingRow = layoutRow2(row, cursor.columnWidthPx, measurer, note);
           if (fragmentRows.length) {
             fragmentRows = [];
             fragmentHeight = 0;
@@ -6118,17 +6575,30 @@ function placeTable(cursor, table, measurer, note, resolveFootnotes) {
       const previousWidth = cursor.columnWidthPx;
       if (before.cells.some((cell) => cell.length)) fragmentRows.push(toRowBox(before, false));
       startNewFragment();
-      remainingRow = after && previousWidth !== cursor.columnWidthPx ? layoutRow(
+      remainingRow = after && (previousWidth !== cursor.columnWidthPx || nativeFragments.get(row)) ? layoutRow2(
         { ...row, heightPx: 0, heightRule: "atLeast" },
         cursor.columnWidthPx,
         measurer,
         note,
-        after.cells
+        after.cells,
+        row
       ) : after;
     }
   }
   for (const row of table.rows) {
-    const layout = layoutRow(row, cursor.columnWidthPx, measurer, note);
+    const layout = layoutRow2(row, cursor.columnWidthPx, measurer, note);
+    if (layout.heightPx > cursor.remainingHeightPx() && !nativeFragments.get(row) && row.cells.some(
+      (cell) => cell.blocks?.some((block) => block.kind === "table" && block.rows.length > 1)
+    ))
+      note(
+        "Nested physical border edges at page cuts remain approximate outside automatic, top-aligned tables with two or more two-cell, note-free rows, direct paragraphs and complete shared borders."
+      );
+    if (activeBorders && layout.heightPx > cursor.remainingHeightPx() && row.cells.some(
+      (cell) => (!measuredNoteReferences(row.cells.flatMap(cellParagraphs)) || !independentNoteStories(cell)) && cell.blocks?.some((block) => block.kind === "table") && cellParagraphs(cell).some((p) => p.footnotes?.length)
+    ))
+      note(
+        "Independent inner-cell continuation around nested note references remains approximate when an enclosing bordered row splits."
+      );
     placeRow(
       row,
       layout,
@@ -6386,9 +6856,9 @@ var SectionFlow = class {
     const page = this.cursor.page;
     const exclusions = this.exclusions?.get(page.index);
     if (!exclusions) return void 0;
-    const plain = this.paragraphLayout(index);
+    const plain2 = this.paragraphLayout(index);
     const topPx = page.marginTopPx + this.cursor.y + spacingBeforePx;
-    const bottomPx = topPx + plain.contentHeightPx;
+    const bottomPx = topPx + plain2.contentHeightPx;
     if (!exclusions.some((item) => item.yPx < bottomPx && item.yPx + item.heightPx > topPx))
       return void 0;
     return layoutParagraph(
@@ -6639,13 +7109,13 @@ function cssHex(value) {
   const hex = value?.replace(/^#/, "");
   return hex && /^[0-9a-f]{6}$/i.test(hex) ? `#${hex}` : void 0;
 }
-function border(side, theme) {
+function border(side, theme, preserveSingleWidth = false) {
   if (!side?.style || side.style === "none" || side.style === "nil") return void 0;
   const style = side.style.startsWith("double") ? "double" : /dot/i.test(side.style) ? "dotted" : /dash/i.test(side.style) ? "dashed" : "solid";
   const themed = side.themeColor && theme ? resolveThemeColorReference({ token: side.themeColor }, theme) : void 0;
   const hex = cssHex(side.color);
   const widthPx = Math.max(
-    style === "double" ? 3 : 1,
+    style === "double" ? 3 : preserveSingleWidth && style === "solid" ? 0 : 1,
     (side.sizeEighthPoints ?? 4) / 8 * 96 / 72
   );
   return { widthPx, style, color: themed ?? hex ?? "#000000" };
@@ -6658,7 +7128,7 @@ function rowLayout(props) {
     ...props.header ? { isHeader: true } : {}
   };
 }
-function adaptTable(table, model, adaptParagraph) {
+function adaptTable(table, model, adaptParagraph, _nested = false) {
   const grid = table.grid?.map(twipsToPx2);
   const columnCount = grid?.length ?? Math.max(1, ...table.rows.map((row) => row.length));
   const gridWidth = (start, span) => grid ? grid.slice(start, start + span).reduce((sum, width) => sum + width, 0) : void 0;
@@ -6700,7 +7170,7 @@ function adaptTable(table, model, adaptParagraph) {
         );
         const borders = {};
         for (const side of ["top", "right", "bottom", "left"]) {
-          const resolved = border(visuals.borders?.[side], model.theme);
+          const resolved = border(visuals.borders?.[side], model.theme, true);
           if (resolved) borders[side] = resolved;
         }
         if (cell.verticalMerge === "continue") delete borders.top;
@@ -6719,7 +7189,7 @@ function adaptTable(table, model, adaptParagraph) {
           paragraphs: cell.paragraphs.map(adaptParagraph),
           ...cell.sourceBlocks ? {
             blocks: cellSourceBlocks(cell).map(
-              (block) => block.type === "paragraph" ? adaptParagraph(block) : adaptTable(block, model, adaptParagraph)
+              (block) => block.type === "paragraph" ? adaptParagraph(block) : adaptTable(block, model, adaptParagraph, true)
             )
           } : {},
           ...width !== void 0 ? { widthPx: width } : {},
@@ -7019,7 +7489,7 @@ function adaptDocumentModel(model, note = () => {
     reportOnce(VERTICAL_MERGE_NOTE);
     if (block.rows.some((row) => row.some((cell) => cell.nestedTables?.length)))
       reportOnce(
-        "Nested tables are projected as read-only cell paragraphs in Print Layout; their borders, shading, vertical merge and repeated header geometry are not rendered."
+        "Nested tables are projected as read-only cell paragraphs in Print Layout; vertical merge and repeated header geometry are not rendered."
       );
     return adaptTable(block, model, adaptParagraph);
   }
@@ -7296,6 +7766,7 @@ exports.SINGLE_LINE_SPACING_UNITS = SINGLE_LINE_SPACING_UNITS;
 exports.adaptDocumentModel = adaptDocumentModel;
 exports.adjustForWidowOrphan = adjustForWidowOrphan;
 exports.appendBreakMarker = appendBreakMarker;
+exports.cellVerticalOffset = cellVerticalOffset;
 exports.createFakeMeasurer = createFakeMeasurer;
 exports.cssFontStack = cssFontStack;
 exports.fieldDisplayText = fieldDisplayText;