@stll/folio-core 0.11.0 → 0.13.0

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

@@ -1,10 +1,18 @@
+import { clearFontResolvedCache } from "./measureHelpers.js";
 import { getLineBreakProviderGeneration } from "./lineBreakProvider.js";
 import { lineBreakPolicyCacheParts } from "./effectiveLineBreakPolicy.js";
 //#region src/layout-engine/measure/cache.ts
 /**
+* Default max entries for text width cache
+* Large documents (30+ pages) can generate 20,000+ unique text measurements.
+* A generous default avoids cache thrashing on big docs.
+*/
+const DEFAULT_TEXT_CACHE_SIZE = 2e4;
+const TEXT_CACHE_REFRESH_AFTER_HITS = 16;
+/**
 * Current max size for text width cache
 */
-let textCacheMaxSize = 2e4;
+let textCacheMaxSize = DEFAULT_TEXT_CACHE_SIZE;
 /**
 * LRU cache for text width measurements
 * Key format: "text|font|letterSpacing"
@@ -34,8 +42,12 @@ function getCachedTextWidth(text, font, letterSpacing = 0) {
 	const key = makeTextKey(text, font, letterSpacing);
 	const entry = textWidthCache.get(key);
 	if (entry !== void 0) {
-		textWidthCache.delete(key);
-		textWidthCache.set(key, entry);
+		entry.hitsSinceRefresh += 1;
+		if (entry.hitsSinceRefresh >= TEXT_CACHE_REFRESH_AFTER_HITS) {
+			entry.hitsSinceRefresh = 0;
+			textWidthCache.delete(key);
+			textWidthCache.set(key, entry);
+		}
 		return entry.width;
 	}
 }
@@ -44,8 +56,11 @@ function getCachedTextWidth(text, font, letterSpacing = 0) {
 */
 function setCachedTextWidth(text, font, letterSpacing, width) {
 	const key = makeTextKey(text, font, letterSpacing);
-	textWidthCache.set(key, { width });
-	evictTextEntries();
+	textWidthCache.set(key, {
+		hitsSinceRefresh: 0,
+		width
+	});
+	if (textWidthCache.size > textCacheMaxSize) evictTextEntries();
 }
 /**
 * Clear the text width cache
@@ -169,6 +184,8 @@ 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");
+		if (attrs.documentGridLinePitch !== void 0) parts.push(`documentGrid:${attrs.documentGridLinePitch}|${attrs.snapToGrid !== false}`);
+		if (attrs.justificationCompatibility) parts.push(`justify-compat:${attrs.justificationCompatibility.type}`);
 		parts.push(...lineBreakPolicyCacheParts(attrs));
 		const borders = attrs.borders;
 		if (borders) {
@@ -239,6 +256,7 @@ function clearAllCaches() {
 	clearTextWidthCache();
 	clearFontMetricsCache();
 	clearParagraphMeasureCache();
+	clearFontResolvedCache();
 }
 /**
 * Get total size of all caches

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

@@ -12,8 +12,8 @@ const resolveEffectiveLineBreakPolicy = ({ attrs, run }) => {
 		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 } : {},
+			...before && languageMatches(before.language, locale) ? { noLineBreaksBefore: toCodePointSet(before.characters) } : {},
+			...after && languageMatches(after.language, locale) ? { noLineBreaksAfter: toCodePointSet(after.characters) } : {},
 			...rules?.useLegacyEthiopicAmharicRules ? { useLegacyEthiopicAmharicRules: true } : {},
 			...automaticHyphenation?.doNotHyphenateCaps !== void 0 ? { doNotHyphenateCaps: automaticHyphenation.doNotHyphenateCaps } : {},
 			...run.allCaps === true ? { renderedAllCaps: true } : {}
@@ -56,5 +56,11 @@ const languageMatches = (ruleLanguage, locale) => {
 	const active = locale.toLowerCase();
 	return active === rule || active.startsWith(`${rule}-`) || rule.startsWith(`${active}-`);
 };
+/**
+* Split an already length-capped kinsoku character list (settingsParser.ts)
+* into a code-point Set so line-edge membership checks are O(1) instead of
+* an O(n) `String.includes` scan per character measured.
+*/
+const toCodePointSet = (characters) => new Set(Array.from(characters));
 //#endregion
 export { lineBreakPolicyCacheParts, resolveEffectiveLineBreakPolicy };

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

@@ -10,8 +10,8 @@
 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. */
