@stll/folio-core 0.47.7 → 0.48.0

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;

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

@@ -7,9 +7,11 @@ import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, resolveTableCellPadding, resolveTableWidthPx, tableColumnsArePinned } from "../types.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
 import { resolveFloatingTablePageX } from "./floatingTablePosition.js";
+import { getHyphenationDictionaryMisses } from "./hyphenationDictionaries.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
+import { buildTableCellFloatingZones, getTableCellFloatingImages } from "./tableCellFloating.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
-import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
+import { buildTableCellGrid, getFirstAvailableColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";
 import { layoutTextBoxContent } from "./textBoxParagraphLayout.js";
 //#region src/layout-engine/measure/measureBlocks.ts
 /**
@@ -59,6 +61,27 @@ function emuToPixels(emu) {
 	if (emu === void 0) return 0;
 	return Math.round(emu * 96 / 914400);
 }
+/**
+* Re-measure a cell's paragraphs against the wrap exclusions of the pictures
+* anchored in it, so lines a picture displaces (beside it, or below it when it
+* leaves no room) count toward the cell height. Mirrors the painter's
+* per-paragraph re-measure so both agree on where each line sits.
+*/
+function wrapTableCellParagraphsAroundFloats(cell, cellMeasure, contentWidth, fieldValues) {
+	const zones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
+	if (zones.length === 0) return;
+	const flowState = createTableCellFlowState();
+	for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
+		const block = cell.blocks[blockIdx];
+		let blockMeasure = cellMeasure.blocks[blockIdx];
+		if (!block || !blockMeasure) continue;
+		if (block.kind === "paragraph") {
+			blockMeasure = measureBlock(block, contentWidth, zones, placeTableCellBlock({ ...flowState }, block, blockMeasure).contentTop, fieldValues);
+			cellMeasure.blocks[blockIdx] = blockMeasure;
+		}
+		placeTableCellBlock(flowState, block, blockMeasure);
+	}
+}
 function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	let columnWidths = tableBlock.columnWidths ?? [];
 	const explicitWidthPx = resolveTableWidthPx(tableBlock.width, tableBlock.widthType, contentWidth);
@@ -74,6 +97,9 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 		}
 	}
 	const cellGrid = buildTableCellGrid(tableBlock.rows, columnWidths.length);
+	const cellSpacing = tableBlock.cellSpacing;
+	const bordersSeparated = (cellSpacing ?? 0) > 0;
+	const rowCount = tableBlock.rows.length;
 	const columnsPinned = tableColumnsArePinned(tableBlock);
 	const rows = tableBlock.rows.map((row, rowIdx) => {
 		let columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, row.gridBefore ?? 0);
@@ -83,15 +109,19 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 				let cellWidth = 0;
 				for (let c = 0; c < colSpan && columnIndex + c < columnWidths.length; c++) cellWidth += columnWidths[columnIndex + c] ?? 0;
 				if (cellWidth === 0) cellWidth = cell.width ?? 100;
+				const spacingInsets = getTableCellSpacingInsetsX(cellSpacing, columnIndex, colSpan, columnWidths.length);
+				cellWidth = Math.max(0, cellWidth - spacingInsets.start - spacingInsets.end);
 				columnIndex = getFirstAvailableColumn(cellGrid, rowIdx, columnIndex + colSpan);
 				const { left: padLeft, right: padRight } = resolveTableCellPadding(cell);
 				const cellContentWidth = Math.max(1, cellWidth - padLeft - padRight);
-				const measureWidth = cell.noWrap === true && !columnsPinned ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
+				const keepSingleLine = cell.noWrap === true && !columnsPinned;
+				const measureWidth = keepSingleLine ? NO_WRAP_MEASURE_WIDTH : cellContentWidth;
 				const cellMeasure = {
 					blocks: cell.blocks.map((b) => measureBlock(b, measureWidth, void 0, void 0, fieldValues)),
 					width: cellWidth,
 					height: 0
 				};
+				if (!keepSingleLine) wrapTableCellParagraphsAroundFloats(cell, cellMeasure, cellContentWidth, fieldValues);
 				if (cell.colSpan !== void 0) cellMeasure.colSpan = cell.colSpan;
 				if (cell.rowSpan !== void 0) cellMeasure.rowSpan = cell.rowSpan;
 				return cellMeasure;
@@ -129,15 +159,17 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const { top: padTop, bottom: padBottom } = resolveTableCellPadding(sourceCell);
 			cell.height += padTop + padBottom;
 			if ((sourceCell?.rowSpan ?? 1) > 1) continue;
-			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx);
+			const borderHeight = getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx, bordersSeparated);
 			maxCellHeightWithBorders = Math.max(maxCellHeightWithBorders, cell.height + borderHeight);
 			maxCellInsets = Math.max(maxCellInsets, padTop + padBottom + borderHeight);
 		}
 		const explicitHeight = sourceRow?.height;
 		const heightRule = sourceRow?.heightRule;
