@stll/folio-core 0.61.0 → 0.63.0

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

@@ -10,7 +10,7 @@ import { getFloatingAvailableWidth, getFloatingMargins } from "./floatingZones.j
 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 { exceedsHyphenationZone, findMaxFittingLength, isFinalTextCandidate, isIgnorableFinalTailRun, measureWordWithTrailingWhitespace, precedingLetterSpacing, resolveTextCandidateFit, trailingHangingPunctuationWidth, trimLineEndWhitespace } from "./lineFitting.js";
 import { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle } from "./lineTypography.js";
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "./measureHelpers.js";
@@ -25,6 +25,13 @@ import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
 * Measures paragraph blocks and computes line breaking.
 * Converts runs into measured lines with typography metrics.
 */
+const scriptLineHeightStyle = ({ run, style, unshiftedFontSize }) => {
+	if (!run.superscript && !run.subscript || unshiftedFontSize <= (style.fontSize ?? 11)) return style;
+	return {
+		...style,
+		fontSize: unshiftedFontSize
+	};
+};
 /**
 * Measure a paragraph block and compute line breaks
 *
@@ -95,7 +102,9 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length === 0) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? 11, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
+		const emptyFontSize = attrs?.defaultFontSize ?? 11;
+		const emptyFontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
+		const emptyMetrics = calculateEmptyParagraphMetrics(emptyFontSize, spacing, emptyFontFamily, attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -116,7 +125,9 @@ function measureParagraph(block, maxWidth, options) {
 		};
 	}
 	if (runs.length > 0 && runs.every((run) => isTextRun(run) && isEmptyTextRun(run))) {
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? 11, spacing, attrs?.defaultFontFamily ?? "Times New Roman", attrs);
+		const fontSize = attrs?.defaultFontSize ?? 11;
+		const fontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
+		const emptyMetrics = calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -166,10 +177,36 @@ function measureParagraph(block, maxWidth, options) {
 			lineFontMetrics = line.maxTabFontMetrics;
 			fontSize = lineFontMetrics ? line.maxTabFontSize : paragraphFontSize;
 		}
+		let consumedText;
+		for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex++) {
+			const run = runs[runIndex];
+			if (!run || !isTextRun(run)) continue;
+			const start = runIndex === line.fromRun ? line.fromChar : 0;
+			if ((runIndex === line.toRun ? line.toChar : run.text.length) <= start) continue;
+			const style = runToFontStyle(run);
+			const lineHeightStyle = scriptLineHeightStyle({
+				run,
+				style: cjkLineHeightStyle(run, complexScriptLineHeightStyle(run, style)),
+				unshiftedFontSize: run.fontSize ?? attrs?.defaultFontSize ?? 11
+			});
+			const scriptFontSize = lineHeightStyle.fontSize ?? 11;
+			const textMetrics = getFontMetrics(lineHeightStyle);
+			if (!consumedText || scriptFontSize > consumedText.fontSize || scriptFontSize === consumedText.fontSize && isCjkFont(lineHeightStyle.fontFamily ?? "") && textMetrics.singleLineRatio > consumedText.metrics.singleLineRatio) consumedText = {
+				fontSize: scriptFontSize,
+				metrics: textMetrics
+			};
+		}
+		if (consumedText) {
+			if (!line.maxFontMetrics || consumedText.fontSize > fontSize || consumedText.fontSize === fontSize && isCjkFont(consumedText.metrics.fontFamily ?? "") && consumedText.metrics.singleLineRatio > (lineFontMetrics?.singleLineRatio ?? 0)) {
+				fontSize = consumedText.fontSize;
+				lineFontMetrics = consumedText.metrics;
+			}
+		}
 		const metrics = lineFontMetrics ?? getFontMetrics({
 			fontSize: paragraphFontSize,
 			fontFamily: paragraphFontFamily,
 			...attrs?.embeddedFontFamilyMap ? { embeddedFontFamilyMap: attrs.embeddedFontFamilyMap } : {},
+			...attrs?.documentFontFacts ? { documentFontFacts: attrs.documentFontFacts } : {},
 			...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
 		});
 		const finalTypography = { ...calculateTypographyMetrics(fontSize, spacing, metrics) };
@@ -322,11 +359,12 @@ function measureParagraph(block, maxWidth, options) {
 			const lineX = currentLine.width + currentLine.leftOffset;
 			const isFirstLine = lines.length === 0;
 			const contentX = indentLeft + (isFirstLine ? firstLineOffset + markerInlineWidth : 0) + lineX;
-			const tabResult = calculateTabWidth(contentX, {
+			const tabContext = {
 				...attrs?.tabs !== void 0 ? { explicitStops: attrs.tabs } : {},
 				...attrs?.defaultTabStopTwips !== void 0 ? { defaultTabInterval: attrs.defaultTabStopTwips } : {},
 				leftIndent: pixelsToTwips(indentLeft)
-			}, {
+			};
+			const tabResult = calculateTabWidth(contentX, tabContext, {
 				followingWidth,
 				decimalPrefixWidth
 			});
@@ -404,12 +442,14 @@ function measureParagraph(block, maxWidth, options) {
 			const style = {
 				fontFamily: run.fontFamily ?? "Cambria Math",
 				...run.embeddedFontFamilyMap ? { embeddedFontFamilyMap: run.embeddedFontFamilyMap } : {},
+				...run.documentFontFacts ? { documentFontFacts: run.documentFontFacts } : {},
 				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 mathText = run.plainText || "[equation]";
+			const mathWidth = measureTextWidth(mathText, style);
 			const mathFootprintPx = estimateMathFootprintPx(run);
 			if (currentLine.width > 0 && currentLine.width + mathWidth > currentLine.availableWidth + .5) {
 				startNewLine(runIndex, 0);
@@ -431,9 +471,13 @@ function measureParagraph(block, maxWidth, options) {
 				run: textRun
 			});
 			const breakPolicy = effectiveLineBreakPolicy.provider;
-			const lineHeightStyle = cjkLineHeightStyle(textRun, complexScriptLineHeightStyle(textRun, style));
-			updateMaxFont(lineHeightStyle);
+			const lineHeightStyle = scriptLineHeightStyle({
+				run: textRun,
+				style: cjkLineHeightStyle(textRun, complexScriptLineHeightStyle(textRun, style)),
+				unshiftedFontSize: textRun.fontSize ?? attrs?.defaultFontSize ?? 11
+			});
 			if (!text || text.length === 0) {
+				updateMaxFont(lineHeightStyle);
 				currentLine.toRun = runIndex;
 				currentLine.toChar = 0;
 				continue;
@@ -488,7 +532,8 @@ function measureParagraph(block, maxWidth, options) {
 					let fittingBreak;
 					for (const breakOffset of activeHyphenationWord.breaks) {
 						if (breakOffset <= consumed || breakOffset >= activeHyphenationWord.text.length) continue;
-						if (measureTextWidth(activeHyphenationWord.text.slice(consumed, breakOffset), style) + hyphenWidth <= spaceLeft) fittingBreak = breakOffset;
+						const prefix = activeHyphenationWord.text.slice(consumed, breakOffset);
+						if (measureTextWidth(prefix, style) + hyphenWidth <= spaceLeft) fittingBreak = breakOffset;
 					}
 					if (fittingBreak !== void 0) {
 						const absoluteBreak = activeHyphenationWord.start + fittingBreak;
@@ -543,7 +588,8 @@ function measureParagraph(block, maxWidth, options) {
 					let chunkLeadingLetterSpacing = leadingLetterSpacing;
 					while (chunkStart < measuredWord.length) {
 						const spaceLeft = currentLine.availableWidth - currentLine.width - chunkLeadingLetterSpacing + WIDTH_TOLERANCE;
-						let bestEnd = findMaxFittingLength(measuredWord.slice(chunkStart), style, spaceLeft, currentLine.width === 0, breakPolicy);
+						const remaining = measuredWord.slice(chunkStart);
+						let bestEnd = findMaxFittingLength(remaining, style, spaceLeft, currentLine.width === 0, breakPolicy);
 						if (bestEnd === 0) {
 							startNewLine(runIndex, charIndex + chunkStart);
 							chunkLeadingLetterSpacing = 0;
@@ -555,7 +601,7 @@ function measureParagraph(block, maxWidth, options) {
 						const chunkWidth = measureTextWidth(chunk, style);
 						currentLine.width += chunkLeadingLetterSpacing + chunkWidth;
 						chunkLeadingLetterSpacing = 0;
-						currentLine.trailingWhitespaceWidth = chunkWidth - measureTextWidth(trimTrailingSpacesAndTabs(chunk), style);
+						currentLine.trailingWhitespaceWidth = chunkWidth - measureTextWidth(trimLineEndWhitespace(chunk), style);
 						currentLine.regularSpaceWidth += compressibleSpaceWidth(chunk, style);
 						currentLine.toRun = runIndex;
 						currentLine.toChar = charIndex + chunkEnd;

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

@@ -5,18 +5,24 @@ import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "./measu
  * the composition roots; a Rust/WASM or headless provider can be installed via
  * `setMeasureProvider` without the layout engine importing canvas directly.
  */
