@stll/folio-core 0.3.1 → 0.5.0

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
@@ -71,12 +72,17 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	}
 	let maxImageHeight = 0;
 	for (const run of inlineImageRuns) maxImageHeight = Math.max(maxImageHeight, run.height);
+	if (inlineImageRuns.length === 1) {
+		const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
+		const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
+		return spacingBefore + maxImageHeight + spacingAfter;
+	}
 	const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
 	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;
@@ -113,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();
@@ -128,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,
@@ -143,8 +150,19 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	});
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
 		const row = rows[rowIdx];
+		const sourceRow = tableBlock.rows[rowIdx];
+		if (sourceRow?.hidden) {
+			row.height = 0;
+			row.cells = sourceRow.cells.map(() => ({
+				blocks: [],
+				width: 0,
+				height: 0
+			}));
+			continue;
+		}
 		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];
@@ -158,13 +176,14 @@ 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));
+			const borderHeight = getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0);
+			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
+			maxBorderHeight = Math.max(maxBorderHeight, borderHeight);
 		}
-		const sourceRow = tableBlock.rows[rowIdx];
 		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;
 	}
 	const totalHeight = rows.reduce((h, r) => h + r.height, 0);
@@ -183,6 +202,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;
@@ -272,28 +292,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
 		});
 	}
@@ -353,14 +376,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

@@ -21,6 +21,12 @@ const DEFAULT_FONT_SIZE = 11;
 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.
 * Returns the number of characters that fit (at least 1 if `forceMin` is true).
@@ -266,6 +272,18 @@ function hasFollowingTabOnLine(runs, tabIndex) {
 	}
 	return false;
 }
+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;
+}
 /**
 * Width of the inline content preceding the first `.` in the runs that follow
 * a tab, used to anchor `decimal` tab stops. Mirrors `getTextAfterTab` +
@@ -299,6 +317,33 @@ function measureDecimalPrefixWidthAfterTab(runs, tabIndex, fieldValues) {
 function isSpaceOrTab(char) {
 	return char === " " || char === "	";
 }
+function uppercaseLetterRatio(text) {
+	let letters = 0;
+	let uppercase = 0;
+	for (const char of text) {
+		const lower = char.toLocaleLowerCase();
+		const upper = char.toLocaleUpperCase();
+		if (lower === upper) continue;
+		letters++;
+		if (char === upper) uppercase++;
+	}
+	return letters === 0 ? 0 : uppercase / letters;
+}
+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 (!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;
+}
 function trimTrailingSpacesAndTabs(text) {
 	let end = text.length;
 	while (end > 0) {
@@ -384,6 +429,7 @@ function measureParagraph(block, maxWidth, options) {
 	const runs = block.runs;
 	const attrs = block.attrs;
 	const spacing = attrs?.spacing;
+	const isJustifiedParagraph = attrs?.alignment === "justify";
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -477,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,
@@ -523,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;
@@ -543,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 } : {}
@@ -589,20 +642,23 @@ function measureParagraph(block, maxWidth, options) {
 			const lineX = currentLine.width + currentLine.leftOffset;
 			const isFirstLine = lines.length === 0;
 			const contentX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + lineX;
-			let tabWidth = calculateTabWidth(contentX, {
+			const tabResult = calculateTabWidth(contentX, {
 				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
+				...attrs?.defaultTabStopTwips !== void 0 ? { defaultTabInterval: attrs.defaultTabStopTwips } : {},
 				leftIndent: pixelsToTwips(indentLeft)
 			}, {
 				followingWidth,
 				decimalPrefixWidth
-			}).width;
+			});
+			let tabWidth = tabResult.width;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			if (!hasFollowingTabOnLine(runs, runIndex) && (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;
@@ -632,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;
@@ -646,6 +703,7 @@ function measureParagraph(block, maxWidth, options) {
 				updateMaxFont(style);
 			}
 			currentLine.width += fieldWidth;
+			currentLine.trailingWhitespaceWidth = 0;
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 1;
 			continue;
@@ -666,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;
@@ -690,12 +749,17 @@ function measureParagraph(block, maxWidth, options) {
 					break;
 				}
 				const word = text.slice(charIndex, nextBreak);
-				const wordWidth = measureTextWidth(word, style);
-				if (wordWidth > currentLine.availableWidth + 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);
@@ -705,26 +769,39 @@ 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;
 				}
 				const rawGlueWidth = nextBreak === text.length && word.length > 0 && !isBreakChar(word[word.length - 1]) ? trailingGlueWidths[runIndex] ?? 0 : 0;
-				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + WIDTH_TOLERANCE ? rawGlueWidth : 0;
-				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
+				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance) {
 					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 };

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

@@ -3,7 +3,7 @@ import { ImagePosition, ImageWrap, SdtProperties, SdtType, TableWidthType } from
 
 //#region src/layout-engine/types.d.ts
 declare namespace types_d_exports {
-  export { 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, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun };
+  export { 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, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned };
 }
 /**
  * Unique identifier for a block in the document.
@@ -303,7 +303,9 @@ type ParagraphAttrs = {
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
-  pageBreakBefore?: boolean;
+  widowControl?: boolean;
+  pageBreakBefore?: boolean; /** Word's cached pagination hint (`w:lastRenderedPageBreak`). */
+  renderedPageBreakBefore?: boolean;
   styleId?: string;
   contextualSpacing?: boolean;
   /**
@@ -432,6 +434,7 @@ type TableRow = {
   height?: number;
   heightRule?: "auto" | "atLeast" | "exact";
   isHeader?: boolean;
+  hidden?: boolean;
 };
 /**
  * Floating table positioning info (pixel values).
@@ -457,7 +460,14 @@ type TableBlock = {
   rows: TableRow[];
   columnWidths?: number[]; /** Table width value (twips for dxa, 50ths of percent for pct). */
   width?: number; /** Table width type ('auto', 'pct', 'dxa', 'nil'). */
