@stll/folio-core 0.47.7 → 0.49.0

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

@@ -1,6 +1,8 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
-import { SCRIPT_CLASS, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
+import "./measureHelpers.js";
+import { SMALL_CAPS_SCALE, smallCapsMask, smallCapsSegments } from "./smallCapsCasing.js";
 //#region src/layout-engine/measure/advanceComposition.ts
 /**
 * The arithmetic that turns raw glyph advances into measured widths.
@@ -48,9 +50,38 @@ const glyphAdvanceStyle = (style) => {
 	if (style.kerning !== void 0) result.kerning = style.kerning;
 	return result;
 };
-const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && [...text].some((c) => isEastAsia(c)) || hasComplexScriptFormatting(style) && hasComplexScript(text);
-const isEastAsia = (char) => {
-	return scriptClassOf(char.codePointAt(0)) === SCRIPT_CLASS.eastAsia;
+const needsPerScriptFonts = (style, text) => style.eastAsiaFontFamily !== void 0 && hasEastAsiaSlotText(text, 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
+* the style's size, everything else at full size. A small segment is measured
+* at that literal, smaller size — not the full-size advance scaled by
+* arithmetic — mirroring {@link canvasMeasureTextWidth}'s
+* `measureSmallCapsWidth` so the two backends agree; each segment still
+* resolves its own per-script font, the same as the plain (non-small-caps)
+* path below.
+*/
+const smallCapsGlyphWidth = (text, style, advanceOf) => {
+	const segmentStyle = { ...style };
+	delete segmentStyle.fontVariant;
+	delete segmentStyle.letterSpacing;
+	delete segmentStyle.horizontalScale;
+	const smallSegmentStyle = {
+		...segmentStyle,
+		fontSize: (segmentStyle.fontSize ?? 11) * SMALL_CAPS_SCALE
+	};
+	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);
+	}
+	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);
+	return advanceOf(transformed, style);
 };
 /**
 * Width of a string: the advance width used for line breaking, never the
@@ -62,7 +93,13 @@ const composeTextWidth = ({ text, style: source, advanceOf }) => {
 	const transformed = applyMeasurementTextTransform(text, style);
 	const letterSpacing = style.letterSpacing ?? 0;
 	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
-	const glyphWidth = !source.forceComplexScript && !letterSpacing && needsPerScriptFonts(style, transformed) ? segmentByScript(transformed).reduce((sum, segment) => sum + advanceOf(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script))), 0) : advanceOf(transformed, style);
+	const glyphWidth = glyphWidthOf({
+		source,
+		style,
+		transformed,
+		letterSpacing,
+		advanceOf
+	});
 	const codePoints = countCodePoints(transformed);
 	return (letterSpacing && codePoints > 1 ? glyphWidth + letterSpacing * (codePoints - 1) : glyphWidth) * horizontalScale;
 };
@@ -95,10 +132,16 @@ const composeRunMeasurement = ({ text, style: source, metrics, advanceOf, advanc
 		perScript
 	});
 	let codePointIndex = 0;
+	const smallCapsAt = style.fontVariant === "small-caps" ? smallCapsMask(text) : void 0;
 	for (const char of text) {
 		const cp = char.codePointAt(0);
-		const charStyle = perScript ? scriptStyle(style, scriptClassOf(cp)) : style;
-		let charWidth = shaped.get(codePointIndex) ?? advanceOf(applyMeasurementTextTransform(char, style), charStyle);
+		const isSmallCap = smallCapsAt?.[codePointIndex] ?? false;
+		const scriptedStyle = perScript ? scriptStyle(style, scriptClassOf(cp, style.eastAsiaHint)) : style;
+		const charStyle = isSmallCap ? {
+			...scriptedStyle,
+			fontSize: (scriptedStyle.fontSize ?? 11) * SMALL_CAPS_SCALE
+		} : scriptedStyle;
+		let charWidth = shaped.get(codePointIndex) ?? advanceOf(isSmallCap ? char.toLocaleUpperCase() : applyMeasurementTextTransform(char, style), charStyle);
 		if (letterSpacing && offset + char.length < text.length) charWidth += letterSpacing;
 		charWidth *= scale;
 		charWidths.push(charWidth);

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

@@ -0,0 +1,74 @@
+//#region src/layout-engine/measure/hyphenationDictionaries.d.ts
+/**
+ * On-demand hyphenation dictionaries for automatic hyphenation.
+ *
+ * Each `hyphen` pattern set is tens to hundreds of kilobytes of source whose
+ * evaluation builds a pattern trie, and most documents never enable
+ * `w:autoHyphenation`. A dictionary is therefore imported only once measurement
+ * asks to hyphenate a word in its language. Measurement is synchronous, so the
+ * first request starts the import and hyphenates nothing. A layout run wrapped
+ * in {@link collectRequestedHyphenationDictionaries} learns which dictionaries
+ * it lacked, so its own editor can re-run layout on load or report the failure
+ * (`controller/hyphenationReadiness`). Hosts that must lay out correctly on the
+ * first pass (headless layout, tests) await `preloadHyphenationDictionaries`
+ * (`./hyphenationPreload`) before measuring.
+ *
+ * This module sits on every editor's import graph, so it speaks in its own
+ * settled-state union rather than `Result`, keeping the `Result` API out of
+ * adapters' type checks; the preload boundary converts.
+ */
+type HyphenateWord = (text: string) => string;
+declare const HYPHENATION_DICTIONARY_IDS: readonly ["cs", "en-gb", "en-us", "sk"];
+type HyphenationDictionaryId = (typeof HYPHENATION_DICTIONARY_IDS)[number];
+type HyphenationDictionaryLoaders = Readonly<Record<HyphenationDictionaryId, () => Promise<HyphenateWord>>>;
+declare const HyphenationDictionaryError_base: import("better-result").TaggedErrorClass<"HyphenationDictionaryError">;
+declare class HyphenationDictionaryError extends HyphenationDictionaryError_base<{
+  message: string;
+  dictionary: HyphenationDictionaryId;
+  cause: unknown;
+}> {}
+type SettledHyphenationDictionary = Readonly<{
+  status: "loaded";
+  hyphenate: HyphenateWord;
+}> | Readonly<{
+  status: "failed";
+  error: HyphenationDictionaryError;
+}>;
+type HyphenationDictionaryState = Readonly<{
+  status: "unloaded";
+}> | Readonly<{
+  status: "loading";
+  promise: Promise<SettledHyphenationDictionary>;
+}> | SettledHyphenationDictionary;
+/** Compare before and after a measurement to tell whether it lacked a dictionary. */
+declare const getHyphenationDictionaryMisses: () => number;
+/** The dictionary that hyphenates text in `locale`, if one is bundled. */
+declare const hyphenationDictionaryFor: (locale: string | undefined) => HyphenationDictionaryId | undefined;
+/** Changes whenever a dictionary finishes loading, so measurement caches cannot go stale. */
+declare const getHyphenationDictionaryGeneration: () => number;
+/** Load `dictionary` once; later calls share the load or its settled outcome. */
+declare const requestHyphenationDictionary: (dictionary: HyphenationDictionaryId) => Promise<SettledHyphenationDictionary>;
+/**
+ * The loaded hyphenator for `dictionary`, or `undefined` while it is not
+ * available. An unloaded dictionary starts loading, and a missing one is
+ * recorded against the enclosing {@link collectRequestedHyphenationDictionaries}
+ * run; the caller hyphenates nothing now.
+ */
+declare const hyphenatorOrRequest: (dictionary: HyphenationDictionaryId) => HyphenateWord | undefined;
+type CollectedHyphenationDictionaries<T> = {
+  result: T;
+  /** Dictionaries the run needed and did not have: loading or failed. */
+  missing: ReadonlySet<HyphenationDictionaryId>;
+};
+/** Run a synchronous layout pass and report the dictionaries it lacked. */
+declare const collectRequestedHyphenationDictionaries: <T>(run: () => T) => CollectedHyphenationDictionaries<T>;
+/**
+ * Test seam: forget every dictionary so a test observes the unloaded path, and
+ * optionally load through `loaders` (for example, ones that fail) until the
+ * next reset.
+ */
+declare const resetHyphenationDictionaries: (loaders?: HyphenationDictionaryLoaders) => void;
+/** Test seam: which dictionaries have been requested or loaded. */
+declare const hyphenationDictionaryStatus: (dictionary: HyphenationDictionaryId) => HyphenationDictionaryState["status"];
+//#endregion
+export { CollectedHyphenationDictionaries, HyphenateWord, HyphenationDictionaryError, HyphenationDictionaryId, HyphenationDictionaryLoaders, SettledHyphenationDictionary, collectRequestedHyphenationDictionaries, getHyphenationDictionaryGeneration, getHyphenationDictionaryMisses, hyphenationDictionaryFor, hyphenationDictionaryStatus, hyphenatorOrRequest, requestHyphenationDictionary, resetHyphenationDictionaries };

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

