@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

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

@@ -0,0 +1,724 @@
+import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
+import "../../utils/fontResolver.js";
+import { buildRunFontStyle, ptToPx } from "./measureHelpers.js";
+import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
+import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
+import { measuredLineAdvance } from "../lineFlow.js";
+import { isFloatingImageRun } from "../types.js";
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.js";
+import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
+//#region src/layout-engine/measure/measureParagraph.ts
+/**
+* Paragraph measurement module
+*
+* Measures paragraph blocks and computes line breaking.
+* 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;
+/**
+* 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) {
+	let lo = 1;
+	let hi = text.length;
+	let best = 0;
+	while (lo <= hi) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (measureTextWidth(text.slice(0, mid), style) <= maxWidth) {
+			best = mid;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return forceMin && best === 0 ? 1 : best;
+}
+/**
+* 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);
+}
+/**
+* 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) {
+	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
+		fontSize,
+		fontFamily: fontFamily ?? DEFAULT_FONT_FAMILY
+	}));
+	const lineRule = spacing?.lineRule ?? "auto";
+	if (lineRule === "auto" || lineRule === "atLeast") {
+		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
+		if (result.lineHeight < floor) return {
+			...result,
+			lineHeight: floor
+		};
+	}
+	return result;
+}
+/**
+* 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 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 (isTextRun(next)) width += measureTextWidth(next.text || "", runToFontStyle(next));
+		else if (isFieldRun(next)) width += measureTextWidth(fieldMeasureText(next, fieldValues), runToFontStyle(next));
+		else if (isImageRun(next) && !isFloatingImageRun(next)) width += next.width || 0;
+		else if (isMathRun(next)) width += measureTextWidth(next.plainText || "[equation]", runToFontStyle(next));
+	}
+	return width;
+}
+/**
+* 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));
+}
+/**
+* Find word break points in text
+* Returns array of indices where words end (after space/punctuation)
+*/
+function findWordBreaks(text) {
+	const breaks = [];
+	for (let i = 0; i < text.length; i++) {
+		const char = text[i];
+		if (char === " " || char === "-" || char === "	") breaks.push(i + 1);
+	}
+	return breaks;
+}
+function isBreakChar(char) {
+	return char === " " || char === "-" || char === "	";
+}
+function isSpaceOrTab(char) {
+	return char === " " || char === "	";
+}
+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);
+}
+/**
+* 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(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[0])) continue;
+		const style = runToFontStyle(nextRun);
+		const breaks = findWordBreaks(text);
+		if (breaks.length === 0) {
+			widths[index] = measureTextWidth(text, style) + (widths[index + 1] ?? 0);
+			continue;
+		}
+		const firstBreak = breaks[0];
+		if (firstBreak === void 0) continue;
+		widths[index] = measureTextWidth(trimTrailingSpacesAndTabs(text.slice(0, firstBreak)), style);
+	}
+	return widths;
+}
+/**
+* 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
+*
+* @param block - The paragraph block to measure
+* @param maxWidth - Maximum available width for the paragraph
+* @param options - Optional measurement options (floating zones, Y offset)
+* @returns ParagraphMeasure with lines and total height
+*/
+function measureParagraph(block, maxWidth, options) {
+	const runs = block.runs;
+	const attrs = block.attrs;
+	const spacing = attrs?.spacing;
+	const floatingZones = options?.floatingZones;
+	const paragraphYOffset = options?.paragraphYOffset ?? 0;
+	const indent = attrs?.indent;
+	const indentLeft = indent?.left ?? 0;
+	const indentRight = indent?.right ?? 0;
+	const firstLineOffset = (indent?.firstLine ?? 0) - (indent?.hanging ?? 0);
+	const bodyContentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
+	let baseFirstLineWidth = Math.max(1, bodyContentWidth - firstLineOffset);
+	const markerInlineWidth = getListMarkerInlineWidth(block);
+	if (markerInlineWidth > 0) baseFirstLineWidth = Math.max(1, baseFirstLineWidth - markerInlineWidth);
+	let cumulativeHeight = 0;
+	let pendingFloatSkip = 0;
+	/**
+	* If floats leave no usable horizontal room at `cumulativeHeight`, advance
+	* past them by mutating cumulativeHeight + pendingFloatSkip.
+	*/
+	const skipObstructingFloats = (lineHeight, lineMaxWidth) => {
+		if (!floatingZones || floatingZones.length === 0) return;
+		const absoluteY = paragraphYOffset + cumulativeHeight;
+		const skip = findClearLineY(absoluteY, lineHeight, floatingZones, lineMaxWidth, 24) - absoluteY;
+		if (skip > 0) {
+			cumulativeHeight += skip;
+			pendingFloatSkip += skip;
+		}
+	};
+	const estimatedFirstLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+	skipObstructingFloats(estimatedFirstLineHeight, baseFirstLineWidth);
+	const firstLineFloatingMargins = getFloatingMargins(cumulativeHeight, estimatedFirstLineHeight, floatingZones, paragraphYOffset);
+	const firstLineWidth = Math.max(1, getFloatingAvailableWidth(firstLineFloatingMargins, baseFirstLineWidth));
+	const lines = [];
+	if (runs.length === 0) {
+		if (attrs?.suppressEmptyParagraphHeight) {
+			lines.push({
+				fromRun: 0,
+				fromChar: 0,
+				toRun: 0,
+				toChar: 0,
+				width: 0,
+				ascent: 0,
+				descent: 0,
+				lineHeight: 0
+			});
+			return {
+				kind: "paragraph",
+				lines,
+				totalHeight: 0
+			};
+		}
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+		lines.push({
+			fromRun: 0,
+			fromChar: 0,
+			toRun: 0,
+			toChar: 0,
+			width: 0,
+			...emptyMetrics
+		});
+		let totalHeight = emptyMetrics.lineHeight;
+		if (spacing?.before) totalHeight += spacing.before;
+		if (spacing?.after) totalHeight += spacing.after;
+		return {
+			kind: "paragraph",
+			lines,
+			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);
+		lines.push({
+			fromRun: 0,
+			fromChar: 0,
+			toRun: 0,
+			toChar: 0,
+			width: 0,
+			...emptyMetrics
+		});
+		let totalHeight = emptyMetrics.lineHeight;
+		if (spacing?.before) totalHeight += spacing.before;
+		if (spacing?.after) totalHeight += spacing.after;
+		return {
+			kind: "paragraph",
+			lines,
+			totalHeight
+		};
+	}
+	const trailingGlueWidths = computeTrailingGlueWidths(runs);
+	let currentLine = {
+		fromRun: 0,
+		fromChar: 0,
+		toRun: 0,
+		toChar: 0,
+		width: 0,
+		maxFontSize: DEFAULT_FONT_SIZE,
+		maxFontMetrics: null,
+		maxImageHeightPx: 0,
+		maxMathHeightPx: 0,
+		availableWidth: firstLineWidth,
+		leftOffset: firstLineFloatingMargins.leftMargin,
+		rightOffset: firstLineFloatingMargins.rightMargin,
+		...firstLineFloatingMargins.segments?.length ? { segmentZones: firstLineFloatingMargins.segments } : {}
+	};
+	const calculateLineTypography = (line) => {
+		const finalTypography = { ...calculateTypographyMetrics(line.maxFontSize, spacing, line.maxFontMetrics) };
+		const inlineObjectHeight = Math.max(line.maxImageHeightPx, line.maxMathHeightPx);
+		if (inlineObjectHeight > finalTypography.lineHeight) {
+			const objectHeight = inlineObjectHeight;
+			const buffer = finalTypography.descent;
+			if (line.fromRun === line.toRun) {
+				finalTypography.lineHeight = objectHeight + buffer * 2;
+				finalTypography.ascent = objectHeight + buffer;
+			} else {
+				finalTypography.lineHeight = objectHeight + buffer;
+				finalTypography.ascent = objectHeight;
+			}
+		}
+		return finalTypography;
+	};
+	const getPostWrapAvailableWidth = () => {
+		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 absoluteY = paragraphYOffset + nextCumulativeHeight;
+		const skip = findClearLineY(absoluteY, estimatedLineHeight, floatingZones, bodyContentWidth, 24) - absoluteY;
+		if (skip > 0) nextCumulativeHeight += skip;
+		const floatingMargins = getFloatingMargins(nextCumulativeHeight, estimatedLineHeight, floatingZones, paragraphYOffset);
+		return Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth));
+	};
+	/**
+	* Finalize and push the current line to the lines array
+	*/
+	const finalizeLine = () => {
+		const finalTypography = calculateLineTypography(currentLine);
+		const line = {
+			fromRun: currentLine.fromRun,
+			fromChar: currentLine.fromChar,
+			toRun: currentLine.toRun,
+			toChar: currentLine.toChar,
+			width: currentLine.width,
+			...finalTypography
+		};
+		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
+		if (currentLine.rightOffset > 0) line.rightOffset = currentLine.rightOffset;
+		if (pendingFloatSkip > 0) {
+			line.floatSkipBefore = pendingFloatSkip;
+			pendingFloatSkip = 0;
+		}
+		lines.push(line);
+		cumulativeHeight += finalTypography.lineHeight;
+	};
+	/**
+	* Start a new line after the current one
+	*/
+	const startNewLine = (runIndex, charIndex) => {
+		finalizeLine();
+		const estimatedLineHeight = ptToPx(DEFAULT_FONT_SIZE) * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+		skipObstructingFloats(estimatedLineHeight, bodyContentWidth);
+		const floatingMargins = getFloatingMargins(cumulativeHeight, estimatedLineHeight, floatingZones, paragraphYOffset);
+		currentLine = {
+			fromRun: runIndex,
+			fromChar: charIndex,
+			toRun: runIndex,
+			toChar: charIndex,
+			width: 0,
+			maxFontSize: DEFAULT_FONT_SIZE,
+			maxFontMetrics: null,
+			maxImageHeightPx: 0,
+			maxMathHeightPx: 0,
+			availableWidth: Math.max(1, getFloatingAvailableWidth(floatingMargins, bodyContentWidth)),
+			leftOffset: floatingMargins.leftMargin,
+			rightOffset: floatingMargins.rightMargin,
+			...floatingMargins.segments?.length ? { segmentZones: floatingMargins.segments } : {}
+		};
+	};
+	/**
+	* Update max font tracking for the current line
+	*/
+	const updateMaxFont = (style) => {
+		const fontSize = style.fontSize ?? DEFAULT_FONT_SIZE;
+		if (!currentLine.maxFontMetrics || fontSize > currentLine.maxFontSize) {
+			currentLine.maxFontSize = fontSize;
+			currentLine.maxFontMetrics = getFontMetrics(style);
+		}
+	};
+	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
+		const run = runs[runIndex];
+		if (isLineBreakRun(run)) {
+			currentLine.toRun = runIndex;
+			currentLine.toChar = 0;
+			startNewLine(runIndex + 1, 0);
+			continue;
+		}
+		if (isTabRun(run)) {
+			const style = runToFontStyle(run);
+			updateMaxFont(style);
+			const followingWidth = measureInlineWidthAfterTab(runs, runIndex, options?.fieldValues);
+			const decimalPrefixWidth = measureDecimalPrefixWidthAfterTab(runs, runIndex, options?.fieldValues);
+			const lineX = currentLine.width + currentLine.leftOffset;
+			const tabWidth = calculateTabWidth(indentLeft + (lines.length === 0 ? firstLineOffset + markerInlineWidth : 0) + lineX, {
+				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
+				leftIndent: pixelsToTwips(indentLeft)
+			}, {
+				followingWidth,
+				decimalPrefixWidth
+			}).width;
+			if (currentLine.width + tabWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+				startNewLine(runIndex, 0);
+				updateMaxFont(style);
+			}
+			currentLine.width += tabWidth;
+			currentLine.toRun = runIndex;
+			currentLine.toChar = 1;
+			continue;
+		}
+		if (isImageRun(run)) {
+			const wrapType = run.wrapType;
+			if (run.displayMode === "float" || wrapType === "square" || wrapType === "tight" || wrapType === "through" || wrapType === "behind" || wrapType === "inFront") {
+				currentLine.toRun = runIndex;
+				currentLine.toChar = 1;
+				continue;
+			}
+			if (wrapType === "topAndBottom" || run.displayMode === "block") {
+				if (currentLine.width > 0) startNewLine(runIndex, 0);
+				const imageHeight = rotatedBlockImageHeight(run);
+				const distTop = run.distTop ?? 6;
+				const distBottom = run.distBottom ?? 6;
+				currentLine.toRun = runIndex;
+				currentLine.toChar = 1;
+				currentLine.maxImageHeightPx = imageHeight + distTop + distBottom;
+				startNewLine(runIndex + 1, 0);
+				continue;
+			}
+			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);
+			const imageFootprintPx = imageHeight + (run.distTop ?? 0) + (run.distBottom ?? 0);
+			if (imageFootprintPx > currentLine.maxImageHeightPx) currentLine.maxImageHeightPx = imageFootprintPx;
+			currentLine.width += imageWidth;
+			currentLine.toRun = runIndex;
+			currentLine.toChar = 1;
+			continue;
+		}
+		if (isFieldRun(run)) {
+			const fallback = fieldMeasureText(run, options?.fieldValues);
+			const style = buildRunFontStyle(run, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE);
+			updateMaxFont(style);
+			const fieldWidth = measureTextWidth(fallback, style);
+			if (currentLine.width > 0 && currentLine.width + fieldWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+				startNewLine(runIndex, 0);
+				updateMaxFont(style);
+			}
+			currentLine.width += fieldWidth;
+			currentLine.toRun = runIndex;
+			currentLine.toChar = 1;
+			continue;
+		}
+		if (isMathRun(run)) {
+			const style = {
+				fontFamily: run.fontFamily ?? "Cambria Math",
+				fontSize: run.fontSize ?? DEFAULT_FONT_SIZE,
+				...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) {
+				startNewLine(runIndex, 0);
+				updateMaxFont(style);
+			}
+			if (mathFootprintPx > currentLine.maxMathHeightPx) currentLine.maxMathHeightPx = mathFootprintPx;
+			currentLine.width += mathWidth;
+			currentLine.toRun = runIndex;
+			currentLine.toChar = 1;
+			continue;
+		}
+		if (isTextRun(run)) {
+			const textRun = run;
+			const text = textRun.text;
+			const style = runToFontStyle(textRun);
+			updateMaxFont(style);
+			if (!text || text.length === 0) {
+				currentLine.toRun = runIndex;
+				currentLine.toChar = 0;
+				continue;
+			}
+			const wordBreaks = findWordBreaks(text);
+			let charIndex = 0;
+			while (charIndex < text.length) {
+				let nextBreak = text.length;
+				for (const breakPoint of wordBreaks) if (breakPoint > charIndex) {
+					nextBreak = breakPoint;
+					break;
+				}
+				const word = text.slice(charIndex, nextBreak);
+				const wordWidth = measureTextWidth(word, style);
+				if (wordWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+					let chunkStart = 0;
+					while (chunkStart < word.length) {
+						const spaceLeft = currentLine.availableWidth - currentLine.width + WIDTH_TOLERANCE;
+						let bestEnd = findMaxFittingLength(word.slice(chunkStart), style, spaceLeft);
+						if (bestEnd === 0) {
+							if (currentLine.width > 0) {
+								startNewLine(runIndex, charIndex + chunkStart);
+								updateMaxFont(style);
+								continue;
+							}
+							bestEnd = 1;
+						}
+						const chunkEnd = chunkStart + bestEnd;
+						const chunkWidth = measureTextWidth(word.slice(chunkStart, chunkEnd), style);
+						currentLine.width += chunkWidth;
+						currentLine.toRun = runIndex;
+						currentLine.toChar = charIndex + chunkEnd;
+						chunkStart = chunkEnd;
+						if (chunkStart < word.length) {
+							startNewLine(runIndex, charIndex + chunkStart);
+							updateMaxFont(style);
+						}
+					}
+					charIndex = nextBreak;
+					continue;
+				}
+				const rawGlueWidth = nextBreak === text.length && word.length > 0 && !isBreakChar(word[word.length - 1]) ? trailingGlueWidths[runIndex] ?? 0 : 0;
+				const glueWidth = rawGlueWidth > 0 && wordWidth + rawGlueWidth <= getPostWrapAvailableWidth() + WIDTH_TOLERANCE ? rawGlueWidth : 0;
+				if (currentLine.width > 0 && currentLine.width + wordWidth + glueWidth > currentLine.availableWidth + WIDTH_TOLERANCE) {
+					startNewLine(runIndex, charIndex);
+					updateMaxFont(style);
+				}
+				currentLine.width += wordWidth;
+				currentLine.toRun = runIndex;
+				currentLine.toChar = nextBreak;
+				charIndex = nextBreak;
+			}
+		}
+	}
+	finalizeLine();
+	let totalWithSpacing = lines.reduce((sum, line) => sum + measuredLineAdvance(line), 0);
+	if (spacing?.before) totalWithSpacing += spacing.before;
+	if (spacing?.after) totalWithSpacing += spacing.after;
+	return {
+		kind: "paragraph",
+		lines,
+		totalHeight: totalWithSpacing
+	};
+}
+/**
+* Measure multiple paragraph blocks
+*
+* @param blocks - Array of paragraph blocks to measure
+* @param maxWidth - Maximum available width
+* @returns Array of ParagraphMeasure results
+*/
+function measureParagraphs(blocks, maxWidth) {
+	return blocks.map((block) => measureParagraph(block, maxWidth));
+}
+/**
+* Get per-character widths for a text run (for click positioning)
+*
+* @param run - The text run to measure
+* @returns Array of character widths
+*/
+function getRunCharWidths(run) {
+	const style = runToFontStyle(run);
+	return measureRun(run.text, style).charWidths;
+}
+//#endregion
+export { MIN_WRAP_SEGMENT_WIDTH, clampFloatingWrapMargins, findClearLineY, getRunCharWidths, measureParagraph, measureParagraphs };