ooxml-core 1.8.4 → 1.9.0

package/dist/docx/layout/index.cjs

@@ -39,8 +39,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
@@ -2651,11 +2651,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>`
@@ -2670,7 +2670,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})`;
   };
@@ -3710,6 +3710,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,
@@ -3730,6 +3738,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"],
@@ -3794,7 +3828,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) {
@@ -4505,6 +4539,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 = [];
@@ -4512,7 +4549,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 });
@@ -4528,7 +4565,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 };
 }
@@ -4550,7 +4587,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);
   }
@@ -4625,7 +4664,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();
@@ -4676,9 +4726,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
         );
@@ -4697,14 +4747,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;
     });
@@ -4838,6 +4891,57 @@ function widowControlEnabled(value) {
   return value !== false;
 }
 
+// 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 = [];
+  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 x = block.alignment === "center" ? Math.max(0, (width - tableWidth) / 2) : block.alignment === "right" ? Math.max(0, width - tableWidth) : block.indentPx ?? 0;
+    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);
+      layout.cells.forEach((paragraphs, index) => {
+        const geometry = layout.geometry[index];
+        for (const paragraph of paragraphs)
+          boxes.push({
+            ...paragraph,
+            yPx: y + paragraph.yPx,
+            xPx: x + geometry.xPx + geometry.paddingLeftPx + (paragraph.xPx ?? 0),
+            widthPx: paragraph.widthPx ?? Math.max(1, geometry.widthPx - geometry.paddingLeftPx - geometry.paddingRightPx),
+            readOnly: true
+          });
+      });
+      y += layout.heightPx;
+    }
+  }
+  boxes.sort((a, b) => a.yPx - b.yPx);
+  return { heightPx: y, boxes };
+}
+
 // docx/layout/table-layout.ts
 function stackParagraphs(paragraphs, widthPx, measurer, note, topPx = 0, startTokens) {
   let y = topPx;
@@ -4853,29 +4957,30 @@ 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) {
   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,
+    const content2 = stackCellBlocks(
+      cell,
       Math.max(1, widthPx - padding.left - padding.right),
       measurer,
       note,
@@ -4898,26 +5003,24 @@ function layoutRow(row, tableWidthPx, measurer, note, remaining) {
   });
   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 };
+  return {
+    heightPx,
+    cells: laidOut.map((cell) => cell.boxes),
+    geometry,
+    cellPadding: row.cells.map((cell) => ({
+      top: cell.padding?.top ?? 0,
+      bottom: cell.padding?.bottom ?? 0
+    }))
+  };
 }
 function splitCellAtHeight(boxes, cutHeightPx) {
   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) {
       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);
       continue;
     }
     const beforeLines = box.lines.filter(
@@ -4927,50 +5030,407 @@ function splitCellAtHeight(boxes, cutHeightPx) {
     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);
     }
     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;
     }
   }
+  const afterOrigin = Math.min(...after.map((box) => box.yPx));
+  for (const box of after) box.yPx -= afterOrigin;
   return { before, after, beforeHeightPx };
 }
-function splitRowAtHeight(row, cutHeightPx) {
-  const splits = row.cells.map((cell) => splitCellAtHeight(cell, cutHeightPx));
+function splitRowAtHeight(row, cutHeightPx, cellCuts) {
+  const splits = row.cells.map((cell, index) => {
+    const padding = row.cellPadding?.[index] ?? { top: 0, bottom: 0 };
+    const split = splitCellAtHeight(cell, (cellCuts?.[index] ?? cutHeightPx) - padding.bottom);
+    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 before = {
     heightPx: Math.max(0, ...splits.map((split) => split.beforeHeightPx)),
     cells: splits.map((split) => split.before),
-    geometry: row.geometry
+    geometry: row.geometry.map((geometry, index) => ({
+      ...geometry,
+      contentHeightPx: splits[index].beforeHeightPx
+    })),
+    ...row.cellPadding ? { cellPadding: row.cellPadding } : {}
   };
   if (!anyAfter) return { before, after: null };
   const after = {
     heightPx: Math.max(
       0,
       ...splits.map(
-        (split) => split.after.reduce((max, box) => Math.max(max, box.yPx + box.heightPx), 0)
+        (split, index) => split.after.length ? split.after.at(-1).yPx + split.after.at(-1).heightPx + (row.cellPadding?.[index]?.bottom ?? 0) : 0
       )
     ),
     cells: splits.map((split) => split.after),
-    geometry: row.geometry
+    geometry: row.geometry.map((geometry, index) => ({
+      ...geometry,
+      contentHeightPx: splits[index].after.length ? splits[index].after.at(-1).yPx + splits[index].after.at(-1).heightPx + (row.cellPadding?.[index]?.bottom ?? 0) : 0
+    })),
+    ...row.cellPadding ? { cellPadding: row.cellPadding } : {}
   };
   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 equal = (width - columns.gapPx * (columns.count - 1)) / columns.count;
+  let x = 0;
+  return Array.from({ length: columns.count }, (_, index) => {
+    const own = columns.widths?.[index];
+    const column = { xPx: x, widthPx: Math.max(1, own?.widthPx ?? equal) };
+    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;
@@ -4994,6 +5454,8 @@ var PageCursor = class {
     }
   }
   balance;
+  noteColumns;
+  legacyFootnoteColumns;
   pages;
   equalColumnWidthPx;
   activeColumns = [];
@@ -5004,10 +5466,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;
@@ -5042,7 +5501,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);
@@ -5050,6 +5509,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;
   }
@@ -5064,6 +5526,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;
   }
@@ -5087,7 +5552,7 @@ var PageCursor = class {
     );
   }
   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() {
@@ -5106,16 +5571,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();
@@ -5125,6 +5615,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();
     }
@@ -5138,25 +5630,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();
   }