@@ -0,0 +1,138 @@
+import { recordHyphenationDictionaryError } from "../layoutInstrumentation.js";
+import { TaggedError } from "better-result";
+//#region src/layout-engine/measure/hyphenationDictionaries.ts
+/**
+* On-demand hyphenation dictionaries for automatic hyphenation.
+*
+* Each `hyphen` pattern set is tens to hundreds of kilobytes of source whose
+* evaluation builds a pattern trie, and most documents never enable
+* `w:autoHyphenation`. A dictionary is therefore imported only once measurement
+* asks to hyphenate a word in its language. Measurement is synchronous, so the
+* first request starts the import and hyphenates nothing. A layout run wrapped
+* in {@link collectRequestedHyphenationDictionaries} learns which dictionaries
+* it lacked, so its own editor can re-run layout on load or report the failure
+* (`controller/hyphenationReadiness`). Hosts that must lay out correctly on the
+* first pass (headless layout, tests) await `preloadHyphenationDictionaries`
+* (`./hyphenationPreload`) before measuring.
+*
+* This module sits on every editor's import graph, so it speaks in its own
+* settled-state union rather than `Result`, keeping the `Result` API out of
+* adapters' type checks; the preload boundary converts.
+*/
+const HYPHENATION_DICTIONARY_IDS = [
+	"cs",
+	"en-gb",
+	"en-us",
+	"sk"
+];
+const HYPHENATION_DICTIONARY_LOADERS = {
+	cs: async () => (await import("hyphen/cs/index.js")).default.hyphenateSync,
+	"en-gb": async () => (await import("hyphen/en-gb/index.js")).default.hyphenateSync,
+	"en-us": async () => (await import("hyphen/en-us/index.js")).default.hyphenateSync,
+	sk: async () => (await import("hyphen/sk/index.js")).default.hyphenateSync
+};
+let dictionaryLoaders = HYPHENATION_DICTIONARY_LOADERS;
+var HyphenationDictionaryError = class extends TaggedError("HyphenationDictionaryError") {};
+const createInitialStates = () => ({
+	cs: { status: "unloaded" },
+	"en-gb": { status: "unloaded" },
+	"en-us": { status: "unloaded" },
+	sk: { status: "unloaded" }
+});
+let dictionaryStates = createInitialStates();
+let dictionaryGeneration = 0;
+let activeRequests;
+let dictionaryMisses = 0;
+/** Compare before and after a measurement to tell whether it lacked a dictionary. */
+const getHyphenationDictionaryMisses = () => dictionaryMisses;
+/** The dictionary that hyphenates text in `locale`, if one is bundled. */
+const hyphenationDictionaryFor = (locale) => {
+	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase();
+	if (!normalized) return;
+	return HYPHENATION_DICTIONARY_IDS.find((id) => normalized === id || normalized.startsWith(`${id}-`));
+};
+/** Changes whenever a dictionary finishes loading, so measurement caches cannot go stale. */
+const getHyphenationDictionaryGeneration = () => dictionaryGeneration;
+const importDictionary = (dictionary) => dictionaryLoaders[dictionary]().then((hyphenate) => ({
+	status: "loaded",
+	hyphenate
+}), (cause) => ({
+	status: "failed",
+	error: new HyphenationDictionaryError({
+		message: `The ${dictionary} hyphenation dictionary could not be loaded.`,
+		dictionary,
+		cause
+	})
+}));
+const startLoad = (dictionary) => {
+	const promise = importDictionary(dictionary).then((settled) => {
+		if (dictionaryStates[dictionary].status !== "loading") return settled;
+		dictionaryStates[dictionary] = settled;
+		switch (settled.status) {
+			case "failed":
+				recordHyphenationDictionaryError(dictionary, settled.error);
+				return settled;
+			case "loaded":
+				dictionaryGeneration += 1;
+				return settled;
+			default: return settled;
+		}
+	});
+	dictionaryStates[dictionary] = {
+		status: "loading",
+		promise
+	};
+	return promise;
+};
+/** Load `dictionary` once; later calls share the load or its settled outcome. */
+const requestHyphenationDictionary = (dictionary) => {
+	const state = dictionaryStates[dictionary];
+	switch (state.status) {
+		case "unloaded": return startLoad(dictionary);
+		case "loading": return state.promise;
+		case "loaded":
+		case "failed": return Promise.resolve(state);
+		default: return state;
+	}
+};
+/**
+* The loaded hyphenator for `dictionary`, or `undefined` while it is not
+* available. An unloaded dictionary starts loading, and a missing one is
+* recorded against the enclosing {@link collectRequestedHyphenationDictionaries}
+* run; the caller hyphenates nothing now.
+*/
+const hyphenatorOrRequest = (dictionary) => {
+	const state = dictionaryStates[dictionary];
+	if (state.status === "loaded") return state.hyphenate;
+	dictionaryMisses += 1;
+	activeRequests?.add(dictionary);
+	if (state.status === "unloaded") startLoad(dictionary);
+};
+/** Run a synchronous layout pass and report the dictionaries it lacked. */
+const collectRequestedHyphenationDictionaries = (run) => {
+	const outer = activeRequests;
+	const missing = /* @__PURE__ */ new Set();
+	activeRequests = missing;
+	try {
+		return {
+			result: run(),
+			missing
+		};
+	} finally {
+		activeRequests = outer;
+	}
+};
+/**
+* Test seam: forget every dictionary so a test observes the unloaded path, and
+* optionally load through `loaders` (for example, ones that fail) until the
+* next reset.
+*/
+const resetHyphenationDictionaries = (loaders = HYPHENATION_DICTIONARY_LOADERS) => {
+	dictionaryLoaders = loaders;
+	dictionaryStates = createInitialStates();
+	dictionaryGeneration += 1;
+};
+/** Test seam: which dictionaries have been requested or loaded. */
+const hyphenationDictionaryStatus = (dictionary) => dictionaryStates[dictionary].status;
+//#endregion
+export { HyphenationDictionaryError, collectRequestedHyphenationDictionaries, getHyphenationDictionaryGeneration, getHyphenationDictionaryMisses, hyphenationDictionaryFor, hyphenationDictionaryStatus, hyphenatorOrRequest, requestHyphenationDictionary, resetHyphenationDictionaries };

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