-type MeasureProvider = {
+export type MeasureProvider = {
   getFontMetrics: (style: FontStyle) => FontMetrics;
   measureTextWidth: (text: string, style: FontStyle) => number;
   measureText: (text: string, style: FontStyle) => TextMeasurement;
   measureRun: (text: string, style: FontStyle) => RunMeasurement;
 };
-declare const getMeasureProvider: () => MeasureProvider;
-declare const setMeasureProvider: (provider: MeasureProvider) => void;
-declare const resetMeasureProvider: () => void;
-declare const getFontMetrics: (style: FontStyle) => FontMetrics;
-declare const measureTextWidth: (text: string, style: FontStyle) => number;
-declare const measureText: (text: string, style: FontStyle) => TextMeasurement;
-declare const measureRun: (text: string, style: FontStyle) => RunMeasurement;
+export declare const getMeasureProvider: () => MeasureProvider;
+export declare const setMeasureProvider: (provider: MeasureProvider) => void;
+export declare const resetMeasureProvider: () => void;
+export declare const getFontMetrics: (style: FontStyle) => FontMetrics;
+export declare const measureTextWidth: (text: string, style: FontStyle) => number;
+export declare const measureText: (text: string, style: FontStyle) => TextMeasurement;
+export declare const measureRun: (text: string, style: FontStyle) => RunMeasurement;
+type MeasurePositionedRunOptions = {
+  text: string;
+  style: FontStyle;
+  trailingAutomaticSpacingPx?: number;
+};
+export declare const measurePositionedRun: ({ text, style, trailingAutomaticSpacingPx }: MeasurePositionedRunOptions) => RunMeasurement;
 //#endregion
-export { MeasureProvider, getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };
+export {};

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

@@ -1,3 +1,4 @@
+import { automaticGapCodeUnitAdvances, automaticTextSpacingGaps } from "./automaticTextSpacing.js";
 import { toPaintedText } from "./textMeasurementPolicy.js";
 import { panic } from "better-result";
 //#region src/layout-engine/measure/measureProvider.ts
@@ -29,8 +30,69 @@ const resetMeasureProvider = () => {
 	activeMeasureProvider = throwingMeasureProvider;
 };
 const getFontMetrics = (style) => activeMeasureProvider.getFontMetrics(style);
-const measureTextWidth = (text, style) => activeMeasureProvider.measureTextWidth(toPaintedText(text), style);
-const measureText = (text, style) => activeMeasureProvider.measureText(toPaintedText(text), style);
-const measureRun = (text, style) => activeMeasureProvider.measureRun(toPaintedText(text), style);
+const measureTextWidth = (text, style) => {
+	const paintedText = toPaintedText(text);
+	let width = activeMeasureProvider.measureTextWidth(paintedText, style);
+	for (const gap of automaticTextSpacingGaps(paintedText, style)) width += gap.advancePx;
+	return width;
+};
+const measureText = (text, style) => {
+	const paintedText = toPaintedText(text);
+	const measured = activeMeasureProvider.measureText(paintedText, style);
+	const gaps = automaticTextSpacingGaps(paintedText, style);
+	if (gaps.length === 0) return measured;
+	let width = measured.width;
+	for (const gap of gaps) width += gap.advancePx;
+	return {
+		...measured,
+		width
+	};
+};
+const measureRun = (text, style) => {
+	const paintedText = toPaintedText(text);
+	const measured = activeMeasureProvider.measureRun(paintedText, style);
+	const gaps = automaticTextSpacingGaps(paintedText, style);
+	if (gaps.length === 0) return measured;
+	const charWidths = [...measured.charWidths];
+	let width = measured.width;
+	for (const [offset, advance] of automaticGapCodeUnitAdvances(paintedText, gaps)) {
+		charWidths[offset] = (charWidths[offset] ?? 0) + advance;
+		width += advance;
+	}
+	return {
+		...measured,
+		charWidths,
+		width
+	};
+};
+const measurePositionedRun = ({ text, style, trailingAutomaticSpacingPx = 0 }) => {
+	const measured = measureRun(text, style);
+	const gaps = automaticTextSpacingGaps(text, style);
+	const gapWidth = gaps.reduce((sum, gap) => sum + gap.advancePx, 0);
+	const glyphWidth = measured.charWidths.reduce((sum, width) => sum + width, 0) - gapWidth;
+	const shapedWidth = measureTextWidth(text, style) - gapWidth;
+	const scale = glyphWidth > 0 ? shapedWidth / glyphWidth : 1;
+	if (scale === 1 && trailingAutomaticSpacingPx === 0) {
+		const width = shapedWidth + gapWidth;
+		return measured.width === width ? measured : {
+			...measured,
+			width
+		};
+	}
+	const gapAdvances = gaps.length === 0 ? void 0 : automaticGapCodeUnitAdvances(text, gaps);
+	const charWidths = measured.charWidths.map((width, offset) => {
+		const gap = gapAdvances?.get(offset) ?? 0;
+		return (width - gap) * scale + gap;
+	});
+	if (text.length > 0 && trailingAutomaticSpacingPx > 0) for (const [offset, advance] of automaticGapCodeUnitAdvances(text, [{
+		offset: text.length,
+		advancePx: trailingAutomaticSpacingPx
+	}])) charWidths[offset] = (charWidths[offset] ?? 0) + advance;
+	return {
+		...measured,
+		charWidths,
+		width: shapedWidth + gapWidth + trailingAutomaticSpacingPx
+	};
+};
 //#endregion
-export { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };
+export { getFontMetrics, getMeasureProvider, measurePositionedRun, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider };

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

@@ -1,22 +1,25 @@
+import { DocumentFontFacts } from "../../fonts/documentFontFacts.js";
 declare namespace measureTypes_d_exports {
-  export { FontMetrics, FontStyle, RunMeasurement, TextMeasurement };
+  export { AutomaticTextSpacingPolicy, FontMetrics, FontStyle, RunMeasurement, TextMeasurement };
 }
-/**
- * Measurement data shapes.
- *
- * Pure type declarations shared by the provider seam (`measureProvider.ts`),
- * the pure helpers (`measureHelpers.ts`), and the canvas implementation
- * (`measureContainer.ts`). Types only — this module has no runtime and never
- * pulls canvas/DOM into an importer's graph.
- */
+export type AutomaticTextSpacingPolicy = {
+  latin: boolean;
+  numbers: boolean;
+  reverseFontFamily?: string | null;
+};
 /**
  * Font styling properties for measurement
  */
-type FontStyle = {
+export type FontStyle = {
+  automaticTextSpacing?: AutomaticTextSpacingPolicy;
   /** Embedded families owned by this editor, never ambient process state. */
   embeddedFontFamilyMap?: ReadonlyMap<string, string>;
+  /** Authored font-table facts owned by this document. */
+  documentFontFacts?: DocumentFontFacts;
   fontFamily?: string;
   alternateFontFamily?: string;
+  hAnsiFontFamily?: string;
+  hAnsiAlternateFontFamily?: string;
   /**
    * East-Asian font for CJK code points. When set, `measureTextWidth` /
    * `measureRun` measure CJK code points with this font and the rest with
@@ -53,7 +56,7 @@ type FontStyle = {
 /**
  * Typography metrics for a font
  */
-type FontMetrics = {
+export type FontMetrics = {
   fontSize: number;
   /** Ink extent above the baseline: how far the glyphs actually reach. */
   ascent: number;
@@ -77,7 +80,7 @@ type FontMetrics = {
 /**
  * Result of measuring a text string
  */
-type TextMeasurement = {
+export type TextMeasurement = {
   width: number;
   height: number;
   ascent: number;
@@ -86,10 +89,10 @@ type TextMeasurement = {
 /**
  * Result of measuring a run of text
  */
-type RunMeasurement = {
+export type RunMeasurement = {
   width: number;
   charWidths: number[];
   metrics: FontMetrics;
 };
 //#endregion
-export { FontMetrics, FontStyle, RunMeasurement, TextMeasurement, measureTypes_d_exports };
+export { measureTypes_d_exports };

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

@@ -4,7 +4,7 @@ import { MeasureRequestEntry, MeasureWorkerRequest, MeasureWorkerResponse } from
  * Minimal duck-typed transport so tests can supply a fake instead of a
  * real `Worker`. Mirrors the subset of `Worker` we use.
  */
-type MeasureWorkerTransport = {
+export type MeasureWorkerTransport = {
   postMessage: (message: MeasureWorkerRequest) => void;
   addEventListener: {
     (type: "message", listener: (event: {
@@ -19,7 +19,7 @@ type TransportFactory = () => MeasureWorkerTransport;
  * Test-only: inject a transport factory in place of the real `Worker`
  * constructor. Pass `null` to restore production behaviour.
  */
-declare function __setMeasureWorkerTransport(factory: TransportFactory | null): void;
+export declare function __setMeasureWorkerTransport(factory: TransportFactory | null): void;
 /**
  * Enqueue a measurement for asynchronous pre-warming. Returns
  * immediately. The caller has already filled the cache synchronously
@@ -31,23 +31,23 @@ declare function __setMeasureWorkerTransport(factory: TransportFactory | null):
  * `OffscreenCanvas`/`Worker`, or when the proxy has been disabled by
  * a previous error.
  */
-declare function prefetchMeasurement(request: MeasureRequestEntry): void;
-declare function canPrefetchMeasurement(): boolean;
+export declare function prefetchMeasurement(request: MeasureRequestEntry): void;
+export declare function canPrefetchMeasurement(): boolean;
 /**
  * Test-only: synchronously drain the pending queue. The caller is
  * expected to have already attached its assertions to the cache or to
  * the injected transport.
  */
-declare function __flushMeasureQueueForTests(): void;
+export declare function __flushMeasureQueueForTests(): void;
 /**
  * Test-only: dispose the proxy. Safe to call when nothing is live.
  */
-declare function __disposeMeasureProxyForTests(): void;
+export declare function __disposeMeasureProxyForTests(): void;
 /**
  * Test-only: report whether the proxy considers itself alive. Useful
  * for asserting that flag/feature-detection gating actually short-
  * circuits worker construction.
  */
-declare function __isMeasureProxyLiveForTests(): boolean;
+export declare function __isMeasureProxyLiveForTests(): boolean;
 //#endregion
-export { MeasureWorkerTransport, __disposeMeasureProxyForTests, __flushMeasureQueueForTests, __isMeasureProxyLiveForTests, __setMeasureWorkerTransport, canPrefetchMeasurement, prefetchMeasurement };
+export {};

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

@@ -19,7 +19,7 @@ import { FontKerningMode } from "./textMeasurementPolicy.js";
  * `fontFingerprintWidth` before caching a result. This covers the actual
  * glyphs and font subsets used by the request, including non-Latin text.
  */
-type MeasureRequestEntry = {
+export type MeasureRequestEntry = {
   text: string;
   font: string;
   fontCacheKey: string;
@@ -35,12 +35,12 @@ type MeasureRequestEntry = {
  * Shared by the main thread (`measureContainer`) and the worker so their cached
  * widths agree on astral text with letter spacing. Allocation-free.
  */
-declare function countCodePoints(text: string): number;
+export declare function countCodePoints(text: string): number;
 /**
  * Worker → main response for a single entry. Echoes the input keys the
  * proxy needs in order to look up the right cache slot.
  */
-type MeasureResponseEntry = {
+export type MeasureResponseEntry = {
   text: string;
   fontCacheKey: string;
   letterSpacing: number;
@@ -50,7 +50,7 @@ type MeasureResponseEntry = {
  * `main → worker` message. `id` lets the proxy reject stale batches if
  * the worker is replaced mid-flight.
  */
-type MeasureWorkerRequest = {
+export type MeasureWorkerRequest = {
   type: "measure";
   id: number;
   entries: readonly MeasureRequestEntry[];
@@ -60,7 +60,7 @@ type MeasureWorkerRequest = {
  * unrecoverable error (e.g., no `OffscreenCanvas` after all); the proxy
  * disables itself for the session.
  */
-type MeasureWorkerResponse = {
+export type MeasureWorkerResponse = {
   type: "measure-result";
   id: number;
   ok: true;
@@ -71,5 +71,4 @@ type MeasureWorkerResponse = {
   ok: false;
   error: string;
 };
-//#endregion
-export { MeasureRequestEntry, MeasureResponseEntry, MeasureWorkerRequest, MeasureWorkerResponse, countCodePoints };
+//#endregion

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

@@ -1,10 +1,10 @@
-import { FieldRun, ImageRun, LineBreakRun, MathRun, MeasuredLine, Run, TabRun, TextRun } from "../types.js";
 import { FontMetrics, FontStyle } from "./measureTypes.js";
+import { FieldRun, ImageRun, LineBreakRun, MathRun, MeasuredLine, Run, TabRun, TextRun } from "../types.js";
 import { FloatingLineSegmentZone } from "./floatingZones.js";
 //#region src/layout-engine/measure/paragraphMeasureShared.d.ts
-declare const DEFAULT_FONT_SIZE = 11;
-declare const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
-declare const WIDTH_TOLERANCE = 0.5;
+export declare const DEFAULT_FONT_SIZE = 11;
+export declare const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
+export declare const WIDTH_TOLERANCE = 0.5;
 /**
  * The width a finished line reports. A line's width is a floating-point sum
  * of per-token measurements, and the same text can reach it through different
@@ -15,11 +15,11 @@ declare const WIDTH_TOLERANCE = 0.5;
  * the same text yields the same width whichever grouping summed it, and the
  * alignment offsets derived from it agree too.
  */
-declare const canonicalLineWidth: (width: number) => number;
+export declare const canonicalLineWidth: (width: number) => number;
 /**
  * Typography metrics for a line
  */
-type LineTypography = {
+export type LineTypography = {
   ascent: number;
   descent: number;
   lineHeight: number;
@@ -27,7 +27,7 @@ type LineTypography = {
 /**
  * State tracking for line accumulation
  */
-type LineState = {
+export type LineState = {
   fromRun: number;
   fromChar: number;
   toRun: number;
@@ -71,38 +71,38 @@ type LineState = {
  * same way; widening the parameter keeps tab-following measurement
  * (FieldRun page numbers, etc.) consistent with TextRun handling.
  */
-declare function runToFontStyle(run: TextRun | TabRun | FieldRun | MathRun): FontStyle;
+export declare function runToFontStyle(run: TextRun | TabRun | FieldRun | MathRun): FontStyle;
 /**
  * Check if a run is a text run
  */
-declare function isTextRun(run: Run): run is TextRun;
+export declare function isTextRun(run: Run): run is TextRun;
 /**
  * Check if a run is a tab run
  */
-declare function isTabRun(run: Run): run is TabRun;
+export declare function isTabRun(run: Run): run is TabRun;
 /**
  * Check if a run is an image run
  */
-declare function isImageRun(run: Run): run is ImageRun;
+export declare function isImageRun(run: Run): run is ImageRun;
 /**
  * Check if a run is a line break run
  */
-declare function isLineBreakRun(run: Run): run is LineBreakRun;
+export declare function isLineBreakRun(run: Run): run is LineBreakRun;
 /**
  * Check if a run is a field run
  */
-declare function isFieldRun(run: Run): run is FieldRun;
+export declare function isFieldRun(run: Run): run is FieldRun;
 /** Text a field run is measured at: its resolved value when known (so the
  *  measurer agrees with the painter), else the cached fallback. */
-declare function fieldMeasureText(run: FieldRun, fieldValues: ReadonlyMap<number, string> | undefined): string;
+export declare function fieldMeasureText(run: FieldRun, fieldValues: ReadonlyMap<number, string> | undefined): string;
 /**
  * Check if a run is a math equation run
  */
-declare function isMathRun(run: Run): run is MathRun;
+export declare function isMathRun(run: Run): run is MathRun;
 /**
  * Check if text run is empty (only whitespace or no text)
  */
-declare function isEmptyTextRun(run: TextRun): boolean;
+export declare function isEmptyTextRun(run: TextRun): boolean;
 /**
  * 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
@@ -114,7 +114,6 @@ declare function isEmptyTextRun(run: TextRun): boolean;
  * desync measurer and painter on tab advance for paragraphs with a tab
  * preceding a floating image.
  */
-declare function isBlockLayoutImageRun(run: ImageRun): boolean;
-declare function isSpaceOrTab(char: string | undefined): boolean;
-//#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, LineState, LineTypography, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export declare function isBlockLayoutImageRun(run: ImageRun): boolean;
+export declare function isSpaceOrTab(char: string | undefined): boolean;
+//#endregion

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

@@ -1,9 +1,9 @@
 import { Run } from "../types.js";
 //#region src/layout-engine/measure/paragraphTabs.d.ts
-declare function measureInlineWidthAfterTab(runs: Run[], tabIndex: number, fieldValues?: ReadonlyMap<number, string>): number;
-declare function hasFollowingTabOnLine(runs: Run[], tabIndex: number): boolean;
-declare function hasPriorTabOnLine(runs: Run[], tabIndex: number): boolean;
-declare function canClampTabToRightEdge(alignment: string, currentLineWidth: number, hasPriorTab: boolean, followingWidth: number, availableWidth: number): boolean;
+export declare function measureInlineWidthAfterTab(runs: Run[], tabIndex: number, fieldValues?: ReadonlyMap<number, string>): number;
+export declare function hasFollowingTabOnLine(runs: Run[], tabIndex: number): boolean;
+export declare function hasPriorTabOnLine(runs: Run[], tabIndex: number): boolean;
+export declare function canClampTabToRightEdge(alignment: string, currentLineWidth: number, hasPriorTab: boolean, followingWidth: number, availableWidth: number): boolean;
 /**
  * Width of the inline content preceding the first `.` in the runs that follow
  * a tab, used to anchor `decimal` tab stops. Mirrors `getTextAfterTab` +
@@ -13,6 +13,5 @@ declare function canClampTabToRightEdge(alignment: string, currentLineWidth: num
  * Returns 0 when no decimal separator appears before the next tab / line
  * break — `calculateTabWidth` treats that as "no anchor adjustment".
  */
-declare function measureDecimalPrefixWidthAfterTab(runs: Run[], tabIndex: number, fieldValues?: ReadonlyMap<number, string>): number;
-//#endregion
-export { canClampTabToRightEdge, hasFollowingTabOnLine, hasPriorTabOnLine, measureDecimalPrefixWidthAfterTab, measureInlineWidthAfterTab };
+export declare function measureDecimalPrefixWidthAfterTab(runs: Run[], tabIndex: number, fieldValues?: ReadonlyMap<number, string>): number;
+//#endregion

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

@@ -1,5 +1,6 @@
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { isFloatingImageRun } from "../types.js";
+import { automaticRunGap } from "./automaticTextSpacing.js";
 import { measureTextWidth } from "./measureProvider.js";
 import { fieldMeasureText, isBlockLayoutImageRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
 //#region src/layout-engine/measure/paragraphTabs.ts
@@ -17,8 +18,10 @@ function measureInlineWidthAfterTab(runs, tabIndex, fieldValues) {
 			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));
+		if (isTextRun(next)) {
+			width += automaticRunGap(runs[i - 1], 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;
@@ -54,25 +57,21 @@ function canClampTabToRightEdge(alignment, currentLineWidth, hasPriorTab, follow
 * break — `calculateTabWidth` treats that as "no anchor adjustment".
 */
 function measureDecimalPrefixWidthAfterTab(runs, tabIndex, fieldValues) {
-	let text = "";
-	let firstRun;
+	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)) {
-			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;
-		}
+		let text;
+		if (isTextRun(next)) text = next.text;
+		else if (isFieldRun(next)) text = fieldMeasureText(next, fieldValues);
+		else if (isMathRun(next)) text = next.plainText || "[equation]";
+		else continue;
+		const decimalIndex = text.indexOf(".");
+		width += automaticRunGap(runs[i - 1], next);
+		width += measureTextWidth(decimalIndex === -1 ? text : text.slice(0, decimalIndex), runToFontStyle(next));
+		if (decimalIndex !== -1) return width;
 	}
-	const decimalIndex = text.indexOf(".");
-	if (decimalIndex === -1 || !firstRun) return 0;
-	return measureTextWidth(text.slice(0, decimalIndex), runToFontStyle(firstRun));
+	return 0;
 }
 //#endregion
 export { canClampTabToRightEdge, hasFollowingTabOnLine, hasPriorTabOnLine, measureDecimalPrefixWidthAfterTab, measureInlineWidthAfterTab };

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

@@ -15,7 +15,7 @@
  * run's advances and its glyphs agree on which characters shrink.
  */
 /** Fraction of the run's declared size a synthesized small capital draws at. */
-declare const SMALL_CAPS_SCALE = 0.8;
+export declare const SMALL_CAPS_SCALE = 0.8;
 /**
  * Whether `char` is a cased letter in its lowercase form — the class
  * `w:smallCaps` draws as a shrunken, uppercased capital. Digits, punctuation,
@@ -25,7 +25,7 @@ declare const SMALL_CAPS_SCALE = 0.8;
  * (CJK, most punctuation) at full size too, since neither form differs from
  * the character itself there.
  */
-declare function isSmallCapsLetter(char: string): boolean;
+export declare function isSmallCapsLetter(char: string): boolean;
 /**
  * Per-code-point small-caps classification for `text`, one entry per code
  * point (iterated the same way `[...text]`/`for...of` does, so it lines up
@@ -37,9 +37,9 @@ declare function isSmallCapsLetter(char: string): boolean;
  * takes the previous code point's class, and only falls back to full size
  * when it opens the string (nothing to inherit from).
  */
-declare function smallCapsMask(text: string): boolean[];
+export declare function smallCapsMask(text: string): boolean[];
 /** A maximal run of `text` drawn at one size: `small` selects which. */
-type SmallCapsSegment = {
+export type SmallCapsSegment = {
   readonly text: string;
   readonly small: boolean;
 };
@@ -51,6 +51,5 @@ type SmallCapsSegment = {
  * `small: false` segment, so a caller can skip the extra painting work its
  * mixed-size runs need.
  */
-declare function smallCapsSegments(text: string): SmallCapsSegment[];
-//#endregion
-export { SMALL_CAPS_SCALE, SmallCapsSegment, isSmallCapsLetter, smallCapsMask, smallCapsSegments };
+export declare function smallCapsSegments(text: string): SmallCapsSegment[];
+//#endregion