@stll/folio-core 0.0.1-placeholder.0 → 0.1.1

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

@@ -0,0 +1,1309 @@
+import { NUMBER_FORMAT_VALUES } from "../../types/documentEnumValues.js";
+import { halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
+import { padDecimal } from "../../docx/numberingParser.js";
+import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
+import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
+import { resolveShadingFill } from "../../utils/formatToStyle.js";
+import { convertBulletToUnicode } from "../../docx/bulletMarkers.js";
+import { directionIsRtl } from "../../prosemirror/paragraphDirection.js";
+import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
+import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
+import { assertValidProseMirrorDocument } from "../../prosemirror/validation.js";
+//#region src/layout-bridge/convert/toFlowBlocks.ts
+const DEFAULT_FONT = "Calibri";
+const DEFAULT_TABLE_CELL_MARGIN_TWIPS = {
+	top: 0,
+	right: 108,
+	bottom: 0,
+	left: 108
+};
+const DEFAULT_BLACK_TEXT_COLOR_VALUES = /* @__PURE__ */ new Set(["000000", "000"]);
+function normalizeResolvedTextColor(color) {
+	return color.trim().toLowerCase().replace(/^#/u, "");
+}
+function isDefaultBlackResolvedTextColor(color) {
+	return DEFAULT_BLACK_TEXT_COLOR_VALUES.has(normalizeResolvedTextColor(color));
+}
+function areResolvedTextColorsEqual(left, right) {
+	return normalizeResolvedTextColor(left) === normalizeResolvedTextColor(right);
+}
+/**
+* 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
+	};
+}
+const DEFAULT_SIZE = 11;
+/**
+* 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}`;
+}
+function formatNumberedMarker(counters, level) {
+	const parts = [];
+	for (let i = 0; i <= level; i += 1) {
+		const value = counters[i] ?? 0;
+		if (value <= 0) break;
+		parts.push(value);
+	}
+	if (parts.length === 0) return "1.";
+	return `${parts.join(".")}.`;
+}
+const ROMAN_PAIRS = [
+	[1e3, "M"],
+	[900, "CM"],
+	[500, "D"],
+	[400, "CD"],
+	[100, "C"],
+	[90, "XC"],
+	[50, "L"],
+	[40, "XL"],
+	[10, "X"],
+	[9, "IX"],
+	[5, "V"],
+	[4, "IV"],
+	[1, "I"]
+];
+function toRoman(value, upper) {
+	if (value <= 0) return "";
+	let remaining = value;
+	let output = "";
+	for (const [number, symbol] of ROMAN_PAIRS) while (remaining >= number) {
+		output += symbol;
+		remaining -= number;
+	}
+	return upper ? output : output.toLowerCase();
+}
+function toLetter(value, upper) {
+	if (value <= 0) return "";
+	const zeroBased = value - 1;
+	const baseCodePoint = upper ? 65 : 97;
+	return String.fromCodePoint(baseCodePoint + zeroBased % 26).repeat(Math.floor(zeroBased / 26) + 1);
+}
+function formatCounter(value, format) {
+	if (value <= 0) return "";
+	switch (format) {
+		case "upperRoman": return toRoman(value, true);
+		case "lowerRoman": return toRoman(value, false);
+		case "upperLetter": return toLetter(value, true);
+		case "lowerLetter": return toLetter(value, false);
+		case "decimalZero": return padDecimal(value, 2);
+		case "decimalZero3": return padDecimal(value, 3);
+		case "decimalZero4": return padDecimal(value, 4);
+		case "decimalZero5": return padDecimal(value, 5);
+		case "none": return "";
+		default: return String(value);
+	}
+}
+function resolveListTemplate(template, counters, levelFormats, forceDecimal = false) {
+	return template.replace(/%(?<digit>\d)(?<punct>[.):\]])?/gu, (...args) => {
+		const { digit, punct = "" } = args.at(-1);
+		const index = Number.parseInt(digit, 10) - 1;
+		if (index < 0) return "";
+		const formatted = formatCounter(counters[index] ?? 0, forceDecimal ? "decimal" : levelFormats?.[index]);
+		return formatted ? `${formatted}${punct}` : "";
+	});
+}
+function getLastListCounters(listCounters) {
+	let lastCounters;
+	for (const counters of listCounters.values()) lastCounters = counters;
+	return lastCounters;
+}
+function applyMarkerAllCaps(marker, allCaps) {
+	if (marker === null || !allCaps) return marker;
+	return marker.toLocaleUpperCase();
+}
+function computeListMarker(pmAttrs, listCounters, abstractCounters, seenNumIds) {
+	const numId = pmAttrs.numPr?.numId;
+	if (numId === void 0 || numId === 0) {
+		if (pmAttrs.listMarker?.includes("%") && !pmAttrs.listIsBullet) {
+			const counters = getLastListCounters(listCounters);
+			if (counters) return resolveListTemplate(pmAttrs.listMarker, counters, pmAttrs.listLevelNumFmts, pmAttrs.listIsLegal);
+		}
+		return null;
+	}
+	if (pmAttrs.listIsBullet) return convertBulletToUnicode(pmAttrs.listMarker || "");
+	const level = pmAttrs.numPr?.ilvl ?? 0;
+	const counters = listCounters.get(numId) ?? Array.from({ length: 9 }, () => 0);
+	const abstractNumId = pmAttrs.listAbstractNumId;
+	if (abstractNumId !== void 0 && level > 0) {
+		const latestAbstractCounters = abstractCounters.get(abstractNumId);
+		const missingParentCounters = counters.slice(0, level).every((value) => value === 0);
+		if (latestAbstractCounters && missingParentCounters) for (let i = 0; i < level; i += 1) counters[i] = latestAbstractCounters[i] ?? 0;
+	}
+	const seenKey = `${numId}:${level}`;
+	if (!seenNumIds.has(seenKey)) {
+		seenNumIds.add(seenKey);
+		if (pmAttrs.listStartOverride != null) counters[level] = pmAttrs.listStartOverride - 1;
+	}
+	counters[level] = (counters[level] ?? 0) + 1;
+	for (let i = level + 1; i < counters.length; i += 1) counters[i] = 0;
+	const childAdvances = pmAttrs.listImplicitChildLevelAdvances ?? 0;
+	if (childAdvances > 0 && level + 1 < counters.length) counters[level + 1] = (counters[level + 1] ?? 0) + childAdvances;
+	listCounters.set(numId, counters);
+	if (abstractNumId !== void 0) abstractCounters.set(abstractNumId, [...counters]);
+	const levelFormats = pmAttrs.listLevelNumFmts ?? (pmAttrs.listNumFmt ? [pmAttrs.listNumFmt] : void 0);
+	if (pmAttrs.listMarker && pmAttrs.listMarker.includes("%")) return resolveListTemplate(pmAttrs.listMarker, counters, levelFormats, pmAttrs.listIsLegal);
+	if (pmAttrs.listMarker) return pmAttrs.listMarker;
+	if ((levelFormats?.[level] ?? pmAttrs.listNumFmt) === "none" || pmAttrs.listMarker === "") return null;
+	return formatNumberedMarker(counters, level);
+}
+/**
+* Reset the block ID counter (useful for testing).
+*/
+function resetBlockIdCounter() {
+	blockIdCounter = 0;
+}
+/**
+* Extract run formatting from ProseMirror marks.
+*/
+function extractRunFormatting(marks, theme) {
+	const formatting = {};
+	let hasNoteRef = false;
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline": {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			if (attrs.style || attrs.color) {
+				const underlineObj = {};
+				if (attrs.style) underlineObj.style = attrs.style;
+				if (attrs.color) underlineObj.color = resolveColor(attrs.color, theme);
+				formatting.underline = underlineObj;
+			} else formatting.underline = true;
+			break;
+		}
+		case "strike":
+			formatting.strike = true;
+			break;
+		case "textColor": {
+			const attrs = expectTextColorMarkAttrs(mark);
+			if (attrs.themeColor || attrs.rgb) {
+				const colorArg = {};
+				if (attrs.rgb) colorArg.rgb = attrs.rgb;
+				if (attrs.themeColor) colorArg.themeColor = attrs.themeColor;
+				if (attrs.themeTint) colorArg.themeTint = attrs.themeTint;
+				if (attrs.themeShade) colorArg.themeShade = attrs.themeShade;
+				if (!isAutomaticTextColorValue(colorArg)) {
+					formatting.color = resolveColor(colorArg, theme);
+					formatting.textColorSource = "direct";
+				}
+			}
+			break;
+		}
+		case "highlight":
+			formatting.highlight = resolveHighlightToCss(expectHighlightMarkAttrs(mark).color);
+			break;
+		case "runShading": {
+			const shadingCss = resolveShadingFill(runShadingAttrsToShading(expectRunShadingMarkAttrs(mark)), theme);
+			if (shadingCss) formatting.shading = shadingCss;
+			break;
+		}
+		case "fontSize":
+			formatting.fontSize = expectFontSizeMarkAttrs(mark).size / 2;
+			break;
+		case "fontFamily": {
+			const attrs = expectFontFamilyMarkAttrs(mark);
+			const font = attrs.ascii || attrs.hAnsi;
+			if (font) formatting.fontFamily = font;
+			if (attrs.eastAsia) formatting.eastAsiaFontFamily = attrs.eastAsia;
+			break;
+		}
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0 && attrs.spacing !== 0) formatting.letterSpacing = twipsToPixels(attrs.spacing);
+			if (attrs.position !== void 0 && attrs.position !== 0) formatting.positionPx = halfPointsToPixels(attrs.position);
+			if (attrs.scale !== void 0 && attrs.scale !== 100) formatting.horizontalScale = attrs.scale;
+			if (attrs.kerning !== void 0 && attrs.kerning > 0) formatting.kerningMinPt = halfPointsToPoints(attrs.kerning);
+			break;
+		}
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.textShadow = true;
+			break;
+		case "textOutline":
+			formatting.textOutline = true;
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "textEffect":
+			formatting.textEffect = expectTextEffectMarkAttrs(mark).effect;
+			break;
+		case "runFormattingOverride":
+			applyRunFormattingOverrides(formatting, expectRunFormattingOverrideMarkAttrs(mark));
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type ?? "dot";
+			break;
+		case "superscript":
+			formatting.superscript = true;
+			break;
+		case "subscript":
+			formatting.subscript = true;
+			break;
+		case "hyperlink": {
+			const attrs = expectHyperlinkMarkAttrs(mark);
+			const link = { href: attrs.href };
+			if (attrs.tooltip !== void 0) link.tooltip = attrs.tooltip;
+			formatting.hyperlink = link;
+			break;
+		}
+		case "footnoteRef": {
+			hasNoteRef = true;
+			const attrs = expectFootnoteRefMarkAttrs(mark);
+			if (attrs.vertAlign === "superscript") formatting.superscript = true;
+			const id = typeof attrs.id === "string" ? Number.parseInt(attrs.id, 10) : attrs.id;
+			if (attrs.noteType === "endnote") formatting.endnoteRefId = id;
+			else formatting.footnoteRefId = id;
+			break;
+		}
+		case "comment": {
+			const commentId = expectCommentMarkAttrs(mark).commentId;
+			if (commentId) {
+				if (!formatting.commentIds) formatting.commentIds = [];
+				formatting.commentIds.push(commentId);
+			}
+			break;
+		}
+		case "insertion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isInsertion = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			break;
+		}
+		case "deletion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isDeletion = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			break;
+		}
+		default: break;
+	}
+	if (hasNoteRef && formatting.subscript) delete formatting.superscript;
+	return formatting;
+}
+function isAutomaticTextColorValue(color) {
+	const rgb = color.rgb?.trim().toLowerCase();
+	return color.auto === true || rgb === "auto" || !rgb && !color.themeColor;
+}
+function markDefaultBlackTextColorSource(formatting, paraDefaults) {
+	if (formatting.textColorSource === "direct" || formatting.color === void 0 || paraDefaults.color === void 0 || !isDefaultBlackResolvedTextColor(formatting.color) || !areResolvedTextColorsEqual(formatting.color, paraDefaults.color)) return formatting;
+	return {
+		...formatting,
+		textColorSource: "paragraphDefault"
+	};
+}
+function mergeRunFormatting(paraDefaults, formatting) {
+	return {
+		...paraDefaults,
+		...markDefaultBlackTextColorSource(formatting, paraDefaults)
+	};
+}
+function applyRunFormattingOverrides(formatting, attrs) {
+	if (attrs.bold === false) formatting.bold = false;
+	if (attrs.italic === false) formatting.italic = false;
+	if (attrs.underline === "none") formatting.underline = false;
+	if (attrs.strike === false) formatting.strike = false;
+	if (attrs.allCaps === false) formatting.allCaps = false;
+	if (attrs.smallCaps === false) formatting.smallCaps = false;
+	if (attrs.emboss === false) formatting.emboss = false;
+	if (attrs.imprint === false) formatting.imprint = false;
+	if (attrs.shadow === false) formatting.textShadow = false;
+	if (attrs.outline === false) formatting.textOutline = false;
+	if (attrs.rtl === false) formatting.rtl = false;
+}
+function paragraphRunDefaults(pmAttrs, theme) {
+	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
+	if (!defaultTextFormatting) return {};
+	const result = {};
+	const fontFamily = defaultTextFormatting.fontFamily?.ascii ?? defaultTextFormatting.fontFamily?.hAnsi;
+	if (fontFamily) result.fontFamily = fontFamily;
+	if (defaultTextFormatting.fontFamily?.eastAsia) result.eastAsiaFontFamily = defaultTextFormatting.fontFamily.eastAsia;
+	if (defaultTextFormatting.fontSize !== void 0) result.fontSize = defaultTextFormatting.fontSize / 2;
+	if (defaultTextFormatting.bold !== void 0) result.bold = defaultTextFormatting.bold;
+	if (defaultTextFormatting.italic !== void 0) result.italic = defaultTextFormatting.italic;
+	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);
+	if (defaultTextFormatting.scale !== void 0 && defaultTextFormatting.scale !== 100) result.horizontalScale = defaultTextFormatting.scale;
+	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;
+}
+/**
+* Build an ImageRun from ProseMirror node attrs, applying conditional property assignment
+* to satisfy exactOptionalPropertyTypes.
+*/
+function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
+	const run = {
+		kind: "image",
+		src: attrs.src,
+		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.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.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.position !== void 0) run.position = attrs.position;
+	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;
+}
+/**
+* Paragraph styleId pattern used by Word for TOC entries (TOC, TOC1, TOC2, …).
+* Hyperlinks inside these paragraphs must render in the paragraph's own colour,
+* not the Hyperlink character style — see {@link stripTocHyperlinkStyle}.
+*/
+const TOC_STYLE_ID = /^TOC\d*$/iu;
+/**
+* In TOC paragraphs, strip the resolved Hyperlink character-style colour and
+* underline so the painter's link fallback doesn't fire. The PM doc keeps the
+* original marks so copy/paste out of a TOC still carries the Hyperlink
+* styling like Word does. Applies to both text and field runs — a TOC entry's
+* page number is a PAGEREF field inside the entry's hyperlink.
+*
+* Mutates `formatting` in place; cheaper than re-cloning per run.
+*/
+function stripTocHyperlinkStyle(formatting) {
+	if (!formatting.hyperlink) return;
+	formatting.hyperlink = {
+		...formatting.hyperlink,
+		noDefaultStyle: true
+	};
+	delete formatting.color;
+	delete formatting.underline;
+}
+/**
+* Convert a paragraph node to runs.
+*/
+function paragraphToRuns(node, startPos, _options) {
+	const runs = [];
+	const offset = startPos + 1;
+	const theme = _options.theme;
+	const pmAttrs = expectParagraphAttrs(node);
+	const paraDefaults = paragraphRunDefaults(pmAttrs, theme);
+	const paragraphStyleId = pmAttrs.styleId;
+	const inTocParagraph = typeof paragraphStyleId === "string" && TOC_STYLE_ID.test(paragraphStyleId);
+	function pushRunsForChild(child, childPos) {
+		if (child.isText && child.text) {
+			const formatting = extractRunFormatting(child.marks, theme);
+			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
+			const run = {
+				kind: "text",
+				text: child.text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "hardBreak") {
+			runs.push({
+				kind: "lineBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "tab") {
+			const run = {
+				kind: "tab",
+				...mergeRunFormatting(paraDefaults, extractRunFormatting(child.marks, theme)),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "image") {
+			const attrs = expectImageAttrs(child);
+			const constrained = constrainImageToPage(attrs.width || 100, attrs.height || 100, _options.pageContentHeight);
+			const trackedFmt = extractRunFormatting(child.marks, theme);
+			const run = buildImageRun(attrs, constrained, childPos, childPos + child.nodeSize, trackedFmt);
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "field") {
+			const attrs = expectFieldAttrs(child);
+			const ft = attrs.fieldType;
+			let mappedType = "OTHER";
+			if (ft === "PAGE") mappedType = "PAGE";
+			else if (ft === "NUMPAGES") mappedType = "NUMPAGES";
+			else if (ft === "DATE") mappedType = "DATE";
+			else if (ft === "TIME") mappedType = "TIME";
+			const extractedFieldFormatting = extractRunFormatting(child.marks, theme);
+			if (inTocParagraph) stripTocHyperlinkStyle(extractedFieldFormatting);
+			const fieldFormatting = markDefaultBlackTextColorSource(extractedFieldFormatting, paraDefaults);
+			const run = {
+				kind: "field",
+				fieldType: mappedType,
+				instruction: attrs.instruction,
+				fallback: attrs.displayText || "",
+				...attrs.fldLock ? { fldLock: true } : {},
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize,
+				...fieldFormatting
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "math") {
+			const attrs = expectMathAttrs(child);
+			const plainText = attrs.plainText || "[equation]";
+			runs.push({
+				kind: "math",
+				display: attrs.display ?? "inline",
+				ommlXml: attrs.ommlXml,
+				plainText,
+				italic: true,
+				fontFamily: "Cambria Math",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "sdt") {
+			const sdtInnerOffset = childPos + 1;
+			child.forEach((sdtChild, sdtChildOffset) => {
+				pushRunsForChild(sdtChild, sdtInnerOffset + sdtChildOffset);
+			});
+		}
+	}
+	node.forEach((child, childOffset) => {
+		pushRunsForChild(child, offset + childOffset);
+	});
+	return runs;
+}
+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"]) && !areListNumPrEqual(previousFormatting["numPr"], currentNumPr);
+}
+function areListNumPrEqual(left, right) {
+	return left.numId === right.numId && left.ilvl === right.ilvl;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isListNumPr(value) {
+	if (!isRecord(value)) return false;
+	const numId = value["numId"];
+	const ilvl = value["ilvl"];
+	return (numId === void 0 || typeof numId === "number") && (ilvl === void 0 || typeof ilvl === "number");
+}
+function isNumberFormat(value) {
+	return NUMBER_FORMAT_VALUES.some((format) => format === value);
+}
+function readNumberFormats(value) {
+	if (!Array.isArray(value)) return;
+	const formats = [];
+	for (const item of value) {
+		if (!isNumberFormat(item)) return;
+		formats.push(item);
+	}
+	return formats;
+}
+function readListMarkerSuffix(value) {
+	if (value === "tab" || value === "space" || value === "nothing") return value;
+}
+function toPreviousListAttrs(previousFormatting) {
+	const attrs = {};
+	const numPr = previousFormatting["numPr"];
+	if (isListNumPr(numPr)) attrs.numPr = numPr;
+	const listIsBullet = previousFormatting["listIsBullet"];
+	if (typeof listIsBullet === "boolean") attrs.listIsBullet = listIsBullet;
+	const listIsLegal = previousFormatting["listIsLegal"];
+	if (typeof listIsLegal === "boolean") attrs.listIsLegal = listIsLegal;
+	const listMarker = previousFormatting["listMarker"];
+	if (typeof listMarker === "string") attrs.listMarker = listMarker;
+	const listNumFmt = previousFormatting["listNumFmt"];
+	if (isNumberFormat(listNumFmt)) attrs.listNumFmt = listNumFmt;
+	const listLevelNumFmts = readNumberFormats(previousFormatting["listLevelNumFmts"]);
+	if (listLevelNumFmts) attrs.listLevelNumFmts = listLevelNumFmts;
+	const listAbstractNumId = previousFormatting["listAbstractNumId"];
+	if (typeof listAbstractNumId === "number") attrs.listAbstractNumId = listAbstractNumId;
+	const listStartOverride = previousFormatting["listStartOverride"];
+	if (typeof listStartOverride === "number") attrs.listStartOverride = listStartOverride;
+	const listMarkerHidden = previousFormatting["listMarkerHidden"];
+	if (typeof listMarkerHidden === "boolean") attrs.listMarkerHidden = listMarkerHidden;
+	const listMarkerFontFamily = previousFormatting["listMarkerFontFamily"];
+	if (typeof listMarkerFontFamily === "string") attrs.listMarkerFontFamily = listMarkerFontFamily;
+	const listMarkerFontSize = previousFormatting["listMarkerFontSize"];
+	if (typeof listMarkerFontSize === "number") attrs.listMarkerFontSize = listMarkerFontSize;
+	const listMarkerSuffix = readListMarkerSuffix(previousFormatting["listMarkerSuffix"]);
+	if (listMarkerSuffix) attrs.listMarkerSuffix = listMarkerSuffix;
+	return attrs;
+}
+function resolveDeletedListMarker(previousListAttrs, listCounters, listAbstractCounters, listSeenNumIds) {
+	if (listCounters && previousListAttrs.numPr) {
+		const marker = computeListMarker(previousListAttrs, listCounters, listAbstractCounters ?? /* @__PURE__ */ new Map(), listSeenNumIds ?? /* @__PURE__ */ new Set());
+		if (marker) return marker;
+	}
+	if (previousListAttrs.listMarker) return previousListAttrs.listIsBullet ? convertBulletToUnicode(previousListAttrs.listMarker) : previousListAttrs.listMarker;
+	if (previousListAttrs.listIsBullet) return "•";
+	return null;
+}
+function applyDeletedListMarkerAttrs(attrs, change, listCounters, listAbstractCounters, listSeenNumIds) {
+	const previousListAttrs = toPreviousListAttrs(change.previousFormatting);
+	const marker = resolveDeletedListMarker(previousListAttrs, listCounters, listAbstractCounters, listSeenNumIds);
+	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;
+	if (previousListAttrs.listMarkerFontFamily) attrs.listMarkerFontFamily = previousListAttrs.listMarkerFontFamily;
+	if (previousListAttrs.listMarkerFontSize) attrs.listMarkerFontSize = previousListAttrs.listMarkerFontSize;
+	if (previousListAttrs.listMarkerSuffix) attrs.listMarkerSuffix = previousListAttrs.listMarkerSuffix;
+}
+function convertParagraphAttrs(pmAttrs, theme, listCounters, listAbstractCounters, listSeenNumIds, defaultTabStopTwips, originalListCounters, originalListAbstractCounters, originalListSeenNumIds) {
+	const attrs = {};
+	if (pmAttrs.alignment) {
+		const align = pmAttrs.alignment;
+		if (align === "both" || align === "distribute") attrs.alignment = "justify";
+		else if (align === "left") attrs.alignment = "left";
+		else if (align === "center") attrs.alignment = "center";
+		else if (align === "right") attrs.alignment = "right";
+	}
+	const spaceBefore = pmAttrs.spaceBefore;
+	const spaceAfter = pmAttrs.spaceAfter;
+	const lineSpacing = pmAttrs.lineSpacing;
+	const autoBefore = autospacingMatchesBase(pmAttrs._autospacingBase, "before", spaceBefore);
+	const autoAfter = autospacingMatchesBase(pmAttrs._autospacingBase, "after", spaceAfter);
+	if (autoBefore || autoAfter || typeof spaceBefore === "number" || typeof spaceAfter === "number" || typeof lineSpacing === "number") {
+		attrs.spacing = {};
+		if (autoBefore) attrs.spacing.before = 14;
+		else if (typeof spaceBefore === "number") attrs.spacing.before = twipsToPixels(spaceBefore);
+		if (autoAfter) attrs.spacing.after = 14;
+		else if (typeof spaceAfter === "number") attrs.spacing.after = twipsToPixels(spaceAfter);
+		const pmSpacingExplicit = pmAttrs.spacingExplicit;
+		const explicit = {};
+		if (autoBefore || pmSpacingExplicit?.before) explicit.before = true;
+		if (autoAfter || pmSpacingExplicit?.after) explicit.after = true;
+		if (explicit.before !== void 0 || explicit.after !== void 0) attrs.spacingExplicit = explicit;
+		if (typeof lineSpacing === "number") if (pmAttrs.lineSpacingRule === "exact" || pmAttrs.lineSpacingRule === "atLeast") {
+			attrs.spacing.line = twipsToPixels(lineSpacing);
+			attrs.spacing.lineUnit = "px";
+			attrs.spacing.lineRule = pmAttrs.lineSpacingRule;
+		} else {
+			attrs.spacing.line = lineSpacing / 240;
+			attrs.spacing.lineUnit = "multiplier";
+			attrs.spacing.lineRule = "auto";
+		}
+	}
+	let indentLeft = typeof pmAttrs.indentLeft === "number" ? pmAttrs.indentLeft : void 0;
+	let indentFirstLine = typeof pmAttrs.indentFirstLine === "number" ? pmAttrs.indentFirstLine : void 0;
+	let hangingIndent = pmAttrs.hangingIndent;
+	if (pmAttrs.numPr?.numId && indentLeft === void 0) {
+		indentLeft = ((pmAttrs.numPr.ilvl ?? 0) + 1) * 720;
+		if (indentFirstLine === void 0) {
+			indentFirstLine = -360;
+			hangingIndent = true;
+		}
+	}
+	if (indentLeft !== void 0 || typeof pmAttrs.indentRight === "number" || indentFirstLine !== void 0) {
+		attrs.indent = {};
+		if (indentLeft !== void 0) attrs.indent.left = twipsToPixels(indentLeft);
+		if (typeof pmAttrs.indentRight === "number") attrs.indent.right = twipsToPixels(pmAttrs.indentRight);
+		if (indentFirstLine !== void 0) if (hangingIndent) attrs.indent.hanging = Math.abs(twipsToPixels(indentFirstLine));
+		else attrs.indent.firstLine = twipsToPixels(indentFirstLine);
+	}
+	if (pmAttrs.styleId) attrs.styleId = pmAttrs.styleId;
+	if (pmAttrs.borders) {
+		const borders = pmAttrs.borders;
+		attrs.borders = {};
+		const convertBorder = (border) => border ? convertBorderSpecToLayout(border, theme) : void 0;
+		const topBorder = borders.top ? convertBorder(borders.top) : void 0;
+		if (topBorder) attrs.borders.top = topBorder;
+		const bottomBorder = borders.bottom ? convertBorder(borders.bottom) : void 0;
+		if (bottomBorder) attrs.borders.bottom = bottomBorder;
+		const leftBorder = borders.left ? convertBorder(borders.left) : void 0;
+		if (leftBorder) attrs.borders.left = leftBorder;
+		const rightBorder = borders.right ? convertBorder(borders.right) : void 0;
+		if (rightBorder) attrs.borders.right = rightBorder;
+		const betweenBorder = borders.between ? convertBorder(borders.between) : void 0;
+		if (betweenBorder) attrs.borders.between = betweenBorder;
+		const barBorder = borders.bar ? convertBorder(borders.bar) : void 0;
+		if (barBorder) attrs.borders.bar = barBorder;
+		if (!attrs.borders.top && !attrs.borders.bottom && !attrs.borders.left && !attrs.borders.right && !attrs.borders.between && !attrs.borders.bar) delete attrs.borders;
+	}
+	const shadingRgb = pmAttrs.shading?.fill?.rgb?.toUpperCase();
+	if (shadingRgb && shadingRgb !== "FFFFFF" && shadingRgb !== "FFFFFE") attrs.shading = `#${pmAttrs.shading?.fill?.rgb}`;
+	if (pmAttrs.tabs && pmAttrs.tabs.length > 0) attrs.tabs = pmAttrs.tabs.map((tab) => {
+		const tabStop = {
+			val: mapTabAlignment(tab.alignment),
+			pos: tab.position
+		};
+		if (tab.leader) tabStop.leader = tab.leader;
+		return tabStop;
+	});
+	if (pmAttrs.pageBreakBefore) attrs.pageBreakBefore = true;
+	if (pmAttrs.keepNext) attrs.keepNext = true;
+	if (pmAttrs.keepLines) attrs.keepLines = true;
+	if (pmAttrs.contextualSpacing) attrs.contextualSpacing = true;
+	if (pmAttrs.runInWithNext) attrs.runInWithNext = true;
+	if (directionIsRtl(pmAttrs.direction)) attrs.bidi = true;
+	if (pmAttrs.styleId) attrs.styleId = pmAttrs.styleId;
+	const pPrChange = pmAttrs._propertyChanges;
+	const propertyChanges = Array.isArray(pPrChange) ? pPrChange : [];
+	let changedNumberingChange;
+	if (pmAttrs.numPr) {
+		const numPr = {};
+		if (pmAttrs.numPr.numId !== void 0) numPr.numId = pmAttrs.numPr.numId;
+		if (pmAttrs.numPr.ilvl !== void 0) numPr.ilvl = pmAttrs.numPr.ilvl;
+		attrs.numPr = numPr;
+		if (pmAttrs.pPrMark?.kind === "del") attrs.listMarkerRevision = toListMarkerRevision("del", pmAttrs.pPrMark.info);
+		else if (pmAttrs.pPrMark?.kind === "ins") attrs.listMarkerRevision = toListMarkerRevision("ins", pmAttrs.pPrMark.info);
+		else {
+			const numberingAddedChange = propertyChanges.find(isAddedNumberingChange);
+			const currentNumPr = pmAttrs.numPr;
+			changedNumberingChange = propertyChanges.find((change) => isChangedNumberingChange(currentNumPr, change));
+			const numberingInsertionChange = numberingAddedChange ?? changedNumberingChange;
+			if (numberingInsertionChange) attrs.listMarkerRevision = toListMarkerRevision("ins", numberingInsertionChange.info);
+		}
+	}
+	const useOriginalStream = attrs.listMarkerRevision?.kind === "del" && originalListCounters !== void 0;
+	const streamCounters = useOriginalStream ? originalListCounters : listCounters;
+	const resolvedMarker = applyMarkerAllCaps(streamCounters ? computeListMarker(pmAttrs, streamCounters, (useOriginalStream ? originalListAbstractCounters : listAbstractCounters) ?? /* @__PURE__ */ new Map(), (useOriginalStream ? originalListSeenNumIds : listSeenNumIds) ?? /* @__PURE__ */ new Set()) : null, pmAttrs.listMarkerAllCaps);
+	const numberedNumId = pmAttrs.numPr?.numId;
+	if (attrs.listMarkerRevision === void 0 && !pmAttrs.listIsBullet && originalListCounters !== void 0 && numberedNumId !== void 0 && numberedNumId !== 0) computeListMarker(pmAttrs, originalListCounters, originalListAbstractCounters ?? /* @__PURE__ */ new Map(), originalListSeenNumIds ?? /* @__PURE__ */ new Set());
+	else if (changedNumberingChange !== void 0 && originalListCounters !== void 0) {
+		const previousListAttrs = toPreviousListAttrs(changedNumberingChange.previousFormatting);
+		if (previousListAttrs.numPr && !previousListAttrs.listIsBullet) computeListMarker(previousListAttrs, originalListCounters, originalListAbstractCounters ?? /* @__PURE__ */ new Map(), originalListSeenNumIds ?? /* @__PURE__ */ new Set());
+	}
+	if (resolvedMarker !== null) attrs.listMarker = resolvedMarker;
+	else if (pmAttrs.listMarker) attrs.listMarker = pmAttrs.listIsBullet ? convertBulletToUnicode(pmAttrs.listMarker) : pmAttrs.listMarker;
+	if (pmAttrs.listIsBullet !== void 0) attrs.listIsBullet = pmAttrs.listIsBullet;
+	if (pmAttrs.listMarkerHidden) attrs.listMarkerHidden = true;
+	if (pmAttrs.listMarkerFontFamily) attrs.listMarkerFontFamily = pmAttrs.listMarkerFontFamily;
+	if (pmAttrs.listMarkerFontSize) attrs.listMarkerFontSize = pmAttrs.listMarkerFontSize;
+	if (pmAttrs.listMarkerSuffix) attrs.listMarkerSuffix = pmAttrs.listMarkerSuffix;
+	if (pmAttrs.listMarkerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = pmAttrs.listMarkerSecondSlotOffsetTwips;
+	if (!pmAttrs.numPr) {
+		const numberingRemovedChange = propertyChanges.find(isRemovedNumberingChange);
+		if (numberingRemovedChange) applyDeletedListMarkerAttrs(attrs, numberingRemovedChange, originalListCounters, originalListAbstractCounters, originalListSeenNumIds);
+	}
+	if (defaultTabStopTwips !== void 0) attrs.defaultTabStopTwips = defaultTabStopTwips;
+	const dtf = pmAttrs.defaultTextFormatting;
+	if (dtf) {
+		if (dtf.fontSize !== void 0) attrs.defaultFontSize = dtf.fontSize / 2;
+		if (dtf.fontFamily) {
+			const resolvedFamily = dtf.fontFamily.ascii || dtf.fontFamily.hAnsi;
+			if (resolvedFamily) attrs.defaultFontFamily = resolvedFamily;
+		}
+	}
+	return attrs;
+}
+/**
+* Map document TabStopAlignment to layout engine TabAlignment
+*/
+function mapTabAlignment(align) {
+	switch (align) {
+		case "left": return "start";
+		case "right": return "end";
+		case "center": return "center";
+		case "decimal": return "decimal";
+		case "bar": return "bar";
+		case "clear": return "clear";
+		case "num": return "start";
+		default: return "start";
+	}
+}
+/**
+* Convert a paragraph node to a ParagraphBlock.
+*/
+function convertParagraph(node, startPos, options) {
+	const pmAttrs = expectParagraphAttrs(node);
+	const runs = paragraphToRuns(node, startPos, options);
+	const attrs = convertParagraphAttrs(pmAttrs, options.theme, options.listCounters, options.listAbstractCounters, options.listSeenNumIds, options.defaultTabStopTwips, options.originalListCounters, options.originalListAbstractCounters, options.originalListSeenNumIds);
+	const bookmarkNames = pmAttrs.bookmarks?.map((b) => b.name);
+	return {
+		kind: "paragraph",
+		id: nextBlockId(),
+		runs,
+		attrs,
+		...bookmarkNames && bookmarkNames.length > 0 ? { bookmarks: bookmarkNames } : {},
+		pmStart: startPos,
+		pmEnd: startPos + node.nodeSize
+	};
+}
+/**
+* Convert border width from eighths of a point to pixels.
+* OOXML stores border widths in eighths of a point.
+*/
+function borderWidthToPixels(eighthsOfPoint) {
+	return Math.max(1, Math.round(eighthsOfPoint / 8 * 1.333));
+}
+const OOXML_TO_CSS_BORDER = {
+	single: "solid",
+	double: "double",
+	dotted: "dotted",
+	dashed: "dashed",
+	thick: "solid",
+	dashSmallGap: "dashed",
+	dotDash: "dashed",
+	dotDotDash: "dotted",
+	triple: "double",
+	wave: "solid",
+	doubleWave: "double",
+	threeDEmboss: "ridge",
+	threeDEngrave: "groove",
+	outset: "outset",
+	inset: "inset"
+};
+/**
+* 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 || border.style === "none" || border.style === "nil") return;
+	const result = {
+		style: OOXML_TO_CSS_BORDER[border.style] || "solid",
+		width: borderWidthToPixels(border.size ?? 0),
+		color: border.color ? resolveColor(border.color, theme) : "#000000"
+	};
+	if (border.space !== void 0) result.space = pointsToPixels(border.space);
+	return result;
+}
+/**
+* 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];
+		result[side] = (border ? convertBorderSpecToLayout(border, theme) : void 0) ?? {
+			width: 0,
+			style: "none"
+		};
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+/**
+* Convert a table cell node.
+*/
+function convertTableCell(node, startPos, options, tableCellMargins) {
+	const blocks = [];
+	let offset = startPos + 1;
+	node.forEach((child) => {
+		if (child.type.name === "paragraph") {
+			const block = convertParagraph(child, offset, options);
+			blocks.push(block);
+		} else if (child.type.name === "table") blocks.push(convertTable(child, offset, options));
+		offset += child.nodeSize;
+	});
+	const attrs = expectTableCellAttrs(node);
+	const margins = attrs.margins;
+	const resolvePaddingSide = (side, cellTwips, tableTwips) => {
+		if (cellTwips !== void 0) {
+			const px = twipsToPixels(cellTwips);
+			if (px > 0) return px;
+		}
+		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,
+		colSpan: attrs.colspan,
+		rowSpan: attrs.rowspan,
+		padding
+	};
+	if (attrs.width) cell.width = twipsToPixels(attrs.width);
+	if (attrs.verticalAlign) cell.verticalAlign = attrs.verticalAlign;
+	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;
+	return cell;
+}
+/**
+* Convert a table row node.
+*/
+function convertTableRow(node, startPos, options, tableCellMargins) {
+	const cells = [];
+	let offset = startPos + 1;
+	node.forEach((child) => {
+		if (child.type.name === "tableCell" || child.type.name === "tableHeader") cells.push(convertTableCell(child, offset, options, tableCellMargins));
+		offset += child.nodeSize;
+	});
+	const attrs = expectTableRowAttrs(node);
+	const row = {
+		id: nextBlockId(),
+		cells
+	};
+	if (attrs.height) row.height = twipsToPixels(attrs.height);
+	if (attrs.heightRule) row.heightRule = attrs.heightRule;
+	if (attrs.isHeader) row.isHeader = attrs.isHeader;
+	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 tableCellMargins = attrs.cellMargins;
+	node.forEach((child) => {
+		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, tableCellMargins));
+		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 justification = attrs.justification;
+	const originalFormatting = attrs._originalFormatting;
+	const indentPx = originalFormatting?.indent?.value && originalFormatting.indent.type === "dxa" ? twipsToPixels(originalFormatting.indent.value) : 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 (justification) tableBlock.justification = justification;
+	if (indentPx !== void 0) tableBlock.indent = indentPx;
+	if (floatingPx) tableBlock.floating = floatingPx;
+	if (originalFormatting?.bidi) tableBlock.bidi = true;
+	return tableBlock;
+}
+/**
+* Convert an image node to an ImageBlock.
+*/
+function convertImage(node, startPos, pageContentHeight) {
+	const attrs = expectImageAttrs(node);
+	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,
+		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 (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;
+	return imgBlock;
+}
+/**
+* Convert a textBox PM node to a TextBoxBlock.
+*/
+function convertTextBoxNode(node, startPos, opts) {
+	const attrs = expectTextBoxAttrs(node);
+	const contentBlocks = [];
+	node.forEach((child, offset) => {
+		if (child.type.name === "paragraph") {
+			const block = convertParagraph(child, startPos + 1 + offset, opts);
+			contentBlocks.push(block);
+		}
+	});
+	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
+	};
+	if (attrs.height !== void 0) textBox.height = attrs.height;
+	if (attrs.fillColor !== void 0) textBox.fillColor = attrs.fillColor;
+	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.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;
+	return textBox;
+}
+/**
+* Convert a ProseMirror document to FlowBlock array.
+*
+* Walks the document tree, converting each node to the appropriate block type.
+* Tracks pmStart/pmEnd positions for each block for click-to-position mapping.
+*/
+function toFlowBlocks(doc, options = {}) {
+	assertValidProseMirrorDocument(doc, "Cannot layout invalid ProseMirror document");
+	resetBlockIdCounter();
+	const opts = {
+		...options,
+		defaultFont: options.defaultFont ?? DEFAULT_FONT,
+		defaultSize: options.defaultSize ?? DEFAULT_SIZE,
+		listCounters: options.listCounters ?? /* @__PURE__ */ new Map(),
+		listAbstractCounters: options.listAbstractCounters ?? /* @__PURE__ */ new Map(),
+		listSeenNumIds: options.listSeenNumIds ?? /* @__PURE__ */ new Set(),
+		originalListCounters: options.originalListCounters ?? /* @__PURE__ */ new Map(),
+		originalListAbstractCounters: options.originalListAbstractCounters ?? /* @__PURE__ */ new Map(),
+		originalListSeenNumIds: options.originalListSeenNumIds ?? /* @__PURE__ */ new Set()
+	};
+	const blocks = [];
+	const offset = 0;
+	let lastSectionMarginsTwips = {
+		top: 1440,
+		bottom: 1440,
+		left: 1440,
+		right: 1440
+	};
+	let sdtSeq = 0;
+	const sdtStack = [];
+	/**
+	* Stamp the active SDT stack (outer→inner) onto every block produced by the
+	* current call. ParagraphBlock/TableBlock accept `sdtGroups`; section breaks
+	* and page breaks deliberately do not — they bracket layout, not content.
+	*/
+	const tagBlockWithSdtStack = (block) => {
+		if (sdtStack.length === 0) return;
+		if (block.kind === "paragraph" || block.kind === "table") block.sdtGroups = [...sdtStack];
+	};
+	const trackedPush = (block) => {
+		tagBlockWithSdtStack(block);
+		blocks.push(block);
+	};
+	const visit = (node, pos) => {
+		switch (node.type.name) {
+			case "blockSdt": {
+				const attrs = expectBlockSdtAttrs(node);
+				sdtSeq += 1;
+				const group = {
+					id: `sdt-${sdtSeq}`,
+					pmPos: pos,
+					sdtType: attrs.sdtType
+				};
+				if (attrs.alias) group.alias = attrs.alias;
+				if (attrs.tag) group.tag = attrs.tag;
+				if (typeof attrs.id === "number") group.sdtId = attrs.id;
+				if (attrs.lock) group.lock = attrs.lock;
+				if (attrs.showingPlaceholder) group.showingPlaceholder = true;
+				if (typeof attrs.checked === "boolean") group.checked = attrs.checked;
+				if (attrs.dateFormat) group.dateFormat = attrs.dateFormat;
+				if (attrs.listItems) group.listItemsJson = attrs.listItems;
+				sdtStack.push(group);
+				const startIndex = blocks.length;
+				let childOffset = pos + 1;
+				for (let i = 0; i < node.childCount; i += 1) {
+					const child = node.child(i);
+					visit(child, childOffset);
+					childOffset += child.nodeSize;
+				}
+				sdtStack.pop();
+				const groupBlocks = [];
+				for (let i = startIndex; i < blocks.length; i += 1) {
+					const b = blocks[i];
+					if (b && (b.kind === "paragraph" || b.kind === "table")) groupBlocks.push(b);
+				}
+				const ourPmPos = group.pmPos;
+				for (let i = 0; i < groupBlocks.length; i += 1) {
+					const b = groupBlocks[i];
+					if (!b || !b.sdtGroups) continue;
+					const idx = b.sdtGroups.findIndex((g) => g.pmPos === ourPmPos);
+					if (idx === -1) continue;
+					let position;
+					if (groupBlocks.length === 1) position = "only";
+					else if (i === 0) position = "first";
+					else if (i === groupBlocks.length - 1) position = "last";
+					else position = "middle";
+					const next = [...b.sdtGroups];
+					const existing = next[idx];
+					if (!existing) continue;
+					next[idx] = {
+						...existing,
+						position
+					};
+					b.sdtGroups = next;
+				}
+				return;
+			}
+			default: break;
+		}
+		switch (node.type.name) {
+			case "paragraph": {
+				const block = convertParagraph(node, pos, opts);
+				const pmAttrs = expectParagraphAttrs(node);
+				trackedPush(block);
+				const secProps = pmAttrs._sectionProperties;
+				if (secProps || pmAttrs.sectionBreakType) {
+					const sectionBreak = {
+						kind: "sectionBreak",
+						id: nextBlockId()
+					};
+					const breakType = secProps?.sectionStart ?? pmAttrs.sectionBreakType;
+					if (breakType) sectionBreak.type = breakType;
+					if (secProps) {
+						if (secProps.pageWidth || secProps.pageHeight) sectionBreak.pageSize = {
+							w: twipsToPixels(secProps.pageWidth ?? 12240),
+							h: twipsToPixels(secProps.pageHeight ?? 15840)
+						};
+						if (secProps.marginTop !== void 0 || secProps.marginBottom !== void 0 || secProps.marginLeft !== void 0 || secProps.marginRight !== void 0) {
+							lastSectionMarginsTwips = {
+								top: secProps.marginTop ?? lastSectionMarginsTwips.top,
+								bottom: secProps.marginBottom ?? lastSectionMarginsTwips.bottom,
+								left: secProps.marginLeft ?? lastSectionMarginsTwips.left,
+								right: secProps.marginRight ?? lastSectionMarginsTwips.right
+							};
+							sectionBreak.margins = {
+								top: twipsToPixels(lastSectionMarginsTwips.top),
+								bottom: twipsToPixels(lastSectionMarginsTwips.bottom),
+								left: twipsToPixels(lastSectionMarginsTwips.left),
+								right: twipsToPixels(lastSectionMarginsTwips.right)
+							};
+							if (secProps.headerDistance !== void 0) sectionBreak.margins.header = twipsToPixels(secProps.headerDistance);
+							if (secProps.footerDistance !== void 0) sectionBreak.margins.footer = twipsToPixels(secProps.footerDistance);
+						}
+						const colCount = secProps.columnCount ?? 1;
+						if (colCount > 1) {
+							const cols = {
+								count: colCount,
+								gap: twipsToPixels(secProps.columnSpace ?? 720),
+								equalWidth: secProps.equalWidth ?? true
+							};
+							if (secProps.separator !== void 0) cols.separator = secProps.separator;
+							sectionBreak.columns = cols;
+						}
+					}
+					trackedPush(sectionBreak);
+				}
+				break;
+			}
+			case "table":
+				trackedPush(convertTable(node, pos, opts));
+				break;
+			case "image":
+				trackedPush(convertImage(node, pos, opts.pageContentHeight));
+				break;
+			case "textBox":
+				trackedPush(convertTextBoxNode(node, pos, opts));
+				break;
+			case "horizontalRule":
+			case "pageBreak":
+				trackedPush({
+					kind: "pageBreak",
+					id: nextBlockId(),
+					pmStart: pos,
+					pmEnd: pos + node.nodeSize
+				});
+				break;
+			default: break;
+		}
+	};
+	doc.forEach((node, nodeOffset) => {
+		visit(node, offset + nodeOffset);
+	});
+	return mergeRunInParagraphs(blocks);
+}
+/**
+* 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 { convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };