@stll/folio-core 0.47.7 → 0.48.0

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

@@ -1,4 +1,4 @@
-import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListMarkerFormatting, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionPageNumbering, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isListNumPr, isTextWrappingFloatingImageRun, resolveTableCellPadding, resolveTableWidthPx, tableColumnsArePinned } from "./types.js";
+import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListMarkerFormatting, MathRun, Measure, MeasuredLine, NOTE_SEPARATOR_RULE_THICKNESS, NOTE_SEPARATOR_WIDTH_FRACTION, NoteAreaLayout, NoteSeparatorKind, NoteSeparatorRule, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionPageNumbering, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isListNumPr, isTextWrappingFloatingImageRun, resolveTableCellPadding, resolveTableWidthPx, stripFlowBlockPmAnchors, tableColumnsArePinned } from "./types.js";
 import { PageState, Paginator, PaginatorOptions, createPaginator } from "./paginator.js";
 import { KeepNextChain, calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
@@ -42,4 +42,4 @@ declare function layoutDocument(blocks: FlowBlock[], measures: Measure[], option
  */
 declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
 //#endregion
-export { BlockId, BorderStyle, type BreakDecision, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListMarkerFormatting, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, SectionPageNumbering, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, 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, tableColumnsArePinned };
+export { BlockId, BorderStyle, type BreakDecision, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListMarkerFormatting, MathRun, Measure, MeasuredLine, NOTE_SEPARATOR_RULE_THICKNESS, NOTE_SEPARATOR_WIDTH_FRACTION, NoteAreaLayout, NoteSeparatorKind, NoteSeparatorRule, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, SectionPageNumbering, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, 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 };

package/dist/layout-engine/index.js

@@ -2,9 +2,10 @@ import { emuToPixels } from "../utils/units.js";
 import { reflowFootnoteColumns } from "./footnoteColumnReflow.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
-import { measuredLineAdvance } from "./lineFlow.js";
+import { measuredLineAdvance, measuredLineRangeHeight } from "./lineFlow.js";
 import { resolveFloatingTablePageX } from "./measure/floatingTablePosition.js";
 import { resolveTableInlineOffset } from "./measure/tableInlinePlacement.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";
@@ -14,7 +15,7 @@ import { applyPendingToActive, createInitialSectionState, getEffectiveColumns, g
 import { applySectionVerticalAlignment } from "./sectionVerticalAlignment.js";
 import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak } from "./tableRowBreak.js";
 import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "./textBoxFlow.js";
-import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isListNumPr, isTextWrappingFloatingImageRun, resolveTableCellPadding, resolveTableWidthPx, tableColumnsArePinned } from "./types.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
 /**
@@ -147,14 +148,14 @@ function applyContextualSpacing(blocks) {
 */
 function layoutDocument(blocks, measures, options) {
 	const initialLayout = layoutDocumentPass(blocks, measures, options);
-	return applySectionVerticalAlignment(options.footnoteHeightById ? reflowFootnoteColumns({
+	return annotateNoteSeparators(applySectionVerticalAlignment(options.footnoteHeightById ? reflowFootnoteColumns({
 		initialLayout,
 		...options.footnoteReservedHeights ? { initialReserveFloors: options.footnoteReservedHeights } : {},
 		runLayout: (reserveFloors) => layoutDocumentPass(blocks, measures, {
 			...options,
 			footnoteReservedHeights: reserveFloors
 		})
-	}) : initialLayout, options.sectionVerticalAlignments);
+	}) : initialLayout, options.sectionVerticalAlignments), blocks, measures, options.noteAreas);
 }
 function layoutDocumentPass(blocks, measures, options) {
 	if (blocks.length !== measures.length) panic(`layoutDocument: expected one measure per block (blocks=${blocks.length}, measures=${measures.length})`);
@@ -208,9 +209,11 @@ function layoutDocumentPass(blocks, measures, options) {
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
 	let renderedBreakState = INITIAL_RENDERED_BREAK_STATE;
+	const noteAreaContinuation = createNoteAreaContinuation(options.noteAreas, paginator);
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
+		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);
@@ -225,13 +228,13 @@ function layoutDocumentPass(blocks, measures, options) {
 			renderedBreakNeedsSnap
 		});
 		if (block.kind !== "pageBreak") {
-			if (breakDecision.pageAdvance === PAGE_ADVANCE.PHYSICAL) paginator.forcePageBreak();
+			if (breakDecision.pageAdvance === PAGE_ADVANCE.PHYSICAL) paginator.forcePageBreak({ coalesceBlankPage: hasPageBreakBefore(block) });
 			else if (breakDecision.pageAdvance === PAGE_ADVANCE.COALESCED) paginator.coalescePageBreak();
 		}
 		renderedBreakState = breakDecision.state;
 		const chain = keepNextChains.get(i);
 		if (chain && !midChainIndices.has(i)) {
-			const chainHeight = calculateChainHeight(chain, blocks, measures);
+			const chainHeight = calculateChainHeight(chain, blocks, measures, paginator.getCurrentState().trailingSpacing);
 			const pageBeforeChainLayout = paginator.getCurrentState().page.number;
 			paginator.ensureFits(chainHeight);
 			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) renderedBreakState = recordReflowBoundary(renderedBreakState, true);
@@ -306,6 +309,7 @@ function layoutDocumentPass(blocks, measures, options) {
 			previousPage: paginator.states[pageBeforeBlockLayout - 1]?.page
 		});
 	}
