@stll/folio-core 0.47.7 → 0.49.0

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

@@ -1,8 +1,8 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
-import { hasCjk, hasComplexScript } from "../../utils/scriptSegments.js";
-import { JUSTIFIED_FINAL_LINE_MAX_SHRINK_RATIO, JUSTIFIED_FINAL_LINE_SPACE_CONTRACTION_RATIO, supportsJustifiedFinalLineContraction } from "../justifiedLineFit.js";
+import { hasCjk, hasComplexScript, hasEastAsiaSlotText } from "../../utils/scriptSegments.js";
+import { splitTrailingToken } from "../../utils/trailingText.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
@@ -10,9 +10,9 @@ import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./comp
 import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
 import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
-import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
+import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
-import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
+import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
@@ -24,16 +24,14 @@ import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
 * Converts runs into measured lines with typography metrics.
 */
 const DEFAULT_FONT_SIZE = 11;
-const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
-const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
-const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
-const JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO = .022;
+const JUSTIFY_SPACE_CONTRACTION_RATIO = .25;
+const JUSTIFY_STRETCH_PER_SHRINK = 1.7;
+const JUSTIFY_ALWAYS_SHRINK_STRETCH = 1.5;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
-const DEFAULT_LIST_HANGING_INDENT_PX = 24;
 const ALL_CAPS_RATIO_THRESHOLD = .8;
 /**
 * Find the longest prefix of `text` that fits within `maxWidth` pixels.
@@ -85,9 +83,11 @@ function runToFontStyle(run) {
 * keeps the base style so wrapping is untouched.
 */
 function cjkLineHeightStyle(run, baseStyle) {
-	if (!run.text || !hasCjk(run.text)) return baseStyle;
+	if (!run.text) return baseStyle;
 	const eastAsia = baseStyle.eastAsiaFontFamily;
-	if (eastAsia !== void 0 && isCjkFont(eastAsia)) {
+	const eastAsiaFace = eastAsia !== void 0 && isCjkFont(eastAsia);
+	if (!hasCjk(run.text) && !(eastAsiaFace && hasEastAsiaSlotText(run.text, baseStyle.eastAsiaHint))) return baseStyle;
+	if (eastAsia !== void 0 && eastAsiaFace) {
 		const result = {
 			...baseStyle,
 			fontFamily: eastAsia
@@ -96,7 +96,7 @@ function cjkLineHeightStyle(run, baseStyle) {
 		if (baseStyle.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = baseStyle.eastAsiaAlternateFontFamily;
 		return result;
 	}
-	if (isCjkFont(baseStyle.fontFamily ?? DEFAULT_FONT_FAMILY)) return baseStyle;
+	if (isCjkFont(baseStyle.fontFamily ?? "Times New Roman")) return baseStyle;
 	return {
 		...baseStyle,
 		fontFamily: CJK_FALLBACK_FONT_FAMILY
@@ -153,7 +153,7 @@ const WORD_SINGLE_LINE_FLOOR = 1.15;
 function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
 	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
 		fontSize,
-		fontFamily: fontFamily ?? DEFAULT_FONT_FAMILY,
+		fontFamily: fontFamily ?? "Times New Roman",
 		...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
 	}));
 	const lineRule = spacing?.lineRule ?? "auto";
@@ -369,22 +369,6 @@ function uppercaseLetterRatio(text) {
 }
 function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 	if (block.attrs?.justificationCompatibility?.type === "legacy") return { type: "rounding" };
-	if (isShallowFullHangingListContinuation(block, isFirstLine)) return { type: "rounding" };
-	if (block.attrs?.listMarker !== void 0) {
-		const hanging = block.attrs.indent?.hanging ?? 0;
-		if (isFirstLine) return hanging <= DEFAULT_LIST_HANGING_INDENT_PX ? {
-			type: "space",
-			ratio: JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO
-		} : {
-			type: "width",
-			ratio: JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO
-		};
-		return {
-			type: "space",
-			ratio: JUSTIFIED_FINAL_LINE_SPACE_CONTRACTION_RATIO,
-			maxWidthRatio: JUSTIFY_SHRINK_TOLERANCE_RATIO
-		};
-	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
 	if (isFirstLine && profile.hasTabRuns && (block.attrs?.indent?.hanging ?? 0) > 0) return {
 		type: "width",
@@ -407,19 +391,6 @@ function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 		ratio: JUSTIFY_SPACE_CONTRACTION_RATIO
 	};
 }
-function resolveFinalLineJustifyFitStrategy(block, profile) {
-	if (supportsJustifiedFinalLineContraction(block)) return {
-		type: "space",
-		ratio: JUSTIFIED_FINAL_LINE_SPACE_CONTRACTION_RATIO,
-		maxWidthRatio: JUSTIFIED_FINAL_LINE_MAX_SHRINK_RATIO
-	};
-	return resolveJustifyFitStrategy(block, false, profile);
-}
-function resolveCandidateJustifyFitStrategy({ isFirstLine, isFinalCandidate, firstLineStrategy, continuationStrategy, finalLineStrategy }) {
-	if (isFirstLine) return firstLineStrategy;
-	if (isFinalCandidate) return finalLineStrategy;
-	return continuationStrategy;
-}
 const isIgnorableFinalTailRun = (run) => run.kind === "renderedPageBreak" || isTextRun(run) && run.text.length === 0;
 function isFinalTextCandidate(block, runIndex, nextBreak) {
 	const currentRun = block.runs[runIndex];
@@ -431,27 +402,34 @@ function isFinalTextCandidate(block, runIndex, nextBreak) {
 	}
 	return true;
 }
-function resolveTextCandidateFit({ block, line, isFirstLine, isFinalCandidate, candidateWidth, candidateSpaceWidth, fallbackTolerancePx, continuationStrategy, finalStrategy }) {
-	if (!isFinalCandidate || !supportsJustifiedFinalLineContraction(block)) return {
+/**
+* Fit of a text candidate on a justified line: the paragraph's final word may
+* be admitted by shrinking spaces, which then needs a paint plan.
+*/
+function resolveTextCandidateFit(isFinalCandidate, candidateWidth, availableWidth, tolerancePx) {
+	if (!isFinalCandidate) return {
 		type: "ordinary",
-		tolerancePx: fallbackTolerancePx
+		tolerancePx
 	};
-	const ordinaryTolerancePx = isFirstLine ? fallbackTolerancePx : justifyFitTolerance(line, continuationStrategy, candidateSpaceWidth);
-	if (candidateWidth <= line.availableWidth + ordinaryTolerancePx) return {
+	return admitFinalCandidate(candidateWidth, availableWidth, tolerancePx);
+}
+/**
+* A paragraph's last line is not stretched, so a final word admitted by space
+* contraction needs an explicit paint plan; otherwise it would paint past the
+* measure. Sub-pixel rounding overflow stays on the ordinary path.
+*/
+function admitFinalCandidate(candidateWidth, availableWidth, tolerancePx) {
+	const contractionPx = candidateWidth - availableWidth;
+	if (contractionPx <= WIDTH_TOLERANCE || contractionPx > tolerancePx) return {
 		type: "ordinary",
-		tolerancePx: ordinaryTolerancePx
-	};
-	const finalTolerancePx = justifyFitTolerance(line, finalStrategy, candidateSpaceWidth);
-	if (candidateWidth > line.availableWidth + finalTolerancePx) return {
-		type: "final-contraction-rejected",
-		tolerancePx: finalTolerancePx
+		tolerancePx
 	};
 	return {
 		type: "final-contraction-admitted",
-		tolerancePx: finalTolerancePx,
+		tolerancePx,
 		paint: {
 			type: "space-contraction",
-			contractionPx: candidateWidth - line.availableWidth
+			contractionPx
 		}
 	};
 }
@@ -459,18 +437,35 @@ function compressibleSpaceWidth(text, style) {
 	const count = countCompressibleSpaces(text);
 	return count === 0 ? 0 : count * measureTextWidth(" ", style);
 }
-function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
+function justifyFitTolerance(line, strategy, candidateSpaceWidth, candidate) {
 	if (strategy.type === "rounding") return WIDTH_TOLERANCE;
 	if (strategy.type === "width") return Math.max(WIDTH_TOLERANCE, line.availableWidth * 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);
+	if (candidate !== void 0 && !prefersSpaceShrink(line, candidate)) return WIDTH_TOLERANCE;
+	return Math.max(WIDTH_TOLERANCE, (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio);
 }
-function isShallowFullHangingListContinuation(block, isFirstLine) {
-	if (isFirstLine || block.attrs?.listMarker === void 0) return false;
-	const hanging = block.attrs.indent?.hanging ?? 0;
-	const left = block.attrs.indent?.left ?? 0;
-	return hanging > 0 && hanging < DEFAULT_LIST_HANGING_INDENT_PX && Math.abs(left - hanging) <= WIDTH_TOLERANCE;
+/**
+* A justified line whose next word overflows the measure has two outcomes:
+* keep the word and shrink the line's spaces, or wrap it and stretch the
+* spaces left on the shorter line. Shrinking wins only when the stretch it
+* avoids is large compared with the shrink it costs: the shrink factor may
+* not exceed `1 + (stretch - 1) / JUSTIFY_STRETCH_PER_SHRINK`, and a stretch
+* beyond `JUSTIFY_ALWAYS_SHRINK_STRETCH` always prefers shrinking. The space
+* before the wrapped word hangs at the line end, so it does not stretch; a
+* line left with nothing to stretch defers to the shrink budget alone.
+*/
+function prefersSpaceShrink(line, candidate) {
+	const overflow = candidate.width - line.availableWidth;
+	if (overflow <= WIDTH_TOLERANCE) return true;
+	const shrinkableSpaceWidth = line.regularSpaceWidth + candidate.innerSpaceWidth;
+	if (shrinkableSpaceWidth <= overflow) return false;
+	const hangingSpaceWidth = Math.min(line.trailingWhitespaceWidth, line.regularSpaceWidth);
+	const stretchableSpaceWidth = line.regularSpaceWidth - hangingSpaceWidth;
+	if (stretchableSpaceWidth <= 0) return true;
+	const visibleWidth = line.width - line.trailingWhitespaceWidth;
+	const stretch = 1 + Math.max(0, line.availableWidth - visibleWidth) / stretchableSpaceWidth;
+	if (stretch > JUSTIFY_ALWAYS_SHRINK_STRETCH) return true;
+	const shrink = shrinkableSpaceWidth / (shrinkableSpaceWidth - overflow);
+	return 1 + (stretch - 1) / JUSTIFY_STRETCH_PER_SHRINK >= shrink;
 }
 function trimTrailingSpacesAndTabs(text) {
 	let end = text.length;
@@ -503,6 +498,21 @@ function measureWordWithTrailingWhitespace(word, style) {
 		fullWordWidth: wordWidth + trailingWhitespaceWidth + boundarySpacing
 	};
 }
+const scaledLetterSpacing = (style) => (style.letterSpacing ?? 0) * getHorizontalScaleFactor(style.horizontalScale);
+/**
+* Character spacing still owed after the last character placed on the line,
+* or 0 when the line has no preceding character at `charIndex` of `runIndex`.
+* Within a run it is the run's own spacing; at a boundary between two text
+* runs it is the preceding run's spacing on its final character.
+*/
+function precedingLetterSpacing({ block, line, runIndex, charIndex, runStyle }) {
+	if (line.fromRun === line.toRun && line.fromChar === line.toChar) return 0;
+	if (line.toRun === runIndex && line.toChar === charIndex) return scaledLetterSpacing(runStyle);
+	if (charIndex !== 0 || line.toRun !== runIndex - 1) return 0;
+	const previousRun = block.runs[runIndex - 1];
+	if (!previousRun || !isTextRun(previousRun) || previousRun.text.length === 0 || line.toChar !== previousRun.text.length) return 0;
+	return scaledLetterSpacing(runToFontStyle(previousRun));
+}
 function trailingCodePoint(text) {
 	if (text.length === 0) return;
 	const trailing = text.charCodeAt(text.length - 1);
@@ -548,6 +558,21 @@ function computeTrailingGlueWidths(block) {
 	}
 	return widths;
 }
+/**
+* First character of the text that follows each run, looking through empty
+* text runs; undefined before a non-text run or at the paragraph end.
+*/
+function computeFollowingTextLeads(block) {
+	const leads = Array.from({ length: block.runs.length }, () => void 0);
+	let lead;
+	for (let index = block.runs.length - 1; index >= 0; index--) {
+		leads[index] = lead;
+		const run = block.runs[index];
+		if (!run || !isTextRun(run)) lead = void 0;
+		else if (run.text) lead = run.text[0];
+	}
+	return leads;
+}
 function computeProtectedCrossRunGlueWidths(block) {
 	const widths = Array.from({ length: block.runs.length }, () => 0);
 	for (let index = 0; index < block.runs.length; index++) {
@@ -558,10 +583,10 @@ function computeProtectedCrossRunGlueWidths(block) {
 			run
 		}).provider;
 		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] ?? "";
+		const trailing = splitTrailingToken(run.text ?? "");
+		if (!trailing || trailing.token.length !== 1) continue;
+		const { token } = trailing;
+		let separator = trailing.separator;
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
 		let followingWord = "";
 		let unseparatedFollowingText = false;
@@ -720,7 +745,6 @@ function measureParagraph(block, maxWidth, options) {
 	};
 	const firstLineJustifyFitStrategy = resolveJustifyFitStrategy(block, true, justificationProfile);
 	const continuationJustifyFitStrategy = resolveJustifyFitStrategy(block, false, justificationProfile);
-	const finalLineJustifyFitStrategy = resolveFinalLineJustifyFitStrategy(block, justificationProfile);
 	const floatingZones = options?.floatingZones;
 	const paragraphYOffset = options?.paragraphYOffset ?? 0;
 	const indent = attrs?.indent;
@@ -772,7 +796,7 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length === 0) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -793,7 +817,7 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	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);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -813,6 +837,7 @@ function measureParagraph(block, maxWidth, options) {
 	}
 	const trailingGlueWidths = computeTrailingGlueWidths(block);
 	const protectedCrossRunGlueWidths = computeProtectedCrossRunGlueWidths(block);
+	const followingTextLeads = computeFollowingTextLeads(block);
 	let currentLine = {
 		fromRun: 0,
 		fromChar: 0,
@@ -823,6 +848,8 @@ function measureParagraph(block, maxWidth, options) {
 		regularSpaceWidth: 0,
 		maxFontSize: DEFAULT_FONT_SIZE,
 		maxFontMetrics: null,
+		maxTabFontSize: DEFAULT_FONT_SIZE,
+		maxTabFontMetrics: null,
 		maxImageHeightPx: 0,
 		maxExactImageHeightPx: 0,
 		maxMathHeightPx: 0,
@@ -833,9 +860,14 @@ function measureParagraph(block, maxWidth, options) {
 	};
 	const calculateLineTypography = (line) => {
 		const paragraphFontSize = attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
-		const paragraphFontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
-		const fontSize = line.maxFontMetrics ? line.maxFontSize : paragraphFontSize;
-		const metrics = line.maxFontMetrics ?? getFontMetrics({
+		const paragraphFontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
+		let lineFontMetrics = line.maxFontMetrics;
+		let fontSize = line.maxFontSize;
+		if (!lineFontMetrics) {
+			lineFontMetrics = line.maxTabFontMetrics;
+			fontSize = lineFontMetrics ? line.maxTabFontSize : paragraphFontSize;
+		}
+		const metrics = lineFontMetrics ?? getFontMetrics({
 			fontSize: paragraphFontSize,
 			fontFamily: paragraphFontFamily,
 			...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
@@ -919,6 +951,8 @@ function measureParagraph(block, maxWidth, options) {
 			regularSpaceWidth: 0,
 			maxFontSize: DEFAULT_FONT_SIZE,
 			maxFontMetrics: null,
+			maxTabFontSize: DEFAULT_FONT_SIZE,
+			maxTabFontMetrics: null,
 			maxImageHeightPx: 0,
 			maxExactImageHeightPx: 0,
 			maxMathHeightPx: 0,
@@ -942,6 +976,19 @@ function measureParagraph(block, maxWidth, options) {
 		const metrics = getFontMetrics(style);
 		if (metrics.singleLineRatio > currentLine.maxFontMetrics.singleLineRatio) currentLine.maxFontMetrics = metrics;
 	};
+	/**
+	* Track the tallest tab on the line separately from content runs: a tab's
+	* font does not raise a line that carries other content, so a tab run
+	* formatted larger than its neighbouring text (a TOC entry whose tab keeps
+	* the paragraph-mark size) leaves the line at the text's height.
+	*/
+	const updateMaxTabFont = (style) => {
+		const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+		if (!currentLine.maxTabFontMetrics || fontSize > currentLine.maxTabFontSize) {
+			currentLine.maxTabFontSize = fontSize;
+			currentLine.maxTabFontMetrics = getFontMetrics(style);
+		}
+	};
 	let crossRunResume;
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
 		if (crossRunResume && runIndex < crossRunResume.runIndex) continue;
@@ -970,7 +1017,7 @@ function measureParagraph(block, maxWidth, options) {
 		}
 		if (isTabRun(run)) {
 			const style = runToFontStyle(run);
-			updateMaxFont(style);
+			updateMaxTabFont(style);
 			const followingWidth = measureInlineWidthAfterTab(runs, runIndex, options?.fieldValues);
 			const decimalPrefixWidth = measureDecimalPrefixWidthAfterTab(runs, runIndex, options?.fieldValues);
 			const lineX = currentLine.width + currentLine.leftOffset;
@@ -987,14 +1034,14 @@ function measureParagraph(block, maxWidth, options) {
 			let tabWidth = tabResult.width;
 			const authoredEndpoint = contentX + tabWidth + followingWidth;
 			const activeContentRightEdge = maxWidth - currentLine.rightOffset;
-			const preservesAuthoredEndStop = tabResult.alignment === "end" && (options?.allowEndTabOverflow === true || authoredEndpoint <= activeContentRightEdge + WIDTH_TOLERANCE);
+			const preservesAuthoredStop = tabResult.alignment === "end" && options?.allowEndTabOverflow === true || tabResult.explicit === true && authoredEndpoint <= activeContentRightEdge + WIDTH_TOLERANCE;
 			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 (!preservesAuthoredEndStop && !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 (preservesAuthoredEndStop) currentLine.availableWidth = Math.max(currentLine.availableWidth, currentLine.width + tabWidth + followingWidth);
+			if (!preservesAuthoredStop && !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 (preservesAuthoredStop) currentLine.availableWidth = Math.max(currentLine.availableWidth, currentLine.width + tabWidth + followingWidth);
 			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
 				startNewLine(runIndex, 0);
-				updateMaxFont(style);
+				updateMaxTabFont(style);
 			}
 			currentLine.width += tabWidth;
 			currentLine.trailingWhitespaceWidth = 0;
@@ -1039,7 +1086,10 @@ function measureParagraph(block, maxWidth, options) {
 			updateMaxFont(style);
 			const fieldWidth = measureTextWidth(fallback, style);
 			const fieldSpaceWidth = compressibleSpaceWidth(fallback, style);
-			const fieldTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, lines.length === 0 ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, fieldSpaceWidth) : WIDTH_TOLERANCE;
+			const fieldTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, lines.length === 0 ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, fieldSpaceWidth, {
+				width: currentLine.width + fieldWidth,
+				innerSpaceWidth: fieldSpaceWidth
+			}) : WIDTH_TOLERANCE;
 			if (currentLine.width > 0 && currentLine.width + fieldWidth > currentLine.availableWidth + fieldTolerance) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
@@ -1098,18 +1148,20 @@ function measureParagraph(block, maxWidth, options) {
 				const nextBreak = wordBreaks[wordBreakIndex] ?? text.length;
 				const word = text.slice(charIndex, nextBreak);
 				const { measuredWord, wordWidth, fullWordWidth } = measureWordWithTrailingWhitespace(word, style);
-				let leadingLetterSpacing = (currentLine.fromRun !== currentLine.toRun || currentLine.fromChar !== currentLine.toChar) && currentLine.toRun === runIndex && currentLine.toChar === charIndex ? (style.letterSpacing ?? 0) * ((style.horizontalScale ?? 100) / 100) : 0;
+				let leadingLetterSpacing = precedingLetterSpacing({
+					block,
+					line: currentLine,
+					runIndex,
+					charIndex,
+					runStyle: style
+				});
 				const hangingPunctuationWidth = trailingHangingPunctuationWidth(measuredWord, style, breakPolicy, effectiveLineBreakPolicy.hangingPunctuation);
 				const isFirstLine = lines.length === 0;
 				const regularSpaceWidth = compressibleSpaceWidth(measuredWord, style);
-				const justifyFitStrategy = resolveCandidateJustifyFitStrategy({
-					isFirstLine,
-					isFinalCandidate: isFinalTextCandidate(block, runIndex, nextBreak),
-					firstLineStrategy: firstLineJustifyFitStrategy,
-					continuationStrategy: continuationJustifyFitStrategy,
-					finalLineStrategy: finalLineJustifyFitStrategy
-				});
-				const widthTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, justifyFitStrategy, regularSpaceWidth) : WIDTH_TOLERANCE;
+				const widthTolerance = isJustifiedParagraph ? justifyFitTolerance(currentLine, isFirstLine ? firstLineJustifyFitStrategy : continuationJustifyFitStrategy, regularSpaceWidth, {
+					width: currentLine.width + leadingLetterSpacing + wordWidth,
+					innerSpaceWidth: 0
+				}) : WIDTH_TOLERANCE;
 				const automaticHyphenation = effectiveLineBreakPolicy.automaticHyphenation;
 				const mayHyphenateLine = automaticHyphenation.type === "enabled" && (automaticHyphenation.consecutiveLineLimit === 0 || consecutiveHyphenatedLines < automaticHyphenation.consecutiveLineLimit) && exceedsHyphenationZone(currentLine, automaticHyphenation.hyphenationZoneTwips);
 				const isRunTail = nextBreak === text.length;
@@ -1223,20 +1275,10 @@ function measureParagraph(block, maxWidth, options) {
 				}
 				const wordTail = word.at(-1);
 				const protectedGlueWidth = protectedCrossRunGlueWidths[runIndex] ?? 0;
-				const rawGlueWidth = isRunTail && wordTail !== void 0 && (!isBreakChar(wordTail) || protectedGlueWidth > 0) ? Math.max(trailingGlueWidths[runIndex] ?? 0, protectedGlueWidth) : 0;
+				const rawGlueWidth = isRunTail && wordTail !== void 0 && (!isBreakBetween(wordTail, followingTextLeads[runIndex]) || protectedGlueWidth > 0) ? Math.max(trailingGlueWidths[runIndex] ?? 0, protectedGlueWidth) : 0;
 				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + widthTolerance ? rawGlueWidth : 0;
 				const hangingAllowance = glueWidth === 0 ? hangingPunctuationWidth : 0;
-				const candidateFit = isJustifiedParagraph ? resolveTextCandidateFit({
-					block,
-					line: currentLine,
-					isFirstLine,
-					isFinalCandidate: isFinalTextCandidate(block, runIndex, nextBreak),
-					candidateWidth: currentLine.width + leadingLetterSpacing + wordWidth + glueWidth - hangingAllowance,
-					candidateSpaceWidth: regularSpaceWidth,
-					fallbackTolerancePx: widthTolerance,
-					continuationStrategy: continuationJustifyFitStrategy,
-					finalStrategy: finalLineJustifyFitStrategy
-				}) : void 0;
+				const candidateFit = isJustifiedParagraph ? resolveTextCandidateFit(isFinalTextCandidate(block, runIndex, nextBreak), currentLine.width + leadingLetterSpacing + wordWidth + glueWidth - hangingAllowance, currentLine.availableWidth, widthTolerance) : void 0;
 				const finalWrapTolerance = candidateFit?.tolerancePx ?? widthTolerance;
 				if (wordWidth > 0 && currentLine.width > 0 && currentLine.width + leadingLetterSpacing + wordWidth + glueWidth > currentLine.availableWidth + finalWrapTolerance + hangingAllowance) {
 					startNewLine(runIndex, charIndex);

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

@@ -23,6 +23,11 @@ type FontStyle = {
    */
   eastAsiaFontFamily?: string;
   eastAsiaAlternateFontFamily?: string;
+  /**
+   * The run's effective `w:hint="eastAsia"`: the code points it moves measure
+   * with `eastAsiaFontFamily` too.
+   */
+  eastAsiaHint?: boolean;
   /**
    * Complex-script font for Arabic, Hebrew, Indic and South-East Asian code
    * points. Same contract as `eastAsiaFontFamily`, over a different slot.

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

@@ -0,0 +1,56 @@
+//#region src/layout-engine/measure/smallCapsCasing.d.ts
+/**
+ * Casing rules for synthesized `w:smallCaps` glyphs.
+ *
+ * A face that carries no `smcp`/`c2sc` substitution has no true small-capital
+ * glyph, so it is faked: a lowercase letter is drawn as its uppercase form at
+ * a smaller point size, on the run's own baseline, at a fixed fraction of the
+ * run's declared size — 0.8, an exact ratio observed to repeat across mixed
+ * two-size runs at every point size and never round to a half-point `w:sz`
+ * step. That is not a canvas or DOM backend's own `font-variant: small-caps`,
+ * which synthesizes at its own, uncontrollable, narrower ratio (Blink and
+ * WebKit use 0.7).
+ *
+ * Pure: no canvas, no DOM. Shared by every measurement and paint backend so a
+ * run's advances and its glyphs agree on which characters shrink.
+ */
+/** Fraction of the run's declared size a synthesized small capital draws at. */
+declare const SMALL_CAPS_SCALE = 0.8;
+/**
+ * Whether `char` is a cased letter in its lowercase form — the class
+ * `w:smallCaps` draws as a shrunken, uppercased capital. Digits, punctuation,
+ * symbols and already-uppercase letters keep the run's full size; combining
+ * `char`'s upper and lower forms this way (rather than comparing to a
+ * separate "is uppercase" test) is what correctly leaves caseless scripts
+ * (CJK, most punctuation) at full size too, since neither form differs from
+ * the character itself there.
+ */
+declare function isSmallCapsLetter(char: string): boolean;
+/**
+ * Per-code-point small-caps classification for `text`, one entry per code
+ * point (iterated the same way `[...text]`/`for...of` does, so it lines up
+ * with any other code-point walk of the same string).
+ *
+ * Whitespace carries no case of its own; a run's space draws at the size of
+ * the character immediately before it — the trailing space after a
+ * synthesized word is itself synthesized — so a whitespace code point here
+ * takes the previous code point's class, and only falls back to full size
+ * when it opens the string (nothing to inherit from).
+ */
+declare function smallCapsMask(text: string): boolean[];
+/** A maximal run of `text` drawn at one size: `small` selects which. */
+type SmallCapsSegment = {
+  readonly text: string;
+  readonly small: boolean;
+};
+/**
+ * `text` split into maximal same-size segments for painting, each already
+ * uppercased where `small` — the shrunken capital a `smcp`-less face
+ * substitutes for the source lowercase letter. A run with no lowercase letter
+ * at all (already-uppercase headings, digits, punctuation) comes back as one
+ * `small: false` segment, so a caller can skip the extra painting work its
+ * mixed-size runs need.
+ */
+declare function smallCapsSegments(text: string): SmallCapsSegment[];
+//#endregion
+export { SMALL_CAPS_SCALE, SmallCapsSegment, isSmallCapsLetter, smallCapsMask, smallCapsSegments };

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

@@ -0,0 +1,88 @@
+//#region src/layout-engine/measure/smallCapsCasing.ts
+/**
+* Casing rules for synthesized `w:smallCaps` glyphs.
+*
+* A face that carries no `smcp`/`c2sc` substitution has no true small-capital
+* glyph, so it is faked: a lowercase letter is drawn as its uppercase form at
+* a smaller point size, on the run's own baseline, at a fixed fraction of the
+* run's declared size — 0.8, an exact ratio observed to repeat across mixed
+* two-size runs at every point size and never round to a half-point `w:sz`
+* step. That is not a canvas or DOM backend's own `font-variant: small-caps`,
+* which synthesizes at its own, uncontrollable, narrower ratio (Blink and
+* WebKit use 0.7).
+*
+* Pure: no canvas, no DOM. Shared by every measurement and paint backend so a
+* run's advances and its glyphs agree on which characters shrink.
+*/
+/** Fraction of the run's declared size a synthesized small capital draws at. */
+const SMALL_CAPS_SCALE = .8;
+/** Whitespace never gets its own small-caps class; see `smallCapsMask`. */
+const WHITESPACE_PATTERN = /\s/u;
+/**
+* Whether `char` is a cased letter in its lowercase form — the class
+* `w:smallCaps` draws as a shrunken, uppercased capital. Digits, punctuation,
+* symbols and already-uppercase letters keep the run's full size; combining
+* `char`'s upper and lower forms this way (rather than comparing to a
+* separate "is uppercase" test) is what correctly leaves caseless scripts
+* (CJK, most punctuation) at full size too, since neither form differs from
+* the character itself there.
+*/
+function isSmallCapsLetter(char) {
+	return char.toLocaleUpperCase() !== char;
+}
+/**
+* Per-code-point small-caps classification for `text`, one entry per code
+* point (iterated the same way `[...text]`/`for...of` does, so it lines up
+* with any other code-point walk of the same string).
+*
+* Whitespace carries no case of its own; a run's space draws at the size of
+* the character immediately before it — the trailing space after a
+* synthesized word is itself synthesized — so a whitespace code point here
+* takes the previous code point's class, and only falls back to full size
+* when it opens the string (nothing to inherit from).
+*/
+function smallCapsMask(text) {
+	const mask = [];
+	let previous = false;
+	for (const char of text) {
+		const small = WHITESPACE_PATTERN.test(char) ? previous : isSmallCapsLetter(char);
+		mask.push(small);
+		previous = small;
+	}
+	return mask;
+}
+/**
+* `text` split into maximal same-size segments for painting, each already
+* uppercased where `small` — the shrunken capital a `smcp`-less face
+* substitutes for the source lowercase letter. A run with no lowercase letter
+* at all (already-uppercase headings, digits, punctuation) comes back as one
+* `small: false` segment, so a caller can skip the extra painting work its
+* mixed-size runs need.
+*/
+function smallCapsSegments(text) {
+	const mask = smallCapsMask(text);
+	const segments = [];
+	let current = "";
+	let currentSmall;
+	let index = 0;
+	for (const char of text) {
+		const small = mask[index] ?? false;
+		if (currentSmall !== void 0 && small !== currentSmall) {
+			segments.push({
+				text: current,
+				small: currentSmall
+			});
+			current = "";
+		}
+		current += small ? char.toLocaleUpperCase() : char;
+		currentSmall = small;
+		index += 1;
+	}
+	if (current) segments.push({
+		text: current,
+		small: currentSmall ?? false
+	});
+	return segments;
+}
+//#endregion
+export { SMALL_CAPS_SCALE, isSmallCapsLetter, smallCapsMask, smallCapsSegments };

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

@@ -50,6 +50,8 @@ type TabWidthResult = {
   leader?: TabLeader;
   /** Alignment that was applied */
   alignment: TabAlignment | "default";
+  /** Set when the tab advanced to one of the context's explicit stops. */
+  explicit?: true;
 };
 /** Default tab interval: 720 twips = 0.5 inch */
 declare const DEFAULT_TAB_INTERVAL_TWIPS = 720;

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

@@ -122,7 +122,8 @@ function calculateTabWidth(currentXPx, context, following = {}) {
 	return {
 		width,
 		...nextStop.leader !== void 0 ? { leader: nextStop.leader } : {},
-		alignment: nextStop.val
+		alignment: nextStop.val,
+		...context.explicitStops?.includes(nextStop) === true ? { explicit: true } : {}
 	};
 }
 /**

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

@@ -22,6 +22,8 @@ type TableCellFloatingImage = {
   distLeft: number;
   distRight: number;
   wrapText?: "bothSides" | "left" | "right" | "largest";
+  /** Authored wrap mode; decides whether and how the picture excludes text. */
+  wrapType?: ImageRun["wrapType"];
   pmStart?: number;
   pmEnd?: number;
 };