@stll/folio-core 0.49.0 → 0.50.0

package/dist/fonts/fontsourceFaces.js

@@ -0,0 +1,230 @@
+import { bytesToDataUrl } from "../utils/base64.js";
+import { FONT_MAPPING } from "../utils/fontLoader.js";
+import { parseFontFamilyList, resolveFontFamily } from "../utils/fontResolver.js";
+//#region src/fonts/fontsourceFaces.ts
+/**
+* The subsets served, in resolution priority: a code point two subsets cover
+* resolves to the earlier one on both sides.
+*/
+const SUBSET_PRIORITY = [
+	"latin",
+	"latin-ext",
+	"arabic"
+];
+/** Folio paints 400 and 700 only, as `DisplayFontFace` states. */
+const REGULAR_WEIGHT = 400;
+const BOLD_WEIGHT = 700;
+/** Each bundled family and the `@fontsource` package that ships it. */
+const FONTSOURCE_PACKAGES = {
+	Arimo: "arimo",
+	Caladea: "caladea",
+	Carlito: "carlito",
+	Cousine: "cousine",
+	Lato: "lato",
+	"Noto Sans Arabic": "noto-sans-arabic",
+	"Source Sans 3": "source-sans-3",
+	Tinos: "tinos"
+};
+/** A CSS stack ends in a generic, so a generic must resolve to a bundled family too. */
+const GENERIC_FAMILIES = {
+	serif: "Tinos",
+	"sans-serif": "Arimo",
+	monospace: "Cousine"
+};
+const isBundledFamily = (name) => Object.hasOwn(FONTSOURCE_PACKAGES, name);
+const isGenericFamily = (name) => Object.hasOwn(GENERIC_FAMILIES, name);
+/** Every name a bundled family answers to: its own, and the authored names mapped to it. */
+const familyIndexEntries = () => {
+	const entries = [];
+	for (const family of Object.keys(FONTSOURCE_PACKAGES)) if (isBundledFamily(family)) entries.push([family.toLowerCase(), family]);
+	for (const [authored, mapped] of Object.entries(FONT_MAPPING)) {
+		if (isBundledFamily(mapped)) {
+			entries.push([authored.toLowerCase(), mapped]);
+			continue;
+		}
+		if (isGenericFamily(mapped)) entries.push([authored.toLowerCase(), GENERIC_FAMILIES[mapped]]);
+	}
+	for (const [generic, bundled] of Object.entries(GENERIC_FAMILIES)) entries.push([generic, bundled]);
+	return entries;
+};
+const FAMILY_INDEX = new Map(familyIndexEntries());
+/** Every family name the faces answer to, in a stable order for the CSS. */
+const bundledFamilyAliases = () => [...Object.keys(FONTSOURCE_PACKAGES), ...Object.keys(FONT_MAPPING).filter((authored) => FAMILY_INDEX.has(authored.toLowerCase()))].sort((a, b) => a.localeCompare(b, "en"));
+/**
+* The bundled family a requested name resolves to: directly, or through the
+* same fallback chain the editor's font resolver walks.
+*/
+const resolveBundledFamily = (family) => {
+	const direct = FAMILY_INDEX.get(family.trim().toLowerCase());
+	if (direct !== void 0) return direct;
+	for (const candidate of parseFontFamilyList(resolveFontFamily(family).cssFallback)) {
+		const resolved = FAMILY_INDEX.get(candidate.trim().toLowerCase());
+		if (resolved !== void 0) return resolved;
+	}
+	return null;
+};
+const weightOf = (bold) => bold ? BOLD_WEIGHT : REGULAR_WEIGHT;
+/** `@fontsource` ships the ranges it cut each subset with, beside the files. */
+const UNICODE_RANGE_FILE = "unicode.json";
+const RANGE_TOKEN_RE = /^U\+([0-9A-Fa-f]+)(?:-([0-9A-Fa-f]+))?$/u;
+const parseRangeToken = (token) => {
+	const match = RANGE_TOKEN_RE.exec(token.trim());
+	if (match === null) return [];
+	const first = Number.parseInt(match[1] ?? "", 16);
+	const last = match[2] === void 0 ? first : Number.parseInt(match[2], 16);
+	if (Number.isNaN(first) || Number.isNaN(last)) return [];
+	return [[first, last]];
+};
+const parseRangeList = (declared) => declared.split(",").flatMap(parseRangeToken);
+const parseDeclaredRanges = (bytes) => {
+	const ranges = /* @__PURE__ */ new Map();
+	const parsed = JSON.parse(new TextDecoder().decode(bytes));
+	if (typeof parsed !== "object" || parsed === null) return ranges;
+	for (const [subset, declared] of Object.entries(parsed)) if (typeof declared === "string") ranges.set(subset, parseRangeList(declared));
+	return ranges;
+};
+const withoutRange = (range, [start, end]) => {
+	const [first, last] = range;
+	if (end < first || start > last) return [range];
+	const remainder = [];
+	if (start > first) remainder.push([first, start - 1]);
+	if (end < last) remainder.push([end + 1, last]);
+	return remainder;
+};
+/**
+* `subject` minus everything a higher-priority subset already serves. The
+* declared ranges overlap (`latin` and `latin-ext` both claim some combining
+* marks); cutting the overlap out of the lower-priority rule makes a browser,
+* which resolves an overlap by declaration order, agree with this table.
+*/
+const subtractRanges = (subject, taken) => {
+	let remaining = subject;
+	for (const range of taken) remaining = remaining.flatMap((candidate) => withoutRange(candidate, range));
+	return remaining;
+};
+const hex = (codePoint) => codePoint.toString(16).toUpperCase().padStart(4, "0");
+const formatRangeList = (ranges) => ranges.map(([first, last]) => first === last ? `U+${hex(first)}` : `U+${hex(first)}-${hex(last)}`).join(",");
+/**
+* A CSS `<string>` token, quoted and escaped. A family name comes from an
+* authored document and is emitted into a `<style>` element, so the
+* backslash is escaped first, then the quote, and line terminators become hex
+* escapes, which CSS strings require.
+*/
+const cssString = (value) => `"${value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\A ").replaceAll("\r", "\\D ").replaceAll("\f", "\\C ")}"`;
+const FACE_VARIANTS = [
+	{
+		weight: REGULAR_WEIGHT,
+		italic: false
+	},
+	{
+		weight: REGULAR_WEIGHT,
+		italic: true
+	},
+	{
+		weight: BOLD_WEIGHT,
+		italic: false
+	},
+	{
+		weight: BOLD_WEIGHT,
+		italic: true
+	}
+];
+/** The media type a `.woff` face is inlined under. */
+const WOFF_MEDIA_TYPE = "font/woff";
+const fontFaceRule = ({ family, dataUrl, weight, italic, unicodeRange }) => [
+	"@font-face {",
+	`  font-family: ${cssString(family)};`,
+	`  src: url(${dataUrl}) format("woff");`,
+	`  font-weight: ${String(weight)};`,
+	`  font-style: ${italic ? "italic" : "normal"};`,
+	`  unicode-range: ${formatRangeList(unicodeRange)};`,
+	"  font-display: block;",
+	"}"
+].join("\n");
+/** The `@fontsource` faces, read through `files` and cached per face. */
+const createFontsourceFaces = (files) => {
+	const faceCache = /* @__PURE__ */ new Map();
+	const rangeCache = /* @__PURE__ */ new Map();
+	const dataUrlCache = /* @__PURE__ */ new Map();
+	const faceBinaries = ({ family, weight, italic }) => {
+		const bundled = resolveBundledFamily(family);
+		if (bundled === null) return [];
+		const packageName = FONTSOURCE_PACKAGES[bundled];
+		const style = italic ? "italic" : "normal";
+		const key = `${packageName}|${String(weight)}|${style}`;
+		const cached = faceCache.get(key);
+		if (cached !== void 0) return cached;
+		const binaries = SUBSET_PRIORITY.flatMap((subset) => {
+			const bytes = files.read(packageName, `files/${packageName}-${subset}-${String(weight)}-${style}.woff`);
+			return bytes === null ? [] : [{
+				subset,
+				bytes
+			}];
+		});
+		faceCache.set(key, binaries);
+		return binaries;
+	};
+	const declaredRanges = (packageName) => {
+		const cached = rangeCache.get(packageName);
+		if (cached !== void 0) return cached;
+		const bytes = files.read(packageName, UNICODE_RANGE_FILE);
+		const ranges = bytes === null ? /* @__PURE__ */ new Map() : parseDeclaredRanges(bytes);
+		rangeCache.set(packageName, ranges);
+		return ranges;
+	};
+	const dataUrlOf = (bytes) => {
+		const cached = dataUrlCache.get(bytes);
+		if (cached !== void 0) return cached;
+		const encoded = bytesToDataUrl(bytes, WOFF_MEDIA_TYPE);
+		dataUrlCache.set(bytes, encoded);
+		return encoded;
+	};
+	/**
+	* The rules for one variant of one family name. A subset whose range a
+	* higher-priority subset already serves, or that `unicode.json` does not
+	* describe, is not declared: a rule with no `unicode-range` would cover
+	* every code point.
+	*/
+	const variantRules = ({ family, weight, italic }) => {
+		const bundled = resolveBundledFamily(family);
+		if (bundled === null) return [];
+		const ranges = declaredRanges(FONTSOURCE_PACKAGES[bundled]);
+		const rules = [];
+		const taken = [];
+		for (const binary of faceBinaries({
+			family,
+			weight,
+			italic
+		})) {
+			const unicodeRange = subtractRanges(ranges.get(binary.subset) ?? [], taken);
+			if (unicodeRange.length === 0) continue;
+			rules.push(fontFaceRule({
+				family,
+				dataUrl: dataUrlOf(binary.bytes),
+				weight,
+				italic,
+				unicodeRange
+			}));
+			taken.push(...unicodeRange);
+		}
+		return rules;
+	};
+	return {
+		source: { load: ({ family, bold, italic }) => faceBinaries({
+			family,
+			weight: weightOf(bold),
+			italic
+		}).map(({ bytes }) => bytes) },
+		fontFaceCss: (options = {}) => {
+			const declared = /* @__PURE__ */ new Map();
+			for (const family of [...bundledFamilyAliases(), ...options.families ?? []]) declared.set(family.trim().toLowerCase(), family.trim());
+			return [...declared.values()].flatMap((family) => FACE_VARIANTS.flatMap(({ weight, italic }) => variantRules({
+				family,
+				weight,
+				italic
+			}))).join("\n");
+		}
+	};
+};
+//#endregion
+export { FONTSOURCE_PACKAGES, createFontsourceFaces, cssString };

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

@@ -0,0 +1,8 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+//#region src/layout-bridge/convert/flowBlockPostprocessing.d.ts
+declare function suppressFinalEmptyParagraphAfterTable(blocks: FlowBlock[]): void;
+declare function suppressFinalParagraphInRepeatedEmptySuffix(blocks: FlowBlock[]): void;
+declare function reserveLeadingEmptyOutlineHeight(blocks: FlowBlock[]): void;
+declare function mergeRunInParagraphs(blocks: FlowBlock[]): FlowBlock[];
+//#endregion
+export { mergeRunInParagraphs, reserveLeadingEmptyOutlineHeight, suppressFinalEmptyParagraphAfterTable, suppressFinalParagraphInRepeatedEmptySuffix };

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