@stll/folio-core 0.49.0 → 0.50.0

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

@@ -0,0 +1,118 @@
+import { expectImageAttrs } from "../../prosemirror/attrs/index.js";
+import { cssBorderStyleOf } from "../../utils/borderCss.js";
+import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
+import { nextBlockId } from "./flowConversionShared.js";
+//#region src/layout-bridge/convert/imageConversion.ts
+/**
+* Constrain image dimensions to fit within the page content area.
+* Scales proportionally if height exceeds pageContentHeight.
+*/
+function constrainImageToPage(width, height, pageContentHeight) {
+	if (!pageContentHeight || height <= pageContentHeight) return {
+		width,
+		height
+	};
+	const scale = pageContentHeight / height;
+	return {
+		width: Math.round(width * scale),
+		height: pageContentHeight
+	};
+}
+/**
+* Build an ImageRun from ProseMirror node attrs, applying conditional property assignment
+* to satisfy exactOptionalPropertyTypes.
+*/
+function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange, forceLayoutInCell) {
+	const run = {
+		kind: "image",
+		src: attrs.src,
+		...attrs.preview ? { preview: attrs.preview } : {},
+		width: constrained.width,
+		height: constrained.height,
+		pmStart,
+		pmEnd
+	};
+	if (attrs.alt !== void 0) run.alt = attrs.alt;
+	if (attrs.transform !== void 0) run.transform = attrs.transform;
+	if (attrs.opacity != null) run.opacity = attrs.opacity;
+	if (attrs.brightness != null) run.brightness = attrs.brightness;
+	if (attrs.contrast != null) run.contrast = attrs.contrast;
+	if (attrs.wrapType !== void 0) run.wrapType = attrs.wrapType;
+	if (attrs.displayMode !== void 0) run.displayMode = attrs.displayMode;
+	if (attrs.cssFloat !== void 0) run.cssFloat = attrs.cssFloat;
+	if (attrs.distTop !== void 0) run.distTop = attrs.distTop;
+	if (attrs.distBottom !== void 0) run.distBottom = attrs.distBottom;
+	if (attrs.distLeft !== void 0) run.distLeft = attrs.distLeft;
+	if (attrs.distRight !== void 0) run.distRight = attrs.distRight;
+	if (attrs._docxObjectPreview === true) run.exactLineHeight = true;
+	if (attrs.cropTop != null) run.cropTop = attrs.cropTop;
+	if (attrs.cropRight != null) run.cropRight = attrs.cropRight;
+	if (attrs.cropBottom != null) run.cropBottom = attrs.cropBottom;
+	if (attrs.cropLeft != null) run.cropLeft = attrs.cropLeft;
+	if (attrs.borderWidth != null) run.borderWidth = attrs.borderWidth;
+	if (attrs.borderColor) run.borderColor = attrs.borderColor;
+	const runBorderStyle = cssBorderStyleOf(attrs.borderStyle);
+	if (runBorderStyle) run.borderStyle = runBorderStyle;
+	if (attrs.position !== void 0) run.position = attrs.position;
+	if (forceLayoutInCell) run.layoutInCell = true;
+	else if (attrs.anchor?.layoutInCell !== void 0) run.layoutInCell = attrs.anchor.layoutInCell;
+	if (trackedChange?.isInsertion) run.isInsertion = true;
+	if (trackedChange?.isDeletion) run.isDeletion = true;
+	if (trackedChange?.changeAuthor !== void 0) run.changeAuthor = trackedChange.changeAuthor;
+	if (trackedChange?.changeDate !== void 0) run.changeDate = trackedChange.changeDate;
+	if (trackedChange?.changeRevisionId !== void 0) run.changeRevisionId = trackedChange.changeRevisionId;
+	return run;
+}
+/** A package image whose bytes cannot paint still owns its authored line box. */
+const hasRelationshipBackedImageBox = (attrs) => typeof attrs.rId === "string" && attrs.rId.trim().length > 0 && typeof attrs.width === "number" && Number.isFinite(attrs.width) && attrs.width >= 0 && typeof attrs.height === "number" && Number.isFinite(attrs.height) && attrs.height >= 0;
+/**
+* A preview counts as a source: the bytes are not in the attrs, but the
+* display list can produce them without I/O when it interns the descriptor.
+*/
+const hasPaintableImageSource = (attrs) => attrs.preview !== void 0 || sanitizeImageSrc(attrs.src) !== void 0;
+/**
+* Convert an image node to an ImageBlock.
+*/
+function convertImage(node, startPos, pageContentHeight) {
+	const attrs = expectImageAttrs(node);
+	if (!hasPaintableImageSource(attrs) && !hasRelationshipBackedImageBox(attrs)) return;
+	const wrapType = attrs.wrapType;
+	const shouldAnchor = wrapType === "behind" || wrapType === "inFront";
+	const constrained = constrainImageToPage(attrs.width ?? 100, attrs.height ?? 100, pageContentHeight);
+	const imgBlock = {
+		kind: "image",
+		id: nextBlockId(),
+		src: attrs.src,
+		...attrs.preview ? { preview: attrs.preview } : {},
+		width: constrained.width,
+		height: constrained.height,
+		pmStart: startPos,
+		pmEnd: startPos + node.nodeSize
+	};
+	if (attrs.alt) imgBlock.alt = attrs.alt;
+	if (attrs.transform) imgBlock.transform = attrs.transform;
+	if (attrs.opacity != null) imgBlock.opacity = attrs.opacity;
+	if (attrs.brightness != null) imgBlock.brightness = attrs.brightness;
+	if (attrs.contrast != null) imgBlock.contrast = attrs.contrast;
+	if (shouldAnchor) {
+		const anchor = {
+			isAnchored: true,
+			behindDoc: wrapType === "behind"
+		};
+		if (attrs.distLeft !== void 0) anchor.offsetH = attrs.distLeft;
+		if (attrs.distTop !== void 0) anchor.offsetV = attrs.distTop;
+		imgBlock.anchor = anchor;
+	}
+	if (attrs.hlinkHref) imgBlock.hlinkHref = attrs.hlinkHref;
+	if (attrs.cropTop != null) imgBlock.cropTop = attrs.cropTop;
+	if (attrs.cropRight != null) imgBlock.cropRight = attrs.cropRight;
+	if (attrs.cropBottom != null) imgBlock.cropBottom = attrs.cropBottom;
+	if (attrs.cropLeft != null) imgBlock.cropLeft = attrs.cropLeft;
+	if (attrs.borderWidth != null) imgBlock.borderWidth = attrs.borderWidth;
+	if (attrs.borderColor) imgBlock.borderColor = attrs.borderColor;
+	const imageBorderStyle = cssBorderStyleOf(attrs.borderStyle);
+	if (imageBorderStyle) imgBlock.borderStyle = imageBorderStyle;
+	return imgBlock;
+}
+//#endregion
+export { buildImageRun, constrainImageToPage, convertImage, hasPaintableImageSource, hasRelationshipBackedImageBox };

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

