ooxml-core 1.8.4 → 1.10.0

package/dist/docx/layout/index.mjs

@@ -37,8 +37,8 @@ function named(element, local, ns, lenient = true) {
 }
 var children = (parent, local, ns, lenient = true) => elements(parent).filter((element) => named(element, local, ns, lenient));
 var first = (parent, local, ns, lenient = true) => parent ? children(parent, local, ns, lenient)[0] : void 0;
-function attr(element, local, ns, prefix) {
-  return element?.getAttributeNS(ns, local) ?? element?.getAttribute(`${prefix}:${local}`) ?? void 0;
+function attr(element, local, ns, prefix2) {
+  return element?.getAttributeNS(ns, local) ?? element?.getAttribute(`${prefix2}:${local}`) ?? void 0;
 }
 
 // docx/xml.ts
@@ -2649,11 +2649,11 @@ function cssFontFamily(name) {
 // chart/render/chart-svg-appearance.ts
 var nextPaintId = 0;
 function chartGradientPaint(model, width = 1024, height = 768) {
-  const prefix = `xlsx-chart-${++nextPaintId}`;
+  const prefix2 = `xlsx-chart-${++nextPaintId}`;
   const appearance = { ...model.appearance };
   const defs = [];
   const shadowPaint = (shadow, suffix) => {
-    const id = `${prefix}-${suffix}`;
+    const id = `${prefix2}-${suffix}`;
     const pad = Math.max(4, shadow.blur * 3 + Math.abs(shadow.dx) + Math.abs(shadow.dy));
     defs.push(
       `<filter id="${id}" filterUnits="userSpaceOnUse" x="${n(-pad)}" y="${n(-pad)}" width="${n(width + pad * 2)}" height="${n(height + pad * 2)}" color-interpolation-filters="sRGB">${svgDropShadowElement(shadow, { number: n, color: (value) => esc(value) })}</filter>`
@@ -2668,7 +2668,7 @@ function chartGradientPaint(model, width = 1024, height = 768) {
       };
   }
   const paint = (gradient, suffix, bounds) => {
-    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds);
+    const def = buildChartGradientDef(`${prefix2}-${suffix}`, gradient, bounds);
     defs.push(chartGradientMarkup(def));
     return `url(#${def.id})`;
   };
@@ -3708,6 +3708,14 @@ function mapDocumentParagraphs(model, map) {
         ...section.footers ? { footers: slots(section.footers) } : {}
       }))
     } : {},
+    ...model.footnoteSeparators ? {
+      footnoteSeparators: Object.fromEntries(
+        Object.entries(model.footnoteSeparators).map(([kind, note]) => [
+          kind,
+          { ...note, blocks: mapBlockParagraphs(note.blocks, map) }
+        ])
+      )
+    } : {},
     ...model.footnotes ? {
       footnotes: model.footnotes.map((note) => ({
         ...note,
@@ -3728,6 +3736,32 @@ function fieldName(instr) {
   return instr.trim().split(/\s+/)[0]?.toUpperCase() ?? "";
 }
 
+// docx/cell-blocks.ts
+function cellSourceBlocks(cell) {
+  if (!cell.sourceBlocks) return cell.paragraphs;
+  const originalIds = new Set(
+    cell.sourceBlocks.filter((block) => block.type === "paragraph").map((block) => block.id)
+  );
+  const positions = new Map(cell.paragraphs.map((paragraph, index) => [paragraph.id, index]));
+  const blocks = [];
+  let cursor = 0;
+  for (const source of cell.sourceBlocks) {
+    if (source.type === "table") {
+      blocks.push(source);
+      continue;
+    }
+    const position = positions.get(source.id);
+    if (position !== void 0 && position >= cursor) {
+      blocks.push(...cell.paragraphs.slice(cursor, position + 1));
+      cursor = position + 1;
+    }
+    while (cursor < cell.paragraphs.length && !originalIds.has(cell.paragraphs[cursor].id))
+      blocks.push(cell.paragraphs[cursor++]);
+  }
+  blocks.push(...cell.paragraphs.slice(cursor));
+  return blocks;
+}
+
 // docx/notes.ts
 var romanNumerals = [
   [1e3, "M"],
@@ -3792,7 +3826,7 @@ function walkBlocks(blocks, kind, order) {
     if (block.type === "paragraph") walkParagraph(block, kind, order);
     else
       for (const row of block.rows)
-        for (const cell of row) walkBlocks(cell.paragraphs, kind, order);
+        for (const cell of row) walkBlocks(cellSourceBlocks(cell), kind, order);
   }
 }
 function numberNotesInOrder(blocks, kind) {
@@ -4391,6 +4425,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;
@@ -4503,6 +4543,9 @@ function resolveIndents(paragraph) {
     firstLineExtraPx
   };
 }
+function sourceLengthOf(run) {
+  return run.sourceLength ?? (run.object ? 1 : run.text.length || (run.breakAfter ? 1 : 0));
+}
 function tokenizeParagraph(paragraph) {
   const tokens = [];
   const runOffsets = [];
@@ -4510,7 +4553,7 @@ function tokenizeParagraph(paragraph) {
   paragraph.runs.forEach((run, runIndex) => {
     runOffsets.push(cursor);
     if (run.hidden) {
-      if (!run.synthetic) cursor += run.sourceLength ?? run.text.length;
+      if (!run.synthetic) cursor += sourceLengthOf(run);
       return;
     }
     if (run.object) tokens.push({ kind: "object", runIndex, sourceStart: 0 });
@@ -4526,7 +4569,7 @@ function tokenizeParagraph(paragraph) {
     if (run.breakAfter) appendBreakMarker(tokens, runIndex, run.text.length, run.breakAfter);
     if (run.synthetic) {
       for (const token of tokens) if (token.runIndex === runIndex) token.sourceStart = 0;
-    } else cursor += run.sourceLength ?? run.text.length;
+    } else cursor += sourceLengthOf(run);
   });
   return { tokens, runOffsets };
 }
@@ -4548,7 +4591,9 @@ function lineMetrics(placed, fonts, paragraph, measurer) {
   let above = 0;
   let below = 0;
   for (const token of tokens) {
-    const extent = tokenExtent(token, paragraph, fonts, measurer);
+    const run = paragraph.runs[token.runIndex];
+    const metrics = run?.object?.noteSeparator ? fontMetrics(measurer, fonts[token.runIndex] ?? fontOf(run)) : void 0;
+    const extent = metrics ? { above: metrics.ascent, below: metrics.descent } : tokenExtent(token, paragraph, fonts, measurer);
     above = Math.max(above, extent.above);
     below = Math.max(below, extent.below);
   }
@@ -4623,7 +4668,18 @@ function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, sta
   const bodyWidth = Math.max(1, contentWidthPx - leftPx - rightPx);
   const fonts = paragraph.runs.map(fontOf);
   const { tokens, runOffsets } = tokenizeParagraph(paragraph);
-  const globalOffset = (token) => expectDefined(runOffsets[token.runIndex], "run offset index") + token.sourceStart;
+  const globalOffset = (token, advance = 0) => {
+    const run = expectDefined(paragraph.runs[token.runIndex], "source run");
+    const length = sourceLengthOf(run);
+    const offset = run.synthetic ? 0 : Math.max(
+      0,
+      Math.min(
+        length,
+        Math.round((token.sourceStart + advance) * length / Math.max(1, run.text.length))
+      )
+    );
+    return expectDefined(runOffsets[token.runIndex], "run offset index") + offset;
+  };
   const effectiveAlign = paragraph.align ?? (paragraph.direction === "rtl" ? "right" : "left");
   const lines = [];
   const pageBreakAfterLine = /* @__PURE__ */ new Set();
@@ -4674,9 +4730,9 @@ function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, sta
       const token = expectDefined(tokens[next], "token index");
       if (ends.has(token.kind)) break;
       if (beforeDecimalPx === void 0 && token.kind === "word" && /[.,]/.test(token.text)) {
-        const prefix = token.text.slice(0, token.text.search(/[.,]/));
+        const prefix2 = token.text.slice(0, token.text.search(/[.,]/));
         beforeDecimalPx = followingPx + runTextWidth(
-          prefix,
+          prefix2,
           expectDefined(paragraph.runs[token.runIndex], "decimal run"),
           measurer
         );
@@ -4695,14 +4751,17 @@ function layoutParagraph(paragraph, contentWidthPx, measurer, note, lineBox, sta
     const [firstPlaced] = placed;
     const start = firstPlaced ? globalOffset(firstPlaced.token) : 0;
     const last = placed.at(-1)?.token;
-    const end = last ? globalOffset(last) + (last.kind === "word" || last.kind === "space" ? last.text.length : 1) : start;
+    const end = last ? globalOffset(last, last.kind === "word" || last.kind === "space" ? last.text.length : 1) : start;
     const gapBeforePx = boxFor(lineIndex).gapBeforePx;
     const { heightPx, baselinePx } = lineMetrics(placed, fonts, paragraph, measurer);
     rendered.forEach(({ token }, index) => {
       const extent2 = tokenExtent(token, paragraph, fonts, measurer);
       const fragment = expectDefined(fragments[index], "fragment for rendered token");
       fragment.sourceStart = globalOffset(token);
-      fragment.sourceEnd = fragment.sourceStart + (paragraph.runs[token.runIndex]?.synthetic ? 0 : token.kind === "word" || token.kind === "space" ? token.text.length : 1);
+      fragment.sourceEnd = globalOffset(
+        token,
+        token.kind === "word" || token.kind === "space" ? token.text.length : 1
+      );
       fragment.topPx = baselinePx - extent2.above;
       if (token.kind !== "object") fragment.boxHeightPx = extent2.ascent + extent2.descent;
     });
@@ -4836,6 +4895,176 @@ function widowControlEnabled(value) {
   return value !== false;
 }
 
+// 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)
+            )
+          } : {}
+        }
+      ];
+    });
+    return [{ ...table, yPx: top - start + inset, heightPx: bottom - top, rows }];
+  });
+}
+
+// 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/table-cell-layout.ts
+function cellParagraphs(cell) {
+  const walk = (blocks) => blocks.flatMap(
+    (block) => block.kind === "paragraph" ? [block] : block.rows.flatMap((row) => row.cells.flatMap(cellParagraphs))
+  );
+  return cell.blocks ? walk(cell.blocks) : cell.paragraphs;
+}
+function stackCellBlocks(cell, width, measurer, note, top, starts) {
+  if (!cell.blocks)
+    return stackParagraphs(
+      starts ? cell.paragraphs.filter((p) => starts.has(p.id)) : cell.paragraphs,
+      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;
+      const result = stackParagraphs([block], width, measurer, note, y, starts);
+      boxes.push(...result.boxes);
+      y = result.heightPx;
+      continue;
+    }
+    const tableWidth = block.widthPx ?? width;
+    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: []
+    };
+    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,
+        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 + 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,
+            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, tables };
+}
+
 // docx/layout/table-layout.ts
 function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTokens) {
   let y = topPx;
@@ -4851,30 +5080,42 @@ function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTo
     );
     y += layout.spacingBeforePx;
     const top = y;
