@stll/folio-core 0.62.0 → 0.63.0

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

@@ -1,5 +1,5 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
-import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasComplexScript, hasDistinctHAnsiFont, hasEastAsiaSlotText, hasHAnsiSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 import "./measureHelpers.js";
 import { SMALL_CAPS_SCALE, smallCapsMask, smallCapsSegments } from "./smallCapsCasing.js";
@@ -31,6 +31,16 @@ const scriptStyle = (style, script) => {
 		if (style.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = style.eastAsiaAlternateFontFamily;
 		return result;
 	}
+	if (script === SCRIPT_CLASS.hAnsi) {
+		if (style.hAnsiFontFamily === void 0) return style;
+		const result = {
+			...style,
+			fontFamily: style.hAnsiFontFamily
+		};
+		delete result.alternateFontFamily;
+		if (style.hAnsiAlternateFontFamily !== void 0) result.alternateFontFamily = style.hAnsiAlternateFontFamily;
+		return result;
+	}
 	if (script === SCRIPT_CLASS.complex) return applyComplexScriptFormatting(style, style);
 	return style;
 };
@@ -50,7 +60,7 @@ const glyphAdvanceStyle = (style) => {
 	if (style.kerning !== void 0) result.kerning = style.kerning;
 	return result;
 };
-const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && hasEastAsiaSlotText(text, style.eastAsiaHint) || hasComplexScriptFormatting(style) && hasComplexScript(text);
+const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && hasEastAsiaSlotText(text, style.eastAsiaHint) || hasDistinctHAnsiFont(style) && hasHAnsiSlotText(text, { eastAsiaHint: style.eastAsiaHint }) || hasComplexScriptFormatting(style) && hasComplexScript(text);
 /**
 * Width of a `w:smallCaps` string: its lowercase letters (and the whitespace
 * that follows them — see smallCapsCasing.ts) draw at `SMALL_CAPS_SCALE` of
@@ -73,14 +83,20 @@ const smallCapsGlyphWidth = (text, style, advanceOf) => {
 	let total = 0;
 	for (const segment of smallCapsSegments(text)) {
 		const activeStyle = segment.small ? smallSegmentStyle : segmentStyle;
-		total += needsPerScriptFonts(activeStyle, segment.text) ? segmentByScript(segment.text, activeStyle.eastAsiaHint).reduce((sum, scriptSegment) => sum + advanceOf(scriptSegment.text, glyphAdvanceStyle(scriptStyle(activeStyle, scriptSegment.script))), 0) : advanceOf(segment.text, activeStyle);
+		total += needsPerScriptFonts(activeStyle, segment.text) ? segmentByScript(segment.text, {
+			eastAsiaHint: activeStyle.eastAsiaHint,
+			hasHAnsiFont: hasDistinctHAnsiFont(activeStyle)
+		}).reduce((sum, scriptSegment) => sum + advanceOf(scriptSegment.text, glyphAdvanceStyle(scriptStyle(activeStyle, scriptSegment.script))), 0) : advanceOf(segment.text, activeStyle);
 	}
 	return total;
 };
 /** The un-spaced, un-scaled glyph width `composeTextWidth` spaces and scales. */
 const glyphWidthOf = ({ source, style, transformed, letterSpacing, advanceOf }) => {
 	if (!source.forceComplexScript && style.fontVariant === "small-caps") return smallCapsGlyphWidth(transformed, style, advanceOf);
-	if (!source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed)) return segmentByScript(transformed, style.eastAsiaHint).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0);
+	if (!source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed)) return segmentByScript(transformed, {
+		eastAsiaHint: style.eastAsiaHint,
+		hasHAnsiFont: hasDistinctHAnsiFont(style)
+	}).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0);
 	return advanceOf(transformed, style);
 };
 /**
@@ -136,7 +152,10 @@ const composeRunMeasurement = ({ text, style: source, metrics, advanceOf, advanc
 	for (const char of text) {
 		const cp = char.codePointAt(0);
 		const isSmallCap = smallCapsAt?.[codePointIndex] ?? false;
-		const scriptedStyle = perScript ? scriptStyle(style, scriptClassOf(cp, style.eastAsiaHint)) : style;
+		const scriptedStyle = perScript ? scriptStyle(style, scriptClassOf(cp, {
+			eastAsiaHint: style.eastAsiaHint,
+			hasHAnsiFont: hasDistinctHAnsiFont(style)
+		})) : style;
 		const charStyle = isSmallCap ? {
 			...scriptedStyle,
 			fontSize: (scriptedStyle.fontSize ?? 11) * SMALL_CAPS_SCALE

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

@@ -0,0 +1,36 @@
+import { AutomaticTextSpacingPolicy, FontStyle } from "./measureTypes.js";
+import { Run } from "../types.js";
+//#region src/layout-engine/measure/automaticTextSpacing.d.ts
+export declare const hasAutomaticTextSpacingCandidates: (text: string) => boolean;
+type AutomaticTextGapOptions = {
+  before: {
+    character: string;
+    style: FontStyle;
+  };
+  after: {
+    character: string;
+    style: FontStyle;
+  };
+  policy: AutomaticTextSpacingPolicy;
+};
+export declare const automaticTextGap: ({ before, after, policy }: AutomaticTextGapOptions) => number;
+export declare const automaticTextSpacingGaps: (text: string, style: FontStyle) => {
+  offset: number;
+  advancePx: number;
+}[];
+export declare const automaticGapCodeUnitAdvances: (text: string, gaps: readonly {
+  offset: number;
+  advancePx: number;
+}[]) => Map<number, number>;
+type AutomaticTextBoundaryOptions = {
+  beforeText: string;
+  beforeStyle: FontStyle;
+  afterText: string;
+  afterStyle: FontStyle;
+  beforeEnd?: number;
+  afterStart?: number;
+};
+export declare const automaticTextBoundaryGap: ({ beforeText, beforeStyle, afterText, afterStyle, beforeEnd, afterStart }: AutomaticTextBoundaryOptions) => number;
+export declare const automaticRunGap: (before: Run | undefined, after: Run | undefined) => number;
+//#endregion
+export {};

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

@@ -0,0 +1,178 @@
+import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
+import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "./measureHelpers.js";
+//#region src/layout-engine/measure/automaticTextSpacing.ts
+const AVERAGE_WIDTH_UNITS_PER_EM = 2048;
+const AUTHORED_AVERAGE_WIDTHS = /* @__PURE__ */ new Map([
+	["aptos", [
+		1148,
+		1202,
+		1150,
+		1204
+	]],
+	["arial", [
+		904,
+		980,
+		904,
+		980
+	]],
+	["calibri", [
+		1067,
+		1098,
+		1067,
+		1099
+	]],
+	["calibri light", [
+		1065,
+		1065,
+		1067,
+		1067
+	]],
+	["cambria", [
+		1260,
+		1228,
+		1111,
+		1198
+	]],
+	["century", [
+		951,
+		951,
+		951,
+		951
+	]],
+	["century gothic", [
+		995,
+		994,
+		995,
+		994
+	]],
+	["courier new", [
+		1229,
+		1229,
+		1229,
+		1229
+	]],
+	["times new roman", [
+		821,
+		874,
+		823,
+		844
+	]]
+]);
+const EAST_ASIAN_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Bopomofo}\p{Script=Yi}]/u;
+const hasAutomaticTextSpacingCandidates = (text) => EAST_ASIAN_SCRIPT.test(text) && /[0-9\p{Script=Latin}]/u.test(text);
+const textScript = (character) => {
+	const codePoint = character.codePointAt(0);
+	if (codePoint === void 0 || codePoint >= 65280 && codePoint <= 65519) return "other";
+	if (/^[0-9]$/u.test(character)) return "number";
+	if (/^\p{Script=Latin}$/u.test(character)) return "latin";
+	if (EAST_ASIAN_SCRIPT.test(character)) return "eastAsian";
+	return "other";
+};
+const eligibleStyle = (style) => Number.isFinite(style.fontSize ?? 11) && (style.fontSize ?? 11) > 0 && style.forceComplexScript !== true && (style.letterSpacing ?? 0) === 0 && getHorizontalScaleFactor(style.horizontalScale) === 1 && style.fontVariant === void 0 && style.textTransform === void 0;
+const authoredReverseGapPx = (style) => {
+	const authoredFamily = style.automaticTextSpacing?.reverseFontFamily;
+	const average = AUTHORED_AVERAGE_WIDTHS.get((authoredFamily === void 0 ? style.fontFamily : authoredFamily)?.trim().toLowerCase() ?? "")?.at((style.bold ? 1 : 0) + (style.italic ? 2 : 0));
+	if (average === void 0) return 0;
+	return ptToPx(style.fontSize ?? 11) * average / AVERAGE_WIDTH_UNITS_PER_EM / 2;
+};
+const automaticTextGap = ({ before, after, policy }) => {
+	if (!eligibleStyle(before.style) || !eligibleStyle(after.style)) return 0;
+	const left = textScript(before.character);
+	const right = textScript(after.character);
+	if (left !== "eastAsian" && right !== "eastAsian") return 0;
+	switch (left === "eastAsian" ? right : left) {
+		case "latin":
+			if (!policy.latin) return 0;
+			break;
+		case "number":
+			if (!policy.numbers) return 0;
+			break;
+		case "eastAsian":
+		case "other": return 0;
+		default: return 0;
+	}
+	if (left !== "eastAsian") return authoredReverseGapPx(before.style);
+	return ptToPx(before.style.fontSize ?? 11) / 4;
+};
+const automaticTextSpacingGaps = (text, style) => {
+	const gaps = [];
+	const policy = style.automaticTextSpacing;
+	if (policy === void 0 || !policy.latin && !policy.numbers || !hasAutomaticTextSpacingCandidates(text)) return gaps;
+	let previousBase = "";
+	let offset = 0;
+	for (const character of text) {
+		if (/^\p{M}$/u.test(character)) {
+			offset += character.length;
+			continue;
+		}
+		const advancePx = automaticTextGap({
+			before: {
+				character: previousBase,
+				style
+			},
+			after: {
+				character,
+				style
+			},
+			policy
+		});
+		if (advancePx > 0) gaps.push({
+			offset,
+			advancePx
+		});
+		previousBase = character;
+		offset += character.length;
+	}
+	return gaps;
+};
+const automaticGapCodeUnitAdvances = (text, gaps) => {
+	const advances = /* @__PURE__ */ new Map();
+	for (const gap of gaps) {
+		const previousUnit = text.charCodeAt(gap.offset - 1);
+		const previousStart = previousUnit >= 56320 && previousUnit <= 57343 ? gap.offset - 2 : gap.offset - 1;
+		advances.set(previousStart, (advances.get(previousStart) ?? 0) + gap.advancePx);
+	}
+	return advances;
+};
+const precedingBase = (text, end) => {
+	let offset = end;
+	while (offset > 0) {
+		const trailing = text.charCodeAt(offset - 1);
+		const start = trailing >= 56320 && trailing <= 57343 ? offset - 2 : offset - 1;
+		const character = text.slice(Math.max(0, start), offset);
+		if (!/^\p{M}$/u.test(character)) return character;
+		offset = start;
+	}
+	return "";
+};
+const automaticTextBoundaryGap = ({ beforeText, beforeStyle, afterText, afterStyle, beforeEnd = beforeText.length, afterStart = 0 }) => {
+	const beforePolicy = beforeStyle.automaticTextSpacing;
+	const afterPolicy = afterStyle.automaticTextSpacing;
+	if (beforePolicy === void 0 || afterPolicy === void 0) return 0;
+	const character = String.fromCodePoint(afterText.codePointAt(afterStart) ?? 0);
+	return automaticTextGap({
+		before: {
+			character: precedingBase(beforeText, beforeEnd),
+			style: beforeStyle
+		},
+		after: {
+			character,
+			style: afterStyle
+		},
+		policy: {
+			latin: beforePolicy.latin && afterPolicy.latin,
+			numbers: beforePolicy.numbers && afterPolicy.numbers
+		}
+	});
+};
+const automaticRunGap = (before, after) => {
+	if (before?.kind !== "text" || after?.kind !== "text") return 0;
+	return automaticTextBoundaryGap({
+		beforeText: before.text,
+		beforeStyle: buildRunFontStyle(before, DEFAULT_FONT_FAMILY, 11),
+		afterText: after.text,
+		afterStyle: buildRunFontStyle(after, DEFAULT_FONT_FAMILY, 11)
+	});
+};
+//#endregion
+export { automaticGapCodeUnitAdvances, automaticRunGap, automaticTextBoundaryGap, automaticTextGap, automaticTextSpacingGaps, hasAutomaticTextSpacingCandidates };

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

@@ -3,28 +3,28 @@ import { ParagraphBlock, ParagraphMeasure } from "../types.js";
 /**
  * Get cached text width or return undefined
  */
-declare function getCachedTextWidth(text: string, font: string, letterSpacing?: number): number | undefined;
+export declare function getCachedTextWidth(text: string, font: string, letterSpacing?: number): number | undefined;
 /**
  * Store text width in cache
  */
-declare function setCachedTextWidth(text: string, font: string, letterSpacing: number, width: number): void;
+export declare function setCachedTextWidth(text: string, font: string, letterSpacing: number, width: number): void;
 /**
  * Clear the text width cache
  */
-declare function clearTextWidthCache(): void;
+export declare function clearTextWidthCache(): void;
 /**
  * Monotonic generation used by async measurement workers to drop
  * responses that were measured before a cache reset.
  */
-declare function getTextWidthCacheGeneration(): number;
+export declare function getTextWidthCacheGeneration(): number;
 /**
  * Set the maximum size of the text width cache
  */
-declare function setTextCacheSize(size: number): void;
+export declare function setTextCacheSize(size: number): void;
 /**
  * Get current text width cache size
  */
-declare function getTextCacheSize(): number;
+export declare function getTextCacheSize(): number;
 /**
  * Cached font metrics entry
  */
