@stll/folio-core 0.8.0 → 0.10.0

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

@@ -1,3 +1,5 @@
+import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
+import { lineBreakPolicyCacheParts } from "./effectiveLineBreakPolicy.js";
 //#region src/layout-engine/measure/cache.ts
 /**
 * Current max size for text width cache
@@ -152,10 +154,10 @@ const paragraphMeasureCache = /* @__PURE__ */ new Map();
 * Used as cache key to identify identical content
 */
 function hashParagraphBlock(block) {
-	const parts = [];
-	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.fontSize}|${run.bold}|${run.italic}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}`);
+	const parts = [`lbp:${getLineBreakProviderGeneration()}`];
+	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.fontSize}|${run.bold}|${run.italic}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}|${run.language?.val}|${run.language?.eastAsia}|${run.language?.bidi}`);
 	else if (run.kind === "tab") parts.push(`tab:${run.width}`);
-	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}`);
+	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}:${run.exactLineHeight === true ? "exact" : "text"}`);
 	else if (run.kind === "lineBreak") parts.push("br");
 	const attrs = block.attrs;
 	if (attrs) {
@@ -167,6 +169,7 @@ function hashParagraphBlock(block) {
 		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
 		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
 		if (attrs.reserveEmptyOutlineHeight) parts.push("outline-empty-reserve");
+		parts.push(...lineBreakPolicyCacheParts(attrs));
 		const borders = attrs.borders;
 		if (borders) {
 			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";

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

@@ -0,0 +1,29 @@
+import { ParagraphAttrs, TextRun } from "../types.js";
+import { LineBreakPolicy } from "./lineBreakProvider.js";
+
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.d.ts
+type EffectiveAutomaticHyphenation = Readonly<{
+  type: "disabled";
+}> | Readonly<{
+  type: "enabled";
+  consecutiveLineLimit: number;
+  hyphenationZoneTwips: number;
+}>;
+type EffectiveLineBreakPolicy = Readonly<{
+  /** Exact provider inputs; omitted OOXML values stay omitted for custom providers. */provider: Readonly<LineBreakPolicy>; /** `w:overflowPunct` defaults to enabled when omitted. */
+  hangingPunctuation: boolean; /** Effective document and paragraph automatic-hyphenation state. */
+  automaticHyphenation: EffectiveAutomaticHyphenation;
+}>;
+type ResolveEffectiveLineBreakPolicyOptions = {
+  attrs: ParagraphAttrs | undefined;
+  run: TextRun;
+};
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+declare const resolveEffectiveLineBreakPolicy: ({
+  attrs,
+  run
+}: ResolveEffectiveLineBreakPolicyOptions) => EffectiveLineBreakPolicy;
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+declare const lineBreakPolicyCacheParts: (attrs: ParagraphAttrs) => readonly string[];
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

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

@@ -0,0 +1,60 @@
+import { hasCjk } from "../../utils/scriptSegments.js";
+//#region src/layout-engine/measure/effectiveLineBreakPolicy.ts
+const DEFAULT_HYPHENATION_ZONE_TWIPS = 360;
+/** Resolve all authored line-breaking inputs used while measuring one text run. */
+const resolveEffectiveLineBreakPolicy = ({ attrs, run }) => {
+	const locale = resolveRunLocale(run);
+	const rules = attrs?.lineBreakRules;
+	const before = rules?.noLineBreaksBefore;
+	const after = rules?.noLineBreaksAfter;
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	return {
+		provider: {
+			...locale ? { locale } : {},
+			...attrs?.kinsoku !== void 0 ? { kinsoku: attrs.kinsoku } : {},
+			...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: before.characters } : {},
+			...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: after.characters } : {},
+			...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
+			...automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: automaticHyphenation.doNotHyphenateCaps } : {},
+			...run.allCaps === true ? { renderedAllCaps: true } : {}
+		},
+		hangingPunctuation: attrs?.overflowPunctuation !== false,
+		automaticHyphenation: resolveAutomaticHyphenation(attrs)
+	};
+};
+/** Cache fragments for every paragraph attribute consumed by the resolver. */
+const lineBreakPolicyCacheParts = (attrs) => {
+	const parts = [];
+	if (attrs.kinsoku !== void 0) parts.push(`kinsoku:${attrs.kinsoku}`);
+	if (attrs.overflowPunctuation !== void 0) parts.push(`overflow-punct:${attrs.overflowPunctuation}`);
+	if (attrs.suppressAutoHyphens !== void 0) parts.push(`suppress-auto-hyphens:${attrs.suppressAutoHyphens}`);
+	const automaticHyphenation = attrs.automaticHyphenation;
+	if (automaticHyphenation) parts.push(`auto-hyphens:${automaticHyphenation.doNotHyphenateCaps}|${automaticHyphenation.consecutiveLineLimit}|${automaticHyphenation.hyphenationZoneTwips}`);
+	const rules = attrs.lineBreakRules;
+	if (rules) parts.push(`line-break-rules:${rules.noLineBreaksBefore?.language}|${rules.noLineBreaksBefore?.characters}|${rules.noLineBreaksAfter?.language}|${rules.noLineBreaksAfter?.characters}|${rules.useLegacyEthiopicAmharicRules}`);
+	return parts;
+};
+const resolveAutomaticHyphenation = (attrs) => {
+	const automaticHyphenation = attrs?.automaticHyphenation;
+	if (automaticHyphenation?.enabled !== true || attrs?.suppressAutoHyphens === true) return { type: "disabled" };
+	return {
+		type: "enabled",
+		consecutiveLineLimit: automaticHyphenation.consecutiveLineLimit ?? 0,
+		hyphenationZoneTwips: automaticHyphenation.hyphenationZoneTwips ?? DEFAULT_HYPHENATION_ZONE_TWIPS
+	};
+};
+const resolveRunLocale = (run) => {
+	const language = run.language;
+	if (hasCjk(run.text)) return language?.eastAsia ?? language?.val;
+	if (run.rtl) return language?.bidi ?? language?.val;
+	return language?.val;
+};
+const languageMatches = (ruleLanguage, locale) => {
+	if (!ruleLanguage) return true;
+	if (!locale) return false;
+	const rule = ruleLanguage.toLowerCase();
+	const active = locale.toLowerCase();
+	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
+};
+//#endregion
+export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