+	paginator.setPageTopContinuation(void 0);
 	if (paginator.states.length === 0) paginator.getCurrentState();
 	return {
 		pageSize,
@@ -376,6 +380,16 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 	}
 	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();
@@ -400,6 +414,19 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 				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 = [];
@@ -561,13 +588,19 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		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.cantSplit || sourceRow.isHeader || verticallyMergedRows.has(rowIndex)) return false;
+		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;
@@ -955,18 +988,44 @@ function layoutTextBox(block, measure, { paginator, sectionMarginTop, sectionPag
 		paginator.addUnflowedFragment(fragment);
 		return;
 	}
-	const state = paginator.ensureFits(measure.height);
+	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: paginator.getColumnX(state.columnIndex),
+		x: 0,
 		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;
+	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
@@ -1072,4 +1131,4 @@ function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionTyp
 	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, 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, tableColumnsArePinned };
+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 };

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

@@ -1,5 +1,5 @@
 import { ParagraphAttrs } from "./types.js";
 //#region src/layout-engine/justificationCompatibility.d.ts
-declare function resolveJustificationCompatibility(compatibilityMode: number | undefined): NonNullable<ParagraphAttrs["justificationCompatibility"]> | undefined;
+declare const resolveJustificationCompatibility: (compatibilityMode: number | undefined) => NonNullable<ParagraphAttrs["justificationCompatibility"]> | undefined;
 //#endregion
 export { resolveJustificationCompatibility };

package/dist/layout-engine/justificationCompatibility.js

@@ -1,8 +1,12 @@
 //#region src/layout-engine/justificationCompatibility.ts
-const LEGACY_JUSTIFICATION_MAX_COMPATIBILITY_MODE = 14;
-function resolveJustificationCompatibility(compatibilityMode) {
-	if (compatibilityMode === void 0 || compatibilityMode > LEGACY_JUSTIFICATION_MAX_COMPATIBILITY_MODE) return;
-	return { type: "legacy" };
-}
+/**
+* First `compatibilityMode` that fits justified lines with the current rules.
+*
+* Earlier modes keep strict justified fitting. A document that declares no
+* `compatSetting` at all is read with the oldest semantics, so it takes the
+* legacy rule too.
+*/
+const FIRST_MODERN_JUSTIFICATION_COMPATIBILITY_MODE = 15;
+const resolveJustificationCompatibility = (compatibilityMode) => compatibilityMode !== void 0 && compatibilityMode >= FIRST_MODERN_JUSTIFICATION_COMPATIBILITY_MODE ? void 0 : { type: "legacy" };
 //#endregion
 export { resolveJustificationCompatibility };

package/dist/layout-engine/keep-together.d.ts

@@ -30,12 +30,18 @@ declare function computeKeepNextChains(blocks: FlowBlock[]): Map<number, KeepNex
  * Calculate the height needed to keep consecutive paragraph boundaries from
  * breaking across pages.
  *