-		if (explicitHeight && heightRule === "exact") row.height = explicitHeight;
-		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets);
-		else row.height = maxCellHeightWithBorders;
+		const spacing = getTableCellSpacingInsetsY(cellSpacing, rowIdx, 1, rowCount);
+		const spacingHeight = spacing.top + spacing.bottom;
+		if (explicitHeight && heightRule === "exact") row.height = (bordersSeparated ? Math.max(0, explicitHeight - (cellSpacing ?? 0)) : explicitHeight) + spacingHeight;
+		else if (explicitHeight) row.height = Math.max(maxCellHeightWithBorders, explicitHeight + maxCellInsets) + spacingHeight;
+		else row.height = maxCellHeightWithBorders + spacingHeight;
 	}
 	for (let rowIdx = 0; rowIdx < rows.length; rowIdx++) {
 		const sourceRow = tableBlock.rows[rowIdx];
@@ -151,7 +183,8 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const spanEnd = Math.min(rows.length, rowIdx + rowSpan);
 			let combinedHeight = 0;
 			for (let spannedRowIdx = rowIdx; spannedRowIdx < spanEnd; spannedRowIdx++) combinedHeight += rows[spannedRowIdx]?.height ?? 0;
-			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx) - combinedHeight;
+			const spanSpacing = getTableCellSpacingInsetsY(cellSpacing, rowIdx, rowSpan, rowCount);
+			const deficit = measuredCell.height + getTableCellVerticalBorderHeight(cellGrid, sourceCell, rowIdx, bordersSeparated) + spanSpacing.top + spanSpacing.bottom - combinedHeight;
 			if (deficit <= 0) continue;
 			for (let spannedRowIdx = spanEnd - 1; spannedRowIdx >= rowIdx; spannedRowIdx--) {
 				if (tableBlock.rows[spannedRowIdx]?.heightRule === "exact") continue;
@@ -529,8 +562,9 @@ function measureBlock(block, contentWidth, floatingZones, cumulativeY, fieldValu
 			if (floatingZones) measureOpts.floatingZones = floatingZones;
 			if (fieldValues) measureOpts.fieldValues = fieldValues;
 			if (options?.allowEndTabOverflow === true) measureOpts.allowEndTabOverflow = true;
+			const missesBefore = getHyphenationDictionaryMisses();
 			const result = measureParagraph(pBlock, contentWidth, measureOpts);
-			if (cacheable) setCachedParagraphMeasure(pBlock, contentWidth, result);
+			if (cacheable && getHyphenationDictionaryMisses() === missesBefore) setCachedParagraphMeasure(pBlock, contentWidth, result);
 			return result;
 		}
 		case "table": return measureTableBlock(block, contentWidth, fieldValues);

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

@@ -1,5 +1,5 @@
 import { getHorizontalScaleFactor } from "../../utils/horizontalScale.js";
-import { SCRIPT_CLASS, hasCjk, hasComplexScript, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
+import { SCRIPT_CLASS, hasComplexScript, hasEastAsiaSlotText, scriptClassOf, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";
 import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
 import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
@@ -70,7 +70,7 @@ function getWorkerFontFingerprintWidth(ctx, font, fontCacheKey, fontKerning) {
 */
 function canvasGetFontMetrics(style) {
 	const fontSize = style.fontSize ?? 11;
-	const fontFamily = style.fontFamily ?? "Calibri";
+	const fontFamily = style.fontFamily ?? "Times New Roman";
 	const bold = style.bold ?? false;
 	const italic = style.italic ?? false;
 	const fontVariant = style.fontVariant;
@@ -197,7 +197,7 @@ function glyphAdvanceStyle(style) {
 * AND text that would select it. Keeps the all-Latin path on a single font.
 */
 function needsPerScriptFonts(style, measuredText) {
-	if (style.eastAsiaFontFamily && hasCjk(measuredText)) return true;
+	if (style.eastAsiaFontFamily && hasEastAsiaSlotText(measuredText, style.eastAsiaHint)) return true;
 	return hasComplexScriptFormatting(style) && hasComplexScript(measuredText);
 }
 /** Resolve the independent font/style slot selected by a script segment. */
@@ -219,7 +219,7 @@ function measureMixedScriptWidth(measuredText, style) {
 	const letterSpacing = style.letterSpacing ?? 0;
 	const horizontalScale = getHorizontalScaleFactor(style.horizontalScale);
 	let glyphWidth = 0;
-	for (const segment of segmentByScript(measuredText)) glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script)));
+	for (const segment of segmentByScript(measuredText, style.eastAsiaHint)) glyphWidth += canvasMeasureTextWidth(segment.text, glyphAdvanceStyle(scriptStyle(style, segment.script)));
 	let width = glyphWidth;
 	if (letterSpacing) {
 		const codePoints = countCodePoints(measuredText);
@@ -302,7 +302,7 @@ function canvasMeasureRun(text, sourceStyle) {
 		const cp = char.codePointAt(0);
 		const measured = applyTextTransform(char, style);
 		if (eastAsiaFont !== void 0 || complexScriptFont !== void 0) {
-			const script = scriptClassOf(cp);
+			const script = scriptClassOf(cp, style.eastAsiaHint);
 			ctx.font = (script === SCRIPT_CLASS.eastAsia ? eastAsiaFont : void 0) ?? (script === SCRIPT_CLASS.complex ? complexScriptFont : void 0) ?? baseFont;
 		}
 		let charWidth = ctx.measureText(measured).width;