@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/layout-engine/index.js

@@ -0,0 +1,691 @@
+import { measuredLineAdvance } from "./lineFlow.js";
+import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun } from "./types.js";
+import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
+import { createPaginator } from "./paginator.js";
+import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
+import { buildTableRowBreakInfo, snapRowBreak } from "./tableRowBreak.js";
+import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
+import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, scheduleSectionBreak } from "./section-breaks.js";
+import { panic } from "better-result";
+//#region src/layout-engine/index.ts
+/**
+* Layout Engine - Main Entry Point
+*
+* Converts blocks + measures into positioned fragments on pages.
+*/
+const DEFAULT_COLUMNS = {
+	count: 1,
+	gap: 0
+};
+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
+		};
+		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
+	};
+}
+/**
+* Whether a paragraph block has no visible content (no runs, or a single
+* empty text run). Word collapses style-inherited spacing on empty
+* paragraphs (only direct `<w:pPr><w:spacing>` formatting survives) — see
+* eigenpal #402.
+*/
+function isEmptyParagraph(block) {
+	if (block.runs.length === 0) return true;
+	if (block.runs.length !== 1) return false;
+	const r = block.runs[0];
+	return r?.kind === "text" && (r.text ?? "") === "";
+}
+/**
+* Get spacing before a paragraph block. Empty paragraphs whose
+* `before` was inherited from a paragraph style (not set inline) collapse
+* to zero — Word fidelity for incidental empty separators.
+*/
+function getSpacingBefore(block) {
+	const value = block.attrs?.spacing?.before ?? 0;
+	if (isEmptyParagraph(block) && !block.attrs?.spacingExplicit?.before) return 0;
+	return value;
+}
+/**
+* Get spacing after a paragraph block. Same empty-paragraph collapse rule
+* as `getSpacingBefore`.
+*/
+function getSpacingAfter(block) {
+	const value = block.attrs?.spacing?.after ?? 0;
+	if (isEmptyParagraph(block) && !block.attrs?.spacingExplicit?.after) return 0;
+	return value;
+}
+/**
+* Apply contextual spacing suppression (OOXML §17.3.1.9).
+*
+* When two consecutive paragraph blocks both have `contextualSpacing: true`
+* and share the same `styleId`, the spaceAfter of the first paragraph and
+* the spaceBefore of the second paragraph are suppressed (set to 0).
+*
+* This mutates the block attrs in-place before layout runs.
+*/
+function applyContextualSpacing(blocks) {
+	for (let i = 0; i < blocks.length - 1; i++) {
+		const curr = blocks[i];
+		const next = blocks[i + 1];
+		if (curr.kind !== "paragraph" || next.kind !== "paragraph") continue;
+		const currAttrs = curr.attrs;
+		const nextAttrs = next.attrs;
+		if (currAttrs?.contextualSpacing && nextAttrs?.contextualSpacing && currAttrs.styleId && currAttrs.styleId === nextAttrs.styleId) {
+			if (currAttrs.spacing) currAttrs.spacing = {
+				...currAttrs.spacing,
+				after: 0
+			};
+			if (nextAttrs.spacing) nextAttrs.spacing = {
+				...nextAttrs.spacing,
+				before: 0
+			};
+		}
+	}
+	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyContextualSpacing(cell.blocks);
+	else if (block.kind === "textBox") applyContextualSpacing(block.content);
+}
+/**
+* Layout a document: convert blocks + measures into pages with positioned fragments.
+*
+* Algorithm:
+* 1. Walk blocks in order with their corresponding measures
+* 2. For each block, create appropriate fragment(s)
+* 3. Use paginator to manage page/column state
+* 4. Handle page breaks, section breaks, and keepNext chains
+*/
+function layoutDocument(blocks, measures, options) {
+	if (blocks.length !== measures.length) panic(`layoutDocument: expected one measure per block (blocks=${blocks.length}, measures=${measures.length})`);
+	const pageSize = options.pageSize;
+	const baseMargins = {
+		top: options.margins.top,
+		right: options.margins.right,
+		bottom: options.margins.bottom,
+		left: options.margins.left
+	};
+	if (options.margins.header !== void 0) baseMargins.header = options.margins.header;
+	if (options.margins.footer !== void 0) baseMargins.footer = options.margins.footer;
+	const margins = { ...baseMargins };
+	const finalPageSize = options.finalPageSize ?? pageSize;
+	const finalMargins = options.finalMargins ?? margins;
+	if (pageSize.w - margins.left - margins.right <= 0) panic("layoutDocument: page size and margins yield no content area");
+	const bodyConfig = {
+		pageSize,
+		margins
+	};
+	if (options.columns !== void 0) bodyConfig.columns = options.columns;
+	const finalConfig = {
+		pageSize: finalPageSize,
+		margins: finalMargins
+	};
+	if (options.columns !== void 0) finalConfig.columns = options.columns;
+	const { configs: sectionConfigs, breakIndices } = collectSectionConfigs(blocks, bodyConfig, finalConfig);
+	const sectionBreakTypes = [...breakIndices.map((index) => blocks[index].type), options.bodyBreakType];
+	const initialConfig = sectionConfigs.at(0) ?? bodyConfig;
+	const paginator = createPaginator({
+		pageSize: initialConfig.pageSize,
+		margins: initialConfig.margins,
+		...options.firstPageMargins !== void 0 ? { firstPageMargins: options.firstPageMargins } : {},
+		columns: initialConfig.columns ?? DEFAULT_COLUMNS,
+		...options.footnoteReservedHeights !== void 0 ? { footnoteReservedHeights: options.footnoteReservedHeights } : {},
+		...options.sectionHeaderFooterRefs !== void 0 ? { sectionHeaderFooterRefs: options.sectionHeaderFooterRefs } : {}
+	});
+	applyContextualSpacing(blocks);
+	const keepNextChains = computeKeepNextChains(blocks);
+	const midChainIndices = getMidChainIndices(keepNextChains);
+	let sectionIdx = 0;
+	let activeSectionMarginTop = initialConfig.margins.top;
+	let activeSectionPageHeight = initialConfig.pageSize.h;
+	let activeSectionMarginBottom = initialConfig.margins.bottom;
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		const measure = measures[i];
+		if (hasPageBreakBefore(block)) paginator.forcePageBreak();
+		const chain = keepNextChains.get(i);
+		if (chain && !midChainIndices.has(i)) {
+			const chainHeight = calculateChainHeight(chain, blocks, measures);
+			const state = paginator.getCurrentState();
+			const availableHeight = paginator.getAvailableHeight();
+			if (chainHeight <= state.contentBottom - state.topMargin && chainHeight > availableHeight && state.page.fragments.length > 0) paginator.forcePageBreak();
+		}
+		switch (block.kind) {
+			case "paragraph":
+				layoutParagraph(block, measure, paginator, paginator.getContentWidth(), options.footnoteHeightById);
+				break;
+			case "table":
+				if (block.floating) layoutFloatingTable(block, measure, paginator, paginator.getContentWidth());
+				else layoutTable(block, measure, paginator);
+				break;
+			case "image":
+				layoutImage(block, measure, paginator);
+				break;
+			case "textBox":
+				layoutTextBox(block, measure, {
+					paginator,
+					sectionMarginTop: activeSectionMarginTop,
+					sectionPageHeight: activeSectionPageHeight,
+					sectionMarginBottom: activeSectionMarginBottom
+				});
+				break;
+			case "pageBreak":
+				paginator.forcePageBreak();
+				break;
+			case "columnBreak":
+				paginator.forceColumnBreak();
+				break;
+			case "sectionBreak": {
+				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
+				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx], sectionIdx + 1);
+				activeSectionMarginTop = nextSectionConfig.margins.top;
+				activeSectionPageHeight = nextSectionConfig.pageSize.h;
+				activeSectionMarginBottom = nextSectionConfig.margins.bottom;
+				sectionIdx++;
+				break;
+			}
+			default: break;
+		}
+	}
+	if (paginator.pages.length === 0) paginator.getCurrentState();
+	return {
+		pageSize,
+		pages: paginator.pages,
+		...options.columns !== void 0 ? { columns: options.columns } : {},
+		...options.pageGap !== void 0 ? { pageGap: options.pageGap } : {}
+	};
+}
+/**
+* Footnote refs whose run sits in line `[fromRun..toRun]`, with their
+* pre-measured content heights. Empty when the engine isn't tracking
+* dynamic fn demand. Used by `layoutParagraph` to (a) reserve fn
+* height per line and (b) record the IDs on the host page so the
+* painter renders the fn on the page where the ref-bearing line
+* actually landed — even when the paragraph splits across pages
+* (fragment pmStart/pmEnd is paragraph-wide and cannot disambiguate
+* between split halves).
+*/
+function getLineFootnoteRefs(block, fromRun, toRun, fnHeights) {
+	if (!fnHeights) return {
+		ids: [],
+		height: 0
+	};
+	const ids = [];
+	let height = 0;
+	for (let r = fromRun; r <= toRun; r++) {
+		const run = block.runs[r];
+		if (!run || run.kind !== "text") continue;
+		const id = run.footnoteRefId;
+		if (id === void 0) continue;
+		const h = fnHeights.get(id);
+		if (h !== void 0) {
+			ids.push(id);
+			height += h;
+		}
+	}
+	return {
+		ids,
+		height
+	};
+}
+/**
+* Layout a paragraph block onto pages.
+*
+* When `footnoteHeightById` is provided, each line carrying a footnote
+* ref additionally reserves space on its host page for the fn's
+* content. Pagination decisions look at the line's effective height
+* (`lineHeight + lineFnHeight`) so a line cannot land on a page that
+* lacks room for both — preventing footnote overflow without the
+* static-reservation iteration loop.
+*/
+function layoutParagraph(block, measure, paginator, contentWidth, footnoteHeightById) {
+	const lines = measure.lines;
+	if (lines.length === 0) {
+		const spaceBefore = getSpacingBefore(block);
+		const spaceAfter = getSpacingAfter(block);
+		const state = paginator.getCurrentState();
+		const fragment = {
+			kind: "paragraph",
+			blockId: block.id,
+			x: paginator.getColumnX(state.columnIndex),
+			y: state.cursorY + spaceBefore,
+			width: contentWidth,
+			height: 0,
+			fromLine: 0,
+			toLine: 0,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {},
+			...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+		};
+		paginator.addFragment(fragment, 0, spaceBefore, spaceAfter);
+		return;
+	}
+	const spaceBefore = getSpacingBefore(block);
+	const spaceAfter = getSpacingAfter(block);
+	let currentLineIndex = 0;
+	while (currentLineIndex < lines.length) {
+		const state = paginator.getCurrentState();
+		const availableHeight = paginator.getAvailableHeight();
+		if (currentLineIndex === 0 && state.trailingSpacing > 0 && state.cursorY !== state.topMargin) {
+			const firstLine = lines[0];
+			const firstLineRefs = getLineFootnoteRefs(block, firstLine.fromRun, firstLine.toRun, footnoteHeightById);
+			const firstLineHeight = measuredLineAdvance(firstLine) + firstLineRefs.height;
+			const collapsedLead = Math.max(spaceBefore, state.trailingSpacing);
+			const columnCapacity = state.contentBottom - state.topMargin;
+			if (collapsedLead + firstLineHeight > availableHeight && spaceBefore + firstLineHeight <= columnCapacity) {
+				paginator.ensureFits(collapsedLead + firstLineHeight);
+				continue;
+			}
+		}
+		let linesHeight = 0;
+		let linesFnHeight = 0;
+		const linesFnIds = [];
+		let fittingLines = 0;
+		const firstFragmentSpaceBefore = currentLineIndex === 0 ? Math.max(spaceBefore, state.trailingSpacing) : 0;
+		for (let j = currentLineIndex; j < lines.length; j++) {
+			const line = lines[j];
+			const lineAdvance = measuredLineAdvance(line);
+			const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
+			const totalWithLine = linesHeight + lineAdvance;
+			if (totalWithLine + firstFragmentSpaceBefore + linesFnHeight + lineRefs.height <= availableHeight || fittingLines === 0) {
+				linesHeight = totalWithLine;
+				linesFnHeight += lineRefs.height;
+				for (const id of lineRefs.ids) linesFnIds.push(id);
+				fittingLines++;
+			} else break;
+		}
+		const isFirstFragment = currentLineIndex === 0;
+		const isLastFragment = currentLineIndex + fittingLines >= lines.length;
+		const effectiveSpaceBefore = isFirstFragment ? spaceBefore : 0;
+		const effectiveSpaceAfter = isLastFragment ? spaceAfter : 0;
+		const pmRange = getParagraphFragmentPmRange(block, measure, currentLineIndex, currentLineIndex + fittingLines);
+		const fragment = {
+			kind: "paragraph",
+			blockId: block.id,
+			x: paginator.getColumnX(state.columnIndex),
+			y: 0,
+			width: contentWidth,
+			height: linesHeight,
+			fromLine: currentLineIndex,
+			toLine: currentLineIndex + fittingLines,
+			...pmRange.pmStart !== void 0 ? { pmStart: pmRange.pmStart } : {},
+			...pmRange.pmEnd !== void 0 ? { pmEnd: pmRange.pmEnd } : {},
+			...!isFirstFragment ? { continuesFromPrev: true } : {},
+			...!isLastFragment ? { continuesOnNext: true } : {},
+			...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+		};
+		if (linesFnHeight > 0) {
+			paginator.ensureFits(effectiveSpaceBefore + linesHeight + linesFnHeight);
+			if (paginator.getCurrentState().footnoteHeight === 0) paginator.ensureFits(effectiveSpaceBefore + linesHeight + linesFnHeight + 12);
+		}
+		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
+		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
+		currentLineIndex += fittingLines;
+		if (currentLineIndex < lines.length) paginator.ensureFits(measuredLineAdvance(lines[currentLineIndex]));
+	}
+}
+/**
+* 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;
+}
+/**
+* Layout a table block onto pages.
+*/
+function layoutTable(block, measure, paginator) {
+	const rows = measure.rows;
+	if (rows.length === 0) return;
+	const headerRowCount = countHeaderRows(block);
+	const headerRowsHeight = getHeaderRowsHeight(measure, headerRowCount);
+	let currentRowIndex = 0;
+	const breakInfo = buildTableRowBreakInfo(block, measure);
+	const computeTableX = (columnIndex) => {
+		let x = paginator.getColumnX(columnIndex);
+		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
+		else if (block.justification === "right") x = x + paginator.columnWidth - measure.totalWidth;
+		else if (block.indent) x += block.indent;
+		return x;
+	};
+	const getCurrentRowCapacity = (state = paginator.getCurrentState()) => state.rawContentBottom - state.topMargin;
+	const getCurrentAvailableHeight = (state = paginator.getCurrentState()) => state.contentBottom - state.cursorY;
+	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 && previous.x === computeTableX(state.columnIndex);
+	};
+	const shouldRepeatHeaderRows = (rowIndex, consumed, state = paginator.getCurrentState()) => headerRowCount > 0 && rowIndex >= headerRowCount && !(consumed === 0 && hasAdjacentPriorTableRows(rowIndex, state));
+	const canSplitRow = (rowIndex, state = paginator.getCurrentState()) => {
+		const row = rows[rowIndex];
+		if (!row) return false;
+		const repeatedHeaderOverhead = shouldRepeatHeaderRows(rowIndex, 0, state) ? headerRowsHeight : 0;
+		if ((breakInfo.breakOffsets[rowIndex]?.length ?? 0) <= 1) return false;
+		const requiredHeight = row.height + repeatedHeaderOverhead;
+		if (requiredHeight > getCurrentRowCapacity(state)) return true;
+		return hasAdjacentPriorTableRows(rowIndex, state) && requiredHeight > getCurrentAvailableHeight(state) - state.trailingSpacing;
+	};
+	while (currentRowIndex < rows.length) {
+		const oversizedRow = rows[currentRowIndex];
+		if (canSplitRow(currentRowIndex)) {
+			let consumed = 0;
+			while (consumed < oversizedRow.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);
+				if (slice <= 0) {
+					if (!(sliceState.cursorY === sliceState.topMargin && sliceState.page.fragments.length === 0)) {
+						paginator.forceColumnBreak();
+						continue;
+					}
+					const from = consumed;
+					slice = (breakInfo.breakOffsets[currentRowIndex]?.find((o) => o > from) ?? oversizedRow.height) - consumed;
+				}
+				const sliceBottom = consumed + slice;
+				const reachesRowEnd = sliceBottom >= oversizedRow.height;
+				const moreAfter = !reachesRowEnd || currentRowIndex + 1 < rows.length;
+				const fragmentHeight = headerOverhead + slice;
+				const sliceFragment = {
+					kind: "table",
+					blockId: block.id,
+					x: computeTableX(sliceState.columnIndex),
+					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 } : {},
+					...reachesRowEnd ? {} : { bottomClip: sliceBottom },
+					...block.sdtGroups ? { sdtGroups: block.sdtGroups } : {}
+				};
+				const sliceResult = paginator.addFragment(sliceFragment, fragmentHeight, 0, 0);
+				sliceFragment.y = sliceResult.y;
+				sliceFragment.x = computeTableX(sliceResult.state.columnIndex);
+				consumed = sliceBottom;
+				if (consumed < oversizedRow.height) paginator.forceColumnBreak();
+			}
+			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;
+		for (let j = currentRowIndex; j < rows.length; j++) {
+			const rowHeight = rows[j].height;
+			if (rowsHeight + rowHeight + normalHeaderOverhead <= availableHeight || fittingRows === 0) {
+				rowsHeight += rowHeight;
+				fittingRows++;
+			} else break;
+		}
+		const fragmentHeight = rowsHeight + normalHeaderOverhead;
+		const isLastFragment = currentRowIndex + fittingRows >= rows.length;
+		const desiredX = computeTableX(state.columnIndex);
+		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 } : {}
+		};
+		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);
+		}
+	}
+}
+/**
+* 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 baseX = margins.left;
+	let baseY = margins.top;
+	if (floating?.horzAnchor === "page") baseX = 0;
+	if (floating?.vertAnchor === "page") baseY = 0;
+	let x = paginator.getColumnX(state.columnIndex);
+	if (floating?.tblpX !== void 0) x = baseX + floating.tblpX;
+	else if (floating?.tblpXSpec) {
+		const spec = floating.tblpXSpec;
+		if (spec === "left" || spec === "inside") x = baseX;
+		else if (spec === "right" || spec === "outside") x = baseX + contentWidth - tableWidth;
+		else x = baseX + (contentWidth - tableWidth) / 2;
+	} else if (block.justification === "center") x = baseX + (contentWidth - tableWidth) / 2;
+	else if (block.justification === "right") x = baseX + contentWidth - tableWidth;
+	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 minX = margins.left;
+	const maxX = margins.left + contentWidth - tableWidth;
+	if (Number.isFinite(maxX)) x = Math.max(minX, Math.min(x, maxX));
+	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 } : {}
+	};
+	state.page.fragments.push(fragment);
+}
+/**
+* Layout an image block onto pages.
+*/
+function layoutImage(block, measure, paginator) {
+	if (block.anchor?.isAnchored) {
+		layoutAnchoredImage(block, measure, paginator);
+		return;
+	}
+	const bandSkip = measure.bandSkipBefore ?? 0;
+	const state = paginator.ensureFits(bandSkip + measure.height);
+	const fragment = {
+		kind: "image",
+		blockId: block.id,
+		x: paginator.getColumnX(state.columnIndex),
+		y: 0,
+		width: measure.width,
+		height: measure.height,
+		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+	};
+	fragment.y = paginator.addFragment(fragment, measure.height, bandSkip, 0).y;
+}
+/**
+* Layout an anchored (floating) image.
+*/
+function layoutAnchoredImage(block, measure, paginator) {
+	const state = paginator.getCurrentState();
+	const anchor = block.anchor;
+	if (!anchor) return;
+	const x = anchor.offsetH ?? paginator.getColumnX(state.columnIndex);
+	const y = anchor.offsetV ?? state.cursorY;
+	const fragment = {
+		kind: "image",
+		blockId: block.id,
+		x,
+		y,
+		width: measure.width,
+		height: measure.height,
+		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {},
+		isAnchored: true,
+		zIndex: anchor.behindDoc ? -1 : 1
+	};
+	state.page.fragments.push(fragment);
+}
+/**
+* Layout a text box block onto pages.
+*/
+function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPageHeight, sectionMarginBottom }) {
+	if (isPagePinnedBandTextBox(block)) {
+		const state = paginator.getCurrentState();
+		const bandTop = bandTopContentY(block.position?.vertical, {
+			pageHeight: sectionPageHeight,
+			marginTop: sectionMarginTop,
+			marginBottom: sectionMarginBottom,
+			boxHeight: measure.height
+		});
+		const horizontal = block.position?.horizontal;
+		const x = horizontal ? bandFragmentX(horizontal, {
+			pageWidth: state.page.size.w,
+			marginLeft: state.page.margins.left,
+			marginRight: state.page.margins.right,
+			boxWidth: measure.width
+		}) : paginator.getColumnX(state.columnIndex);
+		const fragment = {
+			kind: "textBox",
+			blockId: block.id,
+			x,
+			y: state.topMargin + bandTop,
+			width: measure.width,
+			height: measure.height,
+			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+		};
+		state.page.fragments.push(fragment);
+		return;
+	}
+	const state = paginator.ensureFits(measure.height);
+	const fragment = {
+		kind: "textBox",
+		blockId: block.id,
+		x: paginator.getColumnX(state.columnIndex),
+		y: 0,
+		width: measure.width,
+		height: measure.height,
+		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
+		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
+	};
+	fragment.y = paginator.addFragment(fragment, measure.height, 0, 0).y;
+}
+/**
+* A topAndBottom text box whose vertical anchor pins it to the page frame
+* (page/margin/margin-strip) — it floats to a fixed page position rather than
+* flowing in document order. Must agree with the measure pass's band extraction
+* (extractFloatingZones), which uses the same predicate. eigenpal #694.
+*/
+function isPagePinnedBandTextBox(block) {
+	if (!floatingTextBoxReservesBand(block)) return false;
+	return isPageFrameRelativeAnchor(block.position?.vertical?.relativeTo);
+}
+/**
+* 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 = "nextPage", nextSectionIndex) {
+	switch (nextSectionType) {
+		case "nextPage":
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex);
+			paginator.forcePageBreak({ coalesceBlankPage: true });
+			break;
+		case "evenPage":
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex);
+			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 !== 0) paginator.forcePageBreak();
+			break;
+		case "oddPage":
+			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
+			if (nextSectionIndex !== void 0) paginator.startSection(nextSectionIndex);
+			if (paginator.forcePageBreak({ coalesceBlankPage: true }).page.number % 2 === 0) paginator.forcePageBreak();
+			break;
+		case "continuous": {
+			const currentPage = paginator.pages.at(-1);
+			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(nextSectionIndex);
+			if (pageSizeChanges) {
+				paginator.updatePageLayout(nextSize, nextSectionConfig.margins);
+				if (!paginator.retargetCurrentBlankPage()) paginator.forcePageBreak({ coalesceBlankPage: true });
+			} else {
+				paginator.updatePageLayout(nextSize, nextSectionConfig.margins, false);
+				paginator.retargetCurrentBlankPage();
+			}
+			break;
+		}
+		default: break;
+	}
+	paginator.updateColumns(nextSectionConfig.columns ?? DEFAULT_COLUMNS);
+}
+//#endregion
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyContextualSpacing, applyPendingToActive, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, scheduleSectionBreak };