@stll/folio-core 0.48.0 → 0.50.0

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

@@ -0,0 +1,303 @@
+import { setTextBoxGroupId } from "../../layout-engine/textBoxGroup.js";
+import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
+import { expectParagraphAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs } from "../../prosemirror/attrs/index.js";
+import { textBoxHostParagraph } from "../../prosemirror/textBoxHostParagraph.js";
+import { normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
+import { convertBorderSpecToLayout } from "./flowBorders.js";
+import { nextBlockId, twipsToPixels } from "./flowConversionShared.js";
+import { countPageBreakRuns, hasSingleLeadingProjectedPageBreak } from "./pageBreakSplitting.js";
+import { convertParagraphAttrs } from "./paragraphAttrs.js";
+import { convertParagraph } from "./paragraphConversion.js";
+import { groupParagraphFrames } from "./paragraphFrames.js";
+import { resolveParagraphMarkFormatting } from "./paragraphMarkFormatting.js";
+import { inlineEffectExtentPx, resolveLinearGradientFill } from "./textBoxFill.js";
+//#region src/layout-bridge/convert/tableConversion.ts
+const TEXT_BOX_ANCHOR_BLOCK_ID = Symbol.for("stll.textBoxAnchorBlockId");
+const DEFAULT_TABLE_CELL_MARGIN_TWIPS = {
+	top: 0,
+	right: 108,
+	bottom: 0,
+	left: 108
+};
+/**
+* Extract cell borders from ProseMirror attributes.
+* Borders are full BorderSpec objects with style/size/color.
+*/
+function extractCellBorders(borders, theme) {
+	if (!borders) return;
+	const result = {};
+	for (const side of [
+		"top",
+		"bottom",
+		"left",
+		"right"
+	]) {
+		const border = borders[side];
+		const converted = border ? convertBorderSpecToLayout(border, theme) : void 0;
+		if (!converted) {
+			result[side] = {
+				width: 0,
+				style: "none"
+			};
+			continue;
+		}
+		result[side] = border?.size === 0 ? {
+			...converted,
+			width: 0
+		} : converted;
+	}
+	for (const side of ["topLeftToBottomRight", "topRightToBottomLeft"]) {
+		const border = borders[side];
+		const converted = border ? convertBorderSpecToLayout(border, theme) : void 0;
+		if (converted) result[side] = converted;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function convertTableCell(node, startPos, options, tableCellMargins) {
+	const blocks = [];
+	let offset = startPos + 1;
+	const authoredPageBreakPosition = options.firstPageBreakRunPosition(node);
+	const leadingParagraph = node.firstChild?.type.name === "paragraph" && countPageBreakRuns(node) === 1 && options.firstPageBreakRunPosition(node.firstChild) === authoredPageBreakPosition ? node.firstChild : void 0;
+	const pageBreaks = [];
+	const convertCellChild = (child, childStart) => {
+		if (child.type.name === "paragraph") {
+			const block = convertParagraph(child, childStart, options, child === leadingParagraph ? pageBreaks : void 0);
+			blocks.push(block);
+		} else if (child.type.name === "table") blocks.push(convertTable(child, childStart, options));
+		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, childStart, options));
+		else if (child.type.name === "blockSdt") {
+			let sdtChildStart = childStart + 1;
+			child.forEach((sdtChild) => {
+				convertCellChild(sdtChild, sdtChildStart);
+				sdtChildStart += sdtChild.nodeSize;
+			});
+		}
+	};
+	node.forEach((child) => {
+		convertCellChild(child, offset);
+		offset += child.nodeSize;
+	});
+	const trailingBlock = blocks.at(-1);
+	if (blocks.at(-2)?.kind === "table" && trailingBlock?.kind === "paragraph" && trailingBlock.runs.every((run) => run.kind === "text" && run.text.length === 0)) trailingBlock.attrs = {
+		...trailingBlock.attrs,
+		suppressEmptyParagraphHeight: true
+	};
+	const attrs = expectTableCellAttrs(node);
+	if (attrs.hideMark && trailingBlock?.kind === "paragraph" && trailingBlock.runs.every((run) => run.kind === "text" && run.text.length === 0)) trailingBlock.attrs = {
+		...trailingBlock.attrs,
+		suppressEmptyParagraphHeight: true
+	};
+	const margins = attrs.margins;
+	const resolvePaddingSide = (side, cellTwips, tableTwips) => {
+		if (cellTwips !== void 0) return twipsToPixels(cellTwips);
+		if (tableTwips !== void 0) return twipsToPixels(tableTwips);
+		return twipsToPixels(DEFAULT_TABLE_CELL_MARGIN_TWIPS[side]);
+	};
+	const padding = {
+		top: resolvePaddingSide("top", margins?.top, tableCellMargins?.top),
+		right: resolvePaddingSide("right", margins?.right, tableCellMargins?.right),
+		bottom: resolvePaddingSide("bottom", margins?.bottom, tableCellMargins?.bottom),
+		left: resolvePaddingSide("left", margins?.left, tableCellMargins?.left)
+	};
+	const cell = {
+		id: nextBlockId(),
+		blocks: groupParagraphFrames(blocks, nextBlockId),
+		colSpan: attrs.colspan,
+		rowSpan: attrs.rowspan,
+		padding
+	};
+	if (attrs.width) cell.width = twipsToPixels(attrs.width);
+	if (attrs.verticalAlign) cell.verticalAlign = attrs.verticalAlign;
+	if (attrs.textDirection) cell.textDirection = attrs.textDirection;
+	if (attrs.backgroundColor) cell.background = `#${attrs.backgroundColor}`;
+	const cellBorders = extractCellBorders(attrs.borders, options.theme);
+	if (cellBorders) cell.borders = cellBorders;
+	if (attrs.noWrap) cell.noWrap = true;
+	if (authoredPageBreakPosition === void 0 || pageBreaks.length === 0) return { cell };
+	const paragraph = blocks.at(0);
+	if (paragraph?.kind !== "paragraph" || !hasSingleLeadingProjectedPageBreak(paragraph.runs, pageBreaks)) return { cell };
+	return {
+		cell,
+		breakBefore: "page"
+	};
+}
+/**
+* Resolve an `ST_JcTable` placement to the flow engine's logical alignment.
+*
+* `start` and `end` name an edge of the writing direction, not a side of the
+* page, the same distinction `ST_Jc` draws for a paragraph. The flow engine
+* applies `w:bidiVisual` when it resolves that logical alignment to a physical
+* side, so the bridge must not mirror it first.
+*/
+const resolveTablePlacement = (placement) => {
+	switch (placement) {
+		case "start": return "left";
+		case "end": return "right";
+		case "left":
+		case "center":
+		case "right": return placement;
+		default: return placement;
+	}
+};
+function convertTableRow(node, startPos, options, { cellMargins }) {
+	const cells = [];
+	let offset = startPos + 1;
+	let breakBefore;
+	node.forEach((child) => {
+		if (child.type.name === "tableCell" || child.type.name === "tableHeader") {
+			if (!expectTableCellAttrs(child)._omittedGridSlot) {
+				const converted = convertTableCell(child, offset, options, cellMargins);
+				if (converted.breakBefore !== void 0) breakBefore = converted.breakBefore;
+				cells.push(converted.cell);
+			}
+		}
+		offset += child.nodeSize;
+	});
+	const attrs = expectTableRowAttrs(node);
+	const row = {
+		id: nextBlockId(),
+		cells
+	};
+	if (attrs._originalFormatting?.gridBefore) row.gridBefore = attrs._originalFormatting.gridBefore;
+	if (attrs._originalFormatting?.gridAfter) row.gridAfter = attrs._originalFormatting.gridAfter;
+	if (attrs.height) row.height = twipsToPixels(attrs.height);
+	if (attrs.heightRule) row.heightRule = attrs.heightRule;
+	if (attrs.isHeader) row.isHeader = attrs.isHeader;
+	if (attrs._originalFormatting?.cantSplit) row.cantSplit = true;
+	if (breakBefore !== void 0) row.breakBefore = breakBefore;
+	if (attrs.hidden) row.hidden = attrs.hidden;
+	const effectiveJustification = attrs._originalFormatting?.justification ?? attrs._resolvedJustification;
+	if (effectiveJustification) row.justification = resolveTablePlacement(effectiveJustification);
+	return row;
+}
+/**
+* Convert a table node to a TableBlock.
+*/
+function convertTable(node, startPos, options) {
+	const rows = [];
+	let offset = startPos + 1;
+	const attrs = expectTableAttrs(node);
+	const rightToLeft = (attrs._resolvedBidi ?? attrs._originalFormatting?.bidi) === true;
+	const rowContext = { ...attrs.cellMargins === void 0 ? {} : { cellMargins: attrs.cellMargins } };
+	node.forEach((child) => {
+		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, rowContext));
+		offset += child.nodeSize;
+	});
+	let columnWidths = attrs.columnWidths?.map(twipsToPixels);
+	const width = attrs.width;
+	const widthType = attrs.widthType;
+	if (!columnWidths && rows.length > 0) {
+		const cellWidths = rows[0].cells.map((cell) => cell.width);
+		if (cellWidths.every((w) => w !== void 0 && w > 0)) columnWidths = cellWidths;
+	}
+	const authoredJustification = attrs.justification ?? attrs._resolvedJustification;
+	const justification = authoredJustification === void 0 ? void 0 : resolveTablePlacement(authoredJustification);
+	const originalFormatting = attrs._originalFormatting;
+	const effectiveIndent = attrs._resolvedIndent ?? originalFormatting?.indent;
+	const indentPx = effectiveIndent?.value !== void 0 && effectiveIndent?.type === "dxa" ? twipsToPixels(effectiveIndent.value) : void 0;
+	const dropsAuthoredIndent = effectiveIndent?.value !== void 0 && indentPx === void 0;
+	const floating = attrs.floating;
+	let floatingPx;
+	if (floating) {
+		const fp = {};
+		if (floating.horzAnchor) fp.horzAnchor = floating.horzAnchor;
+		if (floating.vertAnchor) fp.vertAnchor = floating.vertAnchor;
+		if (floating.tblpX !== void 0) fp.tblpX = twipsToPixels(floating.tblpX);
+		if (floating.tblpXSpec) fp.tblpXSpec = floating.tblpXSpec;
+		if (floating.tblpY !== void 0) fp.tblpY = twipsToPixels(floating.tblpY);
+		if (floating.tblpYSpec) fp.tblpYSpec = floating.tblpYSpec;
+		if (floating.topFromText !== void 0) fp.topFromText = twipsToPixels(floating.topFromText);
+		if (floating.bottomFromText !== void 0) fp.bottomFromText = twipsToPixels(floating.bottomFromText);
+		if (floating.leftFromText !== void 0) fp.leftFromText = twipsToPixels(floating.leftFromText);
+		if (floating.rightFromText !== void 0) fp.rightFromText = twipsToPixels(floating.rightFromText);
+		floatingPx = fp;
+	}
+	const tableBlock = {
+		kind: "table",
+		id: nextBlockId(),
+		rows,
+		pmStart: startPos,
+		pmEnd: startPos + node.nodeSize
+	};
+	if (columnWidths) tableBlock.columnWidths = columnWidths;
+	if (width !== void 0) tableBlock.width = width;
+	if (widthType !== void 0) tableBlock.widthType = widthType;
+	if (originalFormatting?.layout !== void 0) tableBlock.layout = originalFormatting.layout;
+	if (justification) tableBlock.justification = justification;
+	if (indentPx !== void 0) tableBlock.indent = indentPx;
+	const cellSpacing = originalFormatting?.cellSpacing;
+	if (cellSpacing?.type === "dxa" && cellSpacing.value > 0) tableBlock.cellSpacing = twipsToPixels(cellSpacing.value);
+	if (options.tableIndentCompatibility && !dropsAuthoredIndent) tableBlock.indentCompatibility = options.tableIndentCompatibility;
+	if (floatingPx) tableBlock.floating = floatingPx;
+	if (rightToLeft) tableBlock.bidi = true;
+	return tableBlock;
+}
+/** Convert a textBox PM node to a TextBoxBlock. */
+function convertTextBoxNode(node, startPos, opts) {
+	const attrs = expectTextBoxAttrs(node);
+	const contentBlocks = [];
+	node.forEach((child, offset) => {
+		const childPos = startPos + 1 + offset;
+		if (child.type.name === "paragraph") {
+			contentBlocks.push(convertParagraph(child, childPos, opts));
+			return;
+		}
+		if (child.type.name === "table") contentBlocks.push(convertTable(child, childPos, opts));
+	});
+	const textBox = {
+		kind: "textBox",
+		id: nextBlockId(),
+		width: attrs.width ?? 200,
+		margins: {
+			top: attrs.marginTop ?? DEFAULT_TEXTBOX_MARGINS.top,
+			bottom: attrs.marginBottom ?? DEFAULT_TEXTBOX_MARGINS.bottom,
+			left: attrs.marginLeft ?? DEFAULT_TEXTBOX_MARGINS.left,
+			right: attrs.marginRight ?? DEFAULT_TEXTBOX_MARGINS.right
+		},
+		content: contentBlocks,
+		pmStart: startPos,
+		pmEnd: startPos + node.nodeSize
+	};
+	const verticalAlign = normalizeShapeTextAnchor(attrs.verticalAlign);
+	if (verticalAlign !== void 0) textBox.verticalAlign = verticalAlign;
+	if (attrs.height !== void 0) textBox.height = attrs.height;
+	if (attrs.autoFit !== void 0) textBox.autoFit = attrs.autoFit;
+	if (attrs.textWrap !== void 0) textBox.textWrap = attrs.textWrap;
+	if (attrs.fillColor !== void 0) textBox.fillColor = attrs.fillColor;
+	else {
+		const fillGradient = resolveLinearGradientFill(attrs.gradientFill, opts.theme);
+		if (fillGradient !== void 0) textBox.fillGradient = fillGradient;
+	}
+	if (attrs.outlineWidth !== void 0) textBox.outlineWidth = attrs.outlineWidth;
+	if (attrs.outlineColor !== void 0) textBox.outlineColor = attrs.outlineColor;
+	if (attrs.outlineStyle !== void 0) textBox.outlineStyle = attrs.outlineStyle;
+	if (attrs.transform !== void 0) textBox.transform = attrs.transform;
+	if (attrs.displayMode !== void 0) textBox.displayMode = attrs.displayMode;
+	if (attrs.cssFloat !== void 0) textBox.cssFloat = attrs.cssFloat;
+	if (attrs.wrapType !== void 0) textBox.wrapType = attrs.wrapType;
+	if (attrs.wrapText !== void 0) textBox.wrapText = attrs.wrapText;
+	if (attrs.distTop !== void 0) textBox.distTop = attrs.distTop;
+	if (attrs.distBottom !== void 0) textBox.distBottom = attrs.distBottom;
+	if (attrs.distLeft !== void 0) textBox.distLeft = attrs.distLeft;
+	if (attrs.distRight !== void 0) textBox.distRight = attrs.distRight;
+	if (attrs.position !== void 0) textBox.position = attrs.position;
+	const effectExtent = inlineEffectExtentPx(attrs.wrapType, attrs.wrapEffectExtentSlots?.drawing);
+	if (effectExtent !== void 0) textBox.effectExtent = effectExtent;
+	const host = textBoxHostParagraph(node);
+	if (host && attrs.position === void 0 && (attrs.wrapType ?? "inline") === "inline") {
+		const hostAttrs = expectParagraphAttrs(host);
+		textBox.hostParagraph = convertParagraphAttrs(hostAttrs, {
+			theme: opts.theme,
+			fontAlternates: opts.fontAlternates,
+			listCounterStreams: opts.listCounterStreams,
+			defaultTabStopTwips: opts.defaultTabStopTwips,
+			paragraphMarkFormatting: () => resolveParagraphMarkFormatting(hostAttrs, opts.styleResolver)
+		});
+	}
+	if (attrs._docxGroupId !== void 0) setTextBoxGroupId(textBox, attrs._docxGroupId);
+	const anchorBlockId = attrs._docxAnchorId ? opts.textBoxAnchorBlockIds.get(attrs._docxAnchorId) : void 0;
+	if (anchorBlockId !== void 0) Reflect.set(textBox, TEXT_BOX_ANCHOR_BLOCK_ID, anchorBlockId);
+	return textBox;
+}
+//#endregion
+export { convertTable, convertTextBoxNode };

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

