@stll/folio-core 0.6.1 → 0.8.0

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

@@ -1,9 +1,12 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { layoutTextBoxParagraphs } from "./textBoxParagraphLayout.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
+import { isParagraphFrameTextBox } from "../paragraphFrame.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
-import { bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
+import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "../textBoxFlow.js";
+import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
 //#region src/layout-engine/measure/measureBlocks.ts
 /**
 * Pseudo-infinite measurement width (px) used for `w:noWrap` table cells so
@@ -25,7 +28,7 @@ const NO_WRAP_MEASURE_WIDTH = 1e6;
 * around a background letterhead or a foreground overlay (Codex
 * PR #258 review).
 */
-function isFloatingImageRun(run) {
+function isSideWrappingImageRun(run) {
 	const wrapType = run.wrapType;
 	const displayMode = run.displayMode;
 	if (wrapType === "behind" || wrapType === "inFront") return false;
@@ -82,9 +85,6 @@ function measureTableCellBlockVisualHeight(block, blockMeasure) {
 	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
 	return spacingBefore + maxImageHeight + spacingAfter;
 }
-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;
 	const DEFAULT_CELL_PADDING_Y = 0;
@@ -101,38 +101,17 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			columnWidths = columnWidths.map((w) => w * scale);
 		}
 	}
-	const occupiedColumnsPerRow = /* @__PURE__ */ new Map();
-	for (let rowIdx = 0; rowIdx < tableBlock.rows.length; rowIdx++) {
-		const row = tableBlock.rows[rowIdx];
-		if (!row) continue;
-		let colIdx = 0;
-		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
-		while (occupied.has(colIdx)) colIdx++;
-		for (const cell of row.cells) {
-			const colSpan = cell.colSpan ?? 1;
-			const rowSpan = cell.rowSpan ?? 1;
-			if (rowSpan > 1) for (let r = rowIdx + 1; r < rowIdx + rowSpan; r++) {
-				if (!occupiedColumnsPerRow.has(r)) occupiedColumnsPerRow.set(r, /* @__PURE__ */ new Set());
-				const occSet = occupiedColumnsPerRow.get(r);
-				for (let c = 0; c < colSpan; c++) occSet.add(colIdx + c);
-			}
-			colIdx += colSpan;
-			while (occupied.has(colIdx)) colIdx++;
-		}
-	}
+	const cellGrid = buildTableCellGrid(tableBlock.rows, columnWidths.length);
 	const columnsPinned = tableColumnsArePinned(tableBlock);
 	const rows = tableBlock.rows.map((row, rowIdx) => {
-		let columnIndex = 0;
-		const occupied = occupiedColumnsPerRow.get(rowIdx) ?? /* @__PURE__ */ new Set();
-		while (occupied.has(columnIndex)) columnIndex++;
+		let columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, row.gridBefore ?? 0);
 		return {
 			cells: row.cells.map((cell) => {
 				const colSpan = cell.colSpan ?? 1;
 				let cellWidth = 0;
 				for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
 				if (cellWidth === 0) cellWidth = cell.width ?? 100;
-				columnIndex += colSpan;
-				while (occupied.has(columnIndex)) columnIndex++;
+				columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, columnIndex + colSpan);
 				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);
@@ -163,7 +142,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 		const sourceRowCells = tableBlock.rows[rowIdx]?.cells;
 		let maxCellHeightWithBorders = 0;
-		let maxBorderHeight = 0;
+		let maxCellInsets = 0;
 		for (let cellIdx = 0; cellIdx < row.cells.length; cellIdx++) {
 			const cell = row.cells[cellIdx];
 			const sourceCell = sourceRowCells?.[cellIdx];
@@ -178,14 +157,14 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
 			cell.height += padTop + padBottom;
 			if ((sourceCell?.rowSpan ?? 1) > 1) continue;
-			const borderHeight = getTableCellVerticalBorderHeight(sourceCell, rowIdx === 0);
+			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx);
 			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
-			maxBorderHeight = Math.max(maxBorderHeight, borderHeight);
+			maxCellInsets = Math.max(maxCellInsets, padTop + padBottom + 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 + maxBorderHeight);
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets);
 		else row.height = maxCellHeightWithBorders;
 	}
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
@@ -200,7 +179,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			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;
+			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx) - combinedHeight;
 			if (deficit <= 0) continue;
 			for (let spannedRowIdx = spanEnd - 1; spannedRowIdx >= rowIdx; spannedRowIdx--) {
 				if (tableBlock.rows[spannedRowIdx]?.heightRule === "exact") continue;
@@ -223,13 +202,34 @@ function perBlockNumberValue(value, blockIndex, fallback) {
 	if (Array.isArray(value)) return value[blockIndex] ?? fallback;
 	return value;
 }
+function textBoxWrapSide({ box, contentX, boxWidth, contentWidth }) {
+	if (box.wrapText === "left") return "left";
+	if (box.wrapText === "right") return "right";
+	const leftSpace = contentX;
+	const rightSpace = contentWidth - contentX - boxWidth;
+	if (box.wrapText === "largest") return leftSpace >= rightSpace ? "left" : "right";
+	return contentX + boxWidth / 2 < contentWidth / 2 ? "right" : "left";
+}
 function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry) {
 	const zones = [];
+	const defaultContentWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
 	const textBoxGroupAnchors = /* @__PURE__ */ new Map();
+	const paragraphFrameGroupSizes = /* @__PURE__ */ new Map();
+	for (const block of blocks) {
+		if (block.kind !== "textBox" || !isParagraphFrameTextBox(block)) continue;
+		const groupId = getTextBoxGroupId(block);
+		if (groupId !== void 0) paragraphFrameGroupSizes.set(groupId, (paragraphFrameGroupSizes.get(groupId) ?? 0) + 1);
+	}
 	const defaultMarginTop = Array.isArray(marginTop) ? marginTop[0] ?? 0 : marginTop;
+	const pageWidthInput = pageGeometry?.pageWidth ?? defaultContentWidth;
 	const pageHeightInput = pageGeometry?.pageHeight ?? 0;
+	const marginLeftInput = pageGeometry?.marginLeft ?? 0;
+	const marginRightInput = pageGeometry?.marginRight ?? 0;
 	const marginBottomInput = pageGeometry?.marginBottom ?? 0;
+	const defaultPageWidth = Array.isArray(pageWidthInput) ? pageWidthInput[0] ?? defaultContentWidth : pageWidthInput;
 	const defaultPageHeight = Array.isArray(pageHeightInput) ? pageHeightInput[0] ?? 0 : pageHeightInput;
+	const defaultMarginLeft = Array.isArray(marginLeftInput) ? marginLeftInput[0] ?? 0 : marginLeftInput;
+	const defaultMarginRight = Array.isArray(marginRightInput) ? marginRightInput[0] ?? 0 : marginRightInput;
 	const defaultMarginBottom = Array.isArray(marginBottomInput) ? marginBottomInput[0] ?? 0 : marginBottomInput;
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		const block = blocks[blockIndex];
@@ -238,13 +238,36 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		for (const run of paragraphBlock.runs) {
 			if (run.kind !== "image") continue;
 			const imgRun = run;
-			if (!isFloatingImageRun(imgRun)) continue;
+			const positionedBand = imgRun.wrapType === "topAndBottom" && imgRun.position !== void 0;
+			if (!isSideWrappingImageRun(imgRun) && !positionedBand) continue;
 			let topY = 0;
 			const position = imgRun.position;
 			const distTop = imgRun.distTop ?? 0;
 			const distBottom = imgRun.distBottom ?? 0;
 			const distLeft = imgRun.distLeft ?? 12;
 			const distRight = imgRun.distRight ?? 12;
+			if (positionedBand && position !== void 0) {
+				const vertical = position.vertical;
+				const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
+				const pageFrameRelative = isPageFrameRelativeAnchor(vertical?.relativeTo);
+				const rawTop = pageFrameRelative ? bandTopContentY(vertical, {
+					pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
+					marginTop: blockMarginTop,
+					marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
+					boxHeight: imgRun.height
+				}) : emuToPixels(vertical?.posOffset ?? 0);
+				const bottomY = rawTop + imgRun.height + distBottom;
+				if (bottomY > 0) zones.push({
+					leftMargin: 0,
+					rightMargin: 0,
+					topY: Math.max(0, rawTop - distTop),
+					bottomY,
+					anchorBlockIndex: blockIndex,
+					...pageFrameRelative ? { isMarginRelative: true } : {},
+					fullWidthBlock: true
+				});
+				continue;
+			}
 			if (position?.vertical) {
 				const v = position.vertical;
 				if (v.align === "top" && v.relativeTo === "margin") topY = 0;
@@ -259,8 +282,8 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 				else if (h.align === "right") rightMargin = imgRun.width + distLeft;
 				else if (h.posOffset !== void 0) {
 					const x = emuToPixels(h.posOffset);
-					if (x < contentWidth / 2) leftMargin = x + imgRun.width + distRight;
-					else rightMargin = contentWidth - x + distLeft;
+					if (x < defaultContentWidth / 2) leftMargin = x + imgRun.width + distRight;
+					else rightMargin = defaultContentWidth - x + distLeft;
 				}
 			} else if (imgRun.cssFloat === "left") leftMargin = imgRun.width + distRight;
 			else if (imgRun.cssFloat === "right") rightMargin = imgRun.width + distLeft;
@@ -283,7 +306,7 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		const tableBlock = block;
 		const floating = tableBlock.floating;
 		if (!floating) continue;
-		const tableMeasure = measureTableBlock(tableBlock, contentWidth);
+		const tableMeasure = measureTableBlock(tableBlock, defaultContentWidth);
 		const tableWidth = tableMeasure.totalWidth;
 		const tableHeight = tableMeasure.totalHeight;
 		const distLeft = floating.leftFromText ?? 12;
@@ -295,12 +318,12 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 		let x = 0;
 		if (floating.tblpX !== void 0) x = floating.tblpX;
 		else if (floating.tblpXSpec) if (floating.tblpXSpec === "left" || floating.tblpXSpec === "inside") x = 0;
-		else if (floating.tblpXSpec === "right" || floating.tblpXSpec === "outside") x = contentWidth - tableWidth;
-		else x = (contentWidth - tableWidth) / 2;
-		else if (tableBlock.justification === "center") x = (contentWidth - tableWidth) / 2;
-		else if (tableBlock.justification === "right") x = contentWidth - tableWidth;
-		if (x < contentWidth / 2) leftMargin = x + tableWidth + distRight;
-		else rightMargin = contentWidth - x + distLeft;
+		else if (floating.tblpXSpec === "right" || floating.tblpXSpec === "outside") x = defaultContentWidth - tableWidth;
+		else x = (defaultContentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "center") x = (defaultContentWidth - tableWidth) / 2;
+		else if (tableBlock.justification === "right") x = defaultContentWidth - tableWidth;
+		if (x < defaultContentWidth / 2) leftMargin = x + tableWidth + distRight;
+		else rightMargin = defaultContentWidth - x + distLeft;
 		const topY = floating.tblpY ?? 0;
 		const bottomY = topY + tableHeight;
 		zones.push({
@@ -311,6 +334,64 @@ function extractFloatingZones(blocks, contentWidth, marginTop = 0, pageGeometry)
 			anchorBlockIndex: blockIndex
 		});
 	}
+	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+		const block = blocks[blockIndex];
+		if (block.kind !== "textBox") continue;
+		const tb = block;
+		if (!floatingTextBoxWrapsText(tb) || tb.position === void 0) continue;
+		const measure = measureTextBoxBlock(tb);
+		const blockMarginTop = perBlockNumberValue(marginTop, blockIndex, defaultMarginTop);
+		const blockMarginLeft = perBlockNumberValue(marginLeftInput, blockIndex, defaultMarginLeft);
+		const blockMarginRight = perBlockNumberValue(marginRightInput, blockIndex, defaultMarginRight);
+		const blockPageWidth = perBlockNumberValue(pageWidthInput, blockIndex, defaultPageWidth);
+		const blockContentWidth = perBlockNumberValue(contentWidth, blockIndex, defaultContentWidth);
+		const vertical = tb.position.vertical;
+		const pageFrameRelative = isPageFrameRelativeAnchor(vertical?.relativeTo);
+		const topY = pageFrameRelative ? bandTopContentY(vertical, {
+			pageHeight: perBlockNumberValue(pageHeightInput, blockIndex, defaultPageHeight),
+			marginTop: blockMarginTop,
+			marginBottom: perBlockNumberValue(marginBottomInput, blockIndex, defaultMarginBottom),
+			boxHeight: measure.height
+		}) : emuToPixels(vertical?.posOffset ?? 0);
+		const groupId = getTextBoxGroupId(tb);
+		const anchorBlockIndex = groupId ? textBoxGroupAnchors.get(groupId) ?? blockIndex : blockIndex;
+		if (groupId && !textBoxGroupAnchors.has(groupId)) textBoxGroupAnchors.set(groupId, blockIndex);
+		if (isParagraphFrameTextBox(tb) && groupId !== void 0 && (paragraphFrameGroupSizes.get(groupId) ?? 0) > 1) {
+			zones.push({
+				leftMargin: 0,
+				rightMargin: 0,
+				topY: 0,
+				bottomY: topY + measure.height + (tb.distBottom ?? 0),
+				anchorBlockIndex,
+				...pageFrameRelative ? { isMarginRelative: true } : {},
+				fullWidthBlock: true
+			});
+			continue;
+		}
+		const horizontal = tb.position.horizontal;
+		const contentX = (horizontal ? bandFragmentX(horizontal, {
+			pageWidth: blockPageWidth,
+			marginLeft: blockMarginLeft,
+			marginRight: blockMarginRight,
+			boxWidth: measure.width
+		}) : blockMarginLeft) - blockMarginLeft;
+		const wrapSide = textBoxWrapSide({
+			box: tb,
+			contentX,
+			boxWidth: measure.width,
+			contentWidth: blockContentWidth
+		});
+		const leftMargin = wrapSide === "right" ? contentX + measure.width + (tb.distRight ?? 12) : 0;
+		const rightMargin = wrapSide === "left" ? blockContentWidth - contentX + (tb.distLeft ?? 12) : 0;
+		zones.push({
+			leftMargin: Math.max(0, leftMargin),
+			rightMargin: Math.max(0, rightMargin),
+			topY: topY - (tb.distTop ?? 0),
+			bottomY: topY + measure.height + (tb.distBottom ?? 0),
+			anchorBlockIndex,
+			...pageFrameRelative ? { isMarginRelative: true } : {}
+		});
+	}
 	for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
 		const block = blocks[blockIndex];
 		if (block.kind !== "textBox") continue;
