@stll/folio-core 0.49.0 → 0.50.0

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

@@ -0,0 +1,234 @@
+import { bulletMarkerFontName, convertBulletToUnicode } from "../../docx/bulletMarkers.js";
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
+import { advanceVisibleListMarker } from "../../prosemirror/listMarker.js";
+import { directionIsRtl, directionToBidi } from "../../prosemirror/paragraphDirection.js";
+import { mergeParagraphTabStops } from "../../utils/paragraphFormattingMerge.js";
+import { AUTO_PARAGRAPH_SPACING_PX } from "../../utils/units.js";
+import { convertBorderSpecToLayout } from "./flowBorders.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+import { applyDeletedListMarkerAttrs, applyMarkerAllCaps, isAddedNumberingChange, isChangedNumberingChange, isRemovedNumberingChange, toListMarkerRevision } from "./listMarkers.js";
+import { listMarkerFormattingFor, resolveWesternThemeFont } from "./textFormattingConversion.js";
+import { paragraphNumberingLevel, paragraphNumberingReferenceId } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/paragraphAttrs.ts
+/**
+* Converts ProseMirror paragraph attributes to layout ParagraphAttrs:
+* alignment, spacing, indentation, borders, tab stops, and list markers.
+*/
+/**
+* Every `ST_Jc` member, and the flow alignment that paints it.
+*
+* `start` and `end` stay unresolved here: they name an edge of the writing
+* direction, not a side of the page, so which of `left` and `right` paints
+* them depends on the paragraph's direction. `numTab` has no flow alignment at
+* all — it aligns the paragraph to the list number's tab stop, which the flow
+* engine does not model — so it falls back to the start edge, which is where a
+* numbered paragraph without one sits.
+*/
+const FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT = {
+	start: "start",
+	end: "end",
+	numTab: "start",
+	left: "left",
+	center: "center",
+	right: "right",
+	both: "justify",
+	distribute: "justify",
+	mediumKashida: "justify",
+	highKashida: "justify",
+	lowKashida: "justify",
+	thaiDistribute: "justify"
+};
+/** Resolve a logical alignment against the direction the paragraph runs in. */
+const resolveFlowAlignment = (alignment, rightToLeft) => {
+	const flow = FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT[alignment];
+	switch (flow) {
+		case "start": return rightToLeft ? "right" : "left";
+		case "end": return rightToLeft ? "left" : "right";
+		default: return flow;
+	}
+};
+function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStreams, defaultTabStopTwips, paragraphMarkFormatting }) {
+	const attrs = {};
+	if (pmAttrs.alignment) attrs.alignment = resolveFlowAlignment(pmAttrs.alignment, directionIsRtl(pmAttrs.direction));
+	if (pmAttrs.outlineLevel !== void 0) attrs.outlineLevel = pmAttrs.outlineLevel;
+	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") {
+		attrs.spacing = {};
+		if (autoBefore) attrs.spacing.before = AUTO_PARAGRAPH_SPACING_PX;
+		else if (typeof spaceBefore === "number") attrs.spacing.before = twipsToPixels(spaceBefore);
+		if (autoAfter) attrs.spacing.after = AUTO_PARAGRAPH_SPACING_PX;
+		else if (typeof spaceAfter === "number") attrs.spacing.after = twipsToPixels(spaceAfter);
+		if (autoBefore || autoAfter) attrs.automaticSpacing = {
+			...autoBefore ? { before: true } : {},
+			...autoAfter ? { after: true } : {}
+		};
+		const pmSpacingExplicit = pmAttrs.spacingExplicit;
+		const spacingFromDocDefaults = pmAttrs.spacingFromDocDefaults;
+		const spacingFromImplicitDefaultStyle = pmAttrs.spacingFromImplicitDefaultStyle;
+		const explicit = {};
+		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);
+			attrs.spacing.lineUnit = "px";
+			attrs.spacing.lineRule = pmAttrs.lineSpacingRule;
+		} else {
+			attrs.spacing.line = lineSpacing / 240;
+			attrs.spacing.lineUnit = "multiplier";
+			attrs.spacing.lineRule = "auto";
+		}
+	}
+	let indentLeft = typeof pmAttrs.indentLeft === "number" ? pmAttrs.indentLeft : void 0;
+	let indentFirstLine = typeof pmAttrs.indentFirstLine === "number" ? pmAttrs.indentFirstLine : void 0;
+	let hangingIndent = pmAttrs.hangingIndent;
+	if (paragraphNumberingReferenceId(pmAttrs.numPr) !== void 0 && indentLeft === void 0 && indentFirstLine === void 0) {
+		indentLeft = ((paragraphNumberingLevel(pmAttrs.numPr) ?? 0) + 1) * 720;
+		if (indentFirstLine === void 0) {
+			indentFirstLine = -360;
+			hangingIndent = true;
+		}
+	}
+	if (indentLeft !== void 0 || typeof pmAttrs.indentRight === "number" || indentFirstLine !== void 0) {
+		attrs.indent = {};
+		if (indentLeft !== void 0) attrs.indent.left = twipsToPixels(indentLeft);
+		if (typeof pmAttrs.indentRight === "number") attrs.indent.right = twipsToPixels(pmAttrs.indentRight);
+		if (indentFirstLine !== void 0) if (hangingIndent) attrs.indent.hanging = Math.abs(twipsToPixels(indentFirstLine));
+		else attrs.indent.firstLine = twipsToPixels(indentFirstLine);
+	}
+	if (pmAttrs.styleId) attrs.styleId = pmAttrs.styleId;
+	if (pmAttrs.borders) {
+		const borders = pmAttrs.borders;
+		attrs.borders = {};
+		const convertBorder = (border) => border ? convertBorderSpecToLayout(border, theme) : void 0;
+		const topBorder = borders.top ? convertBorder(borders.top) : void 0;
+		if (topBorder) attrs.borders.top = topBorder;
+		const bottomBorder = borders.bottom ? convertBorder(borders.bottom) : void 0;
+		if (bottomBorder) attrs.borders.bottom = bottomBorder;
+		const leftBorder = borders.left ? convertBorder(borders.left) : void 0;
+		if (leftBorder) attrs.borders.left = leftBorder;
+		const rightBorder = borders.right ? convertBorder(borders.right) : void 0;
+		if (rightBorder) attrs.borders.right = rightBorder;
+		const betweenBorder = borders.between ? convertBorder(borders.between) : void 0;
+		if (betweenBorder) attrs.borders.between = betweenBorder;
+		const barBorder = borders.bar ? convertBorder(borders.bar) : void 0;
+		if (barBorder) attrs.borders.bar = barBorder;
+		if (!attrs.borders.top && !attrs.borders.bottom && !attrs.borders.left && !attrs.borders.right && !attrs.borders.between && !attrs.borders.bar) delete attrs.borders;
+	}
+	const shadingRgb = pmAttrs.shading?.fill?.rgb?.toUpperCase();
+	if (shadingRgb && shadingRgb !== "FFFFFF" && shadingRgb !== "FFFFFE") attrs.shading = `#${pmAttrs.shading?.fill?.rgb}`;
+	const tabs = mergeParagraphTabStops(pmAttrs.listLevelTabs ?? void 0, pmAttrs.tabs ?? void 0);
+	if (tabs && tabs.length > 0) {
+		const rightToLeft = directionIsRtl(pmAttrs.direction);
+		attrs.tabs = tabs.map((tab) => {
+			const tabStop = {
+				val: resolveTabAlignment(tab.alignment, rightToLeft),
+				pos: tab.position
+			};
+			if (tab.leader) tabStop.leader = tab.leader;
+			return tabStop;
+		});
+	}
+	if (pmAttrs.pageBreakBefore) attrs.pageBreakBefore = true;
+	if (pmAttrs.kinsoku !== void 0 && pmAttrs.kinsoku !== null) attrs.kinsoku = pmAttrs.kinsoku;
+	if (pmAttrs.overflowPunctuation !== void 0 && pmAttrs.overflowPunctuation !== null) attrs.overflowPunctuation = pmAttrs.overflowPunctuation;
+	if (pmAttrs.suppressAutoHyphens !== void 0 && pmAttrs.suppressAutoHyphens !== null) attrs.suppressAutoHyphens = pmAttrs.suppressAutoHyphens;
+	if (pmAttrs.renderedPageBreakBefore) attrs.renderedPageBreakBefore = true;
+	if (pmAttrs.keepNext) attrs.keepNext = true;
+	if (pmAttrs.keepLines) attrs.keepLines = true;
+	if (pmAttrs.widowControl === false) attrs.widowControl = false;
+	if (pmAttrs.contextualSpacing) attrs.contextualSpacing = true;
+	if (pmAttrs.runInWithNext) attrs.runInWithNext = true;
+	const bidi = directionToBidi(pmAttrs.direction);
+	if (bidi !== void 0) attrs.bidi = bidi;
+	if (pmAttrs.styleId) attrs.styleId = pmAttrs.styleId;
+	const propertyChanges = pmAttrs._propertyChanges ?? [];
+	let changedNumberingChange;
+	if (pmAttrs.numPr) {
+		attrs.numPr = pmAttrs.numPr;
+		if (pmAttrs.pPrMark?.kind === "del") attrs.listMarkerRevision = toListMarkerRevision("del", pmAttrs.pPrMark.info);
+		else if (pmAttrs.pPrMark?.kind === "ins") attrs.listMarkerRevision = toListMarkerRevision("ins", pmAttrs.pPrMark.info);
+		else {
+			const numberingAddedChange = propertyChanges.find(isAddedNumberingChange);
+			const currentNumPr = pmAttrs.numPr;
+			changedNumberingChange = propertyChanges.find((change) => isChangedNumberingChange(currentNumPr, change));
+			const numberingInsertionChange = numberingAddedChange ?? changedNumberingChange;
+			if (numberingInsertionChange) attrs.listMarkerRevision = toListMarkerRevision("ins", numberingInsertionChange.info);
+		}
+	}
+	const resolvedMarker = applyMarkerAllCaps(advanceVisibleListMarker(pmAttrs, listCounterStreams).marker, pmAttrs.listMarkerAllCaps);
+	if (resolvedMarker !== null) attrs.listMarker = resolvedMarker;
+	else if (pmAttrs.listMarker) attrs.listMarker = pmAttrs.listIsBullet ? convertBulletToUnicode(pmAttrs.listMarker, bulletMarkerFontName(pmAttrs.listMarkerFormatting)) : pmAttrs.listMarker;
+	if (pmAttrs.listIsBullet !== void 0) attrs.listIsBullet = pmAttrs.listIsBullet;
+	if (pmAttrs.listMarkerHidden) attrs.listMarkerHidden = true;
+	if (attrs.listMarker !== void 0 || pmAttrs.listMarkerFormatting) {
+		const listMarkerFormatting = listMarkerFormattingFor(pmAttrs.listMarkerFormatting, paragraphMarkFormatting(), theme, fontAlternates);
+		if (listMarkerFormatting) attrs.listMarkerFormatting = listMarkerFormatting;
+	}
+	if (pmAttrs.listMarkerAlignment) attrs.listMarkerAlignment = pmAttrs.listMarkerAlignment;
+	if (pmAttrs.listMarkerSuffix) attrs.listMarkerSuffix = pmAttrs.listMarkerSuffix;
+	if (pmAttrs.listMarkerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = pmAttrs.listMarkerSecondSlotOffsetTwips;
+	if (!pmAttrs.numPr) {
+		const numberingRemovedChange = propertyChanges.find(isRemovedNumberingChange);
+		if (numberingRemovedChange) {
+			applyDeletedListMarkerAttrs(attrs, numberingRemovedChange, void 0, theme, fontAlternates, paragraphMarkFormatting);
+			if (resolvedMarker !== null) {
+				attrs.listMarker = resolvedMarker;
+				attrs.listMarkerRevision = toListMarkerRevision("del", numberingRemovedChange.info);
+			}
+		}
+	}
+	if (defaultTabStopTwips !== void 0) attrs.defaultTabStopTwips = defaultTabStopTwips;
+	const dtf = pmAttrs.defaultTextFormatting;
+	if (dtf) {
+		if (dtf.fontSize !== void 0) attrs.defaultFontSize = dtf.fontSize / 2;
+		if (attrs.listMarker !== void 0 && !attrs.listMarkerHidden && (attrs.bidi === true || dtf.rtl === true || dtf.cs === true) && dtf.fontSizeCs !== void 0 && (dtf.fontSize === void 0 || dtf.fontSizeCs > dtf.fontSize)) attrs.listParagraphMarkFontSize = dtf.fontSizeCs / 2;
+		if (dtf.fontFamily) {
+			const resolvedFamily = resolveWesternThemeFont(dtf.fontFamily, theme);
+			if (resolvedFamily) {
+				attrs.defaultFontFamily = resolvedFamily;
+				const alternate = getFontAlternate(resolvedFamily, fontAlternates);
+				if (alternate) attrs.defaultAlternateFontFamily = alternate;
+			}
+		}
+	}
+	return attrs;
+}
+/**
+* Every `ST_TabJc` member, and the layout engine's name for it.
+*
+* The engine's `start` and `end` are its names for the left and right edges of
+* the line, not direction-aware ones, so `w:tab w:val="left"` maps to `start`
+* unconditionally. `ST_TabJc`'s own `start` and `end` *are* direction-aware
+* and stay unresolved here, under names the engine has no member for.
+* `num`, the tab a numbered paragraph's text hangs from, has no engine
+* alignment of its own and falls back to the line's start edge.
+*/
+const TAB_ALIGNMENT_BY_TAB_STOP_ALIGNMENT = {
+	start: "logicalStart",
+	end: "logicalEnd",
+	num: "logicalStart",
+	left: "start",
+	right: "end",
+	center: "center",
+	decimal: "decimal",
+	bar: "bar",
+	clear: "clear"
+};
+/** Resolve a logical tab alignment against the direction the paragraph runs in. */
+const resolveTabAlignment = (alignment, rightToLeft) => {
+	const mapped = TAB_ALIGNMENT_BY_TAB_STOP_ALIGNMENT[alignment];
+	switch (mapped) {
+		case "logicalStart": return rightToLeft ? "end" : "start";
+		case "logicalEnd": return rightToLeft ? "start" : "end";
+		default: return mapped;
+	}
+};
+//#endregion
+export { convertParagraphAttrs };

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

