@stll/folio-core 0.49.0 → 0.51.0

package/dist/layout-engine/index.js

@@ -1,20 +1,21 @@
-import { emuToPixels } from "../utils/units.js";
 import { reflowFootnoteColumns } from "./footnoteColumnReflow.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
+import { layoutImage } from "./imageLayout.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
-import { measuredLineAdvance, measuredLineRangeHeight } from "./lineFlow.js";
-import { resolveFloatingTablePageX } from "./measure/floatingTablePosition.js";
-import { resolveTableInlineOffset } from "./measure/tableInlinePlacement.js";
+import "./layoutFlowShared.js";
+import { measuredLineAdvance } from "./lineFlow.js";
 import { annotateNoteSeparators, continuesNoteArea, createNoteAreaContinuation } from "./noteAreaFlow.js";
-import { SECTION_START_PLACEMENT, createPaginator } from "./paginator.js";
-import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
-import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacingTree } from "./paragraphSpacing.js";
+import { createPaginator } from "./paginator.js";
+import { layoutParagraph } from "./paragraphLayout.js";
+import { paragraphsShareStyle, resolveEffectiveParagraphSpacingTree } from "./paragraphSpacing.js";
 import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPageIndex.js";
 import { INITIAL_RENDERED_BREAK_STATE, PAGE_ADVANCE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
-import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, physicalColumnRegionIsShared, scheduleSectionBreak } from "./section-breaks.js";
+import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, normalizeSectionBreakType, scheduleSectionBreak } from "./section-breaks.js";
+import { CONTINUE_PAGE_NUMBERING, DEFAULT_COLUMNS, balancedParagraphSectionHeight, collectSectionConfigs, handleSectionBreak } from "./sectionLayout.js";
 import { applySectionVerticalAlignment } from "./sectionVerticalAlignment.js";
-import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak, tableKeepNextOpeningHeight } from "./tableRowBreak.js";
-import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
+import { getHeaderRowsHeight, layoutFloatingTable, layoutTable } from "./tableLayout.js";
+import { tableKeepNextOpeningHeight } from "./tableRowBreak.js";
+import { layoutTextBox } from "./textBoxLayout.js";
 import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, NOTE_SEPARATOR_RULE_THICKNESS, NOTE_SEPARATOR_WIDTH_FRACTION, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isListNumPr, isTextWrappingFloatingImageRun, resolveTableCellPadding, resolveTableWidthPx, stripFlowBlockPmAnchors, tableColumnsArePinned } from "./types.js";
 import { panic } from "better-result";
 //#region src/layout-engine/index.ts
@@ -23,92 +24,6 @@ import { panic } from "better-result";
 *
 * Converts blocks + measures into positioned fragments on pages.
 */
