@stll/folio-core 0.48.0 → 0.50.0

package/dist/layout-engine/paragraphLayout.js

@@ -0,0 +1,204 @@
+import { hasKeepLines } from "./keep-together.js";
+import { projectedFootnoteReserveGrowth } from "./layoutFlowShared.js";
+import { measuredLineAdvance, measuredLineRangeHeight } from "./lineFlow.js";
+import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore } from "./paragraphSpacing.js";
+import "./types.js";
+//#region src/layout-engine/paragraphLayout.ts
+/**
+* Places a measured paragraph's lines onto pages: keep rules, widow/orphan
+* control, rendered-break reconciliation, and per-line footnote reservation.
+*/
+function hasWidowControl(block) {
+	return block.attrs?.widowControl !== false;
+}
+/**
+* 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 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) * 3) {
+			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 * 3) {
+				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]));
+	}
+}
+//#endregion
+export { layoutParagraph };

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

@@ -1,4 +1,4 @@
-import { FlowBlock, ParagraphBlock } from "./types.js";
+import { FlowBlock, ParagraphBlock, TableBlock } from "./types.js";
 //#region src/layout-engine/paragraphSpacing.d.ts
 type EffectiveParagraphSpacing = Readonly<{
   before: number;
@@ -35,5 +35,7 @@ declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => Effec
  */
 declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
 declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
+/** Derive the effective paragraph spacing of every cell story in a table. */
+declare const resolveTableSpacing: (block: TableBlock) => TableBlock;
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree, resolveTableSpacing };

package/dist/layout-engine/paragraphSpacing.js

@@ -88,6 +88,7 @@ const resolveTextBoxContentSpacing = (blocks) => {
 	});
 	return changed ? resolved : blocks;
 };
+/** Derive the effective paragraph spacing of every cell story in a table. */
 const resolveTableSpacing = (block) => {
 	let changed = false;
 	const rows = block.rows.map((row) => {
@@ -122,4 +123,4 @@ const resolveTextBoxSpacing = (block) => {
 	};
 };
 //#endregion
-export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isAuthoredEmptyParagraph, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree, resolveTableSpacing };

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

@@ -0,0 +1,45 @@
+import { ColumnLayout, FlowBlock, Measure, PageMargins, SectionBreakBlock, SectionPageNumbering } from "./types.js";
+import { createPaginator } from "./paginator.js";
+import { SectionStart } from "@stll/docx-core/model";
+//#region src/layout-engine/sectionLayout.d.ts
+type SectionLayoutConfig = {
+  pageSize: {
+    w: number;
+    h: number;
+  };
+  margins: PageMargins;
+  pageNumbering: SectionPageNumbering;
+  columns?: ColumnLayout;
+};
+declare const DEFAULT_COLUMNS: ColumnLayout;
+declare const CONTINUE_PAGE_NUMBERING: SectionPageNumbering;
+declare function collectSectionConfigs(blocks: FlowBlock[], initialConfig: SectionLayoutConfig, finalConfig: SectionLayoutConfig): {
+  configs: SectionLayoutConfig[];
+  breakIndices: number[];
+};
+/**
+ * Estimate the height of a short paragraph-only multi-column section so its
+ * final page can use Word-style balanced columns. Sections containing tables,
+ * floating blocks, or authored breaks keep the normal bottom-up pagination;
+ * those need structure-aware balancing rather than a height estimate.
+ */
+type BalancedParagraphSectionHeightOptions = {
+  blocks: FlowBlock[];
+  measures: Measure[];
+  startIndex: number;
+  endIndex: number;
+  incomingSpacing: number;
+  columnCount: number;
+  availableHeight: number;
+};
+declare function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }: BalancedParagraphSectionHeightOptions): number | undefined;
+/**
+ * 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)
+ */
+declare function handleSectionBreak(_block: SectionBreakBlock, paginator: ReturnType<typeof createPaginator>, nextSectionConfig: SectionLayoutConfig, nextSectionType: SectionStart, nextSectionIndex?: number): void;
+//#endregion
+export { CONTINUE_PAGE_NUMBERING, DEFAULT_COLUMNS, SectionLayoutConfig, balancedParagraphSectionHeight, collectSectionConfigs, handleSectionBreak };

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 };