@@ -389,8 +470,8 @@ function measureTextBoxBlock(tb, fieldValues) {
 	const margins = tb.margins ?? DEFAULT_TEXTBOX_MARGINS;
 	const innerWidth = tb.width - margins.left - margins.right;
 	const innerMeasures = tb.content.map((p) => measureParagraph(p, innerWidth, fieldValues ? { fieldValues } : void 0));
-	const contentHeight = innerMeasures.reduce((sum, m) => sum + m.totalHeight, 0);
-	const totalHeight = tb.height ?? contentHeight + margins.top + margins.bottom;
+	const contentBoxHeight = layoutTextBoxParagraphs(tb.content, innerMeasures).totalHeight + margins.top + margins.bottom;
+	const totalHeight = tb.autoFit === "shape" ? Math.max(tb.height ?? 0, contentBoxHeight) : tb.height ?? contentBoxHeight;
 	return {
 		kind: "textBox",
 		width: tb.width,
@@ -418,7 +499,7 @@ function isNextPageSectionBreak(block) {
 */
 function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldValues) {
 	const defaultWidth = Array.isArray(contentWidth) ? contentWidth[0] ?? 0 : contentWidth;
-	const floatingZonesWithAnchors = extractFloatingZones(blocks, defaultWidth, marginTop, pageGeometry);
+	const floatingZonesWithAnchors = extractFloatingZones(blocks, contentWidth, marginTop, pageGeometry);
 	const marginRelative = floatingZonesWithAnchors.filter((z) => z.isMarginRelative && !z.fullWidthBlock);
 	const ownAnchorZones = floatingZonesWithAnchors.filter((z) => !z.isMarginRelative || z.fullWidthBlock);
 	const marginByTopY = /* @__PURE__ */ new Map();
@@ -461,10 +542,11 @@ function measureBlocks(blocks, contentWidth, marginTop = 0, pageGeometry, fieldV
 		try {
 			const blockWidth = Array.isArray(contentWidth) ? contentWidth[blockIndex] ?? defaultWidth : contentWidth;
 			const measure = measureBlock(block, blockWidth, zones, cumulativeY, fieldValues);
-			const bandZones = zones?.filter((zone) => zone.fullWidthBlock);
-			if (bandZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
+			const clearingZones = measure.kind === "table" ? zones : zones?.filter((zone) => zone.fullWidthBlock);
+			if (clearingZones?.length && (measure.kind === "image" || measure.kind === "table" && !block.floating)) {
 				const blockHeight = measure.kind === "image" ? measure.height : measure.totalHeight;
-				const skip = findClearLineY(cumulativeY, blockHeight, bandZones, blockWidth, 24) - cumulativeY;
+				const requiredWidth = measure.kind === "table" ? Math.min(blockWidth, measure.totalWidth) : 24;
+				const skip = findClearLineY(cumulativeY, blockHeight, clearingZones, blockWidth, Math.max(24, requiredWidth)) - cumulativeY;
 				if (skip > 0) {
 					measure.bandSkipBefore = skip;
 					cumulativeY += skip;

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

@@ -22,8 +22,9 @@ const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
+const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
-const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .025;
+const JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO = .02;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
 const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
@@ -245,6 +246,7 @@ function isEmptyTextRun(run) {
 * preceding a floating image.
 */
 function isBlockLayoutImageRun(run) {
+	if (isFloatingImageRun(run)) return false;
 	return run.wrapType === "topAndBottom" || run.displayMode === "block";
 }
 function measureInlineWidthAfterTab(runs, tabIndex, fieldValues) {
@@ -329,20 +331,34 @@ function uppercaseLetterRatio(text) {
 	}
 	return letters === 0 ? 0 : uppercase / letters;
 }
+function fixedSpaceAdjustedShrinkTolerance({ tolerance, regularSpaceCount, nonBreakingSpaceCount }) {
+	const totalSpaces = regularSpaceCount + nonBreakingSpaceCount;
+	if (totalSpaces === 0) return tolerance;
+	return Math.max(JUSTIFY_SHRINK_TOLERANCE_RATIO, tolerance * (regularSpaceCount / totalSpaces));
+}
 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 hanging = block.attrs.indent?.hanging ?? 0;
+		if (isFirstLine) return hanging <= DEFAULT_LIST_HANGING_INDENT_PX ? JUSTIFY_SHRINK_TOLERANCE_RATIO : JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO;
+		const left = block.attrs.indent?.left ?? 0;
+		if (hanging > 0 && left > hanging) return JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO;
+		return fixedSpaceAdjustedShrinkTolerance({
+			tolerance: JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO,
+			regularSpaceCount,
+			nonBreakingSpaceCount
+		});
 	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
 	const hasTabRuns = block.runs.some(isTabRun);
+	if (isFirstLine && hasTabRuns && (block.attrs?.indent?.hanging ?? 0) > 0) return 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 (hasTabRuns && (isFirstLine || hasTabStops)) 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;
+	return fixedSpaceAdjustedShrinkTolerance({
+		tolerance: JUSTIFY_PROSE_SHRINK_TOLERANCE_RATIO,
+		regularSpaceCount,
+		nonBreakingSpaceCount
+	});
 }
 function trimTrailingSpacesAndTabs(text) {
 	let end = text.length;
@@ -479,15 +495,17 @@ function measureParagraph(block, maxWidth, options) {
 			};
 		}
 		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
 			toRun: 0,
 			toChar: 0,
 			width: 0,
-			...emptyMetrics
+			...emptyMetrics,
+			lineHeight: outlineLineHeight
 		});
-		let totalHeight = emptyMetrics.lineHeight;
+		let totalHeight = outlineLineHeight;
 		if (spacing?.before) totalHeight += spacing.before;
 		if (spacing?.after) totalHeight += spacing.after;
 		return {
@@ -536,7 +554,14 @@ function measureParagraph(block, maxWidth, options) {
 		...firstLineFloatingMargins.segments?.length ? { segmentZones: firstLineFloatingMargins.segments } : {}
 	};
 	const calculateLineTypography = (line) => {
-		const finalTypography = { ...calculateTypographyMetrics(line.maxFontSize, spacing, line.maxFontMetrics) };
+		const paragraphFontSize = attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
+		const paragraphFontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+		const fontSize = line.maxFontMetrics ? line.maxFontSize : paragraphFontSize;
+		const metrics = line.maxFontMetrics ?? getFontMetrics({
+			fontSize: paragraphFontSize,
+			fontFamily: paragraphFontFamily
+		});
+		const finalTypography = { ...calculateTypographyMetrics(fontSize, spacing, metrics) };
 		const inlineObjectHeight = Math.max(line.maxImageHeightPx, line.maxMathHeightPx);
 		if (inlineObjectHeight > finalTypography.lineHeight) {
 			const objectHeight = inlineObjectHeight;
@@ -651,8 +676,9 @@ function measureParagraph(block, maxWidth, options) {
 				decimalPrefixWidth
 			});
 			let tabWidth = tabResult.width;
+			const landsOnLeftIndent = tabResult.alignment === "start" && indentLeft > 0 && Math.abs(contentX + tabWidth - indentLeft) <= WIDTH_TOLERANCE;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			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 (!landsOnLeftIndent && !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);
@@ -665,7 +691,7 @@ function measureParagraph(block, maxWidth, options) {
 		}
 		if (isImageRun(run)) {
 			const wrapType = run.wrapType;
-			if (run.displayMode === "float" || wrapType === "square" || wrapType === "tight" || wrapType === "through" || wrapType === "behind" || wrapType === "inFront") {
+			if (isFloatingImageRun(run)) {
 				currentLine.toRun = runIndex;
 				currentLine.toChar = 1;
 				continue;
@@ -794,12 +820,13 @@ function measureParagraph(block, maxWidth, options) {
 				}
 				const rawGlueWidth = nextBreak === text.length && word.length > 0 && !isBreakChar(word[word.length - 1]) ? trailingGlueWidths[runIndex] ?? 0 : 0;
 				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
-				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance) {
+				if (wordWidth > 0 && currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + widthTolerance) {
 					startNewLine(runIndex, charIndex);
 					updateMaxFont(lineHeightStyle);
 				}
 				currentLine.width += fullWordWidth;
-				currentLine.trailingWhitespaceWidth = fullWordWidth - wordWidth;
+				const wordTrailingWhitespaceWidth = fullWordWidth - wordWidth;
+				currentLine.trailingWhitespaceWidth = wordWidth === 0 ? currentLine.trailingWhitespaceWidth + wordTrailingWhitespaceWidth : wordTrailingWhitespaceWidth;
 				currentLine.regularSpaceCount += word.split(" ").length - 1;
 				currentLine.nonBreakingSpaceCount += word.split("\xA0").length - 1;
 				currentLine.toRun = runIndex;

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

@@ -0,0 +1,15 @@
+import { TableCell, TableRow } from "../types.js";
+
+//#region src/layout-engine/measure/tableCellGrid.d.ts
+type TableCellGrid = {
+  occupiedColumnsByRow: ReadonlyMap<number, ReadonlySet<number>>;
+  sourceCellsByRow: ReadonlyMap<number, ReadonlyMap<number, TableCell>>;
+  sourceColumnsByCell: ReadonlyMap<TableCell, number>;
+};
+declare const buildTableCellGrid: (rows: readonly TableRow[], columnCount: number) => TableCellGrid;
+declare const getFirstAvailableColumn: (grid: TableCellGrid, rowIndex: number, startingColumn: number) => number;
+declare const getSourceCellAt: (grid: TableCellGrid, rowIndex: number, columnIndex: number) => TableCell | undefined;
+declare const getSourceCellColumn: (grid: TableCellGrid, cell: TableCell) => number | undefined;
+declare const getTableCellVerticalBorderHeight: (grid: TableCellGrid, cell: TableCell | undefined, rowIndex: number) => number;
+//#endregion
+export { TableCellGrid, buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,62 @@
+//#region src/layout-engine/measure/tableCellGrid.ts
+const buildTableCellGrid = (rows, columnCount) => {
+	const occupiedColumnsByRow = /* @__PURE__ */ new Map();
+	const sourceCellsByRow = /* @__PURE__ */ new Map();
+	const sourceColumnsByCell = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), row.gridBefore ?? 0);
+		for (const cell of row.cells) {
+			const columnSpan = cell.colSpan ?? 1;
+			const rowSpan = cell.rowSpan ?? 1;
+			sourceColumnsByCell.set(cell, columnIndex);
+			const rowEnd = Math.min(rows.length, rowIndex + rowSpan);
+			const columnEnd = Math.min(columnCount, columnIndex + columnSpan);
+			for (let gridRowIndex = rowIndex; gridRowIndex < rowEnd; gridRowIndex++) {
+				const cellsByColumn = getOrCreateCellRow(sourceCellsByRow, gridRowIndex);
+				for (let gridColumnIndex = columnIndex; gridColumnIndex < columnEnd; gridColumnIndex++) cellsByColumn.set(gridColumnIndex, cell);
+			}
+			if (rowSpan > 1) for (let spannedRowIndex = rowIndex + 1; spannedRowIndex < rowIndex + rowSpan; spannedRowIndex++) {
+				const occupied = getOrCreateOccupiedRow(occupiedColumnsByRow, spannedRowIndex);
+				for (let columnOffset = 0; columnOffset < columnSpan; columnOffset++) occupied.add(columnIndex + columnOffset);
+			}
+			columnIndex = firstAvailableColumn(occupiedColumnsByRow.get(rowIndex), columnIndex + columnSpan);
+		}
+	}
+	return {
+		occupiedColumnsByRow,
+		sourceCellsByRow,
+		sourceColumnsByCell
+	};
+};
+const getFirstAvailableColumn = (grid, rowIndex, startingColumn) => firstAvailableColumn(grid.occupiedColumnsByRow.get(rowIndex), startingColumn);
+const getSourceCellAt = (grid, rowIndex, columnIndex) => grid.sourceCellsByRow.get(rowIndex)?.get(columnIndex);
+const getSourceCellColumn = (grid, cell) => grid.sourceColumnsByCell.get(cell);
+const getTableCellVerticalBorderHeight = (grid, cell, rowIndex) => {
+	const sourceColumn = cell ? getSourceCellColumn(grid, cell) : void 0;
+	const aboveBottom = (sourceColumn === void 0 ? void 0 : getSourceCellAt(grid, rowIndex - 1, sourceColumn))?.borders?.bottom;
+	const aboveOwnsEdge = aboveBottom !== void 0 && aboveBottom.width !== 0 && aboveBottom.style !== "none" && aboveBottom.style !== "nil";
+	return (rowIndex === 0 || !aboveOwnsEdge ? cell?.borders?.top?.width ?? 0 : 0) + (cell?.borders?.bottom?.width ?? 0);
+};
+const firstAvailableColumn = (occupiedColumns, startingColumn) => {
+	let columnIndex = startingColumn;
+	while (occupiedColumns?.has(columnIndex)) columnIndex++;
+	return columnIndex;
+};
+const getOrCreateCellRow = (sourceCellsByRow, rowIndex) => {
+	const existing = sourceCellsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const cellsByColumn = /* @__PURE__ */ new Map();
+	sourceCellsByRow.set(rowIndex, cellsByColumn);
+	return cellsByColumn;
+};
+const getOrCreateOccupiedRow = (occupiedColumnsByRow, rowIndex) => {
+	const existing = occupiedColumnsByRow.get(rowIndex);
+	if (existing !== void 0) return existing;
+	const occupiedColumns = /* @__PURE__ */ new Set();
+	occupiedColumnsByRow.set(rowIndex, occupiedColumns);
+	return occupiedColumns;
+};
+//#endregion
+export { buildTableCellGrid, getFirstAvailableColumn, getSourceCellAt, getSourceCellColumn, getTableCellVerticalBorderHeight };

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

@@ -0,0 +1,18 @@
+import { ParagraphBlock, ParagraphMeasure } from "../types.js";
+
+//#region src/layout-engine/measure/textBoxParagraphLayout.d.ts
+type TextBoxParagraphPlacement = {
+  leadingSpacing: number;
+  contentHeight: number;
+};
+type TextBoxParagraphLayout = {
+  placements: TextBoxParagraphPlacement[];
+  totalHeight: number;
+};
+/**
+ * Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+ * before/after spacing collapses to the larger value, matching body flow.
+ */
+declare function layoutTextBoxParagraphs(blocks: readonly ParagraphBlock[], measures: readonly ParagraphMeasure[]): TextBoxParagraphLayout;
+//#endregion
+export { TextBoxParagraphLayout, TextBoxParagraphPlacement, layoutTextBoxParagraphs };

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

@@ -0,0 +1,32 @@
+import { measuredLineRangeHeight } from "../lineFlow.js";
+import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
+import { panic } from "better-result";
+//#region src/layout-engine/measure/textBoxParagraphLayout.ts
+/**
+* Lay out a text box's paragraph story as one unpaginated flow. Adjacent
+* before/after spacing collapses to the larger value, matching body flow.
+*/
+function layoutTextBoxParagraphs(blocks, measures) {
+	if (blocks.length !== measures.length) panic("layoutTextBoxParagraphs: block and measure counts must match");
+	const placements = [];
+	let totalHeight = 0;
+	let trailingSpacing = 0;
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const measure = measures[index];
+		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		const contentHeight = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
+		placements.push({
+			leadingSpacing,
+			contentHeight
+		});
+		totalHeight += leadingSpacing + contentHeight;
+		trailingSpacing = getParagraphSpacingAfter(block);
+	}
+	return {
+		placements,
+		totalHeight: totalHeight + trailingSpacing
+	};
+}
+//#endregion
+export { layoutTextBoxParagraphs };

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

@@ -35,7 +35,8 @@ type PaginatorOptions = {
    * its title page (typically extended top margin to clear an overflowing
    * first-page header) vs. its body pages. Pages 2+ use `margins`.
    */
-  firstPageMargins?: PageMargins; /** Column configuration (optional). */
+  firstPageMargins?: PageMargins; /** Per-section body margins used on even section pages. */
+  sectionEvenPageMargins?: (PageMargins | undefined)[]; /** Column configuration (optional). */
   columns?: ColumnLayout; /** Per-page footnote reserved heights (pageNumber → height in pixels). */
   footnoteReservedHeights?: Map<number, number>; /** Header/footer refs by section index. */
   sectionHeaderFooterRefs?: PageHeaderFooterRefs[]; /** Callback when a new page is created. */