package/dist/layout-engine/measure/font-metrics.worker.js

@@ -44,6 +44,7 @@ function isFontFingerprintMatch(context, expectedWidth) {
 function measureEntry(entry) {
 	const context = getCtx();
 	context.font = entry.font;
+	context.fontKerning = entry.fontKerning;
 	if (!isFontFingerprintMatch(context, entry.fontFingerprintWidth)) return null;
 	let width = context.measureText(entry.text).width;
 	const codePoints = countCodePoints(entry.text);

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

@@ -1,9 +1,10 @@
 import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "./measureTypes.js";
 import { MeasureProvider, getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { LineBreakPolicy, LineBreakProvider, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider } from "./lineBreakProvider.js";
 import { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { MeasureParagraphOptions, getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
 import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
 import { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
-export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, type MeasureParagraphOptions, type MeasureProvider, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };
+export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, type LineBreakPolicy, type LineBreakProvider, type MeasureParagraphOptions, type MeasureProvider, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, defaultLineBreakProvider, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getLineBreakProvider, getLineBreakProviderGeneration, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetLineBreakProvider, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setLineBreakProvider, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -1,8 +1,9 @@
 import { getFontMetrics, getMeasureProvider, measureRun, measureText, measureTextWidth, resetMeasureProvider, setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "./measureHelpers.js";
+import { defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider } from "./lineBreakProvider.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
 import { getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "./floatingZones.js";
 import { getRunCharWidths, measureParagraph, measureParagraphs } from "./measureParagraph.js";
 import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "./cache.js";
 import { isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "./featureFlags.js";
-export { buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };
+export { buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, defaultLineBreakProvider, findCharacterAtX, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getLineBreakProvider, getLineBreakProviderGeneration, getMeasureProvider, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetLineBreakProvider, resetMeasureProvider, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setLineBreakProvider, setMeasureProvider, setParagraphCacheSize, setTextCacheSize, twipsToPx };

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

@@ -0,0 +1,33 @@
+//#region src/layout-engine/measure/lineBreakProvider.d.ts
+/**
+ * Replaceable line-break policy for the layout engine.
+ *
+ * Providers return UTF-16 offsets so their output composes directly with the
+ * run and ProseMirror positions used by the rest of the layout pipeline. The
+ * default provider uses the platform's Unicode segmenter, then applies the
+ * OOXML line-edge restrictions that are available in the flow model.
+ */
+type LineBreakPolicy = {
+  /** BCP-47 language tag resolved from `w:lang` for this run. */locale?: string; /** Apply East Asian first/last-character restrictions (`w:kinsoku`). */
+  kinsoku?: boolean; /** Document replacement list: characters that may not begin a line. */
+  noLineBreaksBefore?: string; /** Document replacement list: characters that may not end a line. */
+  noLineBreaksAfter?: string; /** Use the legacy Ethiopic/Amharic compatibility behavior. */
+  useLegacyEthiopicAmharicRules?: boolean; /** Keep words made entirely of capital letters unhyphenated. */
+  doNotHyphenateCaps?: boolean; /** The run renders with the DOCX all-caps transform. */
+  renderedAllCaps?: boolean;
+};
+type LineBreakProvider = {
+  /** Legal soft-wrap offsets, in ascending UTF-16 order. */findBreaks: (text: string, policy?: LineBreakPolicy) => number[]; /** Grapheme-safe emergency-wrap offsets, in ascending UTF-16 order. */
+  findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[]; /** Dictionary-based discretionary hyphen offsets, in ascending UTF-16 order. */
+  findHyphenationBreaks?: (text: string, policy?: LineBreakPolicy) => number[]; /** Whether a trailing grapheme may overhang the line edge. */
+  isHangingPunctuation?: (text: string, policy?: LineBreakPolicy) => boolean;
+};
+declare const MAX_HYPHENATION_WORD_LENGTH = 256;
+declare const defaultLineBreakProvider: LineBreakProvider;
+declare const getLineBreakProvider: () => LineBreakProvider;
+/** Changes whenever the active provider changes, so layout caches cannot go stale. */
+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 };

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

@@ -0,0 +1,252 @@
+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";
+//#region src/layout-engine/measure/lineBreakProvider.ts
+/**
+* Replaceable line-break policy for the layout engine.
+*
+* Providers return UTF-16 offsets so their output composes directly with the
+* run and ProseMirror positions used by the rest of the layout pipeline. The
+* 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 DEFAULT_SEGMENTER_KEY = "";
+const SOFT_HYPHEN = "­";
+const MAX_HYPHENATION_WORD_LENGTH = 256;
+const wordSegmenters = /* @__PURE__ */ new Map();
+const graphemeSegmenters = /* @__PURE__ */ new Map();
+const segmenterLocale = (locale) => {
+	const language = locale?.trim().replaceAll("_", "-").split("-").at(0);
+	return language && /^[a-z]{2,3}$/iu.test(language) ? language.toLowerCase() : void 0;
+};
+const DICTIONARY_BREAK_SCRIPT = /[\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
+const CJK_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
+	"-",
+	"֊",
+	"־",
+	"᐀",
+	"᠆",
+	"‐",
+	"⸗",
+	"⹀",
+	"゠",
+	"﹣",
+	"－",
+	"​",
+	"­"
+]);
+const CZECH_ONE_LETTER_PREPOSITIONS = /* @__PURE__ */ new Set([
+	"k",
+	"o",
+	"s",
+	"u",
+	"v",
+	"z"
+]);
+const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
+	"!",
+	"%",
+	")",
+	",",
+	".",
+	":",
+	";",
+	"?",
+	"]",
+	"}",
+	"、",
+	"。",
+	"〉",
+	"》",
+	"」",
+	"』",
+	"】",
+	"〕",
+	"）",
+	"］",
+	"｝",
+	"，",
+	"．",
+	"：",
+	"；",
+	"！",
+	"？",
+	"…",
+	"’",
+	"”"
+]);
+const DEFAULT_PROHIBITED_LINE_END = /* @__PURE__ */ new Set([
+	"$",
+	"(",
+	"[",
+	"{",
+	"£",
+	"¥",
+	"〈",
+	"《",
+	"「",
+	"『",
+	"【",
+	"〔",
+	"（",
+	"［",
+	"｛",
+	"‘",
+	"“"
+]);
+const getSegmenter = (cache, granularity, locale) => {
+	const normalizedLocale = segmenterLocale(locale);
+	const key = normalizedLocale ?? DEFAULT_SEGMENTER_KEY;
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(normalizedLocale, { granularity });
+	if (cache.size >= SEGMENTER_CACHE_LIMIT) {
+		const oldestKey = cache.keys().next().value;
+		if (typeof oldestKey === "string") cache.delete(oldestKey);
+	}
+	cache.set(key, segmenter);
+	return segmenter;
+};
+const firstCodePoint = (text, index) => {
+	if (index >= text.length) return;
+	return String.fromCodePoint(text.codePointAt(index) ?? 0);
+};
+const previousCodePoint = (text, index) => {
+	if (index <= 0) return;
+	const trailing = text.charCodeAt(index - 1);
+	if (trailing >= 56320 && trailing <= 57343 && index >= 2) return text.slice(index - 2, index);
+	return text[index - 1];
+};
+const isProhibitedLineStart = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksBefore !== void 0 ? policy.noLineBreaksBefore.includes(character) : DEFAULT_PROHIBITED_LINE_START.has(character));
+const isProhibitedLineEnd = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksAfter !== void 0 ? policy.noLineBreaksAfter.includes(character) : DEFAULT_PROHIBITED_LINE_END.has(character));
+const isCjkLineBreakParticipant = (character, policy) => character !== void 0 && (CJK_SCRIPT.test(character) || DEFAULT_PROHIBITED_LINE_START.has(character) || DEFAULT_PROHIBITED_LINE_END.has(character) || policy?.noLineBreaksBefore?.includes(character) === true || policy?.noLineBreaksAfter?.includes(character) === true);
+const isLegacyEthiopicBreakCharacter = (character, policy) => {
+	if (!policy?.useLegacyEthiopicAmharicRules || character === void 0) return false;
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 4961 && codePoint <= 4968;
+};
+const czechProtectedBreaks = (text, policy) => {
+	const breaks = /* @__PURE__ */ new Set();
+	if (segmenterLocale(policy?.locale) !== "cs") return breaks;
+	let tokenStart = 0;
+	let index = 0;
+	while (index < text.length) {
+		const character = firstCodePoint(text, index);
+		if (character === void 0) break;
+		if (!/\s/u.test(character)) {
+			index += character.length;
+			continue;
+		}
+		const token = text.slice(tokenStart, index);
+		const protectsNextWord = token.length === 1 && CZECH_ONE_LETTER_PREPOSITIONS.has(token.toLocaleLowerCase("cs"));
+		while (index < text.length) {
+			const whitespace = firstCodePoint(text, index);
+			if (whitespace === void 0 || !/\s/u.test(whitespace)) break;
+			index += whitespace.length;
+			if (protectsNextWord) breaks.add(index);
+		}
+		tokenStart = index;
+	}
+	return breaks;
+};
+const allowsBreak = (text, index, policy) => {
+	const previous = previousCodePoint(text, index);
+	const next = firstCodePoint(text, index);
+	return !isProhibitedLineEnd(previous, policy) && !isProhibitedLineStart(next, policy);
+};
+const pushBreak = (breaks, text, index, policy) => {
+	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
+	if (allowsBreak(text, index, policy)) breaks.push(index);
+};
+const findUnicodeGraphemeBreaks = (text, policy) => {
+	const breaks = [];
+	for (const segment of getSegmenter(graphemeSegmenters, "grapheme", policy?.locale).segment(text)) {
+		const end = segment.index + segment.segment.length;
+		breaks.push(end);
+	}
+	return breaks;
+};
+const findUnicodeBreaks = (text, policy) => {
+	if (text.length === 0) return [];
+	const breaks = [];
+	const graphemeBreaks = findUnicodeGraphemeBreaks(text, policy);
+	for (const index of graphemeBreaks) {
+		const previous = previousCodePoint(text, index);
+		if (previous !== void 0 && (/\s/u.test(previous) || BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy);
+	}
+	const wordSegments = [...getSegmenter(wordSegmenters, "word", policy?.locale).segment(text)];
+	for (const [segmentIndex, segment] of wordSegments.entries()) {
+		const end = segment.index + segment.segment.length;
+		const nextSegment = wordSegments[segmentIndex + 1];
+		if (segment.isWordLike && nextSegment?.isWordLike === true && DICTIONARY_BREAK_SCRIPT.test(segment.segment + nextSegment.segment)) pushBreak(breaks, text, end, policy);
+	}
+	if (CJK_SCRIPT.test(text)) for (const index of graphemeBreaks) {
+		const previous = previousCodePoint(text, index);
+		if (isCjkLineBreakParticipant(previous, policy)) pushBreak(breaks, text, index, policy);
+	}
+	const protectedBreaks = czechProtectedBreaks(text, policy);
+	return [...new Set(breaks)].filter((index) => !protectedBreaks.has(index)).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;
+	const casingLocale = segmenterLocale(locale);
+	return letters === letters.toLocaleUpperCase(casingLocale) && letters !== letters.toLocaleLowerCase(casingLocale);
+};
+const findPatternHyphenationBreaks = (text, policy) => {
+	if (text.length > 256 || text.includes(SOFT_HYPHEN)) return [];
+	const hyphenate = hyphenatorFor(policy?.locale);
+	if (!hyphenate) return [];
+	if (policy?.doNotHyphenateCaps && (policy.renderedAllCaps === true || isAllCapsWord(text, policy.locale))) return [];
+	const hyphenated = hyphenate(text);
+	const breaks = [];
+	let sourceOffset = 0;
+	for (const character of hyphenated) {
+		if (character === SOFT_HYPHEN) {
+			breaks.push(sourceOffset);
+			continue;
+		}
+		sourceOffset += character.length;
+	}
+	return sourceOffset === text.length ? breaks : [];
+};
+const isDefaultHangingPunctuation = (text, policy) => {
+	const characters = [...text];
+	return characters.length > 0 && characters.every((character) => isProhibitedLineStart(character, policy));
+};
+const defaultLineBreakProvider = {
+	findBreaks: findUnicodeBreaks,
+	findGraphemeBreaks: findUnicodeGraphemeBreaks,
+	findHyphenationBreaks: findPatternHyphenationBreaks,
+	isHangingPunctuation: isDefaultHangingPunctuation
+};
+let activeLineBreakProvider = defaultLineBreakProvider;
+let lineBreakProviderGeneration = 0;
+const getLineBreakProvider = () => activeLineBreakProvider;
+/** Changes whenever the active provider changes, so layout caches cannot go stale. */
+const getLineBreakProviderGeneration = () => lineBreakProviderGeneration;
+const setLineBreakProvider = (provider) => {
+	activeLineBreakProvider = provider;
+	lineBreakProviderGeneration += 1;
+};
+const resetLineBreakProvider = () => {
+	activeLineBreakProvider = defaultLineBreakProvider;
+	lineBreakProviderGeneration += 1;
+};
+//#endregion
+export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider };

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

@@ -1,10 +1,15 @@
+import { LineBreakPolicy } from "./lineBreakProvider.js";
+
 //#region src/layout-engine/measure/lineBreaks.d.ts
 /**
  * Indices in `text` where a line may end. Latin text breaks after
  * whitespace or hyphen; CJK text can break after every ideograph so a
  * partial line is filled instead of pushing the whole run to the next line.
  */
-declare function findWordBreaks(text: string): number[];
+declare const findWordBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const findHyphenationBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const isHangingPunctuation: (text: string, policy?: LineBreakPolicy) => boolean;
 declare function isBreakChar(char: string | undefined): boolean;
 //#endregion
-export { findWordBreaks, isBreakChar };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };

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

@@ -1,3 +1,4 @@
+import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
 import { isCjkCodePoint } from "../../utils/scriptSegments.js";
 //#region src/layout-engine/measure/lineBreaks.ts
 /**
@@ -5,26 +6,18 @@ import { isCjkCodePoint } from "../../utils/scriptSegments.js";
 * whitespace or hyphen; CJK text can break after every ideograph so a
 * partial line is filled instead of pushing the whole run to the next line.
 */
-function findWordBreaks(text) {
-	const breaks = [];
-	for (let index = 0; index < text.length;) {
-		const codePoint = text.codePointAt(index);
-		if (codePoint === void 0) break;
-		const charLength = codePoint > 65535 ? 2 : 1;
-		const char = text[index];
-		if (char === " " || char === "-" || char === "	") breaks.push(index + charLength);
-		else if (isCjkCodePoint(codePoint)) breaks.push(index + charLength);
-		index += charLength;
-	}
-	return breaks;
-}
+const findWordBreaks = (text, policy) => getLineBreakProvider().findBreaks(text, policy);
+const findGraphemeBreaks = (text, policy) => getLineBreakProvider().findGraphemeBreaks(text, policy);
+const findHyphenationBreaks = (text, policy) => getLineBreakProvider().findHyphenationBreaks?.(text, policy) ?? [];
+const isHangingPunctuation = (text, policy) => {
+	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation)?.(text, policy) ?? false;
+};
 function isBreakChar(char) {
 	if (char === void 0) return false;
-	if (char === " " || char === "-" || char === "	") return true;
-	const codePoint = char.codePointAt(0);
-	if (codePoint === void 0) return false;
+	if (/\s/u.test(char) || char === "-" || char === "­" || char === "​") return true;
 	if (char >= "\udc00" && char <= "\udfff") return true;
-	return isCjkCodePoint(codePoint);
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && isCjkCodePoint(codePoint);
 }
 //#endregion