@@ -0,0 +1,11 @@
+import { HyphenationDictionaryError } from "./hyphenationDictionaries.js";
+import { Result } from "better-result";
+//#region src/layout-engine/measure/hyphenationPreload.d.ts
+/**
+ * Load the dictionaries `locales` need before measuring, so a synchronous
+ * layout pass hyphenates on its first run. Locales without a dictionary are
+ * ignored.
+ */
+declare const preloadHyphenationDictionaries: (locales: Iterable<string>) => Promise<Result<void, HyphenationDictionaryError>>;
+//#endregion
+export { preloadHyphenationDictionaries };

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

@@ -0,0 +1,24 @@
+import { hyphenationDictionaryFor, requestHyphenationDictionary } from "./hyphenationDictionaries.js";
+import { Result } from "better-result";
+//#region src/layout-engine/measure/hyphenationPreload.ts
+/**
+* Awaitable dictionary loading for hosts that measure once and cannot re-run
+* layout when a dictionary arrives (headless layout, tests).
+*/
+/**
+* Load the dictionaries `locales` need before measuring, so a synchronous
+* layout pass hyphenates on its first run. Locales without a dictionary are
+* ignored.
+*/
+const preloadHyphenationDictionaries = async (locales) => {
+	const dictionaries = /* @__PURE__ */ new Set();
+	for (const locale of locales) {
+		const dictionary = hyphenationDictionaryFor(locale);
+		if (dictionary !== void 0) dictionaries.add(dictionary);
+	}
+	const settled = await Promise.all([...dictionaries].map(requestHyphenationDictionary));
+	for (const outcome of settled) if (outcome.status === "failed") return Result.err(outcome.error);
+	return Result.ok(void 0);
+};
+//#endregion
+export { preloadHyphenationDictionaries };

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

