@stll/folio-core 0.49.0 → 0.50.0

package/dist/layout-bridge/convert/runFormattingMerge.d.ts

@@ -0,0 +1,19 @@
+import { document_d_exports } from "../../types/document.js";
+import { RunFormattingOverrideAttrs } from "../../prosemirror/schema/marks.js";
+import { RunStyleResolver } from "../../prosemirror/runStyleFormatting.js";
+import { RunFormatting } from "../../layout-engine/types.js";
+import { Mark } from "prosemirror-model";
+//#region src/layout-bridge/convert/runFormattingMerge.d.ts
+declare function markDefaultBlackTextColorSource(formatting: RunFormatting, paraDefaults: RunFormatting): RunFormatting;
+declare function mergeRunFormatting(paraDefaults: RunFormatting, formatting: RunFormatting): RunFormatting;
+type ApplyCharacterStyleToggleFormattingOptions = {
+  formatting: RunFormatting;
+  marks: readonly Mark[];
+  paragraphFormatting: document_d_exports.TextFormatting | undefined;
+  styleResolver: RunStyleResolver;
+};
+/** Restore character-style toggle values that plain visual marks cannot represent. */
+declare function applyCharacterStyleToggleFormatting({ formatting, marks, paragraphFormatting, styleResolver }: ApplyCharacterStyleToggleFormattingOptions): void;
+declare function applyRunFormattingOverrides(formatting: RunFormatting, attrs: RunFormattingOverrideAttrs): void;
+//#endregion
+export { applyCharacterStyleToggleFormatting, applyRunFormattingOverrides, markDefaultBlackTextColorSource, mergeRunFormatting };

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

@@ -0,0 +1,167 @@
+import { expectCharacterStyleMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { resolveEffectiveRunStyleFormatting } from "../../prosemirror/runStyleFormatting.js";
+import { STYLE_TOGGLE_KEYS } from "../../utils/textFormattingMerge.js";
+//#region src/layout-bridge/convert/runFormattingMerge.ts
+const DEFAULT_BLACK_TEXT_COLOR_VALUES = /* @__PURE__ */ new Set(["000000", "000"]);
+function normalizeResolvedTextColor(color) {
+	return color.trim().toLowerCase().replace(/^#/u, "");
+}
+function isDefaultBlackResolvedTextColor(color) {
+	return DEFAULT_BLACK_TEXT_COLOR_VALUES.has(normalizeResolvedTextColor(color));
+}
+function areResolvedTextColorsEqual(left, right) {
+	return normalizeResolvedTextColor(left) === normalizeResolvedTextColor(right);
+}
+function markDefaultBlackTextColorSource(formatting, paraDefaults) {
+	if (formatting.textColorSource === "direct" || formatting.color === void 0 || paraDefaults.color === void 0 || !isDefaultBlackResolvedTextColor(formatting.color) || !areResolvedTextColorsEqual(formatting.color, paraDefaults.color)) return formatting;
+	return {
+		...formatting,
+		textColorSource: "paragraphDefault"
+	};
+}
+function mergeRunFormatting(paraDefaults, formatting) {
+	if (formatting.isDeletion && formatting.usesHistoricalFormatting) return formatting;
+	const merged = {
+		...paraDefaults,
+		...markDefaultBlackTextColorSource(formatting, paraDefaults)
+	};
+	if (formatting.fontFamily !== void 0 && formatting.alternateFontFamily === void 0) delete merged.alternateFontFamily;
+	if (formatting.eastAsiaFontFamily !== void 0 && formatting.eastAsiaAlternateFontFamily === void 0) delete merged.eastAsiaAlternateFontFamily;
+	if (formatting.complexScriptFontFamily !== void 0 && formatting.complexScriptAlternateFontFamily === void 0) delete merged.complexScriptAlternateFontFamily;
+	if (merged.letterSpacing === 0) delete merged.letterSpacing;
+	if (formatting.horizontalScale === 100 && paraDefaults.horizontalScale === void 0) delete merged.horizontalScale;
+	return merged;
+}
+const CHARACTER_STYLE_TOGGLE_LAYOUT_PROPERTIES = {
+	allCaps: "allCaps",
+	bold: "bold",
+	boldCs: "complexScriptBold",
+	emboss: "emboss",
+	hidden: "hidden",
+	imprint: "imprint",
+	italic: "italic",
+	italicCs: "complexScriptItalic",
+	outline: "textOutline",
+	shadow: "textShadow",
+	smallCaps: "smallCaps",
+	strike: "strike"
+};
+/** Restore character-style toggle values that plain visual marks cannot represent. */
+function applyCharacterStyleToggleFormatting({ formatting, marks, paragraphFormatting, styleResolver }) {
+	const characterStyleMark = marks.find((mark) => mark.type.name === "characterStyle");
+	const styleRPr = characterStyleMark ? styleResolver.getRunStyleOwnProperties(expectCharacterStyleMarkAttrs(characterStyleMark).styleId) : styleResolver.getDefaultCharacterStyle()?.rPr;
+	if (!styleRPr) return;
+	const effectiveStyleFormatting = resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting,
+		styleResolver
+	});
+	for (const property of STYLE_TOGGLE_KEYS) {
+		if (styleRPr[property] === void 0) continue;
+		const layoutProperty = CHARACTER_STYLE_TOGGLE_LAYOUT_PROPERTIES[property];
+		if (formatting[layoutProperty] === void 0) Reflect.set(formatting, layoutProperty, effectiveStyleFormatting?.[property] ?? false);
+	}
+}
+const suppressInheritedRunFormatting = (formatting, property) => {
+	Reflect.set(formatting, property, void 0);
+};
+const RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES = Object.entries({
+	_authoredOff() {},
+	_authoredOn() {},
+	_authoredValues() {},
+	allCaps(formatting, value) {
+		if (typeof value === "boolean") formatting.allCaps = value;
+	},
+	bold(formatting, value) {
+		if (typeof value === "boolean") formatting.bold = value;
+	},
+	boldCs(formatting, value) {
+		if (typeof value === "boolean") formatting.complexScriptBold = value;
+	},
+	color(formatting, value) {
+		if (value === "auto") {
+			suppressInheritedRunFormatting(formatting, "color");
+			suppressInheritedRunFormatting(formatting, "textColorSource");
+		}
+	},
+	complexScriptPropertyAbsences() {},
+	cs(formatting, value) {
+		if (typeof value === "boolean") formatting.forceComplexScript = value;
+	},
+	directFontProperties() {},
+	doubleStrike(formatting, value) {
+		if (value === false && formatting.strike === void 0) formatting.strike = false;
+	},
+	effect(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "textEffect");
+	},
+	emboss(formatting, value) {
+		if (typeof value === "boolean") formatting.emboss = value;
+	},
+	emphasisMark(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "emphasisMark");
+	},
+	fontSizeCs(formatting, value) {
+		if (typeof value === "number") formatting.complexScriptFontSize = value / 2;
+	},
+	noProof() {},
+	hidden(formatting, value) {
+		if (typeof value === "boolean") formatting.hidden = value;
+	},
+	highlight(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "highlight");
+	},
+	imprint(formatting, value) {
+		if (typeof value === "boolean") formatting.imprint = value;
+	},
+	italic(formatting, value) {
+		if (typeof value === "boolean") formatting.italic = value;
+	},
+	italicCs(formatting, value) {
+		if (typeof value === "boolean") formatting.complexScriptItalic = value;
+	},
+	kerning(formatting, value) {
+		if (value === 0) formatting.kerningMinPt = 0;
+	},
+	outline(formatting, value) {
+		if (typeof value === "boolean") formatting.textOutline = value;
+	},
+	position(formatting, value) {
+		if (value === 0) formatting.positionPx = 0;
+	},
+	rtl(formatting, value) {
+		if (value === false) formatting.rtl = false;
+	},
+	scale(formatting, value) {
+		if (value === 100) formatting.horizontalScale = 100;
+	},
+	shading(formatting, value) {
+		if (typeof value === "object" && value !== null && Reflect.get(value, "pattern") === "nil") suppressInheritedRunFormatting(formatting, "shading");
+	},
+	shadow(formatting, value) {
+		if (typeof value === "boolean") formatting.textShadow = value;
+	},
+	smallCaps(formatting, value) {
+		if (typeof value === "boolean") formatting.smallCaps = value;
+	},
+	spacing(formatting, value) {
+		if (value === 0) formatting.letterSpacing = 0;
+	},
+	strike(formatting, value) {
+		if (typeof value === "boolean") formatting.strike = value;
+	},
+	underline(formatting, value) {
+		if (value === "none") formatting.underline = false;
+	},
+	vertAlign(formatting, value) {
+		if (value === "baseline") {
+			formatting.superscript = false;
+			formatting.subscript = false;
+		}
+	}
+});
+function applyRunFormattingOverrides(formatting, attrs) {
+	for (const [key, handler] of RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES) handler(formatting, Reflect.get(attrs, key));
+}
+//#endregion
+export { applyCharacterStyleToggleFormatting, applyRunFormattingOverrides, markDefaultBlackTextColorSource, mergeRunFormatting };