@@ -0,0 +1,28 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "../../prosemirror/schema/nodes.js";
+import { ParagraphAttrs as ParagraphAttrs$1 } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { ListCounterState } from "../../prosemirror/listMarker.js";
+//#region src/layout-bridge/convert/listMarkers.d.ts
+declare function applyMarkerAllCaps(marker: string | null, allCaps: boolean | undefined): string | null;
+/**
+ * Convert PM paragraph attrs to layout engine paragraph attrs.
+ */
+type ListMarkerRevision = NonNullable<ParagraphAttrs$1["listMarkerRevision"]>;
+type ListPropertyChange = ParagraphPropertyChangeAttrs;
+type ListPropertyFormatting = NonNullable<ListPropertyChange["previousFormatting"]>;
+declare function toListMarkerRevision(kind: ListMarkerRevision["kind"], info: ListPropertyChange["info"]): ListMarkerRevision;
+declare function isAddedNumberingChange(change: ListPropertyChange): change is ListPropertyChange & {
+  previousFormatting: ListPropertyFormatting;
+};
+declare function isRemovedNumberingChange(change: ListPropertyChange): change is ListPropertyChange & {
+  previousFormatting: ListPropertyFormatting;
+};
+declare function isChangedNumberingChange(currentNumPr: NonNullable<ParagraphAttrs["numPr"]>, change: ListPropertyChange): change is ListPropertyChange & {
+  previousFormatting: ListPropertyFormatting;
+};
+declare function applyDeletedListMarkerAttrs(attrs: ParagraphAttrs$1, change: ListPropertyChange & {
+  previousFormatting: ListPropertyFormatting;
+}, listCounterState: ListCounterState | undefined, theme: document_d_exports.Theme | null | undefined, fontAlternates: FontAlternates | undefined, paragraphMarkFormatting: () => document_d_exports.TextFormatting | undefined): void;
+//#endregion
+export { ListPropertyChange, ListPropertyFormatting, applyDeletedListMarkerAttrs, applyMarkerAllCaps, isAddedNumberingChange, isChangedNumberingChange, isRemovedNumberingChange, toListMarkerRevision };

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

@@ -0,0 +1,98 @@
+import { bulletMarkerFontName, convertBulletToUnicode } from "../../docx/bulletMarkers.js";
+import { isListNumPr } from "../../layout-engine/types.js";
+import { advanceListMarker } from "../../prosemirror/listMarker.js";
+import { listMarkerFormattingFor } from "./textFormattingConversion.js";
+import { sameStatedParagraphNumbering } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/listMarkers.ts
+/**
+* List-marker resolution for paragraphs, including tracked numbering changes
+* (inserted, removed, and changed list markers).
+*/
+function applyMarkerAllCaps(marker, allCaps) {
+	if (marker === null || !allCaps) return marker;
+	return marker.toLocaleUpperCase();
+}
+function computeListMarker(pmAttrs, state) {
+	return advanceListMarker(pmAttrs, state);
+}
+function toListMarkerRevision(kind, info) {
+	const revision = { kind };
+	if (typeof info?.author === "string") revision.author = info.author;
+	if (typeof info?.date === "string") revision.date = info.date;
+	if (typeof info?.id === "number") revision.revisionId = info.id;
+	return revision;
+}
+function isAddedNumberingChange(change) {
+	const previousFormatting = change.previousFormatting;
+	return previousFormatting != null && Object.hasOwn(previousFormatting, "numPr") && previousFormatting.numPr == null;
+}
+function isRemovedNumberingChange(change) {
+	const previousFormatting = change.previousFormatting;
+	return previousFormatting != null && Object.hasOwn(previousFormatting, "numPr") && isListNumPr(previousFormatting.numPr);
+}
+function isChangedNumberingChange(currentNumPr, change) {
+	const previousFormatting = change.previousFormatting;
+	return previousFormatting != null && Object.hasOwn(previousFormatting, "numPr") && isListNumPr(previousFormatting.numPr) && !sameStatedParagraphNumbering(previousFormatting.numPr, currentNumPr);
+}
+function toPreviousListAttrs(previousFormatting) {
+	const attrs = {};
+	const numPr = previousFormatting.numPr;
+	if (isListNumPr(numPr)) attrs.numPr = numPr;
+	const listIsBullet = previousFormatting.listIsBullet;
+	if (listIsBullet !== void 0) attrs.listIsBullet = listIsBullet;
+	const listIsLegal = previousFormatting.listIsLegal;
+	if (listIsLegal !== void 0) attrs.listIsLegal = listIsLegal;
+	const listMarker = previousFormatting.listMarker;
+	if (listMarker !== void 0) attrs.listMarker = listMarker;
+	const listMarkerTemplate = previousFormatting.listMarkerTemplate;
+	if (listMarkerTemplate !== void 0) attrs.listMarkerTemplate = listMarkerTemplate;
+	const listNumFmt = previousFormatting.listNumFmt;
+	if (listNumFmt !== void 0) attrs.listNumFmt = listNumFmt;
+	const listLevelNumFmts = previousFormatting.listLevelNumFmts;
+	if (listLevelNumFmts !== void 0) attrs.listLevelNumFmts = listLevelNumFmts;
+	const listLevelStarts = previousFormatting.listLevelStarts;
+	if (listLevelStarts !== void 0) attrs.listLevelStarts = listLevelStarts;
+	const listAbstractNumId = previousFormatting.listAbstractNumId;
+	if (listAbstractNumId !== void 0) attrs.listAbstractNumId = listAbstractNumId;
+	const listStartOverride = previousFormatting.listStartOverride;
+	if (listStartOverride !== void 0) attrs.listStartOverride = listStartOverride;
+	const listMarkerHidden = previousFormatting.listMarkerHidden;
+	if (listMarkerHidden !== void 0) attrs.listMarkerHidden = listMarkerHidden;
+	const listMarkerFormatting = previousFormatting.listMarkerFormatting;
+	if (listMarkerFormatting !== void 0) attrs.listMarkerFormatting = listMarkerFormatting;
+	const listMarkerAlignment = previousFormatting.listMarkerAlignment;
+	if (listMarkerAlignment !== void 0) attrs.listMarkerAlignment = listMarkerAlignment;
+	const listMarkerSuffix = previousFormatting.listMarkerSuffix;
+	if (listMarkerSuffix !== void 0) attrs.listMarkerSuffix = listMarkerSuffix;
+	const listMarkerAllCaps = previousFormatting.listMarkerAllCaps;
+	if (listMarkerAllCaps !== void 0) attrs.listMarkerAllCaps = listMarkerAllCaps;
+	const listImplicitChildLevelAdvances = previousFormatting.listImplicitChildLevelAdvances;
+	if (listImplicitChildLevelAdvances !== void 0) attrs.listImplicitChildLevelAdvances = listImplicitChildLevelAdvances;
+	const listMarkerSecondSlotOffsetTwips = previousFormatting.listMarkerSecondSlotOffsetTwips;
+	if (listMarkerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = listMarkerSecondSlotOffsetTwips;
+	return attrs;
+}
+function resolveDeletedListMarker(previousListAttrs, listCounterState) {
+	if (listCounterState && previousListAttrs.numPr) {
+		const marker = computeListMarker(previousListAttrs, listCounterState);
+		if (marker) return marker;
+	}
+	if (previousListAttrs.listMarker) return previousListAttrs.listIsBullet ? convertBulletToUnicode(previousListAttrs.listMarker, bulletMarkerFontName(previousListAttrs.listMarkerFormatting)) : previousListAttrs.listMarker;
+	if (previousListAttrs.listIsBullet) return "•";
+	return null;
+}
+function applyDeletedListMarkerAttrs(attrs, change, listCounterState, theme, fontAlternates, paragraphMarkFormatting) {
+	const previousListAttrs = toPreviousListAttrs(change.previousFormatting);
+	const marker = resolveDeletedListMarker(previousListAttrs, listCounterState);
+	if (!marker) return;
+	attrs.listMarker = marker;
+	attrs.listMarkerRevision = toListMarkerRevision("del", change.info);
+	if (previousListAttrs.listIsBullet !== void 0) attrs.listIsBullet = previousListAttrs.listIsBullet;
+	if (previousListAttrs.listMarkerHidden !== void 0) attrs.listMarkerHidden = previousListAttrs.listMarkerHidden;
+	const listMarkerFormatting = listMarkerFormattingFor(previousListAttrs.listMarkerFormatting, paragraphMarkFormatting(), theme, fontAlternates);
+	if (listMarkerFormatting) attrs.listMarkerFormatting = listMarkerFormatting;
+	if (previousListAttrs.listMarkerAlignment) attrs.listMarkerAlignment = previousListAttrs.listMarkerAlignment;
+	if (previousListAttrs.listMarkerSuffix) attrs.listMarkerSuffix = previousListAttrs.listMarkerSuffix;
+}
+//#endregion
+export { applyDeletedListMarkerAttrs, applyMarkerAllCaps, isAddedNumberingChange, isChangedNumberingChange, isRemovedNumberingChange, toListMarkerRevision };

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

@@ -0,0 +1,14 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+//#region src/layout-bridge/convert/noteReferences.d.ts
+/**
+ * Runs with `idKey` set, in document order: the note references a block list
+ * makes, through table cells (and tables within cells) and text boxes.
+ */
+declare function collectNoteRefs(blocks: readonly FlowBlock[], idKey: "footnoteRefId" | "endnoteRefId"): {
+  noteId: number;
+  pmPos: number;
+}[];
+/** Whether captured run-child markup is a note story's `w:footnoteRef`/`w:endnoteRef`. */
+declare function isNoteReferenceMarkXml(xml: string): boolean;
+//#endregion
+export { collectNoteRefs, isNoteReferenceMarkXml };

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

@@ -0,0 +1,29 @@
+//#region src/layout-bridge/convert/noteReferences.ts
+const NOTE_REFERENCE_MARK_XML = /^<(?:[^\s:/>]+:)?(?:footnoteRef|endnoteRef)[\s/>]/u;
+/**
+* Runs with `idKey` set, in document order: the note references a block list
+* makes, through table cells (and tables within cells) and text boxes.
+*/
+function collectNoteRefs(blocks, idKey) {
+	const refs = [];
+	const walk = (containerBlocks) => {
+		for (const block of containerBlocks) if (block.kind === "paragraph") for (const run of block.runs) {
+			if (run.kind !== "text") continue;
+			const noteId = run[idKey];
+			if (noteId !== void 0) refs.push({
+				noteId,
+				pmPos: run.pmStart ?? 0
+			});
+		}
+		else if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) walk(cell.blocks);
+		else if (block.kind === "textBox") walk(block.content);
+	};
+	walk(blocks);
+	return refs;
+}
+/** Whether captured run-child markup is a note story's `w:footnoteRef`/`w:endnoteRef`. */
+function isNoteReferenceMarkXml(xml) {
+	return NOTE_REFERENCE_MARK_XML.test(xml);
+}
+//#endregion
+export { collectNoteRefs, isNoteReferenceMarkXml };

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

@@ -0,0 +1,16 @@
+import { PageBreakBlock, ParagraphBlock, Run } from "../../layout-engine/types.js";
+import { PageBreakRunProjection } from "./paragraphRuns.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/pageBreakSplitting.d.ts
+type SplitParagraphAtPageBreaksOptions = {
+  pageBreaks: readonly PageBreakRunProjection[];
+  paragraph: ParagraphBlock;
+  splitPageBreakAndParagraphMark: boolean;
+};
+/** Every page-break run under a node, nested tables and text boxes included. */
+declare const countPageBreakRuns: (node: Node) => number;
+/** Decide leading-break eligibility from the exact projected runs consumed by layout. */
+declare const hasSingleLeadingProjectedPageBreak: (runs: readonly Run[], pageBreaks: readonly PageBreakRunProjection[]) => boolean;
+declare function splitParagraphAtPageBreaks({ pageBreaks, paragraph, splitPageBreakAndParagraphMark }: SplitParagraphAtPageBreaksOptions): (ParagraphBlock | PageBreakBlock)[];
+//#endregion
+export { countPageBreakRuns, hasSingleLeadingProjectedPageBreak, splitParagraphAtPageBreaks };

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

@@ -0,0 +1,140 @@
+import { partitionRunsAtPageBreaks } from "../../internal/pageBreakRunPartition.js";
+import { nextBlockId } from "./flowConversionShared.js";
+import { hasVisibleParagraphPayload } from "./paragraphConversion.js";
+import { panic } from "better-result";
+//#region src/layout-bridge/convert/pageBreakSplitting.ts
+function paragraphFragmentAttrs(source, index, count) {
+	if (!source) return;
+	const attrs = {
+		...source,
+		...source.indent ? { indent: { ...source.indent } } : {},
+		...source.spacing ? { spacing: { ...source.spacing } } : {},
+		...source.automaticSpacing ? { automaticSpacing: { ...source.automaticSpacing } } : {},
+		...source.spacingExplicit ? { spacingExplicit: { ...source.spacingExplicit } } : {}
+	};
+	if (index > 0) {
+		delete attrs.listMarker;
+		delete attrs.listIsBullet;
+		delete attrs.listMarkerFormatting;
+		delete attrs.listMarkerHidden;
+		delete attrs.listMarkerAlignment;
+		delete attrs.listMarkerSuffix;
+		delete attrs.listMarkerRevision;
+		delete attrs.listMarkerSecondSlotOffsetTwips;
+		delete attrs.reserveEmptyOutlineHeight;
+		delete attrs.pageBreakBefore;
+		delete attrs.renderedPageBreakBefore;
+		if (attrs.indent) {
+			delete attrs.indent.firstLine;
+			delete attrs.indent.hanging;
+		}
+		if (attrs.spacing) delete attrs.spacing.before;
+		if (attrs.automaticSpacing) delete attrs.automaticSpacing.before;
+		if (attrs.spacingExplicit) delete attrs.spacingExplicit.before;
+	}
+	if (index < count - 1) {
+		delete attrs.keepNext;
+		delete attrs.runInWithNext;
+		delete attrs.listParagraphMarkFontSize;
+		if (attrs.spacing) delete attrs.spacing.after;
+		if (attrs.automaticSpacing) delete attrs.automaticSpacing.after;
+		if (attrs.spacingExplicit) delete attrs.spacingExplicit.after;
+	}
+	return attrs;
+}
+const runIsZeroWidthBoundaryMarker = (run) => {
+	switch (run.kind) {
+		case "text": return run.text.length === 0;
+		case "field": return (run.fallback ?? "").length === 0;
+		case "renderedPageBreak": return true;
+		case "image":
+		case "lineBreak":
+		case "math":
+		case "tab": return false;
+		default: return run;
+	}
+};
+/** Every page-break run under a node, nested tables and text boxes included. */
+const countPageBreakRuns = (node) => {
+	let count = node.type.name === "pageBreakRun" ? 1 : 0;
+	node.descendants((descendant) => {
+		if (descendant.type.name === "pageBreakRun") count += 1;
+		return true;
+	});
+	return count;
+};
+/** Decide leading-break eligibility from the exact projected runs consumed by layout. */
+const hasSingleLeadingProjectedPageBreak = (runs, pageBreaks) => {
+	if (pageBreaks.length !== 1) return false;
+	const partitioned = partitionRunsAtPageBreaks(runs, pageBreaks);
+	if (partitioned.type === "overlap") return false;
+	return partitioned.partitions[0]?.before.every(runIsZeroWidthBoundaryMarker) === true;
+};
+function splitParagraphAtPageBreaks({ pageBreaks, paragraph, splitPageBreakAndParagraphMark }) {
+	if (pageBreaks.length === 0) return [paragraph];
+	const result = [];
+	let fragmentStart = paragraph.pmStart ?? pageBreaks[0].pmStart;
+	let emittedParagraph = false;
+	const appendParagraph = (runs, pmStart, pmEnd) => {
+		const fragment = {
+			...paragraph,
+			id: emittedParagraph ? nextBlockId() : paragraph.id,
+			runs,
+			pmStart,
+			pmEnd
+		};
+		if (emittedParagraph) delete fragment.bookmarks;
+		result.push(fragment);
+		emittedParagraph = true;
+	};
+	const partitioned = partitionRunsAtPageBreaks(paragraph.runs, pageBreaks);
+	if (partitioned.type === "overlap") panic("An inline layout run overlaps an explicit page-break carrier");
+	for (const { before, pageBreak } of partitioned.partitions) {
+		if (before.length > 0) appendParagraph(before, fragmentStart, pageBreak.pmStart);
+		result.push({
+			kind: "pageBreak",
+			id: nextBlockId(),
+			pmStart: pageBreak.pmStart,
+			pmEnd: pageBreak.pmEnd,
+			...pageBreak.trackedChange
+		});
+		fragmentStart = pageBreak.pmEnd;
+	}
+	const remainingRuns = partitioned.remaining;
+	let paragraphMarkCarrier;
+	if (remainingRuns.length > 0) appendParagraph(remainingRuns, fragmentStart, paragraph.pmEnd ?? fragmentStart);
+	else if (paragraph.runs.length === 0 || splitPageBreakAndParagraphMark && pageBreaks.at(-1)?.pmEnd === (paragraph.pmEnd ?? fragmentStart) - 1) {
+		appendParagraph([], fragmentStart, paragraph.pmEnd ?? fragmentStart);
+		const carrier = result.at(-1);
+		if (carrier?.kind === "paragraph" && !splitPageBreakAndParagraphMark && !hasVisibleParagraphPayload(carrier.attrs ?? {})) {
+			carrier.attrs = {
+				...carrier.attrs,
+				suppressEmptyParagraphHeight: true
+			};
+			paragraphMarkCarrier = carrier;
+		}
+	}
+	const fragments = result.filter((block) => block.kind === "paragraph");
+	for (let index = 0; index < fragments.length; index += 1) {
+		const fragment = fragments[index];
+		if (!fragment) continue;
+		const attrs = paragraphFragmentAttrs(fragment.attrs, index, fragments.length);
+		if (attrs) fragment.attrs = attrs;
+		else delete fragment.attrs;
+	}
+	if (paragraphMarkCarrier?.attrs) paragraphMarkCarrier.attrs = withoutParagraphSpacing(paragraphMarkCarrier.attrs);
+	return result;
+}
+function withoutParagraphSpacing(source) {
+	const attrs = { ...source };
+	if (attrs.spacing) {
+		const { before: _before, after: _after, ...lineSpacing } = attrs.spacing;
+		if (Object.keys(lineSpacing).length > 0) attrs.spacing = lineSpacing;
+		else delete attrs.spacing;
+	}
+	delete attrs.automaticSpacing;
+	delete attrs.spacingExplicit;
+	return attrs;
+}
+//#endregion
+export { countPageBreakRuns, hasSingleLeadingProjectedPageBreak, splitParagraphAtPageBreaks };

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

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs } from "../../prosemirror/schema/nodes.js";
+import { ParagraphAttrs as ParagraphAttrs$1 } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { ListCounterStreams } from "../../prosemirror/listMarker.js";
+//#region src/layout-bridge/convert/paragraphAttrs.d.ts
+type ConvertParagraphAttrsOptions = {
+  theme: document_d_exports.Theme | null | undefined;
+  fontAlternates: FontAlternates | undefined;
+  listCounterStreams: ListCounterStreams;
+  defaultTabStopTwips: number | undefined;
+  /**
+   * Resolved paragraph-mark run properties, the base of the list marker's
+   * typography. Lazy: only paragraphs that paint a marker resolve them.
+   */
+  paragraphMarkFormatting: () => document_d_exports.TextFormatting | undefined;
+};
+declare function convertParagraphAttrs(pmAttrs: ParagraphAttrs, { theme, fontAlternates, listCounterStreams, defaultTabStopTwips, paragraphMarkFormatting }: ConvertParagraphAttrsOptions): ParagraphAttrs$1;
+//#endregion
+export { convertParagraphAttrs };