@@ -0,0 +1,20 @@
+import { document_d_exports } from "../../types/document.js";
+import { TextBoxBlock, TextBoxGradientFill } from "../../layout-engine/types.js";
+import { ImagePadding } from "@stll/docx-core/model";
+//#region src/layout-bridge/convert/textBoxFill.d.ts
+/**
+ * The `wp:effectExtent` of an inline (`wp:inline`) box, in unrounded pixels.
+ *
+ * An inline object occupies its extent plus the effect extent on every side,
+ * so the box itself sits `l`/`t` inside the space the line gives it. On a
+ * `wp:anchor` the position offsets already locate the shape's own extent, so
+ * the reservation only affects wrapping and is not applied here.
+ */
+declare function inlineEffectExtentPx(wrapType: TextBoxBlock["wrapType"], extent: ImagePadding | undefined): TextBoxBlock["effectExtent"];
+/**
+ * A linear `a:gradFill` with its stop colors resolved through the theme. A path
+ * gradient (`a:path`) is not painted: nothing here places its focus.
+ */
+declare function resolveLinearGradientFill(fill: document_d_exports.ShapeFill | undefined, theme: document_d_exports.Theme | null | undefined): TextBoxGradientFill | undefined;
+//#endregion
+export { inlineEffectExtentPx, resolveLinearGradientFill };

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

