@stll/folio-core 0.48.0 → 0.50.0

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 };

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 };