@stll/folio-core 0.10.0 → 0.12.0

package/dist/layout-bridge/convert/toFlowBlocks.js

@@ -1,15 +1,17 @@
 import { NUMBER_FORMAT_VALUES } from "../../types/documentEnumValues.js";
-import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
-import { convertBulletToUnicode } from "../../docx/bulletMarkers.js";
-import { padDecimal } from "../../docx/numberingParser.js";
-import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
 import { directionIsRtl } from "../../prosemirror/paragraphDirection.js";
 import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { padDecimal } from "../../docx/numberingParser.js";
+import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
+import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
 import { assertValidProseMirrorDocument } from "../../prosemirror/validation.js";
 import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
 import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
+import { resolveThemeFont } from "../../utils/fontResolver.js";
 import { resolveShadingFill } from "../../utils/formatToStyle.js";
+import { convertBulletToUnicode } from "../../docx/bulletMarkers.js";
 import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
+import { resolveDocumentGridLinePitch } from "../../docx/documentGrid.js";
 import { setTextBoxGroupId } from "../../layout-engine/textBoxGroup.js";
 import { setParagraphFrame } from "../../layout-engine/paragraphFrame.js";
 import { getColumns } from "../sectionColumns.js";
@@ -239,9 +241,10 @@ function extractRunFormatting(marks, theme) {
 			break;
 		case "fontFamily": {
 			const attrs = expectFontFamilyMarkAttrs(mark);
-			const font = attrs.ascii || attrs.hAnsi;
+			const font = resolveWesternThemeFont(attrs, theme);
 			if (font) formatting.fontFamily = font;
-			if (attrs.eastAsia) formatting.eastAsiaFontFamily = attrs.eastAsia;
+			const eastAsiaFont = resolveEastAsiaThemeFont(attrs, theme);
+			if (eastAsiaFont) formatting.eastAsiaFontFamily = eastAsiaFont;
 			break;
 		}
 		case "language": {
@@ -345,6 +348,13 @@ function extractRunFormatting(marks, theme) {
 	if (hasNoteRef && formatting.subscript) delete formatting.superscript;
 	return formatting;
 }
+const resolveWesternThemeFont = (fontFamily, theme) => {
+	const themeRef = fontFamily.asciiTheme ?? fontFamily.hAnsiTheme;
+	return (themeRef ? resolveThemeFont(themeRef, theme?.fontScheme) : null) ?? fontFamily.ascii ?? fontFamily.hAnsi ?? void 0;
+};
+const resolveEastAsiaThemeFont = (fontFamily, theme) => {
+	return (fontFamily.eastAsiaTheme ? resolveThemeFont(fontFamily.eastAsiaTheme, theme?.fontScheme) : null) ?? fontFamily.eastAsia ?? void 0;
+};
 function isAutomaticTextColorValue(color) {
 	const rgb = color.rgb?.trim().toLowerCase();
 	return color.auto === true || rgb === "auto" || !rgb && !color.themeColor;
@@ -381,9 +391,10 @@ function paragraphRunDefaults(pmAttrs, theme) {
 	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
 	if (!defaultTextFormatting) return {};
 	const result = {};
-	const fontFamily = defaultTextFormatting.fontFamily?.ascii ?? defaultTextFormatting.fontFamily?.hAnsi;
+	const fontFamily = defaultTextFormatting.fontFamily ? resolveWesternThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
 	if (fontFamily) result.fontFamily = fontFamily;
-	if (defaultTextFormatting.fontFamily?.eastAsia) result.eastAsiaFontFamily = defaultTextFormatting.fontFamily.eastAsia;
+	const eastAsiaFontFamily = defaultTextFormatting.fontFamily ? resolveEastAsiaThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
+	if (eastAsiaFontFamily) result.eastAsiaFontFamily = eastAsiaFontFamily;
 	if (defaultTextFormatting.language) result.language = { ...defaultTextFormatting.language };
 	if (defaultTextFormatting.fontSize !== void 0) result.fontSize = defaultTextFormatting.fontSize / 2;
 	if (defaultTextFormatting.bold !== void 0) result.bold = defaultTextFormatting.bold;
@@ -488,7 +499,21 @@ function paragraphToRuns(node, startPos, _options) {
 	const paraDefaults = paragraphRunDefaults(pmAttrs, theme);
 	const paragraphStyleId = pmAttrs.styleId;
 	const inTocParagraph = typeof paragraphStyleId === "string" && TOC_STYLE_ID.test(paragraphStyleId);
+	let leadingRenderedPageBreakPending = pmAttrs.renderedPageBreakBefore === true;
 	function pushRunsForChild(child, childPos) {
+		if (child.type.name === "renderedPageBreak") {
+			if (leadingRenderedPageBreakPending) {
+				leadingRenderedPageBreakPending = false;
+				return;
+			}
+			runs.push({
+				kind: "renderedPageBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name !== "sdt") leadingRenderedPageBreakPending = false;
 		if (child.isText && child.text) {
 			const formatting = extractRunFormatting(child.marks, theme);
 			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
@@ -700,6 +725,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	const spaceBefore = pmAttrs.spaceBefore;
 	const spaceAfter = pmAttrs.spaceAfter;
 	const lineSpacing = pmAttrs.lineSpacing;
+	if (typeof pmAttrs.snapToGrid === "boolean") attrs.snapToGrid = pmAttrs.snapToGrid;
 	const autoBefore = autospacingMatchesBase(pmAttrs._autospacingBase, "before", spaceBefore);
 	const autoAfter = autospacingMatchesBase(pmAttrs._autospacingBase, "after", spaceAfter);
 	if (autoBefore || autoAfter || typeof spaceBefore === "number" || typeof spaceAfter === "number" || typeof lineSpacing === "number") {
@@ -714,9 +740,10 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 		};
 		const pmSpacingExplicit = pmAttrs.spacingExplicit;
 		const spacingFromDocDefaults = pmAttrs.spacingFromDocDefaults;
+		const spacingFromImplicitDefaultStyle = pmAttrs.spacingFromImplicitDefaultStyle;
 		const explicit = {};
-		if (autoBefore || pmSpacingExplicit?.before || spacingFromDocDefaults?.before) explicit.before = true;
-		if (autoAfter || pmSpacingExplicit?.after || spacingFromDocDefaults?.after) explicit.after = true;
+		if (autoBefore || pmSpacingExplicit?.before || spacingFromDocDefaults?.before || spacingFromImplicitDefaultStyle?.before) explicit.before = true;
+		if (autoAfter || pmSpacingExplicit?.after || spacingFromDocDefaults?.after || spacingFromImplicitDefaultStyle?.after) explicit.after = true;
 		if (explicit.before !== void 0 || explicit.after !== void 0) attrs.spacingExplicit = explicit;
 		if (typeof lineSpacing === "number") if (pmAttrs.lineSpacingRule === "exact" || pmAttrs.lineSpacingRule === "atLeast") {
 			attrs.spacing.line = twipsToPixels(lineSpacing);
@@ -832,7 +859,7 @@ function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounter
 	if (dtf) {
 		if (dtf.fontSize !== void 0) attrs.defaultFontSize = dtf.fontSize / 2;
 		if (dtf.fontFamily) {
-			const resolvedFamily = dtf.fontFamily.ascii || dtf.fontFamily.hAnsi;
+			const resolvedFamily = resolveWesternThemeFont(dtf.fontFamily, theme);
 			if (resolvedFamily) attrs.defaultFontFamily = resolvedFamily;
 		}
 	}
@@ -856,19 +883,23 @@ function mapTabAlignment(align) {
 /**
 * Convert a paragraph node to a ParagraphBlock.
 */
+function hasOnlyVisuallyEmptyTextRuns(runs) {
+	return runs.length > 0 && runs.every((run) => run.kind === "text" && run.text.replace(/\u00a0/gu, " ").trim().length === 0);
+}
 function convertParagraph(node, startPos, options) {
 	const pmAttrs = expectParagraphAttrs(node);
 	const runs = paragraphToRuns(node, startPos, options);
 	const attrs = convertParagraphAttrs(pmAttrs, options.theme, options.listCounters, options.listAbstractCounters, options.listSeenNumIds, options.defaultTabStopTwips, options.originalListCounters, options.originalListAbstractCounters, options.originalListSeenNumIds);
 	if (options.lineBreakRules) attrs.lineBreakRules = options.lineBreakRules;
+	if (options.justificationCompatibility) attrs.justificationCompatibility = options.justificationCompatibility;
 	if (options.automaticHyphenation) attrs.automaticHyphenation = options.automaticHyphenation;
 	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
-	if (runs.length === 0) {
+	if (runs.length === 0 || hasOnlyVisuallyEmptyTextRuns(runs)) {
 		if (pmAttrs._originalFormatting && Object.entries(pmAttrs._originalFormatting).some(([key, value]) => key !== "runProperties" && value !== void 0 && value !== null)) attrs.hasDirectParagraphFormatting = true;
 		const paragraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
 		if (paragraphMarkFormatting && Object.values(paragraphMarkFormatting).some((value) => value !== void 0 && value !== null)) attrs.hasDirectParagraphMarkFormatting = true;
 		if (paragraphMarkFormatting?.fontSize !== void 0) attrs.defaultFontSize = paragraphMarkFormatting.fontSize / 2;
-		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily?.ascii ?? paragraphMarkFormatting?.fontFamily?.hAnsi;
+		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily ? resolveWesternThemeFont(paragraphMarkFormatting.fontFamily, options.theme) : void 0;
 		if (paragraphMarkFontFamily) attrs.defaultFontFamily = paragraphMarkFontFamily;
 	}
 	if (runs.length === 0 && defaultTextFormatting?.hidden === true) {
@@ -1037,12 +1068,13 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 		suppressEmptyParagraphHeight: true
 	};
 	const attrs = expectTableCellAttrs(node);
+	if (attrs.hideMark && trailingBlock?.kind === "paragraph" && trailingBlock.runs.every((run) => run.kind === "text" && run.text.length === 0)) trailingBlock.attrs = {
+		...trailingBlock.attrs,
+		suppressEmptyParagraphHeight: true
+	};
 	const margins = attrs.margins;
 	const resolvePaddingSide = (side, cellTwips, tableTwips) => {
-		if (cellTwips !== void 0) {
-			const px = twipsToPixels(cellTwips);
-			if (px > 0) return px;
-		}
+		if (cellTwips !== void 0) return twipsToPixels(cellTwips);
 		if (tableTwips !== void 0) return twipsToPixels(tableTwips);
 		return twipsToPixels(DEFAULT_TABLE_CELL_MARGIN_TWIPS[side]);
 	};
@@ -1191,10 +1223,12 @@ function convertTextBoxNode(node, startPos, opts) {
 	const attrs = expectTextBoxAttrs(node);
 	const contentBlocks = [];
 	node.forEach((child, offset) => {
+		const childPos = startPos + 1 + offset;
 		if (child.type.name === "paragraph") {
-			const block = convertParagraph(child, startPos + 1 + offset, opts);
-			contentBlocks.push(block);
+			contentBlocks.push(convertParagraph(child, childPos, opts));
+			return;
 		}
+		if (child.type.name === "table") contentBlocks.push(convertTable(child, childPos, opts));
 	});
 	const textBox = {
 		kind: "textBox",
@@ -1271,6 +1305,23 @@ function toFlowBlocks(doc, options = {}) {
 		tagBlockWithSdtStack(block);
 		blocks.push(block);
 	};
+	const trailingPageBreakSectionPositions = /* @__PURE__ */ new Set();
+	const consumedPageBreakPositions = /* @__PURE__ */ new Set();
+	const collectTrailingPageBreakSections = (parent, contentStart) => {
+		let childStart = contentStart;
+		for (let index = 0; index < parent.childCount; index += 1) {
+			const child = parent.child(index);
+			const next = index + 1 < parent.childCount ? parent.child(index + 1) : void 0;
+			const paragraphAttrs = child.type.name === "paragraph" ? expectParagraphAttrs(child) : void 0;
+			if (paragraphAttrs && next?.type.name === "pageBreak" && paragraphAttrs._trailingPageBreak === true && (paragraphAttrs._sectionProperties || paragraphAttrs.sectionBreakType)) {
+				trailingPageBreakSectionPositions.add(childStart);
+				consumedPageBreakPositions.add(childStart + child.nodeSize);
+			}
+			if (child.type.name === "blockSdt") collectTrailingPageBreakSections(child, childStart + 1);
+			childStart += child.nodeSize;
+		}
+	};
+	collectTrailingPageBreakSections(doc, offset);
 	const visit = (node, pos) => {
 		switch (node.type.name) {
 			case "blockSdt": {
@@ -1356,6 +1407,41 @@ function toFlowBlocks(doc, options = {}) {
 					trackedPush(paragraph);
 				} else if (node.content.size > 0 || hasListFormatting || !hasSectionBreak) trackedPush(convertParagraph(node, pos, opts));
 				if (hasSectionBreak) {
+					if (trailingPageBreakSectionPositions.has(pos)) {
+						const sourceParagraph = blocks.at(-1);
+						if (sourceParagraph?.kind === "paragraph" && sourceParagraph.pmStart === pos) {
+							const pageBreak = {
+								kind: "pageBreak",
+								id: nextBlockId(),
+								pmStart: pos + node.nodeSize,
+								pmEnd: pos + node.nodeSize + 1
+							};
+							trackedPush(pageBreak);
+							const sourceAttrs = sourceParagraph.attrs;
+							const carrierSpacing = sourceAttrs?.spacing ? { ...sourceAttrs.spacing } : void 0;
+							if (carrierSpacing) delete carrierSpacing.before;
+							const carrierAttrs = {
+								...carrierSpacing ? { spacing: carrierSpacing } : {},
+								...sourceAttrs?.automaticSpacing?.after === true ? { automaticSpacing: { after: true } } : {},
+								...sourceAttrs?.spacingExplicit?.after === true ? { spacingExplicit: { after: true } } : {},
+								...sourceAttrs?.hasDirectParagraphFormatting === true ? { hasDirectParagraphFormatting: true } : {},
+								...sourceAttrs?.hasDirectParagraphMarkFormatting === true ? { hasDirectParagraphMarkFormatting: true } : {},
+								...sourceAttrs?.snapToGrid !== void 0 ? { snapToGrid: sourceAttrs.snapToGrid } : {},
+								...sourceAttrs?.documentGridLinePitch !== void 0 ? { documentGridLinePitch: sourceAttrs.documentGridLinePitch } : {},
+								...sourceAttrs?.defaultFontSize !== void 0 ? { defaultFontSize: sourceAttrs.defaultFontSize } : {},
+								...sourceAttrs?.defaultFontFamily !== void 0 ? { defaultFontFamily: sourceAttrs.defaultFontFamily } : {}
+							};
+							const carrier = {
+								kind: "paragraph",
+								id: nextBlockId(),
+								runs: [],
+								attrs: carrierAttrs,
+								pmStart: pos + node.nodeSize,
+								pmEnd: pos + node.nodeSize
+							};
+							trackedPush(carrier);
+						}
+					}
 					const sectionBreak = {
 						kind: "sectionBreak",
 						id: nextBlockId()
@@ -1363,6 +1449,8 @@ function toFlowBlocks(doc, options = {}) {
 					const breakType = secProps?.sectionStart ?? pmAttrs.sectionBreakType;
 					if (breakType) sectionBreak.type = breakType;
 					if (secProps) {
+						const documentGridLinePitchTwips = resolveDocumentGridLinePitch(secProps.docGrid);
+						if (documentGridLinePitchTwips !== void 0) sectionBreak.documentGridLinePitchTwips = documentGridLinePitchTwips;
 						if (secProps.pageWidth || secProps.pageHeight) sectionBreak.pageSize = {
 							w: twipsToPixels(secProps.pageWidth ?? 12240),
 							h: twipsToPixels(secProps.pageHeight ?? 15840)
@@ -1401,6 +1489,7 @@ function toFlowBlocks(doc, options = {}) {
 				break;
 			case "horizontalRule":
 			case "pageBreak": {
+				if (consumedPageBreakPositions.has(pos)) break;
 				const pb = {
 					kind: "pageBreak",
 					id: nextBlockId(),
@@ -1419,7 +1508,34 @@ function toFlowBlocks(doc, options = {}) {
 	reserveLeadingEmptyOutlineHeight(blocks);
 	suppressTerminalEmptyParagraphsAfterTable(blocks);
 	suppressFinalParagraphInRepeatedEmptySuffix(blocks);
-	return groupParagraphFrames(mergeRunInParagraphs(blocks), nextBlockId);
+	return groupParagraphFrames(applySectionDocumentGrid(mergeRunInParagraphs(blocks), opts.finalSectionDocumentGridLinePitchTwips), nextBlockId);
+}
+function applySectionDocumentGrid(blocks, finalLinePitchTwips) {
+	const result = [...blocks];
+	let sectionStart = 0;
+	const stampSection = (end, linePitchTwips) => {
+		if (linePitchTwips === void 0 || linePitchTwips <= 0) return;
+		const linePitch = twipsToPixels(linePitchTwips);
+		for (let index = sectionStart; index < end; index += 1) {
+			const block = result[index];
+			if (block?.kind !== "paragraph") continue;
+			result[index] = {
+				...block,
+				attrs: {
+					...block.attrs,
+					documentGridLinePitch: linePitch
+				}
+			};
+		}
+	};
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		if (block?.kind !== "sectionBreak") continue;
+		stampSection(index, block.documentGridLinePitchTwips);
+		sectionStart = index + 1;
+	}
+	stampSection(blocks.length, finalLinePitchTwips);
+	return result;
 }
 /**
 * Merge consecutive paragraph blocks where the first carries

package/dist/layout-bridge/dom/noteStoryDom.d.ts

@@ -0,0 +1,6 @@
+import { NoteStoryKey } from "../../controller/noteEditorManager.js";
+
+//#region src/layout-bridge/dom/noteStoryDom.d.ts
+declare const findNoteStoryForTarget: (target: unknown) => NoteStoryKey | null;
+//#endregion
+export { findNoteStoryForTarget };

package/dist/layout-bridge/dom/noteStoryDom.js

@@ -0,0 +1,17 @@
+//#region src/layout-bridge/dom/noteStoryDom.ts
+const isClosestNoteTarget = (value) => typeof value === "object" && value !== null && "closest" in value && typeof value.closest === "function";
+const findNoteStoryForTarget = (target) => {
+	if (!isClosestNoteTarget(target)) return null;
+	const noteTarget = target.closest("[data-note-kind][data-note-id]");
+	const kind = noteTarget?.dataset["noteKind"];
+	const rawNoteId = noteTarget?.dataset["noteId"] ?? "";
+	if (!/^-?\d+$/u.test(rawNoteId)) return null;
+	const noteId = Number(rawNoteId);
+	if (kind !== "footnote" && kind !== "endnote" || !Number.isSafeInteger(noteId)) return null;
+	return {
+		kind,
+		noteId
+	};
+};
+//#endregion
+export { findNoteStoryForTarget };

package/dist/layout-bridge/engine/clickToPosition.js

@@ -72,7 +72,7 @@ function computeLinePmRange(block, line) {
 		if (!run) continue;
 		if (runIndex < line.fromRun) {
 			if (run.kind === "text") charOffset += run.text.length;
-			else if (run.kind === "tab" || run.kind === "lineBreak") charOffset += 1;
+			else if (run.kind === "tab" || run.kind === "lineBreak" || run.kind === "renderedPageBreak") charOffset += 1;
 			else if (run.kind === "image") charOffset += 1;
 		} else if (runIndex === line.fromRun) {
 			charOffset += line.fromChar;
@@ -90,7 +90,7 @@ function computeLinePmRange(block, line) {
 				const start = runIndex === line.fromRun ? line.fromChar : 0;
 				const end = runIndex === line.toRun ? line.toChar : text.length;
 				lineLength += end - start;
-			} else if (run.kind === "tab" || run.kind === "lineBreak") lineLength += 1;
+			} else if (run.kind === "tab" || run.kind === "lineBreak" || run.kind === "renderedPageBreak") lineLength += 1;
 			else if (run.kind === "image") lineLength += 1;
 		}
 		pmEnd = pmStart + lineLength;

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

@@ -1,4 +1,4 @@
-import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "./types.js";
+import { BlockId, BorderStyle, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "./types.js";
 import { PageState, Paginator, PaginatorOptions, createPaginator } from "./paginator.js";
 import { KeepNextChain, calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
 import { resolveSectionHeaderFooterRefs } from "./headerFooterRefs.js";
@@ -44,4 +44,4 @@ declare function layoutDocument(blocks: FlowBlock[], measures: Measure[], option
  */
 declare function getHeaderRowsHeight(measure: TableMeasure, headerRowCount: number): number;
 //#endregion
-export { BlockId, BorderStyle, type BreakDecision, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, getTableRowLeadingWidth, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, resolveSectionHeaderFooterRefs, scheduleSectionBreak, tableColumnsArePinned };
+export { BlockId, BorderStyle, type BreakDecision, CellBorderSpec, CellBorders, ColumnBreakBlock, ColumnBreakMeasure, ColumnLayout, DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, DocumentPosition, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FieldRun, FloatingTablePosition, FlowBlock, FootnoteContent, Fragment, FragmentBase, HeaderFooterContent, HeaderFooterContentHeights, HeaderFooterLayout, HitTestResult, HyperlinkInfo, ImageBlock, ImageFragment, ImageMeasure, ImageRun, ImageRunPosition, type KeepNextChain, Layout, LayoutOptions, LineBreakRun, ListNumPr, MathRun, Measure, MeasuredLine, Page, PageBreakBlock, PageBreakMeasure, PageHeaderFooterRefs, PageMargins, type PageState, type Paginator, type PaginatorOptions, ParagraphAttrs, ParagraphBlock, ParagraphBorders, ParagraphFragment, ParagraphIndent, ParagraphMeasure, ParagraphSpacing, RenderedPageBreakRun, Run, RunFormatting, SdtGroup, SectionBreakBlock, SectionBreakMeasure, SectionLayoutConfig, type SectionState, TabAlignment, TabRun, TabStop, TableBlock, TableCell, TableCellMeasure, TableFragment, TableMeasure, TableRow, TableRowMeasure, TextBoxBlock, TextBoxFlowAttrs, TextBoxFragment, TextBoxMeasure, TextRun, applyContextualSpacing, applyPendingToActive, assertExhaustiveFlowBlock, calculateChainHeight, collectSectionConfigs, computeKeepNextChains, createInitialSectionState, createPaginator, findPageIndexContainingPmPos, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getEffectiveColumns, getEffectiveMargins, getEffectivePageSize, getHeaderRowsHeight, getMidChainIndices, getTableRowLeadingWidth, hasKeepLines, hasPageBreakBefore, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, layoutDocument, resolveSectionHeaderFooterRefs, scheduleSectionBreak, tableColumnsArePinned };

package/dist/layout-engine/index.js

@@ -1,9 +1,8 @@
 import { emuToPixels } from "../utils/units.js";
 import { measuredLineAdvance } from "./lineFlow.js";
 import { DEFAULT_TEXTBOX_MARGINS, DEFAULT_TEXTBOX_WIDTH, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, floatingTextBoxReservesBand, floatingTextBoxWrapsText, getTableRowLeadingWidth, isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "./types.js";
-import { getParagraphSpacingAfter, getParagraphSpacingBefore } from "./paragraphSpacing.js";
+import { collapseParagraphSpacing, getParagraphSpacingAfter, getParagraphSpacingBefore, paragraphsShareStyle, resolveEffectiveParagraphSpacingTree } from "./paragraphSpacing.js";
 import { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore } from "./keep-together.js";
-import { continuesNumberedSequence } from "./paragraphSequence.js";
 import { createPaginator } from "./paginator.js";
 import { getParagraphFragmentPmRange } from "./paragraphFragmentRange.js";
 import { INITIAL_RENDERED_BREAK_STATE, reconcileAfterBlock, reconcileBreakBeforeBlock, recordReflowBoundary } from "./renderedBreakReconciliation.js";
@@ -19,6 +18,7 @@ import { panic } from "better-result";
 *
 * Converts blocks + measures into positioned fragments on pages.
 */
+const RENDERED_BREAK_REFLOW_TOLERANCE_LINES = 3;
 const DEFAULT_COLUMNS = {
 	count: 1,
 	gap: 0
@@ -58,7 +58,10 @@ function balancedParagraphSectionHeight({ blocks, measures, startIndex, endIndex
 		const measure = measures[index];
 		if (block?.kind !== "paragraph" || measure?.kind !== "paragraph") return;
 		if (block.attrs?.keepNext === true || block.attrs?.keepLines === true || block.runs.some((run) => run.kind === "text" && run.footnoteRefId !== void 0)) return;
-		const leadingSpacing = Math.max(getParagraphSpacingBefore(block), trailingSpacing);
+		const leadingSpacing = collapseParagraphSpacing({
+			before: getParagraphSpacingBefore(block),
+			after: trailingSpacing
+		});
 		if (measure.lines.length === 0) {
 			if (leadingSpacing > 0) {
 				lineUnits.push(leadingSpacing);
@@ -117,7 +120,7 @@ function applyContextualSpacing(blocks) {
 		if (curr.kind !== "paragraph" || next.kind !== "paragraph") continue;
 		const currAttrs = curr.attrs;
 		const nextAttrs = next.attrs;
-		if (currAttrs?.styleId !== nextAttrs?.styleId) continue;
+		if (!paragraphsShareStyle(curr, next)) continue;
 		if (currAttrs?.contextualSpacing && currAttrs.spacing) currAttrs.spacing = {
 			...currAttrs.spacing,
 			after: 0
@@ -130,24 +133,6 @@ function applyContextualSpacing(blocks) {
 	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyContextualSpacing(cell.blocks);
 	else if (block.kind === "textBox") applyContextualSpacing(block.content);
 }
-/** Suppress automatic inter-item spacing within one numbered sequence. */
-const applyAutomaticListSpacing = (blocks) => {
-	for (let index = 1; index < blocks.length; index++) {
-		const previous = blocks[index - 1];
-		const current = blocks[index];
-		if (previous?.kind !== "paragraph" || current?.kind !== "paragraph" || !continuesNumberedSequence(previous, current)) continue;
-		if (previous.attrs?.automaticSpacing?.after && previous.attrs.spacing) previous.attrs.spacing = {
-			...previous.attrs.spacing,
-			after: 0
-		};
-		if (current.attrs?.automaticSpacing?.before && current.attrs.spacing) current.attrs.spacing = {
-			...current.attrs.spacing,
-			before: 0
-		};
-	}
-	for (const block of blocks) if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) applyAutomaticListSpacing(cell.blocks);
-	else if (block.kind === "textBox") applyAutomaticListSpacing(block.content);
-};
 /**
 * Layout a document: convert blocks + measures into pages with positioned fragments.
 *
@@ -196,8 +181,7 @@ function layoutDocument(blocks, measures, options) {
 		...options.footnoteReservedHeights !== void 0 ? { footnoteReservedHeights: options.footnoteReservedHeights } : {},
 		...options.sectionHeaderFooterRefs !== void 0 ? { sectionHeaderFooterRefs: options.sectionHeaderFooterRefs } : {}
 	});
-	applyContextualSpacing(blocks);
-	applyAutomaticListSpacing(blocks);
+	blocks = resolveEffectiveParagraphSpacingTree(blocks);
 	const keepNextChains = computeKeepNextChains(blocks);
 	const midChainIndices = getMidChainIndices(keepNextChains);
 	const blocksById = /* @__PURE__ */ new Map();
@@ -210,7 +194,9 @@ function layoutDocument(blocks, measures, options) {
 	for (let i = 0; i < blocks.length; i++) {
 		const block = blocks[i];
 		const measure = measures[i];
-		const renderedBreakNeedsSnap = measure.kind === "paragraph" && !paginator.fits(measure.totalHeight);
+		const firstLine = measure.kind === "paragraph" ? measure.lines.at(0) : void 0;
+		const firstLineAdvance = firstLine ? measuredLineAdvance(firstLine) : 0;
+		const renderedBreakNeedsSnap = measure.kind === "paragraph" && (!paginator.fits(measure.totalHeight) || firstLineAdvance > 0 && paginator.getAvailableHeight() <= firstLineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES);
 		const hasExplicitPageBreak = hasPageBreakBefore(block);
 		const breakDecision = reconcileBreakBeforeBlock({
 			state: renderedBreakState,
@@ -370,11 +356,20 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 	while (currentLineIndex < lines.length) {
 		const state = paginator.getCurrentState();
 		const availableHeight = paginator.getAvailableHeight();
+		const currentLine = lines.at(currentLineIndex);
+		const markerAlreadySatisfied = state.columnIndex === 0 && state.cursorY === state.topMargin && state.page.fragments.length === 0;
+		if (currentLine?.renderedPageBreakBefore === true && !markerAlreadySatisfied && availableHeight <= measuredLineAdvance(currentLine) * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
+			paginator.forcePageBreak();
+			continue;
+		}
 		if (currentLineIndex === 0 && state.trailingSpacing > 0 && state.cursorY !== state.topMargin) {
 			const firstLine = lines[0];
 			const firstLineRefs = getLineFootnoteRefs(block, firstLine.fromRun, firstLine.toRun, footnoteHeightById);
 			const firstLineHeight = measuredLineAdvance(firstLine) + firstLineRefs.height;
-			const collapsedLead = Math.max(spaceBefore, state.trailingSpacing);
+			const collapsedLead = collapseParagraphSpacing({
+				before: spaceBefore,
+				after: state.trailingSpacing
+			});
 			const columnCapacity = state.contentBottom - state.topMargin;
 			if (collapsedLead + firstLineHeight > availableHeight && spaceBefore + firstLineHeight <= columnCapacity) {
 				paginator.ensureFits(collapsedLead + firstLineHeight);
@@ -385,10 +380,18 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 		let linesFnHeight = 0;
 		const linesFnIds = [];
 		let fittingLines = 0;
-		const firstFragmentSpaceBefore = currentLineIndex === 0 ? Math.max(spaceBefore, state.trailingSpacing) : 0;
+		let forcePageBreakAfterFragment = false;
+		const firstFragmentSpaceBefore = currentLineIndex === 0 ? collapseParagraphSpacing({
+			before: spaceBefore,
+			after: state.trailingSpacing
+		}) : 0;
 		for (let j = currentLineIndex; j < lines.length; j++) {
 			const line = lines[j];
 			const lineAdvance = measuredLineAdvance(line);
+			if (j > currentLineIndex && line.renderedPageBreakBefore === true && availableHeight - (linesHeight + firstFragmentSpaceBefore + linesFnHeight) <= lineAdvance * RENDERED_BREAK_REFLOW_TOLERANCE_LINES) {
+				forcePageBreakAfterFragment = true;
+				break;
+			}
 			const lineRefs = getLineFootnoteRefs(block, line.fromRun, line.toRun, footnoteHeightById);
 			const totalWithLine = linesHeight + lineAdvance;
 			if (totalWithLine + firstFragmentSpaceBefore + linesFnHeight + lineRefs.height <= availableHeight || fittingLines === 0) {
@@ -447,7 +450,8 @@ function layoutParagraph({ block, measure, paginator, contentWidth, footnoteHeig
 		fragment.y = paginator.addFragment(fragment, linesHeight, effectiveSpaceBefore, effectiveSpaceAfter).y;
 		if (linesFnHeight > 0) paginator.addFootnoteHeight(linesFnHeight, linesFnIds);
 		currentLineIndex += fittingLines;
-		if (currentLineIndex < lines.length) if (forceBreakAfterFragment) paginator.forceColumnBreak();
+		if (currentLineIndex < lines.length) if (forcePageBreakAfterFragment) paginator.forcePageBreak();
+		else if (forceBreakAfterFragment) paginator.forceColumnBreak();
 		else paginator.ensureFits(measuredLineAdvance(lines[currentLineIndex]));
 	}
 }
@@ -469,6 +473,10 @@ function getHeaderRowsHeight(measure, headerRowCount) {
 	for (let i = 0; i < headerRowCount && i < measure.rows.length; i++) height += measure.rows[i].height;
 	return height;
 }
+const tableRowStartsWithRenderedPageBreak = (block, rowIndex) => block.rows[rowIndex]?.cells.some((cell) => {
+	const firstBlock = cell.blocks.at(0);
+	return firstBlock?.kind === "paragraph" && firstBlock.attrs?.renderedPageBreakBefore === true;
+}) ?? false;
 /**
 * Layout a table block onto pages.
 */
@@ -511,6 +519,13 @@ function layoutTable(block, measure, paginator, footnoteHeightById) {
 		return oversized || row.height > currentAvailableHeight;
 	};
 	while (currentRowIndex < rows.length) {
+		const rowState = paginator.getCurrentState();
+		const rowHeaderOverhead = shouldRepeatHeaderRows(currentRowIndex, 0, rowState) ? headerRowsHeight : 0;
+		const rowAvailableHeight = paginator.getAvailableHeight() - rowHeaderOverhead - rowState.trailingSpacing;
+		if (!(rowState.cursorY === rowState.topMargin && rowState.page.fragments.length === 0) && tableRowStartsWithRenderedPageBreak(block, currentRowIndex) && rows[currentRowIndex].height > rowAvailableHeight) {
+			paginator.forcePageBreak();
+			continue;
+		}
 		const splittableRow = rows[currentRowIndex];
 		if (canSplitRow(currentRowIndex)) {
 			let consumed = 0;

package/dist/layout-engine/justificationCompatibility.d.ts

@@ -0,0 +1,6 @@
+import { ParagraphAttrs } from "./types.js";
+
+//#region src/layout-engine/justificationCompatibility.d.ts
+declare function resolveJustificationCompatibility(compatibilityMode: number | undefined): NonNullable<ParagraphAttrs["justificationCompatibility"]> | undefined;
+//#endregion
+export { resolveJustificationCompatibility };

package/dist/layout-engine/justificationCompatibility.js

@@ -0,0 +1,8 @@
+//#region src/layout-engine/justificationCompatibility.ts
+const LEGACY_JUSTIFICATION_MAX_COMPATIBILITY_MODE = 14;
+function resolveJustificationCompatibility(compatibilityMode) {
+	if (compatibilityMode === void 0 || compatibilityMode > LEGACY_JUSTIFICATION_MAX_COMPATIBILITY_MODE) return;
+	return { type: "legacy" };
+}
+//#endregion
+export { resolveJustificationCompatibility };

package/dist/layout-engine/keep-together.js

@@ -1,4 +1,11 @@
+import { collapseParagraphSpacing } from "./paragraphSpacing.js";
 //#region src/layout-engine/keep-together.ts
+/**
+* Keep Together Logic - Handle keepNext and keepLines paragraph properties
+*
+* DOCX paragraphs can have keepNext (keep with next paragraph) and keepLines
+* (keep all lines together) properties that affect pagination.
+*/
 function isVisuallyEmptyParagraph(block) {
 	if (block.runs.length === 0) return true;
 	if (block.runs.length !== 1) return false;
@@ -87,7 +94,10 @@ function calculateChainHeight(chain, blocks, measures) {
 		const successorBlock = blocks[successorIndex];
 		const successorMeasure = measures[successorIndex];
 		if (successorBlock?.kind !== "paragraph" || successorMeasure?.kind !== "paragraph") return totalHeight;
-		totalHeight += Math.max(trailingSpacing, successorBlock.attrs?.spacing?.before ?? 0);
+		totalHeight += collapseParagraphSpacing({
+			before: successorBlock.attrs?.spacing?.before ?? 0,
+			after: trailingSpacing
+		});
 		const firstLine = successorMeasure.lines.at(0);
 		if (!firstLine) return totalHeight;
 		const isAnchor = index === successorIndices.length - 1 && chain.anchorIndex !== -1;

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

@@ -2,9 +2,16 @@ 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 +41,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 +55,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 +183,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) {