@@ -0,0 +1,42 @@
+import { resolveColor } from "../../utils/colorResolver.js";
+//#region src/layout-bridge/convert/textBoxFill.ts
+const EMUS_PER_PIXEL = 9525;
+/**
+* The `wp:effectExtent` of an inline (`wp:inline`) box, in unrounded pixels.
+*
+* An inline object occupies its extent plus the effect extent on every side,
+* so the box itself sits `l`/`t` inside the space the line gives it. On a
+* `wp:anchor` the position offsets already locate the shape's own extent, so
+* the reservation only affects wrapping and is not applied here.
+*/
+function inlineEffectExtentPx(wrapType, extent) {
+	if (wrapType !== void 0 && wrapType !== "inline" || extent === void 0) return;
+	const px = (emu) => Math.max(0, (emu ?? 0) / EMUS_PER_PIXEL);
+	const resolved = {
+		top: px(extent.top),
+		bottom: px(extent.bottom),
+		left: px(extent.left),
+		right: px(extent.right)
+	};
+	return resolved.top === 0 && resolved.bottom === 0 && resolved.left === 0 && resolved.right === 0 ? void 0 : resolved;
+}
+const GRADIENT_POSITION_SCALE = 1e5;
+/**
+* A linear `a:gradFill` with its stop colors resolved through the theme. A path
+* gradient (`a:path`) is not painted: nothing here places its focus.
+*/
+function resolveLinearGradientFill(fill, theme) {
+	const gradient = fill?.gradient;
+	if (gradient === void 0 || gradient.type !== "linear" || gradient.stops.length === 0) return;
+	const stops = gradient.stops.map((stop) => ({
+		offset: Math.min(1, Math.max(0, stop.position / GRADIENT_POSITION_SCALE)),
+		color: resolveColor(stop.color, theme)
+	})).toSorted((left, right) => left.offset - right.offset);
+	return {
+		angle: gradient.angle ?? 0,
+		scaled: gradient.scaled ?? false,
+		stops
+	};
+}
+//#endregion
+export { inlineEffectExtentPx, resolveLinearGradientFill };

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