-    const lines = layout.lines.map((line2) => ({ ...line2, yPx: line2.yPx + top }));
+    const lines = layout.lines.map((line2) => ({ ...line2 }));
     boxes.push({
       kind: "paragraph",
       blockId: paragraph.id,
       yPx: top,
       heightPx: layout.contentHeightPx,
-      lines
+      lines,
+      ...layout.frame ? { frame: layout.frame } : {}
     });
     y += layout.contentHeightPx + layout.spacingAfterPx;
   }
   return { heightPx: y, boxes };
 }
-function layoutRow(row, tableWidthPx, measurer, note, remaining) {
+function layoutRow(row, tableWidthPx, measurer, note, remaining, startTokens, frameBorders = false, frameLeftBorderPx) {
   const count = row.cells.length || 1;
   let x = 0;
   const geometry = [];
   const laidOut = row.cells.map((cell) => {
     const continuation = remaining?.[geometry.length];
-    const starts = continuation ? new Map(continuation.map((box) => [box.blockId, box.lines[0]?.firstToken ?? 0])) : void 0;
+    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 content2 = stackParagraphs(
-      starts ? cell.paragraphs.filter((paragraph) => starts.has(paragraph.id)) : cell.paragraphs,
-      Math.max(1, widthPx - padding.left - padding.right),
+    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, paintWidth - padding.left - padding.right - externalRight),
       measurer,
       note,
       padding.top,
@@ -4882,93 +5123,496 @@ function layoutRow(row, tableWidthPx, measurer, note, remaining) {
     );
     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);
-  return { heightPx, cells: laidOut.map((cell) => cell.boxes), geometry };
+  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 afterOrigin = null;
   let beforeHeightPx = 0;
   for (const box of boxes) {
-    if (afterOrigin !== null) {
-      after.push({ ...box, yPx: box.yPx - afterOrigin });
-      continue;
-    }
-    if (box.yPx + box.heightPx <= cutHeightPx) {
+    const cut = paragraphCuts?.get(box.blockId) ?? cutHeightPx;
+    if (box.yPx + box.heightPx + (box.tableFrameInsets?.bottom ?? 0) <= cut) {
       before.push(box);
-      beforeHeightPx = box.yPx + box.heightPx;
-      continue;
-    }
-    if (box.yPx >= cutHeightPx) {
-      afterOrigin = box.yPx;
-      after.push({ ...box, yPx: 0 });
+      beforeHeightPx = Math.max(
+        beforeHeightPx,
+        box.yPx + box.heightPx + (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.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 = box.yPx + bottom;
+      beforeHeightPx = Math.max(
+        beforeHeightPx,
+        box.yPx + bottom + (box.tableFrameInsets?.bottom ?? 0)
+      );
     }
     if (afterLines.length) {
       const shift = expectDefined(afterLines[0], "first line after split").yPx;
-      afterOrigin = box.yPx + shift;
       after.push({
         ...box,
-        yPx: 0,
+        yPx: box.yPx + shift,
         heightPx: afterLines.at(-1).yPx + afterLines.at(-1).heightPx - shift,
         lines: afterLines.map((line2) => ({ ...line2, yPx: line2.yPx - shift }))
       });
-    } else {
-      afterOrigin = box.yPx + box.heightPx;
     }
   }
-  return { before, after, beforeHeightPx };
-}
-function splitRowAtHeight(row, cutHeightPx) {
-  const splits = row.cells.map((cell) => splitCellAtHeight(cell, cutHeightPx));
+  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, ...after.length ? { afterOrigin } : {} };
+}
+function splitRowAtHeight(row, cutHeightPx, cellCuts, paragraphCuts) {
+  const splits = row.cells.map((cell, index) => {
+    const padding = row.cellPadding?.[index] ?? { top: 0, bottom: 0 };
+    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),
-    geometry: row.geometry
+    ...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,
+      ...row.borderBottomPx !== void 0 ? { alignmentHeightPx: beforeHeightPx } : {}
+    })),
+    ...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) => split.after.reduce((max, box) => Math.max(max, box.yPx + box.heightPx), 0)
-      )
-    ),
+    heightPx: afterHeightPx,
     cells: splits.map((split) => split.after),
-    geometry: row.geometry
+    ...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: cellContentBottom(
+        splits[index].after,
+        row.cellPadding?.[index]?.bottom ?? 0
+      ),
+      ...row.borderBottomPx !== void 0 ? { alignmentHeightPx: afterHeightPx } : {}
+    })),
+    ...row.cellPadding ? { cellPadding: row.cellPadding } : {},
+    ...row.borderBottomPx !== void 0 ? { borderBottomPx: row.borderBottomPx } : {}
   };
   return { before, after };
 }
 