@@ -0,0 +1,12 @@
+import { ParagraphAttrs } from "../../prosemirror/schema/nodes.js";
+import { ParagraphAttrs as ParagraphAttrs$1, ParagraphBlock } from "../../layout-engine/types.js";
+import { FlowConversionOptions } from "./flowConversionShared.js";
+import { PageBreakRunProjection } from "./paragraphRuns.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/paragraphConversion.d.ts
+declare function hasVisibleParagraphPayload(attrs: ParagraphAttrs$1): boolean;
+/** Whether any `w:pBdr` side draws a rule (`none`/`nil` sides draw nothing). */
+declare function drawsParagraphBorder(borders: ParagraphAttrs["borders"]): boolean;
+declare function convertParagraph(node: Node, startPos: number, options: FlowConversionOptions, pageBreaks?: PageBreakRunProjection[]): ParagraphBlock;
+//#endregion
+export { convertParagraph, drawsParagraphBorder, hasVisibleParagraphPayload };

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

@@ -0,0 +1,112 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { setParagraphFrame } from "../../layout-engine/paragraphFrame.js";
+import { expectParagraphAttrs } from "../../prosemirror/attrs/index.js";
+import { expectTextBoxAnchorAttrs } from "../../prosemirror/textBoxAnchorAttrs.js";
+import { nextBlockId, twipsToPixels } from "./flowConversionShared.js";
+import { convertParagraphAttrs } from "./paragraphAttrs.js";
+import { resolveParagraphMarkFormatting, resolveParagraphMarkOwnFormatting } from "./paragraphMarkFormatting.js";
+import { paragraphToRuns } from "./paragraphRuns.js";
+import { resolveWesternThemeFont } from "./textFormattingConversion.js";
+import { panic } from "better-result";
+import { statesNoBorder } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/paragraphConversion.ts
+const DETACHED_WATERMARK_HOST_ATTR = "_detachedWatermarkHost";
+const expectDetachedWatermarkHostAttr = (attrs) => {
+	const value = Reflect.get(attrs, DETACHED_WATERMARK_HOST_ATTR);
+	if (value === null || value === void 0) return false;
+	if (typeof value !== "boolean") panic("Invalid ProseMirror detached watermark host attrs:\nparagraph.attrs._detachedWatermarkHost: Expected a boolean.");
+	return value;
+};
+/**
+* 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 hasOnlyHiddenTextRuns(runs) {
+	return runs.length > 0 && runs.every((run) => run.kind === "text" && run.hidden === true);
+}
+function hasVisibleParagraphPayload(attrs) {
+	return attrs.listMarker !== void 0 && !attrs.listMarkerHidden || attrs.borders?.top !== void 0 || attrs.borders?.bottom !== void 0 || attrs.borders?.left !== void 0 || attrs.borders?.right !== void 0 || attrs.borders?.between !== void 0 || attrs.borders?.bar !== void 0 || attrs.shading !== void 0;
+}
+/** Whether any `w:pBdr` side draws a rule (`none`/`nil` sides draw nothing). */
+function drawsParagraphBorder(borders) {
+	if (!borders) return false;
+	return [
+		borders.top,
+		borders.bottom,
+		borders.left,
+		borders.right,
+		borders.between,
+		borders.bar
+	].some((border) => border?.style !== void 0 && !statesNoBorder(border.style));
+}
+function convertParagraph(node, startPos, options, pageBreaks) {
+	const pmAttrs = expectParagraphAttrs(node);
+	const runs = paragraphToRuns(node, startPos, options, pageBreaks);
+	const attrs = convertParagraphAttrs(pmAttrs, {
+		theme: options.theme,
+		fontAlternates: options.fontAlternates,
+		listCounterStreams: options.listCounterStreams,
+		defaultTabStopTwips: options.defaultTabStopTwips,
+		paragraphMarkFormatting: () => resolveParagraphMarkFormatting(pmAttrs, options.styleResolver)
+	});
+	if (options.numberingTabIgnoresIndent && attrs.listMarker !== void 0) attrs.listNumberingTabIgnoresIndent = true;
+	if (options.defaultFont !== void 0) attrs.defaultFontFamily ??= options.defaultFont;
+	if (options.defaultSize !== void 0) attrs.defaultFontSize ??= options.defaultSize;
+	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 || hasOnlyVisuallyEmptyTextRuns(runs)) {
+		if (pmAttrs._originalFormatting && Object.entries(pmAttrs._originalFormatting).some(([key, value]) => key !== "runProperties" && value !== void 0 && value !== null)) attrs.hasDirectParagraphFormatting = true;
+		const directParagraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
+		if (directParagraphMarkFormatting && Object.values(directParagraphMarkFormatting).some((value) => value !== void 0 && value !== null)) attrs.hasDirectParagraphMarkFormatting = true;
+		const paragraphMarkFormatting = resolveParagraphMarkOwnFormatting(directParagraphMarkFormatting, options.styleResolver);
+		if (paragraphMarkFormatting?.fontSize !== void 0) attrs.defaultFontSize = paragraphMarkFormatting.fontSize / 2;
+		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily ? resolveWesternThemeFont(paragraphMarkFormatting.fontFamily, options.theme) : void 0;
+		if (paragraphMarkFontFamily) {
+			attrs.defaultFontFamily = paragraphMarkFontFamily;
+			const alternate = getFontAlternate(paragraphMarkFontFamily, options.fontAlternates);
+			if (alternate) attrs.defaultAlternateFontFamily = alternate;
+		}
+	}
+	const isFullyHiddenParagraph = defaultTextFormatting?.hidden === true && (runs.length === 0 || hasOnlyHiddenTextRuns(runs));
+	if (isFullyHiddenParagraph && attrs.listMarker !== void 0) attrs.listMarkerHidden = true;
+	if (isFullyHiddenParagraph) attrs.suppressEmptyParagraphHeight = true;
+	if (runs.length === 0 && expectDetachedWatermarkHostAttr(node.attrs)) attrs.suppressEmptyParagraphHeight = false;
+	if (runs.length === 0 && pmAttrs._pageBreakCarrier === true && !hasVisibleParagraphPayload(attrs)) attrs.suppressEmptyParagraphHeight = true;
+	const bookmarkNames = pmAttrs.bookmarks?.map((b) => b.name);
+	const block = {
+		kind: "paragraph",
+		id: nextBlockId(),
+		runs,
+		attrs,
+		...pmAttrs.paraId ? { paraId: pmAttrs.paraId } : {},
+		...bookmarkNames && bookmarkNames.length > 0 ? { bookmarks: bookmarkNames } : {},
+		pmStart: startPos,
+		pmEnd: startPos + node.nodeSize
+	};
+	const frame = pmAttrs._originalFormatting?.frame;
+	if (frame !== void 0 && frame.dropCap !== "drop" && frame.dropCap !== "margin") setParagraphFrame(block, {
+		...frame.width !== void 0 ? { width: twipsToPixels(frame.width) } : {},
+		...frame.height !== void 0 ? { height: twipsToPixels(frame.height) } : {},
+		...frame.hSpace !== void 0 ? { hSpace: twipsToPixels(frame.hSpace) } : {},
+		...frame.vSpace !== void 0 ? { vSpace: twipsToPixels(frame.vSpace) } : {},
+		...frame.hAnchor !== void 0 ? { hAnchor: frame.hAnchor } : {},
+		...frame.vAnchor !== void 0 ? { vAnchor: frame.vAnchor } : {},
+		...frame.x !== void 0 ? { x: twipsToPixels(frame.x) } : {},
+		...frame.y !== void 0 ? { y: twipsToPixels(frame.y) } : {},
+		...frame.xAlign !== void 0 ? { xAlign: frame.xAlign } : {},
+		...frame.yAlign !== void 0 ? { yAlign: frame.yAlign } : {},
+		...frame.wrap !== void 0 ? { wrap: frame.wrap } : {}
+	});
+	node.descendants((child) => {
+		if (child.type.name !== "textBoxAnchor") return true;
+		options.textBoxAnchorBlockIds.set(expectTextBoxAnchorAttrs(child).anchorId, block.id);
+		return false;
+	});
+	return block;
+}
+//#endregion
+export { convertParagraph, drawsParagraphBorder, hasVisibleParagraphPayload };

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

