@stll/folio-core 0.4.0 → 0.6.0

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

@@ -1,10 +1,16 @@
 //#region src/layout-engine/keep-together.ts
+function isVisuallyEmptyParagraph(block) {
+	if (block.runs.length === 0) return true;
+	if (block.runs.length !== 1) return false;
+	const run = block.runs.at(0);
+	return run?.kind === "text" && run.text === "";
+}
 /**
 * Pre-scan blocks to find all keepNext chains.
 *
-* A keepNext chain is a sequence of consecutive paragraphs with keepNext=true,
-* followed by an anchor paragraph (the first non-keepNext paragraph).
-* The entire chain must stay on the same page as the anchor's first line.
+* A keepNext chain starts with a paragraph whose keepNext=true and continues
+* through further keepNext paragraphs and structural empty separators. The
+* first visible non-keepNext paragraph is its anchor.
 *
 * Returns a map from chain start index to chain info.
 */
@@ -22,7 +28,8 @@ function computeKeepNextChains(blocks) {
 			const nextBlock = blocks[j];
 			if (nextBlock.kind === "sectionBreak" || nextBlock.kind === "pageBreak" || nextBlock.kind === "columnBreak") break;
 			if (nextBlock.kind !== "paragraph") break;
-			if (nextBlock.attrs?.keepNext) {
+			const nextPara = nextBlock;
+			if (nextPara.attrs?.keepNext || isVisuallyEmptyParagraph(nextPara)) {
 				memberIndices.push(j);
 				endIndex = j;
 				processed.add(j);
@@ -44,30 +51,38 @@ function computeKeepNextChains(blocks) {
 	return chains;
 }
 /**
-* Calculate the total height needed to keep a chain together.
+* Calculate the height needed to keep consecutive paragraph boundaries from
+* breaking across pages.
 *
-* Includes all chain members plus the first line of the anchor paragraph.
+* 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.
 */
 function calculateChainHeight(chain, blocks, measures) {
-	let totalHeight = 0;
-	for (const memberIndex of chain.memberIndices) {
-		const block = blocks[memberIndex];
-		const measure = measures[memberIndex];
-		if (!block || !measure || block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
-		const para = block;
-		const paraMeasure = measure;
-		const spacingBefore = para.attrs?.spacing?.before ?? 0;
-		totalHeight += spacingBefore;
-		totalHeight += paraMeasure.totalHeight;
-		const spacingAfter = para.attrs?.spacing?.after ?? 0;
-		totalHeight += spacingAfter;
-	}
-	if (chain.anchorIndex !== -1) {
-		const anchorMeasure = measures[chain.anchorIndex];
-		if (anchorMeasure?.kind === "paragraph") {
-			const anchorPara = anchorMeasure;
-			if (anchorPara.lines.length > 0) totalHeight += anchorPara.lines[0].lineHeight;
-		}
+	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 trailingSpacing = firstBlock.attrs?.spacing?.after ?? 0;
+	const successorIndices = [...chain.memberIndices.slice(1)];
+	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
+	for (let index = 0; index < successorIndices.length; index++) {
+		const successorIndex = successorIndices[index];
+		if (successorIndex === void 0) continue;
+		const successorBlock = blocks[successorIndex];
+		const successorMeasure = measures[successorIndex];
+		if (successorBlock?.kind !== "paragraph" || successorMeasure?.kind !== "paragraph") return totalHeight;
+		totalHeight += Math.max(trailingSpacing, successorBlock.attrs?.spacing?.before ?? 0);
+		const firstLine = successorMeasure.lines.at(0);
+		if (!firstLine) return totalHeight;
+		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;
+		const isSplittable = successorMeasure.lines.length > 1 && !successorBlock.attrs?.keepLines;
+		if (isAnchor || isSplittable) return totalHeight + firstLine.lineHeight;
+		totalHeight += successorMeasure.totalHeight;
+		trailingSpacing = successorBlock.attrs?.spacing?.after ?? 0;
 	}
 	return totalHeight;
 }

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

@@ -5,7 +5,12 @@ type LayoutRunReason = "font-ready" | "initial" | "layout-input" | "manual" | "t
 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";
+type DocumentLoadPhase = "docx-parse";
 type LayoutInstrumentation = {
+  onDocumentLoadPhase?: (event: {
+    durationMs: number;
+    phase: DocumentLoadPhase;
+  }) => void;
   onHiddenEditorPhase?: (event: {
     durationMs: number;
     phase: HiddenEditorPhase;
@@ -21,6 +26,9 @@ type LayoutInstrumentation = {
     message: string;
     reason: LayoutRunReason;
   }) => void;
+  onLayoutStart?: (event: {
+    reason: LayoutRunReason;
+  }) => void;
   onLayoutPhase?: (event: {
     durationMs: number;
     phase: LayoutPhase;
@@ -42,9 +50,11 @@ declare global {
 declare function recordMeasureBlock(blockIndex: number, block: FlowBlock): void;
 declare function recordMeasureBlockError(blockIndex: number, block: FlowBlock, error: unknown): void;
 declare function recordLayoutComplete(reason?: LayoutRunReason): void;
+declare function recordLayoutStart(reason: LayoutRunReason): void;
 declare function recordLayoutError(reason: LayoutRunReason, error: unknown): 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 { HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };
+export { DocumentLoadPhase, HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/layoutInstrumentation.js

@@ -15,6 +15,9 @@ function recordMeasureBlockError(blockIndex, block, error) {
 function recordLayoutComplete(reason = "manual") {
 	globalThis.__folioLayoutInstrumentation?.onLayoutComplete?.({ reason });
 }
+function recordLayoutStart(reason) {
+	globalThis.__folioLayoutInstrumentation?.onLayoutStart?.({ reason });
+}
 function recordLayoutError(reason, error) {
 	const message = error instanceof Error ? error.message : String(error);
 	globalThis.__folioLayoutInstrumentation?.onLayoutError?.({
@@ -39,5 +42,11 @@ function recordHiddenEditorPhase(reason, phase, durationMs) {
 		reason
 	});
 }
+function recordDocumentLoadPhase(phase, durationMs) {
+	globalThis.__folioLayoutInstrumentation?.onDocumentLoadPhase?.({
+		durationMs,
+		phase
+	});
+}
 //#endregion
-export { recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };
+export { recordDocumentLoadPhase, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordLayoutStart, recordMeasureBlock, recordMeasureBlockError };

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

@@ -1,6 +1,7 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
 import { bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
 //#region src/layout-engine/measure/measureBlocks.ts
@@ -80,8 +81,8 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
 	return spacingBefore + maxImageHeight + spacingAfter;
 }
-function getTableCellVerticalBorderHeight(cell) {
-	return (cell?.borders?.top?.width ?? 0) + (cell?.borders?.bottom?.width ?? 0);
+function getTableCellVerticalBorderHeight(cell, isFirstRow) {
+	return (isFirstRow ? cell?.borders?.top?.width ?? 0 : 0) + (cell?.borders?.bottom?.width ?? 0);
 }
 function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	const DEFAULT_CELL_PADDING_X = 7;
@@ -118,6 +119,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			while (occupied.has(colIdx)) colIdx++;
 		}
 	}
+	const columnsPinned = tableColumnsArePinned(tableBlock);
 	const rows = tableBlock.rows.map((row, rowIdx) => {
 		let columnIndex = 0;
 		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
@@ -133,7 +135,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 				const padLeft = cell.padding?.left ?? DEFAULT_CELL_PADDING_X;
 				const padRight = cell.padding?.right ?? DEFAULT_CELL_PADDING_X;
 				const cellContentWidth = Math.max(1, cellWidth - padLeft - padRight);
-				const measureWidth = cell.noWrap ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
+				const measureWidth = cell.noWrap === true && !columnsPinned ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
 				const cellMeasure = {
 					blocks: cell.blocks.map((b) => measureBlock(b, measureWidth, void 0, void 0, fieldValues)),
 					width: cellWidth,
@@ -160,6 +162,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
+		let maxBorderHeight = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
 			const cell = row.cells[cellIdx];
 			const sourceCell = sourceRowCells?.[cellIdx];
@@ -173,14 +176,38 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const padTop = sourceCell?.padding?.top ?? DEFAULT_CELL_PADDING_Y;
 			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
 			cell.height += padTop + padBottom;
-			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + getTableCellVerticalBorderHeight(sourceCell));
+			if ((sourceCell?.rowSpan ?? 1) > 1) continue;
+			const borderHeight = getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0);
+			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
+			maxBorderHeight = Math.max(maxBorderHeight, borderHeight);
 		}
 		const explicitHeight = sourceRow?.height;
 		const heightRule = sourceRow?.heightRule;
 		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;
-		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight);
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxBorderHeight);
 		else row.height = maxCellHeightWithBorders;
 	}
+	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+		const sourceRow = tableBlock.rows[rowIdx];
+		const measuredRow = rows[rowIdx];
+		if (!sourceRow || !measuredRow) continue;
+		for (let cellIdx = 0; cellIdx < sourceRow.cells.length; cellIdx++) {
+			const sourceCell = sourceRow.cells[cellIdx];
+			const measuredCell = measuredRow.cells[cellIdx];
+			const rowSpan = sourceCell?.rowSpan ?? 1;
+			if (!sourceCell || !measuredCell || rowSpan <= 1) continue;
+			const spanEnd = Math.min(rows.length, rowIdx + rowSpan);
+			let combinedHeight = 0;
+			for (let spannedRowIdx = rowIdx; spannedRowIdx < spanEnd; spannedRowIdx++) combinedHeight += rows[spannedRowIdx]?.height ?? 0;
+			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0) - combinedHeight;
+			if (deficit <= 0) continue;
+			for (let spannedRowIdx = spanEnd - 1; spannedRowIdx >= rowIdx; spannedRowIdx--) {
+				if (tableBlock.rows[spannedRowIdx]?.heightRule === "exact") continue;
+				rows[spannedRowIdx].height += deficit;
+				break;
+			}
+		}
+	}
 	const totalHeight = rows.reduce((h, r) => h + r.height, 0);
 	const totalWidth = columnWidths.reduce((w, cw) => w + cw, 0) || explicitWidthPx || contentWidth;
 	return {
@@ -197,6 +224,7 @@ function perBlockNumberValue(value, blockIndex, fallback) {
 }
 function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
 	const zones = [];
+	const textBoxGroupAnchors = /* @__PURE__ */ new Map();
 	const defaultMarginTop = Array.isArray(marginTop) ? marginTop[0] ?? 0 : marginTop;
 	const pageHeightInput = pageGeometry?.pageHeight ?? 0;
 	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
@@ -286,28 +314,31 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		const block = blocks[blockIndex];
 		if (block.kind !== "textBox") continue;
 		const tb = block;
-		if (!floatingTextBoxReservesBand(tb)) continue;
+		if (!floatingTextBoxReservesBand(tb) || tb.position === void 0) continue;
 		const v = tb.position?.vertical;
-		if (!isPageFrameRelativeAnchor(v?.relativeTo)) continue;
 		const height = measureTextBoxBlock(tb).height;
 		const distTop = tb.distTop ?? 0;
 		const distBottom = tb.distBottom ?? 0;
 		const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
-		const rawTop = bandTopContentY(v, {
+		const pageFrameRelative = isPageFrameRelativeAnchor(v?.relativeTo);
+		const rawTop = pageFrameRelative ? bandTopContentY(v, {
 			pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
 			marginTop: blockMarginTop,
 			marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
 			boxHeight: height
-		});
+		}) : emuToPixels(v?.posOffset ?? 0);
 		const bottomY = rawTop + height + distBottom;
 		if (bottomY <= 0) continue;
+		const groupId = getTextBoxGroupId(tb);
+		const anchorBlockIndex = groupId ? textBoxGroupAnchors.get(groupId) ?? blockIndex : blockIndex;
+		if (groupId && !textBoxGroupAnchors.has(groupId)) textBoxGroupAnchors.set(groupId, blockIndex);
 		zones.push({
 			leftMargin: 0,
 			rightMargin: 0,
 			topY: Math.max(0, rawTop - distTop),
 			bottomY,
-			anchorBlockIndex: blockIndex,
-			isMarginRelative: true,
+			anchorBlockIndex,
+			...pageFrameRelative ? { isMarginRelative: true } : {},
 			fullWidthBlock: true
 		});
 	}
@@ -367,14 +398,15 @@ function measureTextBoxBlock(tb, fieldValues) {
 	};
 }
 /**
-* `true` for a section break that starts a new page (`nextPage`/`evenPage`/
-* `oddPage`, or an unspecified type, which the layout treats as `nextPage`).
-* A `continuous` break stays on the current page, so it does not open a fresh
-* page frame. Used by `measureBlocks` to reset the running Y for a page-pinned
-* band that lands right after the break. eigenpal #694.
+* `true` for a section break that explicitly starts a new page
+* (`nextPage`/`evenPage`/`oddPage`). An absent type follows
+* `scheduleSectionBreak` and stays continuous, so measurement must retain any
+* active exclusion zones across it. Used by `measureBlocks` to reset the
+* running Y for a page-pinned band that lands right after the break.
+* eigenpal #694.
 */
 function isNextPageSectionBreak(block) {
-	return block.kind === "sectionBreak" && block.type !== "continuous";
+	return block.kind === "sectionBreak" && block.type !== void 0 && block.type !== "continuous";
 }
 /**
 * Measure all blocks with floating image support.

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

@@ -22,8 +22,10 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
 const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .025;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
+const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
 /**
 * Find the longest prefix of `text` that fits within `maxWidth` pixels.
@@ -270,8 +272,16 @@ function hasFollowingTabOnLine(runs, tabIndex) {
 	}
 	return false;
 }
-function canClampTabToRightEdge(alignment, currentLineWidth) {
-	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE;
+function hasPriorTabOnLine(runs, tabIndex) {
+	for (let i = tabIndex - 1; i >= 0; i--) {
+		const prior = runs[i];
+		if (!prior || isLineBreakRun(prior) || isImageRun(prior) && isBlockLayoutImageRun(prior)) break;
+		if (isTabRun(prior)) return true;
+	}
+	return false;
+}
+function canClampTabToRightEdge(alignment, currentLineWidth, hasPriorTab, followingWidth, availableWidth) {
+	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE && (hasPriorTab || followingWidth <= availableWidth);
 	return true;
 }
 /**
@@ -319,10 +329,18 @@ function uppercaseLetterRatio(text) {
 	}
 	return letters === 0 ? 0 : uppercase / letters;
 }
-function justifyShrinkToleranceRatio(block) {
+function justifyShrinkToleranceRatio(block, isFirstLine, regularSpaceCount, nonBreakingSpaceCount) {
+	if (block.attrs?.listMarker !== void 0) {
+		if ((block.attrs.indent?.hanging ?? 0) <= DEFAULT_LIST_HANGING_INDENT_PX) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
+		if (isFirstLine) return JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO;
+		const totalSpaces = regularSpaceCount + nonBreakingSpaceCount;
+		if (totalSpaces === 0) return JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO;
+		return Math.max(JUSTIFY_SHRINK_TOLERANCE_RATIO, JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO * (regularSpaceCount / totalSpaces));
+	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
 	const hasTabRuns = block.runs.some(isTabRun);
-	if (hasTabStops || hasTabRuns) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
+	if (!isFirstLine && hasTabRuns && !hasTabStops) return JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO;
+	if ((isFirstLine || hasTabStops) && (hasTabStops || hasTabRuns)) return (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO;
 	if (uppercaseLetterRatio(block.runs.map((run) => isTextRun(run) ? run.text ?? "" : "").join("")) > ALL_CAPS_RATIO_THRESHOLD) return JUSTIFY_SHRINK_TOLERANCE_RATIO;
 	return JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO;
 }
@@ -412,7 +430,6 @@ function measureParagraph(block, maxWidth, options) {
 	const attrs = block.attrs;
 	const spacing = attrs?.spacing;
 	const isJustifiedParagraph = attrs?.alignment === "justify";
-	const justifyToleranceRatio = justifyShrinkToleranceRatio(block);
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -506,6 +523,9 @@ function measureParagraph(block, maxWidth, options) {
 		toRun: 0,
 		toChar: 0,
 		width: 0,
+		trailingWhitespaceWidth: 0,
+		regularSpaceCount: 0,
+		nonBreakingSpaceCount: 0,
 		maxFontSize: DEFAULT_FONT_SIZE,
 		maxFontMetrics: null,
 		maxImageHeightPx: 0,
@@ -552,7 +572,7 @@ function measureParagraph(block, maxWidth, options) {
 			fromChar: currentLine.fromChar,
 			toRun: currentLine.toRun,
 			toChar: currentLine.toChar,
-			width: currentLine.width,
+			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography
 		};
 		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
@@ -572,17 +592,21 @@ function measureParagraph(block, maxWidth, options) {
 		const estimatedLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
 		skipObstructingFloats(estimatedLineHeight, bodyContentWidth);
 		const floatingMargins = getFloatingMargins(cumulativeHeight, estimatedLineHeight, floatingZones, paragraphYOffset);
+		const adjustedWidth = Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth));
 		currentLine = {
 			fromRun: runIndex,
 			fromChar: charIndex,
 			toRun: runIndex,
 			toChar: charIndex,
 			width: 0,
+			trailingWhitespaceWidth: 0,
+			regularSpaceCount: 0,
+			nonBreakingSpaceCount: 0,
 			maxFontSize: DEFAULT_FONT_SIZE,
 			maxFontMetrics: null,
 			maxImageHeightPx: 0,
 			maxMathHeightPx: 0,
-			availableWidth: Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth)),
+			availableWidth: adjustedWidth,
 			leftOffset: floatingMargins.leftMargin,
 			rightOffset: floatingMargins.rightMargin,
 			...floatingMargins.segments?.length ? { segmentZones: floatingMargins.segments } : {}
@@ -620,6 +644,7 @@ function measureParagraph(block, maxWidth, options) {
 			const contentX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + lineX;
 			const tabResult = calculateTabWidth(contentX, {
 				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
+				...attrs?.defaultTabStopTwips !== void 0 ? { defaultTabInterval: attrs.defaultTabStopTwips } : {},
 				leftIndent: pixelsToTwips(indentLeft)
 			}, {
 				followingWidth,
@@ -627,12 +652,13 @@ function measureParagraph(block, maxWidth, options) {
 			});
 			let tabWidth = tabResult.width;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			if (!hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
+			if (!hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width, hasPriorTabOnLine(runs, runIndex), followingWidth, currentLine.availableWidth) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + WIDTH_TOLERANCE) tabWidth = Math.max(1, lineRightEdgeX - contentX - followingWidth);
 			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
 			}
 			currentLine.width += tabWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -662,6 +688,7 @@ function measureParagraph(block, maxWidth, options) {
 			const imageFootprintPx = imageHeight + (run.distTop ?? 0) + (run.distBottom ?? 0);
 			if (imageFootprintPx > currentLine.maxImageHeightPx) currentLine.maxImageHeightPx = imageFootprintPx;
 			currentLine.width += imageWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -676,6 +703,7 @@ function measureParagraph(block, maxWidth, options) {
 				updateMaxFont(style);
 			}
 			currentLine.width += fieldWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -696,6 +724,7 @@ function measureParagraph(block, maxWidth, options) {
 			}
 			if (mathFootprintPx > currentLine.maxMathHeightPx) currentLine.maxMathHeightPx = mathFootprintPx;
 			currentLine.width += mathWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -720,13 +749,17 @@ function measureParagraph(block, maxWidth, options) {
 					break;
 				}
 				const word = text.slice(charIndex, nextBreak);
-				const wordWidth = measureTextWidth(word, style);
-				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyToleranceRatio) : WIDTH_TOLERANCE;
+				const measuredWord = trimTrailingSpacesAndTabs(word);
+				const wordWidth = measureTextWidth(measuredWord, style);
+				const fullWordWidth = measureTextWidth(word, style);
+				const regularSpaces = measuredWord.split(" ").length - 1;
+				const nonBreakingSpaces = measuredWord.split("\xA0").length - 1;
+				const widthTolerance = isJustifiedParagraph ? Math.max(WIDTH_TOLERANCE, currentLine.availableWidth * justifyShrinkToleranceRatio(block, lines.length === 0, currentLine.regularSpaceCount + regularSpaces, currentLine.nonBreakingSpaceCount + nonBreakingSpaces)) : WIDTH_TOLERANCE;
 				if (wordWidth > currentLine.availableWidth + widthTolerance) {
 					let chunkStart = 0;
-					while (chunkStart < word.length) {
+					while (chunkStart < measuredWord.length) {
 						const spaceLeft = currentLine.availableWidth - currentLine.width + WIDTH_TOLERANCE;
-						let bestEnd = findMaxFittingLength(word.slice(chunkStart), style, spaceLeft);
+						let bestEnd = findMaxFittingLength(measuredWord.slice(chunkStart), style, spaceLeft);
 						if (bestEnd === 0) {
 							if (currentLine.width > 0) {
 								startNewLine(runIndex, charIndex + chunkStart);
@@ -736,16 +769,26 @@ function measureParagraph(block, maxWidth, options) {
 							bestEnd = 1;
 						}
 						const chunkEnd = chunkStart + bestEnd;
-						const chunkWidth = measureTextWidth(word.slice(chunkStart, chunkEnd), style);
+						const chunk = measuredWord.slice(chunkStart, chunkEnd);
+						const chunkWidth = measureTextWidth(chunk, style);
 						currentLine.width += chunkWidth;
+						currentLine.trailingWhitespaceWidth = chunkWidth - measureTextWidth(trimTrailingSpacesAndTabs(chunk), style);
+						currentLine.regularSpaceCount += chunk.split(" ").length - 1;
+						currentLine.nonBreakingSpaceCount += chunk.split("\xA0").length - 1;
 						currentLine.toRun = runIndex;
 						currentLine.toChar = charIndex + chunkEnd;
 						chunkStart = chunkEnd;
-						if (chunkStart < word.length) {
+						if (chunkStart < measuredWord.length) {
 							startNewLine(runIndex, charIndex + chunkStart);
 							updateMaxFont(lineHeightStyle);
 						}
 					}
+					const trailingWhitespaceWidth = fullWordWidth - wordWidth;
+					currentLine.width += trailingWhitespaceWidth;
+					currentLine.trailingWhitespaceWidth = trailingWhitespaceWidth;
+					currentLine.regularSpaceCount += word.split(" ").length - 1;
+					currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
+					currentLine.toChar = nextBreak;
 					charIndex = nextBreak;
 					continue;
 				}
@@ -755,7 +798,10 @@ function measureParagraph(block, maxWidth, options) {
 					startNewLine(runIndex, charIndex);
 					updateMaxFont(lineHeightStyle);
 				}
-				currentLine.width += wordWidth;
+				currentLine.width += fullWordWidth;
+				currentLine.trailingWhitespaceWidth = fullWordWidth - wordWidth;
+				currentLine.regularSpaceCount += word.split(" ").length - 1;
+				currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
 				currentLine.toRun = runIndex;
 				currentLine.toChar = nextBreak;
 				charIndex = nextBreak;

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

@@ -27,7 +27,8 @@ type PaginatorOptions = {
     w: number;
     h: number;
   }; /** Page margins. */
-  margins: PageMargins;
+  margins: PageMargins; /** Swap left/right margins on even physical pages. */
+  mirrorMargins?: boolean;
   /**
    * Margins applied only to the very first page (page 1) of the paginator.
    * Used when a `<w:titlePg/>`-enabled section needs different margins for

package/dist/layout-engine/paginator.js

@@ -46,7 +46,7 @@ function createPaginator(options) {
 	}
 	function currentPageUsesActiveLayout(state) {
 		if (pendingPageSize || pendingMargins) return false;
-		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, margins);
+		return arePageSizesEqual(state.page.size, pageSize) && areMarginsEqual(state.page.margins, getPageMargins(state.page.number));
 	}
 	if (getContentHeight() <= 0) panic("Paginator: page size and margins yield no content area");
 	let columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
@@ -62,14 +62,20 @@ function createPaginator(options) {
 		recalculateColumnWidth();
 	}
 	function getPageMargins(pageNumber) {
-		return pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
+		if (options.mirrorMargins === true && pageNumber % 2 === 0) return {
+			...pageMargins,
+			left: pageMargins.right,
+			right: pageMargins.left
+		};
+		return pageMargins;
 	}
 	let columnRegionTop = margins.top;
 	/**
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		return margins.left + columnIndex * (columnWidth + columns.gap);
+		return (states.at(-1)?.page.margins.left ?? getPageMargins(1).left) + columnIndex * (columnWidth + columns.gap);
 	}
 	/**
 	* Create a new page and add it to the list.

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

@@ -0,0 +1,7 @@
+import { TextBoxBlock } from "./types.js";
+
+//#region src/layout-engine/textBoxGroup.d.ts
+declare const setTextBoxGroupId: (textBox: TextBoxBlock, groupId: string) => void;
+declare const getTextBoxGroupId: (textBox: TextBoxBlock) => string | undefined;
+//#endregion
+export { getTextBoxGroupId, setTextBoxGroupId };

package/dist/layout-engine/textBoxGroup.js

@@ -0,0 +1,8 @@
+//#region src/layout-engine/textBoxGroup.ts
+const textBoxGroupIds = /* @__PURE__ */ new WeakMap();
+const setTextBoxGroupId = (textBox, groupId) => {
+	textBoxGroupIds.set(textBox, groupId);
+};
+const getTextBoxGroupId = (textBox) => textBoxGroupIds.get(textBox);
+//#endregion
+export { getTextBoxGroupId, setTextBoxGroupId };