@stll/folio-core 0.6.1 → 0.7.0

package/dist/layout-engine/index.js

@@ -44,9 +44,7 @@ function collectSectionConfigs(blocks, initialConfig, finalConfig) {
 }
 /**
 * Whether a paragraph block has no visible content (no runs, or a single
-* empty text run). Word collapses style-inherited spacing on empty
-* paragraphs (only direct `<w:pPr><w:spacing>` formatting survives) — see
-* eigenpal #402.
+* empty text run).
 */
 function isEmptyParagraph(block) {
 	if (block.runs.length === 0) return true;
@@ -68,16 +66,27 @@ function pageHasVisibleBodyContent(page, blocksById) {
 	}
 	return false;
 }
+function continuesNumberedSequence(previous, current) {
+	if (previous?.kind !== "paragraph" || current.kind !== "paragraph") return false;
+	const previousNumPr = previous.attrs?.numPr;
+	const currentNumPr = current.attrs?.numPr;
+	if (previousNumPr?.numId === void 0 || currentNumPr?.numId === void 0) return false;
+	return previousNumPr.numId === currentNumPr.numId && previousNumPr.ilvl === currentNumPr.ilvl;
+}
+function pageStartsWithPreviousParagraphContinuation(page, previousBlock) {
+	if (previousBlock?.kind !== "paragraph") return false;
+	return page.fragments.some((fragment) => fragment.kind === "paragraph" && String(fragment.blockId) === String(previousBlock.id) && fragment.continuesFromPrev === true);
+}
 /**
 * Get spacing before a paragraph block. Empty paragraphs whose
 * `before` came only from the implicit default paragraph style collapse to
-* zero. An explicit `w:pStyle` selection is authored paragraph formatting,
-* so Word keeps the selected style's spacing even when the paragraph is empty.
+* zero. Reference layout keeps inherited spacing when the empty paragraph itself is
+* authored through direct `w:pPr` formatting or an explicit `w:pStyle`.
 */
 function getSpacingBefore(block) {
 	const value = block.attrs?.spacing?.before ?? 0;
 	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.before) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.spacingExplicit?.before) return 0;
 	return value;
 }
 /**
@@ -87,9 +96,59 @@ function getSpacingBefore(block) {
 function getSpacingAfter(block) {
 	const value = block.attrs?.spacing?.after ?? 0;
 	if (value === 0) return 0;
-	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.spacingExplicit?.after) return 0;
+	if (isEmptyParagraph(block) && !block.attrs?.styleId && !block.attrs?.hasDirectParagraphFormatting && !block.attrs?.spacingExplicit?.after) return 0;
 	return value;
 }
+function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex, incomingSpacing, columnCount, availableHeight }) {
+	if (columnCount <= 1 || startIndex >= endIndex || availableHeight <= 0) return;
+	const lineUnits = [];
+	let totalHeight = 0;
+	let tallestUnit = 0;
+	let trailingSpacing = incomingSpacing;
+	for (let index = startIndex; index < endIndex; index++) {
+		const block = blocks[index];
+		const measure = measures[index];
+		if (block?.kind !== "paragraph" || measure?.kind !== "paragraph") return;
+		if (block.attrs?.keepNext === true || block.attrs?.keepLines === true || block.runs.some((run) => run.kind === "text" && run.footnoteRefId !== void 0)) return;
+		const leadingSpacing = Math.max(getSpacingBefore(block), trailingSpacing);
+		if (measure.lines.length === 0) {
+			if (leadingSpacing > 0) {
+				lineUnits.push(leadingSpacing);
+				totalHeight += leadingSpacing;
+				tallestUnit = Math.max(tallestUnit, leadingSpacing);
+			}
+		}
+		for (let lineIndex = 0; lineIndex < measure.lines.length; lineIndex++) {
+			const line = measure.lines[lineIndex];
+			if (!line) continue;
+			const unitHeight = measuredLineAdvance(line) + (lineIndex === 0 ? leadingSpacing : 0);
+			lineUnits.push(unitHeight);
+			totalHeight += unitHeight;
+			tallestUnit = Math.max(tallestUnit, unitHeight);
+		}
+		if (tallestUnit > availableHeight || totalHeight > availableHeight * columnCount) return;
+		trailingSpacing = getSpacingAfter(block);
+	}
+	if (totalHeight <= 0) return;
+	const columnsNeeded = (targetHeight) => {
+		let usedHeight = 0;
+		let usedColumns = 1;
+		for (const unitHeight of lineUnits) if (usedHeight > 0 && usedHeight + unitHeight > targetHeight) {
+			usedColumns += 1;
+			usedHeight = unitHeight;
+		} else usedHeight += unitHeight;
+		return usedColumns;
+	};
+	let lower = Math.max(tallestUnit, totalHeight / columnCount);
+	let upper = Math.min(totalHeight, availableHeight);
+	if (columnsNeeded(upper) > columnCount) return;
+	for (let iteration = 0; iteration < 32; iteration++) {
+		const middle = (lower + upper) / 2;
+		if (columnsNeeded(middle) <= columnCount) upper = middle;
+		else lower = middle;
+	}
+	return Math.ceil(upper * 1e3) / 1e3;
+}
 function hasWidowControl(block) {
 	return block.attrs?.widowControl !== false;
 }
@@ -123,6 +182,24 @@ function applyContextualSpacing(blocks) {
 	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyContextualSpacing(cell.blocks);
 	else if (block.kind === "textBox") applyContextualSpacing(block.content);
 }
+/** Suppress automatic inter-item spacing within one numbered sequence. */
+const applyAutomaticListSpacing = (blocks) => {
+	for (let index = 1; index < blocks.length; index++) {
+		const previous = blocks[index - 1];
+		const current = blocks[index];
+		if (previous?.kind !== "paragraph" || current?.kind !== "paragraph" || !continuesNumberedSequence(previous, current)) continue;
+		if (previous.attrs?.automaticSpacing?.after && previous.attrs.spacing) previous.attrs.spacing = {
+			...previous.attrs.spacing,
+			after: 0
+		};
+		if (current.attrs?.automaticSpacing?.before && current.attrs.spacing) current.attrs.spacing = {
+			...current.attrs.spacing,
+			before: 0
+		};
+	}
+	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyAutomaticListSpacing(cell.blocks);
+	else if (block.kind === "textBox") applyAutomaticListSpacing(block.content);
+};
 /**
 * Layout a document: convert blocks + measures into pages with positioned fragments.
 *
@@ -171,6 +248,7 @@ function layoutDocument(blocks, measures, options) {
 		...options.sectionHeaderFooterRefs !== void 0 ? { sectionHeaderFooterRefs: options.sectionHeaderFooterRefs } : {}
 	});
 	applyContextualSpacing(blocks);
+	applyAutomaticListSpacing(blocks);
 	const keepNextChains = computeKeepNextChains(blocks);
 	const midChainIndices = getMidChainIndices(keepNextChains);
 	const blocksById = /* @__PURE__ */ new Map();