package/dist/layout-bridge/convert/runMarkFormatting.d.ts

@@ -0,0 +1,11 @@
+import { document_d_exports } from "../../types/document.js";
+import { RunFormatting } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { Mark } from "prosemirror-model";
+//#region src/layout-bridge/convert/runMarkFormatting.d.ts
+/**
+ * Extract run formatting from ProseMirror marks.
+ */
+declare function extractRunFormatting(marks: readonly Mark[], theme?: document_d_exports.Theme | null, fontAlternates?: FontAlternates): RunFormatting;
+//#endregion
+export { extractRunFormatting };

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

@@ -0,0 +1,291 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { setHyperlinkInstanceIndex } from "../../layout-engine/measure/hyperlinkInstance.js";
+import { expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
+import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
+import { resolveShadingFill } from "../../utils/formatToStyle.js";
+import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { halfPointsToPixels, halfPointsToPoints } from "../../utils/units.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+import { applyRunFormattingOverrides } from "./runFormattingMerge.js";
+import { isAutomaticTextColorValue, resolveComplexScriptThemeFont, resolveEastAsiaThemeFont, resolveWesternThemeFont } from "./textFormattingConversion.js";
+import { panic } from "better-result";
+//#region src/layout-bridge/convert/runMarkFormatting.ts
+/**
+* What the painter does with each mark the schema declares.
+*
+* The switch below used to end in `default: break`, so a mark that reached it
+* was silently not painted whether that was the decision or an omission. The
+* table is total over {@link SchemaMarkName}: a mark added to the schema
+* without a paint decision does not compile, and a mark this table says is
+* painted but the switch does not handle panics rather than disappearing.
+*/
+const MARK_PAINT_DISPOSITIONS = {
+	bold: "runFormatting",
+	italic: "runFormatting",
+	underline: "runFormatting",
+	strike: "runFormatting",
+	textColor: "runFormatting",
+	runShading: "runFormatting",
+	highlight: "runFormatting",
+	fontSize: "runFormatting",
+	fontFamily: "runFormatting",
+	language: "runFormatting",
+	superscript: "runFormatting",
+	subscript: "runFormatting",
+	hyperlink: "runFormatting",
+	allCaps: "runFormatting",
+	smallCaps: "runFormatting",
+	footnoteRef: "runFormatting",
+	characterSpacing: "runFormatting",
+	emboss: "runFormatting",
+	imprint: "runFormatting",
+	hidden: "runFormatting",
+	textShadow: "runFormatting",
+	emphasisMark: "runFormatting",
+	textOutline: "runFormatting",
+	rtl: "runFormatting",
+	textEffect: "runFormatting",
+	runFormattingOverride: "runFormatting",
+	comment: "runFormatting",
+	insertion: "runFormatting",
+	deletion: "runFormatting",
+	inlineWrapper: "runFormatting",
+	characterStyle: "resolvedElsewhere",
+	runIdentity: "notPainted",
+	runPropertyChange: "notPainted"
+};
+const markPaintDisposition = (name) => {
+	return MARK_PAINT_DISPOSITIONS[name];
+};
+/**
+* Whether a layer states how its content is laid out.
+*
+* A smart tag and a custom-XML wrapper name an element in another vocabulary
+* and say nothing about layout, so the painter draws the text exactly as it
+* would without them. The `switch` is here rather than inline so a kind added
+* to the model has to answer the question.
+*/
+const paintedDirection = (layer) => {
+	switch (layer.kind) {
+		case "bidi": return layer.direction === void 0 ? { control: layer.control } : {
+			control: layer.control,
+			direction: layer.direction
+		};
+		case "smartTag":
+		case "customXml": return;
+		default: return;
+	}
+};
+/**
+* The direction the innermost bidirectional layer of a stack lays its content out in.
+*
+* Innermost wins: a bidirectional wrapper inside another is the one the text is
+* laid out in, and the outer layers are what the save leg rebuilds the nesting
+* from. The layers that state no direction are skipped rather than ending the
+* search, so a smart tag inside a `w:dir` still reads right to left.
+*/
+const innermostBidiWrapper = (stack) => {
+	for (const layer of stack.toReversed()) {
+		const direction = paintedDirection(layer);
+		if (direction !== void 0) return direction;
+	}
+};
+/**
+* Extract run formatting from ProseMirror marks.
+*/
+function extractRunFormatting(marks, theme, fontAlternates) {
+	const formatting = {};
+	let hasNoteRef = false;
+	let runFormattingOverride;
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline": {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			if (attrs.style || attrs.color) {
+				const underlineObj = {};
+				if (attrs.style) underlineObj.style = attrs.style;
+				if (attrs.color) underlineObj.color = resolveColor(attrs.color, theme);
+				formatting.underline = underlineObj;
+			} else formatting.underline = true;
+			break;
+		}
+		case "strike":
+			formatting.strike = true;
+			break;
+		case "textColor": {
+			const attrs = expectTextColorMarkAttrs(mark);
+			if (attrs.themeColor || attrs.rgb) {
+				const colorArg = {};
+				if (attrs.rgb) colorArg.rgb = attrs.rgb;
+				if (attrs.themeColor) colorArg.themeColor = attrs.themeColor;
+				if (attrs.themeTint) colorArg.themeTint = attrs.themeTint;
+				if (attrs.themeShade) colorArg.themeShade = attrs.themeShade;
+				if (!isAutomaticTextColorValue(colorArg)) {
+					formatting.color = resolveColor(colorArg, theme);
+					formatting.textColorSource = "direct";
+				}
+			}
+			break;
+		}
+		case "highlight":
+			formatting.highlight = resolveHighlightToCss(expectHighlightMarkAttrs(mark).color);
+			break;
+		case "runShading": {
+			const shadingCss = resolveShadingFill(runShadingAttrsToShading(expectRunShadingMarkAttrs(mark)), theme);
+			if (shadingCss) formatting.shading = shadingCss;
+			break;
+		}
+		case "fontSize":
+			formatting.fontSize = expectFontSizeMarkAttrs(mark).size / 2;
+			break;
+		case "fontFamily": {
+			const attrs = expectFontFamilyMarkAttrs(mark);
+			const font = resolveWesternThemeFont(attrs, theme);
+			if (font) {
+				formatting.fontFamily = font;
+				const alternate = getFontAlternate(font, fontAlternates);
+				if (alternate) formatting.alternateFontFamily = alternate;
+			}
+			const eastAsiaFont = resolveEastAsiaThemeFont(attrs, theme);
+			if (eastAsiaFont) {
+				formatting.eastAsiaFontFamily = eastAsiaFont;
+				const alternate = getFontAlternate(eastAsiaFont, fontAlternates);
+				if (alternate) formatting.eastAsiaAlternateFontFamily = alternate;
+			}
+			if (attrs.hint) formatting.eastAsiaHint = attrs.hint === "eastAsia";
+			const complexScriptFont = resolveComplexScriptThemeFont(attrs, theme);
+			if (complexScriptFont) {
+				formatting.complexScriptFontFamily = complexScriptFont;
+				const alternate = getFontAlternate(complexScriptFont, fontAlternates);
+				if (alternate) formatting.complexScriptAlternateFontFamily = alternate;
+			}
+			break;
+		}
+		case "language": {
+			const attrs = expectLanguageMarkAttrs(mark);
+			formatting.language = {
+				...attrs.val ? { val: attrs.val } : {},
+				...attrs.eastAsia ? { eastAsia: attrs.eastAsia } : {},
+				...attrs.bidi ? { bidi: attrs.bidi } : {}
+			};
+			break;
+		}
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0) formatting.letterSpacing = twipsToPixels(attrs.spacing);
+			if (attrs.position !== void 0 && attrs.position !== 0) formatting.positionPx = halfPointsToPixels(attrs.position);
+			const horizontalScale = normalizeHorizontalScalePercent(attrs.scale);
+			if (horizontalScale !== void 0) formatting.horizontalScale = horizontalScale;
+			if (attrs.kerning !== void 0 && attrs.kerning > 0) formatting.kerningMinPt = halfPointsToPoints(attrs.kerning);
+			break;
+		}
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.textShadow = true;
+			break;
+		case "textOutline":
+			formatting.textOutline = true;
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "textEffect":
+			formatting.textEffect = expectTextEffectMarkAttrs(mark).effect;
+			break;
+		case "runFormattingOverride":
+			runFormattingOverride = expectRunFormattingOverrideMarkAttrs(mark);
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type ?? "dot";
+			break;
+		case "superscript":
+			formatting.superscript = true;
+			break;
+		case "subscript":
+			formatting.subscript = true;
+			break;
+		case "hyperlink": {
+			const attrs = expectHyperlinkMarkAttrs(mark);
+			const link = { href: attrs.href };
+			if (attrs.tooltip !== void 0) link.tooltip = attrs.tooltip;
+			if (attrs._docxHyperlinkIndex !== void 0) setHyperlinkInstanceIndex(link, attrs._docxHyperlinkIndex);
+			formatting.hyperlink = link;
+			break;
+		}
+		case "footnoteRef": {
+			hasNoteRef = true;
+			const attrs = expectFootnoteRefMarkAttrs(mark);
+			if (attrs.vertAlign === "superscript") formatting.superscript = true;
+			const id = typeof attrs.id === "string" ? Number.parseInt(attrs.id, 10) : attrs.id;
+			if (attrs.noteType === "endnote") formatting.endnoteRefId = id;
+			else formatting.footnoteRefId = id;
+			break;
+		}
+		case "comment": {
+			const commentId = expectCommentMarkAttrs(mark).commentId;
+			if (commentId) {
+				if (!formatting.commentIds) formatting.commentIds = [];
+				formatting.commentIds.push(commentId);
+			}
+			break;
+		}
+		case "insertion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isInsertion = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			if (attrs.provenance === "suggested") {
+				formatting.isSuggestion = true;
+				if (attrs.suggestionId) formatting.suggestionId = attrs.suggestionId;
+			}
+			break;
+		}
+		case "deletion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isDeletion = true;
+			if (attrs._historicalFormatting) formatting.usesHistoricalFormatting = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			if (attrs.provenance === "suggested") {
+				formatting.isSuggestion = true;
+				if (attrs.suggestionId) formatting.suggestionId = attrs.suggestionId;
+			}
+			break;
+		}
+		case "inlineWrapper": {
+			const bidiWrapper = innermostBidiWrapper(expectInlineWrapperMarkAttrs(mark).stack);
+			if (bidiWrapper) formatting.bidiWrapper = bidiWrapper;
+			break;
+		}
+		default:
+			if (markPaintDisposition(mark.type.name) === "runFormatting") panic(`Mark ${mark.type.name} is painted as run formatting but has no branch here`);
+			break;
+	}
+	if (runFormattingOverride) applyRunFormattingOverrides(formatting, runFormattingOverride);
+	if (hasNoteRef && formatting.subscript) delete formatting.superscript;
+	return formatting;
+}
+//#endregion
+export { extractRunFormatting };