-// docx/layout/page-cursor.ts
+// docx/layout/footnote-split.ts
+function splitNote(note, budget) {
+  if (note.heightPx <= budget + 1e-6) return { before: note };
+  const before = [];
+  const after = [];
+  let origin;
+  const sourceTokenStarts = { ...note.sourceTokenStarts };
+  for (const paragraph of note.paragraphs) {
+    if (origin !== void 0) {
+      after.push({ ...paragraph, yPx: paragraph.yPx - origin });
+      continue;
+    }
+    if (paragraph.yPx + paragraph.heightPx <= budget + 1e-6) {
+      before.push(paragraph);
+      continue;
+    }
+    const count = paragraph.lines.filter(
+      (line2) => paragraph.yPx + line2.yPx + line2.heightPx <= budget + 1e-6
+    ).length;
+    const head = paragraph.lines.slice(0, count);
+    const tail = paragraph.lines.slice(count);
+    if (head.length) {
+      const bottom = head.at(-1).yPx + head.at(-1).heightPx;
+      before.push({ ...paragraph, heightPx: bottom, lines: head });
+    }
+    const first3 = tail[0];
+    if (head.length)
+      sourceTokenStarts[paragraph.blockId] = head.at(-1).nextToken ?? sourceTokenStarts[paragraph.blockId] ?? 0;
+    origin = paragraph.yPx + (first3?.yPx ?? 0);
+    after.push({
+      ...paragraph,
+      yPx: 0,
+      heightPx: Math.max(0, paragraph.heightPx - (first3?.yPx ?? 0)),
+      lines: tail.map((line2) => ({ ...line2, yPx: line2.yPx - (first3?.yPx ?? 0) }))
+    });
+  }
+  if (!before.length) return { after: note };
+  const last = before.at(-1);
+  return {
+    before: { ...note, heightPx: last.yPx + last.heightPx, paragraphs: before },
+    ...after.length ? {
+      after: {
+        ...note,
+        yPx: 0,
+        heightPx: Math.max(0, note.heightPx - (origin ?? 0)),
+        paragraphs: after,
+        continued: true,
+        sourceTokenStarts
+      }
+    } : {}
+  };
+}
+
+// docx/layout/footnote-columns.ts
+function footnoteColumns(page, columns) {
+  const width = page.widthPx - page.marginLeftPx - page.marginRightPx;
+  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 ?? equal2) };
+    x += column.widthPx + (own?.gapPx ?? columns.gapPx);
+    return column;
+  });
+}
+function packFootnotes(notes, columns, height, reflow) {
+  const remaining = [...notes], placed = [];
+  let used = 0;
+  for (const [columnIndex, column] of columns.entries()) {
+    let y = 0;
+    while (remaining.length) {
+      const current = reflow(remaining[0], column.widthPx);
+      const split = splitNote(current, Math.max(0, height - y));
+      if (!split.before) break;
+      placed.push({
+        ...split.before,
+        yPx: y,
+        xPx: column.xPx,
+        widthPx: column.widthPx,
+        columnIndex
+      });
+      y += split.before.heightPx;
+      used = Math.max(used, y);
+      if (split.after) {
+        remaining[0] = { ...split.after, continued: !!current.continued };
+        break;
+      }
+      remaining.shift();
+    }
+  }
+  return { placed, remaining, heightPx: used };
+}
+function balancedFootnotes(notes, columns, limit, reflow) {
+  if (!notes.length) return { placed: [], remaining: [], heightPx: 0 };
+  const full = packFootnotes(notes, columns, limit, reflow);
+  if (full.remaining.length) return full;
+  let lower = 0, upper = limit;
+  for (let step = 0; step < 24 && upper - lower > 5e-3; step++) {
+    const middle = (lower + upper) / 2;
+    if (packFootnotes(notes, columns, middle, reflow).remaining.length) lower = middle;
+    else upper = middle;
+  }
+  return packFootnotes(notes, columns, Math.ceil(upper * 100) / 100, reflow);
+}
+function minimumFootnoteHeight(notes, columns, reflow) {
+  const width = columns[0].widthPx;
+  const maximum = notes.reduce((sum, note) => sum + reflow(note, width).heightPx, 0);
+  return balancedFootnotes(notes, columns, maximum, reflow).heightPx;
+}
+
+// docx/layout/footnote-flow.ts
+function firstLineBottom(note) {
+  const first3 = note?.paragraphs[0];
+  return first3 ? first3.yPx + (first3.lines[0]?.yPx ?? 0) + (first3.lines[0]?.heightPx ?? first3.heightPx) : note?.heightPx ?? 0;
+}
 var FOOTNOTE_SEPARATOR_PX = 12;
