@stll/folio-core 0.47.7 → 0.49.0

package/dist/layout-bridge/engine/selectionRects.js

@@ -4,7 +4,7 @@ import { buildRunFontStyle } from "../../layout-engine/measure/measureHelpers.js
 import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
 import { measureRun } from "../../layout-engine/measure/measureProvider.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "../../layout-engine/measure/tableCellFloating.js";
-import { buildTableCellGrid, buildTableCellPlacements } from "../../layout-engine/measure/tableCellGrid.js";
+import { buildTableCellGrid, buildTableCellPlacements, getTableCellSpacingInsetsY } from "../../layout-engine/measure/tableCellGrid.js";
 import { resolveTableCellPadding } from "../../layout-engine/types.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
@@ -312,7 +312,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 					cellPlacements = buildTableCellPlacements({
 						grid: buildTableCellGrid(tableBlock.rows, tableMeasure.columnWidths.length),
 						columnWidths: tableMeasure.columnWidths,
-						bidi: tableBlock.bidi === true
+						bidi: tableBlock.bidi === true,
+						cellSpacing: tableBlock.cellSpacing
 					});
 					tableCellPlacements.set(tableBlock, cellPlacements);
 				}
@@ -333,7 +334,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 						const contentWidth = getTableCellContentWidth(cell, cellMeasure);
 						const floatingZones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
 						const contentOffsetX = getCellContentOffsetX(cell);
-						const contentOffsetY = getCellContentOffsetY(cell, cellMeasure, rowMeasure.height);
+						const spacing = getTableCellSpacingInsetsY(tableBlock.cellSpacing, rowIndex, cell.rowSpan ?? 1, tableBlock.rows.length);
+						const contentOffsetY = spacing.top + getCellContentOffsetY(cell, cellMeasure, Math.max(0, rowMeasure.height - spacing.top - spacing.bottom));
 						let blockY = 0;
 						for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
 							const cellBlock = cell.blocks[blockIdx];

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

@@ -0,0 +1,10 @@
+//#region src/layout-engine/anchorLayoutInCellCompatibility.d.ts
+/**
+ * `true` when the document's compatibility mode forces every table-cell
+ * anchor to lay out inside its cell, ignoring an authored
+ * `layoutInCell="0"`. `false` means the authored attribute (or its
+ * OOXML default of "confined to the cell") should be honoured as stated.
+ */
+declare const resolveAnchorLayoutInCellCompatibility: (compatibilityMode: number | undefined) => boolean;
+//#endregion
+export { resolveAnchorLayoutInCellCompatibility };

package/dist/layout-engine/anchorLayoutInCellCompatibility.js

@@ -0,0 +1,22 @@
+//#region src/layout-engine/anchorLayoutInCellCompatibility.ts
+/**
+* First `compatibilityMode` that ignores `wp:anchor/@layoutInCell="0"`.
+*
+* From `compatibilityMode` 15 onward, an anchor inside a table cell is laid
+* out in the cell regardless of what `wp:anchor/@layoutInCell` states: the
+* attribute stops opting the anchor out of the cell's coordinate space.
+* Earlier modes still honour an explicit `layoutInCell="0"` and let the
+* anchor position itself relative to the page. A document that declares no
+* `compatSetting` at all is read with the oldest semantics, so it honours
+* the attribute too.
+*/
+const FIRST_ALWAYS_IN_CELL_COMPATIBILITY_MODE = 15;
+/**
+* `true` when the document's compatibility mode forces every table-cell
+* anchor to lay out inside its cell, ignoring an authored
+* `layoutInCell="0"`. `false` means the authored attribute (or its
+* OOXML default of "confined to the cell") should be honoured as stated.
+*/
+const resolveAnchorLayoutInCellCompatibility = (compatibilityMode) => compatibilityMode !== void 0 && compatibilityMode >= FIRST_ALWAYS_IN_CELL_COMPATIBILITY_MODE;
+//#endregion
+export { resolveAnchorLayoutInCellCompatibility };

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, TextBoxGradientFill, 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, TextBoxGradientFill, 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";
@@ -12,9 +13,9 @@ import { assertExhaustiveFlowBlock, findPageIndexContainingPmPos } from "./pmPag
 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 { applySectionVerticalAlignment } from "./sectionVerticalAlignment.js";