@@ -39,50 +39,50 @@ type FontMetricsEntry = {
 /**
  * Get cached font metrics or return undefined
  */
-declare function getCachedFontMetrics(fontFamily: string, fontSize: number, bold?: boolean, italic?: boolean, fontVariant?: string): FontMetricsEntry | undefined;
+export declare function getCachedFontMetrics(fontFamily: string, fontSize: number, bold?: boolean, italic?: boolean, fontVariant?: string): FontMetricsEntry | undefined;
 /**
  * Store font metrics in cache
  */
-declare function setCachedFontMetrics(fontFamily: string, fontSize: number, bold: boolean, italic: boolean, metrics: FontMetricsEntry, fontVariant?: string): void;
+export declare function setCachedFontMetrics(fontFamily: string, fontSize: number, bold: boolean, italic: boolean, metrics: FontMetricsEntry, fontVariant?: string): void;
 /**
  * Clear the font metrics cache
  */
-declare function clearFontMetricsCache(): void;
+export declare function clearFontMetricsCache(): void;
 /**
  * Set the maximum size of the font metrics cache
  */
-declare function setFontCacheSize(size: number): void;
+export declare function setFontCacheSize(size: number): void;
 /**
  * Get current font metrics cache size
  */
-declare function getFontCacheSize(): number;
+export declare function getFontCacheSize(): number;
 /** Serialize the complete, semantically normalized paragraph measurement contract into a cache key. */
-declare function hashParagraphBlock(block: ParagraphBlock): string;
+export declare function hashParagraphBlock(block: ParagraphBlock): string;
 /**
  * Get cached paragraph measurement or return undefined
  */
-declare function getCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number): ParagraphMeasure | undefined;
+export declare function getCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number): ParagraphMeasure | undefined;
 /**
  * Store paragraph measurement in cache
  */