package/dist/layout-bridge/convert/sectionBoundaries.d.ts

@@ -0,0 +1,35 @@
+import { FlowBlock, SectionBreakBlock } from "../../layout-engine/types.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/sectionBoundaries.d.ts
+declare function getLastMapKey<K, V>(map: ReadonlyMap<K, V>): K | undefined;
+/**
+ * Translate section-owned start modes into the boundary-owned values consumed
+ * by the paginator. Each flow section break carries the properties for the
+ * section it ends, so its start mode belongs on the preceding boundary.
+ */
+declare function applySectionStartsToBoundaries(blocks: readonly FlowBlock[], finalSectionStart: NonNullable<SectionBreakBlock["type"]> | undefined): FlowBlock[];
+/**
+ * A trailing page break belongs to its section-ending paragraph. When the
+ * paragraph mark stays on the current page, an immediately following
+ * continuous section resumes there too. Accept both the legacy generated
+ * carrier and the inline atom's one-token paragraph-mark fragment; neither is
+ * a physical layout boundary.
+ *
+ * A section break in `breaksWithoutMarker` ends at an empty w:sectPr paragraph
+ * that projected no block, so a page break just before it ends an earlier
+ * paragraph and still starts the next page.
+ */
+declare function coalesceTrailingPageBreakBeforeContinuousSection(blocks: readonly FlowBlock[], splitPageBreakAndParagraphMark: boolean, breaksWithoutMarker: ReadonlySet<SectionBreakBlock["id"]>): FlowBlock[];
+/**
+ * The last section's start mode, off a document attribute the schema types as
+ * `any`. `parseSectionBreakType` owns the enumeration, so a member added to
+ * `ST_SectionMark` reaches the paginator instead of being dropped here.
+ */
+declare function readFinalSectionStart(doc: Node): NonNullable<SectionBreakBlock["type"]> | undefined;
+type SectionDocumentGridOptions = {
+  finalLinePitchTwips: number | undefined;
+  tableCellLinePitch: "sectionGrid" | undefined;
+};
+declare function applySectionDocumentGrid(blocks: FlowBlock[], { finalLinePitchTwips, tableCellLinePitch }: SectionDocumentGridOptions): FlowBlock[];
+//#endregion
+export { applySectionDocumentGrid, applySectionStartsToBoundaries, coalesceTrailingPageBreakBeforeContinuousSection, getLastMapKey, readFinalSectionStart };

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