@@ -5164,9 +5685,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;
   };
@@ -5180,15 +5715,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)) {
@@ -5213,9 +5760,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;
@@ -5230,6 +5785,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;
@@ -5239,8 +5795,170 @@ function placeParagraph(cursor, placement, note) {
   }
 }
 
+// docx/layout/table-footnotes.ts
+function prefix(row, cut, cellCuts) {
+  const cells = row.cells.map((cell, index) => {
+    const contentCut = (cellCuts?.[index] ?? cut) - (row.cellPadding?.[index]?.bottom ?? 0);
+    const boxes = [];
+    for (const box of cell) {
+      if (box.yPx >= contentCut + 1e-6) break;
+      if (box.yPx + box.heightPx <= contentCut + 1e-6) {
+        boxes.push(box);
+        continue;
+      }
+      const lines = [];
+      for (const line2 of box.lines) {
+        if (box.yPx + line2.yPx + line2.heightPx > 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.flatMap(
+        (cell, index) => cell.map((box) => box.yPx + box.heightPx + (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)
+      for (const cell of row.cells)
+        for (const paragraph of cellParagraphs(cell))
+          if (paragraph.footnotes?.length) this.paragraphs.set(paragraph.id, paragraph);
+  }
+  cursor;
+  table;
+  height;
+  resolve;
+  paragraphs = /* @__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)
+          );
+          const prior = refs.get(note.id);
+          if (!prior || bottom < prior.bottom) refs.set(note.id, { note, bottom });
+        }
+      }
+    return [...refs.values()];
+  }
+  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) {
+    const refs = new Map(this.fragment);
+    for (const ref of this.references(row))
+      if (!refs.has(ref.note.id))
+        refs.set(ref.note.id, { ...ref, bottom: this.height() + ref.bottom });
+    const referenceBottom = Math.max(0, ...[...refs.values()].map((ref) => ref.bottom));
+    const contentBottom = this.height() + Math.max(0, ...row.cells.flatMap((cell) => cell.map((box) => box.yPx + box.heightPx)));
+    const paddingBottom = Math.max(0, ...(row.cellPadding ?? []).map((padding) => padding.bottom));
+    this.hold(
+      refs,
+      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 cuts = /* @__PURE__ */ new Set();
+      for (const [index, cell] of row.cells.entries())
+        for (const box of cell) {
+          if (box.yPx > available + 1e-6) break;
+          for (const line2 of box.lines) {
+            const bottom = box.yPx + line2.yPx + line2.heightPx + (row.cellPadding?.[index]?.bottom ?? 0);
+            if (bottom > available + 1e-6) break;
+            if (bottom > 0) cuts.add(bottom);
+          }
+        }
+      for (const cut of [...cuts].sort((a, b) => b - a)) {
+        const candidate = prefix(row, cut);
+        this.holdCandidate(candidate);
+        if (candidate.heightPx <= this.cursor.remainingHeightPx() - this.height() + 1e-6) {
+          const space = this.cursor.remainingHeightPx() - this.height();
+          const cellCuts = row.cells.map(
+            (cell) => cell.some((box) => this.paragraphs.has(box.blockId)) ? cut : space
+          );
+          const expanded = prefix(row, cut, cellCuts);
+          this.holdCandidate(expanded);
+          if (expanded.heightPx <= this.cursor.remainingHeightPx() - this.height() + 1e-6)
+            return { layout: expanded, cut, cellCuts };
+          this.holdCandidate(candidate);
+          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 = () => {
@@ -5249,7 +5967,9 @@ function placeTable(cursor, table, measurer, note) {
   };
   let fragmentRows = [];
   let fragmentHeight = 0;
+  const footnotes = resolveFootnotes ? new TableFootnotes(cursor, table, () => fragmentHeight, resolveFootnotes) : void 0;
   const toRowBox = (layout, repeated) => {
+    footnotes?.add(layout, repeated);
     const box = {
       yPx: fragmentHeight,
       heightPx: layout.heightPx,
@@ -5261,7 +5981,10 @@ function placeTable(cursor, table, measurer, note) {
     return box;
   };
   function flushFragment() {
-    if (!fragmentRows.length) return;
+    if (!fragmentRows.length) {
+      footnotes?.holdFragment();
+      return;
+    }
     const box = {
       kind: "table",
       blockId: table.id,
@@ -5270,19 +5993,89 @@ function placeTable(cursor, table, measurer, note) {
       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));
   }
   function placeRow(row, initial, cantSplit) {
     let remainingRow = initial;
     while (remainingRow) {
+      const minimum = cantSplit ? Math.min(remainingRow.heightPx, cursor.columnHeightPx) : Math.min(
+        ...remainingRow.cells.flatMap(
+          (cell) => cell.map(
+            (paragraph) => paragraph.yPx + (paragraph.lines[0]?.yPx ?? 0) + (paragraph.lines[0]?.heightPx ?? 0)
+          )
+        )
+      );
+      if (fragmentRows.every((item) => item.repeated)) {
+        const width = cursor.columnWidthPx;
+        cursor.advancePastFootnotes(fragmentHeight + (Number.isFinite(minimum) ? minimum : 0));
+        if (width !== cursor.columnWidthPx) {
+          remainingRow = layoutRow(
+            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)
+          );
+          fragmentRows.push(toRowBox(before2, false));
+          const previousWidth2 = cursor.columnWidthPx;
+          startNewFragment();
+          remainingRow = after2 && previousWidth2 !== cursor.columnWidthPx ? layoutRow(
+            { ...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 = layoutRow(
+              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));
@@ -5294,6 +6087,18 @@ function placeTable(cursor, table, measurer, note) {
           startNewFragment();
           remainingRow = layoutRow(row, cursor.columnWidthPx, measurer, note);
         }
+        const noteWidth = cursor.columnWidthPx;
+        cursor.advancePastFootnotes(
+          fragmentHeight + Math.min(remainingRow.heightPx, cursor.columnHeightPx)
+        );
+        if (noteWidth !== cursor.columnWidthPx) {
+          remainingRow = layoutRow(row, cursor.columnWidthPx, measurer, note);
+          if (fragmentRows.length) {
+            fragmentRows = [];
+            fragmentHeight = 0;
+            addHeaders();
+          }
+        }
         const freshRemaining = cursor.remainingHeightPx() - fragmentHeight;
         if (remainingRow.heightPx > freshRemaining)
           note('A table row marked "keep row together" is taller than an empty page/column.');
@@ -5324,11 +6129,37 @@ 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));
+    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;
@@ -5382,20 +6213,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;
@@ -5405,6 +6333,7 @@ var SectionFlow = class {
   measurer;
   note;
   paragraphCache = /* @__PURE__ */ new Map();
+  referenceFootnotes;
   firstRowHeightCache = /* @__PURE__ */ new Map();
   paragraphLayout(index) {
     const key = `${index}:${this.cursor.columnWidthPx}`;
@@ -5479,7 +6408,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;
@@ -5487,19 +6426,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;
@@ -5508,7 +6435,9 @@ var SectionFlow = class {
         {
           paragraph: block,
           layout,
+          footnotes,
           spacingBeforePx,
+          ...this.section.modernFootnoteSeparator || this.section.legacyFootnoteColumns ? { trimLeadingColumnBreak: true } : {},
           requiredTogetherPx,
           reflow: (token) => layoutParagraph(
             block,
@@ -5524,6 +6453,7 @@ var SectionFlow = class {
       if (this.balance?.pageIndex === this.cursor.page.index && this.cursor.usedColumnHeightPx > this.cursor.columnHeightPx)
         this.balanceValid = false;
     }
+    this.cursor.finishFootnotes();
   }
 };
 
@@ -5566,8 +6496,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: [] }))
@@ -5581,7 +6519,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))
@@ -5774,6 +6717,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)
+            )
+          } : {},
           ...width !== void 0 ? { widthPx: width } : {},
           ...grid && xPx !== void 0 ? { xPx } : {},
           padding,
@@ -5953,7 +6901,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,
@@ -5961,8 +6915,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,
@@ -6061,6 +7017,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; their borders, shading, vertical merge and repeated header geometry are not rendered."
+      );
     return adaptTable(block, model, adaptParagraph);
   }
   const blocks = [
@@ -6070,7 +7030,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: [
@@ -6083,6 +7061,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))
         }
       ]
@@ -6096,8 +7077,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),