@stll/folio-core 0.48.0 → 0.50.0

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

@@ -1,22 +1,23 @@
-import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
-import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
+import { isCjkFont } from "../../utils/fontResolver.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
-import { hasCjk, hasComplexScript, hasEastAsiaSlotText } from "../../utils/scriptSegments.js";
-import { splitTrailingToken } from "../../utils/trailingText.js";
-import { JUSTIFIED_FINAL_LINE_MAX_SHRINK_RATIO, JUSTIFIED_FINAL_LINE_SPACE_CONTRACTION_RATIO, supportsJustifiedFinalLineContraction } from "../justifiedLineFit.js";
 import { measuredLineAdvance } from "../lineFlow.js";
 import { isFloatingImageRun } from "../types.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
-import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
+import { collectCrossRunWord, computeFollowingTextLeads, computeProtectedCrossRunGlueWidths, computeTrailingGlueWidths, measureCrossRunPrefix } from "./crossRunWords.js";
 import { resolveEffectiveLineBreakPolicy } from "./effectiveLineBreakPolicy.js";
+import { MIN_WRAP_SEGMENT_WIDTH, findClearLineY } from "./floatingLineClearance.js";
 import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
-import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
-import { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation } from "./lineBreaks.js";
+import { estimateMathFootprintPx, rotatedBlockImageHeight } from "./inlineObjectMetrics.js";
+import { compressibleSpaceWidth, justifyFitTolerance, resolveJustifyFitStrategy, uppercaseLetterRatio } from "./justification.js";
+import { findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar } from "./lineBreaks.js";
+import { exceedsHyphenationZone, findMaxFittingLength, isFinalTextCandidate, isIgnorableFinalTailRun, measureWordWithTrailingWhitespace, precedingLetterSpacing, resolveTextCandidateFit, trailingHangingPunctuationWidth, trimTrailingSpacesAndTabs } from "./lineFitting.js";
+import { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle } from "./lineTypography.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
-import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
+import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "./measureHelpers.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
+import { WIDTH_TOLERANCE, fieldMeasureText, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
+import { canClampTabToRightEdge, hasFollowingTabOnLine, hasPriorTabOnLine, measureDecimalPrefixWidthAfterTab, measureInlineWidthAfterTab } from "./paragraphTabs.js";
 import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
-import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
 //#region src/layout-engine/measure/measureParagraph.ts
 /**
 * Paragraph measurement module
@@ -24,733 +25,6 @@ import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
 * Measures paragraph blocks and computes line breaking.
 * Converts runs into measured lines with typography metrics.
 */
-const DEFAULT_FONT_SIZE = 11;
-const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
-const WIDTH_TOLERANCE = .5;
-const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
-const JUSTIFY_SPACE_CONTRACTION_RATIO = .25;
-const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
-const JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO = .022;
-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.
-* Returns the number of characters that fit (at least 1 if `forceMin` is true).
-*/
-function findMaxFittingLength(text, style, maxWidth, forceMin = false, policy) {
-	const boundaries = findGraphemeBreaks(text, policy);
-	let lo = 0;
-	let hi = boundaries.length - 1;
-	let best = 0;
-	while (lo <= hi) {
-		const mid = Math.floor((lo + hi) / 2);
-		const boundary = boundaries[mid];
-		if (measureTextWidth(text.slice(0, boundary), style) <= maxWidth) {
-			best = boundary;
-			lo = mid + 1;
-		} else hi = mid - 1;
-	}
-	return forceMin && best === 0 ? boundaries.at(0) ?? 0 : best;
-}
-function exceedsHyphenationZone(line, zoneTwips) {
-	if (line.width <= 0) return true;
-	const visibleWidth = Math.max(0, line.width - line.trailingWhitespaceWidth);
-	return Math.max(0, line.availableWidth - visibleWidth) > twipsToPx(zoneTwips) + WIDTH_TOLERANCE;
-}
-/**
-* Extract FontStyle from a run that carries RunFormatting (text, tab, or
-* field). All three share the same formatting shape, so they measure the
-* same way; widening the parameter keeps tab-following measurement
-* (FieldRun page numbers, etc.) consistent with TextRun handling.
-*/
-function runToFontStyle(run) {
-	return buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
-}
-/**
-* Line-HEIGHT style for a text run. Word derives a CJK line's height from an
-* East-Asian face, not the run's ascii font: real documents routinely put CJK
-* glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
-* "Century"), and Word font-links those glyphs to the default East-Asian face
-* and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
-*
-* When the run holds CJK text, swap `fontFamily` to the face whose
-* `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
-* it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
-* `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
-* unchanged, so Latin-only documents are unaffected by construction.
-*
-* The result feeds `updateMaxFont` (line height) ONLY — width measurement
-* keeps the base style so wrapping is untouched.
-*/
-function cjkLineHeightStyle(run, baseStyle) {
-	if (!run.text) return baseStyle;
-	const eastAsia = baseStyle.eastAsiaFontFamily;
-	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
-		};
-		delete result.alternateFontFamily;
-		if (baseStyle.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = baseStyle.eastAsiaAlternateFontFamily;
-		return result;
-	}
-	if (isCjkFont(baseStyle.fontFamily ?? "Times New Roman")) return baseStyle;
-	return {
-		...baseStyle,
-		fontFamily: CJK_FALLBACK_FONT_FAMILY
-	};
-}
-/** Pick the dominant typography metrics for a run containing complex script. */
-function complexScriptLineHeightStyle(run, baseStyle) {
-	if (!hasComplexScriptFormatting(run) || !run.forceComplexScript && !hasComplexScript(run.text)) return baseStyle;
-	const complexStyle = applyComplexScriptFormatting(baseStyle, run);
-	return (complexStyle.fontSize ?? DEFAULT_FONT_SIZE) >= (baseStyle.fontSize ?? DEFAULT_FONT_SIZE) ? complexStyle : baseStyle;
-}
-/**
-* Calculate typography metrics from font size and spacing settings
-*
-* @param fontSize - Font size in points
-* @param spacing - Paragraph spacing settings
-* @param metrics - Pre-calculated font metrics (in pixels)
-*/
-function calculateTypographyMetrics(fontSize, spacing, metrics) {
-	const fontSizePx = ptToPx(fontSize);
-	const ascent = metrics?.ascent ?? fontSizePx * .8;
-	const descent = metrics?.descent ?? fontSizePx * .2;
-	const singleLineBase = fontSizePx * (metrics?.singleLineRatio ?? 1.15);
-	let lineHeight;
-	if (spacing?.lineRule === "exact" && spacing.line !== void 0) lineHeight = spacing.line;
-	else if (spacing?.lineRule === "atLeast" && spacing.line !== void 0) {
-		const defaultHeight = singleLineBase * DEFAULT_LINE_HEIGHT_MULTIPLIER;
-		lineHeight = Math.max(spacing.line, defaultHeight);
-	} else if (spacing?.line !== void 0 && spacing.lineUnit === "multiplier") lineHeight = singleLineBase * spacing.line;
-	else if (spacing?.line !== void 0 && spacing.lineUnit === "px") lineHeight = spacing.line;
-	else lineHeight = singleLineBase * DEFAULT_LINE_HEIGHT_MULTIPLIER;
-	return {
-		ascent,
-		descent,
-		lineHeight
-	};
-}
-/**
-* Word's "single line spacing" floor (≈ 1.15×) applied to empty paragraphs
-* with `auto`/`atLeast` line rules. Without this, narrow-metric fonts
-* (Arial Narrow, OS/2 ratio ≈ 1.117) collapse empty rows visibly tighter
-* than Word renders them. See eigenpal #391/#394.
-*/
-const WORD_SINGLE_LINE_FLOOR = 1.15;
-/**
-* Calculate metrics for an empty paragraph.
-*
-* Word renders an empty paragraph as a single readable line — its line
-* height never collapses below 1.15 × font size, even when the doc
-* explicitly writes `<w:line w:val="240"/>` (1.0×). The floor is scoped to
-* `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
-* and stays untouched.
-*/
-function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
-	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
-		fontSize,
-		fontFamily: fontFamily ?? "Times New Roman",
-		...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
-	}));
-	const lineRule = spacing?.lineRule ?? "auto";
-	if (lineRule === "auto" || lineRule === "atLeast") {
-		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
-		if (result.lineHeight < floor) return applyDocumentGrid({
-			...result,
-			lineHeight: floor
-		}, attrs, spacing);
-	}
-	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
-*/
-function isTextRun(run) {
-	return run.kind === "text";
-}
-/**
-* Check if a run is a tab run
-*/
-function isTabRun(run) {
-	return run.kind === "tab";
-}
-/**
-* Check if a run is an image run
-*/
-function isImageRun(run) {
-	return run.kind === "image";
-}
-function parseRotationDegrees(transform) {
-	if (!transform) return 0;
-	const match = /rotate\(\s*(?<degrees>[-\d.]+)\s*deg\s*\)/u.exec(transform);
-	if (!match) return 0;
-	const raw = Number.parseFloat(match.groups["degrees"]);
-	if (!Number.isFinite(raw)) return 0;
-	return (raw % 360 + 360) % 360;
-}
-function rotatedBlockImageHeight(run) {
-	const deg = parseRotationDegrees(run.transform);
-	if (deg === 0 || deg === 180) return run.height;
-	if (deg === 90 || deg === 270) return run.width;
-	const rad = deg * Math.PI / 180;
-	const sinA = Math.abs(Math.sin(rad));
-	const cosA = Math.abs(Math.cos(rad));
-	return run.width * sinA + run.height * cosA;
-}
-/**
-* Check if a run is a line break run
-*/
-function isLineBreakRun(run) {
-	return run.kind === "lineBreak";
-}
-/**
-* Check if a run is a field run
-*/
-function isFieldRun(run) {
-	return run.kind === "field";
-}
-/** Text a field run is measured at: its resolved value when known (so the
-*  measurer agrees with the painter), else the cached fallback. */
-function fieldMeasureText(run, fieldValues) {
-	return (run.pmStart === void 0 ? void 0 : fieldValues?.get(run.pmStart)) ?? (run.fallback || "1");
-}
-/**
-* Check if a run is a math equation run
-*/
-function isMathRun(run) {
-	return run.kind === "math";
-}
-function isStackedMathLocalName(localName) {
-	switch (localName) {
-		case "bar":
-		case "d":
-		case "eqArr":
-		case "f":
-		case "groupChr":
-		case "limLow":
-		case "limUpp":
-		case "m":
-		case "nary":
-		case "rad":
-		case "sPre":
-		case "sSubSup": return true;
-		default: return false;
-	}
-}
-function hasStackedMathLayout(run) {
-	if (run.display === "block") return true;
-	for (const match of run.ommlXml.matchAll(/<(?<tag>[A-Za-z_][\w.-]*(?::[A-Za-z_][\w.-]*)?)(?:\s|\/|>)/gu)) {
-		const tagName = match.groups?.["tag"];
-		if (!tagName) continue;
-		const colonIndex = tagName.indexOf(":");
-		if (isStackedMathLocalName(colonIndex === -1 ? tagName : tagName.slice(colonIndex + 1))) return true;
-	}
-	return false;
-}
-function estimateMathFootprintPx(run) {
-	return ptToPx(run.fontSize ?? DEFAULT_FONT_SIZE) * (hasStackedMathLayout(run) ? 2.4 : 1.25);
-}
-/**
-* Check if text run is empty (only whitespace or no text)
-*/
-function isEmptyTextRun(run) {
-	return !run.text || run.text.replace(/\u00a0/gu, " ").trim().length === 0;
-}
-/**
-* Sum the inline pixel widths of runs after a tab, up to (but not including)
-* the next tab or line break. Measured per-run so widths reserved match what
-* the painter draws even when trailing runs use different fonts/sizes.
-*
-* Floating/anchored images are skipped — the painter lifts them out of the
-* paragraph flow (see `isFloatingImageRun`) and `measureFollowingContentWidth`
-* in the painter already excludes them, so counting their width here would
-* desync measurer and painter on tab advance for paragraphs with a tab
-* preceding a floating image.
-*/
-function isBlockLayoutImageRun(run) {
-	if (isFloatingImageRun(run)) return false;
-	return run.wrapType === "topAndBottom" || run.displayMode === "block";
-}
-function measureInlineWidthAfterTab(runs, tabIndex, fieldValues) {
-	let width = 0;
-	for (let i = tabIndex + 1; i < runs.length; i++) {
-		const next = runs[i];
-		if (!next || isTabRun(next) || isLineBreakRun(next)) break;
-		if (isImageRun(next)) {
-			if (isBlockLayoutImageRun(next)) break;
-			if (!isFloatingImageRun(next)) width += inlineImageBoundingBox(next).width || 0;
-			continue;
-		}
-		if (isTextRun(next)) width += measureTextWidth(next.text || "", runToFontStyle(next));
-		else if (isFieldRun(next)) width += measureTextWidth(fieldMeasureText(next, fieldValues), runToFontStyle(next));
-		else if (isMathRun(next)) width += measureTextWidth(next.plainText || "[equation]", runToFontStyle(next));
-	}
-	return width;
-}
-function hasFollowingTabOnLine(runs, tabIndex) {
-	for (let i = tabIndex + 1; i < runs.length; i++) {
-		const next = runs[i];
-		if (!next || isLineBreakRun(next)) break;
-		if (isImageRun(next) && isBlockLayoutImageRun(next)) break;
-		if (isTabRun(next)) return true;
-	}
-	return false;
-}
-function hasPriorTabOnLine(runs, tabIndex) {
-	for (let i = tabIndex - 1; i >= 0; i--) {
-		const prior = runs[i];
-		if (!prior || isLineBreakRun(prior) || isImageRun(prior) && isBlockLayoutImageRun(prior)) break;
-		if (isTabRun(prior)) return true;
-	}
-	return false;
-}
-function canClampTabToRightEdge(alignment, currentLineWidth, hasPriorTab, followingWidth, availableWidth) {
-	if (alignment === "start" || alignment === "default") return currentLineWidth > WIDTH_TOLERANCE && (hasPriorTab || followingWidth <= availableWidth);
-	return true;
-}
-/**
-* Width of the inline content preceding the first `.` in the runs that follow
-* a tab, used to anchor `decimal` tab stops. Mirrors `getTextAfterTab` +
-* decimal-prefix measurement in the painter (`renderParagraph.ts`) so the
-* measurer and painter agree on tab advance for decimal stops.
-*
-* Returns 0 when no decimal separator appears before the next tab / line
-* break — `calculateTabWidth` treats that as "no anchor adjustment".
-*/
-function measureDecimalPrefixWidthAfterTab(runs, tabIndex, fieldValues) {
-	let text = "";
-	let firstRun;
-	for (let i = tabIndex + 1; i < runs.length; i++) {
-		const next = runs[i];
-		if (!next || isTabRun(next) || isLineBreakRun(next)) break;
-		if (isTextRun(next)) {
-			text += next.text || "";
-			firstRun ??= next;
-		} else if (isFieldRun(next)) {
-			text += fieldMeasureText(next, fieldValues);
-			firstRun ??= next;
-		} else if (isMathRun(next)) {
-			text += next.plainText || "[equation]";
-			firstRun ??= next;
-		}
-	}
-	const decimalIndex = text.indexOf(".");
-	if (decimalIndex === -1 || !firstRun) return 0;
-	return measureTextWidth(text.slice(0, decimalIndex), runToFontStyle(firstRun));
-}
-function isSpaceOrTab(char) {
-	return char === " " || char === "	";
-}
-function uppercaseLetterRatio(text) {
-	let letters = 0;
-	let uppercase = 0;
-	for (const char of text) {
-		const lower = char.toLocaleLowerCase();
-		const upper = char.toLocaleUpperCase();
-		if (lower === upper) continue;
-		letters++;
-		if (char === upper) uppercase++;
-	}
-	return letters === 0 ? 0 : uppercase / letters;
-}
-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",
-		ratio: JUSTIFY_SHRINK_TOLERANCE_RATIO
-	};
-	if (!isFirstLine && profile.hasTabRuns && !hasTabStops) return {
-		type: "width",
-		ratio: JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO
-	};
-	if (profile.hasTabRuns && (isFirstLine || hasTabStops)) return {
-		type: "width",
-		ratio: (block.attrs?.indent?.firstLine ?? 0) === 0 ? JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO : JUSTIFY_SHRINK_TOLERANCE_RATIO
-	};
-	if (profile.uppercaseRatio > ALL_CAPS_RATIO_THRESHOLD) return {
-		type: "width",
-		ratio: JUSTIFY_SHRINK_TOLERANCE_RATIO
-	};
-	return {
-		type: "space",
-		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];
-	if (!currentRun || !isTextRun(currentRun) || nextBreak !== currentRun.text.length) return false;
-	for (let index = runIndex + 1; index < block.runs.length; index += 1) {
-		const run = block.runs[index];
-		if (run && isIgnorableFinalTailRun(run)) continue;
-		return false;
-	}
-	return true;
-}
-function resolveTextCandidateFit({ block, line, isFirstLine, isFinalCandidate, candidateWidth, candidateSpaceWidth, fallbackTolerancePx, continuationStrategy, finalStrategy }) {
-	if (!isFinalCandidate) return {
-		type: "ordinary",
-		tolerancePx: fallbackTolerancePx
-	};
-	if (!supportsJustifiedFinalLineContraction(block)) return admitFinalCandidate(candidateWidth, line.availableWidth, fallbackTolerancePx);
-	const ordinaryTolerancePx = isFirstLine ? fallbackTolerancePx : justifyFitTolerance(line, continuationStrategy, candidateSpaceWidth);
-	if (candidateWidth <= line.availableWidth + ordinaryTolerancePx) return admitFinalCandidate(candidateWidth, line.availableWidth, ordinaryTolerancePx);
-	const finalTolerancePx = justifyFitTolerance(line, finalStrategy, candidateSpaceWidth);
-	if (candidateWidth > line.availableWidth + finalTolerancePx) return {
-		type: "final-contraction-rejected",
-		tolerancePx: finalTolerancePx
-	};
-	return {
-		type: "final-contraction-admitted",
-		tolerancePx: finalTolerancePx,
-		paint: {
-			type: "space-contraction",
-			contractionPx: candidateWidth - line.availableWidth
-		}
-	};
-}
-/**
-* 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
-	};
-	return {
-		type: "final-contraction-admitted",
-		tolerancePx,
-		paint: {
-			type: "space-contraction",
-			contractionPx
-		}
-	};
-}
-function compressibleSpaceWidth(text, style) {
-	const count = countCompressibleSpaces(text);
-	return count === 0 ? 0 : count * measureTextWidth(" ", style);
-}
-function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
-	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);
-}
-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;
-}
-function trimTrailingSpacesAndTabs(text) {
-	let end = text.length;
-	while (end > 0) {
-		const char = text[end - 1];
-		if (char !== " " && char !== "	") break;
-		end--;
-	}
-	return text.slice(0, end);
-}
-function measureWordWithTrailingWhitespace(word, style) {
-	const measuredWord = trimTrailingSpacesAndTabs(word);
-	const wordWidth = measureTextWidth(measuredWord, style);
-	const trailingWhitespace = word.slice(measuredWord.length);
-	if (trailingWhitespace.length === 0) return {
-		measuredWord,
-		wordWidth,
-		fullWordWidth: wordWidth
-	};
-	if (style.kerning || trailingWhitespace.includes("	")) return {
-		measuredWord,
-		wordWidth,
-		fullWordWidth: measureTextWidth(word, style)
-	};
-	const trailingWhitespaceWidth = measureTextWidth(trailingWhitespace, style);
-	const boundarySpacing = measuredWord.length > 0 ? (style.letterSpacing ?? 0) * getHorizontalScaleFactor(style.horizontalScale) : 0;
-	return {
-		measuredWord,
-		wordWidth,
-		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);
-	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;
-	return measureTextWidth(lastGrapheme, style);
-}
-/**
-* Width of the unbreakable text glued to the end of each run.
-* A run boundary is not itself a wrap opportunity: adjacent note markers and
-* format-only word splits must wrap as one cluster.
-*/
-function computeTrailingGlueWidths(block) {
-	const runs = block.runs;
-	const widths = Array.from({ length: runs.length }, () => 0);
-	for (let index = runs.length - 1; index >= 0; index--) {
-		const nextRun = runs[index + 1];
-		if (!nextRun || !isTextRun(nextRun)) continue;
-		const text = nextRun.text;
-		if (!text) {
-			widths[index] = widths[index + 1] ?? 0;
-			continue;
-		}
-		if (isSpaceOrTab(text.at(0))) continue;
-		const style = runToFontStyle(nextRun);
-		const firstBreak = findWordBreaks(text, resolveEffectiveLineBreakPolicy({
-			attrs: block.attrs,
-			run: nextRun
-		}).provider).at(0);
-		widths[index] = measureTextWidth(firstBreak === void 0 ? text : trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style) + (firstBreak === void 0 ? widths[index + 1] ?? 0 : 0);
-	}
-	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++) {
-		const run = block.runs[index];
-		if (!run || !isTextRun(run)) continue;
-		const policy = resolveEffectiveLineBreakPolicy({
-			attrs: block.attrs,
-			run
-		}).provider;
-		if (!policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
-		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;
-		for (let nextIndex = index + 1; nextIndex < block.runs.length; nextIndex++) {
-			const nextRun = block.runs[nextIndex];
-			if (!nextRun || !isTextRun(nextRun)) break;
-			const text = nextRun.text ?? "";
-			let consumed = "";
-			for (const char of text) {
-				const isWhitespace = /\s/u.test(char);
-				if (followingWord.length > 0 && isWhitespace) break;
-				if (separator.length === 0 && !isWhitespace) {
-					unseparatedFollowingText = true;
-					break;
-				}
-				consumed += char;
-				if (isWhitespace) separator += char;
-				else followingWord += char;
-			}
-			if (consumed.length > 0) glueWidth += measureTextWidth(consumed, runToFontStyle(nextRun));
-			if (unseparatedFollowingText) break;
-			if (followingWord.length > 0 && consumed.length < text.length) break;
-		}
-		if (unseparatedFollowingText || separator.length === 0 || followingWord.length === 0) continue;
-		const boundary = token.length + separator.length;
-		if (!findWordBreaks(token + separator + followingWord, policy).includes(boundary)) widths[index] = glueWidth;
-	}
-	return widths;
-}
-/**
-* Cap on the number of runs `collectCrossRunWord` traverses per call. A
-* paragraph split into many tiny (including empty) runs would otherwise let
-* the search walk the full run list for every word-start position it is
-* invoked from, without the per-word text-length budget ever kicking in.
-*/
-const MAX_CROSS_RUN_SEGMENTS = 64;
-/** Collect one lexical word continued through adjacent formatting runs. */
-function collectCrossRunWord({ block, startRunIndex, startChar }) {
-	const segments = [];
-	let text = "";
-	let width = 0;
-	for (let runIndex = startRunIndex; runIndex < block.runs.length; runIndex++) {
-		if (runIndex - startRunIndex >= MAX_CROSS_RUN_SEGMENTS) return;
-		const run = block.runs[runIndex];
-		if (!run || !isTextRun(run)) break;
-		const start = runIndex === startRunIndex ? startChar : 0;
-		const remainder = run.text.slice(start);
-		if (remainder.length === 0) continue;
-		if (runIndex !== startRunIndex && isSpaceOrTab(remainder[0])) break;
-		const remainingBudget = 256 - text.length;
-		const boundedRemainder = remainder.slice(0, remainingBudget + 1);
-		const firstBreak = findWordBreaks(boundedRemainder, resolveEffectiveLineBreakPolicy({
-			attrs: block.attrs,
-			run
-		}).provider).at(0);
-		const segmentText = trimTrailingSpacesAndTabs(firstBreak === void 0 ? boundedRemainder : boundedRemainder.slice(0, firstBreak));
-		if (segmentText.length === 0) break;
-		if (segmentText.length > remainingBudget) return;
-		const style = runToFontStyle(run);
-		segments.push({
-			runIndex,
-			startChar: start,
-			text: segmentText,
-			run,
-			style
-		});
-		text += segmentText;
-		width += measureTextWidth(segmentText, style);
-		if (firstBreak !== void 0) break;
-	}
-	if (segments.length < 2) return;
-	const firstRun = segments[0]?.run;
-	if (!firstRun) return;
-	return {
-		text,
-		width,
-		breaks: findHyphenationBreaks(text, resolveEffectiveLineBreakPolicy({
-			attrs: block.attrs,
-			run: firstRun
-		}).provider),
-		segments
-	};
-}
-function measureCrossRunPrefix(word, breakOffset) {
-	let width = 0;
-	let remaining = breakOffset;
-	const measuredSegments = [];
-	for (const segment of word.segments) {
-		const length = Math.min(remaining, segment.text.length);
-		if (length > 0) {
-			width += measureTextWidth(segment.text.slice(0, length), segment.style);
-			measuredSegments.push(segment);
-		}
-		if (remaining <= segment.text.length) return {
-			width,
-			endRunIndex: segment.runIndex,
-			endChar: segment.startChar + remaining,
-			hyphenStyle: segment.style,
-			segments: measuredSegments
-		};
-		remaining -= segment.text.length;
-	}
-}
-/**
-* Minimum horizontal room a line must offer before we treat it as usable for
-* body text. Below this threshold the line is bumped past obstructing floats
-* via `findClearLineY` instead of being rendered into the unusable sliver.
-* Without this guard, a near-full-width float (e.g. floating table) produces
-* a ~2px segment that collapses every wrap line to one glyph per row.
-*/
-const MIN_WRAP_SEGMENT_WIDTH = 24;
-/**
-* Find the next vertical position at or below `startY` where the available
-* text width is at least `minWidth`. Used to skip lines past stacked floats
-* when there is no horizontal room for meaningful text at the current Y.
-*
-* Returns `startY` if the current position already has enough room, otherwise
-* the lowest `bottomY` of any zone currently obstructing the line. The caller
-* is expected to re-query margins at the returned Y.
-*
-* Coordinates are absolute (i.e., already include any paragraphYOffset).
-*/
-function findClearLineY(startY, lineHeight, zones, contentWidth, minWidth) {
-	if (!zones || zones.length === 0) return startY;
-	let y = startY;
-	for (let i = 0; i < zones.length + 2; i++) {
-		const margins = getFloatingMargins(y, lineHeight, zones, 0);
-		if (Math.max(0, getFloatingAvailableWidth(margins, contentWidth)) >= minWidth) return y;
-		const lineBottom = y + lineHeight;
-		let nextY = Number.POSITIVE_INFINITY;
-		for (const zone of zones) {
-			if (lineBottom <= zone.topY || y >= zone.bottomY) continue;
-			if (zone.bottomY > y && zone.bottomY < nextY) nextY = zone.bottomY;
-		}
-		if (!Number.isFinite(nextY) || nextY <= y) return y;
-		y = nextY;
-	}
-	return y;
-}
 /**
 * Measure a paragraph block and compute line breaks
 *
@@ -770,7 +44,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;
@@ -796,7 +69,7 @@ function measureParagraph(block, maxWidth, options) {
 			pendingFloatSkip += skip;
 		}
 	};
-	const estimatedFirstLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+	const estimatedFirstLineHeight = ptToPx(11) * 1;
 	skipObstructingFloats(estimatedFirstLineHeight, baseFirstLineWidth);
 	const firstLineFloatingMargins = getFloatingMargins(cumulativeHeight, estimatedFirstLineHeight, floatingZones, paragraphYOffset);
 	const firstLineWidth = Math.max(1, getFloatingAvailableWidth(firstLineFloatingMargins, baseFirstLineWidth));
@@ -822,7 +95,7 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length === 0) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? 11, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -843,7 +116,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 ?? "Times New Roman", attrs);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? 11, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -872,9 +145,9 @@ function measureParagraph(block, maxWidth, options) {
 		width: 0,
 		trailingWhitespaceWidth: 0,
 		regularSpaceWidth: 0,
-		maxFontSize: DEFAULT_FONT_SIZE,
+		maxFontSize: 11,
 		maxFontMetrics: null,
-		maxTabFontSize: DEFAULT_FONT_SIZE,
+		maxTabFontSize: 11,
 		maxTabFontMetrics: null,
 		maxImageHeightPx: 0,
 		maxExactImageHeightPx: 0,
@@ -885,7 +158,7 @@ function measureParagraph(block, maxWidth, options) {
 		...firstLineFloatingMargins.segments?.length ? { segmentZones: firstLineFloatingMargins.segments } : {}
 	};
 	const calculateLineTypography = (line) => {
-		const paragraphFontSize = attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
+		const paragraphFontSize = attrs?.defaultFontSize ?? 11;
 		const paragraphFontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
 		let lineFontMetrics = line.maxFontMetrics;
 		let fontSize = line.maxFontSize;
@@ -925,7 +198,7 @@ function measureParagraph(block, maxWidth, options) {
 		if (!floatingZones || floatingZones.length === 0) return bodyContentWidth;
 		const lineTypography = calculateLineTypography(currentLine);
 		let nextCumulativeHeight = cumulativeHeight + lineTypography.lineHeight;
-		const estimatedLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+		const estimatedLineHeight = ptToPx(11) * 1;
 		const absoluteY = paragraphYOffset + nextCumulativeHeight;
 		const skip = findClearLineY(absoluteY, estimatedLineHeight, floatingZones, bodyContentWidth, 24) - absoluteY;
 		if (skip > 0) nextCumulativeHeight += skip;
@@ -963,10 +236,9 @@ function measureParagraph(block, maxWidth, options) {
 	*/
 	const startNewLine = (runIndex, charIndex) => {
 		finalizeLine();
-		const estimatedLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+		const estimatedLineHeight = ptToPx(11) * 1;
 		skipObstructingFloats(estimatedLineHeight, bodyContentWidth);
 		const floatingMargins = getFloatingMargins(cumulativeHeight, estimatedLineHeight, floatingZones, paragraphYOffset);
-		const adjustedWidth = Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth));
 		currentLine = {
 			fromRun: runIndex,
 			fromChar: charIndex,
@@ -975,14 +247,14 @@ function measureParagraph(block, maxWidth, options) {
 			width: 0,
 			trailingWhitespaceWidth: 0,
 			regularSpaceWidth: 0,
-			maxFontSize: DEFAULT_FONT_SIZE,
+			maxFontSize: 11,
 			maxFontMetrics: null,
-			maxTabFontSize: DEFAULT_FONT_SIZE,
+			maxTabFontSize: 11,
 			maxTabFontMetrics: null,
 			maxImageHeightPx: 0,
 			maxExactImageHeightPx: 0,
 			maxMathHeightPx: 0,
-			availableWidth: adjustedWidth,
+			availableWidth: Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth)),
 			leftOffset: floatingMargins.leftMargin,
 			rightOffset: floatingMargins.rightMargin,
 			...floatingMargins.segments?.length ? { segmentZones: floatingMargins.segments } : {}
