@stll/folio-core 0.49.0 → 0.50.0

package/dist/layout-engine/sectionLayout.js

@@ -0,0 +1,216 @@
+import { measuredLineAdvance } from "./lineFlow.js";
+import { SECTION_START_PLACEMENT } from "./paginator.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore } from "./paragraphSpacing.js";
+import { physicalColumnRegionIsShared } from "./section-breaks.js";
+import { panic } from "better-result";
+//#region src/layout-engine/sectionLayout.ts
+/**
+* Section handling during pagination: per-section layout configuration,
+* section-break scheduling (in place, next page, odd/even filler pages), and
+* balanced column height for continuous sections.
+*/
+const DEFAULT_COLUMNS = {
+	count: 1,
+	gap: 0
+};
+const CONTINUE_PAGE_NUMBERING = { type: "continue" };
+function collectSectionConfigs(blocks, initialConfig, finalConfig) {
+	const configs = [];
+	const breakIndices = [];
+	let previousConfig = initialConfig;
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		if (block?.kind !== "sectionBreak") continue;
+		const sectionBreak = block;
+		const config = {
+			pageSize: sectionBreak.pageSize ?? previousConfig.pageSize,
+			margins: sectionBreak.margins ?? previousConfig.margins,
+			pageNumbering: sectionBreak.pageNumbering ?? CONTINUE_PAGE_NUMBERING
+		};
+		if (sectionBreak.columns !== void 0) config.columns = sectionBreak.columns;
+		configs.push(config);
+		breakIndices.push(index);
+		previousConfig = configs.at(-1) ?? previousConfig;
+	}
+	configs.push(finalConfig);
+	return {
+		configs,
+		breakIndices
+	};
+}
+function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }) {
+	if (columnCount <= 1 || startIndex >= endIndex || availableHeight <= 0) return;
+	const lineUnits = [];
+	let totalHeight = 0;
+	let tallestUnit = 0;
+	let trailingSpacing = incomingSpacing;
+	for (let index = startIndex; index < endIndex; index++) {
+		const block = blocks[index];
+		const measure = measures[index];
+		if (block?.kind !== "paragraph" || measure?.kind !== "paragraph") return;
+		if (block.attrs?.keepNext === true || block.attrs?.keepLines === true || block.runs.some((run) => run.kind === "text" && run.footnoteRefId !== void 0)) return;
+		const leadingSpacing = collapseParagraphSpacing({
+			before: getParagraphSpacingBefore(block),
+			after: trailingSpacing
+		});
+		if (measure.lines.length === 0) {
+			if (leadingSpacing > 0) {
+				lineUnits.push(leadingSpacing);
+				totalHeight += leadingSpacing;
+				tallestUnit = Math.max(tallestUnit, leadingSpacing);
+			}
+		}
+		for (let lineIndex = 0; lineIndex < measure.lines.length; lineIndex++) {
+			const line = measure.lines[lineIndex];
+			if (!line) continue;
+			const unitHeight = measuredLineAdvance(line) + (lineIndex === 0 ? leadingSpacing : 0);
+			lineUnits.push(unitHeight);
+			totalHeight += unitHeight;
+			tallestUnit = Math.max(tallestUnit, unitHeight);
+		}
+		if (tallestUnit > availableHeight || totalHeight > availableHeight * columnCount) return;
+		trailingSpacing = getParagraphSpacingAfter(block);
+	}
+	if (totalHeight <= 0) return;
+	const columnsNeeded = (targetHeight) => {
+		let usedHeight = 0;
+		let usedColumns = 1;
+		for (const unitHeight of lineUnits) if (usedHeight > 0 && usedHeight + unitHeight > targetHeight) {
+			usedColumns += 1;
+			usedHeight = unitHeight;
+		} else usedHeight += unitHeight;
+		return usedColumns;
+	};
+	let lower = Math.max(tallestUnit, totalHeight / columnCount);
+	let upper = Math.min(totalHeight, availableHeight);
+	if (columnsNeeded(upper) > columnCount) return;
+	for (let iteration = 0; iteration < 32; iteration++) {
+		const middle = (lower + upper) / 2;
+		if (columnsNeeded(middle) <= columnCount) upper = middle;
+		else lower = middle;
+	}
+	return Math.ceil(upper * 1e3) / 1e3;
+}
+/**
+* Start the next section in the current page region, below the outgoing
+* content.
+*
+* ECMA-376 §17.6.22: a `continuous` break normally keeps the current page
+* geometry and defers the new size/margins to the next natural page break. But
+* a break that changes page size or orientation cannot share a physical sheet
+* with the preceding section, so Word and LibreOffice promote it to a page
+* break (eigenpal/docx-editor#841).
+*
+* Compare against the last laid-out page without materializing one: a break
+* before any content has no sheet to share, so it defers (the first content
+* then opens a page with the new geometry) rather than stranding a blank
+* leading page.
+*/
+function startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex) {
+	const currentPage = paginator.states.at(-1)?.page;
+	const nextSize = nextSectionConfig.pageSize;
+	const pageSizeChanges = currentPage != null && (Math.round(nextSize.w) !== Math.round(currentPage.size.w) || Math.round(nextSize.h) !== Math.round(currentPage.size.h));
+	if (nextSectionIndex !== void 0) paginator.startSection({
+		sectionIndex: nextSectionIndex,
+		pageNumbering: nextSectionConfig.pageNumbering,
+		placement: pageSizeChanges ? SECTION_START_PLACEMENT.NEXT_PAGE : SECTION_START_PLACEMENT.CONTINUOUS
+	});
+	if (pageSizeChanges) {
+		paginator.updatePageLayout(nextSize, nextSectionConfig.margins);
+		if (!paginator.retargetCurrentBlankPage()) paginator.forcePageBreak({ coalesceBlankPage: true });
+		return;
+	}
+	paginator.updatePageLayout(nextSize, nextSectionConfig.margins, false);
+	paginator.retargetCurrentBlankPage();
+}
+/**
+* Whether a section opening on `target` would give two consecutive sheets page
+* numbers that are both odd or both even under `w:evenAndOddHeaders` (§17.10.1). Odd and
+* even page numbers alternate between right- and left-hand sheets, so a
+* `w:pgNumType w:start` restart that repeats whether the previous sheet's number is odd or even
+* needs a blank sheet between them.
+*/
+function sectionStartRepeatsOddEven(paginator, target) {
+	if (target.page.headerFooterRefs?.evenAndOddHeaders !== true) return false;
+	const previous = paginator.states.at(-2)?.page;
+	if (previous === void 0 || previous.number !== target.page.number - 1) return false;
+	return previous.logicalNumber % 2 === target.page.logicalNumber % 2;
+}
+/**
+* Keep the blank sheet the section break opened as a filler with no page
+* furniture, and open the section again on the following sheet so its first
+* page keeps the restarted page number.
+*/
+function insertOddEvenFillerPage(paginator, filler, sectionIndex, sectionConfig) {
+	filler.page.headerFooterRefs = {};
+	paginator.startSection({
+		sectionIndex,
+		pageNumbering: sectionConfig.pageNumbering
+	});
+	paginator.forcePageBreak();
+}
+/**
+* Handle a section break block.
+* @param block - The section break block (current section's properties)
+* @param paginator - The paginator instance
+* @param nextSectionConfig - Page layout for the NEXT section
+* @param nextSectionType - Break type of the NEXT section (how it starts relative to current)
+*/
+function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionType, nextSectionIndex) {
+	switch (nextSectionType) {
+		case "nextPage": {
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
+			const target = paginator.forcePageBreak({ coalesceBlankPage: true });
+			if (nextSectionIndex !== void 0 && sectionStartRepeatsOddEven(paginator, target)) insertOddEvenFillerPage(paginator, target, nextSectionIndex, nextSectionConfig);
+			break;
+		}
+		case "evenPage":
+			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 !== 0) paginator.forcePageBreak();
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
+			if (!paginator.retargetCurrentBlankPage()) panic("Even-page section target must be blank");
+			break;
+		case "oddPage":
+			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 === 0) paginator.forcePageBreak();
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering
+			});
+			if (!paginator.retargetCurrentBlankPage()) panic("Odd-page section target must be blank");
+			break;
+		case "nextColumn": {
+			const currentPage = paginator.states.at(-1)?.page;
+			if (currentPage === void 0 || !physicalColumnRegionIsShared({
+				pageSize: currentPage.size,
+				margins: currentPage.margins,
+				columns: paginator.columns
+			}, nextSectionConfig)) {
+				startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex);
+				break;
+			}
+			if (nextSectionIndex !== void 0) paginator.startSection({
+				sectionIndex: nextSectionIndex,
+				pageNumbering: nextSectionConfig.pageNumbering,
+				placement: SECTION_START_PLACEMENT.CONTINUOUS
+			});
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins, false);
+			paginator.forceColumnBreak();
+			return;
+		}
+		case "continuous":
+			startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex);
+			break;
+		default:
+	}
+	paginator.updateColumns(nextSectionConfig.columns ?? DEFAULT_COLUMNS);
+}
+//#endregion
+export { CONTINUE_PAGE_NUMBERING, DEFAULT_COLUMNS, balancedParagraphSectionHeight, collectSectionConfigs, handleSectionBreak };

