@stll/folio-core 0.10.0 → 0.12.0

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

@@ -27,6 +27,13 @@ const segmenterLocale = (locale) => {
 };
 const DICTIONARY_BREAK_SCRIPT = /[\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
 const CJK_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const WORD_HANGING_PUNCTUATION_LANGUAGES = /* @__PURE__ */ new Set([
+	"ii",
+	"ja",
+	"ko",
+	"zh"
+]);
+const SIMPLE_BREAK_TEXT = /^[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Number}\p{Punctuation}\p{White_Space}]*$/u;
 const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"-",
 	"֊",
@@ -42,13 +49,10 @@ const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"​",
 	"­"
 ]);
-const CZECH_ONE_LETTER_PREPOSITIONS = /* @__PURE__ */ new Set([
-	"k",
-	"o",
-	"s",
-	"u",
-	"v",
-	"z"
+const NONBREAKING_SPACES = /* @__PURE__ */ new Set([
+	"\xA0",
+	" ",
+	" "
 ]);
 const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
 	"!",
@@ -132,30 +136,6 @@ const isLegacyEthiopicBreakCharacter = (character, policy) => {
 	const codePoint = character.codePointAt(0);
 	return codePoint !== void 0 && codePoint >= 4961 && codePoint <= 4968;
 };
-const czechProtectedBreaks = (text, policy) => {
-	const breaks = /* @__PURE__ */ new Set();
-	if (segmenterLocale(policy?.locale) !== "cs") return breaks;
-	let tokenStart = 0;
-	let index = 0;
-	while (index < text.length) {
-		const character = firstCodePoint(text, index);
-		if (character === void 0) break;
-		if (!/\s/u.test(character)) {
-			index += character.length;
-			continue;
-		}
-		const token = text.slice(tokenStart, index);
-		const protectsNextWord = token.length === 1 && CZECH_ONE_LETTER_PREPOSITIONS.has(token.toLocaleLowerCase("cs"));
-		while (index < text.length) {
-			const whitespace = firstCodePoint(text, index);
-			if (whitespace === void 0 || !/\s/u.test(whitespace)) break;
-			index += whitespace.length;
-			if (protectsNextWord) breaks.add(index);
-		}
-		tokenStart = index;
-	}
-	return breaks;
-};
 const allowsBreak = (text, index, policy) => {
 	const previous = previousCodePoint(text, index);
 	const next = firstCodePoint(text, index);
@@ -165,7 +145,20 @@ const pushBreak = (breaks, text, index, policy) => {
 	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
 	if (allowsBreak(text, index, policy)) breaks.push(index);
 };
+const findSimpleGraphemeBreaks = (text) => {
+	if (!SIMPLE_BREAK_TEXT.test(text)) return;
+	const breaks = [];
+	for (let index = 0; index < text.length; index += 1) {
+		const codeUnit = text.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 57343) return;
+		if (codeUnit === 13 && text.charCodeAt(index + 1) === 10) index += 1;
+		breaks.push(index + 1);
+	}
+	return breaks;
+};
 const findUnicodeGraphemeBreaks = (text, policy) => {
+	const simpleBreaks = findSimpleGraphemeBreaks(text);
+	if (simpleBreaks !== void 0) return simpleBreaks;
 	const breaks = [];
 	for (const segment of getSegmenter(graphemeSegmenters, "grapheme", policy?.locale).segment(text)) {
 		const end = segment.index + segment.segment.length;
@@ -173,13 +166,38 @@ const findUnicodeGraphemeBreaks = (text, policy) => {
 	}
 	return breaks;
 };
+const isSimpleWhitespace = (character, codePoint) => codePoint === 32 || codePoint >= 9 && codePoint <= 13 || codePoint > 127 && /\s/u.test(character);
+/**
+* Find the complete set of Unicode line-break opportunities for simple text
+* without invoking `Intl.Segmenter`.
+*
+* Latin, Cyrillic, and Greek letters plus ordinary numbers, punctuation, and
+* spacing are single grapheme clusters, except CRLF, which Unicode treats as
+* one cluster. Returning `undefined` for combining marks, astral characters,
+* dictionary-segmented scripts, CJK, and other complex input keeps the full
+* Unicode provider responsible for those cases.
+*/
+const findSimpleBreaks = (text, policy) => {
+	if (!SIMPLE_BREAK_TEXT.test(text)) return;
+	const breaks = [];
+	for (let index = 0; index < text.length; index += 1) {
+		const codePoint = text.charCodeAt(index);
+		if (codePoint >= 55296 && codePoint <= 57343) return;
+		if (codePoint === 13 && text.charCodeAt(index + 1) === 10) continue;
+		const character = text[index];
+		if (isSimpleWhitespace(character, codePoint) && !NONBREAKING_SPACES.has(character) || BREAK_AFTER_CHARACTER.has(character) || isLegacyEthiopicBreakCharacter(character, policy)) pushBreak(breaks, text, index + 1, policy);
+	}
+	return breaks;
+};
 const findUnicodeBreaks = (text, policy) => {
 	if (text.length === 0) return [];
+	const simpleBreaks = findSimpleBreaks(text, policy);
+	if (simpleBreaks !== void 0) return simpleBreaks;
 	const breaks = [];
 	const graphemeBreaks = findUnicodeGraphemeBreaks(text, policy);
 	for (const index of graphemeBreaks) {
 		const previous = previousCodePoint(text, index);
-		if (previous !== void 0 && (/\s/u.test(previous) || BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy);
+		if (previous !== void 0 && (/\s/u.test(previous) && !NONBREAKING_SPACES.has(previous) || BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy);
 	}
 	const wordSegments = [...getSegmenter(wordSegmenters, "word", policy?.locale).segment(text)];
 	for (const [segmentIndex, segment] of wordSegments.entries()) {
@@ -191,8 +209,7 @@ const findUnicodeBreaks = (text, policy) => {
 		const previous = previousCodePoint(text, index);
 		if (isCjkLineBreakParticipant(previous, policy)) pushBreak(breaks, text, index, policy);
 	}
-	const protectedBreaks = czechProtectedBreaks(text, policy);
-	return [...new Set(breaks)].filter((index) => !protectedBreaks.has(index)).sort((left, right) => left - right);
+	return [...new Set(breaks)].sort((left, right) => left - right);
 };
 const hyphenatorFor = (locale) => {
 	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase();
@@ -226,6 +243,8 @@ const findPatternHyphenationBreaks = (text, policy) => {
 	return sourceOffset === text.length ? breaks : [];
 };
 const isDefaultHangingPunctuation = (text, policy) => {
+	const language = segmenterLocale(policy?.locale);
+	if (!language || !WORD_HANGING_PUNCTUATION_LANGUAGES.has(language)) return false;
 	const characters = [...text];
 	return characters.length > 0 && characters.every((character) => isProhibitedLineStart(character, policy));
 };

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

@@ -2,7 +2,7 @@ import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWr
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
-import { layoutTextBoxParagraphs } from "./textBoxParagraphLayout.js";
+import { layoutTextBoxContent } from "./textBoxParagraphLayout.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { isParagraphFrameTextBox } from "../paragraphFrame.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
@@ -439,8 +439,11 @@ function measureBlock(block, contentWidth, floatingZones, cumulativeY, fieldValu
 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 contentBoxHeight = layoutTextBoxParagraphs(tb.content, innerMeasures).totalHeight + margins.top + margins.bottom;
+	const innerMeasures = tb.content.map((block) => {
+		if (block.kind === "table") return measureTableBlock(block, innerWidth, fieldValues);
+		return measureParagraph(block, innerWidth, fieldValues ? { fieldValues } : void 0);
+	});
+	const contentBoxHeight = layoutTextBoxContent(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",

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

@@ -1,5 +1,5 @@
-import { setMeasureProvider } from "./measureProvider.js";
 import { getFontKerningMode } from "./textMeasurementPolicy.js";
+import { setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
 import { hasCjk, isCjkCodePoint, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";

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

@@ -34,7 +34,7 @@ declare function getResolvedData(fontFamily: string): ResolvedFontCache;
  *
  * @example
  * buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
- * // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+ * // Returns: "700 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
  */
 declare function buildFontString(style: FontStyle): string;
 /**

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

@@ -1,6 +1,6 @@
 import { resolveFontFamily } from "../../utils/fontResolver.js";
-import "../../utils/fontWeights.js";
 import { FONT_KERNING_MODE, getRunFontKerningMode } from "./textMeasurementPolicy.js";
+import "../../utils/fontWeights.js";
 //#region src/layout-engine/measure/measureHelpers.ts
 /**
 * Pure measurement helpers — no canvas, no DOM, no worker.
@@ -73,13 +73,13 @@ function getResolvedFallback(fontFamily) {
 *
 * @example
 * buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
-* // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+* // Returns: "700 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
 */
 function buildFontString(style) {
 	const parts = [];
 	if (style.italic) parts.push("italic");
 	if (style.fontVariant) parts.push(style.fontVariant);
-	if (style.bold) parts.push("800");
+	if (style.bold) parts.push("700");
 	const fontSizePx = ptToPx(style.fontSize ?? 11);
 	parts.push(`${fontSizePx}px`);
 	const fontFamily = style.fontFamily ?? "Calibri";

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

@@ -1,8 +1,8 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
-import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
+import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
-import "./lineBreakProvider.js";
+import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { hasCjk } from "../../utils/scriptSegments.js";
@@ -27,7 +27,9 @@ const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
 const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
 const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
-const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .23;
+const JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO = .022;
+const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .32;
+const JUSTIFY_LIST_CONTINUATION_MAX_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
@@ -137,7 +139,7 @@ const WORD_SINGLE_LINE_FLOOR = 1.15;
 * `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
 * and stays untouched.
 */
-function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily) {
+function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
 	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
 		fontSize,
 		fontFamily: fontFamily ?? DEFAULT_FONT_FAMILY
@@ -145,12 +147,22 @@ function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily) {
 	const lineRule = spacing?.lineRule ?? "auto";
 	if (lineRule === "auto" || lineRule === "atLeast") {
 		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
-		if (result.lineHeight < floor) return {
+		if (result.lineHeight < floor) return applyDocumentGrid({
 			...result,
 			lineHeight: floor
-		};
+		}, attrs, spacing);
 	}
-	return result;
+	return applyDocumentGrid(result, attrs, spacing);
+}
+function applyDocumentGrid(typography, attrs, spacing) {
+	const pitch = attrs?.documentGridLinePitch;
+	if (pitch === void 0 || pitch <= 0 || attrs?.snapToGrid === false) return typography;
+	if (spacing?.lineRule === "exact") return typography;
+	const lineHeight = Math.ceil(typography.lineHeight / pitch - 1e-9) * pitch;
+	return lineHeight === typography.lineHeight ? typography : {
+		...typography,
+		lineHeight
+	};
 }
 /**
 * Check if a run is a text run
@@ -344,6 +356,7 @@ function uppercaseLetterRatio(text) {
 	return letters === 0 ? 0 : uppercase / letters;
 }
 function resolveJustifyFitStrategy(block, isFirstLine, profile) {
+	if (block.attrs?.justificationCompatibility?.type === "legacy") return { type: "strict" };
 	if (isShallowFullHangingListContinuation(block, isFirstLine)) return { type: "rounding" };
 	if (block.attrs?.listMarker !== void 0) {
 		const hanging = block.attrs.indent?.hanging ?? 0;
@@ -352,7 +365,7 @@ function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 			ratio: JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO
 		} : {
 			type: "width",
-			ratio: JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO
+			ratio: JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO
 		};
 		const left = block.attrs.indent?.left ?? 0;
 		if (hanging > 0 && left > hanging) return {
@@ -361,7 +374,8 @@ function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 		};
 		return {
 			type: "space",
-			ratio: JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO
+			ratio: JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO,
+			maxWidthRatio: JUSTIFY_LIST_CONTINUATION_MAX_SHRINK_TOLERANCE_RATIO
 		};
 	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
@@ -391,9 +405,12 @@ function compressibleSpaceWidth(text, style) {
 	return count === 0 ? 0 : count * measureTextWidth(" ", style);
 }
 function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
+	if (strategy.type === "strict") return 0;
 	if (strategy.type === "rounding") return WIDTH_TOLERANCE;
 	if (strategy.type === "width") return Math.max(WIDTH_TOLERANCE, line.availableWidth * strategy.ratio);
-	return Math.max(WIDTH_TOLERANCE, (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio);
+	const spaceTolerance = (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio;
+	const boundedTolerance = strategy.maxWidthRatio === void 0 ? spaceTolerance : Math.min(spaceTolerance, line.availableWidth * strategy.maxWidthRatio);
+	return Math.max(WIDTH_TOLERANCE, boundedTolerance);
 }
 function isShallowFullHangingListContinuation(block, isFirstLine) {
 	if (isFirstLine || block.attrs?.listMarker === void 0) return false;
@@ -410,8 +427,20 @@ function trimTrailingSpacesAndTabs(text) {
 	}
 	return text.slice(0, end);
 }
+function trailingCodePoint(text) {
+	if (text.length === 0) return;
+	const trailing = text.charCodeAt(text.length - 1);
+	const preceding = text.charCodeAt(text.length - 2);
+	const start = trailing >= 56320 && trailing <= 57343 && preceding >= 55296 && preceding <= 56319 ? text.length - 2 : text.length - 1;
+	return text.slice(start);
+}
+const usesDefaultHangingPunctuationClassifier = () => {
+	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation) === defaultLineBreakProvider.isHangingPunctuation;
+};
 function trailingHangingPunctuationWidth(text, style, policy, enabled) {
 	if (!enabled || text.length === 0) return 0;
+	const trailing = trailingCodePoint(text);
+	if (usesDefaultHangingPunctuationClassifier() && !isHangingPunctuation(trailing ?? "", policy)) return 0;
 	const lastStart = findGraphemeBreaks(text, policy).at(-2) ?? 0;
 	const lastGrapheme = text.slice(lastStart);
 	if (!isHangingPunctuation(lastGrapheme, policy)) return 0;
@@ -448,13 +477,14 @@ function computeProtectedCrossRunGlueWidths(block) {
 	for (let index = 0; index < block.runs.length; index++) {
 		const run = block.runs[index];
 		if (!run || !isTextRun(run)) continue;
-		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
-		const token = trailing?.[1];
 		const policy = resolveEffectiveLineBreakPolicy({
 			attrs: block.attrs,
 			run
 		}).provider;
-		if (!token || token.length !== 1 || !policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
+		if (!policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
+		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
+		const token = trailing?.[1];
+		if (!token || token.length !== 1) continue;
 		let separator = trailing[2] ?? "";
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
 		let followingWord = "";
@@ -655,7 +685,7 @@ function measureParagraph(block, maxWidth, options) {
 				totalHeight: 0
 			};
 		}
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -675,9 +705,8 @@ function measureParagraph(block, maxWidth, options) {
 			totalHeight
 		};
 	}
-	if (runs.length === 1 && isTextRun(runs[0]) && isEmptyTextRun(runs[0])) {
-		const run = runs[0];
-		const emptyMetrics = calculateEmptyParagraphMetrics(run.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, run.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+	if (runs.length > 0 && runs.every((run) => isTextRun(run) && isEmptyTextRun(run))) {
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -733,7 +762,7 @@ function measureParagraph(block, maxWidth, options) {
 				finalTypography.lineHeight = objectHeight;
 				finalTypography.ascent = objectHeight;
 				finalTypography.descent = 0;
-				return finalTypography;
+				return applyDocumentGrid(finalTypography, attrs, spacing);
 			}
 			if (soleRun && isImageRun(soleRun)) {
 				finalTypography.lineHeight = objectHeight;
@@ -744,7 +773,7 @@ function measureParagraph(block, maxWidth, options) {
 				finalTypography.ascent = objectHeight;
 			}
 		}
-		return finalTypography;
+		return applyDocumentGrid(finalTypography, attrs, spacing);
 	};
 	const getPostWrapAvailableWidth = () => {
 		if (!floatingZones || floatingZones.length === 0) return bodyContentWidth;
@@ -769,7 +798,8 @@ function measureParagraph(block, maxWidth, options) {
 			toChar: currentLine.toChar,
 			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography,
-			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {}
+			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {},
+			...currentLine.renderedPageBreakBefore ? { renderedPageBreakBefore: true } : {}
 		};
 		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
 		if (currentLine.rightOffset > 0) line.rightOffset = currentLine.rightOffset;
@@ -827,6 +857,22 @@ function measureParagraph(block, maxWidth, options) {
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
 		if (crossRunResume && runIndex < crossRunResume.runIndex) continue;
 		const run = runs[runIndex];
+		if (run.kind === "renderedPageBreak") {
+			if (!runs.slice(runIndex + 1).some((followingRun) => followingRun.kind !== "renderedPageBreak")) {
+				currentLine.toRun = runIndex;
+				currentLine.toChar = 0;
+				continue;
+			}
+			if (currentLine.width > 0 || currentLine.maxImageHeightPx > 0 || currentLine.maxMathHeightPx > 0) startNewLine(runIndex + 1, 0);
+			else {
+				currentLine.fromRun = runIndex + 1;
+				currentLine.toRun = runIndex + 1;
+				currentLine.fromChar = 0;
+				currentLine.toChar = 0;
+			}
+			currentLine.renderedPageBreakBefore = true;
+			continue;
+		}
 		if (isLineBreakRun(run)) {
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 0;
@@ -952,13 +998,11 @@ function measureParagraph(block, maxWidth, options) {
 			const wordBreaks = findWordBreaks(text, breakPolicy);
 			let charIndex = crossRunResume?.runIndex === runIndex ? crossRunResume.charIndex : 0;
 			if (crossRunResume?.runIndex === runIndex) crossRunResume = void 0;
+			let wordBreakIndex = 0;
 			let activeHyphenationWord;
 			while (charIndex < text.length) {
-				let nextBreak = text.length;
-				for (const breakPoint of wordBreaks) if (breakPoint > charIndex) {
-					nextBreak = breakPoint;
-					break;
-				}
+				while ((wordBreaks[wordBreakIndex] ?? Number.POSITIVE_INFINITY) <= charIndex) wordBreakIndex += 1;
+				const nextBreak = wordBreaks[wordBreakIndex] ?? text.length;
 				const word = text.slice(charIndex, nextBreak);
 				const measuredWord = trimTrailingSpacesAndTabs(word);
 				const wordWidth = measureTextWidth(measuredWord, style);

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

@@ -1,3 +1,4 @@
+import { toPaintedText } from "./textMeasurementPolicy.js";
 import { panic } from "better-result";
 //#region src/layout-engine/measure/measureProvider.ts
 /**
@@ -28,8 +29,8 @@ const resetMeasureProvider = () => {
 	activeMeasureProvider = throwingMeasureProvider;
 };
 const getFontMetrics = (style) => activeMeasureProvider.getFontMetrics(style);
-const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(text, style);
-const measureText = (text, style) => activeMeasureProvider.measureText(text, style);
-const measureRun = (text, style) => activeMeasureProvider.measureRun(text, style);
+const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(toPaintedText(text), style);
+const measureText = (text, style) => activeMeasureProvider.measureText(toPaintedText(text), style);
+const measureRun = (text, style) => activeMeasureProvider.measureRun(toPaintedText(text), style);
 //#endregion
 export { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };

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

@@ -1,6 +1,6 @@
 import { measuredLineRangeHeight } from "../lineFlow.js";
 import { isFloatingTextBoxBlock } from "../types.js";
-import { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph } from "../paragraphSpacing.js";
 //#region src/layout-engine/measure/tableCellFlow.ts
 const createTableCellFlowState = () => ({
 	height: 0,
@@ -57,7 +57,10 @@ const placeTableCellBlock = (state, block, measure) => {
 	}
 	const spacing = paragraphSpacing(block, measure);
 	const empty = isEmptyParagraph(block);
-	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : Math.max(spacing.before, state.trailingSpacing);
+	const leadingSpacing = empty && state.previousParagraphWasEmpty ? spacing.before + state.trailingSpacing : collapseParagraphSpacing({
+		before: spacing.before,
+		after: state.trailingSpacing
+	});
 	const contentTop = top + leadingSpacing;
 	state.height = contentTop + contentHeight;
 	state.previousParagraphWasEmpty = empty;

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

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

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

@@ -1,20 +1,36 @@
 import { measuredLineRangeHeight } from "../lineFlow.js";
-import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "../paragraphSpacing.js";
+import { collapseParagraphSpacing, 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
+* Lay out a text box's block story as one unpaginated flow. Adjacent paragraph
 * 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");
+function layoutTextBoxContent(blocks, measures) {
+	if (blocks.length !== measures.length) panic("layoutTextBoxContent: 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);
+		if (block.kind === "table") {
+			if (measure.kind !== "table") panic("layoutTextBoxContent: block and measure kinds must match");
+			const leadingSpacing = trailingSpacing;
+			const contentHeight = measure.totalHeight;
+			placements.push({
+				leadingSpacing,
+				contentHeight
+			});
+			totalHeight += leadingSpacing + contentHeight;
+			trailingSpacing = 0;
+			continue;
+		}
+		if (measure.kind !== "paragraph") panic("layoutTextBoxContent: block and measure kinds must match");
+		const leadingSpacing = collapseParagraphSpacing({
+			before: getParagraphSpacingBefore(block),
+			after: trailingSpacing
+		});
 		const contentHeight = measuredLineRangeHeight(measure.lines, 0, measure.lines.length);
 		placements.push({
 			leadingSpacing,
@@ -29,4 +45,4 @@ function layoutTextBoxParagraphs(blocks, measures) {
 	};
 }
 //#endregion
-export { layoutTextBoxParagraphs };
+export { layoutTextBoxContent };

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

@@ -14,5 +14,7 @@ declare function getRunFontKerningMode(run: RunKerningInput, fallbackFontSize: n
 declare function getFontKerningMode(style: Pick<FontStyle, "kerning">): FontKerningMode;
 /** Count ordinary ASCII spaces that justification may compress. */
 declare function countCompressibleSpaces(text: string): number;
+/** Paint OOXML no-break hyphens with the ordinary hyphen glyph. */
+declare function toPaintedText(text: string): string;
 //#endregion
-export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };
+export { FONT_KERNING_MODE, FontKerningMode, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText };

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

@@ -3,6 +3,8 @@ const FONT_KERNING_MODE = {
 	enabled: "normal",
 	disabled: "none"
 };
+const NO_BREAK_HYPHEN = "‑";
+const PAINTED_HYPHEN = "-";
 /** Resolve an authored kerning threshold against the effective run size. */
 function getRunFontKerningMode(run, fallbackFontSize) {
 	const threshold = run.kerningMinPt;
@@ -20,5 +22,9 @@ function countCompressibleSpaces(text) {
 	for (const char of text) if (char === " ") count += 1;
 	return count;
 }
+/** Paint OOXML no-break hyphens with the ordinary hyphen glyph. */
+function toPaintedText(text) {
+	return text.replaceAll(NO_BREAK_HYPHEN, PAINTED_HYPHEN);
+}
 //#endregion
-export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode };
+export { FONT_KERNING_MODE, countCompressibleSpaces, getFontKerningMode, getRunFontKerningMode, toPaintedText };

package/dist/layout-engine/paginator.js

@@ -1,4 +1,5 @@
 import { FOOTNOTE_SEPARATOR_HEIGHT } from "./types.js";
+import { collapseParagraphSpacing } from "./paragraphSpacing.js";
 import { panic } from "better-result";
 //#region src/layout-engine/paginator.ts
 /**
@@ -178,7 +179,10 @@ function createPaginator(options) {
 	function addFragment(fragment, height, spaceBefore = 0, spaceAfter = 0) {
 		const initialState = getCurrentState();
 		const initialColumnIndex = initialState.columnIndex;
-		const effectiveSpaceBefore = Math.max(spaceBefore, initialState.trailingSpacing);
+		const effectiveSpaceBefore = collapseParagraphSpacing({
+			before: spaceBefore,
+			after: initialState.trailingSpacing
+		});
 		const state = ensureFits(effectiveSpaceBefore + height);
 		const actualSpaceBefore = state === initialState && state.columnIndex === initialColumnIndex ? effectiveSpaceBefore : spaceBefore;
 		const x = getColumnX(state.columnIndex);

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

@@ -1,17 +1,41 @@
-import { ParagraphBlock } from "./types.js";
+import { FlowBlock, ParagraphBlock } from "./types.js";
 
 //#region src/layout-engine/paragraphSpacing.d.ts
+type EffectiveParagraphSpacing = Readonly<{
+  before: number;
+  after: number;
+}>;
+type CollapseParagraphSpacingOptions = {
+  before: number;
+  after: number;
+};
+/** Collapse adjacent paragraph spacing to the larger authored side. */
+declare const collapseParagraphSpacing: ({
+  before,
+  after
+}: CollapseParagraphSpacingOptions) => number;
 /** Whether a paragraph has no visible run content. */
 declare function isEmptyParagraph(block: ParagraphBlock): boolean;
 /**
  * Resolve leading paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare function getParagraphSpacingBefore(block: ParagraphBlock): number;
+declare const getParagraphSpacingBefore: (block: ParagraphBlock) => number;
 /**
  * Resolve trailing paragraph spacing after applying the empty-paragraph
  * inherited-spacing collapse rule.
  */
-declare function getParagraphSpacingAfter(block: ParagraphBlock): number;
+declare const getParagraphSpacingAfter: (block: ParagraphBlock) => number;
+/** Resolve empty-paragraph spacing without modifying the authored block. */
+declare const resolveEffectiveParagraphSpacing: (block: ParagraphBlock) => EffectiveParagraphSpacing;
+/**
+ * Derive sequence-level spacing suppression with structural sharing.
+ *
+ * Contextual and automatic list spacing affect layout values, not authored
+ * OOXML formatting. Only changed branches are cloned; the input tree remains
+ * untouched and repeated resolution is idempotent.
+ */
+declare const resolveEffectiveParagraphSpacingTree: (blocks: FlowBlock[]) => FlowBlock[];
+declare const paragraphsShareStyle: (previous: ParagraphBlock, current: ParagraphBlock) => boolean;
 //#endregion
-export { getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph };
+export { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, isEmptyParagraph, paragraphsShareStyle, resolveEffectiveParagraphSpacing, resolveEffectiveParagraphSpacingTree };