@@ -34,11 +34,21 @@ type LineBreakProvider = {
   isHangingPunctuation?: (text: string, policy?: LineBreakPolicy) => boolean;
 };
 declare const MAX_HYPHENATION_WORD_LENGTH = 256;
+declare const isNonBreakingGlue: (character: string | undefined) => boolean;
+/**
+ * Whether glue characters permit a line break between `previous` and `next`.
+ * Only the character after the break matters here: glue characters are never
+ * break opportunities themselves, so a break after one is never proposed.
+ */
+declare const gluePermitsBreakBefore: (previous: string | undefined, next: string | undefined) => boolean;
 declare const defaultLineBreakProvider: LineBreakProvider;
 declare const getLineBreakProvider: () => LineBreakProvider;
-/** Changes whenever the active provider changes, so layout caches cannot go stale. */
+/**
+ * Changes whenever the active provider or a hyphenation dictionary changes, so
+ * layout caches cannot go stale. Both counters only grow, so their sum does too.
+ */
 declare const getLineBreakProviderGeneration: () => number;
 declare const setLineBreakProvider: (provider: LineBreakProvider) => void;
 declare const resetLineBreakProvider: () => void;
 //#endregion
-export { LineBreakPolicy, LineBreakProvider, MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider };
+export { LineBreakPolicy, LineBreakProvider, MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, gluePermitsBreakBefore, isNonBreakingGlue, resetLineBreakProvider, setLineBreakProvider };

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