@@ -0,0 +1,22 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs } from "../../prosemirror/schema/nodes.js";
+import { ListMarkerFormatting, RunFormatting } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+//#region src/layout-bridge/convert/textFormattingConversion.d.ts
+type ThemeFontAttributes = Omit<NonNullable<document_d_exports.TextFormatting["fontFamily"]>, "asciiTheme"> & {
+  /** The ProseMirror attr reader validates this against the canonical theme values. */
+  asciiTheme?: string;
+};
+declare const resolveWesternThemeFont: (fontFamily: ThemeFontAttributes, theme?: document_d_exports.Theme | null) => string | undefined;
+declare const resolveComplexScriptThemeFont: (fontFamily: ThemeFontAttributes, theme?: document_d_exports.Theme | null) => string | undefined;
+declare const resolveEastAsiaThemeFont: (fontFamily: ThemeFontAttributes, theme?: document_d_exports.Theme | null) => string | undefined;
+declare function isAutomaticTextColorValue(color: document_d_exports.ColorValue): boolean;
+/**
+ * The numbering symbol's typography: the numbering level's `w:rPr` applied
+ * over the paragraph mark's run properties (ECMA-376 §17.9.24, §17.3.1.29).
+ * Text runs of the paragraph play no part.
+ */
+declare function listMarkerFormattingFor(levelFormatting: document_d_exports.TextFormatting | undefined, paragraphMarkFormatting: document_d_exports.TextFormatting | undefined, theme: document_d_exports.Theme | null | undefined, fontAlternates: FontAlternates | undefined): ListMarkerFormatting | undefined;
+declare function paragraphRunDefaults(pmAttrs: ParagraphAttrs, theme?: document_d_exports.Theme | null, fontAlternates?: FontAlternates): RunFormatting;
+//#endregion
+export { isAutomaticTextColorValue, listMarkerFormattingFor, paragraphRunDefaults, resolveComplexScriptThemeFont, resolveEastAsiaThemeFont, resolveWesternThemeFont };

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