-  widthType?: TableWidthType; /** Table horizontal alignment */
+  widthType?: TableWidthType;
+  /**
+   * Table layout algorithm (`w:tblLayout`). "fixed" pins columns to their grid
+   * widths; "autofit" (the default when absent) lets Word size columns to
+   * content. Consulted alongside `widthType` to decide whether `w:noWrap` cells
+   * can be honored (see `tableColumnsArePinned`).
+   */
+  layout?: "fixed" | "autofit"; /** Table horizontal alignment */
   justification?: "left" | "center" | "right"; /** Table indent from left margin (in pixels, from w:tblInd) */
   indent?: number; /** Right-to-left column order (w:bidiVisual): logical column 0 paints on the right. */
   bidi?: boolean; /** Floating table properties (pixel values). */
@@ -518,6 +528,7 @@ type SectionBreakBlock = {
 };
 type PageHeaderFooterRefs = {
   titlePg?: boolean;
+  evenAndOddHeaders?: boolean;
   headerDefault?: string;
   headerFirst?: string;
   headerEven?: string;
@@ -900,7 +911,8 @@ type LayoutOptions = {
   headerContentHeights?: HeaderFooterContentHeights; /** Footer content heights by variant. */
   footerContentHeights?: HeaderFooterContentHeights; /** Whether section has different first page header/footer. */
   titlePage?: boolean; /** Whether section has different even/odd headers/footers. */
-  evenAndOddHeaders?: boolean; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
+  evenAndOddHeaders?: boolean; /** Swap left/right margins on even physical pages. */
+  mirrorMargins?: boolean; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
   footnoteReservedHeights?: Map<number, number>;
   /**
    * Footnote content heights keyed by internal footnote id (the OOXML
@@ -967,10 +979,8 @@ type HeaderFooterContent = {
   visualTop?: number; /** Bottom-most visual extent relative to the nominal flow origin. */
   visualBottom?: number;
   /**
-   * Flow-only bounds used by `computeHeaderFooterMarginExtender` to push
-   * body margins clear of HF overflow. Excludes `behindDoc` images that
-   * the renderer paints behind body content; including them would reserve
-   * a full-page letterhead as body push-down.
+   * Flow-only bounds for consumers that need to distinguish normal
+   * header/footer flow from floating or `behindDoc` artwork.
    */
   marginPushTop?: number;
   marginPushBottom?: number;
@@ -1028,5 +1038,19 @@ declare function floatingTextBoxWrapsText(block: TextBoxFlowAttrs): boolean;
  * Ported from eigenpal #694.
  */
 declare function floatingTextBoxReservesBand(block: TextBoxFlowAttrs): boolean;
+/**
+ * A table's columns are pinned when the layout engine cannot widen a column to
+ * fit content that overflows it: either the layout is explicitly fixed
+ * (`w:tblLayout w:type="fixed"`) or an explicit total width (`w:tblW` `dxa`/
+ * `pct`) is fully consumed by the grid.
+ *
+ * In OOXML, `w:noWrap` (§17.4.30) asks Word not to soft-wrap a cell, but Word
+ * can only honor it by widening the column. When the columns are pinned it
+ * cannot, so overflowing content wraps despite `w:noWrap`. An auto-width table
+ * (`w:tblW` `auto`/`nil`/absent with autofit layout) lets Word widen the column
+ * instead, so there `w:noWrap` genuinely keeps content on one line. Measurement
+ * and the painter both consult this so their line count and `white-space` agree.
+ */
+declare function tableColumnsArePinned(table: TableBlock): boolean;
 //#endregion
-export { 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, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, types_d_exports };
+export { 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, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_d_exports };

package/dist/layout-engine/types.js

@@ -11,7 +11,8 @@ var types_exports = /* @__PURE__ */ __exportAll({
 	floatingTextBoxWrapsText: () => floatingTextBoxWrapsText,
 	isFloatingImageRun: () => isFloatingImageRun,
 	isFloatingTextBoxBlock: () => isFloatingTextBoxBlock,
-	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun
+	isTextWrappingFloatingImageRun: () => isTextWrappingFloatingImageRun,
+	tableColumnsArePinned: () => tableColumnsArePinned
 });
 /** Default internal margins for text boxes (OOXML defaults in pixels) */
 const DEFAULT_TEXTBOX_MARGINS = {
@@ -96,5 +97,22 @@ function floatingTextBoxWrapsText(block) {
 function floatingTextBoxReservesBand(block) {
 	return isFloatingTextBoxBlock(block) && block.wrapType === "topAndBottom";
 }
+/**
+* A table's columns are pinned when the layout engine cannot widen a column to
+* fit content that overflows it: either the layout is explicitly fixed
+* (`w:tblLayout w:type="fixed"`) or an explicit total width (`w:tblW` `dxa`/
+* `pct`) is fully consumed by the grid.
+*
+* In OOXML, `w:noWrap` (§17.4.30) asks Word not to soft-wrap a cell, but Word
+* can only honor it by widening the column. When the columns are pinned it
+* cannot, so overflowing content wraps despite `w:noWrap`. An auto-width table
+* (`w:tblW` `auto`/`nil`/absent with autofit layout) lets Word widen the column
+* instead, so there `w:noWrap` genuinely keeps content on one line. Measurement
+* and the painter both consult this so their line count and `white-space` agree.
+*/
+function tableColumnsArePinned(table) {
+	if (table.layout === "fixed") return true;
+	return table.widthType === "dxa" || table.widthType === "pct";
+}
 //#endregion
-export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, types_exports };
+export { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned, types_exports };