@@ -1,7 +1,4 @@
-import czechHyphenation from "hyphen/cs/index.js";
-import britishEnglishHyphenation from "hyphen/en-gb/index.js";
-import americanEnglishHyphenation from "hyphen/en-us/index.js";
-import slovakHyphenation from "hyphen/sk/index.js";
+import { getHyphenationDictionaryGeneration, hyphenationDictionaryFor, hyphenatorOrRequest } from "./hyphenationDictionaries.js";
 //#region src/layout-engine/measure/lineBreakProvider.ts
 /**
 * Replaceable line-break policy for the layout engine.
@@ -11,10 +8,6 @@ import slovakHyphenation from "hyphen/sk/index.js";
 * default provider uses the platform's Unicode segmenter, then applies the
 * OOXML line-edge restrictions that are available in the flow model.
 */
-const { hyphenateSync: hyphenateCzech } = czechHyphenation;
-const { hyphenateSync: hyphenateBritishEnglish } = britishEnglishHyphenation;
-const { hyphenateSync: hyphenateAmericanEnglish } = americanEnglishHyphenation;
-const { hyphenateSync: hyphenateSlovak } = slovakHyphenation;
 const SEGMENTER_CACHE_LIMIT = 16;
 const LINE_BREAK_LOCALE_CACHE_LIMIT = 16;
 const DEFAULT_SEGMENTER_KEY = "";
@@ -59,11 +52,20 @@ const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"​",
 	"­"
 ]);
-const NONBREAKING_SPACES = /* @__PURE__ */ new Set([
-	"\xA0",
-	" ",
-	" "
-]);
+const isGlueCodeUnit = (code) => code >= 160 && (code === 160 || code === 8199 || code === 8209 || code === 8239 || code === 8288 || code === 65279);
+const isWordJoinerCodeUnit = (code) => code === 8288 || code === 65279;
+const isBreakingWhitespace = (character) => /\s/u.test(character) && !isGlueCodeUnit(character.charCodeAt(0));
+const isNonBreakingGlue = (character) => character?.length === 1 && isGlueCodeUnit(character.charCodeAt(0));
+/**
+* Whether glue characters permit a line break between `previous` and `next`.
+* Only the character after the break matters here: glue characters are never
+* break opportunities themselves, so a break after one is never proposed.
+*/
+const gluePermitsBreakBefore = (previous, next) => {
+	if (!isNonBreakingGlue(next)) return true;
+	if (isWordJoinerCodeUnit(next?.charCodeAt(0) ?? 0) || previous === void 0) return false;
+	return isBreakingWhitespace(previous) || BREAK_AFTER_CHARACTER.has(previous);
+};
 const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
 	"!",
 	"%",