-declare function setCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number, measure: ParagraphMeasure): void;
+export declare function setCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number, measure: ParagraphMeasure): void;
 /**
  * Clear the paragraph measure cache
  */
-declare function clearParagraphMeasureCache(): void;
+export declare function clearParagraphMeasureCache(): void;
 /**
  * Set the maximum size of the paragraph measure cache
  */
-declare function setParagraphCacheSize(size: number): void;
+export declare function setParagraphCacheSize(size: number): void;
 /**
  * Get current paragraph measure cache size
  */
-declare function getParagraphCacheSize(): number;
+export declare function getParagraphCacheSize(): number;
 /**
  * Clear all measurement caches
  * Call when fonts change, page width changes, or for testing
  */
-declare function clearAllCaches(): void;
+export declare function clearAllCaches(): void;
 /**
  * Bind the caches to the font set the next measurements are taken in. When a
  * face has loaded (or been added or removed) since the cached entries were
@@ -91,7 +91,7 @@ declare function clearAllCaches(): void;
  * caches were first bound are dropped too: nothing records their font set.
  * Returns whether it cleared.
  */
-declare function syncMeasureCachesToFontSet(fontSet: string): boolean;
+export declare function syncMeasureCachesToFontSet(fontSet: string): boolean;
 /**
  * Rename the font set the cached entries were measured in, without dropping
  * them: for a layout run that has just measured, whose signature now also
@@ -99,10 +99,10 @@ declare function syncMeasureCachesToFontSet(fontSet: string): boolean;
  * the caches with {@link syncMeasureCachesToFontSet}, since no face can load
  * during a synchronous run.
  */