+  noLineBreaksBefore?: ReadonlySet<string>; /** Document replacement list: characters that may not end a line. */
+  noLineBreaksAfter?: ReadonlySet<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;

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

@@ -27,6 +27,13 @@ const segmenterLocale = (locale) => {
 };
 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 WORD_HANGING_PUNCTUATION_LANGUAGES = /* @__PURE__ */ new Set([
+	"ii",
+	"ja",
+	"ko",
+	"zh"
+]);
+const SIMPLE_BREAK_TEXT = /^[\p{Script=Latin}\p{Script=Cyrillic}\p{Script=Greek}\p{Number}\p{Punctuation}\p{White_Space}]*$/u;
 const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"-",
 	"֊",
@@ -42,13 +49,10 @@ const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
 	"​",
 	"­"
 ]);
-const CZECH_ONE_LETTER_PREPOSITIONS = /* @__PURE__ */ new Set([
-	"k",
-	"o",
-	"s",
-	"u",
-	"v",
-	"z"
+const NONBREAKING_SPACES = /* @__PURE__ */ new Set([
+	"\xA0",
+	" ",
+	" "
 ]);
 const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
 	"!",
@@ -124,38 +128,14 @@ const previousCodePoint = (text, index) => {
 	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 isProhibitedLineStart = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksBefore !== void 0 ? policy.noLineBreaksBefore.has(character) : DEFAULT_PROHIBITED_LINE_START.has(character));
+const isProhibitedLineEnd = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksAfter !== void 0 ? policy.noLineBreaksAfter.has(character) : DEFAULT_PROHIBITED_LINE_END.has(character));
+const isCjkLineBreakParticipant = (character, policy) => character !== void 0 && (CJK_SCRIPT.test(character) || policy?.kinsoku !== false && (DEFAULT_PROHIBITED_LINE_START.has(character) || DEFAULT_PROHIBITED_LINE_END.has(character) || policy?.noLineBreaksBefore?.has(character) === true || policy?.noLineBreaksAfter?.has(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);
@@ -165,7 +145,20 @@ 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 findSimpleGraphemeBreaks = (text) => {
+	if (!SIMPLE_BREAK_TEXT.test(text)) return;
+	const breaks = [];
+	for (let index = 0; index < text.length; index += 1) {
+		const codeUnit = text.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 57343) return;
+		if (codeUnit === 13 && text.charCodeAt(index + 1) === 10) index += 1;
+		breaks.push(index + 1);
+	}
+	return breaks;
+};
 const findUnicodeGraphemeBreaks = (text, policy) => {
+	const simpleBreaks = findSimpleGraphemeBreaks(text);
+	if (simpleBreaks !== void 0) return simpleBreaks;
 	const breaks = [];
 	for (const segment of getSegmenter(graphemeSegmenters, "grapheme", policy?.locale).segment(text)) {
 		const end = segment.index + segment.segment.length;
@@ -173,13 +166,38 @@ const findUnicodeGraphemeBreaks = (text, policy) => {
 	}
 	return breaks;
 };
+const isSimpleWhitespace = (character, codePoint) => codePoint === 32 || codePoint >= 9 && codePoint <= 13 || codePoint > 127 && /\s/u.test(character);
+/**
+* Find the complete set of Unicode line-break opportunities for simple text
+* without invoking `Intl.Segmenter`.
+*
+* Latin, Cyrillic, and Greek letters plus ordinary numbers, punctuation, and
+* spacing are single grapheme clusters, except CRLF, which Unicode treats as
+* one cluster. Returning `undefined` for combining marks, astral characters,
+* dictionary-segmented scripts, CJK, and other complex input keeps the full
+* Unicode provider responsible for those cases.
+*/
+const findSimpleBreaks = (text, policy) => {
+	if (!SIMPLE_BREAK_TEXT.test(text)) return;
+	const breaks = [];
+	for (let index = 0; index < text.length; index += 1) {
+		const codePoint = text.charCodeAt(index);
+		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) || BREAK_AFTER_CHARACTER.has(character) || isLegacyEthiopicBreakCharacter(character, policy)) pushBreak(breaks, text, index + 1, policy);
+	}
+	return breaks;
+};
 const findUnicodeBreaks = (text, policy) => {
 	if (text.length === 0) return [];
+	const simpleBreaks = findSimpleBreaks(text, policy);
+	if (simpleBreaks !== void 0) return simpleBreaks;
 	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);
+		if (previous !== void 0 && (/\s/u.test(previous) && !NONBREAKING_SPACES.has(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()) {
@@ -191,8 +209,7 @@ const findUnicodeBreaks = (text, policy) => {
 		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);
+	return [...new Set(breaks)].sort((left, right) => left - right);
 };
 const hyphenatorFor = (locale) => {
 	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase();
@@ -226,6 +243,8 @@ const findPatternHyphenationBreaks = (text, policy) => {
 	return sourceOffset === text.length ? breaks : [];
 };
 const isDefaultHangingPunctuation = (text, policy) => {
+	const language = segmenterLocale(policy?.locale);
+	if (!language || !WORD_HANGING_PUNCTUATION_LANGUAGES.has(language)) return false;
 	const characters = [...text];
 	return characters.length > 0 && characters.every((character) => isProhibitedLineStart(character, policy));
 };

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

@@ -2,7 +2,7 @@ import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWr
 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 { layoutTextBoxContent } from "./textBoxParagraphLayout.js";
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { isParagraphFrameTextBox } from "../paragraphFrame.js";
 import { recordMeasureBlock, recordMeasureBlockError } from "../layoutInstrumentation.js";
@@ -17,6 +17,14 @@ import { buildTableCellGrid, getFirstAvailableColumn, getTableCellVerticalBorder
 */
 const NO_WRAP_MEASURE_WIDTH = 1e6;
 /**
+* Sanity cap on the table column count derived from summed cell colSpans
+* when a table has no `tblGrid`/explicit column widths. Mirrors the
+* `MAX_TABLE_COLUMNS` clamp applied to `w:gridSpan` at parse time
+* (`docx/tableParser.ts`); enforced again here since a hostile colSpan sum
+* would otherwise size the fallback column array and cell grid unbounded.
+*/
+const MAX_TABLE_COLUMNS = 63;
+/**
 * Check if an image run is a *text-wrapping* floating image — it
 * occupies an exclusion zone the body text should flow around.
 *
@@ -59,7 +67,7 @@ function measureTableBlock(tableBlock, contentWidth, fieldValues) {
 	let columnWidths = tableBlock.columnWidths ?? [];
 	const explicitWidthPx = resolveTableWidthPx(tableBlock.width, tableBlock.widthType, contentWidth);
 	if (columnWidths.length === 0 && tableBlock.rows.length > 0) {
-		const colCount = tableBlock.rows[0].cells.reduce((sum, cell) => sum + (cell.colSpan ?? 1), 0);
+		const colCount = Math.min(tableBlock.rows[0].cells.reduce((sum, cell) => sum + (cell.colSpan ?? 1), 0), MAX_TABLE_COLUMNS);
 		const equalWidth = (explicitWidthPx ?? contentWidth) / Math.max(1, colCount);
 		columnWidths = Array.from({ length: colCount }, () => equalWidth);
 	} else if (columnWidths.length > 0 && explicitWidthPx) {
@@ -439,8 +447,11 @@ function measureBlock(block, contentWidth, floatingZones, cumulativeY, fieldValu
 function measureTextBoxBlock(tb, fieldValues) {
 	const margins = tb.margins ?? DEFAULT_TEXTBOX_MARGINS;
 	const innerWidth = tb.width - margins.left - margins.right;
-	const innerMeasures = tb.content.map((p) => measureParagraph(p, innerWidth, fieldValues ? { fieldValues } : void 0));
-	const contentBoxHeight = layoutTextBoxParagraphs(tb.content, innerMeasures).totalHeight + margins.top + margins.bottom;
+	const innerMeasures = tb.content.map((block) => {
+		if (block.kind === "table") return measureTableBlock(block, innerWidth, fieldValues);
+		return measureParagraph(block, innerWidth, fieldValues ? { fieldValues } : void 0);
+	});
+	const contentBoxHeight = layoutTextBoxContent(tb.content, innerMeasures).totalHeight + margins.top + margins.bottom;
 	const totalHeight = tb.autoFit === "shape" ? Math.max(tb.height ?? 0, contentBoxHeight) : tb.height ?? contentBoxHeight;
 	return {
 		kind: "textBox",

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

@@ -1,5 +1,5 @@
-import { setMeasureProvider } from "./measureProvider.js";
 import { getFontKerningMode } from "./textMeasurementPolicy.js";
+import { setMeasureProvider } from "./measureProvider.js";
 import { buildFontString, getResolvedData, ptToPx } from "./measureHelpers.js";
 import { hasCjk, isCjkCodePoint, segmentByScript } from "../../utils/scriptSegments.js";
 import { getCachedFontMetrics, getCachedTextWidth, getTextWidthCacheGeneration, setCachedFontMetrics, setCachedTextWidth } from "./cache.js";

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

@@ -22,6 +22,15 @@ type ResolvedFontCache = {
  * Get the resolved font data for a font family, with caching.
  */
 declare function getResolvedData(fontFamily: string): ResolvedFontCache;
+/**
+ * Clear the resolved-font-family cache. `resolveFontFamily`'s output for a
+ * given key can change even when the raw font names don't — e.g. when the
+ * active document's embedded-font family map changes (see
+ * `utils/fontResolver.ts`'s `setEmbeddedFontFamilyMap`) — so this must be
+ * cleared whenever that happens, not just on font-name changes. Folded into
+ * `clearAllCaches` (`./cache.ts`) so callers get it for free.
+ */
+declare function clearFontResolvedCache(): void;
 /**
  * Build a CSS font string from styling properties
  *
@@ -34,7 +43,7 @@ declare function getResolvedData(fontFamily: string): ResolvedFontCache;
  *
  * @example
  * buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
- * // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+ * // Returns: "700 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
  */
 declare function buildFontString(style: FontStyle): string;
 /**
@@ -79,4 +88,4 @@ declare function halfPtToPx(halfPt: number): number;
  */
 declare function pxToHalfPt(px: number): number;
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -1,6 +1,6 @@
 import { resolveFontFamily } from "../../utils/fontResolver.js";
-import "../../utils/fontWeights.js";
 import { FONT_KERNING_MODE, getRunFontKerningMode } from "./textMeasurementPolicy.js";
+import "../../utils/fontWeights.js";
 //#region src/layout-engine/measure/measureHelpers.ts
 /**
 * Pure measurement helpers — no canvas, no DOM, no worker.
@@ -62,6 +62,17 @@ function getResolvedFallback(fontFamily) {
 	return getResolvedData(fontFamily).cssFallback;
 }
 /**
+* Clear the resolved-font-family cache. `resolveFontFamily`'s output for a
+* given key can change even when the raw font names don't — e.g. when the
+* active document's embedded-font family map changes (see
+* `utils/fontResolver.ts`'s `setEmbeddedFontFamilyMap`) — so this must be
+* cleared whenever that happens, not just on font-name changes. Folded into
+* `clearAllCaches` (`./cache.ts`) so callers get it for free.
+*/
+function clearFontResolvedCache() {
+	fontResolvedCache.clear();
+}
+/**
 * Build a CSS font string from styling properties
 *
 * Font sizes are in points and need to be converted to pixels for canvas.
@@ -73,13 +84,13 @@ function getResolvedFallback(fontFamily) {
 *
 * @example
 * buildFontString({ fontFamily: "Arial", fontSize: 12, bold: true })
-* // Returns: "800 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
+* // Returns: "700 16px Arial, Arimo, Helvetica, sans-serif" (12pt = 16px)
 */
 function buildFontString(style) {
 	const parts = [];
 	if (style.italic) parts.push("italic");
 	if (style.fontVariant) parts.push(style.fontVariant);
-	if (style.bold) parts.push("800");
+	if (style.bold) parts.push("700");
 	const fontSizePx = ptToPx(style.fontSize ?? 11);
 	parts.push(`${fontSizePx}px`);
 	const fontFamily = style.fontFamily ?? "Calibri";
@@ -156,4 +167,4 @@ function pxToHalfPt(px) {
 	return pxToPt(px) * 2;
 }
 //#endregion
-export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };
+export { DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, buildFontString, buildRunFontStyle, clearFontResolvedCache, findCharacterAtX, getResolvedData, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx };

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

@@ -1,8 +1,8 @@
 import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
-import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { countCompressibleSpaces } from "./textMeasurementPolicy.js";
+import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
 import { buildRunFontStyle, ptToPx, twipsToPx } from "./measureHelpers.js";
-import "./lineBreakProvider.js";
+import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
 import { calculateTabWidth, pixelsToTwips } from "../../prosemirror/utils/tabCalculator.js";
 import { inlineImageBoundingBox } from "../../utils/rotationBoundingBox.js";
 import { hasCjk } from "../../utils/scriptSegments.js";
@@ -27,7 +27,9 @@ const WIDTH_TOLERANCE = .5;
 const JUSTIFY_SHRINK_TOLERANCE_RATIO = .016;
 const JUSTIFY_SPACE_CONTRACTION_RATIO = .075;
 const JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO = .195;
-const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .23;
+const JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO = .022;
+const JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO = .32;
+const JUSTIFY_LIST_CONTINUATION_MAX_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_INSET_LIST_SHRINK_TOLERANCE_RATIO = .015;
 const JUSTIFY_LITERAL_TAB_CONTINUATION_SHRINK_TOLERANCE_RATIO = .017;
 const JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO = .021;
@@ -137,7 +139,7 @@ const WORD_SINGLE_LINE_FLOOR = 1.15;
 * `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
 * and stays untouched.
 */
-function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily) {
+function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
 	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
 		fontSize,
 		fontFamily: fontFamily ?? DEFAULT_FONT_FAMILY
@@ -145,12 +147,22 @@ function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily) {
 	const lineRule = spacing?.lineRule ?? "auto";
 	if (lineRule === "auto" || lineRule === "atLeast") {
 		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
-		if (result.lineHeight < floor) return {
+		if (result.lineHeight < floor) return applyDocumentGrid({
 			...result,
 			lineHeight: floor
-		};
+		}, attrs, spacing);
 	}
-	return result;
+	return applyDocumentGrid(result, attrs, spacing);
+}
+function applyDocumentGrid(typography, attrs, spacing) {
+	const pitch = attrs?.documentGridLinePitch;
+	if (pitch === void 0 || pitch <= 0 || attrs?.snapToGrid === false) return typography;
+	if (spacing?.lineRule === "exact") return typography;
+	const lineHeight = Math.ceil(typography.lineHeight / pitch - 1e-9) * pitch;
+	return lineHeight === typography.lineHeight ? typography : {
+		...typography,
+		lineHeight
+	};
 }
 /**
 * Check if a run is a text run
@@ -344,6 +356,7 @@ function uppercaseLetterRatio(text) {
 	return letters === 0 ? 0 : uppercase / letters;
 }
 function resolveJustifyFitStrategy(block, isFirstLine, profile) {
+	if (block.attrs?.justificationCompatibility?.type === "legacy") return { type: "strict" };
 	if (isShallowFullHangingListContinuation(block, isFirstLine)) return { type: "rounding" };
 	if (block.attrs?.listMarker !== void 0) {
 		const hanging = block.attrs.indent?.hanging ?? 0;
@@ -352,7 +365,7 @@ function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 			ratio: JUSTIFY_LIST_MARKER_SPACE_CONTRACTION_RATIO
 		} : {
 			type: "width",
-			ratio: JUSTIFY_HANGING_TAB_SHRINK_TOLERANCE_RATIO
+			ratio: JUSTIFY_DEEP_HANGING_LIST_MARKER_SHRINK_TOLERANCE_RATIO
 		};
 		const left = block.attrs.indent?.left ?? 0;
 		if (hanging > 0 && left > hanging) return {
@@ -361,7 +374,8 @@ function resolveJustifyFitStrategy(block, isFirstLine, profile) {
 		};
 		return {
 			type: "space",
-			ratio: JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO
+			ratio: JUSTIFY_LIST_CONTINUATION_SPACE_CONTRACTION_RATIO,
+			maxWidthRatio: JUSTIFY_LIST_CONTINUATION_MAX_SHRINK_TOLERANCE_RATIO
 		};
 	}
 	const hasTabStops = (block.attrs?.tabs?.length ?? 0) > 0;
@@ -391,9 +405,12 @@ function compressibleSpaceWidth(text, style) {
 	return count === 0 ? 0 : count * measureTextWidth(" ", style);
 }
 function justifyFitTolerance(line, strategy, candidateSpaceWidth) {
+	if (strategy.type === "strict") return 0;
 	if (strategy.type === "rounding") return WIDTH_TOLERANCE;
 	if (strategy.type === "width") return Math.max(WIDTH_TOLERANCE, line.availableWidth * strategy.ratio);
-	return Math.max(WIDTH_TOLERANCE, (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio);
+	const spaceTolerance = (line.regularSpaceWidth + candidateSpaceWidth) * strategy.ratio;
+	const boundedTolerance = strategy.maxWidthRatio === void 0 ? spaceTolerance : Math.min(spaceTolerance, line.availableWidth * strategy.maxWidthRatio);
+	return Math.max(WIDTH_TOLERANCE, boundedTolerance);
 }
 function isShallowFullHangingListContinuation(block, isFirstLine) {
 	if (isFirstLine || block.attrs?.listMarker === void 0) return false;
@@ -410,8 +427,20 @@ function trimTrailingSpacesAndTabs(text) {
 	}
 	return text.slice(0, end);
 }
+function trailingCodePoint(text) {
+	if (text.length === 0) return;
+	const trailing = text.charCodeAt(text.length - 1);
+	const preceding = text.charCodeAt(text.length - 2);
+	const start = trailing >= 56320 && trailing <= 57343 && preceding >= 55296 && preceding <= 56319 ? text.length - 2 : text.length - 1;
+	return text.slice(start);
+}
+const usesDefaultHangingPunctuationClassifier = () => {
+	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation) === defaultLineBreakProvider.isHangingPunctuation;
+};
 function trailingHangingPunctuationWidth(text, style, policy, enabled) {
 	if (!enabled || text.length === 0) return 0;
+	const trailing = trailingCodePoint(text);
+	if (usesDefaultHangingPunctuationClassifier() && !isHangingPunctuation(trailing ?? "", policy)) return 0;
 	const lastStart = findGraphemeBreaks(text, policy).at(-2) ?? 0;
 	const lastGrapheme = text.slice(lastStart);
 	if (!isHangingPunctuation(lastGrapheme, policy)) return 0;
@@ -448,13 +477,14 @@ function computeProtectedCrossRunGlueWidths(block) {
 	for (let index = 0; index < block.runs.length; index++) {
 		const run = block.runs[index];
 		if (!run || !isTextRun(run)) continue;
-		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
-		const token = trailing?.[1];
 		const policy = resolveEffectiveLineBreakPolicy({
 			attrs: block.attrs,
 			run
 		}).provider;
-		if (!token || token.length !== 1 || !policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
+		if (!policy.locale?.toLocaleLowerCase().startsWith("cs")) continue;
+		const trailing = /(\S+)(\s*)$/u.exec(run.text ?? "");
+		const token = trailing?.[1];
+		if (!token || token.length !== 1) continue;
 		let separator = trailing[2] ?? "";
 		let glueWidth = separator.length > 0 ? measureTextWidth(separator, runToFontStyle(run)) : 0;
 		let followingWord = "";
@@ -485,12 +515,20 @@ function computeProtectedCrossRunGlueWidths(block) {
 	}
 	return widths;
 }
+/**
+* Cap on the number of runs `collectCrossRunWord` traverses per call. A
+* paragraph split into many tiny (including empty) runs would otherwise let
+* the search walk the full run list for every word-start position it is
+* invoked from, without the per-word text-length budget ever kicking in.
+*/
+const MAX_CROSS_RUN_SEGMENTS = 64;
 /** Collect one lexical word continued through adjacent formatting runs. */
 function collectCrossRunWord({ block, startRunIndex, startChar }) {
 	const segments = [];
 	let text = "";
 	let width = 0;
 	for (let runIndex = startRunIndex; runIndex < block.runs.length; runIndex++) {
+		if (runIndex - startRunIndex >= MAX_CROSS_RUN_SEGMENTS) return;
 		const run = block.runs[runIndex];
 		if (!run || !isTextRun(run)) break;
 		const start = runIndex === startRunIndex ? startChar : 0;
@@ -655,7 +693,7 @@ function measureParagraph(block, maxWidth, options) {
 				totalHeight: 0
 			};
 		}
-		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
 		const outlineLineHeight = attrs?.reserveEmptyOutlineHeight ? emptyMetrics.lineHeight * 2 : emptyMetrics.lineHeight;
 		lines.push({
 			fromRun: 0,
@@ -675,9 +713,8 @@ function measureParagraph(block, maxWidth, options) {
 			totalHeight
 		};
 	}
-	if (runs.length === 1 && isTextRun(runs[0]) && isEmptyTextRun(runs[0])) {
-		const run = runs[0];
-		const emptyMetrics = calculateEmptyParagraphMetrics(run.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, run.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY);
+	if (runs.length > 0 && runs.every((run) => isTextRun(run) && isEmptyTextRun(run))) {
+		const emptyMetrics = calculateEmptyParagraphMetrics(attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE, spacing, attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY, attrs);
 		lines.push({
 			fromRun: 0,
 			fromChar: 0,
@@ -733,7 +770,7 @@ function measureParagraph(block, maxWidth, options) {
 				finalTypography.lineHeight = objectHeight;
 				finalTypography.ascent = objectHeight;
 				finalTypography.descent = 0;
-				return finalTypography;
+				return applyDocumentGrid(finalTypography, attrs, spacing);
 			}
 			if (soleRun && isImageRun(soleRun)) {
 				finalTypography.lineHeight = objectHeight;
@@ -744,7 +781,7 @@ function measureParagraph(block, maxWidth, options) {
 				finalTypography.ascent = objectHeight;
 			}
 		}
-		return finalTypography;
+		return applyDocumentGrid(finalTypography, attrs, spacing);
 	};
 	const getPostWrapAvailableWidth = () => {
 		if (!floatingZones || floatingZones.length === 0) return bodyContentWidth;
@@ -769,7 +806,8 @@ function measureParagraph(block, maxWidth, options) {
 			toChar: currentLine.toChar,
 			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography,
-			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {}
+			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {},
+			...currentLine.renderedPageBreakBefore ? { renderedPageBreakBefore: true } : {}
 		};
 		if (currentLine.leftOffset > 0) line.leftOffset = currentLine.leftOffset;
 		if (currentLine.rightOffset > 0) line.rightOffset = currentLine.rightOffset;
@@ -827,6 +865,22 @@ function measureParagraph(block, maxWidth, options) {
 	for (let runIndex = 0; runIndex < runs.length; runIndex++) {
 		if (crossRunResume && runIndex < crossRunResume.runIndex) continue;
 		const run = runs[runIndex];
+		if (run.kind === "renderedPageBreak") {
+			if (!runs.slice(runIndex + 1).some((followingRun) => followingRun.kind !== "renderedPageBreak")) {
+				currentLine.toRun = runIndex;
+				currentLine.toChar = 0;
+				continue;
+			}
+			if (currentLine.width > 0 || currentLine.maxImageHeightPx > 0 || currentLine.maxMathHeightPx > 0) startNewLine(runIndex + 1, 0);
+			else {
+				currentLine.fromRun = runIndex + 1;
+				currentLine.toRun = runIndex + 1;
+				currentLine.fromChar = 0;
+				currentLine.toChar = 0;
+			}
+			currentLine.renderedPageBreakBefore = true;
+			continue;
+		}
 		if (isLineBreakRun(run)) {
 			currentLine.toRun = runIndex;
 			currentLine.toChar = 0;
@@ -952,13 +1006,11 @@ function measureParagraph(block, maxWidth, options) {
 			const wordBreaks = findWordBreaks(text, breakPolicy);
 			let charIndex = crossRunResume?.runIndex === runIndex ? crossRunResume.charIndex : 0;
 			if (crossRunResume?.runIndex === runIndex) crossRunResume = void 0;
+			let wordBreakIndex = 0;
 			let activeHyphenationWord;
 			while (charIndex < text.length) {
-				let nextBreak = text.length;
-				for (const breakPoint of wordBreaks) if (breakPoint > charIndex) {
-					nextBreak = breakPoint;
-					break;
-				}
+				while ((wordBreaks[wordBreakIndex] ?? Number.POSITIVE_INFINITY) <= charIndex) wordBreakIndex += 1;
+				const nextBreak = wordBreaks[wordBreakIndex] ?? text.length;
 				const word = text.slice(charIndex, nextBreak);
 				const measuredWord = trimTrailingSpacesAndTabs(word);
 				const wordWidth = measureTextWidth(measuredWord, style);
@@ -1094,6 +1146,14 @@ function measureParagraph(block, maxWidth, options) {
 			}
 		}
 	}
+	const listParagraphMarkFontSize = attrs?.listParagraphMarkFontSize;
+	if (listParagraphMarkFontSize !== void 0 && listParagraphMarkFontSize > currentLine.maxFontSize) {
+		const fontFamily = currentLine.maxFontMetrics?.fontFamily ?? attrs?.defaultFontFamily;
+		updateMaxFont({
+			fontSize: listParagraphMarkFontSize,
+			...fontFamily === void 0 ? {} : { fontFamily }
+		});
+	}
 	finalizeLine();
 	let totalWithSpacing = lines.reduce((sum, line) => sum + measuredLineAdvance(line), 0);
 	if (spacing?.before) totalWithSpacing += spacing.before;