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

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

@@ -0,0 +1,280 @@
+import { setMeasureProvider } from "./measureProvider.js";
+import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
+import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
+import { hasCjk, isCjkCodePoint, segmentByScript } from "../../utils/scriptSegments.js";
+import { canPrefetchMeasurement, prefetchMeasurement } from "./measureWorker.js";
+import { WORKER_FONT_FINGERPRINT_TEXT, countCodePoints } from "./measureWorkerProtocol.js";
+import { panic } from "better-result";
+//#region src/layout-engine/measure/measureContainer.ts
+/**
+* Canvas-backed text measurement (the default MeasureProvider).
+*
+* Uses the HTML5 Canvas API to measure text runs and calculate typography
+* metrics. Canvas-based measurement is more accurate and performant than
+* DOM-based approaches. This module touches canvas/`document`/the worker, so it
+* lives off the layout engine's import path: the engine measures through the
+* pure `measureProvider.ts` seam, and a composition root installs this backend
+* via `installCanvasMeasureProvider()` (the React editor and the bun test
+* preload do so).
+*
+* Typography conventions (matching Word behavior):
+* - ascent ≈ fontSize * 0.8 (baseline to top)
+* - descent ≈ fontSize * 0.2 (baseline to bottom)
+* - lineHeight from font metrics (fontBoundingBoxAscent + fontBoundingBoxDescent),
+*   falling back to fontSize * 1.0 (OOXML spec default single spacing)
+*/
+const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
+const DEFAULT_ASCENT_RATIO = .8;
+const DEFAULT_DESCENT_RATIO = .2;
+let canvasContext = null;
+const workerFontFingerprintCache = /* @__PURE__ */ new Map();
+/**
+* Get or create a canvas 2D context for text measurement
+*/
+function getCanvasContext() {
+	if (!canvasContext) {
+		const canvas = typeof document !== "undefined" ? document.createElement("canvas") : null;
+		if (!canvas) panic("Canvas not available. Ensure this runs in a DOM environment.");
+		canvasContext = canvas.getContext("2d");
+		if (!canvasContext) panic("Failed to get 2D context from canvas");
+	}
+	return canvasContext;
+}
+/**
+* Reset the canvas context (useful for testing)
+*/
+function resetCanvasContext() {
+	canvasContext = null;
+}
+function getWorkerFontFingerprintWidth(ctx, font) {
+	const generation = getTextWidthCacheGeneration();
+	const cached = workerFontFingerprintCache.get(font);
+	if (cached?.generation === generation) return cached.width;
+	ctx.font = font;
+	const width = ctx.measureText(WORKER_FONT_FINGERPRINT_TEXT).width;
+	workerFontFingerprintCache.set(font, {
+		generation,
+		width
+	});
+	return width;
+}
+/**
+* Get typography metrics for a given font size and family
+*
+* Uses Canvas TextMetrics API when available for precise metrics,
+* falls back to ratio-based approximations.
+*/
+function canvasGetFontMetrics(style) {
+	const fontSize = style.fontSize ?? 11;
+	const fontFamily = style.fontFamily ?? "Calibri";
+	const bold = style.bold ?? false;
+	const italic = style.italic ?? false;
+	const fontVariant = style.fontVariant;
+	const cached = getCachedFontMetrics(fontFamily, fontSize, bold, italic, fontVariant);
+	if (cached !== void 0) return {
+		fontSize,
+		ascent: cached.ascent,
+		descent: cached.descent,
+		lineHeight: cached.lineHeight,
+		fontFamily,
+		singleLineRatio: cached.singleLineRatio
+	};
+	const fontSizePx = ptToPx(fontSize);
+	let ascent = fontSizePx * DEFAULT_ASCENT_RATIO;
+	let descent = fontSizePx * DEFAULT_DESCENT_RATIO;
+	let lineHeight = fontSizePx * DEFAULT_LINE_HEIGHT_MULTIPLIER;
+	try {
+		const ctx = getCanvasContext();
+		ctx.font = buildFontString(style);
+		const metrics = ctx.measureText("Hg");
+		if (typeof metrics.actualBoundingBoxAscent === "number" && typeof metrics.actualBoundingBoxDescent === "number") {
+			ascent = metrics.actualBoundingBoxAscent;
+			descent = metrics.actualBoundingBoxDescent;
+		}
+	} catch {}
+	lineHeight = Math.max(lineHeight, ascent + descent);
+	const singleLineRatio = getResolvedData(fontFamily).singleLineRatio;
+	const result = {
+		fontSize,
+		ascent,
+		descent,
+		lineHeight,
+		fontFamily,
+		singleLineRatio
+	};
+	setCachedFontMetrics(fontFamily, fontSize, bold, italic, result, fontVariant);
+	return result;
+}
+/**
+* Measure the width of a text string with specific styling
+*
+* @param text - The text to measure
+* @param style - Font styling properties
+* @returns Width in pixels
+*/
+function canvasMeasureTextWidth(text, style) {
+	if (!text) return 0;
+	const measuredText = applyTextTransform(text, style);
+	if (style.eastAsiaFontFamily && !style.letterSpacing && hasCjk(measuredText)) return measureMixedScriptWidth(measuredText, style);
+	const ctx = getCanvasContext();
+	const font = buildFontString(style);
+	const letterSpacing = style.letterSpacing ?? 0;
+	const horizontalScale = getHorizontalScaleFactor(style);
+	const fontCacheKey = `${font}|scale:${horizontalScale}`;
+	const cached = getCachedTextWidth(measuredText, fontCacheKey, letterSpacing);
+	if (cached !== void 0) return cached;
+	ctx.font = font;
+	let width = ctx.measureText(measuredText).width;
+	if (letterSpacing) {
+		const codePoints = countCodePoints(measuredText);
+		if (codePoints > 1) width += letterSpacing * (codePoints - 1);
+	}
+	const scaledWidth = width * horizontalScale;
+	setCachedTextWidth(measuredText, fontCacheKey, letterSpacing, scaledWidth);
+	if (!canPrefetchMeasurement()) return scaledWidth;
+	const fontFingerprintWidth = getWorkerFontFingerprintWidth(ctx, font);
+	prefetchMeasurement(measuredText, font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth);
+	prefetchBinarySearchProbes(measuredText, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale);
+	return scaledWidth;
+}
+/**
+* Build a glyph-advance-only style for one script segment: keep the properties
+* that change advance width (family, size, bold/italic, small-caps) and drop
+* letter spacing, horizontal scale, transform, and the EA font so the segment
+* takes the single-font path (no double-counting, no recursion).
+*/
+function glyphAdvanceStyle(style, fontFamily) {
+	const result = {};
+	if (fontFamily !== void 0) result.fontFamily = fontFamily;
+	if (style.fontSize !== void 0) result.fontSize = style.fontSize;
+	if (style.bold !== void 0) result.bold = style.bold;
+	if (style.italic !== void 0) result.italic = style.italic;
+	if (style.fontVariant !== void 0) result.fontVariant = style.fontVariant;
+	return result;
+}
+/**
+* Width of text whose CJK code points use `style.eastAsiaFontFamily` and whose
+* other code points use `style.fontFamily`. Each script segment is measured
+* with its own font (reusing the single-font cache); letter spacing and
+* horizontal scale are applied once over the whole string so the total matches
+* the painter, which renders the same segments as sibling spans.
+*/
+function measureMixedScriptWidth(measuredText, style) {
+	const letterSpacing = style.letterSpacing ?? 0;
+	const horizontalScale = getHorizontalScaleFactor(style);
+	let glyphWidth = 0;
+	for (const segment of segmentByScript(measuredText)) {
+		const fontFamily = segment.isCjk ? style.eastAsiaFontFamily : style.fontFamily;
+		glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(style, fontFamily));
+	}
+	let width = glyphWidth;
+	if (letterSpacing) {
+		const codePoints = countCodePoints(measuredText);
+		if (codePoints > 1) width += letterSpacing * (codePoints - 1);
+	}
+	return width * horizontalScale;
+}
+/**
+* Speculatively enqueue the slice lengths that a subsequent
+* `findMaxFittingLength` binary search is likely to probe. We pick the
+* geometric series (full, half, quarter, eighth) which covers the
+* majority of probe points the binary search uses, without flooding
+* the worker for runs that will never trigger a line break.
+*
+* The worker is racing the main thread here: if the main thread asks
+* for slice(0, n/2) before the worker has answered, the cache miss
+* pays the main-thread cost as usual. When the worker wins, that probe
+* lands on a hit.
+*/
+function prefetchBinarySearchProbes(text, font, fontCacheKey, fontFingerprintWidth, letterSpacing, horizontalScale) {
+	if (text.length < 4) return;
+	for (let denom = 2; denom <= 8; denom *= 2) {
+		const len = Math.floor(text.length / denom);
+		if (len < 2) break;
+		prefetchMeasurement(text.slice(0, len), font, letterSpacing, horizontalScale, fontCacheKey, fontFingerprintWidth);
+	}
+}
+/**
+* Measure text and return full metrics
+*/
+function canvasMeasureText(text, style) {
+	const width = canvasMeasureTextWidth(text, style);
+	const metrics = canvasGetFontMetrics(style);
+	return {
+		width,
+		height: metrics.ascent + metrics.descent,
+		ascent: metrics.ascent,
+		descent: metrics.descent
+	};
+}
+/**
+* Measure a run of text and return per-character widths for click positioning
+*
+* @param text - The text to measure
+* @param style - Font styling properties
+* @returns Run measurement with width and per-character widths
+*/
+function canvasMeasureRun(text, style) {
+	const metrics = canvasGetFontMetrics(style);
+	if (!text) return {
+		width: 0,
+		charWidths: [],
+		metrics
+	};
+	const ctx = getCanvasContext();
+	const baseFont = buildFontString(style);
+	ctx.font = baseFont;
+	const eastAsiaFont = style.eastAsiaFontFamily !== void 0 && !style.letterSpacing ? buildFontString({
+		...style,
+		fontFamily: style.eastAsiaFontFamily
+	}) : void 0;
+	const letterSpacing = style.letterSpacing ?? 0;
+	const scale = getHorizontalScaleFactor(style);
+	const charWidths = [];
+	let totalWidth = 0;
+	let offset = 0;
+	for (const char of text) {
+		const cp = char.codePointAt(0);
+		const measured = applyTextTransform(char, style);
+		if (eastAsiaFont !== void 0) ctx.font = isCjkCodePoint(cp) ? eastAsiaFont : baseFont;
+		let charWidth = ctx.measureText(measured).width;
+		if (letterSpacing && offset + char.length < text.length) charWidth += letterSpacing;
+		charWidth *= scale;
+		charWidths.push(charWidth);
+		if (char.length === 2) charWidths.push(0);
+		totalWidth += charWidth;
+		offset += char.length;
+	}
+	return {
+		width: totalWidth,
+		charWidths,
+		metrics
+	};
+}
+/**
+* Default provider backed by the canvas measurement functions above.
+*/
+const canvasMeasureProvider = {
+	getFontMetrics: canvasGetFontMetrics,
+	measureTextWidth: canvasMeasureTextWidth,
+	measureText: canvasMeasureText,
+	measureRun: canvasMeasureRun
+};
+/**
+* Install the canvas backend as the active MeasureProvider. Called once at each
+* composition root (the React editor's layout pipeline and the bun test
+* preload) before any layout runs. Explicit call, not a module side effect, so
+* importing this module never silently swaps the active provider.
+*/
+const installCanvasMeasureProvider = () => {
+	setMeasureProvider(canvasMeasureProvider);
+};
+function applyTextTransform(text, style) {
+	if (style.textTransform === "uppercase") return text.toLocaleUpperCase();
+	return text;
+}
+function getHorizontalScaleFactor(style) {
+	return (style.horizontalScale ?? 100) / 100;
+}
+//#endregion
+export { canvasMeasureProvider, getCanvasContext, installCanvasMeasureProvider, resetCanvasContext };

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