@@ -179,7 +257,7 @@ function layoutDocument(blocks, measures, options) {
 	let activeSectionMarginTop = initialConfig.margins.top;
 	let activeSectionPageHeight = initialConfig.pageSize.h;
 	let activeSectionMarginBottom = initialConfig.margins.bottom;
-	let naturalPageAdvanceSinceRenderedBreak = false;
+	let naturalPageAdvanceSinceRenderedBreak = "none";
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
@@ -187,13 +265,15 @@ function layoutDocument(blocks, measures, options) {
 		if (hasPageBreakBefore(block)) paginator.forcePageBreak();
 		else if (hasRenderedPageBreak) {
 			const state = paginator.getCurrentState();
-			if (!(block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
+			if (!(pageStartsWithPreviousParagraphContinuation(state.page, blocks[i - 1]) || naturalPageAdvanceSinceRenderedBreak === "reflowBoundary" || block.kind === "paragraph" && isPaginationEmptyParagraph(block) && naturalPageAdvanceSinceRenderedBreak !== "none" || naturalPageAdvanceSinceRenderedBreak !== "none" && continuesNumberedSequence(blocks[i - 1], block)) && pageHasVisibleBodyContent(state.page, blocksById)) paginator.forcePageBreak();
 		}
-		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = false;
+		if (hasRenderedPageBreak || hasPageBreakBefore(block)) naturalPageAdvanceSinceRenderedBreak = "none";
 		const chain = keepNextChains.get(i);
 		if (chain && !midChainIndices.has(i)) {
 			const chainHeight = calculateChainHeight(chain, blocks, measures);
+			const pageBeforeChainLayout = paginator.getCurrentState().page.number;
 			paginator.ensureFits(chainHeight);
+			if (paginator.getCurrentState().page.number > pageBeforeChainLayout) naturalPageAdvanceSinceRenderedBreak = "reflowBoundary";
 		}
 		const pageBeforeBlockLayout = paginator.getCurrentState().page.number;
 		switch (block.kind) {
@@ -224,6 +304,23 @@ function layoutDocument(blocks, measures, options) {
 			case "sectionBreak": {
 				const nextSectionConfig = sectionConfigs[sectionIdx + 1] ?? initialConfig;
 				handleSectionBreak(block, paginator, nextSectionConfig, sectionBreakTypes[sectionIdx + 1] ?? sectionBreakTypes[sectionIdx], sectionIdx + 1);
+				const nextColumns = nextSectionConfig.columns;
+				const nextBreakIndex = breakIndices[sectionIdx + 1] ?? blocks.length;
+				const nextBreak = blocks[nextBreakIndex];
+				const sectionEndsContinuously = nextBreakIndex === blocks.length || nextBreak?.kind === "sectionBreak" && nextBreak.type === "continuous";
+				if (nextColumns && sectionEndsContinuously) {
+					const state = paginator.getCurrentState();
+					const balancedHeight = balancedParagraphSectionHeight({
+						blocks,
+						measures,
+						startIndex: i + 1,
+						endIndex: nextBreakIndex,
+						incomingSpacing: state.trailingSpacing,
+						columnCount: nextColumns.count,
+						availableHeight: paginator.getAvailableHeight()
+					});
+					if (balancedHeight !== void 0) state.contentBottom = Math.min(state.contentBottom, state.cursorY + balancedHeight);
+				}
 				activeSectionMarginTop = nextSectionConfig.margins.top;
 				activeSectionPageHeight = nextSectionConfig.pageSize.h;
 				activeSectionMarginBottom = nextSectionConfig.margins.bottom;
@@ -233,8 +330,8 @@ function layoutDocument(blocks, measures, options) {
 			default: break;
 		}
 		const isVisibleBodyBlock = block.kind === "paragraph" ? !isEmptyParagraph(block) : block.kind !== "pageBreak" && block.kind !== "columnBreak" && block.kind !== "sectionBreak";
-		if (block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak") naturalPageAdvanceSinceRenderedBreak = false;
-		else if (isVisibleBodyBlock && paginator.getCurrentState().page.number > pageBeforeBlockLayout) naturalPageAdvanceSinceRenderedBreak = true;
+		if (block.kind === "pageBreak" || block.kind === "columnBreak" || block.kind === "sectionBreak") naturalPageAdvanceSinceRenderedBreak = "none";
+		else if (isVisibleBodyBlock && paginator.getCurrentState().page.number > pageBeforeBlockLayout) naturalPageAdvanceSinceRenderedBreak = paginator.pages[pageBeforeBlockLayout - 1]?.fragments.some(({ blockId }) => blockId === block.id) ? "reflowBoundary" : "ordinary";
 	}
 	if (paginator.pages.length === 0) paginator.getCurrentState();
 	return {
@@ -429,9 +526,10 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		let x = paginator.getColumnX(columnIndex);
 		if (block.justification === "center") x += (paginator.columnWidth - measure.totalWidth) / 2;
 		else if (block.justification === "right") x = x + paginator.columnWidth - measure.totalWidth;
+		else if (block.indent !== void 0) x += block.indent;
 		else {
 			const leadingCellMargin = block.rows.at(0)?.cells.at(0)?.padding?.left ?? 0;
-			x += (block.indent ?? 0) - leadingCellMargin;
+			x -= leadingCellMargin;
 		}
 		return x;
 	};
@@ -638,9 +736,10 @@ function layoutFloatingTable(block, measure, paginator, contentWidth) {
 		else if (spec === "center") y = baseY + (contentHeight - tableHeight) / 2;
 	}
 	if (!usedExplicitY) y = paginator.ensureFits(tableHeight).cursorY;
-	const pageAnchored = floating?.horzAnchor === "page";
-	const minX = pageAnchored ? 0 : margins.left;
-	const maxX = pageAnchored ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
+	const usesNumericOffset = floating?.tblpX !== void 0;
+	const clampToPage = floating?.horzAnchor === "page" || usesNumericOffset;
+	const minX = clampToPage ? 0 : margins.left;
+	const maxX = clampToPage ? page.size.w - tableWidth : margins.left + contentWidth - tableWidth;
 	if (Number.isFinite(maxX)) x = Math.max(minX, Math.min(x, maxX));
 	const fragment = {
 		kind: "table",

package/dist/layout-engine/keep-together.d.ts

@@ -2,8 +2,9 @@ import { FlowBlock, Measure } from "./types.js";
 
 //#region src/layout-engine/keep-together.d.ts
 /**
- * A chain of keepNext-linked paragraphs, including empty separators Word
- * carries through to the next paragraph with visible content.
+ * A chain of paragraphs that Word keeps with following content. This includes
+ * explicit keepNext links and a trailing table separator that would otherwise
+ * be stranded at the bottom of a page.
  */
 type KeepNextChain = {
   /** Index of the first paragraph in the chain. */startIndex: number; /** Index of the last keepNext or pass-through empty member. */
@@ -14,9 +15,10 @@ type KeepNextChain = {
 /**
  * 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.
  */

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/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.js

@@ -72,6 +72,7 @@ function createPaginator(options) {
 		return pageMargins;
 	}
 	let columnRegionTop = margins.top;
+	let columnRegionMaxBottom = margins.top;
 	/**
 	* Get X position for a given column index.
 	*/
@@ -114,6 +115,7 @@ function createPaginator(options) {
 		pages.push(page);
 		states.push(state);
 		columnRegionTop = topMargin;
+		columnRegionMaxBottom = topMargin;
 		if (options.onNewPage) options.onNewPage(state);
 		return state;
 	}
@@ -143,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;
@@ -159,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;
 			}
@@ -276,12 +279,17 @@ function createPaginator(options) {
 	* column advancement stays below existing content (for continuous breaks).
 	*/
 	function updateColumns(newColumns) {
+		const previousColumnCount = columns.count;
+		const state = getCurrentState();
+		const previousRegionBottom = Math.max(columnRegionMaxBottom, state.cursorY);
 		columns = newColumns;
 		recalculateColumnWidths();
-		const state = getCurrentState();
 		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) {

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;

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])) {
@@ -914,7 +996,7 @@ function renderLine(block, line, alignment, doc, options) {
 			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";
@@ -989,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;
@@ -1003,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, {

package/dist/prosemirror/conversion/toProseDoc.js

@@ -549,6 +549,7 @@ function convertTable(table, styleResolver, context) {
 	const fallbackTableStyle = tableStyleId ? void 0 : defaultTableStyle;
 	const conditionalTableStyleId = tableStyle?.styleId ?? fallbackTableStyle?.styleId;
 	const resolvedTableBorders = table.formatting?.borders ?? tableStyle?.tblPr?.borders ?? fallbackTableStyle?.tblPr?.borders;
+	const resolvedTableIndent = table.formatting?.indent ?? tableStyle?.tblPr?.indent ?? fallbackTableStyle?.tblPr?.indent;
 	const tableCellMargins = table.formatting?.cellMargins ?? tableStyle?.tblPr?.cellMargins ?? fallbackTableStyle?.tblPr?.cellMargins;
 	let cellMarginsAttr;
 	if (tableCellMargins) {
@@ -569,6 +570,7 @@ function convertTable(table, styleResolver, context) {
 	if (cellMarginsAttr) attrs.cellMargins = cellMarginsAttr;
 	if (table.formatting?.look) attrs.look = table.formatting.look;
 	if (table.formatting?.borders) attrs.borders = table.formatting.borders;
+	if (resolvedTableIndent) attrs._resolvedIndent = resolvedTableIndent;
 	if (table.formatting) attrs._originalFormatting = table.formatting;
 	if (table.propertyChanges && table.propertyChanges.length > 0) attrs.tblPrChange = [...table.propertyChanges];
 	const conditionalStyles = {};