@stll/folio-core 0.48.0 → 0.50.0

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

@@ -0,0 +1,106 @@
+import { headingLevelOf } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/flowBlockPostprocessing.ts
+/**
+* Post-conversion passes over the flow block list: terminal empty-paragraph
+* suppression, leading empty outline reservation, and run-in paragraph
+* merging.
+*/
+/**
+* Word keeps a final empty body paragraph after a table as an editable anchor,
+* but that final anchor does not create a page of its own. Earlier authored
+* empty paragraphs retain their height and may carry the document onto a blank
+* page. Preserve every block and PM range while collapsing only the final one.
+*/
+function isPaintlessTerminalParagraph(block) {
+	if (block?.kind !== "paragraph" || block.runs.length !== 0) return false;
+	const attrs = block.attrs;
+	if (attrs?.suppressEmptyParagraphHeight === false) return false;
+	return !(attrs?.listMarker !== void 0 && !attrs.listMarkerHidden || attrs?.borders?.top || attrs?.borders?.bottom || attrs?.borders?.left || attrs?.borders?.right || attrs?.borders?.between || attrs?.borders?.bar || attrs?.shading || attrs?.spacingExplicit?.before || attrs?.spacingExplicit?.after || attrs?.pageBreakBefore || attrs?.renderedPageBreakBefore);
+}
+function suppressFinalEmptyParagraphAfterTable(blocks) {
+	let suffixStart = blocks.length;
+	while (suffixStart > 0 && isPaintlessTerminalParagraph(blocks[suffixStart - 1])) suffixStart -= 1;
+	if (suffixStart === blocks.length || suffixStart === 0 || blocks[suffixStart - 1]?.kind !== "table") return;
+	const finalBlock = blocks.at(-1);
+	if (isPaintlessTerminalParagraph(finalBlock)) finalBlock.attrs = {
+		...finalBlock.attrs,
+		suppressEmptyParagraphHeight: true
+	};
+}
+function suppressFinalParagraphInRepeatedEmptySuffix(blocks) {
+	let suffixStart = blocks.length;
+	while (suffixStart > 0 && isPaintlessTerminalParagraph(blocks[suffixStart - 1])) suffixStart -= 1;
+	if (suffixStart === 0 || blocks.length - suffixStart < 2 || blocks[suffixStart - 1]?.kind === "table") return;
+	const finalBlock = blocks.at(-1);
+	if (isPaintlessTerminalParagraph(finalBlock)) finalBlock.attrs = {
+		...finalBlock.attrs,
+		suppressEmptyParagraphHeight: true
+	};
+}
+function reserveLeadingEmptyOutlineHeight(blocks) {
+	const firstBlock = blocks.at(0);
+	if (firstBlock?.kind !== "paragraph" || firstBlock.runs.length !== 0 || headingLevelOf(firstBlock.attrs?.outlineLevel) !== 0) return;
+	firstBlock.attrs = {
+		...firstBlock.attrs,
+		reserveEmptyOutlineHeight: true
+	};
+}
+/**
+* Merge consecutive paragraph blocks where the first carries
+* `runInWithNext` (`<w:specVanish/>` on the paragraph mark).
+*
+* Word's run-in heading feature renders the next paragraph inline on
+* the same line, so for layout we collapse the pair into one
+* ParagraphBlock with combined runs. The merged block keeps the first
+* paragraph's attrs (heading formatting, list marker, indent) and
+* extends pmEnd to the second paragraph's range so click-to-position
+* resolution still maps both ranges back to body content.
+*
+* Chains: runInWithNext on the merged block is dropped because the
+* second paragraph's mark wasn't `specVanish`. If a chain of
+* specVanish paragraphs needs collapsing (rare in practice), the loop
+* naturally handles it by re-inspecting the merged block's flag (we
+* preserve runInWithNext only when the second paragraph itself has
+* specVanish).
+*/
+function sdtGroupStacksEqual(a, b) {
+	const lenA = a?.length ?? 0;
+	if (lenA !== (b?.length ?? 0)) return false;
+	if (lenA === 0) return true;
+	for (let i = 0; i < lenA; i++) if (a?.[i]?.pmPos !== b?.[i]?.pmPos) return false;
+	return true;
+}
+function mergeRunInParagraphs(blocks) {
+	const out = [];
+	for (let i = 0; i < blocks.length; i++) {
+		let current = blocks[i];
+		if (!current) continue;
+		while (current.kind === "paragraph" && current.attrs?.runInWithNext && i + 1 < blocks.length) {
+			const next = blocks[i + 1];
+			if (!next || next.kind !== "paragraph") break;
+			const a = current;
+			const b = next;
+			if (!sdtGroupStacksEqual(a.sdtGroups, b.sdtGroups)) break;
+			const mergedAttrs = { ...a.attrs };
+			if (b.attrs?.spacing?.after !== void 0) mergedAttrs.spacing = {
+				...mergedAttrs.spacing,
+				after: b.attrs.spacing.after
+			};
+			if (b.attrs?.runInWithNext) mergedAttrs.runInWithNext = true;
+			else delete mergedAttrs.runInWithNext;
+			const merged = {
+				...a,
+				runs: [...a.runs, ...b.runs],
+				attrs: mergedAttrs
+			};
+			const mergedPmEnd = b.pmEnd ?? a.pmEnd;
+			if (mergedPmEnd !== void 0) merged.pmEnd = mergedPmEnd;
+			current = merged;
+			i += 1;
+		}
+		out.push(current);
+	}
+	return out;
+}
+//#endregion
+export { mergeRunInParagraphs, reserveLeadingEmptyOutlineHeight, suppressFinalEmptyParagraphAfterTable, suppressFinalParagraphInRepeatedEmptySuffix };

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

@@ -0,0 +1,17 @@
+import { document_d_exports } from "../../types/document.js";
+import { BorderStyle } from "../../layout-engine/types.js";
+//#region src/layout-bridge/convert/flowBorders.d.ts
+/** A parsed border, or the same shape read off ProseMirror attributes. */
+type ConvertibleBorder = {
+  style?: document_d_exports.BorderStyleValue;
+  size?: number;
+  space?: number;
+  color?: document_d_exports.ColorValue;
+};
+/**
+ * Convert an OOXML BorderSpec to a layout-engine BorderStyle.
+ * Shared by paragraph borders, cell borders, and header/footer borders.
+ */
+declare function convertBorderSpecToLayout(border: ConvertibleBorder, theme?: document_d_exports.Theme | null): BorderStyle | undefined;
+//#endregion
+export { ConvertibleBorder, convertBorderSpecToLayout };

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

@@ -0,0 +1,31 @@
+import { cssBorderStyle } from "../../utils/borderCss.js";
+import { resolveColor } from "../../utils/colorResolver.js";
+import { pointsToPixels } from "../../utils/units.js";
+import { statesNoBorder } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/flowBorders.ts
+/**
+* Converts document-model border specifications to layout BorderStyle.
+*/
+/**
+* Convert border width from eighths of a point to pixels.
+* OOXML stores border widths in eighths of a point.
+*/
+function borderWidthToPixels(eighthsOfPoint) {
+	return pointsToPixels(eighthsOfPoint / 8);
+}
+/**
+* Convert an OOXML BorderSpec to a layout-engine BorderStyle.
+* Shared by paragraph borders, cell borders, and header/footer borders.
+*/
+function convertBorderSpecToLayout(border, theme) {
+	if (border.style === void 0 || statesNoBorder(border.style)) return;
+	const result = {
+		style: cssBorderStyle(border.style),
+		width: border.size === void 0 ? 1 : borderWidthToPixels(border.size),
+		color: border.color ? resolveColor(border.color, theme) : "#000000"
+	};
+	if (border.space !== void 0) result.space = pointsToPixels(border.space);
+	return result;
+}
+//#endregion
+export { convertBorderSpecToLayout };

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

@@ -0,0 +1,111 @@
+import { document_d_exports } from "../../types/document.js";
+import { RunStyleResolver } from "../../prosemirror/runStyleFormatting.js";
+import { ParagraphAttrs, ParagraphBlock, TableBlock } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { ListCounterStreams } from "../../prosemirror/listMarker.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/flowConversionShared.d.ts
+/**
+ * Options for the conversion.
+ */
+type ToFlowBlocksOptions = {
+  /** Default font family. */
+  defaultFont?: string;
+  /** Default font size in points. */
+  defaultSize?: number;
+  /** Theme for resolving theme colors. */
+  theme?: document_d_exports.Theme | null;
+  /** Document styles used to resolve character-style toggles without per-run copies. */
+  styles?: document_d_exports.StyleDefinitions;
+  /** Document-scoped OOXML primary-font to `w:altName` lookup. */
+  fontAlternates?: FontAlternates;
+  /** Page content height in pixels (pageHeight - marginTop - marginBottom). Images taller than this are scaled down to fit. */
+  pageContentHeight?: number;
+  /** Whether a trailing page break moves its paragraph mark to the next page. */
+  splitPageBreakAndParagraphMark?: boolean;
+  /** Shared list counters for nested containers. */
+  listCounters?: Map<number, number[]>;
+  /** Latest concrete counters by abstract numbering definition. */
+  listAbstractCounters?: Map<number, number[]>;
+  /** Shared startOverride state for nested containers. */
+  listSeenNumIds?: Set<string>;
+  /**
+   * Parallel counter state for the "original" (pre-revision) document, used to
+   * number tracked-deletion list items. Word numbers inserted and deleted list
+   * runs as if they never coexist: insertions get final-document numbering,
+   * deletions keep their original numbering. Without a separate stream a deleted
+   * item continues the counter of the inserted item before it (a, b → c, d, e
+   * instead of a, b and a, b, c). Normal items advance both streams.
+   */
+  originalListCounters?: Map<number, number[]>;
+  /** Latest concrete original-stream counters by abstract numbering definition. */
+  originalListAbstractCounters?: Map<number, number[]>;
+  /** Original-stream startOverride state. */
+  originalListSeenNumIds?: Set<string>;
+  /**
+   * Document-wide `w:defaultTabStop` (§17.6.13) in twips. Stamped onto
+   * every paragraph block so paragraph-local layout helpers (list marker
+   * tab-stop math) can read it without taking a `Document` reference.
+   * Defaults to the OOXML 720-twip value when absent.
+   */
+  defaultTabStopTwips?: number;
+  /** Document-wide custom Word line-breaking settings. */
+  lineBreakRules?: {
+    noLineBreaksBefore?: {
+      language?: string;
+      characters: string;
+    };
+    noLineBreaksAfter?: {
+      language?: string;
+      characters: string;
+    };
+    useLegacyEthiopicAmharicRules?: boolean;
+  };
+  /** Document-generation policy for justified line fitting. */
+  justificationCompatibility?: NonNullable<ParagraphAttrs["justificationCompatibility"]>;
+  /** Document-generation policy for where `w:tblInd` is measured from. */
+  tableIndentCompatibility?: NonNullable<TableBlock["indentCompatibility"]>;
+  /**
+   * When set, every table-cell anchor lays out inside its cell regardless of
+   * an authored `wp:anchor/@layoutInCell="0"`. Compatibility mode 15 and
+   * above ignore that opt-out; see `resolveAnchorLayoutInCellCompatibility`.
+   */
+  forceAnchorLayoutInCell?: boolean;
+  /** Document-wide automatic hyphenation policy. */
+  automaticHyphenation?: NonNullable<ParagraphAttrs["automaticHyphenation"]>;
+  /** Line pitch for the final body section, whose properties live outside the PM body. */
+  finalSectionDocumentGridLinePitchTwips?: number;
+  /**
+   * The number a note story's `w:footnoteRef`/`w:endnoteRef` marks show. The
+   * mark stands for its note's reference number and shows it where it sits
+   * among the story's runs, in that run's formatting.
+   */
+  noteReferenceMarkText?: string;
+  /**
+   * Endnotes laid out after the body's last block (`w:pos="docEnd"`). A body
+   * that references one ends in its endnote area, so its final paragraph is no
+   * longer the document's last and keeps its height.
+   */
+  trailingEndnoteIds?: ReadonlySet<number>;
+};
+type FlowConversionOptions = ToFlowBlocksOptions & {
+  firstPageBreakRunPosition: (node: Node) => number | undefined;
+  /** `w:doNotUseIndentAsNumberingTabStop`, read from the document node. */
+  numberingTabIgnoresIndent: boolean;
+  listCounterStreams: ListCounterStreams;
+  numberedRefResults?: ReadonlyMap<Node, string>;
+  textBoxAnchorBlockIds: Map<string, ParagraphBlock["id"]>;
+  styleResolver: RunStyleResolver;
+};
+/**
+ * Convert twips to pixels (1 twip = 1/1440 inch, 1 inch = 96 CSS px).
+ * No rounding — precision prevents cumulative layout drift across paragraphs.
+ */
+declare function twipsToPixels(twips: number): number;
+declare function nextBlockId(): string;
+/**
+ * Reset the block ID counter (useful for testing).
+ */
+declare function resetBlockIdCounter(): void;
+//#endregion
+export { FlowConversionOptions, ToFlowBlocksOptions, nextBlockId, resetBlockIdCounter, twipsToPixels };

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

@@ -0,0 +1,23 @@
+//#region src/layout-bridge/convert/flowConversionShared.ts
+/**
+* Convert twips to pixels (1 twip = 1/1440 inch, 1 inch = 96 CSS px).
+* No rounding — precision prevents cumulative layout drift across paragraphs.
+*/
+function twipsToPixels(twips) {
+	return twips / 1440 * 96;
+}
+/**
+* Generate a unique block ID.
+*/
+let blockIdCounter = 0;
+function nextBlockId() {
+	return `block-${++blockIdCounter}`;
+}
+/**
+* Reset the block ID counter (useful for testing).
+*/
+function resetBlockIdCounter() {
+	blockIdCounter = 0;
+}
+//#endregion
+export { nextBlockId, resetBlockIdCounter, twipsToPixels };

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

@@ -1,6 +1,7 @@
 import { document_d_exports } from "../../types/document.js";
 import { FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FlowBlock, FootnoteContent, Measure, Page } from "../../layout-engine/types.js";
-import { ToFlowBlocksOptions } from "./toFlowBlocks.js";
+import { ToFlowBlocksOptions } from "./flowConversionShared.js";
+import "./toFlowBlocks.js";
 //#region src/layout-bridge/convert/footnoteLayout.d.ts
 type MeasureBlocksFn = (blocks: FlowBlock[], contentWidth: number) => Measure[];
 type ConvertFootnoteOptions = {

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

@@ -3,7 +3,8 @@ import { layoutTextBoxContent } from "../../layout-engine/measure/textBoxParagra
 import { DEFAULT_TEXTBOX_MARGINS, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, isFloatingImageRun, resolveTableWidthPx } from "../../layout-engine/types.js";
 import { expectPreservedXmlAttrs } from "../../prosemirror/attrs/index.js";
 import { footnoteToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
-import { collectNoteRefs, isNoteReferenceMarkXml, toFlowBlocks } from "./toFlowBlocks.js";
+import { collectNoteRefs, isNoteReferenceMarkXml } from "./noteReferences.js";
+import { toFlowBlocks } from "./toFlowBlocks.js";
 //#region src/layout-bridge/convert/footnoteLayout.ts
 /** Default footnote font size in points */
 const FOOTNOTE_FONT_SIZE = 8;

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

@@ -1,6 +1,7 @@
 import { document_d_exports } from "../../types/document.js";
 import { FlowBlock, HeaderFooterContent, ImageRun, ImageRunPosition, Measure, PageMargins } from "../../layout-engine/types.js";
-import { ToFlowBlocksOptions } from "./toFlowBlocks.js";
+import { ToFlowBlocksOptions } from "./flowConversionShared.js";
+import "./toFlowBlocks.js";
 import { MeasureBlocksFn } from "./footnoteLayout.js";
 import { Node } from "prosemirror-model";
 //#region src/layout-bridge/convert/headerFooterLayout.d.ts

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

@@ -0,0 +1,33 @@
+import { ImageAttrs } from "../../prosemirror/schema/nodes.js";
+import { ImageBlock, ImageRun, RunFormatting } from "../../layout-engine/types.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/imageConversion.d.ts
+/**
+ * Constrain image dimensions to fit within the page content area.
+ * Scales proportionally if height exceeds pageContentHeight.
+ */
+declare function constrainImageToPage(width: number, height: number, pageContentHeight: number | undefined): {
+  width: number;
+  height: number;
+};
+/**
+ * Build an ImageRun from ProseMirror node attrs, applying conditional property assignment
+ * to satisfy exactOptionalPropertyTypes.
+ */
+declare function buildImageRun(attrs: ImageAttrs, constrained: {
+  width: number;
+  height: number;
+}, pmStart: number, pmEnd: number, trackedChange?: Pick<RunFormatting, "isInsertion" | "isDeletion" | "changeAuthor" | "changeDate" | "changeRevisionId">, forceLayoutInCell?: boolean): ImageRun;
+/** A package image whose bytes cannot paint still owns its authored line box. */
+declare const hasRelationshipBackedImageBox: (attrs: ImageAttrs) => boolean;
+/**
+ * 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.
+ */
+declare const hasPaintableImageSource: (attrs: Pick<ImageAttrs, "src" | "preview">) => boolean;
+/**
+ * Convert an image node to an ImageBlock.
+ */
+declare function convertImage(node: Node, startPos: number, pageContentHeight?: number): ImageBlock | undefined;
+//#endregion
+export { buildImageRun, constrainImageToPage, convertImage, hasPaintableImageSource, hasRelationshipBackedImageBox };

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