- * Single-line and `keepLines` members are indivisible, so the reservation must
- * continue through them to the anchor's first line. A multi-line member without
- * `keepLines` may itself split; only its first line is needed to satisfy the
- * preceding member's `keepNext`, and the chain can stop there.
+ * Each successor (later member or the anchor) must bring its minimum
+ * unbreakable opening onto the page: see {@link minimumOpeningLineCount}. When
+ * that opening is the whole paragraph, the successor is indivisible and the
+ * reservation continues through it; otherwise the chain stops after the
+ * opening, because a later split cannot separate it from its predecessor.
+ *
+ * A paragraph measure's `totalHeight` already includes its own spacing before
+ * and after. The chain accounts for spacing separately (collapsing each gap to
+ * the larger side, as the paginator does), so members contribute only their
+ * line advances; otherwise every gap would be reserved twice.
  */
-declare function calculateChainHeight(chain: KeepNextChain, blocks: FlowBlock[], measures: Measure[]): number;
+declare function calculateChainHeight(chain: KeepNextChain, blocks: FlowBlock[], measures: Measure[], incomingSpacing?: number): number;
 /**
  * Get the set of indices that are mid-chain (not chain starters).
  * These should skip the keepNext check since their chain starter already decided.

package/dist/layout-engine/keep-together.js

@@ -1,3 +1,4 @@
+import { measuredLineRangeHeight } from "./lineFlow.js";
 import { collapseParagraphSpacing, isAuthoredEmptyParagraph, isEmptyParagraph } from "./paragraphSpacing.js";
 //#region src/layout-engine/keep-together.ts
 /**
@@ -6,6 +7,8 @@ import { collapseParagraphSpacing, isAuthoredEmptyParagraph, isEmptyParagraph }
 * DOCX paragraphs can have keepNext (keep with next paragraph) and keepLines
 * (keep all lines together) properties that affect pagination.
 */
+/** Lines §17.3.1.44 widow control keeps on each side of a paragraph split. */
+const MIN_WIDOW_CONTROL_SPLIT_LINES = 2;
 /**
 * Whether an empty paragraph is only a structural separator through which a
 * keep-with-next chain may pass. An explicitly styled or directly formatted
@@ -74,23 +77,47 @@ function computeKeepNextChains(blocks) {
 	return chains;
 }
 /**
+* Lines of a paragraph that must share a page with the paragraph before it for
+* a `w:keepNext` link (§17.3.1.15) to hold.
+*
+* - `w:keepLines` (§17.3.1.14): the paragraph never splits, so all of it.
+* - `w:widowControl` (§17.3.1.44): a split leaves at least two lines on each
+*   side, so a paragraph shorter than four lines cannot split at all and a
+*   longer one needs its first two lines.
+* - Otherwise a single line.
+*/
+function minimumOpeningLineCount(block, measure) {
+	const lineCount = measure.lines.length;
+	if (block.attrs?.keepLines === true) return lineCount;
+	if (block.attrs?.widowControl !== false) return lineCount < MIN_WIDOW_CONTROL_SPLIT_LINES * 2 ? lineCount : MIN_WIDOW_CONTROL_SPLIT_LINES;
+	return Math.min(1, lineCount);
+}
+/**
 * Calculate the height needed to keep consecutive paragraph boundaries from
 * breaking across pages.
 *
-* Single-line and `keepLines` members are indivisible, so the reservation must
-* continue through them to the anchor's first line. A multi-line member without
-* `keepLines` may itself split; only its first line is needed to satisfy the
-* preceding member's `keepNext`, and the chain can stop there.
+* Each successor (later member or the anchor) must bring its minimum
+* unbreakable opening onto the page: see {@link minimumOpeningLineCount}. When
+* that opening is the whole paragraph, the successor is indivisible and the
+* reservation continues through it; otherwise the chain stops after the
+* opening, because a later split cannot separate it from its predecessor.
+*
+* A paragraph measure's `totalHeight` already includes its own spacing before
+* and after. The chain accounts for spacing separately (collapsing each gap to
+* the larger side, as the paginator does), so members contribute only their
+* line advances; otherwise every gap would be reserved twice.
 */