@@ -992,7 +264,7 @@ function measureParagraph(block, maxWidth, options) {
 	* Update max font tracking for the current line
 	*/
 	const updateMaxFont = (style) => {
-		const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+		const fontSize = style.fontSize ?? 11;
 		if (!currentLine.maxFontMetrics || fontSize > currentLine.maxFontSize) {
 			currentLine.maxFontSize = fontSize;
 			currentLine.maxFontMetrics = getFontMetrics(style);
@@ -1009,7 +281,7 @@ function measureParagraph(block, maxWidth, options) {
 	* the paragraph-mark size) leaves the line at the text's height.
 	*/
 	const updateMaxTabFont = (style) => {
-		const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+		const fontSize = style.fontSize ?? 11;
 		if (!currentLine.maxTabFontMetrics || fontSize > currentLine.maxTabFontSize) {
 			currentLine.maxTabFontSize = fontSize;
 			currentLine.maxTabFontMetrics = getFontMetrics(style);
@@ -1060,12 +332,12 @@ function measureParagraph(block, maxWidth, options) {
 			let tabWidth = tabResult.width;
 			const authoredEndpoint = contentX + tabWidth + followingWidth;
 			const activeContentRightEdge = maxWidth - currentLine.rightOffset;
-			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 preservesAuthoredStop = tabResult.alignment === "end" && options?.allowEndTabOverflow === true || tabResult.explicit === true && authoredEndpoint <= activeContentRightEdge + .5;
+			const landsOnLeftIndent = tabResult.alignment === "start" && indentLeft > 0 && Math.abs(contentX + tabWidth - indentLeft) <= .5;
 			const lineRightEdgeX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + currentLine.availableWidth + currentLine.leftOffset;
-			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 && !landsOnLeftIndent && !hasFollowingTabOnLine(runs, runIndex) && canClampTabToRightEdge(tabResult.alignment, currentLine.width, hasPriorTabOnLine(runs, runIndex), followingWidth, currentLine.availableWidth) && (tabWidth > 0 || followingWidth > 0) && contentX + tabWidth + followingWidth > lineRightEdgeX + .5) 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) {
+			if (currentLine.width + tabWidth > currentLine.availableWidth + .5) {
 				startNewLine(runIndex, 0);
 				updateMaxTabFont(style);
 			}
@@ -1096,7 +368,7 @@ function measureParagraph(block, maxWidth, options) {
 			const inlineBbox = inlineImageBoundingBox(run);
 			const imageWidth = inlineBbox.width;
 			const imageHeight = inlineBbox.height;
-			if (currentLine.width > 0 && currentLine.width + imageWidth > currentLine.availableWidth + WIDTH_TOLERANCE) startNewLine(runIndex, 0);
+			if (currentLine.width > 0 && currentLine.width + imageWidth > currentLine.availableWidth + .5) startNewLine(runIndex, 0);
 			const imageFootprintPx = imageHeight + (run.distTop ?? 0) + (run.distBottom ?? 0);
 			if (imageFootprintPx > currentLine.maxImageHeightPx) currentLine.maxImageHeightPx = imageFootprintPx;
 			if (run.exactLineHeight === true && imageFootprintPx > currentLine.maxExactImageHeightPx) currentLine.maxExactImageHeightPx = imageFootprintPx;
@@ -1108,11 +380,14 @@ function measureParagraph(block, maxWidth, options) {
 		}
 		if (isFieldRun(run)) {
 			const fallback = fieldMeasureText(run, options?.fieldValues);
-			const style = buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
+			const style = buildRunFontStyle(run, DEFAULT_FONT_FAMILY, 11);
 			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);
@@ -1127,14 +402,14 @@ function measureParagraph(block, maxWidth, options) {
 		if (isMathRun(run)) {
 			const style = {
 				fontFamily: run.fontFamily ?? "Cambria Math",
-				fontSize: run.fontSize ?? DEFAULT_FONT_SIZE,
+				fontSize: run.fontSize ?? 11,
 				...run.bold !== void 0 ? { bold: run.bold } : {},
 				...run.italic !== void 0 ? { italic: run.italic } : {}
 			};
 			updateMaxFont(style);
 			const mathWidth = measureTextWidth(run.plainText || "[equation]", style);
 			const mathFootprintPx = estimateMathFootprintPx(run);
-			if (currentLine.width > 0 && currentLine.width + mathWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+			if (currentLine.width > 0 && currentLine.width + mathWidth > currentLine.availableWidth + .5) {
 				startNewLine(runIndex, 0);
 				updateMaxFont(style);
 			}
@@ -1181,14 +456,10 @@ function measureParagraph(block, maxWidth, options) {
 				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;
@@ -1305,17 +576,7 @@ function measureParagraph(block, maxWidth, options) {
 				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);