@@ -175,6 +177,7 @@ const allowsBreak = (text, index, policy, usesEastAsianRules, nextLineStart) =>
 };
 const pushBreak = (breaks, text, index, policy, usesEastAsianRules, nextLineStart) => {
 	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
+	if (isGlueCodeUnit(text.charCodeAt(index)) && !gluePermitsBreakBefore(previousCodePoint(text, index), text[index])) return;
 	if (allowsBreak(text, index, policy, usesEastAsianRules, nextLineStart)) breaks.push(index);
 };
 const findSimpleGraphemeBreaks = (text) => {
@@ -220,11 +223,11 @@ const findSimpleBreaks = (text, policy) => {
 		if (codePoint >= 55296 && codePoint <= 57343) return;
 		if (codePoint === 13 && text.charCodeAt(index + 1) === 10) continue;
 		const character = text[index];
-		if (isSimpleWhitespace(character, codePoint) && !NONBREAKING_SPACES.has(character)) {
+		if (isSimpleWhitespace(character, codePoint) && !isGlueCodeUnit(codePoint)) {
 			if (index >= whitespaceRunEnd) {
 				whitespaceRunEnd = index + 1;
 				let next = firstCodePoint(text, whitespaceRunEnd);
-				while (next !== void 0 && /\s/u.test(next) && !NONBREAKING_SPACES.has(next)) {
+				while (next !== void 0 && isBreakingWhitespace(next)) {
 					whitespaceRunEnd += next.length;
 					next = firstCodePoint(text, whitespaceRunEnd);
 				}
@@ -246,11 +249,11 @@ const findUnicodeBreaks = (text, policy) => {
 	let nextVisibleAfterWhitespace;
 	for (const index of graphemeBreaks) {
 		const previous = previousCodePoint(text, index);
-		if (previous !== void 0 && /\s/u.test(previous) && !NONBREAKING_SPACES.has(previous)) {
+		if (previous !== void 0 && isBreakingWhitespace(previous)) {
 			if (index > whitespaceRunEnd) {
 				whitespaceRunEnd = index;
 				let next = firstCodePoint(text, whitespaceRunEnd);
-				while (next !== void 0 && /\s/u.test(next) && !NONBREAKING_SPACES.has(next)) {
+				while (next !== void 0 && isBreakingWhitespace(next)) {
 					whitespaceRunEnd += next.length;
 					next = firstCodePoint(text, whitespaceRunEnd);
 				}
@@ -271,14 +274,6 @@ const findUnicodeBreaks = (text, policy) => {
 	}
 	return [...new Set(breaks)].sort((left, right) => left - right);
 };
-const hyphenatorFor = (locale) => {
-	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase();
-	if (!normalized) return;
-	if (normalized === "en-gb" || normalized.startsWith("en-gb-")) return hyphenateBritishEnglish;
-	if (normalized === "en-us" || normalized.startsWith("en-us-")) return hyphenateAmericanEnglish;
-	if (normalized === "cs" || normalized.startsWith("cs-")) return hyphenateCzech;
-	if (normalized === "sk" || normalized.startsWith("sk-")) return hyphenateSlovak;
-};
 const isAllCapsWord = (text, locale) => {
 	const letters = [...text].filter((character) => /\p{Letter}/u.test(character)).join("");
 	if (letters.length === 0) return false;
@@ -287,9 +282,11 @@ const isAllCapsWord = (text, locale) => {
 };
 const findPatternHyphenationBreaks = (text, policy) => {
 	if (text.length > 256 || text.includes(SOFT_HYPHEN)) return [];
-	const hyphenate = hyphenatorFor(policy?.locale);
-	if (!hyphenate) return [];
+	const dictionary = hyphenationDictionaryFor(policy?.locale);
+	if (!dictionary) return [];
 	if (policy?.doNotHyphenateCaps && (policy.renderedAllCaps === true || isAllCapsWord(text, policy.locale))) return [];
+	const hyphenate = hyphenatorOrRequest(dictionary);
+	if (!hyphenate) return [];
 	const hyphenated = hyphenate(text);
 	const breaks = [];
 	let sourceOffset = 0;
@@ -317,8 +314,11 @@ const defaultLineBreakProvider = {
 let activeLineBreakProvider = defaultLineBreakProvider;
 let lineBreakProviderGeneration = 0;
 const getLineBreakProvider = () => activeLineBreakProvider;
-/** Changes whenever the active provider changes, so layout caches cannot go stale. */
-const getLineBreakProviderGeneration = () => lineBreakProviderGeneration;
+/**
+* Changes whenever the active provider or a hyphenation dictionary changes, so
+* layout caches cannot go stale. Both counters only grow, so their sum does too.
+*/
+const getLineBreakProviderGeneration = () => lineBreakProviderGeneration + getHyphenationDictionaryGeneration();
 const setLineBreakProvider = (provider) => {
 	activeLineBreakProvider = provider;
 	lineBreakProviderGeneration += 1;
@@ -328,4 +328,4 @@ const resetLineBreakProvider = () => {
 	lineBreakProviderGeneration += 1;
 };
 //#endregion
-export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider };
+export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, gluePermitsBreakBefore, isNonBreakingGlue, resetLineBreakProvider, setLineBreakProvider };

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

@@ -10,5 +10,10 @@ declare const findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => nu
 declare const findHyphenationBreaks: (text: string, policy?: LineBreakPolicy) => number[];
 declare const isHangingPunctuation: (text: string, policy?: LineBreakPolicy) => boolean;
 declare function isBreakChar(char: string | undefined): boolean;
+/**
+ * Whether a line may break at a run boundary, between the last character of
+ * one run and the first character of the text that follows it.
+ */
+declare function isBreakBetween(previous: string | undefined, next: string | undefined): boolean;
 //#endregion
-export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation };

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

@@ -1,5 +1,5 @@
 import { isCjkCodePoint } from "../../utils/scriptSegments.js";
-import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
+import { defaultLineBreakProvider, getLineBreakProvider, gluePermitsBreakBefore, isNonBreakingGlue } from "./lineBreakProvider.js";
 //#region src/layout-engine/measure/lineBreaks.ts
 /**
 * Indices in `text` where a line may end. Latin text breaks after
@@ -13,11 +13,18 @@ const isHangingPunctuation = (text, policy) => {
 	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation)?.(text, policy) ?? false;
 };
 function isBreakChar(char) {
-	if (char === void 0) return false;
+	if (char === void 0 || isNonBreakingGlue(char)) return false;
 	if (/\s/u.test(char) || char === "-" || char === "­" || char === "​") return true;
 	if (char >= "\udc00" && char <= "\udfff") return true;
 	const codePoint = char.codePointAt(0);
 	return codePoint !== void 0 && isCjkCodePoint(codePoint);
 }
+/**
+* Whether a line may break at a run boundary, between the last character of
+* one run and the first character of the text that follows it.
+*/
+function isBreakBetween(previous, next) {
+	return isBreakChar(previous) && gluePermitsBreakBefore(previous, next);
+}
 //#endregion
-export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakBetween, isBreakChar, isHangingPunctuation };

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

@@ -7,10 +7,10 @@ import { ParagraphBlock } from "../types.js";
  */
 declare const DEFAULT_TAB_STOP_TWIPS = 720;
 /**
- * Marker font resolution per ECMA-376 §17.9.6:
- *  1. explicit numbering-level rPr (`attrs.listMarkerFormatting`),
- *  2. first body text run's font,
- *  3. paragraph defaults, then document defaults.
+ * Marker font resolution per ECMA-376 §17.9: the numbering level's `w:rPr`
+ * over the paragraph mark's run properties (`attrs.listMarkerFormatting`,
+ * resolved by the bridge), then paragraph and document defaults. The text runs
+ * of the paragraph do not format its number.
  */
 declare function resolveListMarkerFont(block: ParagraphBlock): {
   fontFamily: string;
@@ -19,6 +19,7 @@ declare function resolveListMarkerFont(block: ParagraphBlock): {
   bold?: boolean;
   italic?: boolean;
   rtl?: boolean;
+  color?: string;
 };
 /**
  * Compute the marker's inline-block width in pixels, or 0 if the paragraph
@@ -31,8 +32,10 @@ declare function resolveListMarkerFont(block: ParagraphBlock): {
  *    one space glyph, `tab` (default) → grow to the next tab stop. A hanging
  *    indent remains the minimum footprint so body text cannot enter the
  *    marker slot.
- *  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
- *    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
+ *  - `w:tabs` on the paragraph (its style and numbering level's stops merged
+ *    in): non-`clear`/non-`bar` stops past the marker. `bar` (§17.3.1.37) is
+ *    a vertical line and doesn't advance the cursor. A stop inside the
+ *    hanging slot, past the marker, takes precedence over the hanging indent.
  *  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,
  *    anchored at 0 (start of body content area, NOT `w:ind`).
  *

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

@@ -3,7 +3,6 @@ import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./comp
 import { ptToPx } from "./measureHelpers.js";
 import { measureTextWidth } from "./measureProvider.js";
 //#region src/layout-engine/measure/listMarkerWidth.ts
-const DEFAULT_FONT_FAMILY = "Calibri";
 const DEFAULT_FONT_SIZE = 11;
 /**
 * OOXML default `w:defaultTabStop` (§17.6.13) when settings.xml omits it.
@@ -13,23 +12,16 @@ const DEFAULT_FONT_SIZE = 11;
 const DEFAULT_TAB_STOP_TWIPS = 720;
 const TWIPS_TO_PX = 96 / 1440;
 /**
-* Marker font resolution per ECMA-376 §17.9.6:
-*  1. explicit numbering-level rPr (`attrs.listMarkerFormatting`),
-*  2. first body text run's font,
-*  3. paragraph defaults, then document defaults.
+* Marker font resolution per ECMA-376 §17.9: the numbering level's `w:rPr`
+* over the paragraph mark's run properties (`attrs.listMarkerFormatting`,
+* resolved by the bridge), then paragraph and document defaults. The text runs
+* of the paragraph do not format its number.
 */
 function resolveListMarkerFont(block) {
 	const attrs = block.attrs;
-	const firstTextRun = block.runs.find((r) => r.kind === "text");
 	const markerFormatting = attrs?.listMarkerFormatting;
-	const bold = markerFormatting?.bold ?? firstTextRun?.bold;
-	const italic = markerFormatting?.italic ?? firstTextRun?.italic;
-	let fontFamily = attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+	let fontFamily = attrs?.defaultFontFamily ?? "Times New Roman";
 	let alternateFontFamily = attrs?.defaultAlternateFontFamily;
-	if (firstTextRun?.fontFamily !== void 0) {
-		fontFamily = firstTextRun.fontFamily;
-		alternateFontFamily = firstTextRun.alternateFontFamily;
-	}
 	if (markerFormatting?.fontFamily !== void 0) {
 		fontFamily = markerFormatting.fontFamily;
 		alternateFontFamily = markerFormatting.alternateFontFamily;
@@ -37,10 +29,11 @@ function resolveListMarkerFont(block) {
 	const base = {
 		fontFamily,
 		...alternateFontFamily !== void 0 ? { alternateFontFamily } : {},
-		fontSize: markerFormatting?.fontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE,
-		...bold !== void 0 ? { bold } : {},
-		...italic !== void 0 ? { italic } : {},
-		...markerFormatting?.rtl !== void 0 ? { rtl: markerFormatting.rtl } : {}
+		fontSize: markerFormatting?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE,
+		...markerFormatting?.bold !== void 0 ? { bold: markerFormatting.bold } : {},
+		...markerFormatting?.italic !== void 0 ? { italic: markerFormatting.italic } : {},
+		...markerFormatting?.rtl !== void 0 ? { rtl: markerFormatting.rtl } : {},
+		...markerFormatting?.color !== void 0 ? { color: markerFormatting.color } : {}
 	};
 	const marker = attrs?.listMarker ?? "";
 	if (markerFormatting && hasComplexScriptFormatting(markerFormatting) && (markerFormatting.forceComplexScript || hasComplexScript(marker))) return applyComplexScriptFormatting(base, markerFormatting);
@@ -66,8 +59,10 @@ function resolveListMarkerFont(block) {
 *    one space glyph, `tab` (default) → grow to the next tab stop. A hanging
 *    indent remains the minimum footprint so body text cannot enter the
 *    marker slot.
-*  - `w:tabs` on the paragraph: non-`clear`/non-`bar` stops past the marker.
-*    `bar` (§17.3.1.37) is a vertical line and doesn't advance the cursor.
+*  - `w:tabs` on the paragraph (its style and numbering level's stops merged
+*    in): non-`clear`/non-`bar` stops past the marker. `bar` (§17.3.1.37) is
+*    a vertical line and doesn't advance the cursor. A stop inside the
+*    hanging slot, past the marker, takes precedence over the hanging indent.
 *  - default tab grid: stops at multiples of `DEFAULT_TAB_STOP_TWIPS`,
 *    anchored at 0 (start of body content area, NOT `w:ind`).
 *
@@ -90,10 +85,13 @@ function getListMarkerInlineWidth(block) {
 	const firstLine = indent?.firstLine ?? 0;
 	const markerStartPx = hanging > 0 ? indentLeft - hanging : indentLeft + firstLine;
 	const minBodyStart = markerStartPx + markerEndOffset;
-	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX);
-	if (hanging > 0) customTabs.push(indentLeft);
+	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX).sort((a, b) => a - b);
+	if (hanging > 0 && minBodyStart <= indentLeft) {
+		const firstCustomStop = customTabs.find((px) => px >= minBodyStart);
+		return (firstCustomStop !== void 0 && (firstCustomStop < indentLeft || attrs.listNumberingTabIgnoresIndent === true) ? firstCustomStop : indentLeft) - markerStartPx;
+	}
 	const searchStart = hanging > 0 ? Math.max(minBodyStart, indentLeft) : minBodyStart;
-	const firstCustomPast = customTabs.filter((px) => px >= searchStart).sort((a, b) => a - b)[0];
+	const firstCustomPast = customTabs.find((px) => px >= searchStart);
 	const defaultTabStopPx = (attrs.defaultTabStopTwips ?? 720) * TWIPS_TO_PX;
 	const firstGridPast = defaultTabStopPx > 0 ? Math.ceil(searchStart / defaultTabStopPx) * defaultTabStopPx : void 0;
 	let bodyStart;