-function calculateChainHeight(chain, blocks, measures) {
+function calculateChainHeight(chain, blocks, measures, incomingSpacing = 0) {
 	const firstMemberIndex = chain.memberIndices.at(0);
 	if (firstMemberIndex === void 0) return 0;
 	const firstBlock = blocks[firstMemberIndex];
 	const firstMeasure = measures[firstMemberIndex];
 	if (firstBlock?.kind !== "paragraph" || firstMeasure?.kind !== "paragraph") return 0;
-	let totalHeight = (firstBlock.attrs?.spacing?.before ?? 0) + firstMeasure.totalHeight;
+	let totalHeight = collapseParagraphSpacing({
+		before: firstBlock.attrs?.spacing?.before ?? 0,
+		after: incomingSpacing
+	}) + measuredLineRangeHeight(firstMeasure.lines, 0, firstMeasure.lines.length);
 	let trailingSpacing = firstBlock.attrs?.spacing?.after ?? 0;
-	const startsWithTrailingTableSeparator = blocks[firstMemberIndex - 1]?.kind === "table" && isEmptyParagraph(firstBlock) && !firstBlock.attrs?.keepNext;
 	const successorIndices = [...chain.memberIndices.slice(1)];
 	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
 	for (let index = 0; index < successorIndices.length; index++) {
@@ -103,16 +130,12 @@ function calculateChainHeight(chain, blocks, measures) {
 			before: successorBlock.attrs?.spacing?.before ?? 0,
 			after: trailingSpacing
 		});
-		const firstLine = successorMeasure.lines.at(0);
-		if (!firstLine) return totalHeight;
+		const lineCount = successorMeasure.lines.length;
+		if (lineCount === 0) return totalHeight;
 		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;
-		const isSplittable = successorMeasure.lines.length > 1 && !successorBlock.attrs?.keepLines;
-		if (isAnchor && startsWithTrailingTableSeparator && successorBlock.attrs?.widowControl !== false && successorMeasure.lines.length > 1) {
-			const secondLine = successorMeasure.lines.at(1);
-			return totalHeight + firstLine.lineHeight + (secondLine?.lineHeight ?? 0);
-		}
-		if (isAnchor || isSplittable) return totalHeight + firstLine.lineHeight;
-		totalHeight += successorMeasure.totalHeight;
+		const openingLines = minimumOpeningLineCount(successorBlock, successorMeasure);
+		totalHeight += measuredLineRangeHeight(successorMeasure.lines, 0, openingLines);
+		if (isAnchor || openingLines < lineCount) return totalHeight;
 		trailingSpacing = successorBlock.attrs?.spacing?.after ?? 0;
 	}
 	return totalHeight;

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

@@ -1,6 +1,6 @@
 import { FlowBlock } from "./types.js";
 //#region src/layout-engine/layoutInstrumentation.d.ts
-type LayoutRunReason = "font-ready" | "initial" | "layout-input" | "manual" | "transaction";
+type LayoutRunReason = "font-ready" | "hyphenation-ready" | "initial" | "layout-input" | "manual" | "transaction";
 type LayoutPhase = "flow-blocks" | "header-footer" | "initial-fonts" | "layout-document" | "measure-blocks" | "render-pages";
 type HiddenEditorStateReason = "external-document" | "mount";
 type HiddenEditorPhase = "editor-state" | "editor-view" | "to-prose-doc" | "update-state";
@@ -18,6 +18,10 @@ type LayoutInstrumentation = {
   onHiddenEditorStateCreate?: (event: {
     reason: HiddenEditorStateReason;
   }) => void;
+  onHyphenationDictionaryError?: (event: {
+    dictionary: string;
+    message: string;
+  }) => void;
   onLayoutComplete?: (event: {
     reason: LayoutRunReason;
   }) => void;
@@ -51,9 +55,11 @@ declare function recordMeasureBlockError(blockIndex: number, block: FlowBlock, e
 declare function recordLayoutComplete(reason?: LayoutRunReason): void;
 declare function recordLayoutStart(reason: LayoutRunReason): void;
 declare function recordLayoutError(reason: LayoutRunReason, error: unknown): void;
+/** A dictionary failed to load; layout continues without hyphenating that language. */
+declare function recordHyphenationDictionaryError(dictionary: string, error: Error): void;
 declare function recordLayoutPhase(reason: LayoutRunReason, phase: LayoutPhase, durationMs: number): void;
 declare function recordHiddenEditorStateCreate(reason: HiddenEditorStateReason): void;
 declare function recordHiddenEditorPhase(reason: HiddenEditorStateReason, phase: HiddenEditorPhase, durationMs: number): void;
 declare function recordDocumentLoadPhase(phase: DocumentLoadPhase, durationMs: number): void;
 //#endregion
-export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };
+export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/layoutInstrumentation.js

@@ -25,6 +25,13 @@ function recordLayoutError(reason, error) {
 		reason
 	});
 }