-import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak } from "./tableRowBreak.js";
+import { buildTableRowBreakInfo, getRowContinuationSkip, snapRowBreak, tableKeepNextOpeningHeight } 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})`);
@@ -193,6 +194,7 @@ function layoutDocumentPass(blocks, measures, options) {
 		...options.mirrorMargins === true ? { mirrorMargins: true } : {},
 		...options.firstPageMargins !== void 0 ? { firstPageMargins: options.firstPageMargins } : {},
 		...options.sectionEvenPageMargins !== void 0 ? { sectionEvenPageMargins: options.sectionEvenPageMargins } : {},
+		...options.sectionFirstPageMargins !== void 0 ? { sectionFirstPageMargins: options.sectionFirstPageMargins } : {},
 		columns: initialConfig.columns ?? DEFAULT_COLUMNS,
 		pageNumbering: initialConfig.pageNumbering,
 		...options.footnoteReservedHeights !== void 0 ? { footnoteReservedHeights: options.footnoteReservedHeights } : {},
@@ -208,9 +210,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 +229,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, tableKeepNextOpeningHeight);
 			const pageBeforeChainLayout = paginator.getCurrentState().page.number;
 			paginator.ensureFits(chainHeight);
 			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) renderedBreakState = recordReflowBoundary(renderedBreakState, true);
@@ -306,6 +310,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 +381,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 +415,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 +589,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 +989,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
@@ -1011,6 +1071,32 @@ function startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex) {
 	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
@@ -1019,14 +1105,16 @@ function startSectionInPlace(paginator, nextSectionConfig, nextSectionIndex) {
 */
 function handleSectionBreak(_block, paginator, nextSectionConfig, nextSectionType, nextSectionIndex) {
 	switch (nextSectionType) {
-		case "nextPage":
+		case "nextPage": {
 			paginator.updatePageLayout(nextSectionConfig.pageSize, nextSectionConfig.margins);
 			if (nextSectionIndex !== void 0) paginator.startSection({
 				sectionIndex: nextSectionIndex,
 				pageNumbering: nextSectionConfig.pageNumbering
 			});
-			paginator.forcePageBreak({ coalesceBlankPage: true });
+			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);
@@ -1072,4 +1160,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

@@ -1,4 +1,4 @@
-import { FlowBlock, Measure } from "./types.js";
+import { FlowBlock, Measure, TableBlock, TableMeasure } from "./types.js";
 //#region src/layout-engine/keep-together.d.ts
 /**
  * A chain of paragraphs that Word keeps with following content. This includes
@@ -30,12 +30,21 @@ 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 table anchor contributes `tableOpeningHeight`: the part of the table
+ * that must start on the same page as the paragraph before it.
+ *
+ * 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, tableOpeningHeight?: (block: TableBlock, measure: TableMeasure) => 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,50 @@ 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 table anchor contributes `tableOpeningHeight`: the part of the table
+* that must start on the same page as the paragraph before it.
+*
+* 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, tableOpeningHeight) {
 	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++) {
@@ -98,21 +128,18 @@ function calculateChainHeight(chain, blocks, measures) {
 		if (successorIndex === void 0) continue;
 		const successorBlock = blocks[successorIndex];
 		const successorMeasure = measures[successorIndex];
+		if (tableOpeningHeight !== void 0 && successorBlock?.kind === "table" && successorMeasure?.kind === "table" && successorBlock.floating === void 0) return totalHeight + trailingSpacing + tableOpeningHeight(successorBlock, successorMeasure);
 		if (successorBlock?.kind !== "paragraph" || successorMeasure?.kind !== "paragraph") return totalHeight;
 		totalHeight += collapseParagraphSpacing({
 			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 };