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

package/dist/prosemirror/conversion/toProseDoc.js

@@ -0,0 +1,1404 @@
+import { emuToPixels } from "../../utils/units.js";
+import { resolveColor } from "../../utils/colorResolver.js";
+import { directionFromBidi } from "../paragraphDirection.js";
+import { setAutospacingBaseValue } from "../autospacingBase.js";
+import { shadingToRunShadingAttrs } from "./runShadingMark.js";
+import { assertValidProseMirrorDocument } from "../validation.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+import { marksToTextFormatting } from "./fromProseDoc.js";
+import { createStyleEngine } from "../../style-engine/styleEngine.js";
+import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
+import { schema } from "../schema/index.js";
+//#region src/prosemirror/conversion/toProseDoc.ts
+/**
+* Convert a Document to a ProseMirror document
+*
+* @param document - The Document to convert
+* @param options - Conversion options including style definitions
+*/
+function toProseDoc(document, options) {
+	const paragraphs = document.package.document.content;
+	const nodes = [];
+	const styleResolver = createStyleEngine(options?.styles ?? document.package.styles);
+	const theme = options?.theme ?? document.package.theme ?? null;
+	let textBoxGroupIndex = 0;
+	const convertBodyBlocks = (blocks) => {
+		const out = [];
+		for (const block of blocks) if (block.type === "paragraph") {
+			const pbPos = paragraphPageBreakPosition(block);
+			if (pbPos === "before") out.push(schema.node("pageBreak"));
+			out.push(...convertParagraphWithTextBoxes(block, styleResolver, String(textBoxGroupIndex)));
+			textBoxGroupIndex += 1;
+			if (pbPos === "after") out.push(schema.node("pageBreak"));
+		} else if (block.type === "table") out.push(convertTable(block, styleResolver, theme));
+		else out.push(convertBlockSdt(block, convertBodyBlocks));
+		return out;
+	};
+	nodes.push(...convertBodyBlocks(paragraphs));
+	if (nodes.length === 0) nodes.push(schema.node("paragraph", {}, []));
+	const pmDoc = schema.node("doc", null, nodes);
+	assertValidProseMirrorDocument(pmDoc, "Document conversion produced an invalid ProseMirror document");
+	return pmDoc;
+}
+/**
+* Convert a `BlockSdt` model node into a `blockSdt` PM node, recursively
+* converting its children with the caller-supplied block converter. Pass
+* `rawPropertiesXml` / `rawEndPropertiesXml` through as attrs so the
+* serializer can replay them verbatim after a save.
+*/
+function convertBlockSdt(blockSdt, convertBlocks) {
+	const props = blockSdt.properties;
+	const attrs = {
+		sdtType: props.sdtType,
+		alias: props.alias ?? null,
+		tag: props.tag ?? null,
+		id: props.id ?? null,
+		lock: props.lock ?? null,
+		placeholder: props.placeholder ?? null,
+		showingPlaceholder: props.showingPlaceholder ?? false,
+		dateFormat: props.dateFormat ?? null,
+		dateValueISO: props.dateValueISO ?? null,
+		listItems: props.listItems ? JSON.stringify(props.listItems) : null,
+		dropdownLastValue: props.dropdownLastValue ?? null,
+		checked: props.checked ?? null,
+		_originallyEmpty: blockSdt.content.length === 0,
+		rawPropertiesXml: props.rawPropertiesXml ?? null,
+		rawEndPropertiesXml: props.rawEndPropertiesXml ?? null,
+		rawSdtChildrenBeforeContent: props.rawSdtChildrenBeforeContent ?? null,
+		rawSdtChildrenAfterContent: props.rawSdtChildrenAfterContent ?? null
+	};
+	const children = convertBlocks(blockSdt.content);
+	if (children.length === 0) children.push(schema.node("paragraph", {}, []));
+	return schema.node("blockSdt", attrs, children);
+}
+/**
+* Convert a Paragraph to a ProseMirror paragraph node
+*
+* Resolves style-based text formatting and passes it to runs so that
+* paragraph styles (like Heading1) apply their font size, color, etc.
+*/
+function convertParagraph(paragraph, styleResolver, activeCommentIds, extraRunFormatting) {
+	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver);
+	const inlineNodes = [];
+	let inlineOffset = 0;
+	let bookmarksArr;
+	let emptyHyperlinks;
+	let hyperlinkIndex = 0;
+	const commentIds = activeCommentIds ?? /* @__PURE__ */ new Set();
+	const emitInlineNodes = (nodes) => {
+		if (nodes.length === 0) return;
+		const markedNodes = applyCommentMarks(nodes, commentIds);
+		inlineNodes.push(...markedNodes);
+		for (const node of markedNodes) inlineOffset += node.nodeSize;
+	};
+	const emitInlineNode = (node) => {
+		if (!node) return;
+		emitInlineNodes([node]);
+	};
+	let styleRunFormatting;
+	if (styleResolver) styleRunFormatting = styleResolver.resolveParagraphStyle(paragraph.formatting?.styleId).runFormatting;
+	const paragraphRunFormatting = paragraph.formatting?.runProperties ? resolveTextFormatting(paragraph.formatting.runProperties, styleResolver) : void 0;
+	const inheritableParagraphRunFormatting = paragraphRunFormatting ? stripParagraphMarkOnlyFormatting(paragraphRunFormatting) : void 0;
+	const baseRunFormatting = mergeTextFormatting(styleRunFormatting, extraRunFormatting);
+	const defaultRunFormatting = mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
+	const getInheritedRunFormatting = (formatting) => {
+		if (!hasDirectRunFormatting(formatting)) return defaultRunFormatting;
+		return suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting);
+	};
+	const emitTrackedChange = (change, markType, moveKind) => {
+		emitInlineNodes(convertTrackedChange(change, markType, getInheritedRunFormatting, styleResolver, moveKind));
+	};
+	for (const content of paragraph.content) {
+		if (content.type === "commentRangeStart") commentIds.add(content.id);
+		else if (content.type === "commentRangeEnd") commentIds.delete(content.id);
+		else if (content.type === "commentReference") anchorPointComment(inlineNodes, content.id);
+		else if (content.type === "run") emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), styleResolver));
+		else if (content.type === "hyperlink") {
+			const currentHyperlinkIndex = hyperlinkIndex;
+			hyperlinkIndex += 1;
+			const linkNodes = convertHyperlink(content, getInheritedRunFormatting, styleResolver, currentHyperlinkIndex);
+			if (linkNodes.length === 0) {
+				emptyHyperlinks ??= [];
+				emptyHyperlinks.push({
+					offset: inlineOffset,
+					...content.href !== void 0 ? { href: content.href } : {},
+					...content.anchor !== void 0 ? { anchor: content.anchor } : {},
+					...content.tooltip !== void 0 ? { tooltip: content.tooltip } : {},
+					...content.rId !== void 0 ? { rId: content.rId } : {}
+				});
+				continue;
+			}
+			emitInlineNodes(linkNodes);
+		} else if (content.type === "simpleField" || content.type === "complexField") emitInlineNode(convertField(content, getInheritedRunFormatting, styleResolver));
+		else if (content.type === "inlineSdt") emitInlineNode(convertInlineSdt(content, getInheritedRunFormatting, styleResolver));
+		else if (content.type === "insertion" || content.type === "moveTo") emitTrackedChange(content, "insertion", content.type === "moveTo" ? "moveTo" : null);
+		else if (content.type === "deletion" || content.type === "moveFrom") emitTrackedChange(content, "deletion", content.type === "moveFrom" ? "moveFrom" : null);
+		else if (content.type === "mathEquation") emitInlineNode(convertMathEquation(content));
+		if (content.type === "bookmarkStart") {
+			if (!bookmarksArr) bookmarksArr = [];
+			bookmarksArr.push({
+				id: content.id,
+				name: content.name
+			});
+		}
+	}
+	if (bookmarksArr) attrs.bookmarks = bookmarksArr;
+	if (emptyHyperlinks) attrs._emptyHyperlinks = emptyHyperlinks;
+	return schema.node("paragraph", attrs, inlineNodes);
+}
+/**
+* Apply comment marks to PM nodes within a comment range.
+* Only the first active comment ID is used (comments don't overlap visually).
+*/
+function applyCommentMarks(nodes, commentIds) {
+	if (commentIds.size === 0) return nodes;
+	const commentId = [...commentIds][0];
+	const commentMark = schema.marks["comment"].create({ commentId });
+	return nodes.map((node) => {
+		if (node.isText || node.isInline && node.type.allowsMarkType(commentMark.type)) return node.mark(commentMark.addToSet(node.marks));
+		return node;
+	});
+}
+function anchorPointComment(nodes, commentId) {
+	const commentMark = schema.marks["comment"]?.create({ commentId });
+	if (!commentMark) return;
+	for (let index = nodes.length - 1; index >= 0; index--) {
+		const node = nodes[index];
+		if (!node?.isText) continue;
+		nodes[index] = node.mark(commentMark.addToSet(node.marks));
+		return;
+	}
+}
+/**
+* Convert tracked change (insertion or deletion) content to PM nodes with
+* an insertion/deletion mark applied.
+*/
+function convertTrackedChange(change, markType, getInheritedRunFormatting, styleResolver, moveKind = null) {
+	const nodes = [];
+	let hyperlinkIndex = 0;
+	for (const item of change.content) if (item.type === "run") nodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), styleResolver));
+	else {
+		const currentHyperlinkIndex = hyperlinkIndex;
+		hyperlinkIndex += 1;
+		nodes.push(...convertHyperlink(item, getInheritedRunFormatting, styleResolver, currentHyperlinkIndex));
+	}
+	const mark = schema.marks[markType].create({
+		revisionId: change.info.id,
+		author: change.info.author,
+		date: change.info.date ?? null,
+		moveKind
+	});
+	return nodes.map((node) => {
+		if (canCarryTrackedRunMark(node, mark.type)) return node.mark(mark.addToSet(node.marks));
+		return node;
+	});
+}
+function canCarryTrackedRunMark(node, markType) {
+	return node.isText || node.isInline && node.type.allowsMarkType(markType) && (node.type.name === "image" || node.type.name === "shape" || node.type.name === "hardBreak" || node.type.name === "tab");
+}
+/**
+* Convert ParagraphFormatting to ProseMirror paragraph attrs
+*
+* If a styleResolver is provided, resolves style-based formatting and merges
+* with inline formatting. Inline formatting takes precedence.
+*/
+function paragraphFormattingToAttrs(paragraph, styleResolver) {
+	const formatting = paragraph.formatting;
+	const styleId = formatting?.styleId;
+	const attrs = {};
+	if (paragraph.paraId) attrs.paraId = paragraph.paraId;
+	if (paragraph.textId) attrs.textId = paragraph.textId;
+	if (styleId) attrs.styleId = styleId;
+	if (formatting?.numPr) attrs.numPr = formatting.numPr;
+	if (formatting?.numPrFromStyle) attrs.numPrFromStyle = formatting.numPrFromStyle;
+	if (paragraph.listRendering?.numFmt) attrs.listNumFmt = paragraph.listRendering.numFmt;
+	if (paragraph.listRendering?.isBullet) attrs.listIsBullet = paragraph.listRendering.isBullet;
+	if (paragraph.listRendering?.isLegal) attrs.listIsLegal = paragraph.listRendering.isLegal;
+	if (paragraph.listRendering?.marker) attrs.listMarker = paragraph.listRendering.marker;
+	if (paragraph.listRendering?.markerHidden) attrs.listMarkerHidden = paragraph.listRendering.markerHidden;
+	if (paragraph.listRendering?.markerFontFamily) attrs.listMarkerFontFamily = paragraph.listRendering.markerFontFamily;
+	if (paragraph.listRendering?.markerFontSize) attrs.listMarkerFontSize = paragraph.listRendering.markerFontSize;
+	if (paragraph.listRendering?.markerSuffix) attrs.listMarkerSuffix = paragraph.listRendering.markerSuffix;
+	if (paragraph.listRendering?.markerAllCaps) attrs.listMarkerAllCaps = paragraph.listRendering.markerAllCaps;
+	if (paragraph.listRendering?.implicitChildLevelAdvances !== void 0) attrs.listImplicitChildLevelAdvances = paragraph.listRendering.implicitChildLevelAdvances;
+	if (paragraph.listRendering?.markerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = paragraph.listRendering.markerSecondSlotOffsetTwips;
+	if (paragraph.listRendering?.levelNumFmts) attrs.listLevelNumFmts = paragraph.listRendering.levelNumFmts;
+	if (paragraph.listRendering?.abstractNumId !== void 0) attrs.listAbstractNumId = paragraph.listRendering.abstractNumId;
+	if (paragraph.listRendering?.startOverride !== void 0) attrs.listStartOverride = paragraph.listRendering.startOverride;
+	if (formatting) attrs._originalFormatting = formatting;
+	if (paragraph.propertyChanges && paragraph.propertyChanges.length > 0) attrs._propertyChanges = [...paragraph.propertyChanges];
+	if (paragraph.pPrMark) attrs.pPrMark = paragraph.pPrMark;
+	const set = (key, val) => {
+		if (val !== void 0) attrs[key] = val;
+	};
+	let stylePpr;
+	if (styleResolver) {
+		stylePpr = styleResolver.resolveParagraphStyle(styleId).paragraphFormatting;
+		set("alignment", formatting?.alignment ?? stylePpr?.alignment);
+		set("spaceBefore", formatting?.spaceBefore ?? stylePpr?.spaceBefore);
+		set("spaceAfter", formatting?.spaceAfter ?? stylePpr?.spaceAfter);
+		set("lineSpacing", formatting?.lineSpacing ?? stylePpr?.lineSpacing);
+		set("lineSpacingRule", formatting?.lineSpacingRule ?? stylePpr?.lineSpacingRule);
+		set("spacingExplicit", formatting?.spacingExplicit);
+		set("indentLeft", formatting?.indentLeft ?? stylePpr?.indentLeft);
+		set("indentRight", formatting?.indentRight ?? stylePpr?.indentRight);
+		const styleFirstLine = formatting?.numPr?.numId === 0 && stylePpr?.numPr !== void 0 && stylePpr.numPr.numId !== 0 ? void 0 : stylePpr;
+		set("indentFirstLine", formatting?.indentFirstLine ?? styleFirstLine?.indentFirstLine);
+		set("hangingIndent", formatting?.hangingIndent ?? styleFirstLine?.hangingIndent);
+		set("borders", formatting?.borders ?? stylePpr?.borders);
+		set("shading", formatting?.shading ?? stylePpr?.shading);
+		set("tabs", formatting?.tabs ?? stylePpr?.tabs);
+		set("pageBreakBefore", formatting?.pageBreakBefore ?? stylePpr?.pageBreakBefore);
+		set("keepNext", formatting?.keepNext ?? stylePpr?.keepNext);
+		set("keepLines", formatting?.keepLines ?? stylePpr?.keepLines);
+		set("contextualSpacing", formatting?.contextualSpacing ?? stylePpr?.contextualSpacing);
+		set("runInWithNext", formatting?.runInWithNext ?? stylePpr?.runInWithNext);
+		set("outlineLevel", formatting?.outlineLevel ?? stylePpr?.outlineLevel);
+		set("direction", directionFromBidi(formatting?.bidi ?? stylePpr?.bidi));
+		set("defaultTextFormatting", resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver));
+		if (!formatting?.numPr && stylePpr?.numPr && stylePpr.numPr.numId !== 0) {
+			attrs.numPr = stylePpr.numPr;
+			attrs.numPrFromStyle = stylePpr.numPr;
+		}
+	} else {
+		set("alignment", formatting?.alignment);
+		set("spaceBefore", formatting?.spaceBefore);
+		set("spaceAfter", formatting?.spaceAfter);
+		set("lineSpacing", formatting?.lineSpacing);
+		set("lineSpacingRule", formatting?.lineSpacingRule);
+		set("spacingExplicit", formatting?.spacingExplicit);
+		set("indentLeft", formatting?.indentLeft);
+		set("indentRight", formatting?.indentRight);
+		set("indentFirstLine", formatting?.indentFirstLine);
+		set("hangingIndent", formatting?.hangingIndent);
+		set("borders", formatting?.borders);
+		set("shading", formatting?.shading);
+		set("tabs", formatting?.tabs);
+		set("pageBreakBefore", formatting?.pageBreakBefore);
+		set("keepNext", formatting?.keepNext);
+		set("keepLines", formatting?.keepLines);
+		set("runInWithNext", formatting?.runInWithNext);
+		set("outlineLevel", formatting?.outlineLevel);
+		set("direction", directionFromBidi(formatting?.bidi));
+		set("defaultTextFormatting", resolveTextFormatting(formatting?.runProperties, styleResolver));
+	}
+	if (paragraph.sectionProperties) {
+		attrs._sectionProperties = paragraph.sectionProperties;
+		const st = paragraph.sectionProperties.sectionStart;
+		if (st === "nextPage" || st === "continuous" || st === "oddPage" || st === "evenPage") attrs.sectionBreakType = st;
+	}
+	if (paragraph.renderedPageBreakBefore) attrs.renderedPageBreakBefore = true;
+	const beforeAutospacing = formatting?.beforeAutospacing ?? stylePpr?.beforeAutospacing;
+	const afterAutospacing = formatting?.afterAutospacing ?? stylePpr?.afterAutospacing;
+	if (beforeAutospacing || afterAutospacing) {
+		const base = {};
+		if (beforeAutospacing) setAutospacingBaseValue(base, "before", attrs.spaceBefore);
+		if (afterAutospacing) setAutospacingBaseValue(base, "after", attrs.spaceAfter);
+		attrs._autospacingBase = base;
+	}
+	return attrs;
+}
+/**
+* Resolve table style conditional formatting
+*/
+function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType) {
+	if (!styleResolver || !tableStyleId) return;
+	const style = styleResolver.getStyle(tableStyleId);
+	if (!style?.tblStylePr) return;
+	const conditional = style.tblStylePr.find((p) => p.type === conditionType);
+	if (!conditional) return;
+	const mergedRunProps = mergeTextFormatting(conditional.pPr?.runProperties ? resolveTextFormatting(conditional.pPr.runProperties, styleResolver) : void 0, conditional.rPr ? resolveTextFormatting(conditional.rPr, styleResolver) : void 0);
+	const result = {};
+	if (conditional.tcPr) result.tcPr = conditional.tcPr;
+	if (mergedRunProps) result.rPr = mergedRunProps;
+	return result;
+}
+function resolveTableBaseStyle(styleResolver, tableStyleId) {
+	if (!styleResolver || !tableStyleId) return;
+	const style = styleResolver.getStyle(tableStyleId);
+	if (!style) return;
+	const mergedRunProps = mergeTextFormatting(style.pPr?.runProperties ? resolveTextFormatting(style.pPr.runProperties, styleResolver) : void 0, style.rPr ? resolveTextFormatting(style.rPr, styleResolver) : void 0);
+	const result = {};
+	if (style.tcPr) result.tcPr = style.tcPr;
+	if (mergedRunProps) result.rPr = mergedRunProps;
+	return result.tcPr || result.rPr ? result : void 0;
+}
+function mergeConditionalStyles(base, override) {
+	if (!base && !override) return;
+	if (!base) return override;
+	if (!override) return base;
+	const merged = {};
+	const baseTcPr = base.tcPr;
+	const overrideTcPr = override.tcPr;
+	if (baseTcPr || overrideTcPr) {
+		const tcPr = {
+			...baseTcPr,
+			...overrideTcPr
+		};
+		if (baseTcPr?.borders || overrideTcPr?.borders) tcPr.borders = {
+			...baseTcPr?.borders,
+			...overrideTcPr?.borders
+		};
+		if (baseTcPr?.shading || overrideTcPr?.shading) tcPr.shading = {
+			...baseTcPr?.shading,
+			...overrideTcPr?.shading
+		};
+		if (baseTcPr?.margins || overrideTcPr?.margins) tcPr.margins = {
+			...baseTcPr?.margins,
+			...overrideTcPr?.margins
+		};
+		merged.tcPr = tcPr;
+	}
+	const mergedRPr = mergeTextFormatting(base.rPr, override.rPr);
+	if (mergedRPr) merged.rPr = mergedRPr;
+	return merged;
+}
+function hasDirectRunFormatting(formatting) {
+	if (!formatting) return false;
+	return Object.entries(formatting).some(([key, value]) => key !== "styleId" && value !== void 0);
+}
+function stripParagraphMarkOnlyFormatting(formatting) {
+	const { highlight: _h, shading: _s, ...rest } = formatting;
+	return Object.keys(rest).length > 0 ? rest : void 0;
+}
+function suppressParagraphMarkFormatting(base, paragraphMark, direct) {
+	if (!paragraphMark) return base;
+	const result = { ...base };
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "bold");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "italic");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "strike");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "doubleStrike");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "allCaps");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "smallCaps");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "hidden");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "emboss");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "imprint");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "shadow");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "outline");
+	suppressBooleanParagraphMark(result, paragraphMark, direct, "rtl");
+	if (paragraphMark.underline !== void 0 && direct?.underline === void 0) result.underline = { style: "none" };
+	return Object.keys(result).length > 0 ? result : void 0;
+}
+function suppressBooleanParagraphMark(result, paragraphMark, direct, key) {
+	if (paragraphMark[key] === void 0 || direct?.[key] !== void 0) return;
+	result[key] = false;
+}
+function resolveTextFormatting(formatting, styleResolver) {
+	if (!formatting) return styleResolver?.resolveRunStyle(null);
+	if (!styleResolver) return formatting;
+	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
+}
+function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver) {
+	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
+	const paragraphStyleRpr = style?.type === "paragraph" ? style.rPr : void 0;
+	const rawParagraphMarkRpr = formatting?.runProperties;
+	const characterStyleRpr = rawParagraphMarkRpr?.styleId !== void 0 ? styleResolver.getRunStyleOwnProperties(rawParagraphMarkRpr.styleId) : void 0;
+	const paragraphRunProperties = rawParagraphMarkRpr ? stripParagraphMarkOnlyFormatting(mergeTextFormatting(characterStyleRpr, rawParagraphMarkRpr) ?? {}) : void 0;
+	return mergeTextFormatting(mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr), paragraphRunProperties);
+}
+function calculateRowSpans(table) {
+	const result = /* @__PURE__ */ new Map();
+	const numRows = table.rows.length;
+	const activeMerges = /* @__PURE__ */ new Map();
+	for (let rowIndex = 0; rowIndex < numRows; rowIndex++) {
+		const row = table.rows[rowIndex];
+		if (row.cells.length === 0) {
+			clearActiveVerticalMerges(activeMerges, result);
+			continue;
+		}
+		let colIndex = 0;
+		const rowCells = row.cells.map((cell) => {
+			const colspan = cell.formatting?.gridSpan ?? 1;
+			const vMerge = cell.formatting?.vMerge;
+			const startRow = vMerge === "continue" ? activeMerges.get(colIndex) : void 0;
+			const info = {
+				cell,
+				colIndex,
+				colspan,
+				vMerge,
+				startRow,
+				hasMeaningfulContent: tableCellHasMeaningfulContent(cell),
+				shouldSkip: vMerge === "continue" && startRow !== void 0
+			};
+			colIndex += colspan;
+			return info;
+		});
+		const rowWouldBeEmpty = rowCells.length > 0 && rowCells.every((cell) => cell.shouldSkip);
+		for (const cellInfo of rowCells) {
+			const { colIndex: cellColIndex, vMerge, startRow, hasMeaningfulContent } = cellInfo;
+			const key = `${rowIndex}-${cellColIndex}`;
+			if (vMerge === "restart") {
+				activeMerges.set(cellColIndex, rowIndex);
+				result.set(key, {
+					rowSpan: 1,
+					skip: false
+				});
+			} else if (vMerge === "continue") {
+				if (startRow === void 0 || rowWouldBeEmpty || hasMeaningfulContent) {
+					result.set(key, {
+						rowSpan: 1,
+						skip: false
+					});
+					if ((rowWouldBeEmpty || hasMeaningfulContent) && startRow !== void 0) {
+						const restartCell = result.get(`${startRow}-${cellColIndex}`);
+						if (restartCell) restartCell.preserveVMergeRestart = true;
+						activeMerges.delete(cellColIndex);
+					}
+					continue;
+				}
+				const startKey = `${startRow}-${cellColIndex}`;
+				const startCell = result.get(startKey);
+				if (startCell) {
+					startCell.rowSpan++;
+					startCell.continuationCells ??= [];
+					startCell.continuationCells.push(cellInfo.cell);
+				}
+				result.set(key, {
+					rowSpan: 1,
+					skip: true
+				});
+			} else {
+				activeMerges.delete(cellColIndex);
+				result.set(key, {
+					rowSpan: 1,
+					skip: false
+				});
+			}
+		}
+	}
+	return result;
+}
+function clearActiveVerticalMerges(activeMerges, result) {
+	for (const [colIndex, startRow] of activeMerges) {
+		const restartCell = result.get(`${startRow}-${colIndex}`);
+		if (restartCell) restartCell.preserveVMergeRestart = true;
+	}
+	activeMerges.clear();
+}
+function tableCellHasMeaningfulContent(cell) {
+	return cell.content.some(blockHasMeaningfulContent);
+}
+function blockHasMeaningfulContent(block) {
+	if (block.type === "table") return block.rows.some((row) => row.cells.some((cell) => tableCellHasMeaningfulContent(cell)));
+	return block.content.some(paragraphContentHasMeaningfulContent);
+}
+function paragraphContentHasMeaningfulContent(content) {
+	if (content.type === "run") return content.content.length > 0;
+	if (content.type === "hyperlink") return content.children.some(paragraphContentHasMeaningfulContent);
+	if (content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo") return content.content.some(paragraphContentHasMeaningfulContent);
+	return true;
+}
+function convertTable(table, styleResolver, theme) {
+	const rowSpanMap = calculateRowSpans(table);
+	const columnWidths = table.columnWidths;
+	const totalWidth = columnWidths?.reduce((sum, w) => sum + w, 0) ?? 0;
+	const tableStyleId = table.formatting?.styleId;
+	const look = table.formatting?.look;
+	const tableStyle = tableStyleId ? styleResolver?.getStyle(tableStyleId) : void 0;
+	const defaultTableStyle = styleResolver?.getDefaultTableStyle();
+	const fallbackTableStyle = tableStyleId ? void 0 : defaultTableStyle;
+	const conditionalTableStyleId = tableStyle?.styleId ?? fallbackTableStyle?.styleId;
+	const resolvedTableBorders = table.formatting?.borders ?? tableStyle?.tblPr?.borders ?? fallbackTableStyle?.tblPr?.borders;
+	const tableCellMargins = table.formatting?.cellMargins ?? tableStyle?.tblPr?.cellMargins ?? fallbackTableStyle?.tblPr?.cellMargins;
+	let cellMarginsAttr;
+	if (tableCellMargins) {
+		const m = {};
+		if (tableCellMargins.top?.value !== void 0) m.top = tableCellMargins.top.value;
+		if (tableCellMargins.bottom?.value !== void 0) m.bottom = tableCellMargins.bottom.value;
+		if (tableCellMargins.left?.value !== void 0) m.left = tableCellMargins.left.value;
+		if (tableCellMargins.right?.value !== void 0) m.right = tableCellMargins.right.value;
+		cellMarginsAttr = m;
+	}
+	const attrs = {};
+	if (table.formatting?.styleId) attrs.styleId = table.formatting.styleId;
+	if (table.formatting?.width?.value !== void 0) attrs.width = table.formatting.width.value;
+	if (table.formatting?.width?.type) attrs.widthType = table.formatting.width.type;
+	if (table.formatting?.justification) attrs.justification = table.formatting.justification;
+	if (columnWidths) attrs.columnWidths = columnWidths;
+	if (table.formatting?.floating) attrs.floating = table.formatting.floating;
+	if (cellMarginsAttr) attrs.cellMargins = cellMarginsAttr;
+	if (table.formatting?.look) attrs.look = table.formatting.look;
+	if (table.formatting?.borders) attrs.borders = table.formatting.borders;
+	if (table.formatting) attrs._originalFormatting = table.formatting;
+	const conditionalStyles = {};
+	const setCS = (key, type) => {
+		const val = resolveTableStyleConditional(styleResolver, conditionalTableStyleId, type);
+		if (val) conditionalStyles[key] = val;
+	};
+	setCS("wholeTable", "wholeTable");
+	const wholeTableStyle = mergeConditionalStyles(resolveTableBaseStyle(styleResolver, conditionalTableStyleId), conditionalStyles.wholeTable);
+	if (wholeTableStyle) conditionalStyles.wholeTable = wholeTableStyle;
+	setCS("firstRow", "firstRow");
+	setCS("lastRow", "lastRow");
+	setCS("firstCol", "firstCol");
+	setCS("lastCol", "lastCol");
+	setCS("band1Horz", "band1Horz");
+	setCS("band2Horz", "band2Horz");
+	setCS("band1Vert", "band1Vert");
+	setCS("band2Vert", "band2Vert");
+	setCS("nwCell", "nwCell");
+	setCS("neCell", "neCell");
+	setCS("swCell", "swCell");
+	setCS("seCell", "seCell");
+	const bandingEnabledH = look?.noHBand !== true;
+	const bandingEnabledV = look?.noVBand !== true;
+	let dataRowIndex = 0;
+	const totalRows = table.rows.length;
+	const gridColumnCount = columnWidths?.length ?? 0;
+	const totalColumns = gridColumnCount > 0 ? gridColumnCount : countTableColumns(table.rows);
+	const rows = table.rows.map((row, rowIndex) => {
+		const isFirstRowStyled = rowIndex === 0 && !!look?.firstRow;
+		const isLastRow = rowIndex === totalRows - 1 && !!look?.lastRow;
+		const rowBandStyle = (() => {
+			if (bandingEnabledH && !isFirstRowStyled && !isLastRow) return (() => {
+				if (dataRowIndex % 2 === 0) return conditionalStyles.band1Horz;
+				return conditionalStyles.band2Horz;
+			})();
+		})();
+		if (bandingEnabledH && !isFirstRowStyled && !isLastRow) dataRowIndex++;
+		return convertTableRow(row, styleResolver, isFirstRowStyled, columnWidths, totalWidth, conditionalStyles, rowBandStyle, bandingEnabledV, look, resolvedTableBorders, rowIndex, totalRows, totalColumns, rowSpanMap, cellMarginsAttr, theme);
+	});
+	return schema.node("table", attrs, rows);
+}
+function countTableColumns(rows) {
+	let maxColumns = 0;
+	for (const row of rows) {
+		let rowColumns = 0;
+		for (const cell of row.cells) rowColumns += cell.formatting?.gridSpan ?? 1;
+		maxColumns = Math.max(maxColumns, rowColumns);
+	}
+	return maxColumns;
+}
+/**
+* Convert a TableRow to a ProseMirror table row node
+*/
+function convertTableRow(row, styleResolver, isHeaderRow, columnWidths, totalWidth, conditionalStyles, rowBandStyle, bandingEnabledV, tableLook, tableBorders, rowIndex, totalRows, totalColumns, rowSpanMap, defaultCellMargins, theme) {
+	const attrs = { isHeader: !!row.formatting?.header };
+	if (row.formatting?.height?.value !== void 0) attrs.height = row.formatting.height.value;
+	if (row.formatting?.heightRule) attrs.heightRule = row.formatting.heightRule;
+	if (row.formatting) attrs._originalFormatting = row.formatting;
+	const numCells = row.cells.length;
+	const isFirstRow = rowIndex === 0;
+	const isLastRow = rowIndex === (totalRows ?? 1) - 1;
+	const rowCnf = row.formatting?.conditionalFormat;
+	const rowIsFirstRow = rowCnf?.firstRow ?? isFirstRow;
+	const rowIsLastRow = rowCnf?.lastRow ?? isLastRow;
+	const totalCols = totalColumns != null && totalColumns > 0 ? totalColumns : Math.max(numCells, 1);
+	let effectiveCells = row.cells;
+	if (effectiveCells.length === 0) {
+		const fallback = {
+			type: "tableCell",
+			content: [{
+				type: "paragraph",
+				content: []
+			}]
+		};
+		if (totalCols > 1) fallback.formatting = { gridSpan: totalCols };
+		effectiveCells = [fallback];
+	}
+	let colIndex = 0;
+	const cells = [];
+	for (const cellIndex_item of effectiveCells) {
+		const cell = cellIndex_item;
+		const colspan = cell.formatting?.gridSpan ?? 1;
+		const rowSpanKey = `${rowIndex ?? 0}-${colIndex}`;
+		const rowSpanInfo = rowSpanMap?.get(rowSpanKey);
+		const shouldSkip = rowSpanInfo?.skip ?? false;
+		const calculatedRowSpan = rowSpanInfo?.rowSpan ?? 1;
+		const preserveVMergeRestart = rowSpanInfo?.preserveVMergeRestart ?? false;
+		let gridWidth;
+		if (columnWidths && totalWidth && totalWidth > 0) {
+			let cellWidthTwips = 0;
+			for (let i = 0; i < colspan && colIndex + i < columnWidths.length; i++) cellWidthTwips += columnWidths[colIndex + i] ?? 0;
+			gridWidth = Math.round(cellWidthTwips / totalWidth * 100);
+		}
+		colIndex += colspan;
+		if (shouldSkip) continue;
+		const isFirstCol = colIndex - colspan === 0;
+		const isLastCol = colIndex === totalCols;
+		const cellCnf = cell.formatting?.conditionalFormat;
+		const cellIsFirstRow = cellCnf?.firstRow ?? rowIsFirstRow;
+		const cellIsLastRow = cellCnf?.lastRow ?? rowIsLastRow;
+		const cellIsFirstCol = cellCnf?.firstColumn ?? isFirstCol;
+		const cellIsLastCol = cellCnf?.lastColumn ?? isLastCol;
+		let vertBandStyle;
+		if (bandingEnabledV) {
+			const firstColOffset = tableLook?.firstColumn ? 1 : 0;
+			const bandColIndex = colIndex - colspan - firstColOffset;
+			if (bandColIndex >= 0 && !(tableLook?.lastColumn && cellIsLastCol) && !(tableLook?.firstColumn && cellIsFirstCol)) vertBandStyle = bandColIndex % 2 === 0 ? conditionalStyles?.band1Vert : conditionalStyles?.band2Vert;
+		}
+		if (cellCnf?.oddVBand) vertBandStyle = conditionalStyles?.band1Vert;
+		else if (cellCnf?.evenVBand) vertBandStyle = conditionalStyles?.band2Vert;
+		let effectiveRowBandStyle = rowBandStyle;
+		if (rowCnf?.oddHBand) effectiveRowBandStyle = conditionalStyles?.band1Horz;
+		else if (rowCnf?.evenHBand) effectiveRowBandStyle = conditionalStyles?.band2Horz;
+		if (cellCnf?.oddHBand) effectiveRowBandStyle = conditionalStyles?.band1Horz;
+		else if (cellCnf?.evenHBand) effectiveRowBandStyle = conditionalStyles?.band2Horz;
+		let cellConditionalStyle = conditionalStyles?.wholeTable;
+		cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, effectiveRowBandStyle);
+		cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, vertBandStyle);
+		if (cellIsFirstRow && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.firstRow);
+		if (cellIsLastRow && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.lastRow);
+		if (cellIsFirstCol && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.firstCol);
+		if (cellIsLastCol && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.lastCol);
+		if (cellIsFirstRow && cellIsFirstCol && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow) && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.nwCell);
+		if (cellIsFirstRow && cellIsLastCol && (tableLook?.firstRow || rowCnf?.firstRow || cellCnf?.firstRow) && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.neCell);
+		if (cellIsLastRow && cellIsFirstCol && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow) && (tableLook?.firstColumn || rowCnf?.firstColumn || cellCnf?.firstColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.swCell);
+		if (cellIsLastRow && cellIsLastCol && (tableLook?.lastRow || rowCnf?.lastRow || cellCnf?.lastRow) && (tableLook?.lastColumn || rowCnf?.lastColumn || cellCnf?.lastColumn)) cellConditionalStyle = mergeConditionalStyles(cellConditionalStyle, conditionalStyles?.seCell);
+		cells.push(convertTableCell(cell, styleResolver, isHeaderRow, gridWidth, cellConditionalStyle, tableBorders, isFirstRow, isLastRow, isFirstCol, isLastCol, calculatedRowSpan, preserveVMergeRestart, rowSpanInfo?.continuationCells, defaultCellMargins, theme));
+	}
+	return schema.node("tableRow", attrs, cells);
+}
+const TABLE_BORDER_SIDES = [
+	"top",
+	"bottom",
+	"left",
+	"right",
+	"insideH",
+	"insideV"
+];
+function resolveThemedBorderColors(borders, theme) {
+	if (!borders || !theme?.colorScheme) return borders;
+	let resolved;
+	for (const side of TABLE_BORDER_SIDES) {
+		const border = borders[side];
+		if (!border?.color?.themeColor || border.color.auto) continue;
+		resolved ??= { ...borders };
+		resolved[side] = {
+			...border,
+			color: { rgb: resolveColor(border.color, theme).replace(/^#/u, "") }
+		};
+	}
+	return resolved ?? borders;
+}
+/**
+* Convert a TableCell to a ProseMirror table cell node
+*/
+function convertTableCell(cell, styleResolver, isHeader, gridWidthPercent, conditionalStyle, tableBorders, isFirstRow, isLastRow, isFirstCol, isLastCol, calculatedRowSpan, preserveVMergeRestart, vMergeContinuationCells, defaultCellMargins, theme) {
+	const formatting = cell.formatting;
+	const rowspan = calculatedRowSpan ?? 1;
+	let width = formatting?.width?.value;
+	let widthType = formatting?.width?.type;
+	if (width === void 0 && gridWidthPercent !== void 0) {
+		width = gridWidthPercent;
+		widthType = "pct";
+	}
+	const backgroundColor = formatting?.shading?.fill?.rgb ?? conditionalStyle?.tcPr?.shading?.fill?.rgb;
+	const baseBorders = (() => {
+		if (tableBorders) return {
+			top: isFirstRow ? tableBorders.top : tableBorders.insideH,
+			bottom: isLastRow ? tableBorders.bottom : tableBorders.insideH,
+			left: isFirstCol ? tableBorders.left : tableBorders.insideV,
+			right: isLastCol ? tableBorders.right : tableBorders.insideV
+		};
+	})();
+	const conditionalBorders = conditionalStyle?.tcPr?.borders;
+	const cellBorders = formatting?.borders;
+	const borders = resolveThemedBorderColors(baseBorders || conditionalBorders || cellBorders ? {
+		...baseBorders,
+		...conditionalBorders,
+		...cellBorders
+	} : void 0, theme);
+	const buildMarginsAttr = (src) => {
+		const m = {};
+		if (src.top?.value !== void 0) m.top = src.top.value;
+		if (src.bottom?.value !== void 0) m.bottom = src.bottom.value;
+		if (src.left?.value !== void 0) m.left = src.left.value;
+		if (src.right?.value !== void 0) m.right = src.right.value;
+		return m;
+	};
+	const attrs = {
+		colspan: formatting?.gridSpan ?? 1,
+		rowspan
+	};
+	if (width !== void 0) attrs.width = width;
+	if (widthType) attrs.widthType = widthType;
+	if (formatting?.verticalAlign) attrs.verticalAlign = formatting.verticalAlign;
+	if (backgroundColor) attrs.backgroundColor = backgroundColor;
+	if (formatting?.textDirection) attrs.textDirection = formatting.textDirection;
+	if (formatting?.noWrap !== void 0) attrs.noWrap = formatting.noWrap;
+	if (borders) attrs.borders = borders;
+	if (formatting?.margins) attrs.margins = buildMarginsAttr(formatting.margins);
+	else if (conditionalStyle?.tcPr?.margins) attrs.margins = buildMarginsAttr(conditionalStyle.tcPr.margins);
+	else if (defaultCellMargins) attrs.margins = defaultCellMargins;
+	if (formatting) attrs._originalFormatting = formatting;
+	if (preserveVMergeRestart) attrs._preserveVMergeRestart = true;
+	if (vMergeContinuationCells && vMergeContinuationCells.length > 0) attrs._docxVMergeContinuationCells = vMergeContinuationCells;
+	const contentNodes = [];
+	for (const content of cell.content) if (content.type === "paragraph") contentNodes.push(convertParagraph(content, styleResolver, void 0, conditionalStyle?.rPr));
+	else contentNodes.push(convertTable(content, styleResolver, theme));
+	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
+	const nodeType = isHeader ? "tableHeader" : "tableCell";
+	return schema.node(nodeType, attrs, contentNodes);
+}
+/**
+* Convert a SimpleField or ComplexField to a ProseMirror field node.
+* Preserves run formatting (bold, fontSize, color, etc.) as PM marks.
+* Accepts a run formatting resolver so fields inherit paragraph-level
+* formatting the same way regular text runs do.
+*/
+function convertField(field, getInheritedRunFormatting, styleResolver) {
+	let displayText = "";
+	let fieldFormatting;
+	const runs = field.type === "simpleField" ? field.content : field.fieldResult;
+	for (const r of runs) if (r.type === "run") {
+		for (const c of r.content) if (c.type === "text") displayText += c.text;
+		if (!fieldFormatting && r.formatting) fieldFormatting = r.formatting;
+	}
+	if (!fieldFormatting && field.type === "complexField" && field.fieldResult.length === 0) fieldFormatting = field.formatting;
+	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting);
+	const { marks } = buildRunMarks(fieldFormatting, inheritedFormatting, styleResolver);
+	return schema.node("field", {
+		fieldType: field.fieldType,
+		instruction: field.instruction,
+		displayText,
+		fieldKind: field.type === "simpleField" ? "simple" : "complex",
+		fldLock: field.fldLock ?? false,
+		dirty: field.dirty ?? false
+	}, void 0, marks);
+}
+/**
+* Convert a MathEquation to a ProseMirror math node.
+*/
+function convertMathEquation(math) {
+	return schema.node("math", {
+		display: math.display,
+		ommlXml: math.ommlXml,
+		plainText: math.plainText || ""
+	});
+}
+/**
+* Convert an InlineSdt to a ProseMirror sdt node with inline content.
+*/
+function convertInlineSdt(sdt, getInheritedRunFormatting, styleResolver) {
+	const props = sdt.properties;
+	const inlineNodes = [];
+	let hyperlinkIndex = 0;
+	for (const content of sdt.content) if (content.type === "run") {
+		const runNodes = convertRun(content, getInheritedRunFormatting(content.formatting), styleResolver);
+		inlineNodes.push(...runNodes);
+	} else if (content.type === "hyperlink") {
+		const currentHyperlinkIndex = hyperlinkIndex;
+		hyperlinkIndex += 1;
+		const linkNodes = convertHyperlink(content, getInheritedRunFormatting, styleResolver, currentHyperlinkIndex);
+		inlineNodes.push(...linkNodes);
+	} else if (content.type === "simpleField" || content.type === "complexField") {
+		const fieldNode = convertField(content, getInheritedRunFormatting, styleResolver);
+		if (fieldNode) inlineNodes.push(fieldNode);
+	} else if (content.type === "inlineSdt") {
+		const nestedSdt = convertInlineSdt(content, getInheritedRunFormatting, styleResolver);
+		if (nestedSdt) inlineNodes.push(nestedSdt);
+	} else {
+		const mathNode = convertMathEquation(content);
+		if (mathNode) inlineNodes.push(mathNode);
+	}
+	return schema.node("sdt", {
+		sdtType: props.sdtType,
+		alias: props.alias ?? null,
+		tag: props.tag ?? null,
+		id: props.id ?? null,
+		lock: props.lock ?? null,
+		placeholder: props.placeholder ?? null,
+		showingPlaceholder: props.showingPlaceholder ?? false,
+		dateFormat: props.dateFormat ?? null,
+		dateValueISO: props.dateValueISO ?? null,
+		listItems: props.listItems ? JSON.stringify(props.listItems) : null,
+		dropdownLastValue: props.dropdownLastValue ?? null,
+		checked: props.checked ?? null,
+		rawPropertiesXml: props.rawPropertiesXml ?? null,
+		rawEndPropertiesXml: props.rawEndPropertiesXml ?? null
+	}, inlineNodes.length > 0 ? inlineNodes : void 0);
+}
+/**
+* Convert a Run to ProseMirror text nodes with marks
+*
+* @param run - The run to convert
+* @param styleFormatting - Text formatting from the paragraph's style (e.g., Heading1's font size/color)
+*/
+function convertRun(run, styleFormatting, styleResolver) {
+	const nodes = [];
+	const { marks, mergedFormatting } = buildRunMarks(run.formatting, styleFormatting, styleResolver);
+	for (const content of run.content) {
+		const contentNodes = convertRunContent(content, marks, mergedFormatting);
+		nodes.push(...contentNodes);
+	}
+	return nodes;
+}
+function buildRunMarks(runFormatting, inheritedFormatting, styleResolver) {
+	const styleId = runFormatting?.styleId;
+	const runStyleFormatting = styleId ? styleResolver?.getRunStyleOwnProperties(styleId) : void 0;
+	const mergedFormatting = mergeTextFormatting(mergeTextFormatting(inheritedFormatting, runStyleFormatting), runFormatting);
+	const marks = textFormattingToMarks(mergedFormatting);
+	if (styleId) {
+		const styleRPr = runStyleFormatting ? marksToTextFormatting(textFormattingToMarks(runStyleFormatting)) : void 0;
+		marks.push(schema.mark("characterStyle", {
+			styleId,
+			_styleRPr: styleRPr && Object.keys(styleRPr).length > 0 ? styleRPr : null
+		}));
+	}
+	return {
+		marks,
+		mergedFormatting
+	};
+}
+/**
+* Convert RunContent to ProseMirror nodes
+*/
+function convertRunContent(content, marks, formatting) {
+	switch (content.type) {
+		case "text":
+			if (content.text) return [schema.text(content.text, marks)];
+			return [];
+		case "break":
+			if (content.breakType === "textWrapping" || !content.breakType) return [withHyperlinkBoundaryMarks(schema.node("hardBreak"), marks)];
+			if (content.breakType === "column") return [withHyperlinkBoundaryMarks(schema.node("hardBreak", { breakType: "column" }), marks)];
+			return [];
+		case "tab": return [schema.node("tab").mark(marks)];
+		case "drawing": return [withHyperlinkBoundaryMarks(convertImage(content.image, content.rawXml), marks)];
+		case "shape": {
+			const shp = content.shape;
+			if (shp.textBody) return [];
+			return [withHyperlinkBoundaryMarks(convertShape(shp), marks)];
+		}
+		case "footnoteRef": {
+			const footnoteMark = schema.mark("footnoteRef", {
+				id: content.id.toString(),
+				noteType: "footnote",
+				vertAlign: formatting?.vertAlign === "baseline" || formatting?.vertAlign === "superscript" ? formatting.vertAlign : null
+			});
+			return [schema.text(content.id.toString(), [...marks, footnoteMark])];
+		}
+		case "endnoteRef": {
+			const endnoteMark = schema.mark("footnoteRef", {
+				id: content.id.toString(),
+				noteType: "endnote",
+				vertAlign: formatting?.vertAlign === "baseline" || formatting?.vertAlign === "superscript" ? formatting.vertAlign : null
+			});
+			return [schema.text(content.id.toString(), [...marks, endnoteMark])];
+		}
+		case "fieldChar":
+		case "instrText": return [];
+		case "noBreakHyphen": return [schema.text("‑", marks)];
+		case "softHyphen": return [schema.text("­", marks)];
+		case "symbol": return content.char ? [schema.text(content.char, marks)] : [];
+	}
+}
+function withHyperlinkBoundaryMarks(node, marks) {
+	if (!marks.some((mark) => mark.type.name === "hyperlink")) return node;
+	return node.mark(marks);
+}
+function convertImage(image, rawXml) {
+	const imageSize = image.size;
+	const widthPx = imageSize?.width ? emuToPixels(imageSize.width) : void 0;
+	const heightPx = imageSize?.height ? emuToPixels(imageSize.height) : void 0;
+	const wrapType = image.wrap.type;
+	const wrapText = image.wrap.wrapText;
+	const imagePosition = image.position;
+	const hAlign = imagePosition?.horizontal?.alignment;
+	let cssFloat;
+	if (wrapType === "inline") cssFloat = "none";
+	else if (wrapType === "topAndBottom") cssFloat = "none";
+	else if (wrapType === "square" || wrapType === "tight" || wrapType === "through") if (wrapText === "left") cssFloat = "right";
+	else if (wrapText === "right") cssFloat = "left";
+	else if (hAlign === "left") cssFloat = "left";
+	else if (hAlign === "right") cssFloat = "right";
+	else cssFloat = "none";
+	else cssFloat = "none";
+	let displayMode;
+	if (wrapType === "inline") displayMode = "inline";
+	else if (wrapType === "topAndBottom") displayMode = "block";
+	else if (wrapType === "behind" || wrapType === "inFront") displayMode = "float";
+	else if (cssFloat !== "none") displayMode = "float";
+	else displayMode = "block";
+	let transform;
+	if (image.transform) {
+		const transforms = [];
+		if (image.transform.rotation) transforms.push(`rotate(${image.transform.rotation}deg)`);
+		if (image.transform.flipH) transforms.push("scaleX(-1)");
+		if (image.transform.flipV) transforms.push("scaleY(-1)");
+		if (transforms.length > 0) transform = transforms.join(" ");
+	}
+	const distTop = image.wrap.distT != null ? emuToPixels(image.wrap.distT) : void 0;
+	const distBottom = image.wrap.distB != null ? emuToPixels(image.wrap.distB) : void 0;
+	const distLeft = image.wrap.distL != null ? emuToPixels(image.wrap.distL) : void 0;
+	const distRight = image.wrap.distR != null ? emuToPixels(image.wrap.distR) : void 0;
+	let position;
+	if (imagePosition) {
+		position = {};
+		if (imagePosition.horizontal) {
+			const h = { relativeTo: imagePosition.horizontal.relativeTo };
+			if (imagePosition.horizontal.posOffset !== void 0) h.posOffset = imagePosition.horizontal.posOffset;
+			if (imagePosition.horizontal.alignment) h.align = imagePosition.horizontal.alignment;
+			position.horizontal = h;
+		}
+		if (imagePosition.vertical) {
+			const v = { relativeTo: imagePosition.vertical.relativeTo };
+			if (imagePosition.vertical.posOffset !== void 0) v.posOffset = imagePosition.vertical.posOffset;
+			if (imagePosition.vertical.alignment) v.align = imagePosition.vertical.alignment;
+			position.vertical = v;
+		}
+	}
+	let borderWidth;
+	let borderColor;
+	let borderStyle;
+	if (image.outline && image.outline.width) {
+		borderWidth = Math.round(image.outline.width / 914400 * 96 * 100) / 100;
+		if (image.outline.color?.rgb) borderColor = `#${image.outline.color.rgb}`;
+		borderStyle = image.outline.style ? {
+			solid: "solid",
+			dot: "dotted",
+			dash: "dashed",
+			lgDash: "dashed",
+			dashDot: "dashed",
+			lgDashDot: "dashed",
+			lgDashDotDot: "dashed",
+			sysDot: "dotted",
+			sysDash: "dashed",
+			sysDashDot: "dashed",
+			sysDashDotDot: "dashed"
+		}[image.outline.style] || "solid" : "solid";
+	}
+	return schema.node("image", {
+		src: image.src || "",
+		alt: image.alt,
+		title: image.title,
+		width: widthPx,
+		height: heightPx,
+		rId: image.rId,
+		wrapType,
+		displayMode,
+		cssFloat,
+		transform,
+		opacity: image.opacity,
+		distTop,
+		distBottom,
+		distLeft,
+		distRight,
+		cropTop: image.crop?.top,
+		cropRight: image.crop?.right,
+		cropBottom: image.crop?.bottom,
+		cropLeft: image.crop?.left,
+		position,
+		borderWidth,
+		borderColor,
+		borderStyle,
+		wrapText,
+		hlinkHref: image.hlinkHref,
+		_docxRawXml: rawXml
+	});
+}
+/**
+* Convert a Hyperlink to ProseMirror nodes with link mark
+*
+* @param hyperlink - The hyperlink to convert
+* @param getInheritedRunFormatting - Formatting inherited by each child run
+*/
+function convertHyperlink(hyperlink, getInheritedRunFormatting, styleResolver, hyperlinkIndex) {
+	const nodes = [];
+	const href = hyperlink.href || (hyperlink.anchor ? `#${hyperlink.anchor}` : "");
+	const linkMark = schema.mark("hyperlink", {
+		href,
+		tooltip: hyperlink.tooltip,
+		rId: hyperlink.rId,
+		_docxHyperlinkIndex: hyperlinkIndex
+	});
+	for (const child of hyperlink.children) if (child.type === "run") {
+		const inheritedFormatting = getInheritedRunFormatting(child.formatting);
+		const { marks: runMarks, mergedFormatting } = buildRunMarks(child.formatting, inheritedFormatting, styleResolver);
+		const allMarks = [...runMarks, linkMark];
+		for (const content of child.content) nodes.push(...convertRunContent(content, allMarks, mergedFormatting));
+	}
+	return nodes;
+}
+/**
+* Convert TextFormatting to ProseMirror marks
+*/
+function textFormattingToMarks(formatting) {
+	if (!formatting) return [];
+	const marks = [];
+	const overrideAttrs = buildRunFormattingOverrideAttrs(formatting);
+	if (overrideAttrs) marks.push(schema.mark("runFormattingOverride", overrideAttrs));
+	if (formatting.bold) marks.push(schema.mark("bold"));
+	if (formatting.italic) marks.push(schema.mark("italic"));
+	if (formatting.underline && formatting.underline.style !== "none") marks.push(schema.mark("underline", {
+		style: formatting.underline.style,
+		color: formatting.underline.color
+	}));
+	if (formatting.strike || formatting.doubleStrike) marks.push(schema.mark("strike", { double: formatting.doubleStrike || false }));
+	if (formatting.color && !formatting.color.auto) marks.push(schema.mark("textColor", {
+		rgb: formatting.color.rgb,
+		themeColor: formatting.color.themeColor,
+		themeTint: formatting.color.themeTint,
+		themeShade: formatting.color.themeShade
+	}));
+	if (formatting.highlight && formatting.highlight !== "none") marks.push(schema.mark("highlight", { color: formatting.highlight }));
+	const runShadingMarkAttrs = shadingToRunShadingAttrs(formatting.shading);
+	if (runShadingMarkAttrs) marks.push(schema.mark("runShading", runShadingMarkAttrs));
+	if (formatting.fontSize) marks.push(schema.mark("fontSize", { size: formatting.fontSize }));
+	if (formatting.fontFamily) marks.push(schema.mark("fontFamily", {
+		ascii: formatting.fontFamily.ascii,
+		hAnsi: formatting.fontFamily.hAnsi,
+		eastAsia: formatting.fontFamily.eastAsia,
+		cs: formatting.fontFamily.cs,
+		asciiTheme: formatting.fontFamily.asciiTheme,
+		hAnsiTheme: formatting.fontFamily.hAnsiTheme,
+		eastAsiaTheme: formatting.fontFamily.eastAsiaTheme,
+		csTheme: formatting.fontFamily.csTheme
+	}));
+	if (formatting.vertAlign === "superscript") marks.push(schema.mark("superscript"));
+	else if (formatting.vertAlign === "subscript") marks.push(schema.mark("subscript"));
+	if (formatting.allCaps) marks.push(schema.mark("allCaps"));
+	if (formatting.smallCaps) marks.push(schema.mark("smallCaps"));
+	const spacing = typeof formatting.spacing === "number" ? formatting.spacing : null;
+	const position = typeof formatting.position === "number" ? formatting.position : null;
+	const scale = typeof formatting.scale === "number" ? formatting.scale : null;
+	const kerning = typeof formatting.kerning === "number" ? formatting.kerning : null;
+	if (spacing !== null || position !== null || scale !== null || kerning !== null) marks.push(schema.mark("characterSpacing", {
+		spacing,
+		position,
+		scale,
+		kerning
+	}));
+	if (formatting.hidden === true) marks.push(schema.mark("hidden"));
+	if (formatting.emboss) marks.push(schema.mark("emboss"));
+	if (formatting.imprint) marks.push(schema.mark("imprint"));
+	if (formatting.shadow) marks.push(schema.mark("textShadow"));
+	if (formatting.emphasisMark && formatting.emphasisMark !== "none") marks.push(schema.mark("emphasisMark", { type: formatting.emphasisMark }));
+	if (formatting.outline) marks.push(schema.mark("textOutline"));
+	if (formatting.rtl) marks.push(schema.mark("rtl"));
+	if (formatting.effect && formatting.effect !== "none") marks.push(schema.mark("textEffect", { effect: formatting.effect }));
+	return marks;
+}
+/**
+* Convert a Shape to a ProseMirror shape node (inline SVG)
+*/
+function convertShape(shape) {
+	const shapeSize = shape.size;
+	const widthPx = shapeSize?.width ? emuToPixels(shapeSize.width) : 100;
+	const heightPx = shapeSize?.height ? emuToPixels(shapeSize.height) : 80;
+	const shapeAttrs = shape;
+	let fillColor;
+	let fillType = "solid";
+	let gradientType;
+	let gradientAngle;
+	let gradientStops;
+	if (shape.fill) {
+		fillType = shape.fill.type;
+		if (shape.fill.color?.rgb) fillColor = `#${shape.fill.color.rgb}`;
+		if (shape.fill.type === "gradient" && shape.fill.gradient) {
+			const g = shape.fill.gradient;
+			gradientType = g.type;
+			gradientAngle = g.angle;
+			gradientStops = JSON.stringify(g.stops.map((s) => ({
+				position: s.position,
+				color: s.color.rgb ? `#${s.color.rgb}` : "#000000"
+			})));
+		}
+	}
+	let outlineWidth;
+	let outlineColor;
+	let outlineStyle = "none";
+	let outlineCap;
+	let outlineHeadEnd;
+	let outlineTailEnd;
+	if (shape.outline) {
+		if (shape.outline.width) outlineWidth = Math.round(shape.outline.width / 914400 * 96 * 100) / 100;
+		if (shape.outline.color?.rgb) outlineColor = `#${shape.outline.color.rgb}`;
+		outlineStyle = shape.outline.style || "solid";
+		outlineCap = shape.outline.cap;
+		outlineHeadEnd = shape.outline.headEnd;
+		outlineTailEnd = shape.outline.tailEnd;
+	} else outlineWidth = 0;
+	let transform;
+	if (shape.transform) {
+		const transforms = [];
+		if (shape.transform.rotation) transforms.push(`rotate(${shape.transform.rotation}deg)`);
+		if (shape.transform.flipH) transforms.push("scaleX(-1)");
+		if (shape.transform.flipV) transforms.push("scaleY(-1)");
+		if (transforms.length > 0) transform = transforms.join(" ");
+	}
+	const wrapType = shape.wrap?.type ?? "inline";
+	const displayMode = wrapType === "inline" ? "inline" : "float";
+	let cssFloat = "none";
+	if (shape.wrap?.wrapText === "left") cssFloat = "right";
+	else if (shape.wrap?.wrapText === "right") cssFloat = "left";
+	let position;
+	if (shape.position) position = {
+		horizontal: {
+			relativeTo: shape.position.horizontal.relativeTo,
+			...shape.position.horizontal.posOffset !== void 0 ? { posOffset: shape.position.horizontal.posOffset } : {},
+			...shape.position.horizontal.alignment ? { align: shape.position.horizontal.alignment } : {}
+		},
+		vertical: {
+			relativeTo: shape.position.vertical.relativeTo,
+			...shape.position.vertical.posOffset !== void 0 ? { posOffset: shape.position.vertical.posOffset } : {},
+			...shape.position.vertical.alignment ? { align: shape.position.vertical.alignment } : {}
+		}
+	};
+	return schema.node("shape", {
+		shapeType: shapeAttrs.shapeType ?? "rect",
+		shapeId: shape.id,
+		width: widthPx,
+		height: heightPx,
+		fillColor,
+		fillType,
+		gradientType,
+		gradientAngle,
+		gradientStops,
+		outlineWidth,
+		outlineColor,
+		outlineStyle,
+		outlineCap,
+		outlineHeadEnd,
+		outlineTailEnd,
+		transform,
+		displayMode,
+		cssFloat,
+		wrapType,
+		wrapText: shape.wrap?.wrapText,
+		distTop: shape.wrap?.distT !== void 0 ? emuToPixels(shape.wrap.distT) : void 0,
+		distBottom: shape.wrap?.distB !== void 0 ? emuToPixels(shape.wrap.distB) : void 0,
+		distLeft: shape.wrap?.distL !== void 0 ? emuToPixels(shape.wrap.distL) : void 0,
+		distRight: shape.wrap?.distR !== void 0 ? emuToPixels(shape.wrap.distR) : void 0,
+		position
+	});
+}
+/**
+* Convert a paragraph block to PM nodes, extracting text boxes as sibling nodes.
+* Skips ghost empty paragraphs that only contained text box drawings.
+*/
+function convertParagraphWithTextBoxes(block, styleResolver, textBoxGroupId) {
+	const textBoxes = extractTextBoxesFromParagraph(block);
+	const pmParagraph = convertParagraph(block, styleResolver);
+	const nodes = [];
+	const isEmptyAfterExtraction = textBoxes.length > 0 && pmParagraph.content.size === 0;
+	const keepWrapperParagraph = isEmptyAfterExtraction && hasParagraphBoundaryPayload(block, pmParagraph);
+	if (!isEmptyAfterExtraction || keepWrapperParagraph) nodes.push(pmParagraph);
+	for (const tb of textBoxes) nodes.push(convertTextBox(tb, styleResolver, {
+		placement: isEmptyAfterExtraction && !keepWrapperParagraph ? "standalone" : "inlineWithPrevious",
+		groupId: textBoxGroupId
+	}));
+	return nodes;
+}
+function hasParagraphBoundaryPayload(block, pmParagraph) {
+	const bookmarks = pmParagraph.attrs["bookmarks"];
+	const emptyHyperlinks = pmParagraph.attrs["_emptyHyperlinks"];
+	return Boolean(block.sectionProperties || block.propertyChanges?.length || Array.isArray(bookmarks) && bookmarks.length > 0 || Array.isArray(emptyHyperlinks) && emptyHyperlinks.length > 0);
+}
+/**
+* Extract text boxes from paragraph runs.
+* Text boxes appear as ShapeContent where the shape has textBody,
+* or as DrawingContent that contains a text box instead of an image.
+*/
+function extractTextBoxesFromParagraph(paragraph) {
+	const textBoxes = [];
+	for (const content of paragraph.content) if (content.type === "run") {
+		for (const rc of content.content) if (rc.type === "shape") {
+			const shape = rc.shape;
+			if (shape.textBody) {
+				const textBox = {
+					type: "textBox",
+					size: shape.size,
+					content: shape.textBody.content
+				};
+				if (shape.id) textBox.id = shape.id;
+				if (shape.position) textBox.position = shape.position;
+				if (shape.wrap) textBox.wrap = shape.wrap;
+				if (shape.fill) textBox.fill = shape.fill;
+				if (shape.outline) textBox.outline = shape.outline;
+				if (shape.textBody.margins) textBox.margins = shape.textBody.margins;
+				textBoxes.push(textBox);
+			}
+		}
+	}
+	return textBoxes;
+}
+/**
+* Convert a TextBox to a ProseMirror textBox node
+*/
+function convertTextBox(textBox, styleResolver, options = {}) {
+	const textBoxSize = textBox.size;
+	const widthPx = textBoxSize?.width ? emuToPixels(textBoxSize.width) : 200;
+	const heightPx = textBoxSize?.height ? emuToPixels(textBoxSize.height) : void 0;
+	let fillColor;
+	if (textBox.fill?.color?.rgb) fillColor = `#${textBox.fill.color.rgb}`;
+	let outlineWidth;
+	let outlineColor;
+	let outlineStyle;
+	if (textBox.outline && textBox.outline.width) {
+		outlineWidth = Math.round(textBox.outline.width / 914400 * 96 * 100) / 100;
+		if (textBox.outline.color?.rgb) outlineColor = `#${textBox.outline.color.rgb}`;
+		outlineStyle = textBox.outline.style || "solid";
+	}
+	const marginTop = textBox.margins?.top !== void 0 ? emuToPixels(textBox.margins.top) : 4;
+	const marginBottom = textBox.margins?.bottom !== void 0 ? emuToPixels(textBox.margins.bottom) : 4;
+	const marginLeft = textBox.margins?.left !== void 0 ? emuToPixels(textBox.margins.left) : 7;
+	const marginRight = textBox.margins?.right !== void 0 ? emuToPixels(textBox.margins.right) : 7;
+	const contentNodes = [];
+	for (const para of textBox.content) contentNodes.push(convertParagraph(para, styleResolver));
+	if (contentNodes.length === 0) contentNodes.push(schema.node("paragraph", {}, []));
+	const wrapType = textBox.wrap?.type;
+	const wrapText = textBox.wrap?.wrapText;
+	const hAlign = textBox.position?.horizontal.alignment;
+	let position;
+	if (textBox.position) position = {
+		horizontal: {
+			relativeTo: textBox.position.horizontal.relativeTo,
+			...textBox.position.horizontal.posOffset !== void 0 ? { posOffset: textBox.position.horizontal.posOffset } : {},
+			...textBox.position.horizontal.alignment ? { align: textBox.position.horizontal.alignment } : {}
+		},
+		vertical: {
+			relativeTo: textBox.position.vertical.relativeTo,
+			...textBox.position.vertical.posOffset !== void 0 ? { posOffset: textBox.position.vertical.posOffset } : {},
+			...textBox.position.vertical.alignment ? { align: textBox.position.vertical.alignment } : {}
+		}
+	};
+	let cssFloat;
+	if (wrapType === void 0 || wrapType === "inline") cssFloat = "none";
+	else if (wrapType === "topAndBottom") cssFloat = "none";
+	else if (wrapType === "square" || wrapType === "tight" || wrapType === "through") if (wrapText === "left") cssFloat = "right";
+	else if (wrapText === "right") cssFloat = "left";
+	else if (hAlign === "left") cssFloat = "left";
+	else if (hAlign === "right") cssFloat = "right";
+	else cssFloat = "none";
+	else cssFloat = "none";
+	let displayMode;
+	if (wrapType === void 0 || wrapType === "inline") displayMode = "inline";
+	else if (wrapType === "topAndBottom") displayMode = "block";
+	else if (wrapType === "behind" || wrapType === "inFront") displayMode = "float";
+	else if (cssFloat !== "none") displayMode = "float";
+	else displayMode = "block";
+	const distTop = textBox.wrap?.distT ? emuToPixels(textBox.wrap.distT) : void 0;
+	const distBottom = textBox.wrap?.distB ? emuToPixels(textBox.wrap.distB) : void 0;
+	const distLeft = textBox.wrap?.distL ? emuToPixels(textBox.wrap.distL) : void 0;
+	const distRight = textBox.wrap?.distR ? emuToPixels(textBox.wrap.distR) : void 0;
+	return schema.node("textBox", {
+		width: widthPx,
+		height: heightPx,
+		textBoxId: textBox.id,
+		fillColor,
+		outlineWidth,
+		outlineColor,
+		outlineStyle,
+		marginTop,
+		marginBottom,
+		marginLeft,
+		marginRight,
+		displayMode,
+		cssFloat,
+		wrapType: wrapType ?? "inline",
+		wrapText,
+		distTop,
+		distBottom,
+		distLeft,
+		distRight,
+		position,
+		_docxPlacement: options.placement,
+		_docxGroupId: options.groupId
+	}, contentNodes);
+}
+/**
+* Convert HeaderFooter content (array of Paragraph/Table blocks) to a ProseMirror document.
+* Used for editing headers/footers in their own ProseMirror editor and for
+* the unified header/footer render pipeline (see
+* `core/layout-bridge/headerFooterLayout.ts`). `theme` lives in
+* `ToProseDocOptions` for future themeColor cell-shading resolution; folio's
+* `convertTable` does not yet thread it (orthogonal upstream divergence).
+*/
+function headerFooterToProseDoc(content, options) {
+	const nodes = [];
+	const styleResolver = options?.styles ? createStyleEngine(options.styles) : null;
+	const theme = options?.theme ?? null;
+	let textBoxGroupIndex = 0;
+	const convertBlocks = (blocks) => {
+		const out = [];
+		for (const block of blocks) if (block.type === "paragraph") {
+			out.push(...convertParagraphWithTextBoxes(block, styleResolver, String(textBoxGroupIndex)));
+			textBoxGroupIndex += 1;
+		} else if (block.type === "table") out.push(convertTable(block, styleResolver, theme));
+		else out.push(convertBlockSdt(block, convertBlocks));
+		return out;
+	};
+	nodes.push(...convertBlocks(content));
+	if (nodes.length === 0) nodes.push(schema.node("paragraph", {}, []));
+	const pmDoc = schema.node("doc", null, nodes);
+	assertValidProseMirrorDocument(pmDoc, "Header/footer conversion produced an invalid ProseMirror document");
+	return pmDoc;
+}
+function footnoteToProseDoc(content, options) {
+	return headerFooterToProseDoc(content, options);
+}
+/**
+* Determine where a page break appears inside a paragraph.
+*
+* Per ECMA-376 §17.3.3.1, `<w:br w:type="page"/>` is always a forced break,
+* including in a paragraph whose only content is the break itself. We previously
+* searched only top-level runs and missed breaks nested in hyperlinks, tracked
+* changes, or fields — so those paragraphs silently dropped their forced break
+* and the following content collapsed onto the previous page (common on legal
+* signature pages and exhibit covers).
+* See eigenpal docx-editor #409 (break-only page break sub-fix).
+*
+* Returns:
+*   "before" — the break appears before any visible content; the paragraph's
+*              content belongs on the NEXT page.
+*   "after"  — the break follows some visible content; the paragraph stays
+*              on the current page and the next block starts a new page.
+*   null     — no page break found.
+*/
+function paragraphPageBreakPosition(paragraph) {
+	const state = { seenVisibleContent: false };
+	function isPageBreak(content) {
+		return content.type === "break" && content.breakType === "page";
+	}
+	function isVisibleRunContent(content) {
+		return content.type === "text" && content.text.length > 0 || content.type === "tab" || content.type === "drawing" || content.type === "shape" || content.type === "symbol" || content.type === "fieldChar" || content.type === "instrText" || content.type === "footnoteRef" || content.type === "endnoteRef" || content.type === "noBreakHyphen" || content.type === "softHyphen";
+	}
+	function visitRun(run) {
+		for (const content of run.content) {
+			if (isPageBreak(content)) return true;
+			if (isVisibleRunContent(content)) state.seenVisibleContent = true;
+		}
+		return false;
+	}
+	function visitHyperlinkChildren(hyperlink) {
+		for (const child of hyperlink.children) if (child.type === "run" && visitRun(child)) return true;
+		return false;
+	}
+	function visitRunOrHyperlinkList(children) {
+		for (const child of children) {
+			if (child.type === "run" && visitRun(child)) return true;
+			if (child.type === "hyperlink" && visitHyperlinkChildren(child)) return true;
+		}
+		return false;
+	}
+	function visitItem(item) {
+		if (item.type === "run") return visitRun(item);
+		if (item.type === "hyperlink") return visitHyperlinkChildren(item);
+		if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") return visitRunOrHyperlinkList(item.content);
+		if (item.type === "simpleField") return visitRunOrHyperlinkList(item.content);
+		if (item.type === "complexField") {
+			for (const run of item.fieldResult) if (visitRun(run)) return true;
+			return false;
+		}
+		if (item.type === "inlineSdt") {
+			for (const child of item.content) if (visitItem(child)) return true;
+			return false;
+		}
+		if (item.type === "mathEquation") {
+			state.seenVisibleContent = true;
+			return false;
+		}
+		return false;
+	}
+	for (const item of paragraph.content) if (visitItem(item)) return state.seenVisibleContent ? "after" : "before";
+	return null;
+}
+/**
+* Create an empty ProseMirror document
+*/
+function createEmptyDoc() {
+	return schema.node("doc", null, [schema.node("paragraph", {}, [])]);
+}
+//#endregion
+export { createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, textFormattingToMarks, toProseDoc };