+/** A dictionary failed to load; layout continues without hyphenating that language. */
+function recordHyphenationDictionaryError(dictionary, error) {
+	globalThis.__folioLayoutInstrumentation?.onHyphenationDictionaryError?.({
+		dictionary,
+		message: error.message
+	});
+}
 function recordLayoutPhase(reason, phase, durationMs) {
 	globalThis.__folioLayoutInstrumentation?.onLayoutPhase?.({
 		durationMs,
@@ -49,4 +56,4 @@ function recordDocumentLoadPhase(phase, durationMs) {
 	});
 }
 //#endregion
-export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };
+export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordHyphenationDictionaryError, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/measure/advanceComposition.js

@@ -1,5 +1,5 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
-import { SCRIPT_CLASS, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 //#region src/layout-engine/measure/advanceComposition.ts
 /**
@@ -48,10 +48,7 @@ const glyphAdvanceStyle = (style) => {
 	if (style.kerning !== void 0) result.kerning = style.kerning;
 	return result;
 };
-const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && [...text].some((c) => isEastAsia(c)) || hasComplexScriptFormatting(style) && hasComplexScript(text);
-const isEastAsia = (char) => {
-	return scriptClassOf(char.codePointAt(0)) === SCRIPT_CLASS.eastAsia;
-};
+const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && hasEastAsiaSlotText(text, style.eastAsiaHint) || hasComplexScriptFormatting(style) && hasComplexScript(text);
 /**
 * Width of a string: the advance width used for line breaking, never the
 * painted (ink) extent, which includes overhang a break decision must ignore.
@@ -62,7 +59,7 @@ const composeTextWidth = ({ text, style: source, advanceOf }) => {
 	const transformed = applyMeasurementTextTransform(text, style);
 	const letterSpacing = style.letterSpacing ?? 0;
 	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
-	const glyphWidth = !source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed) ? segmentByScript(transformed).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0) : advanceOf(transformed, style);
+	const glyphWidth = !source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed) ? segmentByScript(transformed, style.eastAsiaHint).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0) : advanceOf(transformed, style);
 	const codePoints = countCodePoints(transformed);
 	return (letterSpacing && codePoints > 1 ? glyphWidth + letterSpacing * (codePoints - 1) : glyphWidth) * horizontalScale;
 };
@@ -97,7 +94,7 @@ const composeRunMeasurement = ({ text, style: source, metrics, advanceOf, advanc
 	let codePointIndex = 0;
 	for (const char of text) {
 		const cp = char.codePointAt(0);
-		const charStyle = perScript ? scriptStyle(style, scriptClassOf(cp)) : style;
+		const charStyle = perScript ? scriptStyle(style, scriptClassOf(cp, style.eastAsiaHint)) : style;
 		let charWidth = shaped.get(codePointIndex) ?? advanceOf(applyMeasurementTextTransform(char, style), charStyle);
 		if (letterSpacing && offset + char.length < text.length) charWidth += letterSpacing;
 		charWidth *= scale;

package/dist/layout-engine/measure/hyphenationDictionaries.d.ts

@@ -0,0 +1,74 @@
+//#region src/layout-engine/measure/hyphenationDictionaries.d.ts
+/**
+ * On-demand hyphenation dictionaries for automatic hyphenation.
+ *
+ * Each `hyphen` pattern set is tens to hundreds of kilobytes of source whose
+ * evaluation builds a pattern trie, and most documents never enable
+ * `w:autoHyphenation`. A dictionary is therefore imported only once measurement
+ * asks to hyphenate a word in its language. Measurement is synchronous, so the
+ * first request starts the import and hyphenates nothing. A layout run wrapped
+ * in {@link collectRequestedHyphenationDictionaries} learns which dictionaries
+ * it lacked, so its own editor can re-run layout on load or report the failure
+ * (`controller/hyphenationReadiness`). Hosts that must lay out correctly on the
+ * first pass (headless layout, tests) await `preloadHyphenationDictionaries`
+ * (`./hyphenationPreload`) before measuring.
+ *
+ * This module sits on every editor's import graph, so it speaks in its own
+ * settled-state union rather than `Result`, keeping the `Result` API out of
+ * adapters' type checks; the preload boundary converts.
+ */
+type HyphenateWord = (text: string) => string;
+declare const HYPHENATION_DICTIONARY_IDS: readonly ["cs", "en-gb", "en-us", "sk"];
+type HyphenationDictionaryId = (typeof HYPHENATION_DICTIONARY_IDS)[number];
+type HyphenationDictionaryLoaders = Readonly<Record<HyphenationDictionaryId, () => Promise<HyphenateWord>>>;
+declare const HyphenationDictionaryError_base: import("better-result").TaggedErrorClass<"HyphenationDictionaryError">;
+declare class HyphenationDictionaryError extends HyphenationDictionaryError_base<{
+  message: string;
+  dictionary: HyphenationDictionaryId;
+  cause: unknown;
+}> {}
+type SettledHyphenationDictionary = Readonly<{
+  status: "loaded";
+  hyphenate: HyphenateWord;
+}> | Readonly<{
+  status: "failed";
+  error: HyphenationDictionaryError;
+}>;
+type HyphenationDictionaryState = Readonly<{
+  status: "unloaded";
+}> | Readonly<{
+  status: "loading";
+  promise: Promise<SettledHyphenationDictionary>;
+}> | SettledHyphenationDictionary;
+/** Compare before and after a measurement to tell whether it lacked a dictionary. */
+declare const getHyphenationDictionaryMisses: () => number;
+/** The dictionary that hyphenates text in `locale`, if one is bundled. */
+declare const hyphenationDictionaryFor: (locale: string | undefined) => HyphenationDictionaryId | undefined;
+/** Changes whenever a dictionary finishes loading, so measurement caches cannot go stale. */
+declare const getHyphenationDictionaryGeneration: () => number;
+/** Load `dictionary` once; later calls share the load or its settled outcome. */
+declare const requestHyphenationDictionary: (dictionary: HyphenationDictionaryId) => Promise<SettledHyphenationDictionary>;
+/**
+ * The loaded hyphenator for `dictionary`, or `undefined` while it is not
+ * available. An unloaded dictionary starts loading, and a missing one is
+ * recorded against the enclosing {@link collectRequestedHyphenationDictionaries}
+ * run; the caller hyphenates nothing now.
+ */
+declare const hyphenatorOrRequest: (dictionary: HyphenationDictionaryId) => HyphenateWord | undefined;
+type CollectedHyphenationDictionaries<T> = {
+  result: T;
+  /** Dictionaries the run needed and did not have: loading or failed. */
+  missing: ReadonlySet<HyphenationDictionaryId>;
+};
+/** Run a synchronous layout pass and report the dictionaries it lacked. */
+declare const collectRequestedHyphenationDictionaries: <T>(run: () => T) => CollectedHyphenationDictionaries<T>;
+/**
+ * Test seam: forget every dictionary so a test observes the unloaded path, and
+ * optionally load through `loaders` (for example, ones that fail) until the
+ * next reset.
+ */
+declare const resetHyphenationDictionaries: (loaders?: HyphenationDictionaryLoaders) => void;
+/** Test seam: which dictionaries have been requested or loaded. */
+declare const hyphenationDictionaryStatus: (dictionary: HyphenationDictionaryId) => HyphenationDictionaryState["status"];
+//#endregion
+export { CollectedHyphenationDictionaries, HyphenateWord, HyphenationDictionaryError, HyphenationDictionaryId, HyphenationDictionaryLoaders, SettledHyphenationDictionary, collectRequestedHyphenationDictionaries, getHyphenationDictionaryGeneration, getHyphenationDictionaryMisses, hyphenationDictionaryFor, hyphenationDictionaryStatus, hyphenatorOrRequest, requestHyphenationDictionary, resetHyphenationDictionaries };