@@ -0,0 +1,15 @@
+import { Run, RunFormatting } from "../../layout-engine/types.js";
+import { FlowConversionOptions } from "./flowConversionShared.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/paragraphRuns.d.ts
+/**
+ * Convert a paragraph node to runs.
+ */
+type PageBreakRunProjection = {
+  pmStart: number;
+  pmEnd: number;
+  trackedChange?: Pick<RunFormatting, "isInsertion" | "changeAuthor" | "changeDate" | "changeRevisionId" | "isSuggestion" | "suggestionId">;
+};
+declare function paragraphToRuns(node: Node, startPos: number, _options: FlowConversionOptions, pageBreaks?: PageBreakRunProjection[]): Run[];
+//#endregion
+export { PageBreakRunProjection, paragraphToRuns };

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

@@ -0,0 +1,281 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { expectFieldAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "../../prosemirror/attrs/index.js";
+import { decodeOoxmlSymbolCharacter } from "../../utils/ooxmlSymbol.js";
+import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
+import { buildImageRun, constrainImageToPage, hasPaintableImageSource, hasRelationshipBackedImageBox } from "./imageConversion.js";
+import { isNoteReferenceMarkXml } from "./noteReferences.js";
+import { applyCharacterStyleToggleFormatting, markDefaultBlackTextColorSource, mergeRunFormatting } from "./runFormattingMerge.js";
+import { extractRunFormatting } from "./runMarkFormatting.js";
+import { paragraphRunDefaults } from "./textFormattingConversion.js";
+//#region src/layout-bridge/convert/paragraphRuns.ts
+/**
+* In TOC paragraphs, strip the resolved Hyperlink character-style colour and
+* underline so the painter's link fallback doesn't fire. The PM doc keeps the
+* original marks so copy/paste out of a TOC still carries the Hyperlink
+* styling like Word does. Applies to both text and field runs — a TOC entry's
+* page number is a PAGEREF field inside the entry's hyperlink.
+*
+* Mutates `formatting` in place; cheaper than re-cloning per run.
+*/
+function stripTocHyperlinkStyle(formatting) {
+	if (!formatting.hyperlink) return;
+	formatting.hyperlink.noDefaultStyle = true;
+	delete formatting.color;
+	delete formatting.underline;
+}
+const isTrackedRunMark = ({ type }) => type.name === "insertion" || type.name === "deletion";
+/**
+* Inline wrappers own marks that apply to every projected descendant. A
+* descendant's mark of the same type is more specific, and any descendant
+* revision replaces (rather than combines with) an inherited revision.
+*/
+const mergeProjectedInlineMarks = (inheritedMarks, ownMarks) => {
+	if (inheritedMarks.length === 0) return ownMarks;
+	const ownMarkTypes = new Set(ownMarks.map(({ type }) => type));
+	const hasOwnTrackedMark = ownMarks.some(isTrackedRunMark);
+	return [...inheritedMarks.filter((mark) => !ownMarkTypes.has(mark.type) && !(hasOwnTrackedMark && isTrackedRunMark(mark))), ...ownMarks];
+};
+function paragraphToRuns(node, startPos, _options, pageBreaks) {
+	const runs = [];
+	const offset = startPos + 1;
+	const theme = _options.theme;
+	const fontAlternates = _options.fontAlternates;
+	const pmAttrs = expectParagraphAttrs(node);
+	const paraDefaults = paragraphRunDefaults(pmAttrs, theme, fontAlternates);
+	const paragraphStyleId = pmAttrs.styleId;
+	const inTocParagraph = pmAttrs._tableOfContentsLevel !== void 0 || tableOfContentsStyleLevel({ styleId: paragraphStyleId }) !== void 0;
+	let leadingRenderedPageBreakPending = pmAttrs.renderedPageBreakBefore === true;
+	function pushRunsForChild(child, childPos, inheritedMarks = []) {
+		if (child.type.name === "bookmarkBoundary") return;
+		if (child.type.name === "renderedPageBreak") {
+			if (leadingRenderedPageBreakPending) {
+				leadingRenderedPageBreakPending = false;
+				return;
+			}
+			runs.push({
+				kind: "renderedPageBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		const effectiveMarks = mergeProjectedInlineMarks(inheritedMarks, child.marks);
+		if (child.type.name === "pageBreakRun") {
+			const trackedChange = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			if (trackedChange.isDeletion) {
+				runs.push({
+					kind: "text",
+					text: "",
+					isDeletion: true,
+					...trackedChange.changeAuthor !== void 0 ? { changeAuthor: trackedChange.changeAuthor } : {},
+					...trackedChange.changeDate !== void 0 ? { changeDate: trackedChange.changeDate } : {},
+					...trackedChange.changeRevisionId !== void 0 ? { changeRevisionId: trackedChange.changeRevisionId } : {},
+					...trackedChange.isSuggestion === true ? { isSuggestion: true } : {},
+					...trackedChange.suggestionId !== void 0 ? { suggestionId: trackedChange.suggestionId } : {},
+					pmStart: childPos,
+					pmEnd: childPos + child.nodeSize
+				});
+				return;
+			}
+			pageBreaks?.push({
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize,
+				...trackedChange.isInsertion ? { trackedChange: {
+					isInsertion: true,
+					...trackedChange.changeAuthor !== void 0 ? { changeAuthor: trackedChange.changeAuthor } : {},
+					...trackedChange.changeDate !== void 0 ? { changeDate: trackedChange.changeDate } : {},
+					...trackedChange.changeRevisionId !== void 0 ? { changeRevisionId: trackedChange.changeRevisionId } : {},
+					...trackedChange.isSuggestion === true ? { isSuggestion: true } : {},
+					...trackedChange.suggestionId !== void 0 ? { suggestionId: trackedChange.suggestionId } : {}
+				} } : {}
+			});
+			return;
+		}
+		if (child.type.name !== "sdt") leadingRenderedPageBreakPending = false;
+		if (child.isText && child.text) {
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
+			const run = {
+				kind: "text",
+				text: child.text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "symbol") {
+			const attrs = expectSymbolAttrs(child);
+			const text = decodeOoxmlSymbolCharacter(attrs.char);
+			if (text === null) return;
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
+			const alternateFontFamily = getFontAlternate(attrs.font, fontAlternates);
+			formatting.fontFamily = attrs.font;
+			if (alternateFontFamily) formatting.alternateFontFamily = alternateFontFamily;
+			runs.push({
+				kind: "text",
+				text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "preservedXml") {
+			const { xml, text: capturedText } = expectPreservedXmlAttrs(child);
+			const text = capturedText === "" && _options.noteReferenceMarkText !== void 0 && isNoteReferenceMarkXml(xml) ? _options.noteReferenceMarkText : capturedText;
+			if (text === "") return;
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			runs.push({
+				kind: "text",
+				text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "hardBreak") {
+			runs.push({
+				kind: "lineBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "tab") {
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			const run = {
+				kind: "tab",
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "image") {
+			const attrs = expectImageAttrs(child);
+			if (!hasPaintableImageSource(attrs) && !hasRelationshipBackedImageBox(attrs)) return;
+			const constrained = constrainImageToPage(attrs.width ?? 100, attrs.height ?? 100, _options.pageContentHeight);
+			const trackedFmt = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			const run = buildImageRun(attrs, constrained, childPos, childPos + child.nodeSize, trackedFmt, _options.forceAnchorLayoutInCell);
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "structuredField") {
+			let containsPageBreak = false;
+			child.descendants((descendant) => {
+				if (descendant.type.name === "pageBreakRun") {
+					containsPageBreak = true;
+					return false;
+				}
+				return true;
+			});
+			if (containsPageBreak) {
+				const fieldContentStart = childPos + 1;
+				child.forEach((fieldChild, fieldChildOffset) => {
+					pushRunsForChild(fieldChild, fieldContentStart + fieldChildOffset, effectiveMarks);
+				});
+				return;
+			}
+		}
+		if (child.type.name === "field" || child.type.name === "structuredField") {
+			const attrs = expectFieldAttrs(child);
+			const ft = attrs.fieldType;
+			let mappedType = "OTHER";
+			if (ft === "PAGE") mappedType = "PAGE";
+			else if (ft === "NUMPAGES") mappedType = "NUMPAGES";
+			else if (ft === "DATE") mappedType = "DATE";
+			else if (ft === "TIME") mappedType = "TIME";
+			const extractedFieldFormatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting: extractedFieldFormatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(extractedFieldFormatting);
+			const fieldFormatting = markDefaultBlackTextColorSource(extractedFieldFormatting, paraDefaults);
+			const run = {
+				kind: "field",
+				fieldType: mappedType,
+				instruction: attrs.instruction,
+				fallback: _options.numberedRefResults?.get(child) ?? attrs.displayText ?? "",
+				...attrs.fldLock ? { fldLock: true } : {},
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize,
+				...fieldFormatting
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "math") {
+			const attrs = expectMathAttrs(child);
+			const plainText = attrs.plainText || "[equation]";
+			runs.push({
+				kind: "math",
+				display: attrs.display ?? "inline",
+				ommlXml: attrs.ommlXml,
+				plainText,
+				italic: true,
+				fontFamily: "Cambria Math",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "sdt") {
+			const sdtInnerOffset = childPos + 1;
+			child.forEach((sdtChild, sdtChildOffset) => {
+				pushRunsForChild(sdtChild, sdtInnerOffset + sdtChildOffset, effectiveMarks);
+			});
+		}
+	}
+	node.forEach((child, childOffset) => {
+		pushRunsForChild(child, offset + childOffset);
+	});
+	const { defaultFont, defaultSize } = _options;
+	if (defaultFont !== void 0 || defaultSize !== void 0) for (const run of runs) switch (run.kind) {
+		case "text":
+		case "tab":
+		case "renderedPageBreak":
+		case "field":
+		case "math":
+			if (defaultFont !== void 0) run.fontFamily ??= defaultFont;
+			if (defaultSize !== void 0) run.fontSize ??= defaultSize;
+			break;
+		case "image":
+		case "lineBreak": break;
+		default:
+	}
+	return runs;
+}
+//#endregion
+export { paragraphToRuns };