+var FootnoteFlow = class {
+  constructor(report, separator, columns, reflow = (note) => note) {
+    this.report = report;
+    this.separator = separator;
+    this.columns = columns;
+    this.reflow = reflow;
+  }
+  report;
+  separator;
+  columns;
+  reflow;
+  pending;
+  remaining = [];
+  sources = /* @__PURE__ */ new WeakMap();
+  separatorHeight(page, notes = this.pending?.notes ?? []) {
+    return (page.footnoteSeparator ?? this.separator?.(page, !!notes[0]?.continued))?.heightPx ?? FOOTNOTE_SEPARATOR_PX;
+  }
+  get hasContinuation() {
+    return this.remaining.length > 0;
+  }
+  hold(blockId, notes, bodyMinimum, freshBodyMinimum = bodyMinimum) {
+    this.pending = notes.length ? { blockId, notes, bodyMinimum, freshBodyMinimum } : void 0;
+  }
+  reserved(page, _columnIndex = 0) {
+    return page.footnotes?.length ? this.separatorHeight(page) + (page.footnoteHeightPx ?? page.footnotes.reduce((sum, note) => sum + note.heightPx, 0)) : 0;
+  }
+  pendingHeight(page, capacity, bodyUsed, _columnIndex = 0) {
+    if (!this.pending) return 0;
+    if (this.columns) {
+      const existing = this.sources.get(page) ?? [];
+      const height = minimumFootnoteHeight(
+        [...existing, ...this.pending.notes],
+        footnoteColumns(page, this.columns),
+        this.reflow
+      ) + this.separatorHeight(page);
+      if (height + this.pending.freshBodyMinimum <= capacity)
+        return Math.max(0, height - this.reserved(page));
+      return Math.max(
+        firstLineBottom(this.pending.notes[0]) + (page.footnotes?.length ? 0 : this.separatorHeight(page)),
+        capacity - bodyUsed - this.reserved(page) - this.pending.bodyMinimum
+      );
+    }
+    const total = this.pending.notes.reduce((sum, note) => sum + note.heightPx, 0);
+    const separator = page.footnotes?.length ? 0 : this.separatorHeight(page);
+    if (total + this.separatorHeight(page) + this.pending.freshBodyMinimum <= capacity)
+      return total + separator;
+    return Math.max(
+      firstLineBottom(this.pending.notes[0]) + separator,
+      capacity - bodyUsed - this.reserved(page) - this.pending.bodyMinimum
+    );
+  }
+  /** A later column cannot grow the page-wide note area into body content already placed. */
+  blockedByEarlierColumn(page, capacity, bodyBottom) {
+    if (!this.pending) return false;
+    if (this.columns)
+      return bodyBottom + this.reserved(page) + this.pendingHeight(page, capacity, bodyBottom) > capacity;
+    const total = this.pending.notes.reduce((sum, note) => sum + note.heightPx, 0);
+    const minimum = firstLineBottom(this.pending.notes[0]);
+    const needed = total + this.separatorHeight(page) + this.pending.freshBodyMinimum <= capacity ? total : minimum;
+    return bodyBottom + this.reserved(page) + needed + (page.footnotes?.length ? 0 : this.separatorHeight(page)) > capacity;
+  }
+  commit(blockId, page, available, _columnIndex = 0) {
+    if (this.pending?.blockId !== blockId) return false;
+    const notes = this.pending.notes;
+    this.pending = void 0;
+    this.append(page, notes, available);
+    return true;
+  }
+  resume(page, capacity, _columnIndex, width) {
+    const notes = width === void 0 ? this.remaining : this.remaining.map((note) => this.reflow(note, width));
+    this.remaining = [];
+    this.append(page, notes, capacity);
+  }
+  append(page, notes, available) {
+    if (!page.footnotes?.length && notes.length) {
+      const separator = this.separator?.(page, !!notes[0]?.continued);
+      if (separator) page.footnoteSeparator = separator;
+    }
+    if (this.columns) {
+      const sources = [...this.sources.get(page) ?? [], ...notes];
+      this.sources.set(page, sources);
+      const geometry = footnoteColumns(page, this.columns);
+      const previousHeight = page.footnoteHeightPx ?? 0;
+      const capacity = Math.max(
+        0,
+        available + previousHeight - (page.footnotes?.length ? 0 : this.separatorHeight(page))
+      );
+      let packed = balancedFootnotes(sources, geometry, capacity, this.reflow);
+      if (!packed.placed.length && sources.length) {
+        this.report(
+          "A footnote line was taller than its available page area and was placed without splitting."
+        );
+        packed = balancedFootnotes(
+          sources,
+          geometry,
+          firstLineBottom(this.reflow(sources[0], geometry[0].widthPx)),
+          this.reflow
+        );
+      }
+      page.footnotes = packed.placed;
+      page.footnoteHeightPx = packed.heightPx;
+      this.remaining = packed.remaining.map((note) => ({
+        ...note,
+        continued: !!note.continued || packed.placed.some((fragment) => fragment.id === note.id)
+      }));
+      return;
+    }
+    let top = page.footnotes?.reduce((sum, note) => sum + note.heightPx, 0) ?? 0;
+    let budget = Math.max(0, available - (page.footnotes?.length ? 0 : this.separatorHeight(page)));
+    for (let index = 0; index < notes.length; index++) {
+      const note = notes[index];
+      let split = splitNote(note, budget);
+      if (!split.before && !page.footnotes?.length) {
+        split = splitNote(note, firstLineBottom(note));
+        this.report(
+          "A footnote line was taller than its available page area and was placed without splitting."
+        );
+      }
+      if (split.before) {
+        (page.footnotes ??= []).push({ ...split.before, yPx: top });
+        top += split.before.heightPx;
+        budget -= split.before.heightPx;
+      }
+      if (split.after) {
+        this.remaining.push(split.after, ...notes.slice(index + 1));
+        break;
+      }
+    }
+  }
+};
+
+// docx/layout/legacy-footnote-flow.ts
+var LegacyFootnoteFlow = class {
+  flow;
+  views = /* @__PURE__ */ new WeakMap();
+  constructor(report, separator, reflow = (note) => note) {
+    this.flow = new FootnoteFlow(report, separator, void 0, reflow);
+  }
+  view(page, index) {
+    let views = this.views.get(page);
+    if (!views) {
+      views = /* @__PURE__ */ new Map();
+      this.views.set(page, views);
+    }
+    let view = views.get(index);
+    if (!view) {
+      const {
+        footnotes: _notes,
+        footnoteSeparator: _separator,
+        footnoteHeightPx: _height,
+        footnoteColumnAreas: _areas,
+        ...geometry
+      } = page;
+      view = {
+        ...geometry,
+        widthPx: page.columns[index].widthPx,
+        marginLeftPx: 0,
+        marginRightPx: 0,
+        columns: []
+      };
+      views.set(index, view);
+    }
+    return view;
+  }
+  sync(page) {
+    const views = this.views.get(page);
+    if (!views) return;
+    const areas = [...views].filter(([, view]) => view.footnotes?.length).map(([columnIndex, view]) => {
+      const column = page.columns[columnIndex];
+      return {
+        columnIndex,
+        xPx: column.xPx,
+        widthPx: column.widthPx,
+        heightPx: view.footnotes.reduce((sum, note) => sum + note.heightPx, 0),
+        continued: !!view.footnotes[0]?.continued,
+        ...view.footnoteSeparator ? { separator: view.footnoteSeparator } : {},
+        yPx: 0
+      };
+    });
+    const height = Math.max(0, ...areas.map((area) => area.heightPx));
+    for (const area of areas) area.yPx = height - area.heightPx;
+    page.footnoteColumnAreas = areas;
+    page.footnoteHeightPx = height;
+    page.footnotes = areas.flatMap(
+      (area) => this.view(page, area.columnIndex).footnotes.map((note) => ({
+        ...note,
+        xPx: area.xPx,
+        widthPx: area.widthPx,
+        columnIndex: area.columnIndex,
+        yPx: area.yPx + note.yPx
+      }))
+    );
+  }
+  get hasContinuation() {
+    return this.flow.hasContinuation;
+  }
+  hold(blockId, notes, bodyMinimum, freshBodyMinimum = bodyMinimum) {
+    this.flow.hold(blockId, notes, bodyMinimum, freshBodyMinimum);
+  }
+  reserved(page, columnIndex = 0) {
+    return this.flow.reserved(this.view(page, columnIndex));
+  }
+  pendingHeight(page, capacity, bodyUsed, columnIndex = 0) {
+    return this.flow.pendingHeight(this.view(page, columnIndex), capacity, bodyUsed);
+  }
+  blockedByEarlierColumn(_page, _capacity, _bodyBottom) {
+    return false;
+  }
+  commit(blockId, page, available, columnIndex = 0) {
+    if (this.flow.commit(blockId, this.view(page, columnIndex), available)) this.sync(page);
+  }
+  resume(page, capacity, columnIndex) {
+    if (!this.flow.hasContinuation) return;
+    const indexes = columnIndex === void 0 ? page.columns.map((_, index) => index) : [columnIndex];
+    for (const index of indexes) {
+      if (!this.flow.hasContinuation) break;
+      const view = this.view(page, index);
+      if (view.footnotes?.length) continue;
+      this.flow.resume(view, capacity, void 0, view.widthPx);
+    }
+    this.sync(page);
+  }
+};
+
+// docx/layout/page-cursor.ts
 var PageCursor = class {
-  constructor(pages, geometry, columns, sectionIndex = 0, continueAt, balance) {
+  constructor(pages, geometry, columns, sectionIndex = 0, continueAt, balance, report = () => {
+  }, separator, noteColumns, reflow, legacyFootnoteColumns = false) {
     this.balance = balance;
+    this.noteColumns = noteColumns;
+    this.legacyFootnoteColumns = legacyFootnoteColumns;
+    this.footnotes = legacyFootnoteColumns ? new LegacyFootnoteFlow(report, separator, reflow) : new FootnoteFlow(report, separator, noteColumns, reflow);
     this.sectionIndex = sectionIndex;
     this.pages = pages;
     this.geometry = geometry;
@@ -4992,6 +5636,8 @@ var PageCursor = class {
     }
   }
   balance;
+  noteColumns;
+  legacyFootnoteColumns;
   pages;
   equalColumnWidthPx;
   activeColumns = [];
@@ -5002,10 +5648,7 @@ var PageCursor = class {
   yPx = 0;
   sectionIndex;
   pageInSection = 0;
-  /** Height taken by footnotes (and their separator) at the bottom of the current page. */
-  reservedPx = 0;
-  /** Footnotes of the paragraph about to be placed; they join the page its first box lands on. */
-  pending;
+  footnotes;
   columnBoxes(offsetPx = 0) {
     const columnBoxes = [];
     let xPx = offsetPx;
@@ -5040,7 +5683,7 @@ var PageCursor = class {
     this.columnIndex = 0;
     this.columnTopPx = 0;
     this.yPx = 0;
-    this.reservedPx = 0;
+    this.footnotes.resume(this.page, this.physicalColumnHeightPx);
   }
   get page() {
     return this.pages.at(-1);
@@ -5048,6 +5691,9 @@ var PageCursor = class {
   get column() {
     return expectDefined(this.activeColumns[this.columnIndex], "current page column");
   }
+  get noteColumnIndex() {
+    return this.legacyFootnoteColumns ? this.page.columns.indexOf(this.column) : this.columnIndex;
+  }
   get columnWidthPx() {
     return this.column.widthPx;
   }
@@ -5062,6 +5708,9 @@ var PageCursor = class {
   endBalance() {
     this.balance = void 0;
   }
+  get footnoteWidthPx() {
+    return this.noteColumns ? footnoteColumns(this.page, this.noteColumns)[0].widthPx : this.columnWidthPx;
+  }
   get y() {
     return this.yPx;
   }
@@ -5084,8 +5733,12 @@ 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.reservedPx - this.pendingHeightPx();
+    return this.columnHeightPx - (this.yPx - this.columnTopPx) - this.footnotes.reserved(this.page, this.noteColumnIndex) - this.pendingHeightPx();
   }
   /** Close this section's column band before another section shares its page. */
   finishBand() {
@@ -5104,16 +5757,41 @@ var PageCursor = class {
     return bottom;
   }
   pendingHeightPx() {
-    if (!this.pending) return 0;
-    return this.pending.heightPx + (this.page.footnotes?.length ? 0 : FOOTNOTE_SEPARATOR_PX);
+    return this.footnotes.pendingHeight(
+      this.page,
+      this.columnHeightPx,
+      this.usedColumnHeightPx,
+      this.noteColumnIndex
+    );
   }
   /**
    * Reserves room for a paragraph's footnotes on whichever page its first box is placed, so the
    * notes print on the same page as their reference, as Word does.
    */
-  holdFootnotes(blockId, notes) {
-    const heightPx = notes.reduce((sum, note) => sum + note.heightPx, 0);
-    this.pending = notes.length ? { blockId, notes, heightPx } : void 0;
+  holdFootnotes(blockId, notes, bodyMinimum = 0, freshBodyMinimum = bodyMinimum) {
+    this.footnotes.hold(blockId, notes, bodyMinimum, freshBodyMinimum);
+  }
+  /** Finish long notes even when the section has no more body paragraphs. */
+  finishFootnotes() {
+    while (this.footnotes.hasContinuation) {
+      if (this.legacyFootnoteColumns) this.newColumn();
+      else this.newPage();
+    }
+  }
+  /** Continued notes can occupy an otherwise empty page, before body/table content starts. */
+  advancePastFootnotes(minimumBodyHeight) {
+    while (this.page.footnotes?.length && this.atColumnTop && this.remainingHeightPx() < minimumBodyHeight - 1e-6 || this.columnIndex > 0 && this.footnotes.blockedByEarlierColumn(
+      this.page,
+      this.columnHeightPx,
+      Math.max(
+        0,
+        ...this.activeColumns.slice(0, this.columnIndex).flatMap(
+          (column) => column.blocks.map((block) => block.yPx + block.heightPx - this.columnTopPx)
+        )
+      )
+    ))
+      if (this.legacyFootnoteColumns) this.newColumn();
+      else this.newPage();
   }
   newPage() {
     this.pushPage();
@@ -5123,6 +5801,8 @@ var PageCursor = class {
     if (this.columnIndex + 1 < this.columns.count) {
       this.columnIndex++;
       this.yPx = this.columnTopPx;
+      if (this.legacyFootnoteColumns)
+        this.footnotes.resume(this.page, this.physicalColumnHeightPx, this.noteColumnIndex);
     } else {
       this.pushPage();
     }
@@ -5136,25 +5816,54 @@ var PageCursor = class {
     box.yPx = this.yPx;
     this.column.blocks.push(box);
     this.yPx += advancePx;
-    if (this.pending && this.pending.blockId === box.blockId) {
-      this.reservedPx += this.pendingHeightPx();
-      const page = this.page;
-      let top = page.footnotes?.reduce((sum, note) => sum + note.heightPx, 0) ?? 0;
-      for (const note of this.pending.notes) {
-        (page.footnotes ??= []).push({ ...note, yPx: top });
-        top += note.heightPx;
-      }
-      this.pending = void 0;
-    }
+    const bodyBottom = this.legacyFootnoteColumns ? this.yPx : Math.max(
+      this.yPx,
+      ...this.activeColumns.flatMap(
+        (column) => column.blocks.map((block) => block.yPx + block.heightPx)
+      )
+    );
+    this.footnotes.commit(
+      box.blockId,
+      this.page,
+      this.columnHeightPx - (bodyBottom - this.columnTopPx) - this.footnotes.reserved(this.page, this.noteColumnIndex),
+      this.noteColumnIndex
+    );
   }
 };
 
 // docx/layout/flow-paragraph.ts
 function placeParagraph(cursor, placement, note) {
   const { paragraph, spacingBeforePx, requiredTogetherPx, reflow } = placement;
-  let layout = placement.layout;
+  const trailingBreakLine = (result) => {
+    const last = result.lines.at(-1);
+    if (!placement.trimLeadingColumnBreak || !last || !result.columnBreakAfterLine.has(result.lines.length - 1))
+      return result;
+    return {
+      ...result,
+      contentHeightPx: result.contentHeightPx + last.heightPx,
+      lines: [
+        ...result.lines,
+        {
+          ...last,
+          yPx: last.yPx + last.heightPx,
+          fragments: [],
+          sourceStart: last.sourceEnd,
+          sourceEnd: last.sourceEnd
+        }
+      ]
+    };
+  };
+  let layout = trailingBreakLine(placement.layout);
   let width = cursor.columnWidthPx;
   if (paragraph.pageBreakBefore && cursor.hasPageContent) cursor.newPage();
+  if (requiredTogetherPx > 0 && placement.footnotes) {
+    cursor.holdFootnotes(
+      paragraph.id,
+      placement.footnotes(layout.lines, true),
+      requiredTogetherPx,
+      layout.lines[0]?.heightPx ?? 0
+    );
+  }
   if (requiredTogetherPx > 0 && requiredTogetherPx <= cursor.columnHeightPx && requiredTogetherPx > cursor.remainingHeightPx() && !cursor.atColumnTop) {
     cursor.newColumn();
   }
@@ -5162,9 +5871,23 @@ function placeParagraph(cursor, placement, note) {
   let lineCursor = 0;
   let nextToken = 0;
   let firstSegment = true;
+  const lineHeight = (line2, index) => placement.trimLeadingColumnBreak && layout.columnBreakAfterLine.has(index) && line2.fragments.every((fragment) => !fragment.text && !fragment.object) ? 0 : line2.heightPx;
+  const placedNotes = /* @__PURE__ */ new Set();
+  const notesFor = (lines) => (placement.footnotes?.(lines, firstSegment) ?? []).filter((item) => !placedNotes.has(item.id));
+  const hold = (lines, bodyMinimum) => {
+    const notes = notesFor(lines);
+    if (placement.footnotes)
+      cursor.holdFootnotes(
+        paragraph.id,
+        notes,
+        bodyMinimum,
+        Math.max(0, ...lines.map((line2) => line2.heightPx))
+      );
+    return notes;
+  };
   const reflowIfNeeded = () => {
     if (!reflow || cursor.columnWidthPx === width) return;
-    layout = reflow(nextToken);
+    layout = trailingBreakLine(reflow(nextToken));
     lineCursor = 0;
     width = cursor.columnWidthPx;
   };
@@ -5178,15 +5901,27 @@ function placeParagraph(cursor, placement, note) {
   }
   while (lineCursor < layout.lines.length) {
     reflowIfNeeded();
-    const budget = cursor.remainingHeightPx() - (firstSegment ? spacingBeforePx : 0);
+    hold(
+      layout.lines.slice(lineCursor, lineCursor + 1),
+      layout.lines[lineCursor] ? lineHeight(layout.lines[lineCursor], lineCursor) : 0
+    );
+    cursor.advancePastFootnotes(
+      layout.lines[lineCursor] ? lineHeight(layout.lines[lineCursor], lineCursor) : 0
+    );
+    reflowIfNeeded();
     let cumulative = 0;
     let end = lineCursor;
     let forced;
     for (let i = lineCursor; i < layout.lines.length; i++) {
       const line2 = expectDefined(layout.lines[i], "paragraph line index");
       const gap = i === lineCursor && !firstSegment ? 0 : line2.gapBeforePx ?? 0;
-      const height = line2.heightPx + gap;
-      if (cumulative + height > budget && (end > lineCursor || !cursor.atColumnTop)) break;
+      const height = lineHeight(line2, i) + gap;
+      hold(
+        layout.lines.slice(lineCursor, i + 1),
+        cumulative + height + (firstSegment ? spacingBeforePx : 0)
+      );
+      const budget = cursor.remainingHeightPx() - (firstSegment ? spacingBeforePx : 0);
+      if (cumulative + height > budget + 1e-6 && (end > lineCursor || !cursor.atColumnTop)) break;
       cumulative += height;
       end = i + 1;
       if (layout.pageBreakAfterLine.has(i)) {
@@ -5211,9 +5946,17 @@ function placeParagraph(cursor, placement, note) {
       );
       placedCount = Math.max(1, end - lineCursor);
     }
+    const committedNotes = hold(
+      layout.lines.slice(lineCursor, lineCursor + placedCount),
+      cumulative + (firstSegment ? spacingBeforePx : 0)
+    );
     const first3 = expectDefined(layout.lines[lineCursor], "first line of paragraph segment");
     const origin = first3.yPx - (firstSegment ? (first3.gapBeforePx ?? 0) + layout.insetTopPx : 0);
-    const segmentLines = layout.lines.slice(lineCursor, lineCursor + placedCount).map((line2) => ({ ...line2, yPx: line2.yPx - origin }));
+    const segmentLines = layout.lines.slice(lineCursor, lineCursor + placedCount).map((line2, index) => ({
+      ...line2,
+      yPx: line2.yPx - origin,
+      heightPx: lineHeight(line2, lineCursor + index)
+    }));
     const isFinal = lineCursor + placedCount >= layout.lines.length;
     const lastLine = segmentLines.at(-1);
     const isLastSegment = lineCursor + placedCount >= layout.lines.length;
@@ -5228,6 +5971,7 @@ function placeParagraph(cursor, placement, note) {
     };
     const advance = (firstSegment ? spacingBeforePx : 0) + segmentHeight + (isFinal ? layout.spacingAfterPx : 0);
     cursor.place(box, advance);
+    for (const item of committedNotes) placedNotes.add(item.id);
     nextToken = layout.lines[lineCursor + placedCount - 1]?.nextToken ?? nextToken;
     lineCursor += placedCount;
     firstSegment = false;
@@ -5237,50 +5981,494 @@ 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) {
+  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
+  );
+  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, paragraphCuts) {
+  const cells = row.cells.map((cell, index) => {
+    const padding = row.cellPadding?.[index]?.bottom ?? 0;
+    const boxes = [];
+    for (const box of cell) {
+      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 + (box.tableFrameInsets?.bottom ?? 0) > contentCut + 1e-6)
+          break;
+        lines.push(line2);
+      }
+      if (lines.length)
+        boxes.push({ ...box, lines, heightPx: lines.at(-1).yPx + lines.at(-1).heightPx });
+      continue;
+    }
+    return boxes;
+  });
+  if (cells.every(
+    (cell, index) => cell.length === row.cells[index].length && cell.every(
+      (box, boxIndex) => box.lines.length === row.cells[index][boxIndex].lines.length
+    )
+  ))
+    return row;
+  return {
+    ...row,
+    cells,
+    heightPx: Math.max(
+      0,
+      ...cells.map((cell, index) => cellContentBottom(cell, row.cellPadding?.[index]?.bottom ?? 0))
+    )
+  };
+}
+var TableFootnotes = class {
+  constructor(cursor, table, height, resolve) {
+    this.cursor = cursor;
+    this.table = table;
+    this.height = height;
+    this.resolve = resolve;
+    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) {
+    const refs = /* @__PURE__ */ new Map();
+    for (const cell of row.cells)
+      for (const box of cell) {
+        const source = this.paragraphs.get(box.blockId);
+        if (!source) continue;
+        for (const note of this.resolve(
+          source,
+          box.lines,
+          (box.lines[0]?.sourceStart ?? 0) === 0
+        )) {
+          if (this.placed.has(note.id)) continue;
+          const line2 = box.lines.find(
+            (line3) => line3.fragments.some(
+              (fragment) => source.runs[fragment.runIndex]?.footnoteReferenceId === note.id
+            )
+          ) ?? box.lines[0];
+          const bottom = Math.min(
+            row.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,
+              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);
+    this.cursor.holdFootnotes(
+      this.table.id,
+      [...refs.values()].map((ref) => ref.note),
+      bodyHeight,
+      this.cursor.usedColumnHeightPx + referenceBottom
+    );
+  }
+  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.map((cell) => cellContentBottom(cell)));
+    const paddingBottom = Math.max(0, ...(row.cellPadding ?? []).map((padding) => padding.bottom));
+    this.hold(
+      refs,
+      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. */
+  choose(row, atomic) {
+    this.cursor.holdFootnotes(this.table.id, [], 0);
+    const available = this.cursor.remainingHeightPx() - this.height();
+    if (row.heightPx <= available + 1e-6) {
+      this.holdCandidate(row);
+      if (row.heightPx <= this.cursor.remainingHeightPx() - this.height() + 1e-6)
+        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 + (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);
+        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, 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 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,
+              ...paragraphCuts.size ? { paragraphCuts } : {}
+            };
+          this.holdCandidate(candidate, completion);
+          return { layout: candidate, cut };
+        }
+      }
+    }
+    this.holdFragment();
+    return void 0;
+  }
+  add(row, repeated) {
+    if (repeated) return;
+    for (const ref of this.references(row))
+      if (!this.fragment.has(ref.note.id))
+        this.fragment.set(ref.note.id, { ...ref, bottom: this.height() + ref.bottom });
+  }
+  holdFragment() {
+    this.hold(this.fragment);
+  }
+  flushed() {
+    for (const id of this.fragment.keys()) this.placed.add(id);
+    this.fragment.clear();
+  }
+};
+
 // docx/layout/flow-table.ts
-function placeTable(cursor, table, measurer, note) {
+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 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) => layoutBorderedRow(
+    row,
+    activeBorders ? table.widthPx ?? width : width,
+    m,
+    n2,
+    profile,
+    remaining
+  );
+  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() {
-    if (!fragmentRows.length) return;
+    fragmentHeight += fragmentBorders.restore(fragmentRows.at(-1));
+    if (!fragmentRows.length) {
+      footnotes?.holdFragment();
+      return;
+    }
     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,
       rows: fragmentRows
     };
+    footnotes?.holdFragment();
     cursor.place(box, fragmentHeight);
+    footnotes?.flushed();
     fragmentRows = [];
     fragmentHeight = 0;
   }
   function startNewFragment() {
     flushFragment();
     cursor.newColumn();
+    addHeaders();
+  }
+  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, 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)
+          )
+        )
+      );
+      if (fragmentRows.every((item) => item.repeated)) {
+        const width = cursor.columnWidthPx;
+        cursor.advancePastFootnotes(fragmentHeight + (Number.isFinite(minimum) ? minimum : 0));
+        if (width !== cursor.columnWidthPx) {
+          remainingRow = layoutRow2(
+            remainingRow === initial ? row : { ...row, heightPx: 0, heightRule: "atLeast" },
+            cursor.columnWidthPx,
+            measurer,
+            note,
+            remainingRow.cells
+          );
+          if (fragmentRows.length) {
+            fragmentRows = [];
+            fragmentHeight = 0;
+            addHeaders();
+          }
+          continue;
+        }
+      }
+      if (footnotes) {
+        const selected = footnotes.choose(remainingRow, cantSplit);
+        if (selected) {
+          if (selected.layout === remainingRow) {
+            fragmentRows.push(toRowBox(remainingRow, false));
+            remainingRow = null;
+            continue;
+          }
+          const { before: before2, after: after2 } = splitRowAtHeight(
+            remainingRow,
+            selected.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 && (selected.paragraphCuts || previousWidth2 !== cursor.columnWidthPx) ? layoutRow2(
+            { ...row, heightPx: 0, heightRule: "atLeast" },
+            cursor.columnWidthPx,
+            measurer,
+            note,
+            after2.cells
+          ) : after2;
+          continue;
+        }
+        if (fragmentRows.length || !cursor.atColumnTop) {
+          const previousWidth2 = cursor.columnWidthPx;
+          startNewFragment();
+          if (previousWidth2 !== cursor.columnWidthPx)
+            remainingRow = layoutRow2(
+              remainingRow === initial ? row : { ...row, heightPx: 0, heightRule: "atLeast" },
+              cursor.columnWidthPx,
+              measurer,
+              note,
+              remainingRow === initial ? void 0 : remainingRow.cells
+            );
+          continue;
+        }
+      }
       const remaining = cursor.remainingHeightPx() - fragmentHeight;
       if (remainingRow.heightPx <= remaining) {
         fragmentRows.push(toRowBox(remainingRow, false));
@@ -5290,7 +6478,19 @@ function placeTable(cursor, table, measurer, note) {
       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 = layoutRow2(row, cursor.columnWidthPx, measurer, note);
+          if (fragmentRows.length) {
+            fragmentRows = [];
+            fragmentHeight = 0;
+            addHeaders();
+          }
         }
         const freshRemaining = cursor.remainingHeightPx() - fragmentHeight;
         if (remainingRow.heightPx > freshRemaining)
@@ -5311,7 +6511,7 @@ function placeTable(cursor, table, measurer, note) {
       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 ? layoutRow2(
         { ...row, heightPx: 0, heightRule: "atLeast" },
         cursor.columnWidthPx,
         measurer,
@@ -5321,12 +6521,44 @@ function placeTable(cursor, table, measurer, note) {
     }
   }
   for (const row of table.rows) {
-    const layout = layoutRow(row, cursor.columnWidthPx, measurer, note);
-    placeRow(row, layout, Boolean(row.cantSplit) || headerRows.includes(row));
+    const layout = layoutRow2(row, cursor.columnWidthPx, measurer, note);
+    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,
+      Boolean(row.cantSplit) || headerRows.includes(row) || !!footnotes && row.heightRule === "exact"
+    );
   }
   flushFragment();
 }
 
+// docx/layout/reference-footnotes.ts
+function createReferenceFootnotes(width, measurer, report) {
+  const cache = /* @__PURE__ */ new Map();
+  return (paragraph, lines, includeUnanchored) => {
+    const selected = new Set(
+      lines.flatMap(
+        (line2) => line2.fragments.map((fragment) => paragraph.runs[fragment.runIndex]?.footnoteReferenceId)
+      )
+    );
+    const anchored = new Set(paragraph.runs.map((run) => run.footnoteReferenceId));
+    return (paragraph.footnotes ?? []).filter((note) => selected.has(note.id) || includeUnanchored && !anchored.has(note.id)).map((note) => {
+      const key = `${note.id}:${width()}`;
+      const prior = cache.get(key);
+      if (prior) return prior;
+      const stacked = stackParagraphs(note.paragraphs, width(), measurer, report);
+      const box = { id: note.id, yPx: 0, heightPx: stacked.heightPx, paragraphs: stacked.boxes };
+      cache.set(key, box);
+      return box;
+    });
+  };
+}
+
 // docx/layout/wrap.ts
 var SIDE_DISTANCE_PX = 12;
 var MIN_SIDE_WIDTH_PX = 48;
@@ -5380,20 +6612,117 @@ function lineBoxesFor(exclusions, topPx, columnLeftPx, columnWidthPx) {
 // docx/layout/section-flow.ts
 var SectionFlow = class {
   constructor(section, pages, measurer, note, sectionIndex = 0, exclusions, continueAt, balance) {
+    this.section = section;
     this.exclusions = exclusions;
     this.balance = balance;
+    const noteColumns = section.footnoteColumns ?? (section.modernFootnoteSeparator ? section.columns ?? { count: 1, gapPx: 0 } : void 0);
+    if (!noteColumns && !section.legacyFootnoteColumns && (section.columns?.count ?? 1) > 1 && section.blocks.some(
+      (block) => block.kind === "paragraph" ? !!block.footnotes?.length : block.rows.some(
+        (row) => row.cells.some(
+          (cell) => cellParagraphs(cell).some((paragraph) => !!paragraph.footnotes?.length)
+        )
+      )
+    ))
+      note(
+        "Multi-column footnotes use a page-wide area; native per-column footnote balancing is not yet modeled."
+      );
+    const sources = /* @__PURE__ */ new Map();
+    for (const block of section.blocks) {
+      const paragraphs = block.kind === "paragraph" ? [block] : block.rows.flatMap((row) => row.cells.flatMap(cellParagraphs));
+      for (const paragraph of paragraphs)
+        for (const source of paragraph.footnotes ?? []) sources.set(source.id, source);
+    }
+    const reflowCache = /* @__PURE__ */ new Map();
+    const reflow = (box, width) => {
+      const source = sources.get(box.id);
+      if (!source) return box;
+      const ids = new Set(box.paragraphs.map((paragraph) => paragraph.blockId));
+      const key = JSON.stringify([box.id, width, [...ids], box.sourceTokenStarts]);
+      const cached = reflowCache.get(key);
+      if (cached) return { ...cached, continued: !!box.continued };
+      const paragraphs = source.paragraphs.filter((paragraph) => ids.has(paragraph.id)).map(
+        (paragraph) => box.sourceTokenStarts?.[paragraph.id] ? { ...paragraph, spacingBeforeTwips: NO_TWIPS } : paragraph
+      );
+      const stacked = stackParagraphs(
+        paragraphs,
+        width,
+        measurer,
+        note,
+        0,
+        new Map(Object.entries(box.sourceTokenStarts ?? {}))
+      );
+      const result = { ...box, yPx: 0, heightPx: stacked.heightPx, paragraphs: stacked.boxes };
+      reflowCache.set(key, result);
+      return result;
+    };
     this.blocks = section.blocks;
     this.measurer = measurer;
     this.note = note;
+    const separatorCache = /* @__PURE__ */ new Map();
     this.cursor = new PageCursor(
       pages,
       section.page,
       section.columns ?? { count: 1, gapPx: 0 },
       sectionIndex,
       continueAt,
-      balance
+      balance,
+      note,
+      (page, continued) => {
+        const paragraphs = section.footnoteSeparators?.[continued && !section.modernFootnoteSeparator ? "continuationSeparator" : "separator"];
+        if (!paragraphs) return void 0;
+        const width = page.widthPx - page.marginLeftPx - page.marginRightPx;
+        const key = `${width}:${continued}`;
+        const cached = separatorCache.get(key);
+        if (cached) return cached;
+        const adapted = paragraphs.map((paragraph) => {
+          const probe = section.legacyFootnoteColumns ? layoutParagraph(
+            {
+              ...paragraph,
+              runs: paragraph.runs.map(
+                (run) => run.object?.noteSeparator ? { ...run, object: { ...run.object, widthPx: 0 } } : run
+              )
+            },
+            width,
+            measurer,
+            note
+          ) : void 0;
+          return {
+            ...paragraph,
+            runs: paragraph.runs.map(
+              (run, index) => run.object?.noteSeparator ? {
+                ...run,
+                object: {
+                  ...run.object,
+                  widthPx: section.legacyFootnoteColumns ? Math.min(
+                    run.object.noteSeparator === "continuationSeparator" ? width : 192,
+                    Math.max(
+                      0,
+                      width - (probe?.lines.flatMap((line2) => line2.fragments).find(
+                        (fragment) => fragment.runIndex === index && fragment.object?.noteSeparator
+                      )?.xPx ?? 0)
+                    )
+                  ) : run.object.noteSeparator === "continuationSeparator" ? width : Math.min(192, width)
+                }
+              } : run
+            )
+          };
+        });
+        const stacked = stackParagraphs(adapted, width, measurer, note);
+        const result = { heightPx: stacked.heightPx, paragraphs: stacked.boxes };
+        separatorCache.set(key, result);
+        return result;
+      },
+      noteColumns,
+      reflow,
+      section.legacyFootnoteColumns
+    );
+    this.referenceFootnotes = createReferenceFootnotes(
+      () => this.cursor.footnoteWidthPx,
+      measurer,
+      note
     );
   }
+  section;
   exclusions;
   balance;
   cursor;
@@ -5403,6 +6732,7 @@ var SectionFlow = class {
   measurer;
   note;
   paragraphCache = /* @__PURE__ */ new Map();
+  referenceFootnotes;
   firstRowHeightCache = /* @__PURE__ */ new Map();
   paragraphLayout(index) {
     const key = `${index}:${this.cursor.columnWidthPx}`;
@@ -5477,7 +6807,17 @@ var SectionFlow = class {
     for (let index = 0; index < this.blocks.length; index++) {
       const block = expectDefined(this.blocks[index], "flow block index");
       if (block.kind === "table") {
-        placeTable(this.cursor, block, this.measurer, this.note);
+        placeTable(
+          this.cursor,
+          block,
+          this.measurer,
+          this.note,
+          block.rows.some(
+            (row) => row.cells.some(
+              (cell) => cellParagraphs(cell).some((paragraph) => paragraph.footnotes?.length)
+            )
+          ) ? this.referenceFootnotes : void 0
+        );
         if (this.balance?.pageIndex === this.cursor.page.index && !this.cursor.columnContentFits)
           this.balanceValid = false;
         continue;
@@ -5485,19 +6825,7 @@ var SectionFlow = class {
       if (block.afterTableSectionBreak) this.cursor.endBalance();
       const spacingBeforePx = this.spacingBeforeFor(index);
       const layout = this.wrappedLayout(index, spacingBeforePx) ?? this.paragraphLayout(index);
-      if (block.footnotes?.length)
-        this.cursor.holdFootnotes(
-          block.id,
-          block.footnotes.map((note) => {
-            const stacked = stackParagraphs(
-              note.paragraphs,
-              this.cursor.columnWidthPx,
-              this.measurer,
-              this.note
-            );
-            return { id: note.id, yPx: 0, heightPx: stacked.heightPx, paragraphs: stacked.boxes };
-          })
-        );
+      const footnotes = (lines, includeUnanchored) => this.referenceFootnotes(block, lines, includeUnanchored);
       const requiredTogetherPx = block.keepNext ? this.requiredKeepHeight(index) : block.keepLines ? spacingBeforePx + layout.contentHeightPx + layout.spacingAfterPx : 0;
       if (requiredTogetherPx > this.cursor.columnHeightPx && requiredTogetherPx <= this.cursor.physicalColumnHeightPx)
         this.balanceValid = false;
@@ -5506,7 +6834,9 @@ var SectionFlow = class {
         {
           paragraph: block,
           layout,
+          footnotes,
           spacingBeforePx,
+          ...this.section.modernFootnoteSeparator || this.section.legacyFootnoteColumns ? { trimLeadingColumnBreak: true } : {},
           requiredTogetherPx,
           reflow: (token) => layoutParagraph(
             block,
@@ -5522,6 +6852,7 @@ var SectionFlow = class {
       if (this.balance?.pageIndex === this.cursor.page.index && this.cursor.usedColumnHeightPx > this.cursor.columnHeightPx)
         this.balanceValid = false;
     }
+    this.cursor.finishFootnotes();
   }
 };
 
@@ -5564,8 +6895,16 @@ function insertParityBlank(pages, section) {
   const nextNumber = pages.length + 1;
   const wanted = section.break === "evenPage" ? 0 : 1;
   if (nextNumber % 2 === wanted) return;
+  const {
+    footnotes: _footnotes,
+    footnoteSeparator: _separator,
+    footnoteHeightPx: _noteHeight,
+    footnoteColumnAreas: _noteColumnAreas,
+    floats: _floats,
+    ...geometry
+  } = previous;
   pages.push({
-    ...previous,
+    ...geometry,
     index: pages.length,
     pageInSection: previous.pageInSection + 1,
     columns: previous.columns.map((column) => ({ ...column, blocks: [] }))
@@ -5579,7 +6918,12 @@ function alignVertically(pages, section, note) {
     return;
   }
   for (const page of pages) {
-    const available = page.heightPx - page.marginTopPx - page.marginBottomPx;
+    const footnoteHeight = page.footnoteColumnAreas?.length ? Math.max(
+      ...page.footnoteColumnAreas.map(
+        (area) => area.heightPx + (area.separator?.heightPx ?? FOOTNOTE_SEPARATOR_PX)
+      )
+    ) : page.footnotes?.length ? (page.footnoteSeparator?.heightPx ?? FOOTNOTE_SEPARATOR_PX) + (page.footnoteHeightPx ?? page.footnotes.reduce((sum, footnote) => sum + footnote.heightPx, 0)) : 0;
+    const available = page.heightPx - page.marginTopPx - page.marginBottomPx - footnoteHeight;
     const used = Math.max(
       0,
       ...page.columns.flatMap((column) => column.blocks.map((block) => block.yPx + block.heightPx))
@@ -5694,13 +7038,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" };
@@ -5713,7 +7057,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;
@@ -5755,7 +7099,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;
@@ -5772,6 +7116,11 @@ function adaptTable(table, model, adaptParagraph) {
         const fill = cssHex(visuals.shadingFill);
         return {
           paragraphs: cell.paragraphs.map(adaptParagraph),
+          ...cell.sourceBlocks ? {
+            blocks: cellSourceBlocks(cell).map(
+              (block) => block.type === "paragraph" ? adaptParagraph(block) : adaptTable(block, model, adaptParagraph, true)
+            )
+          } : {},
           ...width !== void 0 ? { widthPx: width } : {},
           ...grid && xPx !== void 0 ? { xPx } : {},
           padding,
@@ -5951,7 +7300,13 @@ function adaptDocumentModel(model, note = () => {
     const script = formatting.verticalAlign === "superscript" || noteText !== void 0 && formatting.verticalAlign === void 0 ? "super" : formatting.verticalAlign === "subscript" ? "sub" : void 0;
     const image = run.image;
     if (image?.unsupported === "Text box") reportOnce(TEXT_BOX_NOTE);
-    const object = image && !image.anchored ? {
+    const object = run.noteSeparator ? {
+      partName: "",
+      contentType: "",
+      widthPx: 192,
+      heightPx: 1,
+      noteSeparator: run.noteSeparator
+    } : image && !image.anchored ? {
       partName: image.partName,
       contentType: image.contentType,
       widthPx: image.widthPx,
@@ -5959,8 +7314,10 @@ function adaptDocumentModel(model, note = () => {
       ...image.chart ? { chart: docxChartPaint(image.chart, image.widthPx, image.heightPx, theme) } : {}
     } : void 0;
     return {
+      sourceLength: reviewSourceLength(run),
       // Hidden text (`w:vanish`) takes no space when printed, as in Word by default.
       text: image || formatting.vanish ? "" : formatting.caps ? text2.toUpperCase() : text2,
+      ...run.noteReference?.kind === "footnote" ? { footnoteReferenceId: run.noteReference.id } : {},
       ...object ? { object } : {},
       ...definedProps({
         bold: formatting.bold,
@@ -6059,6 +7416,10 @@ function adaptDocumentModel(model, note = () => {
     if (block.type === "paragraph") return adaptParagraph(block);
     reportOnce(TABLE_ROW_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; vertical merge and repeated header geometry are not rendered."
+      );
     return adaptTable(block, model, adaptParagraph);
   }
   const blocks = [
@@ -6068,7 +7429,25 @@ function adaptDocumentModel(model, note = () => {
   groupParagraphBorders(blocks, betweenBorders);
   const folded = foldDropCaps(model.blocks, blocks);
   if (folded.size) reportOnce(DROP_CAP_NOTE);
+  if (Object.values(model.footnoteSeparators ?? {}).some(
+    (note2) => note2.blocks.some((block) => block.type === "table")
+  ))
+    reportOnce(
+      "Tables in custom footnote separators are preserved but are not rendered in Print Layout."
+    );
+  const footnoteSeparators = model.footnoteSeparators ? Object.fromEntries(
+    Object.entries(model.footnoteSeparators).map(([kind, note2]) => [
+      kind,
+      note2.blocks.filter((block) => block.type === "paragraph").map((paragraph) => adaptParagraph(paragraph))
+    ])
+  ) : void 0;
   const sections = model.sections;
+  const modernFootnoteSeparator = model.compatibilityMode === 15;
+  const legacyFootnoteColumns = model.compatibilityMode === 12 || model.compatibilityMode === 14;
+  if (!modernFootnoteSeparator && !legacyFootnoteColumns && model.sections?.some((section) => section.footnoteColumns !== void 0))
+    reportOnce(
+      "Footnote column settings are preserved, but this compatibility mode has not been verified against native Word; Print Layout uses the existing page-wide fallback."
+    );
   if (!sections || !sections.length) {
     return {
       sections: [
@@ -6081,6 +7460,9 @@ function adaptDocumentModel(model, note = () => {
             marginBottomPx: model.page.marginBottom,
             marginLeftPx: model.page.marginLeft
           },
+          ...footnoteSeparators ? { footnoteSeparators } : {},
+          ...modernFootnoteSeparator ? { modernFootnoteSeparator: true } : {},
+          ...legacyFootnoteColumns ? { legacyFootnoteColumns: true } : {},
           blocks: blocks.filter((block) => !folded.has(block))
         }
       ]
@@ -6094,8 +7476,34 @@ function adaptDocumentModel(model, note = () => {
     const end = Math.max(start, endIndex);
     const slice = blocks.slice(start, end);
     start = end;
+    if (legacyFootnoteColumns && section.footnoteColumns)
+      reportOnce(
+        "Independent footnote column counts are preserved but ignored in measured compatibility modes 12 and 14; Print Layout attaches notes to body columns."
+      );
+    const footnoteWidth = twipsToPx3(section.pageWidthTwips) - twipsToPx3(section.marginLeftTwips) - twipsToPx3(section.marginRightTwips);
+    if (modernFootnoteSeparator && section.footnoteColumns && (section.footnoteColumns > 45 || footnoteWidth <= 48 * (section.footnoteColumns - 1)))
+      reportOnce(
+        "Footnote columns exceeding the available page width or 45 rendered columns use one column in Print Layout; the saved count is preserved."
+      );
     const sectionStart = index === 0 ? void 0 : sectionBreak(section.type, reportOnce);
     return {
+      ...footnoteSeparators ? { footnoteSeparators } : {},
+      ...modernFootnoteSeparator ? { modernFootnoteSeparator: true } : {},
+      ...legacyFootnoteColumns ? { legacyFootnoteColumns: true } : {},
+      ...section.footnoteColumns !== void 0 && modernFootnoteSeparator ? {
+        footnoteColumns: {
+          count: section.footnoteColumns && (section.footnoteColumns > 45 || footnoteWidth <= 48 * (section.footnoteColumns - 1)) ? 1 : Math.max(1, section.footnoteColumns || section.columns.count),
+          gapPx: section.footnoteColumns ? 48 : twipsToPx3(section.columns.spacingTwips ?? twips(720)),
+          ...!section.footnoteColumns && !section.columns.equalWidth && section.columns.widths?.length ? {
+            widths: section.columns.widths.map((column) => ({
+              widthPx: twipsToPx3(column.widthTwips),
+              gapPx: twipsToPx3(
+                column.spacingTwips ?? section.columns.spacingTwips ?? twips(720)
+              )
+            }))
+          } : {}
+        }
+      } : {},
       page: {
         widthPx: twipsToPx3(section.pageWidthTwips),
         heightPx: twipsToPx3(section.pageHeightTwips),
@@ -6277,4 +7685,4 @@ function cssFontStack(family) {
   );
 }
 
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE_PT, DEFAULT_TAB_STOP_PX, FLOAT_WRAP_NOTE, NO_TWIPS, PageCursor, SINGLE_LINE_SPACING_UNITS, adaptDocumentModel, adjustForWidowOrphan, appendBreakMarker, createFakeMeasurer, cssFontStack, fieldDisplayText, floatPosition, fontMetrics, headerFooterForPage, isEastAsianChar, layoutDocument, layoutDocumentModel, layoutParagraph, layoutRow, layoutSections, ligatureCss, pageNumberValues, pageNumbers, paragraphFloats, placeParagraph, placeTab, placeTable, positionFloats, ptToPx, pxToTwips, sectionPageCounts, splitRowAtHeight, suppressesSpacing, tokenizeRun, twipsToPx, widowControlEnabled };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE_PT, DEFAULT_TAB_STOP_PX, FLOAT_WRAP_NOTE, NO_TWIPS, PageCursor, SINGLE_LINE_SPACING_UNITS, adaptDocumentModel, adjustForWidowOrphan, appendBreakMarker, cellVerticalOffset, createFakeMeasurer, cssFontStack, fieldDisplayText, floatPosition, fontMetrics, headerFooterForPage, isEastAsianChar, layoutDocument, layoutDocumentModel, layoutParagraph, layoutRow, layoutSections, ligatureCss, pageNumberValues, pageNumbers, paragraphFloats, placeParagraph, placeTab, placeTable, positionFloats, ptToPx, pxToTwips, sectionPageCounts, splitRowAtHeight, suppressesSpacing, tokenizeRun, twipsToPx, widowControlEnabled };