@stll/folio-core 0.6.0 → 0.7.0

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

@@ -5,12 +5,23 @@ function isVisuallyEmptyParagraph(block) {
 	const run = block.runs.at(0);
 	return run?.kind === "text" && run.text === "";
 }
+function startsTrailingTableSeparatorChain(blocks, index) {
+	const block = blocks[index];
+	if (block?.kind !== "paragraph" || !isVisuallyEmptyParagraph(block) || blocks[index - 1]?.kind !== "table") return false;
+	for (let nextIndex = index + 1; nextIndex < blocks.length; nextIndex++) {
+		const nextBlock = blocks[nextIndex];
+		if (nextBlock?.kind !== "paragraph") return false;
+		if (!isVisuallyEmptyParagraph(nextBlock)) return true;
+	}
+	return false;
+}
 /**
 * Pre-scan blocks to find all keepNext chains.
 *
-* 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.
+* A chain starts with a paragraph whose keepNext=true or with an empty
+* separator immediately following a table. It 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.
 */
@@ -21,7 +32,7 @@ function computeKeepNextChains(blocks) {
 		if (processed.has(i)) continue;
 		const block = blocks[i];
 		if (block.kind !== "paragraph") continue;
-		if (!block.attrs?.keepNext) continue;
+		if (!block.attrs?.keepNext && !startsTrailingTableSeparatorChain(blocks, i)) continue;
 		const memberIndices = [i];
 		let endIndex = i;
 		for (let j = i + 1; j < blocks.length; j++) {
@@ -67,6 +78,7 @@ function calculateChainHeight(chain, blocks, measures) {
 	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 startsWithTrailingTableSeparator = blocks[firstMemberIndex - 1]?.kind === "table" && isVisuallyEmptyParagraph(firstBlock) && !firstBlock.attrs?.keepNext;
 	const successorIndices = [...chain.memberIndices.slice(1)];
 	if (chain.anchorIndex !== -1) successorIndices.push(chain.anchorIndex);
 	for (let index = 0; index < successorIndices.length; index++) {
@@ -80,6 +92,10 @@ function calculateChainHeight(chain, blocks, measures) {
 		if (!firstLine) return totalHeight;
 		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;
 		const isSplittable = successorMeasure.lines.length > 1 && !successorBlock.attrs?.keepLines;
+		if (isAnchor && startsWithTrailingTableSeparator && successorBlock.attrs?.widowControl !== false && successorMeasure.lines.length > 1) {
+			const secondLine = successorMeasure.lines.at(1);
+			return totalHeight + firstLine.lineHeight + (secondLine?.lineHeight ?? 0);
+		}
 		if (isAnchor || isSplittable) return totalHeight + firstLine.lineHeight;
 		totalHeight += successorMeasure.totalHeight;
 		trailingSpacing = successorBlock.attrs?.spacing?.after ?? 0;

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

@@ -160,11 +160,13 @@ function hashParagraphBlock(block) {
 	const attrs = block.attrs;
 	if (attrs) {
 		if (attrs.alignment) parts.push(`align:${attrs.alignment}`);
+		if (attrs.outlineLevel !== void 0) parts.push(`outline:${attrs.outlineLevel}`);
 		if (attrs.indent) parts.push(`indent:${attrs.indent.left}|${attrs.indent.right}|${attrs.indent.firstLine}|${attrs.indent.hanging}`);
 		if (attrs.spacing) parts.push(`spacing:${attrs.spacing.before}|${attrs.spacing.after}|${attrs.spacing.line}|${attrs.spacing.lineRule}`);
 		if (attrs.defaultFontSize != null) parts.push(`dfs:${attrs.defaultFontSize}`);
 		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
 		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
+		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
 		const borders = attrs.borders;
 		if (borders) {
 			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";

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

@@ -1,4 +1,4 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, tableColumnsArePinned } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
@@ -56,6 +56,7 @@ function isInlineFlowImageRun(run) {
 	return true;
 }
 function measureTableCellBlockVisualHeight(block, blockMeasure) {
+	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return 0;
 	if (block.kind !== "paragraph" || blockMeasure.kind !== "paragraph") {
 		if ("totalHeight" in blockMeasure) return blockMeasure.totalHeight;
 		if ("height" in blockMeasure) return blockMeasure.height;
@@ -95,7 +96,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		columnWidths = Array.from({ length: colCount }, () => equalWidth);
 	} else if (columnWidths.length > 0 && explicitWidthPx) {
 		const totalWidth = columnWidths.reduce((sum, w) => sum + w, 0);
-		if (totalWidth > 0 && Math.abs(totalWidth - explicitWidthPx) > 1) {
+		if (!(tableBlock.layout !== "fixed" && (tableBlock.widthType === void 0 || tableBlock.widthType === "dxa") && totalWidth - explicitWidthPx > 1) && totalWidth > 0 && Math.abs(totalWidth - explicitWidthPx) > 1) {
 			const scale = explicitWidthPx / totalWidth;
 			columnWidths = columnWidths.map((w) => w * scale);
 		}

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

@@ -329,20 +329,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_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 +493,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 {
@@ -651,8 +667,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);
@@ -794,12 +811,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/paginator.d.ts

@@ -55,6 +55,8 @@ declare function createPaginator(options: PaginatorOptions): {
     count: number;
     gap: number;
     equalWidth?: boolean;
+    widths?: number[];
+    gaps?: number[];
     separator?: boolean;
   }; /** Get current state. */
   getCurrentState: () => PageState; /** Get available height in current column. */

package/dist/layout-engine/paginator.js

@@ -7,12 +7,13 @@ import { panic } from "better-result";
 * Tracks the current page, cursor position, and available space.
 * Creates new pages when content doesn't fit.
 */
-/**
-* Calculate the width of a single column.
-*/
-function calculateColumnWidth(pageWidth, leftMargin, rightMargin, columns) {
-	return (pageWidth - leftMargin - rightMargin - (columns.count - 1) * columns.gap) / columns.count;
+/** Calculate active column widths, preferring authored unequal widths. */
+function calculateColumnWidths(pageWidth, leftMargin, rightMargin, columns) {
+	if (columns.widths?.length === columns.count && columns.widths.every((width) => Number.isFinite(width) && width > 0)) return [...columns.widths];
+	const equalWidth = (pageWidth - leftMargin - rightMargin - (columns.count - 1) * columns.gap) / columns.count;
+	return Array.from({ length: columns.count }, () => equalWidth);
 }
+const gapAfterColumn = (columns, columnIndex) => columns.gaps?.[columnIndex] ?? columns.gap;
 function arePageSizesEqual(left, right) {
 	return left.w === right.w && left.h === right.h;
 }
@@ -49,9 +50,9 @@ function createPaginator(options) {
 		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);
-	function recalculateColumnWidth() {
-		columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
+	let columnWidths = calculateColumnWidths(pageSize.w, margins.left, margins.right, columns);
+	function recalculateColumnWidths() {
+		columnWidths = calculateColumnWidths(pageSize.w, margins.left, margins.right, columns);
 	}
 	function applyPendingLayout() {
 		if (pendingPageSize) pageSize = pendingPageSize;
@@ -59,7 +60,7 @@ function createPaginator(options) {
 		pendingPageSize = void 0;
 		pendingMargins = void 0;
 		if (getContentHeight() <= 0) panic("Paginator: section page size and margins yield no content area");
-		recalculateColumnWidth();
+		recalculateColumnWidths();
 	}
 	function getPageMargins(pageNumber) {
 		const pageMargins = pageNumber === 1 && options.firstPageMargins ? { ...options.firstPageMargins } : { ...margins };
@@ -71,11 +72,14 @@ function createPaginator(options) {
 		return pageMargins;
 	}
 	let columnRegionTop = margins.top;
+	let columnRegionMaxBottom = margins.top;
 	/**
 	* Get X position for a given column index.
 	*/
 	function getColumnX(columnIndex) {
-		return (states.at(-1)?.page.margins.left ?? getPageMargins(1).left) + columnIndex * (columnWidth + columns.gap);
+		let x = states.at(-1)?.page.margins.left ?? getPageMargins(1).left;
+		for (let index = 0; index < columnIndex; index++) x += (columnWidths[index] ?? columnWidths[0] ?? 0) + gapAfterColumn(columns, index);
+		return x;
 	}
 	/**
 	* Create a new page and add it to the list.
@@ -111,6 +115,7 @@ function createPaginator(options) {
 		pages.push(page);
 		states.push(state);
 		columnRegionTop = topMargin;
+		columnRegionMaxBottom = topMargin;
 		if (options.onNewPage) options.onNewPage(state);
 		return state;
 	}
@@ -140,6 +145,7 @@ function createPaginator(options) {
 	*/
 	function advanceColumn(state) {
 		if (state.columnIndex < columns.count - 1) {
+			columnRegionMaxBottom = Math.max(columnRegionMaxBottom, state.cursorY);
 			state.columnIndex += 1;
 			state.cursorY = columnRegionTop;
 			state.trailingSpacing = 0;
@@ -156,7 +162,7 @@ function createPaginator(options) {
 		let state = getCurrentState();
 		const safeHeight = Number.isFinite(height) && height > 0 ? height : 0;
 		while (!fits(safeHeight, state)) {
-			if (safeHeight > state.contentBottom - state.topMargin) {
+			if (safeHeight > state.contentBottom - columnRegionTop) {
 				if (state.cursorY !== state.topMargin) state = advanceColumn(state);
 				return state;
 			}
@@ -273,12 +279,17 @@ function createPaginator(options) {
 	* column advancement stays below existing content (for continuous breaks).
 	*/
 	function updateColumns(newColumns) {
-		columns = newColumns;
-		columnWidth = calculateColumnWidth(pageSize.w, margins.left, margins.right, columns);
+		const previousColumnCount = columns.count;
 		const state = getCurrentState();
+		const previousRegionBottom = Math.max(columnRegionMaxBottom, state.cursorY);
+		columns = newColumns;
+		recalculateColumnWidths();
 		if (columns.count > 1) state.page.columns = { ...columns };
 		else delete state.page.columns;
+		state.contentBottom = state.rawContentBottom - state.footnoteHeight;
+		if (previousColumnCount > 1) state.cursorY = previousRegionBottom;
 		columnRegionTop = state.cursorY;
+		columnRegionMaxBottom = state.cursorY;
 		state.columnIndex = 0;
 	}
 	function updatePageLayout(newPageSize, newMargins, applyImmediately = true) {
@@ -290,7 +301,7 @@ function createPaginator(options) {
 		if (newPageSize) pageSize = { ...newPageSize };
 		if (newMargins) margins = { ...newMargins };
 		if (getContentHeight() <= 0) panic("Paginator: section page size and margins yield no content area");
-		recalculateColumnWidth();
+		recalculateColumnWidths();
 		pendingPageSize = void 0;
 		pendingMargins = void 0;
 	}
@@ -312,7 +323,8 @@ function createPaginator(options) {
 		states,
 		/** Column width in pixels (use getColumnWidth() for current value after updates). */
 		get columnWidth() {
-			return columnWidth;
+			const columnIndex = states.at(-1)?.columnIndex ?? 0;
+			return columnWidths[columnIndex] ?? columnWidths[0] ?? getContentWidth();
 		},
 		/** Get current column layout (returns copy to prevent external mutation). */
 		get columns() {

package/dist/layout-engine/tableRowBreak.js

@@ -1,3 +1,4 @@
+import { isFloatingTextBoxBlock } from "./types.js";
 import { measureParagraph } from "./measure/measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "./measure/tableCellFloating.js";
 //#region src/layout-engine/tableRowBreak.ts
@@ -74,6 +75,8 @@ function cellBreakGeometry(cell, measure) {
 			y = blockTop + blockMeasure.totalHeight;
 			paragraphY += blockMeasure.totalHeight;
 		} else if (blockMeasure) {
+			const block = cellBlocks?.[i];
+			if (block?.kind === "textBox" && isFloatingTextBoxBlock(block)) continue;
 			const blockHeight = getAtomicBlockHeight(blockMeasure);
 			if (blockHeight > 0) {
 				const top = y;

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

@@ -286,8 +286,13 @@ type ListNumPr = {
  * Paragraph block attributes.
  */
 type ParagraphAttrs = {
-  alignment?: "left" | "center" | "right" | "justify";
-  spacing?: ParagraphSpacing;
+  alignment?: "left" | "center" | "right" | "justify"; /** OOXML outline level (`w:outlineLvl`), where zero is the top level. */
+  outlineLevel?: number;
+  spacing?: ParagraphSpacing; /** Spacing sides resolved from OOXML automatic paragraph spacing. */
+  automaticSpacing?: {
+    before?: boolean;
+    after?: boolean;
+  };
   /**
    * Tracks which `spacing` sides came from inline (`<w:pPr><w:spacing>`)
    * formatting versus inherited via paragraph style. Word collapses
@@ -300,6 +305,12 @@ type ParagraphAttrs = {
     before?: boolean;
     after?: boolean;
   };
+  /**
+   * Whether an empty paragraph carries direct paragraph formatting in its
+   * source `w:pPr`. Word treats such a blank as authored and keeps its
+   * inherited spacing; a bare empty paragraph still collapses that spacing.
+   */
+  hasDirectParagraphFormatting?: boolean;
   indent?: ParagraphIndent;
   keepNext?: boolean;
   keepLines?: boolean;
@@ -319,7 +330,8 @@ type ParagraphAttrs = {
   borders?: ParagraphBorders;
   shading?: string;
   tabs?: TabStop[]; /** Render structural empty paragraphs as zero-height anchors. */
-  suppressEmptyParagraphHeight?: boolean;
+  suppressEmptyParagraphHeight?: boolean; /** Reserve the reference extra line advance for a story-leading empty level-0 outline paragraph. */
+  reserveEmptyOutlineHeight?: boolean;
   numPr?: ListNumPr;
   listMarker?: string;
   listIsBullet?: boolean;
@@ -846,7 +858,9 @@ type Page = {
 type ColumnLayout = {
   count: number;
   gap: number;
-  equalWidth?: boolean; /** Draw vertical separator line between columns (w:sep). */
+  equalWidth?: boolean; /** Authored widths for unequal-width section columns. */
+  widths?: number[]; /** Authored space after each column except the last. */
+  gaps?: number[]; /** Draw vertical separator line between columns (w:sep). */
   separator?: boolean;
 };
 /**
@@ -904,7 +918,8 @@ type LayoutOptions = {
     w: number;
     h: number;
   }; /** Body-level final section margins. */
-  finalMargins?: PageMargins; /** Column configuration. */
+  finalMargins?: PageMargins; /** Body-level final section column configuration. */
+  finalColumns?: ColumnLayout; /** Column configuration. */
   columns?: ColumnLayout; /** Gap between rendered pages (for UI). */
   pageGap?: number; /** Default line height multiplier. */
   defaultLineHeight?: number; /** Header content heights by variant. */

package/dist/layout-painter/index.js

@@ -1,8 +1,8 @@
 import { FRAGMENT_CLASS_NAMES, renderFragment } from "./renderFragment.js";
 import { IMAGE_CLASS_NAMES, renderImageFragment } from "./renderImage.js";
 import { renderLine, renderParagraphFragment, sliceRunsForLine } from "./renderParagraph.js";
-import { TABLE_CLASS_NAMES, renderTableFragment } from "./renderTable.js";
 import { TEXTBOX_CLASS_NAMES, renderTextBoxFragment } from "./renderTextBox.js";
+import { TABLE_CLASS_NAMES, renderTableFragment } from "./renderTable.js";
 import { renderPage, renderPages } from "./renderPage.js";
 import { prefersReducedMotionBehavior } from "../paged-layout/scrollNavigation.js";
 import { createFeatureRegistry } from "./registry/registry.js";

package/dist/layout-painter/renderPage.js

@@ -8,8 +8,8 @@ import { renderFragment } from "./renderFragment.js";
 import { applyImageVisualAttrs, hasImageVisualAttrs, renderImageFragment } from "./renderImage.js";
 import { emuToPixels } from "./renderUtils.js";
 import { renderParagraphFragment } from "./renderParagraph.js";
-import { renderTableFragment } from "./renderTable.js";
 import { renderTextBoxFragment } from "./renderTextBox.js";
+import { renderTableFragment } from "./renderTable.js";
 import { renderWatermarkLayer } from "./renderWatermark.js";
 import { panic } from "better-result";
 //#region src/layout-painter/renderPage.ts
@@ -560,7 +560,12 @@ function renderHeaderFooterContent(content, context, options, layout) {
 				...block.pmStart !== void 0 ? { pmStart: block.pmStart } : {},
 				...block.pmEnd !== void 0 ? { pmEnd: block.pmEnd } : {}
 			}, block, measure, hfContext, { document: doc });
-			fragEl.style.top = `${cursorY}px`;
+			const textBoxTop = block.position ? resolveHeaderFooterFloatTop({
+				height: measure.height,
+				paragraphY: cursorY,
+				position: block.position
+			}, layout) : cursorY;
+			fragEl.style.top = `${textBoxTop}px`;
 			fragEl.style.left = resolveHeaderFooterFloatLeft(measure.width, block.position?.horizontal, layout);
 			if (block.wrapType === "behind") fragEl.style.zIndex = "-1";
 			containerEl.append(fragEl);

package/dist/layout-painter/renderParagraph.js

@@ -709,6 +709,75 @@ function splitTextRunsByEastAsia(runs) {
 	}
 	return result;
 }
+const paintsLineEdgeSpaces = (run) => Boolean(run.underline || run.strike || run.highlight || run.shading || run.hyperlink || run.hidden || run.templatePreview || run.isInsertion || run.isDeletion || run.commentIds?.length || run.textEffect || run.emphasisMark);
+const splitTextRunAt = (run, index) => {
+	const leading = {
+		...run,
+		text: run.text.slice(0, index)
+	};
+	const trailing = {
+		...run,
+		text: run.text.slice(index)
+	};
+	if (run.pmStart === void 0) return [leading, trailing];
+	const splitPosition = Math.min(run.pmStart + index, run.pmEnd ?? Number.POSITIVE_INFINITY);
+	leading.pmEnd = splitPosition;
+	trailing.pmStart = splitPosition;
+	return [leading, trailing];
+};
+/**
+* Word keeps ordinary line-edge spaces addressable in the document model but
+* gives them no painted advance. Collapsible trailing spaces always collapse;
+* leading spaces collapse only after a soft wrap, not at the authored
+* paragraph start or after a manual line break. Split paint runs to preserve
+* exact PM ranges.
+*/
+const splitCollapsibleLineEdgeSpaces = (sourceRuns, collapseLeading) => {
+	const runs = [...sourceRuns];
+	const collapsedLeadingRuns = /* @__PURE__ */ new Set();
+	const collapsedTrailingRuns = /* @__PURE__ */ new Set();
+	for (let index = runs.length - 1; index >= 0; index--) {
+		const run = runs[index];
+		if (!run || !isTextRun(run)) break;
+		if (run.text.length === 0) continue;
+		const trailingSpaces = / +$/u.exec(run.text);
+		if (!trailingSpaces || paintsLineEdgeSpaces(run)) break;
+		if (trailingSpaces.index === 0) {
+			collapsedTrailingRuns.add(run);
+			continue;
+		}
+		const [leading, trailing] = splitTextRunAt(run, trailingSpaces.index);
+		runs.splice(index, 1, leading, trailing);
+		collapsedTrailingRuns.add(trailing);
+		break;
+	}
+	if (collapseLeading) for (let index = 0; index < runs.length; index++) {
+		const run = runs[index];
+		if (!run || !isTextRun(run)) break;
+		if (run.text.length === 0) continue;
+		const leadingSpaces = /^ +/u.exec(run.text);
+		if (!leadingSpaces || paintsLineEdgeSpaces(run)) break;
+		if (leadingSpaces[0].length === run.text.length) {
+			collapsedLeadingRuns.add(run);
+			continue;
+		}
+		const [leading, trailing] = splitTextRunAt(run, leadingSpaces[0].length);
+		runs.splice(index, 1, leading, trailing);
+		collapsedLeadingRuns.add(leading);
+		break;
+	}
+	return {
+		runs,
+		collapsedLeadingRuns,
+		collapsedTrailingRuns
+	};
+};
+const startsAfterSoftWrap = (block, line) => {
+	if (line.fromChar > 0) return true;
+	if (line.fromRun === 0) return false;
+	const previousRun = block.runs.at(line.fromRun - 1);
+	return previousRun !== void 0 && !isLineBreakRun(previousRun);
+};
 /**
 * Sub-pixel tolerance when comparing canvas-measured widths against the DOM's
 * actual right edge. Accumulated rounding from canvas measureText vs. browser
@@ -878,7 +947,20 @@ function renderLine(block, line, alignment, doc, options) {
 	lineEl.style.boxSizing = "content-box";
 	lineEl.style.height = `${line.lineHeight}px`;
 	lineEl.style.lineHeight = `${line.lineHeight}px`;
-	const runsForLine = splitTextRunsByEastAsia(sliceRunsForLine(block, line));
+	const splitRuns = splitTextRunsByEastAsia(sliceRunsForLine(block, line));
+	const { runs: runsForLine, collapsedLeadingRuns: collapsedLeadingSpaceRuns, collapsedTrailingRuns: collapsedTrailingSpaceRuns } = splitCollapsibleLineEdgeSpaces(splitRuns, startsAfterSoftWrap(block, line));
+	const isCollapsedLineEdgeSpaceRun = (run) => collapsedLeadingSpaceRuns.has(run) || collapsedTrailingSpaceRuns.has(run);
+	const renderLineTextRun = (run) => {
+		const runEl = renderTextRun(run, doc);
+		if (collapsedLeadingSpaceRuns.has(run)) runEl.dataset["collapsedLeadingSpaces"] = "true";
+		if (collapsedTrailingSpaceRuns.has(run)) runEl.dataset["collapsedTrailingSpaces"] = "true";
+		if (isCollapsedLineEdgeSpaceRun(run)) {
+			runEl.style.fontSize = "0";
+			runEl.style.letterSpacing = "0";
+			runEl.style.wordSpacing = "0";
+		}
+		return runEl;
+	};
 	const onlyRun = runsForLine.length === 1 ? runsForLine[0] : void 0;
 	if (onlyRun && isMathRun(onlyRun) && onlyRun.display === "block" && block.attrs?.alignment !== "right") lineEl.style.textAlign = "center";
 	if (runsForLine.length === 1 && isImageRun(runsForLine[0])) {
@@ -910,9 +992,11 @@ function renderLine(block, line, alignment, doc, options) {
 		if (!options.isLastLine || options.paragraphEndsWithLineBreak) {
 			const firstLineIndentPx = options.isFirstLine ? options.firstLineIndentPx ?? 0 : 0;
 			const firstLineHangingPx = Math.max(0, -firstLineIndentPx);
-			const justifyCapacityPx = options.availableWidth + firstLineHangingPx;
+			const hasVisibleListMarker = options.isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden;
+			const firstLineHangingExpansionPx = hasVisibleListMarker ? Math.min(firstLineHangingPx, Math.max(0, options.leftIndentPx ?? 0)) : firstLineHangingPx;
+			const justifyCapacityPx = options.availableWidth + firstLineHangingExpansionPx;
 			const overfullPx = line.width - justifyCapacityPx;
-			const shrinkableSpaces = countShrinkableSpaces(runsForLine);
+			const shrinkableSpaces = countShrinkableSpaces(runsForLine.filter((run) => !isTextRun(run) || !isCollapsedLineEdgeSpaceRun(run)));
 			if (overfullPx > RIGHT_EDGE_EPSILON_PX && shrinkableSpaces > 0) {
 				lineEl.style.textAlign = "left";
 				lineEl.style.textAlignLast = "auto";
@@ -925,7 +1009,7 @@ function renderLine(block, line, alignment, doc, options) {
 				lineEl.style.textAlign = "justify";
 				lineEl.style.textAlignLast = "justify";
 			}
-			const listFirstLineOffset = options.isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden ? options.firstLineIndentPx ?? 0 : 0;
+			const listFirstLineOffset = hasVisibleListMarker ? Math.max(firstLineIndentPx, -firstLineHangingExpansionPx) : 0;
 			lineEl.style.width = `${options.availableWidth - listFirstLineOffset}px`;
 		}
 	}
@@ -987,7 +1071,7 @@ function renderLine(block, line, alignment, doc, options) {
 				for (let j = i + 1; j < runsForLine.length; j++) {
 					const next = runsForLine[j];
 					if (isTabRun(next) || isLineBreakRun(next)) break;
-					if (isTextRun(next)) lineEl.append(renderTextRun(next, doc));
+					if (isTextRun(next)) lineEl.append(renderLineTextRun(next));
 					else if (isFieldRun(next) && options?.context) lineEl.append(renderFieldRun(next, doc, options.context));
 					else if (isImageRun(next)) {
 						if (isFloatingImageRun(next)) continue;
@@ -1001,13 +1085,14 @@ function renderLine(block, line, alignment, doc, options) {
 				break;
 			}
 			let tabWidth = tabResult.width;
-			if (lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0, runsForLine.slice(0, i).some(isTabRun), options?.isLastLine === true) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
+			if (!(tabResult.alignment === "start" && leftIndentPx > 0 && Math.abs(currentX + tabWidth - leftIndentPx) <= RIGHT_EDGE_EPSILON_PX) && lineRightEdgeX !== void 0 && canClampTabToRightEdge(tabResult.alignment, i > 0, runsForLine.slice(0, i).some(isTabRun), options?.isLastLine === true) && currentX + tabWidth + followingWidthForCheck > lineRightEdgeX) tabWidth = Math.max(1, lineRightEdgeX - currentX - followingWidthForCheck);
 			const tabEl = renderTabRun(run, doc, tabWidth, tabResult.leader);
 			lineEl.append(tabEl);
 			currentX += tabWidth;
 		} else if (isTextRun(run)) {
-			const runEl = renderTextRun(run, doc);
+			const runEl = renderLineTextRun(run);
 			lineEl.append(runEl);
+			if (isCollapsedLineEdgeSpaceRun(run)) continue;
 			const fontSize = run.fontSize || 11;
 			const fontFamily = run.fontFamily || "Calibri";
 			const measuredWidth = measureText(run.allCaps ? run.text.toLocaleUpperCase() : run.text, fontSize, fontFamily, {
@@ -1249,7 +1334,6 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			} else if (indentLeft > 0) lineEl.style.paddingLeft = `${indentLeft}px`;
 			else if (hasFirstLine && !isFlexLine) lineEl.style.textIndent = `${indent.firstLine ?? 0}px`;
 		} else if (indentLeft > 0) lineEl.style.paddingLeft = `${indentLeft}px`;
-		else if (hasHanging && indentLeft === 0) lineEl.style.paddingLeft = `${indent.hanging ?? 0}px`;
 		if (indentRight > 0) lineEl.style.paddingRight = `${indentRight}px`;
 		if (isFirstLine && block.attrs?.listMarker && !block.attrs.listMarkerHidden) {
 			const hanging = indent?.hanging ?? 0;
@@ -1269,7 +1353,7 @@ function renderParagraphFragment(fragment, block, measure, context, options = {}
 			const markerFontSize = block.attrs.listMarkerFontSize ?? firstTextRun?.fontSize ?? block.attrs.defaultFontSize;
 			const marker = renderListMarker(block.attrs.listMarker, getListMarkerInlineWidth(block), doc, markerFontFamily, markerFontSize, block.attrs.listMarkerRevision, block.attrs.listMarkerSecondSlotOffsetTwips);
 			const markerMarginLeft = markerStart - Math.min(indentLeft, 0);
-			if (markerMarginLeft < 0 && indentLeft !== 0) marker.style.marginLeft = `${markerMarginLeft}px`;
+			if (markerMarginLeft < 0) marker.style.marginLeft = `${markerMarginLeft}px`;
 			lineEl.prepend(marker);
 		}
 		fragmentEl.append(lineEl);