-declare function labelMeasureCachesFontSet(fontSet: string): void;
+export declare function labelMeasureCachesFontSet(fontSet: string): void;
 /**
  * Get total size of all caches
  */
-declare function getTotalCacheSize(): number;
+export declare function getTotalCacheSize(): number;
 //#endregion
-export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, labelMeasureCachesFontSet, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize, syncMeasureCachesToFontSet };
+export {};

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

@@ -1,6 +1,8 @@
+import { documentFontFactsCacheIdentity } from "../../fonts/documentFontFacts.js";
 import { embeddedFontFingerprint } from "../../fonts/embeddedFontFingerprint.js";
 import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
 import { clearFontResolvedCache } from "./measureHelpers.js";
+import { panic } from "better-result";
 //#region src/layout-engine/measure/cache.ts
 /**
 * Measurement Cache
@@ -162,14 +164,21 @@ function getFontCacheSize() {
 	return fontMetricsCache.size;
 }
 /**
+* Default max entries for paragraph measure cache
+* Large documents can have 500+ unique paragraphs.
+*/
+const DEFAULT_PARAGRAPH_CACHE_SIZE = 5e3;
+const MAX_PARAGRAPH_CACHE_BYTES = 16777216;
+/**
 * Current max size for paragraph measure cache
 */
-let paragraphCacheMaxSize = 5e3;
+let paragraphCacheMaxSize = DEFAULT_PARAGRAPH_CACHE_SIZE;
 /**
 * LRU cache for paragraph measurements
 * Key format: block content hash
 */
 const paragraphMeasureCache = /* @__PURE__ */ new Map();