@@ -0,0 +1,120 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
+import { resolveThemeFont } from "../../utils/fontResolver.js";
+import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { halfPointsToPixels, halfPointsToPoints } from "../../utils/units.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+//#region src/layout-bridge/convert/textFormattingConversion.ts
+/**
+* Converts document-model TextFormatting (style, paragraph-mark, and list
+* marker run properties) to layout RunFormatting, including theme-font
+* resolution per script slot.
+*/
+const resolveWesternThemeFont = (fontFamily, theme) => {
+	const themeRef = fontFamily.asciiTheme ?? fontFamily.hAnsiTheme;
+	return (themeRef ? resolveThemeFont(themeRef, theme?.fontScheme) : null) ?? fontFamily.ascii ?? fontFamily.hAnsi ?? void 0;
+};
+const resolveComplexScriptThemeFont = (fontFamily, theme) => {
+	return (fontFamily.csTheme ? resolveThemeFont(fontFamily.csTheme, theme?.fontScheme) : null) ?? fontFamily.cs ?? void 0;
+};
+const resolveEastAsiaThemeFont = (fontFamily, theme) => {
+	return (fontFamily.eastAsiaTheme ? resolveThemeFont(fontFamily.eastAsiaTheme, theme?.fontScheme) : null) ?? fontFamily.eastAsia ?? void 0;
+};
+function isAutomaticTextColorValue(color) {
+	const rgb = color.rgb?.trim().toLowerCase();
+	return color.auto === true || rgb === "auto" || !rgb && !color.themeColor;
+}
+function textFormattingToRunFormatting(defaultTextFormatting, theme, fontAlternates) {
+	if (!defaultTextFormatting) return {};
+	const result = {};
+	const fontFamily = defaultTextFormatting.fontFamily ? resolveWesternThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
+	if (fontFamily) {
+		result.fontFamily = fontFamily;
+		const alternate = getFontAlternate(fontFamily, fontAlternates);
+		if (alternate) result.alternateFontFamily = alternate;
+	}
+	const eastAsiaFontFamily = defaultTextFormatting.fontFamily ? resolveEastAsiaThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
+	if (eastAsiaFontFamily) {
+		result.eastAsiaFontFamily = eastAsiaFontFamily;
+		const alternate = getFontAlternate(eastAsiaFontFamily, fontAlternates);
+		if (alternate) result.eastAsiaAlternateFontFamily = alternate;
+	}
+	if (defaultTextFormatting.fontFamily?.hint) result.eastAsiaHint = defaultTextFormatting.fontFamily.hint === "eastAsia";
+	const complexScriptFontFamily = defaultTextFormatting.fontFamily ? resolveComplexScriptThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
+	if (complexScriptFontFamily) {
+		result.complexScriptFontFamily = complexScriptFontFamily;
+		const alternate = getFontAlternate(complexScriptFontFamily, fontAlternates);
+		if (alternate) result.complexScriptAlternateFontFamily = alternate;
+	}
+	if (defaultTextFormatting.language) result.language = { ...defaultTextFormatting.language };
+	if (defaultTextFormatting.fontSize !== void 0) result.fontSize = defaultTextFormatting.fontSize / 2;
+	if (defaultTextFormatting.fontSizeCs !== void 0) result.complexScriptFontSize = defaultTextFormatting.fontSizeCs / 2;
+	if (defaultTextFormatting.bold !== void 0) result.bold = defaultTextFormatting.bold;
+	if (defaultTextFormatting.boldCs !== void 0) result.complexScriptBold = defaultTextFormatting.boldCs;
+	if (defaultTextFormatting.italic !== void 0) result.italic = defaultTextFormatting.italic;
+	if (defaultTextFormatting.italicCs !== void 0) result.complexScriptItalic = defaultTextFormatting.italicCs;
+	if (defaultTextFormatting.rtl !== void 0) result.rtl = defaultTextFormatting.rtl;
+	if (defaultTextFormatting.cs !== void 0) result.forceComplexScript = defaultTextFormatting.cs;
+	if (defaultTextFormatting.underline && defaultTextFormatting.underline.style !== "none") {
+		result.underline = { style: defaultTextFormatting.underline.style };
+		if (defaultTextFormatting.underline.color) result.underline.color = resolveColor(defaultTextFormatting.underline.color, theme);
+	}
+	if (defaultTextFormatting.strike !== void 0) result.strike = defaultTextFormatting.strike;
+	if (defaultTextFormatting.color && !isAutomaticTextColorValue(defaultTextFormatting.color)) {
+		result.color = resolveColor(defaultTextFormatting.color, theme);
+		result.textColorSource = "paragraphDefault";
+	}
+	if (defaultTextFormatting.highlight) {
+		const highlight = resolveHighlightToCss(defaultTextFormatting.highlight);
+		if (highlight) result.highlight = highlight;
+	}
+	if (defaultTextFormatting.vertAlign === "superscript") result.superscript = true;
+	if (defaultTextFormatting.vertAlign === "subscript") result.subscript = true;
+	if (defaultTextFormatting.allCaps !== void 0) result.allCaps = defaultTextFormatting.allCaps;
+	if (defaultTextFormatting.smallCaps !== void 0) result.smallCaps = defaultTextFormatting.smallCaps;
+	if (defaultTextFormatting.spacing !== void 0 && defaultTextFormatting.spacing !== 0) result.letterSpacing = twipsToPixels(defaultTextFormatting.spacing);
+	if (defaultTextFormatting.position !== void 0 && defaultTextFormatting.position !== 0) result.positionPx = halfPointsToPixels(defaultTextFormatting.position);
+	const horizontalScale = normalizeHorizontalScalePercent(defaultTextFormatting.scale);
+	if (horizontalScale !== void 0 && horizontalScale !== 100) result.horizontalScale = horizontalScale;
+	if (defaultTextFormatting.kerning !== void 0 && defaultTextFormatting.kerning > 0) result.kerningMinPt = halfPointsToPoints(defaultTextFormatting.kerning);
+	if (defaultTextFormatting.emboss !== void 0) result.emboss = defaultTextFormatting.emboss;
+	if (defaultTextFormatting.imprint !== void 0) result.imprint = defaultTextFormatting.imprint;
+	if (defaultTextFormatting.shadow !== void 0) result.textShadow = defaultTextFormatting.shadow;
+	if (defaultTextFormatting.outline !== void 0) result.textOutline = defaultTextFormatting.outline;
+	if (defaultTextFormatting.emphasisMark && defaultTextFormatting.emphasisMark !== "none") result.emphasisMark = defaultTextFormatting.emphasisMark;
+	return result;
+}
+const LIST_MARKER_FORMATTING_KEYS = [
+	"fontFamily",
+	"alternateFontFamily",
+	"eastAsiaFontFamily",
+	"eastAsiaAlternateFontFamily",
+	"complexScriptFontFamily",
+	"complexScriptAlternateFontFamily",
+	"fontSize",
+	"complexScriptFontSize",
+	"bold",
+	"complexScriptBold",
+	"italic",
+	"complexScriptItalic",
+	"rtl",
+	"forceComplexScript",
+	"color"
+];
+/**
+* The numbering symbol's typography: the numbering level's `w:rPr` applied
+* over the paragraph mark's run properties (ECMA-376 §17.9.24, §17.3.1.29).
+* Text runs of the paragraph play no part.
+*/
+function listMarkerFormattingFor(levelFormatting, paragraphMarkFormatting, theme, fontAlternates) {
+	const runFormatting = textFormattingToRunFormatting(mergeTextFormatting(paragraphMarkFormatting, levelFormatting), theme, fontAlternates);
+	const formatting = {};
+	for (const key of LIST_MARKER_FORMATTING_KEYS) if (runFormatting[key] !== void 0) Reflect.set(formatting, key, runFormatting[key]);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+function paragraphRunDefaults(pmAttrs, theme, fontAlternates) {
+	return textFormattingToRunFormatting(pmAttrs.defaultTextFormatting, theme, fontAlternates);
+}
+//#endregion
+export { isAutomaticTextColorValue, listMarkerFormattingFor, paragraphRunDefaults, resolveComplexScriptThemeFont, resolveEastAsiaThemeFont, resolveWesternThemeFont };

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

@@ -1,102 +1,10 @@
-import { document_d_exports } from "../../types/document.js";
-import { BorderStyle, FlowBlock, ParagraphAttrs, TableBlock } from "../../layout-engine/types.js";
-import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { FlowBlock } from "../../layout-engine/types.js";
 import { formatCounter, resolveListTemplate } from "../../prosemirror/listMarker.js";
+import { ToFlowBlocksOptions, resetBlockIdCounter } from "./flowConversionShared.js";
+import { collectNoteRefs, isNoteReferenceMarkXml } from "./noteReferences.js";
+import { convertBorderSpecToLayout } from "./flowBorders.js";
 import { Node } from "prosemirror-model";
 //#region src/layout-bridge/convert/toFlowBlocks.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>;
-};
-/**
- * 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;
 /**
  * Word's layout fallback when an imported OOXML style hierarchy never supplies
  * `w:sz`. ECMA-376 deliberately leaves that terminal fallback to the consumer;
@@ -105,22 +13,6 @@ declare function isNoteReferenceMarkXml(xml: string): boolean;
  * default.
  */
 declare const WORD_UNSPECIFIED_FONT_SIZE = 10;
-/**
- * Reset the block ID counter (useful for testing).
- */
-declare function resetBlockIdCounter(): void;
-/** 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;
 /**
  * Convert a ProseMirror document to FlowBlock array.
  *
@@ -129,4 +21,4 @@ declare function convertBorderSpecToLayout(border: ConvertibleBorder, theme?: do
  */
 declare function toFlowBlocks(doc: Node, options?: ToFlowBlocksOptions): FlowBlock[];
 //#endregion
-export { ToFlowBlocksOptions, WORD_UNSPECIFIED_FONT_SIZE, collectNoteRefs, convertBorderSpecToLayout, formatCounter, isNoteReferenceMarkXml, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };
+export { type ToFlowBlocksOptions, WORD_UNSPECIFIED_FONT_SIZE, collectNoteRefs, convertBorderSpecToLayout, formatCounter, isNoteReferenceMarkXml, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };