@stll/folio-core 0.49.0 → 0.51.0

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

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