-const RENDERED_BREAK_REFLOW_TOLERANCE_LINES = 3;
-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;
-}
-function hasWidowControl(block) {
-	return block.attrs?.widowControl !== false;
-}
 /**
 * Apply contextual spacing suppression (OOXML §17.3.1.9).
 *
@@ -217,7 +132,7 @@ function layoutDocumentPass(blocks, measures, options) {
 		if (noteAreaContinuation !== void 0) paginator.setPageTopContinuation(continuesNoteArea(options.noteAreas, block) ? noteAreaContinuation : void 0);
 		const firstLine = measure.kind === "paragraph" ? measure.lines.at(0) : void 0;
 		const firstLineAdvance = firstLine ? measuredLineAdvance(firstLine) : 0;
-		const renderedBreakNeedsSnap = measure.kind === "paragraph" && (!paginator.fits(measure.totalHeight) || firstLineAdvance > 0 && paginator.getAvailableHeight() <= firstLineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES);
+		const renderedBreakNeedsSnap = measure.kind === "paragraph" && (!paginator.fits(measure.totalHeight) || firstLineAdvance > 0 && paginator.getAvailableHeight() <= firstLineAdvance * 3);
 		const hasExplicitPageBreak = block.kind === "pageBreak" || hasPageBreakBefore(block);
 		const breakDecision = reconcileBreakBeforeBlock({
 			state: renderedBreakState,
@@ -319,845 +234,5 @@ function layoutDocumentPass(blocks, measures, options) {
 		...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
-	};
-}
-function projectedFootnoteReserveGrowth(state, additionalDemandHeight) {
-	const projectedDemand = state.footnoteDemandHeight + additionalDemandHeight;
-	return Math.max(state.footnoteHeightFloor, projectedDemand) - state.footnoteHeight;
-}
-function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeightById, suppressSpaceBefore }) {
-	const lines = measure.lines;
-	if (lines.length === 0) {
-		const spaceBefore = suppressSpaceBefore ? 0 : getParagraphSpacingBefore(block);
-		const spaceAfter = getParagraphSpacingAfter(block);
-		const state = paginator.getCurrentState();
-		const fragment = {
-			kind: "paragraph",
-			...block.attrs?.suppressEmptyParagraphHeight === true ? { paginationRole: "empty-carrier" } : {},
-			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 = suppressSpaceBefore ? 0 : getParagraphSpacingBefore(block);
-	const spaceAfter = getParagraphSpacingAfter(block);
-	let keepLinesDemand;
-	if (lines.length > 1 && hasKeepLines(block)) {
-		let footnoteHeight = 0;
-		for (const line of lines) footnoteHeight += getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById).height;
-		keepLinesDemand = {
-			linesHeight: measuredLineRangeHeight(lines, 0, lines.length),
-			footnoteHeight
-		};
-	}
-	let keepLinesMoveAttempted = false;
-	let currentLineIndex = 0;
-	while (currentLineIndex < lines.length) {
-		const state = paginator.getCurrentState();
-		const availableHeight = paginator.getAvailableHeight();
-		const currentLine = lines.at(currentLineIndex);
-		const markerAlreadySatisfied = state.columnIndex === 0 && state.cursorY === state.topMargin && state.page.fragments.length === 0;
-		if (currentLine?.renderedPageBreakBefore === true && !markerAlreadySatisfied && availableHeight <= measuredLineAdvance(currentLine) * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
-			paginator.forcePageBreak();
-			continue;
-		}
-		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) + projectedFootnoteReserveGrowth(state, firstLineRefs.height);
-			const collapsedLead = collapseParagraphSpacing({
-				before: spaceBefore,
-				after: state.trailingSpacing
-			});
-			const columnCapacity = state.contentBottom - state.topMargin;
-			if (collapsedLead + firstLineHeight > availableHeight && spaceBefore + firstLineHeight <= columnCapacity) {
-				paginator.ensureFits(collapsedLead + firstLineHeight);
-				continue;
-			}
-		}
-		if (keepLinesDemand !== void 0 && !keepLinesMoveAttempted && currentLineIndex === 0 && state.cursorY !== state.topMargin) {
-			const wholeHeight = keepLinesDemand.linesHeight + projectedFootnoteReserveGrowth(state, keepLinesDemand.footnoteHeight);
-			const collapsedLead = collapseParagraphSpacing({
-				before: spaceBefore,
-				after: state.trailingSpacing
-			});
-			const columnCapacity = state.contentBottom - state.topMargin;
-			if (collapsedLead + wholeHeight > availableHeight && spaceBefore + wholeHeight <= columnCapacity) {
-				keepLinesMoveAttempted = true;
-				paginator.ensureFits(collapsedLead + wholeHeight);
-				continue;
-			}
-		}
-		let linesHeight = 0;
-		let linesFnHeight = 0;
-		const linesFnIds = [];
-		let fittingLines = 0;
-		let forcePageBreakAfterFragment = false;
-		const firstFragmentSpaceBefore = currentLineIndex === 0 ? collapseParagraphSpacing({
-			before: spaceBefore,
-			after: state.trailingSpacing
-		}) : 0;
-		for (let j = currentLineIndex; j < lines.length; j++) {
-			const line = lines[j];
-			const lineAdvance = measuredLineAdvance(line);
-			if (j > currentLineIndex && line.renderedPageBreakBefore === true && availableHeight - (linesHeight + firstFragmentSpaceBefore + linesFnHeight) <= lineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
-				forcePageBreakAfterFragment = true;
-				break;
-			}
-			const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
-			const totalWithLine = linesHeight + lineAdvance;
-			const footnoteGrowth = projectedFootnoteReserveGrowth(state, linesFnHeight + lineRefs.height);
-			if (totalWithLine + firstFragmentSpaceBefore + footnoteGrowth <= availableHeight || fittingLines === 0) {
-				linesHeight = totalWithLine;
-				linesFnHeight += lineRefs.height;
-				for (const id of lineRefs.ids) linesFnIds.push(id);
-				fittingLines++;
-			} else break;
-		}
-		let forceBreakAfterFragment = false;
-		if (hasWidowControl(block)) {
-			const remainingAfter = lines.length - (currentLineIndex + fittingLines);
-			if (fittingLines > 1 && remainingAfter === 1) {
-				if (currentLineIndex === 0 && fittingLines === 2 && state.cursorY !== state.topMargin) {
-					paginator.forceColumnBreak();
-					continue;
-				}
-				fittingLines -= 1;
-				forceBreakAfterFragment = true;
-				linesHeight = 0;
-				linesFnHeight = 0;
-				linesFnIds.length = 0;
-				for (let j = currentLineIndex; j < currentLineIndex + fittingLines; j++) {
-					const line = lines[j];
-					linesHeight += measuredLineAdvance(line);
-					const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
-					linesFnHeight += lineRefs.height;
-					for (const id of lineRefs.ids) linesFnIds.push(id);
-				}
-			}
-		}
-		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",
-			...block.attrs?.suppressEmptyParagraphHeight === true ? { paginationRole: "empty-carrier" } : {},
-			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) {
-			const stateBefore = paginator.getCurrentState();
-			paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateBefore, linesFnHeight));
-			const stateAfter = paginator.getCurrentState();
-			if (stateAfter.footnoteDemandHeight === 0) paginator.ensureFits(effectiveSpaceBefore + linesHeight + projectedFootnoteReserveGrowth(stateAfter, linesFnHeight + 12));
-		}
-		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
-		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
-		currentLineIndex += fittingLines;
-		if (currentLineIndex < lines.length) if (forcePageBreakAfterFragment) paginator.forcePageBreak();
-		else if (forceBreakAfterFragment) paginator.forceColumnBreak();
-		else 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;
-}
-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 * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
-					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);
-}
-/**
-* 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
-	};
-	paginator.addUnflowedFragment(fragment);
-}
-const TEXT_BOX_ANCHOR_BLOCK_ID = Symbol.for("stll.textBoxAnchorBlockId");
-const readTextBoxAnchorBlockId = (block) => Reflect.get(block, TEXT_BOX_ANCHOR_BLOCK_ID);
-/**
-* 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 x = bandFragmentX(block.position?.horizontal, {
-			pageWidth: state.page.size.w,
-			marginLeft: state.page.margins.left,
-			marginRight: state.page.margins.right,
-			activeColumnLeft: paginator.getColumnX(state.columnIndex),
-			activeColumnWidth: paginator.columnWidth,
-			boxWidth: measure.width
-		});
-		const fragment = {
-			kind: "textBox",
-			blockId: block.id,
-			x,
-			y: block.position?.vertical?.relativeTo === "page" ? sectionMarginTop + bandTop : state.topMargin + bandTop,
-			width: measure.width,
-			height: measure.height,
-			isPositioned: true,
-			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
-			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
-		};
-		paginator.addUnflowedFragment(fragment);
-		return;
-	}
-	if (block.position !== void 0) {
-		const state = paginator.getCurrentState();
-		const x = bandFragmentX(block.position.horizontal, {
-			pageWidth: state.page.size.w,
-			marginLeft: state.page.margins.left,
-			marginRight: state.page.margins.right,
-			activeColumnLeft: paginator.getColumnX(state.columnIndex),
-			activeColumnWidth: paginator.columnWidth,
-			boxWidth: measure.width
-		});
-		const vertical = block.position.vertical;
-		const anchorBlockId = readTextBoxAnchorBlockId(block);
-		const anchorParagraph = vertical?.relativeTo === "paragraph" && typeof anchorBlockId === "string" ? state.page.fragments.find((fragment) => fragment.kind === "paragraph" && fragment.blockId === anchorBlockId) : void 0;
-		const bandGeometry = {
-			pageHeight: sectionPageHeight,
-			marginTop: sectionMarginTop,
-			marginBottom: sectionMarginBottom,
-			boxHeight: measure.height
-		};
-		let y;
-		if (vertical?.relativeTo === "page") y = sectionMarginTop + bandTopContentY(vertical, bandGeometry);
-		else if (isPageFrameRelativeAnchor(vertical?.relativeTo)) y = state.topMargin + bandTopContentY(vertical, {
-			pageHeight: sectionPageHeight,
-			marginTop: sectionMarginTop,
-			marginBottom: sectionMarginBottom,
-			boxHeight: measure.height
-		});
-		else y = (anchorParagraph?.y ?? state.cursorY) + emuToPixels(vertical?.posOffset ?? 0);
-		const fragment = {
-			kind: "textBox",
-			blockId: block.id,
-			x,
-			y,
-			width: measure.width,
-			height: measure.height,
-			isPositioned: true,
-			...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
-			...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
-		};
-		paginator.addUnflowedFragment(fragment);
-		return;
-	}
-	const effect = block.effectExtent;
-	const occupiedHeight = measure.height + (effect?.top ?? 0) + (effect?.bottom ?? 0);
-	const occupiedWidth = measure.width + (effect?.left ?? 0) + (effect?.right ?? 0);
-	const host = block.hostParagraph;
-	const fragment = {
-		kind: "textBox",
-		blockId: block.id,
-		x: 0,
-		y: 0,
-		width: measure.width,
-		height: measure.height,
-		...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
-		...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
-	};
-	const result = paginator.addFragment(fragment, occupiedHeight, host?.spacing?.before ?? 0, host?.spacing?.after ?? 0);
-	fragment.x = result.x + hostParagraphLineOffset(host, paginator.columnWidth, occupiedWidth) + (effect?.left ?? 0);
-	fragment.y = result.y + (effect?.top ?? 0);
-}
-/**
-* Where a line holding only an object of `width` starts within a column:
-* after the host paragraph's start and first-line indents, then aligned in
-* what remains before its end indent.
-*/
-function hostParagraphLineOffset(host, columnWidth, width) {
-	if (!host) return 0;
-	const indent = host.indent;
-	const start = (indent?.left ?? 0) + (indent?.firstLine ?? 0) - (indent?.hanging ?? 0);
-	const slack = Math.max(0, columnWidth - start - (indent?.right ?? 0) - width);
-	switch (host.alignment) {
-		case "center": return start + slack / 2;
-		case "right": return start + slack;
-		case "left":
-		case "justify":
-		case void 0: return start;
-		default:
-			host.alignment;
-			return start;
-	}
-}
-/**
-* 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);
-}
-/**
-* 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 { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, NOTE_SEPARATOR_RULE_THICKNESS, NOTE_SEPARATOR_WIDTH_FRACTION, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, getTableRowLeadingWidth, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isListNumPr, isTextWrappingFloatingImageRun, layoutDocument, resolveSectionHeaderFooterRefs, resolveTableCellPadding, resolveTableWidthPx, scheduleSectionBreak, stripFlowBlockPmAnchors, tableColumnsArePinned };