+let paragraphCacheBytes = 0;
 /** Keep image payloads bounded while classifying every field as measured or intentionally ignored. */
 const imageMeasureCacheInput = (run) => ({
 	kind: run.kind,
@@ -183,17 +192,18 @@ const imageMeasureCacheInput = (run) => ({
 	exactLineHeight: run.exactLineHeight,
 	positioned: run.position !== void 0
 });
-const runMeasureCacheInput = (run, fontContextRef) => {
+const runMeasureCacheInput = (run, fontContextRef, documentFontContextRef) => {
 	switch (run.kind) {
 		case "text":
 		case "tab":
 		case "renderedPageBreak":
 		case "field":
 		case "math": {
-			const { embeddedFontFamilyMap, ...formatting } = run;
+			const { embeddedFontFamilyMap, documentFontFacts, ...formatting } = run;
 			return {
 				...formatting,
-				embeddedFontFamilies: fontContextRef(embeddedFontFamilyMap)
+				embeddedFontFamilies: fontContextRef(embeddedFontFamilyMap),
+				documentFontFacts: documentFontContextRef(documentFontFacts)
 			};
 		}
 		case "lineBreak": return run;
@@ -201,12 +211,13 @@ const runMeasureCacheInput = (run, fontContextRef) => {
 		default: return run;
 	}
 };
-const paragraphAttrsMeasureCacheInput = (attrs, fontContextRef) => {
+const paragraphAttrsMeasureCacheInput = (attrs, fontContextRef, documentFontContextRef) => {
 	if (attrs === void 0) return void 0;
-	const { snapToGrid, embeddedFontFamilyMap, ...rest } = attrs;
+	const { snapToGrid, embeddedFontFamilyMap, documentFontFacts, ...rest } = attrs;
 	const measurementAttrs = {
 		...rest,
-		embeddedFontFamilies: fontContextRef(embeddedFontFamilyMap)
+		embeddedFontFamilies: fontContextRef(embeddedFontFamilyMap),
+		documentFontFacts: documentFontContextRef(documentFontFacts)
 	};
 	if (measurementAttrs.documentGridLinePitch === void 0) return measurementAttrs;
 	return {
@@ -218,6 +229,8 @@ const paragraphAttrsMeasureCacheInput = (attrs, fontContextRef) => {
 function hashParagraphBlock(block) {
 	const fontContexts = [];
 	const contextRefs = /* @__PURE__ */ new Map();
+	const documentFontContexts = [];
+	const documentContextRefs = /* @__PURE__ */ new Map();
 	const fontContextRef = (families) => {
 		if (!families) return void 0;
 		const fingerprint = embeddedFontFingerprint(families);
@@ -228,23 +241,36 @@ function hashParagraphBlock(block) {
 		fontContexts.push(fingerprint);
 		return index;
 	};
-	const attrs = paragraphAttrsMeasureCacheInput(block.attrs, fontContextRef);
-	const runs = block.runs.map((run) => runMeasureCacheInput(run, fontContextRef));
+	const documentFontContextRef = (facts) => {
+		const identity = documentFontFactsCacheIdentity(facts);
+		if (identity === void 0) return void 0;
+		const existing = documentContextRefs.get(identity);
+		if (existing !== void 0) return existing;
+		const index = documentFontContexts.length;
+		documentContextRefs.set(identity, index);
+		documentFontContexts.push(identity);
+		return index;
+	};
+	const attrs = paragraphAttrsMeasureCacheInput(block.attrs, fontContextRef, documentFontContextRef);
+	const runs = block.runs.map((run) => runMeasureCacheInput(run, fontContextRef, documentFontContextRef));
 	return JSON.stringify({
 		lineBreakProviderGeneration: getLineBreakProviderGeneration(),
 		attrs,
 		runs,
-		fontContexts
+		fontContexts,
+		documentFontContexts
 	});
 }
 /**
 * Evict oldest entries if paragraph cache exceeds max size
 */
 function evictParagraphEntries() {
-	while (paragraphMeasureCache.size > paragraphCacheMaxSize) {
-		const oldestKey = paragraphMeasureCache.keys().next().value;
-		if (oldestKey === void 0) break;
+	while (paragraphMeasureCache.size > paragraphCacheMaxSize || paragraphCacheBytes > MAX_PARAGRAPH_CACHE_BYTES) {
+		const oldest = paragraphMeasureCache.entries().next().value;
+		if (oldest === void 0) panic("Paragraph cache byte accounting must match retained entries.");
+		const [oldestKey, entry] = oldest;
 		paragraphMeasureCache.delete(oldestKey);
+		paragraphCacheBytes -= entry.bytes;
 	}
 }
 /**
@@ -264,10 +290,19 @@ function getCachedParagraphMeasure(block, maxWidth) {
 */
 function setCachedParagraphMeasure(block, maxWidth, measure) {
 	const key = hashParagraphBlock(block);
+	const bytes = (key.length + JSON.stringify(measure).length) * 2;
+	const previous = paragraphMeasureCache.get(key);
+	if (previous !== void 0) {
+		paragraphMeasureCache.delete(key);
+		paragraphCacheBytes -= previous.bytes;
+	}
+	if (bytes > MAX_PARAGRAPH_CACHE_BYTES) return;
 	paragraphMeasureCache.set(key, {
 		measure,
-		maxWidth
+		maxWidth,
+		bytes
 	});
+	paragraphCacheBytes += bytes;
 	evictParagraphEntries();
 }
 /**
@@ -275,6 +310,7 @@ function setCachedParagraphMeasure(block, maxWidth, measure) {
 */
 function clearParagraphMeasureCache() {
 	paragraphMeasureCache.clear();
+	paragraphCacheBytes = 0;
 }
 /**
 * Set the maximum size of the paragraph measure cache

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

@@ -12,9 +12,8 @@
  * their sum is >= contentWidth. Otherwise the original (non-negative) values
  * pass through unchanged.
  */
-declare function clampFloatingWrapMargins(leftMargin: number, rightMargin: number, contentWidth: number): {
+export declare function clampFloatingWrapMargins(leftMargin: number, rightMargin: number, contentWidth: number): {
   leftMargin: number;
   rightMargin: number;
 };
-//#endregion
-export { clampFloatingWrapMargins };
+//#endregion

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

@@ -6,7 +6,7 @@ type ComplexScriptFormattingSource = {
   complexScriptBold?: boolean;
   complexScriptItalic?: boolean;
 };
-type ResolvedComplexScriptFormatting = {
+export type ResolvedComplexScriptFormatting = {
   fontFamily?: string;
   alternateFontFamily?: string;
   fontSize?: number;
@@ -14,10 +14,10 @@ type ResolvedComplexScriptFormatting = {
   italic?: boolean;
 };
 /** Resolve Word's independent complex-script slot into ordinary paint fields. */
-declare const resolveComplexScriptFormatting: (source: ComplexScriptFormattingSource) => ResolvedComplexScriptFormatting;
-declare const applyComplexScriptFormatting: <T extends {
+export declare const resolveComplexScriptFormatting: (source: ComplexScriptFormattingSource) => ResolvedComplexScriptFormatting;
+export declare const applyComplexScriptFormatting: <T extends {
   alternateFontFamily?: string;
 }>(base: T, source: ComplexScriptFormattingSource) => T & ResolvedComplexScriptFormatting;
-declare const hasComplexScriptFormatting: (source: ComplexScriptFormattingSource) => boolean;
+export declare const hasComplexScriptFormatting: (source: ComplexScriptFormattingSource) => boolean;
 //#endregion
-export { ResolvedComplexScriptFormatting, applyComplexScriptFormatting, hasComplexScriptFormatting, resolveComplexScriptFormatting };
+export {};

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

@@ -1,18 +1,18 @@
-import { ParagraphBlock, TextRun } from "../types.js";
 import { FontStyle } from "./measureTypes.js";
+import { ParagraphBlock, TextRun } from "../types.js";
 //#region src/layout-engine/measure/crossRunWords.d.ts
 /**
  * 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.
  */
-declare function computeTrailingGlueWidths(block: ParagraphBlock): number[];
+export declare function computeTrailingGlueWidths(block: ParagraphBlock): number[];
 /**
  * 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.
  */
-declare function computeFollowingTextLeads(block: ParagraphBlock): (string | undefined)[];
-declare function computeProtectedCrossRunGlueWidths(block: ParagraphBlock): number[];
+export declare function computeFollowingTextLeads(block: ParagraphBlock): (string | undefined)[];
+export declare function computeProtectedCrossRunGlueWidths(block: ParagraphBlock): number[];
 type CrossRunWordSegment = {
   runIndex: number;
   startChar: number;
@@ -32,14 +32,14 @@ type CollectCrossRunWordOptions = {
   startChar: number;
 };
 /** Collect one lexical word continued through adjacent formatting runs. */
-declare function collectCrossRunWord({ block, startRunIndex, startChar }: CollectCrossRunWordOptions): CrossRunWord | undefined;
-type CrossRunPrefix = {
+export declare function collectCrossRunWord({ block, startRunIndex, startChar }: CollectCrossRunWordOptions): CrossRunWord | undefined;
+export type CrossRunPrefix = {
   width: number;
   endRunIndex: number;
   endChar: number;
   hyphenStyle: FontStyle;
   segments: CrossRunWordSegment[];
 };
-declare function measureCrossRunPrefix(word: CrossRunWord, breakOffset: number): CrossRunPrefix | undefined;
+export declare function measureCrossRunPrefix(word: CrossRunWord, breakOffset: number): CrossRunPrefix | undefined;
 //#endregion
-export { CrossRunPrefix, collectCrossRunWord, computeFollowingTextLeads, computeProtectedCrossRunGlueWidths, computeTrailingGlueWidths, measureCrossRunPrefix };
+export {};