@@ -0,0 +1,114 @@
+import { parseSectionBreakType } from "../../prosemirror/sectionCarrier.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+//#region src/layout-bridge/convert/sectionBoundaries.ts
+function getLastMapKey(map) {
+	let lastKey;
+	for (const key of map.keys()) lastKey = key;
+	return lastKey;
+}
+/**
+* Translate section-owned start modes into the boundary-owned values consumed
+* by the paginator. Each flow section break carries the properties for the
+* section it ends, so its start mode belongs on the preceding boundary.
+*/
+function applySectionStartsToBoundaries(blocks, finalSectionStart) {
+	const breakIndexes = [];
+	for (let index = 0; index < blocks.length; index += 1) if (blocks[index]?.kind === "sectionBreak") breakIndexes.push(index);
+	if (breakIndexes.length === 0) return [...blocks];
+	const result = [...blocks];
+	for (let index = 0; index < breakIndexes.length; index += 1) {
+		const boundaryIndex = breakIndexes[index];
+		if (boundaryIndex === void 0) continue;
+		const boundary = blocks[boundaryIndex];
+		if (boundary?.kind !== "sectionBreak") continue;
+		const nextBoundaryIndex = breakIndexes[index + 1];
+		const nextBoundary = nextBoundaryIndex === void 0 ? void 0 : blocks[nextBoundaryIndex];
+		const nextStart = nextBoundary?.kind === "sectionBreak" ? nextBoundary.type : finalSectionStart;
+		const translated = { ...boundary };
+		if (nextStart === void 0) delete translated.type;
+		else translated.type = nextStart;
+		result[boundaryIndex] = translated;
+	}
+	return result;
+}
+/**
+* A trailing page break belongs to its section-ending paragraph. When the
+* paragraph mark stays on the current page, an immediately following
+* continuous section resumes there too. Accept both the legacy generated
+* carrier and the inline atom's one-token paragraph-mark fragment; neither is
+* a physical layout boundary.
+*
+* A section break in `breaksWithoutMarker` ends at an empty w:sectPr paragraph
+* that projected no block, so a page break just before it ends an earlier
+* paragraph and still starts the next page.
+*/
+function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreakAndParagraphMark, breaksWithoutMarker) {
+	if (splitPageBreakAndParagraphMark) return [...blocks];
+	const result = [];
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const carrier = blocks[index + 1];
+		const section = blocks[index + 2];
+		const isLegacyGeneratedCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmStart !== void 0 && block.pmStart === carrier.pmStart && carrier.pmStart === carrier.pmEnd;
+		const isInlineParagraphMarkCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmEnd !== void 0 && carrier.pmStart === block.pmEnd && carrier.pmEnd === block.pmEnd + 1;
+		const isUnresolvedInsertion = block?.kind === "pageBreak" && block.isInsertion === true;
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && carrier?.kind === "sectionBreak" && carrier.type === "continuous" && !breaksWithoutMarker.has(carrier.id)) continue;
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && (isLegacyGeneratedCarrier || isInlineParagraphMarkCarrier) && section?.kind === "sectionBreak" && section.type === "continuous" && !breaksWithoutMarker.has(section.id)) {
+			index += 1;
+			continue;
+		}
+		if (block) result.push(block);
+	}
+	return result;
+}
+/**
+* The last section's start mode, off a document attribute the schema types as
+* `any`. `parseSectionBreakType` owns the enumeration, so a member added to
+* `ST_SectionMark` reaches the paginator instead of being dropped here.
+*/
+function readFinalSectionStart(doc) {
+	return parseSectionBreakType(doc.attrs["_finalSectionStart"]) ?? void 0;
+}
+function applySectionDocumentGrid(blocks, { finalLinePitchTwips, tableCellLinePitch }) {
+	const result = [...blocks];
+	let sectionStart = 0;
+	const stampSection = (end, linePitchTwips) => {
+		if (linePitchTwips === void 0 || linePitchTwips <= 0) return;
+		const linePitch = twipsToPixels(linePitchTwips);
+		const stampBlock = (block) => {
+			if (block.kind === "paragraph") return {
+				...block,
+				attrs: {
+					...block.attrs,
+					documentGridLinePitch: linePitch
+				}
+			};
+			if (block.kind !== "table" || tableCellLinePitch !== "sectionGrid") return block;
+			return {
+				...block,
+				rows: block.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						blocks: cell.blocks.map(stampBlock)
+					}))
+				}))
+			};
+		};
+		for (let index = sectionStart; index < end; index += 1) {
+			const block = result[index];
+			if (!block) continue;
+			result[index] = stampBlock(block);
+		}
+	};
+	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;
+}
+//#endregion
+export { applySectionDocumentGrid, applySectionStartsToBoundaries, coalesceTrailingPageBreakBeforeContinuousSection, getLastMapKey, readFinalSectionStart };

package/dist/layout-bridge/convert/tableConversion.d.ts

@@ -0,0 +1,12 @@
+import { TableBlock, TextBoxBlock } from "../../layout-engine/types.js";
+import { FlowConversionOptions } from "./flowConversionShared.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/tableConversion.d.ts
+/**
+ * Convert a table node to a TableBlock.
+ */
+declare function convertTable(node: Node, startPos: number, options: FlowConversionOptions): TableBlock;
+/** Convert a textBox PM node to a TextBoxBlock. */
+declare function convertTextBoxNode(node: Node, startPos: number, opts: FlowConversionOptions): TextBoxBlock;
+//#endregion
+export { convertTable, convertTextBoxNode };