@@ -0,0 +1,82 @@
+import { RunFormatting } from "../types.js";
+import { FontStyle } from "./measureTypes.js";
+
+//#region src/layout-engine/measure/measureHelpers.d.ts
+declare const DEFAULT_FONT_SIZE = 11;
+declare const DEFAULT_FONT_FAMILY = "Calibri";
+/**
+ * Build a measurement `FontStyle` from a run's formatting. Single source of
+ * truth for run → FontStyle so every measurement path (layout line-breaking,
+ * click-to-position, selection rects) carries the same fields — notably
+ * `eastAsiaFontFamily`, which must reach the measurer for CJK click/selection
+ * offsets to match what was wrapped and painted. Callers pass their own family
+ * and size fallbacks for runs that declare neither.
+ */
+declare function buildRunFontStyle(run: RunFormatting, fallbackFontFamily: string, fallbackFontSize: number): FontStyle;
+/** Cached resolved font data (CSS fallback + single-line ratio) */
+type ResolvedFontCache = {
+  cssFallback: string;
+  singleLineRatio: number;
+};
+/**
+ * Get the resolved font data for a font family, with caching.
+ */
+declare function getResolvedData(fontFamily: string): ResolvedFontCache;
+/**
+ * Build a CSS font string from styling properties
+ *
+ * Font sizes are in points and need to be converted to pixels for canvas.
+ * 1pt = 96/72 px ≈ 1.333px at standard web DPI.
+ *
+ * Uses the font resolver to get category-appropriate fallback stacks
+ * (serif fonts get serif fallbacks, sans-serif get sans-serif, etc.)
+ * matching the same stacks used in rendering for consistent measurements.
+ *
+ * @example
+ * buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
+ * // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+ */
+declare function buildFontString(style: FontStyle): string;
+/**
+ * Find the character offset at a given X position within a text run
+ *
+ * @param x - X position relative to run start
+ * @param charWidths - Per-character widths from measureRun
+ * @returns Character offset (0-based index)
+ */
+declare function findCharacterAtX(x: number, charWidths: number[]): number;
+/**
+ * Get the X position of a character offset within a text run
+ *
+ * @param offset - Character offset (0-based index)
+ * @param charWidths - Per-character widths from measureRun
+ * @returns X position in pixels
+ */
+declare function getXForCharacter(offset: number, charWidths: number[]): number;
+/**
+ * Convert twips to pixels
+ */
+declare function twipsToPx(twips: number): number;
+/**
+ * Convert pixels to twips
+ */
+declare function pxToTwips(px: number): number;
+/**
+ * Convert points to pixels
+ */
+declare function ptToPx(pt: number): number;
+/**
+ * Convert pixels to points
+ */
+declare function pxToPt(px: number): number;
+/**
+ * Convert OOXML half-points to pixels
+ * OOXML font sizes are in half-points (24 = 12pt)
+ */
+declare function halfPtToPx(halfPt: number): number;
+/**
+ * Convert pixels to OOXML half-points
+ */
+declare function pxToHalfPt(px: number): number;
+//#endregion
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -0,0 +1,156 @@
+import { resolveFontFamily } from "../../utils/fontResolver.js";
+import "../../utils/fontWeights.js";
+//#region src/layout-engine/measure/measureHelpers.ts
+/**
+* Pure measurement helpers — no canvas, no DOM, no worker.
+*
+* Unit conversions, font-string construction, run → FontStyle mapping, and
+* char-offset geometry. The layout engine imports these directly so it never
+* transitively pulls the canvas measurement backend; the canvas implementation
+* (`measureContainer.ts`) consumes them too.
+*/
+const TWIPS_PER_INCH = 1440;
+const PX_PER_INCH = 96;
+const TWIPS_PER_PX = TWIPS_PER_INCH / PX_PER_INCH;
+const DEFAULT_FONT_SIZE = 11;
+const DEFAULT_FONT_FAMILY = "Calibri";
+/**
+* Build a measurement `FontStyle` from a run's formatting. Single source of
+* truth for run → FontStyle so every measurement path (layout line-breaking,
+* click-to-position, selection rects) carries the same fields — notably
+* `eastAsiaFontFamily`, which must reach the measurer for CJK click/selection
+* offsets to match what was wrapped and painted. Callers pass their own family
+* and size fallbacks for runs that declare neither.
+*/
+function buildRunFontStyle(run, fallbackFontFamily, fallbackFontSize) {
+	return {
+		fontFamily: run.fontFamily ?? fallbackFontFamily,
+		...run.eastAsiaFontFamily !== void 0 ? { eastAsiaFontFamily: run.eastAsiaFontFamily } : {},
+		fontSize: run.fontSize ?? fallbackFontSize,
+		...run.bold !== void 0 ? { bold: run.bold } : {},
+		...run.italic !== void 0 ? { italic: run.italic } : {},
+		...run.letterSpacing !== void 0 ? { letterSpacing: run.letterSpacing } : {},
+		...run.allCaps ? { textTransform: "uppercase" } : {},
+		...run.smallCaps ? { fontVariant: "small-caps" } : {},
+		...run.horizontalScale !== void 0 ? { horizontalScale: run.horizontalScale } : {}
+	};
+}
+/** Cache for resolved font data */
+const fontResolvedCache = /* @__PURE__ */ new Map();
+/**
+* Get the resolved font data for a font family, with caching.
+*/
+function getResolvedData(fontFamily) {
+	let cached = fontResolvedCache.get(fontFamily);
+	if (cached === void 0) {
+		const resolved = resolveFontFamily(fontFamily);
+		cached = {
+			cssFallback: resolved.cssFallback,
+			singleLineRatio: resolved.singleLineRatio
+		};
+		fontResolvedCache.set(fontFamily, cached);
+	}
+	return cached;
+}
+/**
+* Get the CSS fallback string for a font family, with caching.
+*/
+function getResolvedFallback(fontFamily) {
+	return getResolvedData(fontFamily).cssFallback;
+}
+/**
+* Build a CSS font string from styling properties
+*
+* Font sizes are in points and need to be converted to pixels for canvas.
+* 1pt = 96/72 px ≈ 1.333px at standard web DPI.
+*
+* Uses the font resolver to get category-appropriate fallback stacks
+* (serif fonts get serif fallbacks, sans-serif get sans-serif, etc.)
+* matching the same stacks used in rendering for consistent measurements.
+*
+* @example
+* buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
+* // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+*/
+function buildFontString(style) {
+	const parts = [];
+	if (style.italic) parts.push("italic");
+	if (style.fontVariant) parts.push(style.fontVariant);
+	if (style.bold) parts.push("800");
+	const fontSizePx = ptToPx(style.fontSize ?? 11);
+	parts.push(`${fontSizePx}px`);
+	const fontFamily = style.fontFamily ?? "Calibri";
+	parts.push(getResolvedFallback(fontFamily));
+	return parts.join(" ");
+}
+/**
+* Find the character offset at a given X position within a text run
+*
+* @param x - X position relative to run start
+* @param charWidths - Per-character widths from measureRun
+* @returns Character offset (0-based index)
+*/
+function findCharacterAtX(x, charWidths) {
+	if (charWidths.length === 0) return 0;
+	if (x <= 0) return 0;
+	let accumulatedWidth = 0;
+	for (let i = 0; i < charWidths.length; i++) {
+		const charWidth = charWidths[i];
+		if (x <= accumulatedWidth + charWidth / 2) return i;
+		accumulatedWidth += charWidth;
+	}
+	return charWidths.length;
+}
+/**
+* Get the X position of a character offset within a text run
+*
+* @param offset - Character offset (0-based index)
+* @param charWidths - Per-character widths from measureRun
+* @returns X position in pixels
+*/
+function getXForCharacter(offset, charWidths) {
+	if (offset <= 0 || charWidths.length === 0) return 0;
+	const clampedOffset = Math.min(offset, charWidths.length);
+	let x = 0;
+	for (let i = 0; i < clampedOffset; i++) x += charWidths[i];
+	return x;
+}
+/**
+* Convert twips to pixels
+*/
+function twipsToPx(twips) {
+	return twips / TWIPS_PER_PX;
+}
+/**
+* Convert pixels to twips
+*/
+function pxToTwips(px) {
+	return Math.round(px * TWIPS_PER_PX);
+}
+/**
+* Convert points to pixels
+*/
+function ptToPx(pt) {
+	return pt * PX_PER_INCH / 72;
+}
+/**
+* Convert pixels to points
+*/
+function pxToPt(px) {
+	return px * 72 / PX_PER_INCH;
+}
+/**
+* Convert OOXML half-points to pixels
+* OOXML font sizes are in half-points (24 = 12pt)
+*/
+function halfPtToPx(halfPt) {
+	return ptToPx(halfPt / 2);
+}
+/**
+* Convert pixels to OOXML half-points
+*/
+function pxToHalfPt(px) {
+	return pxToPt(px) * 2;
+}
+//#endregion
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -0,0 +1,61 @@
+import { ParagraphBlock, ParagraphMeasure, TextRun } from "../types.js";
+import { FloatingImageZone } from "./floatingZones.js";
+import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+
+//#region src/layout-engine/measure/measureParagraph.d.ts
+/**
+ * Options for paragraph measurement
+ */
+type MeasureParagraphOptions = {
+  /** Floating image exclusion zones that affect line widths */floatingZones?: FloatingImageZone[]; /** Y offset of this paragraph relative to the exclusion zones (default: 0) */
+  paragraphYOffset?: number;
+  /** Field run `pmStart` -> resolved display text, so a field measures at its
+   *  painted width instead of the cached fallback. */
+  fieldValues?: ReadonlyMap<number, string>;
+};
+/**
+ * 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.
+ */
+declare 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).
+ */
+declare function findClearLineY(startY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, contentWidth: number, minWidth: number): number;
+/**
+ * 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
+ */
+declare function measureParagraph(block: ParagraphBlock, maxWidth: number, options?: MeasureParagraphOptions): ParagraphMeasure;
+/**
+ * Measure multiple paragraph blocks
+ *
+ * @param blocks - Array of paragraph blocks to measure
+ * @param maxWidth - Maximum available width
+ * @returns Array of ParagraphMeasure results
+ */
+declare function measureParagraphs(blocks: ParagraphBlock[], maxWidth: number): ParagraphMeasure[];
+/**
+ * Get per-character widths for a text run (for click positioning)
+ *
+ * @param run - The text run to measure
+ * @returns Array of character widths
+ */
+declare function getRunCharWidths(run: TextRun): number[];
+//#endregion
+export { type FloatingImageZone, MIN_WRAP_SEGMENT_WIDTH, MeasureParagraphOptions, clampFloatingWrapMargins, findClearLineY, getRunCharWidths, measureParagraph, measureParagraphs };