package/dist/layout-engine/tableLayout.d.ts

@@ -0,0 +1,17 @@
+import { TableBlock, TableMeasure } from "./types.js";
+import { createPaginator } from "./paginator.js";
+//#region src/layout-engine/tableLayout.d.ts
+/**
+ * Calculate total height of header rows from their measures.
+ */
+declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
+/**
+ * Layout a table block onto pages.
+ */
+declare function layoutTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, footnoteHeightById?: Map<number, number>): void;
+/**
+ * Layout a floating table (anchored) without advancing the cursor.
+ */
+declare function layoutFloatingTable(block: TableBlock, measure: TableMeasure, paginator: ReturnType<typeof createPaginator>, contentWidth: number): void;
+//#endregion
+export { getHeaderRowsHeight, layoutFloatingTable, layoutTable };

package/dist/layout-engine/tableLayout.js

@@ -0,0 +1,369 @@
+import { projectedFootnoteReserveGrowth } from "./layoutFlowShared.js";
+import { resolveFloatingTablePageX } from "./measure/floatingTablePosition.js";
+import { resolveTableInlineOffset } from "./measure/tableInlinePlacement.js";
+import { isEmptyParagraph } from "./paragraphSpacing.js";
+import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak } from "./tableRowBreak.js";
+import "./types.js";
+//#region src/layout-engine/tableLayout.ts
+/**
+* Places measured tables onto pages: row splitting across pages, repeated
+* header rows, rendered-break and tracked-change row handling, row footnote
+* collection, and floating table placement.
+*/
+/**
+* Count consecutive header rows at the start of a table.
+* Header rows are marked with isHeader: true in the block data.
+*/
+function countHeaderRows(block) {
+	let count = 0;
+	for (const row of block.rows) if (row.isHeader) count++;
+	else break;
+	return count;
+}
+/**
+* Calculate total height of header rows from their measures.
+*/
+function getHeaderRowsHeight(measure, headerRowCount) {
+	let height = 0;
+	for (let i = 0; i < headerRowCount && i < measure.rows.length; i++) height += measure.rows[i].height;
+	return height;
+}
+const tableRowStartsWithRenderedPageBreak = (block, rowIndex) => {
+	const row = block.rows[rowIndex];
+	const visibleCells = row?.cells.filter((cell) => cell.blocks.some((cellBlock) => cellBlock.kind !== "paragraph" || !isEmptyParagraph(cellBlock)));
+	if (!visibleCells || visibleCells.length === 0) return false;
+	const startsWithRenderedPageBreak = (cell) => {
+		const firstVisibleBlock = cell.blocks.find((cellBlock) => cellBlock.kind !== "paragraph" || !isEmptyParagraph(cellBlock));
+		return firstVisibleBlock?.kind === "paragraph" && firstVisibleBlock.attrs?.renderedPageBreakBefore === true;
+	};
+	if (row?.heightRule === "exact") return startsWithRenderedPageBreak(visibleCells[0]);
+	return visibleCells.every(startsWithRenderedPageBreak);
+};
+const getVerticallyMergedRows = (block) => {
+	const mergedRows = /* @__PURE__ */ new Set();
+	for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+		const row = block.rows[rowIndex];
+		if (!row) continue;
+		for (const cell of row.cells) {
+			const rowSpan = cell.rowSpan ?? 1;
+			if (rowSpan <= 1) continue;
+			for (let mergedRowIndex = rowIndex; mergedRowIndex < Math.min(block.rows.length, rowIndex + rowSpan); mergedRowIndex += 1) mergedRows.add(mergedRowIndex);
+		}
+	}
+	return mergedRows;
+};
+const flowBlockHasTrackedChanges = (block) => {
+	if (block.kind === "paragraph") return block.runs.some((run) => {
+		if (run.kind === "lineBreak") return false;
+		return run.isInsertion || run.isDeletion;
+	});
+	if (block.kind === "table") return block.rows.some((row) => row.cells.some((cell) => cell.blocks.some(flowBlockHasTrackedChanges)));
+	if (block.kind === "textBox") return block.content.some(flowBlockHasTrackedChanges);
+	return false;
+};
+const tableRowHasTrackedChanges = (block, rowIndex) => block.rows[rowIndex]?.cells.some((cell) => cell.blocks.some(flowBlockHasTrackedChanges)) ?? false;
+/**
+* Layout a table block onto pages.
+*/
+function layoutTable(block, measure, paginator, footnoteHeightById) {
+	const rows = measure.rows;
+	if (rows.length === 0) return;
+	const rowFootnoteIds = block.rows.map((row) => collectTableRowFootnoteIds(row, footnoteHeightById));
+	const headerRowCount = countHeaderRows(block);
+	const headerRowsHeight = getHeaderRowsHeight(measure, headerRowCount);
+	let currentRowIndex = 0;
+	const breakInfo = buildTableRowBreakInfo(block, measure);
+	const verticallyMergedRows = getVerticallyMergedRows(block);
+	const computeTableX = ({ columnIndex, rowIndex }) => {
+		return paginator.getColumnX(columnIndex) + resolveTableInlineOffset({
+			table: block,
+			rowJustification: block.rows[rowIndex]?.justification,
+			frameWidth: paginator.columnWidth,
+			tableWidth: measure.totalWidth
+		});
+	};
+	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
+	const hasAdjacentPriorTableRows = (rowIndex, state = paginator.getCurrentState()) => {
+		const previous = state.page.fragments.at(-1);
+		return previous?.kind === "table" && previous.blockId === block.id && previous.toRow === rowIndex && previous.y + previous.height === state.cursorY;
+	};
+	const shouldRepeatHeaderRows = (rowIndex, consumed, state = paginator.getCurrentState()) => headerRowCount > 0 && rowIndex >= headerRowCount && !(consumed === 0 && hasAdjacentPriorTableRows(rowIndex, state));
+	const rowOpensFlowRegion = (rowIndex, state) => {
+		if (state.cursorY === state.topMargin) return true;
+		const previous = state.page.fragments.at(-1);
+		return rowIndex > 0 && rowIndex <= headerRowCount && previous?.kind === "table" && previous.blockId === block.id && previous.fromRow === 0 && previous.toRow === rowIndex && previous.y === state.topMargin && previous.y + previous.height === state.cursorY;
+	};
+	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
+		const row = rows[rowIndex];
+		const sourceRow = block.rows[rowIndex];
+		if (!row || !sourceRow || sourceRow.isHeader || verticallyMergedRows.has(rowIndex)) return false;
+		if ((breakInfo.breakOffsets[rowIndex]?.length ?? 0) <= 1) return false;
+		const freshHeaderOverhead = headerRowCount > 0 && rowIndex >= headerRowCount ? headerRowsHeight : 0;
+		const oversized = row.height + freshHeaderOverhead > getCurrentRowCapacity(state);
+		if (sourceRow.cantSplit) return oversized && sourceRow.heightRule !== "exact" && rowOpensFlowRegion(rowIndex, state);
+		if (!oversized && (state.footnoteHeight > 0 || (rowFootnoteIds[rowIndex]?.length ?? 0) > 0)) return false;
+		const currentHeaderOverhead = shouldRepeatHeaderRows(rowIndex, 0, state) ? headerRowsHeight : 0;
+		const currentAvailableHeight = paginator.getAvailableHeight() - currentHeaderOverhead - state.trailingSpacing;
+		return oversized || row.height > currentAvailableHeight;
+	};
+	while (currentRowIndex < rows.length) {
+		const rowState = paginator.getCurrentState();
+		const rowHeaderOverhead = shouldRepeatHeaderRows(currentRowIndex, 0, rowState) ? headerRowsHeight : 0;
+		const rowAvailableHeight = paginator.getAvailableHeight() - rowHeaderOverhead - rowState.trailingSpacing;
+		const rowStartsFreshPage = rowState.cursorY === rowState.topMargin && rowState.page.fragments.length === 0;
+		if (block.rows[currentRowIndex]?.breakBefore === "page" && !rowStartsFreshPage) {
+			paginator.forcePageBreak();
+			continue;
+		}
+		if (!rowStartsFreshPage && tableRowStartsWithRenderedPageBreak(block, currentRowIndex) && !tableRowHasTrackedChanges(block, currentRowIndex) && rows[currentRowIndex].height > rowAvailableHeight) {
+			paginator.forcePageBreak();
+			continue;
+		}
+		const splittableRow = rows[currentRowIndex];
+		if (canSplitRow(currentRowIndex)) {
+			let consumed = 0;
+			const renderedBreakHints = tableRowHasTrackedChanges(block, currentRowIndex) ? [] : breakInfo.renderedBreakHints[currentRowIndex] ?? [];
+			let renderedBreakHintIndex = 0;
+			const discardPassedRenderedBreakHints = () => {
+				while ((renderedBreakHints[renderedBreakHintIndex]?.offset ?? Infinity) <= consumed) renderedBreakHintIndex += 1;
+			};
+			const advanceAfterNaturalFlowBreak = (previousPageNumber) => {
+				discardPassedRenderedBreakHints();
+				if (paginator.getCurrentState().page.number > previousPageNumber && renderedBreakHintIndex < renderedBreakHints.length) renderedBreakHintIndex += 1;
+			};
+			while (consumed < splittableRow.height) {
+				const sliceState = paginator.getCurrentState();
+				const repeatHeaderRows = shouldRepeatHeaderRows(currentRowIndex, consumed, sliceState);
+				const headerOverhead = repeatHeaderRows ? headerRowsHeight : 0;
+				const sliceAvail = paginator.getAvailableHeight() - headerOverhead - (consumed === 0 ? sliceState.trailingSpacing : 0);
+				let slice = snapRowBreak(breakInfo, currentRowIndex, consumed, sliceAvail);
+				let forceRenderedPageBreak = false;
+				if (slice <= 0) {
+					if (!(sliceState.cursorY === sliceState.topMargin && sliceState.page.fragments.length === 0)) {
+						const previousPageNumber = sliceState.page.number;
+						paginator.forceColumnBreak();
+						advanceAfterNaturalFlowBreak(previousPageNumber);
+						continue;
+					}
+					const from = consumed;
+					slice = (breakInfo.breakOffsets[currentRowIndex]?.find((o) => o > from) ?? splittableRow.height) - consumed;
+				}
+				discardPassedRenderedBreakHints();
+				const renderedBreakHint = renderedBreakHints[renderedBreakHintIndex];
+				if (renderedBreakHint && renderedBreakHint.offset <= consumed + slice && sliceAvail - (renderedBreakHint.offset - consumed) <= renderedBreakHint.lineAdvance * 3) {
+					slice = renderedBreakHint.offset - consumed;
+					renderedBreakHintIndex += 1;
+					forceRenderedPageBreak = true;
+				}
+				const sliceBottom = consumed + slice;
+				const continuationSkip = sliceBottom < splittableRow.height ? getRowContinuationSkip(breakInfo, currentRowIndex, sliceBottom) : 0;
+				const nextConsumed = Math.min(splittableRow.height, sliceBottom + continuationSkip);
+				const moreAfter = !(nextConsumed >= splittableRow.height) || currentRowIndex + 1 < rows.length;
+				const fragmentHeight = headerOverhead + slice;
+				const sliceFragment = {
+					kind: "table",
+					blockId: block.id,
+					x: computeTableX({
+						columnIndex: sliceState.columnIndex,
+						rowIndex: currentRowIndex
+					}),
+					y: 0,
+					width: measure.totalWidth,
+					height: fragmentHeight,
+					fromRow: currentRowIndex,
+					toRow: currentRowIndex + 1,
+					...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+					...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {},
+					...consumed > 0 || currentRowIndex > 0 ? { continuesFromPrev: true } : {},
+					...moreAfter ? { continuesOnNext: true } : {},
+					...repeatHeaderRows ? { headerRowCount } : {},
+					...consumed > 0 ? { topClip: consumed } : {},
+					...sliceBottom >= splittableRow.height ? {} : { bottomClip: sliceBottom },
+					...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+				};
+				const sliceResult = paginator.addFragment(sliceFragment, fragmentHeight, 0, 0);
+				sliceFragment.y = sliceResult.y;
+				sliceFragment.x = computeTableX({
+					columnIndex: sliceResult.state.columnIndex,
+					rowIndex: currentRowIndex
+				});
+				consumed = nextConsumed;
+				if (consumed < splittableRow.height) if (forceRenderedPageBreak) paginator.forcePageBreak();
+				else {
+					const previousPageNumber = paginator.getCurrentState().page.number;
+					paginator.forceColumnBreak();
+					advanceAfterNaturalFlowBreak(previousPageNumber);
+				}
+			}
+			currentRowIndex += 1;
+			continue;
+		}
+		const state = paginator.getCurrentState();
+		const rawAvailableHeight = paginator.getAvailableHeight();
+		const isFirstFragment = currentRowIndex === 0;
+		const bandSkip = isFirstFragment ? measure.bandSkipBefore ?? 0 : 0;
+		const availableHeight = rawAvailableHeight - (isFirstFragment ? Math.max(bandSkip, state.trailingSpacing) : 0);
+		const repeatHeaderRowsForNormalFragment = shouldRepeatHeaderRows(currentRowIndex, 0, state);
+		const normalHeaderOverhead = repeatHeaderRowsForNormalFragment ? headerRowsHeight : 0;
+		let rowsHeight = 0;
+		let fittingRows = 0;
+		const pageFootnoteIds = new Set(state.page.footnoteIds ?? []);
+		const fragmentFootnoteIds = [];
+		let fragmentFootnoteHeight = 0;
+		let retryOnNextFlowRegion = false;
+		const fragmentX = computeTableX({
+			columnIndex: state.columnIndex,
+			rowIndex: currentRowIndex
+		});
+		for (let j = currentRowIndex; j < rows.length; j++) {
+			if (j > currentRowIndex && block.rows[j]?.breakBefore === "page") break;
+			if (j > currentRowIndex && computeTableX({
+				columnIndex: state.columnIndex,
+				rowIndex: j
+			}) !== fragmentX) break;
+			const rowHeight = rows[j].height;
+			const currentRowFootnoteIds = rowFootnoteIds[j] ?? [];
+			const fragmentFootnoteCountBeforeRow = fragmentFootnoteIds.length;
+			let rowFootnoteHeight = 0;
+			for (const id of currentRowFootnoteIds) {
+				if (pageFootnoteIds.has(id) || fragmentFootnoteIds.includes(id)) continue;
+				fragmentFootnoteIds.push(id);
+				rowFootnoteHeight += footnoteHeightById?.get(id) ?? 0;
+			}
+			const candidateFootnoteHeight = fragmentFootnoteHeight + rowFootnoteHeight;
+			const footnoteGrowth = projectedFootnoteReserveGrowth(state, candidateFootnoteHeight + (state.footnoteDemandHeight === 0 && candidateFootnoteHeight > 0 ? 12 : 0));
+			if (rowsHeight + rowHeight + normalHeaderOverhead + footnoteGrowth <= availableHeight) {
+				rowsHeight += rowHeight;
+				fragmentFootnoteHeight += rowFootnoteHeight;
+				fittingRows++;
+			} else if (fittingRows === 0) {
+				if (state.cursorY === state.topMargin && state.page.fragments.length === 0) {
+					rowsHeight += rowHeight;
+					fragmentFootnoteHeight += rowFootnoteHeight;
+					fittingRows++;
+					break;
+				}
+				fragmentFootnoteIds.splice(fragmentFootnoteCountBeforeRow);
+				paginator.forceColumnBreak();
+				retryOnNextFlowRegion = true;
+				break;
+			} else {
+				fragmentFootnoteIds.splice(fragmentFootnoteCountBeforeRow);
+				break;
+			}
+		}
+		if (retryOnNextFlowRegion) continue;
+		const fragmentHeight = rowsHeight + normalHeaderOverhead;
+		const isLastFragment = currentRowIndex + fittingRows >= rows.length;
+		const desiredX = fragmentX;
+		const fragment = {
+			kind: "table",
+			blockId: block.id,
+			x: desiredX,
+			y: 0,
+			width: measure.totalWidth,
+			height: fragmentHeight,
+			fromRow: currentRowIndex,
+			toRow: currentRowIndex + fittingRows,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {},
+			...!isFirstFragment ? { continuesFromPrev: true } : {},
+			...!isLastFragment ? { continuesOnNext: true } : {},
+			...repeatHeaderRowsForNormalFragment ? { headerRowCount } : {},
+			...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+		};
+		if (fragmentFootnoteHeight > 0) paginator.addFootnoteHeight(fragmentFootnoteHeight, fragmentFootnoteIds);
+		fragment.y = paginator.addFragment(fragment, fragmentHeight, bandSkip, 0).y;
+		fragment.x = desiredX;
+		currentRowIndex += fittingRows;
+		if (currentRowIndex < rows.length) {
+			if (canSplitRow(currentRowIndex)) {
+				const nextState = paginator.getCurrentState();
+				const nextHeaderOverhead = shouldRepeatHeaderRows(currentRowIndex, 0, nextState) ? headerRowsHeight : 0;
+				const nextSliceAvail = paginator.getAvailableHeight() - nextHeaderOverhead - nextState.trailingSpacing;
+				if (snapRowBreak(breakInfo, currentRowIndex, 0, nextSliceAvail) > 0) continue;
+			}
+			const nextState = paginator.getCurrentState();
+			const nextRowHeight = rows[currentRowIndex].height + (shouldRepeatHeaderRows(currentRowIndex, 0, nextState) ? headerRowsHeight : 0);
+			paginator.ensureFits(nextRowHeight);
+		}
+	}
+}
+function collectTableRowFootnoteIds(row, footnoteHeightById) {
+	if (!row || !footnoteHeightById || row.hidden) return [];
+	const ids = [];
+	const walk = (blocks) => {
+		for (const block of blocks) {
+			if (block.kind === "paragraph") {
+				for (const run of block.runs) if (run.kind === "text" && run.footnoteRefId !== void 0 && footnoteHeightById.has(run.footnoteRefId) && !ids.includes(run.footnoteRefId)) ids.push(run.footnoteRefId);
+				continue;
+			}
+			if (block.kind === "table") {
+				for (const nestedRow of block.rows) {
+					if (nestedRow.hidden) continue;
+					for (const cell of nestedRow.cells) walk(cell.blocks);
+				}
+				continue;
+			}
+			if (block.kind === "textBox") walk(block.content);
+		}
+	};
+	for (const cell of row.cells) walk(cell.blocks);
+	return ids;
+}
+/**
+* Layout a floating table (anchored) without advancing the cursor.
+*/
+function layoutFloatingTable(block, measure, paginator, contentWidth) {
+	const state = paginator.getCurrentState();
+	const floating = block.floating;
+	const page = state.page;
+	const margins = page.margins;
+	const tableWidth = measure.totalWidth;
+	const tableHeight = measure.totalHeight;
+	const contentHeight = page.size.h - margins.top - margins.bottom;
+	let baseY = margins.top;
+	if (floating?.vertAnchor === "page") baseY = 0;
+	else if (floating?.vertAnchor === "text") baseY = state.cursorY;
+	let x = paginator.getColumnX(state.columnIndex);
+	if (floating) x = resolveFloatingTablePageX({
+		anchor: floating,
+		justification: block.justification,
+		tableWidth,
+		marginWidth: contentWidth,
+		pageWidth: page.size.w,
+		marginLeft: margins.left,
+		textFrameWidth: paginator.columnWidth,
+		textFrameLeft: paginator.getColumnX(state.columnIndex)
+	});
+	let y = state.cursorY;
+	let usedExplicitY = false;
+	if (floating?.tblpY !== void 0) {
+		y = baseY + floating.tblpY;
+		usedExplicitY = true;
+	} else if (floating?.tblpYSpec) {
+		usedExplicitY = true;
+		const spec = floating.tblpYSpec;
+		if (spec === "top") y = baseY;
+		else if (spec === "bottom") y = baseY + contentHeight - tableHeight;
+		else if (spec === "center") y = baseY + (contentHeight - tableHeight) / 2;
+	}
+	if (!usedExplicitY) y = paginator.ensureFits(tableHeight).cursorY;
+	const fragment = {
+		kind: "table",
+		blockId: block.id,
+		x,
+		y,
+		width: tableWidth,
+		height: tableHeight,
+		fromRow: 0,
+		toRow: block.rows.length,
+		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {},
+		isFloating: true,
+		...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+	};
+	paginator.addUnflowedFragment(fragment);
+}
+//#endregion
+export { getHeaderRowsHeight, layoutFloatingTable, layoutTable };

package/dist/layout-engine/textBoxLayout.d.ts

@@ -0,0 +1,15 @@
+import { TextBoxBlock, TextBoxMeasure } from "./types.js";
+import { createPaginator } from "./paginator.js";
+//#region src/layout-engine/textBoxLayout.d.ts
+type LayoutTextBoxOptions = {
+  paginator: ReturnType<typeof createPaginator>;
+  sectionMarginTop: number;
+  sectionPageHeight: number;
+  sectionMarginBottom: number;
+};
+/**
+ * Layout a text box block onto pages.
+ */
+declare function layoutTextBox(block: TextBoxBlock, measure: TextBoxMeasure, { paginator, sectionMarginTop, sectionPageHeight, sectionMarginBottom }: LayoutTextBoxOptions): void;
+//#endregion
+export { layoutTextBox };