-export { findWordBreaks, isBreakChar };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };

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

@@ -16,6 +16,7 @@ declare const DEFAULT_TAB_STOP_TWIPS = 720;
 declare function resolveListMarkerFont(block: ParagraphBlock): {
   fontFamily: string;
   fontSize: number;
+  bold?: boolean;
 };
 /**
  * Compute the marker's inline-block width in pixels, or 0 if the paragraph

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

@@ -19,9 +19,13 @@ const TWIPS_TO_PX = 96 / 1440;
 function resolveListMarkerFont(block) {
 	const attrs = block.attrs;
 	const firstTextRun = block.runs.find((r) => r.kind === "text");
+	const fontFamily = attrs?.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+	const fontSize = attrs?.listMarkerFontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
+	const bold = attrs?.listMarkerBold ?? firstTextRun?.bold;
 	return {
-		fontFamily: attrs?.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY,
-		fontSize: attrs?.listMarkerFontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE
+		fontFamily,
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
 	};
 }
 /**
@@ -45,10 +49,11 @@ function resolveListMarkerFont(block) {
 function getListMarkerInlineWidth(block) {
 	const attrs = block.attrs;
 	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
-	const { fontFamily, fontSize } = resolveListMarkerFont(block);
+	const { fontFamily, fontSize, bold } = resolveListMarkerFont(block);
 	const style = {
 		fontFamily,
-		fontSize
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
 	};
 	const naturalWidth = measureTextWidth(attrs.listMarker, style);
 	const markerEndOffset = getMarkerEndOffset(naturalWidth, attrs.listMarkerAlignment);
@@ -77,10 +82,11 @@ function getListMarkerInlineWidth(block) {
 function getListMarkerVisualOffset(block) {
 	const attrs = block.attrs;
 	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
-	const { fontFamily, fontSize } = resolveListMarkerFont(block);
+	const { fontFamily, fontSize, bold } = resolveListMarkerFont(block);
 	const naturalWidth = measureTextWidth(attrs.listMarker, {
 		fontFamily,
-		fontSize
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
 	});
 	if (attrs.listMarkerAlignment === "right") return -naturalWidth;
 	if (attrs.listMarkerAlignment === "center") return -naturalWidth / 2;

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

@@ -1,7 +1,6 @@
 import { FlowBlock, Measure, TableBlock, TableMeasure, TextBoxBlock, TextBoxMeasure } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 //#region src/layout-engine/measure/measureBlocks.d.ts
-declare function measureTableCellBlockVisualHeight(block: FlowBlock, blockMeasure: Measure): number;
 declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
 type BandPageGeometry = {
   pageWidth?: number | number[];
@@ -25,4 +24,4 @@ declare function measureTextBoxBlock(tb: TextBoxBlock, fieldValues?: ReadonlyMap
 declare function measureBlocks(blocks: FlowBlock[], contentWidth: number | number[], marginTop?: number | number[], pageGeometry?: BandPageGeometry, fieldValues?: ReadonlyMap<number, string>): Measure[];
 declare function measureSingleBlockWithoutFloatingZones(block: FlowBlock, blockWidth: number, blockIndex: number): Measure;
 //#endregion
-export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTextBoxBlock };

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

@@ -1,6 +1,7 @@
-import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, isFloatingTextBoxBlock, tableColumnsArePinned } from "../types.js";
+import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, tableColumnsArePinned } from "../types.js";
 import { findClearLineY, measureParagraph } from "./measureParagraph.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
 import { layoutTextBoxParagraphs } from "./textBoxParagraphLayout.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { isParagraphFrameTextBox } from "../paragraphFrame.js";
@@ -52,39 +53,6 @@ function resolveTableWidthPx(width, widthType, contentWidth) {
 	if (widthType === "pct") return contentWidth * width / 5e3;
 	if (widthType === "dxa" || !widthType || widthType === "auto") return Math.round(width / 20 * 1.333);
 }
-function isInlineFlowImageRun(run) {
-	if (run.displayMode === "float") return false;
-	if (run.wrapType === "square" || run.wrapType === "tight" || run.wrapType === "through" || run.wrapType === "behind" || run.wrapType === "inFront") return false;
-	if (run.displayMode === "block" || run.wrapType === "topAndBottom") return false;
-	return true;
-}
-function measureTableCellBlockVisualHeight(block, blockMeasure) {
-	if (block.kind === "textBox" && isFloatingTextBoxBlock(block)) return 0;
-	if (block.kind !== "paragraph" || blockMeasure.kind !== "paragraph") {
-		if ("totalHeight" in blockMeasure) return blockMeasure.totalHeight;
-		if ("height" in blockMeasure) return blockMeasure.height;
-		return 0;
-	}
-	const paragraphBlock = block;
-	const paragraphMeasure = blockMeasure;
-	const nonEmptyRuns = paragraphBlock.runs.filter((run) => run.kind !== "text" || run.text.replace(/\u00a0/gu, " ").trim().length > 0);
-	if (paragraphMeasure.lines.length !== 1 || nonEmptyRuns.length === 0) return paragraphMeasure.totalHeight;
-	const inlineImageRuns = [];
-	for (const run of nonEmptyRuns) {
-		if (run.kind !== "image" || !isInlineFlowImageRun(run)) return paragraphMeasure.totalHeight;
-		inlineImageRuns.push(run);
-	}
-	let maxImageHeight = 0;
-	for (const run of inlineImageRuns) maxImageHeight = Math.max(maxImageHeight, run.height);
-	if (inlineImageRuns.length === 1) {
-		const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
-		const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
-		return spacingBefore + maxImageHeight + spacingAfter;
-	}
-	const spacingBefore = paragraphBlock.attrs?.spacing?.before ?? 0;
-	const spacingAfter = paragraphBlock.attrs?.spacing?.after ?? 0;
-	return spacingBefore + maxImageHeight + spacingAfter;
-}
 function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	const DEFAULT_CELL_PADDING_X = 7;
 	const DEFAULT_CELL_PADDING_Y = 0;
@@ -147,12 +115,14 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 			const cell = row.cells[cellIdx];
 			const sourceCell = sourceRowCells?.[cellIdx];
 			cell.height = 0;
+			const flowState = createTableCellFlowState();
 			for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
 				const sourceBlock = sourceCell?.blocks[blockIdx];
 				const blockMeasure = cell.blocks[blockIdx];
 				if (!sourceBlock || !blockMeasure) continue;
-				cell.height += measureTableCellBlockVisualHeight(sourceBlock, blockMeasure);
+				placeTableCellBlock(flowState, sourceBlock, blockMeasure);
 			}
+			cell.height = finishTableCellFlow(flowState);
 			const padTop = sourceCell?.padding?.top ?? DEFAULT_CELL_PADDING_Y;
 			const padBottom = sourceCell?.padding?.bottom ?? DEFAULT_CELL_PADDING_Y;
 			cell.height += padTop + padBottom;
@@ -576,4 +546,4 @@ function measureSingleBlockWithoutFloatingZones(block, blockWidth, blockIndex) {
 	return measureBlock(block, blockWidth);
 }
 //#endregion
-export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTextBoxBlock };