@stll/folio-core 0.36.0 → 0.37.0

package/dist/prosemirror/conversion/toProseDoc.js

@@ -1,5 +1,6 @@
 import { resolveColorValueToHex } from "../../docx/drawingUtils.js";
 import { linkProseParagraphPropertySource, recreateProseNodeWithParagraphPropertySource } from "../../docx/paragraphPropertySource.js";
+import { buildPageBreakRunSourceDescendantIndex } from "../../internal/pageBreakRunSourceDescendantIndex.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { mergeParagraphFormatting, mergeParagraphTabStops } from "../../utils/paragraphFormattingMerge.js";
@@ -9,16 +10,22 @@ import { emuToPixels } from "../../utils/units.js";
 import { setAutospacingBaseValue } from "../autospacingBase.js";
 import { buildRunFormattingOverrideAttrs } from "../extensions/marks/RunFormattingOverrideExtension.js";
 import { stampNumberedRefFieldBaselines } from "../numberedRefFields.js";
+import { pageBreakRunParagraphProjectionDispositionForFeatures } from "../pageBreakRunProjection.js";
 import { directionFromBidi } from "../paragraphDirection.js";
+import { lineSpacingProvenanceFromSpacing } from "../paragraphSpacing.js";
+import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, stripParagraphMarkFormattingForBodyRuns, stripParagraphMarkOnlyFormatting, suppressParagraphMarkFormatting } from "../runStyleFormatting.js";
 import { schema } from "../schema/index.js";
+import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS } from "../schema/marks.js";
 import { cascadeStyleTextFormatting } from "../styles/styleToggleCascade.js";
+import { canCarryTrackedRunMark, trackedRunInlineAtomDisposition } from "../trackedRunInlineAtoms.js";
 import { assertValidProseMirrorDocument } from "../validation.js";
 import { resolveEffectiveTableCellFormatting } from "./effectiveTableCellFormatting.js";
-import { marksToTextFormatting } from "./fromProseDoc.js";
 import { shadingToRunShadingAttrs } from "./runShadingMark.js";
 import { sdtAttrsFromProperties } from "./sdtAttrs.js";
-import { panic } from "better-result";
+import { TaggedError, panic } from "better-result";
 //#region src/prosemirror/conversion/toProseDoc.ts
+/** DOCX content that cannot be preserved by the editable ProseMirror model. */
+var UnsupportedDocxToProseMirrorConversionError = class extends TaggedError("UnsupportedDocxToProseMirrorConversionError") {};
 const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
 /**
 * Build a `nextTextBoxGroupId()` generator salted with a random per-load
@@ -106,36 +113,16 @@ function toProseDoc(document, options) {
 		theme,
 		nextTextBoxGroupId,
 		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator(),
-		pairedBookmarkIds: collectPairedBookmarkIds(paragraphs)
+		pairedBookmarkIds: collectPairedBookmarkIds(paragraphs),
+		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(paragraphs)
 	};
 	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"));
-			const converted = convertParagraphWithTextBoxes(block, styleResolver, {
-				textBoxGroupId: nextTextBoxGroupId(),
-				context: conversionContext
-			});
-			const firstConverted = converted.at(0);
-			if (pbPos === "before" && converted.length === 1 && firstConverted?.type.name === "paragraph" && firstConverted.content.size === 0 && document.package.settings?.splitPageBreakAndParagraphMark !== true) {
-				const paragraph = firstConverted;
-				converted[0] = recreateProseNodeWithParagraphPropertySource(paragraph, { attrs: {
-					...paragraph.attrs,
-					_pageBreakCarrier: true
-				} });
-			}
-			if (pbPos === "after") {
-				const paragraphIndex = converted.findIndex((node) => node.type.name === "paragraph");
-				const trailingParagraph = paragraphIndex >= 0 ? converted.at(paragraphIndex) : void 0;
-				if (trailingParagraph) converted[paragraphIndex] = recreateProseNodeWithParagraphPropertySource(trailingParagraph, { attrs: {
-					...trailingParagraph.attrs,
-					_trailingPageBreak: true
-				} });
-			}
-			out.push(...converted);
-			if (pbPos === "after") out.push(schema.node("pageBreak"));
-		} else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
+		for (const block of blocks) if (block.type === "paragraph") out.push(...convertParagraphWithTextBoxes(block, styleResolver, {
+			textBoxGroupId: nextTextBoxGroupId(),
+			context: conversionContext
+		}));
+		else if (block.type === "table") out.push(convertTable(block, styleResolver, conversionContext));
 		else out.push(convertBlockSdt(block, convertBodyBlocks));
 		return out;
 	};
@@ -187,8 +174,17 @@ function convertBlockSdt(blockSdt, convertBlocks) {
 * 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, nextHyperlinkInstanceIndex, pairedBookmarkIds, activeCommentIds, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
-	const attrs = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
+function convertParagraph(paragraph, styleResolver, context, activeCommentIds, extraRunFormatting, tableParagraphOverlay, textBoxAnchors) {
+	const { nextHyperlinkInstanceIndex, pairedBookmarkIds, pageBreakRunSourceDescendants } = context;
+	let pageBreakRunOwnerId = 0;
+	const nextPageBreakRunOwnerId = () => pageBreakRunOwnerId++;
+	const { attrs, effectiveFrame } = paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOverlay);
+	assertParagraphPageBreakCanBeProjected({
+		paragraph,
+		attrs,
+		effectiveFrame,
+		sourceDescendants: pageBreakRunSourceDescendants
+	});
 	const isTocParagraph = attrs._tableOfContentsLevel !== void 0;
 	const inlineNodes = [];
 	let inlineOffset = 0;
@@ -216,7 +212,7 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 	}
 	const paragraphRunFormatting = resolveRunFormattingWithoutDefaults(paragraph.formatting?.runProperties, styleResolver);
 	let inheritableParagraphRunFormatting;
-	if (paragraphRunFormatting && !isTocParagraph) inheritableParagraphRunFormatting = stripParagraphMarkFormattingForBodyRuns(paragraphRunFormatting);
+	if (paragraphRunFormatting && !isTocParagraph && paragraph.formatting?.styleId === void 0) inheritableParagraphRunFormatting = stripParagraphMarkFormattingForBodyRuns(paragraphRunFormatting);
 	const ordinaryStyleFormatting = paragraph.formatting?.styleId === void 0 ? mergeTextFormatting(styleRunFormatting, extraRunFormatting) : mergeTextFormatting(extraRunFormatting, styleRunFormatting);
 	const orderedToggleFormatting = cascadeStyleTextFormatting([
 		{
@@ -234,53 +230,75 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 	], { ordinaryFormatting: ordinaryStyleFormatting });
 	let baseRunFormatting = orderedToggleFormatting.formatting;
 	if (paragraphStyleFontFamily) baseRunFormatting = mergeTextFormatting(baseRunFormatting, { fontFamily: paragraphStyleFontFamily });
-	const paragraphMarkPrecedesStyle = paragraph.formatting?.styleId !== void 0;
-	const ordinaryDefaultRunFormatting = paragraphMarkPrecedesStyle ? mergeTextFormatting(inheritableParagraphRunFormatting, baseRunFormatting) : mergeTextFormatting(baseRunFormatting, inheritableParagraphRunFormatting);
-	const defaultToggleCascade = paragraphMarkPrecedesStyle ? cascadeStyleTextFormatting([{
+	const defaultCharacterFormatting = styleResolver?.getDefaultCharacterStyle()?.rPr;
+	const ordinaryBaseWithDefaultCharacter = mergeTextFormatting(defaultCharacterFormatting, baseRunFormatting);
+	const defaultCharacterStyleCascade = cascadeStyleTextFormatting([{
 		cascade: orderedToggleFormatting,
 		type: "carried"
-	}], { ordinaryFormatting: ordinaryDefaultRunFormatting }) : cascadeStyleTextFormatting([{
-		cascade: orderedToggleFormatting,
+	}, {
+		formatting: defaultCharacterFormatting,
+		type: "style"
+	}], { ordinaryFormatting: ordinaryBaseWithDefaultCharacter });
+	const ordinaryDefaultRunFormatting = mergeTextFormatting(ordinaryBaseWithDefaultCharacter, inheritableParagraphRunFormatting);
+	const defaultToggleCascade = cascadeStyleTextFormatting([{
+		cascade: defaultCharacterStyleCascade,
 		type: "carried"
 	}, {
 		formatting: inheritableParagraphRunFormatting,
 		type: "direct"
 	}], { ordinaryFormatting: ordinaryDefaultRunFormatting });
 	const defaultRunFormatting = defaultToggleCascade.formatting;
+	if (extraRunFormatting !== void 0) if (defaultRunFormatting) attrs.defaultTextFormatting = defaultRunFormatting;
+	else delete attrs.defaultTextFormatting;
 	const getInheritedRunFormatting = (formatting, fieldType) => {
+		const hasCharacterStyle = formatting?.styleId !== void 0;
+		const inheritedBaseFormatting = hasCharacterStyle ? baseRunFormatting : ordinaryBaseWithDefaultCharacter;
+		const inheritedToggleCascade = hasCharacterStyle ? orderedToggleFormatting : defaultCharacterStyleCascade;
 		if (fieldType === "TOC") return {
-			formatting: hasDirectRunFormatting(formatting) ? suppressParagraphMarkFormatting(baseRunFormatting, void 0, formatting) : baseRunFormatting,
-			toggleCascade: orderedToggleFormatting
+			formatting: hasDirectRunFormatting(formatting) ? suppressParagraphMarkFormatting({
+				baseFormatting: inheritedBaseFormatting,
+				directFormatting: formatting,
+				paragraphMarkFormatting: void 0
+			}) : inheritedBaseFormatting,
+			...!hasCharacterStyle ? { implicitCharacterStyleApplied: true } : {},
+			toggleCascade: inheritedToggleCascade
 		};
 		if (!(hasDirectRunFormatting(formatting) || formatting?.styleId !== void 0)) return {
 			formatting: defaultRunFormatting,
+			implicitCharacterStyleApplied: true,
 			toggleCascade: defaultToggleCascade
 		};
-		const suppressedFormatting = suppressParagraphMarkFormatting(baseRunFormatting, inheritableParagraphRunFormatting, formatting, paragraphMarkPrecedesStyle);
+		const suppressedFormatting = suppressParagraphMarkFormatting({
+			baseFormatting: inheritedBaseFormatting,
+			directFormatting: formatting,
+			paragraphMarkFormatting: inheritableParagraphRunFormatting
+		});
 		const paragraphMarkOverrides = getParagraphMarkSuppressionOverrides({
 			directFormatting: formatting,
 			paragraphMarkFormatting: inheritableParagraphRunFormatting,
 			suppressedFormatting
-		});
+		}) ?? (inheritableParagraphRunFormatting ? {} : void 0);
 		return {
 			formatting: suppressedFormatting,
+			...!hasCharacterStyle ? { implicitCharacterStyleApplied: true } : {},
 			...paragraphMarkOverrides ? { paragraphMarkOverrides } : {},
-			toggleCascade: orderedToggleFormatting
+			toggleCascade: inheritedToggleCascade
 		};
 	};
 	const emitTrackedChange = (change, markType, moveKind) => {
-		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
+		emitInlineNodes(convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind, textBoxAnchors));
 	};
 	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, textBoxAnchors));
+	else if (content.type === "run") emitInlineNodes(convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
 	else if (content.type === "hyperlink") {
 		const linkNodes = convertHyperlink(content, {
 			getInheritedRunFormatting,
 			styleResolver,
 			hyperlinkIndex: nextHyperlinkInstanceIndex(),
-			textBoxAnchors
+			textBoxAnchors,
+			nextPageBreakRunOwnerId
 		});
 		if (linkNodes.length === 0) {
 			emptyHyperlinks ??= [];
@@ -298,9 +316,10 @@ function convertParagraph(paragraph, styleResolver, nextHyperlinkInstanceIndex,
 		getInheritedRunFormatting,
 		styleResolver,
 		nextHyperlinkInstanceIndex,
+		nextPageBreakRunOwnerId,
 		textBoxAnchors
 	}));
-	else if (content.type === "inlineSdt") emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors));
+	else if (content.type === "inlineSdt") emitInlineNode(convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors));
 	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));
@@ -366,29 +385,31 @@ function anchorPointComment(nodes, commentId) {
 * Convert tracked change (insertion or deletion) content to PM nodes with
 * an insertion/deletion mark applied.
 */
-function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors) {
+function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, moveKind = null, textBoxAnchors) {
 	const nodes = [];
-	for (const item of change.content) if (item.type === "run") nodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), styleResolver, textBoxAnchors));
+	for (const item of change.content) if (item.type === "run") nodes.push(...convertRun(item, getInheritedRunFormatting(item.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
 	else if (item.type === "hyperlink") {
 		const currentHyperlinkIndex = nextHyperlinkInstanceIndex();
 		nodes.push(...convertHyperlink(item, {
 			getInheritedRunFormatting,
 			styleResolver,
 			hyperlinkIndex: currentHyperlinkIndex,
-			textBoxAnchors
+			textBoxAnchors,
+			nextPageBreakRunOwnerId
 		}));
 	} else if (item.type === "simpleField" || item.type === "complexField") {
 		const fieldNode = convertField(item, {
 			getInheritedRunFormatting,
 			styleResolver,
 			nextHyperlinkInstanceIndex,
+			nextPageBreakRunOwnerId,
 			textBoxAnchors
 		});
 		if (fieldNode) nodes.push(fieldNode);
 	} else if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
 		const nestedMarkType = item.type === "insertion" || item.type === "moveTo" ? "insertion" : "deletion";
 		const nestedMoveKind = item.type === "moveFrom" || item.type === "moveTo" ? item.type : null;
-		nodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, nestedMoveKind, textBoxAnchors));
+		nodes.push(...convertTrackedChange(item, nestedMarkType, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, nestedMoveKind, textBoxAnchors));
 	} else if (item.type === "bookmarkStart") nodes.push(schema.node("bookmarkBoundary", {
 		type: "start",
 		id: item.id,
@@ -411,22 +432,11 @@ function convertTrackedChange(change, markType, nextHyperlinkInstanceIndex, getI
 	});
 	return nodes.map((node) => {
 		if (node.marks.some(({ type }) => type.name === "insertion" || type.name === "deletion")) return node;
-		if (canCarryTrackedRunMark(node, mark.type)) return node.mark(mark.addToSet(node.marks));
+		if (trackedRunInlineAtomDisposition(node) === "outside-wrapper") panic(`Inline atom ${JSON.stringify(node.type.name)} cannot occur in a tracked-run wrapper`);
+		if (canCarryTrackedRunMark(node)) return node.mark(mark.addToSet(node.marks));
 		return node;
 	});
 }
-function canCarryTrackedRunMark(node, markType) {
-	if (node.isText) return true;
-	if (!node.isInline) return false;
-	if (node.type.name === "field" || node.type.name === "structuredField") return true;
-	return node.type.allowsMarkType(markType) && (node.type.name === "image" || node.type.name === "shape" || node.type.name === "hardBreak" || node.type.name === "tab" || node.type.name === "symbol" || node.type.name === "bookmarkBoundary" || node.type.name === "textBoxAnchor");
-}
-/**
-* 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, tableParagraphOverlay) {
 	const formatting = paragraph.formatting;
 	const styleId = formatting?.styleId;
@@ -446,6 +456,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 	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?.markerTemplate) attrs.listMarkerTemplate = paragraph.listRendering.markerTemplate;
 	if (paragraph.listRendering?.markerHidden) attrs.listMarkerHidden = paragraph.listRendering.markerHidden;
 	if (paragraph.listRendering?.markerFormatting) attrs.listMarkerFormatting = paragraph.listRendering.markerFormatting;
 	if (paragraph.listRendering?.markerAlignment) attrs.listMarkerAlignment = paragraph.listRendering.markerAlignment;
@@ -475,15 +486,15 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("spaceAfter", formatting?.spaceAfter ?? stylePpr?.spaceAfter);
 		set("lineSpacing", formatting?.lineSpacing ?? stylePpr?.lineSpacing);
 		set("lineSpacingRule", formatting?.lineSpacingRule ?? stylePpr?.lineSpacingRule);
-		set("lineSpacingExplicit", formatting?.lineSpacing !== void 0 || formatting?.lineSpacingRule !== void 0 ? true : void 0);
+		set("lineSpacingExplicit", lineSpacingProvenanceFromSpacing(formatting));
 		set("snapToGrid", formatting?.snapToGrid ?? stylePpr?.snapToGrid);
 		set("spacingExplicit", formatting?.spacingExplicit);
 		const paragraphStyle = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
 		const docDefaultSpacing = styleResolver.getDocDefaults()?.pPr;
-		const spacingFromImplicitDefaultStyle = {};
-		if (!styleId && formatting?.spaceBefore === void 0 && paragraphStyle?.pPr?.spaceBefore !== void 0) spacingFromImplicitDefaultStyle.before = true;
-		if (!styleId && formatting?.spaceAfter === void 0 && paragraphStyle?.pPr?.spaceAfter !== void 0) spacingFromImplicitDefaultStyle.after = true;
-		if (spacingFromImplicitDefaultStyle.before || spacingFromImplicitDefaultStyle.after) attrs.spacingFromImplicitDefaultStyle = spacingFromImplicitDefaultStyle;
+		const spacingFromStyle = {};
+		if (formatting?.spaceBefore === void 0 && stylePpr?.spaceBefore !== void 0) spacingFromStyle.before = true;
+		if (formatting?.spaceAfter === void 0 && stylePpr?.spaceAfter !== void 0) spacingFromStyle.after = true;
+		if (spacingFromStyle.before || spacingFromStyle.after) attrs.spacingFromImplicitDefaultStyle = spacingFromStyle;
 		const spacingFromDocDefaults = {};
 		if (formatting?.spaceBefore === void 0 && tableParagraphOverlay?.spaceBefore === void 0 && paragraphStyle?.pPr?.spaceBefore === void 0 && docDefaultSpacing?.spaceBefore !== void 0) spacingFromDocDefaults.before = true;
 		if (formatting?.spaceAfter === void 0 && tableParagraphOverlay?.spaceAfter === void 0 && paragraphStyle?.pPr?.spaceAfter === void 0 && docDefaultSpacing?.spaceAfter !== void 0) spacingFromDocDefaults.after = true;
@@ -507,9 +518,12 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		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, { includeParagraphMarkRunProperties: tableOfContentsLevel === void 0 }));
-		if (!formatting?.numPr && stylePpr?.numPr && stylePpr.numPr.numId !== 0) {
-			attrs.numPr = stylePpr.numPr;
+		set("defaultTextFormatting", resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, { includeParagraphMarkRunProperties: tableOfContentsLevel === void 0 && (styleId === void 0 || paragraph.content.length === 0) }));
+		if (stylePpr?.numPr && formatting?.numPr?.numId === void 0 && stylePpr.numPr.numId !== 0) {
+			attrs.numPr = {
+				...stylePpr.numPr,
+				...formatting?.numPr
+			};
 			attrs.numPrFromStyle = stylePpr.numPr;
 		}
 	} else {
@@ -518,6 +532,7 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		set("spaceAfter", formatting?.spaceAfter);
 		set("lineSpacing", formatting?.lineSpacing);
 		set("lineSpacingRule", formatting?.lineSpacingRule);
+		set("lineSpacingExplicit", lineSpacingProvenanceFromSpacing(formatting));
 		set("snapToGrid", formatting?.snapToGrid);
 		set("spacingExplicit", formatting?.spacingExplicit);
 		set("indentLeft", formatting?.indentLeft);
@@ -553,15 +568,19 @@ function paragraphFormattingToAttrs(paragraph, styleResolver, tableParagraphOver
 		if (afterAutospacing) setAutospacingBaseValue(base, "after", attrs.spaceAfter);
 		attrs._autospacingBase = base;
 	}
-	return attrs;
+	return {
+		attrs,
+		effectiveFrame: formatting?.frame === void 0 ? stylePpr?.frame : {
+			...stylePpr?.frame,
+			...formatting.frame
+		}
+	};
 }
 /**
-* Pick the paragraph-spacing fields out of a table style's (or conditional
-* region's) `w:pPr` for use as the cell-paragraph cascade overlay. Narrower
-* than the full `ParagraphFormatting` bag — see
-* {@link TableCellParagraphSpacingOverlay}.
+* Pick the modeled paragraph fields out of a table style's (or conditional
+* region's) `w:pPr` for use as the cell-paragraph cascade overlay.
 */
-function extractTableParagraphSpacingOverlay(pPr) {
+function extractTableParagraphOverlay(pPr) {
 	if (!pPr) return;
 	const overlay = {};
 	if (pPr.spaceBefore !== void 0) overlay.spaceBefore = pPr.spaceBefore;
@@ -569,6 +588,7 @@ function extractTableParagraphSpacingOverlay(pPr) {
 	if (pPr.lineSpacing !== void 0) overlay.lineSpacing = pPr.lineSpacing;
 	if (pPr.lineSpacingRule !== void 0) overlay.lineSpacingRule = pPr.lineSpacingRule;
 	if (pPr.contextualSpacing !== void 0) overlay.contextualSpacing = pPr.contextualSpacing;
+	if (pPr.frame !== void 0) overlay.frame = pPr.frame;
 	return Object.keys(overlay).length > 0 ? overlay : void 0;
 }
 /**
@@ -581,11 +601,11 @@ function resolveTableStyleConditional(styleResolver, tableStyleId, conditionType
 	const conditional = style.tblStylePr.find((p) => p.type === conditionType);
 	if (!conditional) return;
 	const mergedRunProps = mergeTextFormatting(conditional.pPr?.runProperties ? resolveRunFormattingWithoutDefaults(conditional.pPr.runProperties, styleResolver) : void 0, conditional.rPr ? resolveRunFormattingWithoutDefaults(conditional.rPr, styleResolver) : void 0);
-	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(conditional.pPr);
+	const paragraphOverlay = extractTableParagraphOverlay(conditional.pPr);
 	const result = {};
 	if (conditional.tcPr) result.tcPr = conditional.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
-	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
+	if (paragraphOverlay) result.pPr = paragraphOverlay;
 	return result;
 }
 function resolveTableBaseStyle(styleResolver, tableStyleId) {
@@ -593,11 +613,11 @@ function resolveTableBaseStyle(styleResolver, tableStyleId) {
 	const style = styleResolver.getStyle(tableStyleId);
 	if (!style) return;
 	const mergedRunProps = mergeTextFormatting(style.pPr?.runProperties ? resolveRunFormattingWithoutDefaults(style.pPr.runProperties, styleResolver) : void 0, style.rPr ? resolveRunFormattingWithoutDefaults(style.rPr, styleResolver) : void 0);
-	const paragraphSpacingOverlay = extractTableParagraphSpacingOverlay(style.pPr);
+	const paragraphOverlay = extractTableParagraphOverlay(style.pPr);
 	const result = {};
 	if (style.tcPr) result.tcPr = style.tcPr;
 	if (mergedRunProps) result.rPr = mergedRunProps;
-	if (paragraphSpacingOverlay) result.pPr = paragraphSpacingOverlay;
+	if (paragraphOverlay) result.pPr = paragraphOverlay;
 	return result.tcPr || result.rPr || result.pPr ? result : void 0;
 }
 function mergeConditionalStyles(base, override) {
@@ -632,70 +652,11 @@ function mergeConditionalStyles(base, override) {
 	if (mergedPPr) merged.pPr = mergedPPr;
 	return merged;
 }
-function hasDirectRunFormatting(formatting) {
-	if (!formatting) return false;
-	for (const key in formatting) {
-		if (!Object.hasOwn(formatting, key)) continue;
-		const value = Reflect.get(formatting, key);
-		if (key !== "styleId" && value !== void 0) return true;
-	}
-	return false;
-}
-function stripParagraphMarkOnlyFormatting(formatting) {
-	const { allCaps: _ac, highlight: _h, shading: _s, smallCaps: _sc, vertAlign: _va, ...rest } = formatting;
-	return Object.keys(rest).length > 0 ? rest : void 0;
-}
-function stripParagraphMarkFormattingForBodyRuns(formatting) {
-	const paragraphMarkFormatting = stripParagraphMarkOnlyFormatting(formatting);
-	if (!paragraphMarkFormatting) return;
-	const { fontFamily: _fontFamily, ...bodyRunFormatting } = paragraphMarkFormatting;
-	return Object.keys(bodyRunFormatting).length > 0 ? bodyRunFormatting : void 0;
-}
-const PARAGRAPH_MARK_BOOLEAN_KEYS = [
-	"bold",
-	"italic",
-	"strike",
-	"doubleStrike",
-	"allCaps",
-	"smallCaps",
-	"hidden",
-	"emboss",
-	"imprint",
-	"shadow",
-	"outline",
-	"rtl"
-];
-function suppressParagraphMarkFormatting(base, paragraphMark, direct, paragraphMarkPrecedesStyle = false) {
-	if (!paragraphMark) return base;
-	const result = (paragraphMarkPrecedesStyle ? mergeTextFormatting(paragraphMark, base) : mergeTextFormatting(base, paragraphMark)) ?? {};
-	for (const key of PARAGRAPH_MARK_BOOLEAN_KEYS) suppressBooleanParagraphMark(result, base, paragraphMark, direct, key);
-	if (paragraphMark.fontSize !== void 0 && direct?.fontSize === void 0 && base?.fontSize !== void 0) result.fontSize = base.fontSize;
-	if (paragraphMark.fontSizeCs !== void 0 && direct?.fontSizeCs === void 0 && base?.fontSizeCs !== void 0) result.fontSizeCs = base.fontSizeCs;
-	if (paragraphMark.underline !== void 0 && direct?.underline === void 0) result.underline = { style: "none" };
-	if (paragraphMark.spacing !== void 0 && direct?.spacing === void 0) result.spacing = 0;
-	return Object.keys(result).length > 0 ? result : void 0;
-}
-function getParagraphMarkSuppressionOverrides({ directFormatting, paragraphMarkFormatting, suppressedFormatting }) {
-	if (!paragraphMarkFormatting) return;
-	const overrides = {};
-	for (const key of PARAGRAPH_MARK_BOOLEAN_KEYS) if (paragraphMarkFormatting[key] !== void 0 && directFormatting?.[key] === void 0 && suppressedFormatting?.[key] === false) overrides[key] = false;
-	if (paragraphMarkFormatting.underline !== void 0 && directFormatting?.underline === void 0 && suppressedFormatting?.underline?.style === "none") overrides.underline = { style: "none" };
-	return Object.keys(overrides).length > 0 ? overrides : void 0;
-}
-function suppressBooleanParagraphMark(result, base, paragraphMark, direct, key) {
-	if (paragraphMark[key] === void 0 || direct?.[key] !== void 0) return;
-	result[key] = base?.[key] ?? false;
-}
 function resolveTextFormatting(formatting, styleResolver) {
 	if (!formatting) return styleResolver?.resolveRunStyle(null);
 	if (!styleResolver) return formatting;
 	return mergeTextFormatting(styleResolver.resolveRunStyle(formatting.styleId), formatting);
 }
-/**
-* Resolve an embedded character-style reference without importing
-* `docDefaults`. The caller already has the paragraph cascade, including
-* document defaults, and will layer these own properties over it.
-*/
 function resolveRunFormattingWithoutDefaults(formatting, styleResolver) {
 	if (!formatting || !styleResolver) return formatting;
 	return cascadeStyleTextFormatting([{
@@ -706,6 +667,7 @@ function resolveRunFormattingWithoutDefaults(formatting, styleResolver) {
 		type: "direct"
 	}]).formatting;
 }
+/** @internal Recompute a paragraph's inherited run defaults from authored package state. */
 function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolver, options = {}) {
 	const style = styleId ? styleResolver.getStyle(styleId) ?? styleResolver.getDefaultParagraphStyle() : styleResolver.getDefaultParagraphStyle();
 	const paragraphStyleRpr = style?.type === "paragraph" ? style.rPr : void 0;
@@ -726,10 +688,6 @@ function resolveParagraphDefaultTextFormatting(styleId, formatting, styleResolve
 		}
 	], { ordinaryFormatting: mergeTextFormatting(mergeTextFormatting(styleResolver.getDocDefaults()?.rPr, styleResolver.getDefaultCharacterStyle()?.rPr), paragraphStyleRpr) });
 	const bodyRunDefaults = orderedBodyToggleFormatting.formatting;
-	if (styleId !== void 0) return cascadeStyleTextFormatting([{
-		cascade: orderedBodyToggleFormatting,
-		type: "carried"
-	}], { ordinaryFormatting: mergeTextFormatting(paragraphRunProperties, bodyRunDefaults) }).formatting;
 	return cascadeStyleTextFormatting([{
 		cascade: orderedBodyToggleFormatting,
 		type: "carried"
@@ -831,6 +789,7 @@ function paragraphContentHasMeaningfulContent(content) {
 	return true;
 }
 function convertTable(table, styleResolver, context) {
+	for (const row of table.rows) for (const cell of row.cells) assertSourceContainerHasNoPageBreakRun(cell.content, "table-cell", context.pageBreakRunSourceDescendants);
 	const rowSpanMap = calculateRowSpans(table);
 	const columnWidths = table.columnWidths;
 	const totalWidth = columnWidths?.reduce((sum, w) => sum + w, 0) ?? 0;
@@ -967,10 +926,7 @@ function convertTableRow(row, styleResolver, context, isHeaderRow, columnWidths,
 	if (effectiveCells.length === 0) {
 		const fallback = {
 			type: "tableCell",
-			content: [{
-				type: "paragraph",
-				content: []
-			}]
+			content: []
 		};
 		if (totalCols > 1) fallback.formatting = { gridSpan: totalCols };
 		effectiveCells = [fallback];
@@ -1135,14 +1091,19 @@ function convertTableCell({ cell, styleResolver, context, isHeader, gridWidthPer
 	return schema.node(nodeType, attrs, contentNodes);
 }
 function standaloneTableCellToProseMirror(cell, nodeType) {
+	const nextTextBoxGroupId = createTextBoxGroupIdFactory();
+	const nextHyperlinkInstanceIndex = createHyperlinkInstanceIndexAllocator();
+	const pageBreakRunSourceDescendants = buildPageBreakRunSourceDescendantIndex(cell.content);
+	assertSourceContainerHasNoPageBreakRun(cell.content, "table-cell", pageBreakRunSourceDescendants);
 	return convertTableCell({
 		cell,
 		styleResolver: null,
 		context: {
 			theme: null,
-			nextTextBoxGroupId: createTextBoxGroupIdFactory(),
-			nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator(),
-			pairedBookmarkIds: collectPairedBookmarkIds(cell.content)
+			nextTextBoxGroupId,
+			nextHyperlinkInstanceIndex,
+			pairedBookmarkIds: collectPairedBookmarkIds(cell.content),
+			pageBreakRunSourceDescendants
 		},
 		isHeader: nodeType === "tableHeader",
 		gridWidthPercent: void 0,
@@ -1155,16 +1116,26 @@ function standaloneTableCellToProseMirror(cell, nodeType) {
 		defaultCellMargins: void 0
 	});
 }
-function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyperlinkInstanceIndex, textBoxAnchors }) {
+function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, textBoxAnchors }) {
 	let displayText = "";
 	let fieldFormatting;
+	let fieldPropertyChanges;
 	const inlineNodes = [];
-	const hasStructuredSourceContent = field.type === "simpleField" && field.content.some((content) => content.type === "hyperlink");
+	const runHasPageBreak = (run) => run.content.some((content) => content.type === "break" && content.breakType === "page");
+	if (field.type === "complexField" && field.fieldCode.some(runHasPageBreak)) throw new UnsupportedDocxToProseMirrorConversionError({
+		message: "A complex-field instruction containing an explicit page break cannot be represented in the editor model",
+		owner: "complex-field-instruction",
+		contentType: "break"
+	});
+	const hasPageBreakContent = field.type === "simpleField" ? field.content.some((content) => content.type === "run" ? runHasPageBreak(content) : content.children.some((child) => child.type === "run" && runHasPageBreak(child))) : field.fieldResult.some(runHasPageBreak);
+	if (hasPageBreakContent) assertPageBreakFieldResultIsRepresentable(field);
+	const hasStructuredSourceContent = hasPageBreakContent || field.type === "simpleField" && field.content.some((content) => content.type === "hyperlink");
 	const appendRun = (run) => {
 		for (const content of run.content) if (content.type === "text") displayText += content.text;
 		fieldFormatting ??= run.formatting;
+		fieldPropertyChanges ??= run.propertyChanges;
 		if (!hasStructuredSourceContent) return;
-		inlineNodes.push(...convertRun(run, getInheritedRunFormatting(run.formatting, field.fieldType), styleResolver, textBoxAnchors));
+		inlineNodes.push(...convertRun(run, getInheritedRunFormatting(run.formatting, field.fieldType), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors));
 	};
 	if (field.type === "simpleField") for (const content of field.content) {
 		if (content.type === "run") {
@@ -1174,12 +1145,14 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 		for (const child of content.children) if (child.type === "run") {
 			for (const runContent of child.content) if (runContent.type === "text") displayText += runContent.text;
 			fieldFormatting ??= child.formatting;
+			fieldPropertyChanges ??= child.propertyChanges;
 		}
 		inlineNodes.push(...convertHyperlink(content, {
 			getInheritedRunFormatting: (formatting) => getInheritedRunFormatting(formatting, field.fieldType),
 			styleResolver,
 			hyperlinkIndex: nextHyperlinkInstanceIndex(),
-			textBoxAnchors
+			textBoxAnchors,
+			nextPageBreakRunOwnerId
 		}));
 	}
 	else for (const run of field.fieldResult) appendRun(run);
@@ -1187,7 +1160,8 @@ function convertField(field, { getInheritedRunFormatting, styleResolver, nextHyp
 	const inheritedFormatting = getInheritedRunFormatting(fieldFormatting, field.fieldType);
 	const { marks } = buildRunMarks(fieldFormatting, inheritedFormatting, styleResolver);
 	const hasConvertedHyperlinkContent = inlineNodes.some((node) => node.marks.some((mark) => mark.type.name === "hyperlink"));
-	const createStructuredField = hasStructuredSourceContent && hasConvertedHyperlinkContent;
+	const createStructuredField = inlineNodes.some((node) => node.type.name === "pageBreakRun") || hasStructuredSourceContent && hasConvertedHyperlinkContent;
+	if (!createStructuredField && fieldPropertyChanges && fieldPropertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...fieldPropertyChanges] }));
 	return schema.node(createStructuredField ? "structuredField" : "field", {
 		fieldType: field.fieldType,
 		instruction: field.instruction,
@@ -1210,18 +1184,19 @@ function convertMathEquation(math) {
 /**
 * Convert an InlineSdt to a ProseMirror sdt node with inline content.
 */
-function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors) {
+function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors) {
 	const props = sdt.properties;
 	const inlineNodes = [];
 	for (const content of sdt.content) if (content.type === "run") {
-		const runNodes = convertRun(content, getInheritedRunFormatting(content.formatting), styleResolver, textBoxAnchors);
+		const runNodes = convertRun(content, getInheritedRunFormatting(content.formatting), nextPageBreakRunOwnerId, styleResolver, textBoxAnchors);
 		inlineNodes.push(...runNodes);
 	} else if (content.type === "hyperlink") {
 		const linkNodes = convertHyperlink(content, {
 			getInheritedRunFormatting,
 			styleResolver,
 			hyperlinkIndex: nextHyperlinkInstanceIndex(),
-			textBoxAnchors
+			textBoxAnchors,
+			nextPageBreakRunOwnerId
 		});
 		inlineNodes.push(...linkNodes);
 	} else if (content.type === "simpleField" || content.type === "complexField") {
@@ -1229,16 +1204,17 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, getInheritedRunFormat
 			getInheritedRunFormatting,
 			styleResolver,
 			nextHyperlinkInstanceIndex,
+			nextPageBreakRunOwnerId,
 			textBoxAnchors
 		});
 		if (fieldNode) inlineNodes.push(fieldNode);
 	} else if (content.type === "inlineSdt") {
-		const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, textBoxAnchors);
+		const nestedSdt = convertInlineSdt(content, nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, textBoxAnchors);
 		if (nestedSdt) inlineNodes.push(nestedSdt);
-	} else if (content.type === "insertion") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
-	else if (content.type === "deletion") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
-	else if (content.type === "moveTo") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, "moveTo", textBoxAnchors));
-	else if (content.type === "moveFrom") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, getInheritedRunFormatting, styleResolver, "moveFrom", textBoxAnchors));
+	} else if (content.type === "insertion") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
+	else if (content.type === "deletion") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, null, textBoxAnchors));
+	else if (content.type === "moveTo") inlineNodes.push(...convertTrackedChange(content, "insertion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, "moveTo", textBoxAnchors));
+	else if (content.type === "moveFrom") inlineNodes.push(...convertTrackedChange(content, "deletion", nextHyperlinkInstanceIndex, nextPageBreakRunOwnerId, getInheritedRunFormatting, styleResolver, "moveFrom", textBoxAnchors));
 	else {
 		const mathNode = convertMathEquation(content);
 		if (mathNode) inlineNodes.push(mathNode);
@@ -1251,19 +1227,208 @@ function convertInlineSdt(sdt, nextHyperlinkInstanceIndex, getInheritedRunFormat
 * @param run - The run to convert
 * @param resolvedStyleFormatting - Paragraph formatting and its explicit style-toggle state
 */
-function convertRun(run, resolvedStyleFormatting, styleResolver, textBoxAnchors) {
+function convertRun(run, resolvedStyleFormatting, nextPageBreakRunOwnerId, styleResolver, textBoxAnchors) {
+	assertPageBreakSourceRunIsRepresentable(run);
 	const nodes = [];
 	const { marks, mergedFormatting } = buildRunMarks(run.formatting, resolvedStyleFormatting, styleResolver);
 	if (run.propertyChanges && run.propertyChanges.length > 0) marks.push(schema.mark("runPropertyChange", { changes: [...run.propertyChanges] }));
+	if (run.content.some((content) => content.type === "break" && content.breakType === "page")) marks.push(schema.mark("pageBreakRunOwner", { id: nextPageBreakRunOwnerId() }));
 	for (const content of run.content) {
 		const contentNodes = convertRunContent(content, marks, mergedFormatting, textBoxAnchors);
 		nodes.push(...contentNodes);
 	}
 	return nodes;
 }
+function assertPageBreakSourceRunIsRepresentable(run) {
+	if (!run.content.some((content) => content.type === "break" && content.breakType === "page")) return;
+	assertRunContentIsRepresentableBesidePageBreak(run, "page-break-bearing-run");
+}
+const PAGE_BREAK_CONTAINER_DESCRIPTIONS = {
+	"table-cell": "A table cell containing an explicit page break",
+	"text-box": "A text box containing an explicit page break"
+};
+const PAGE_BREAK_PARAGRAPH_OWNERS = {
+	borders: "paragraph-borders",
+	frame: "paragraph-frame",
+	outline: "paragraph-outline",
+	textBoxAnchor: "paragraph-text-box-anchor"
+};
+function assertSourceContainerHasNoPageBreakRun(content, owner, sourceDescendants) {
+	if (!sourceDescendants.containsPageBreakRun(content)) return;
+	throw new UnsupportedDocxToProseMirrorConversionError({
+		message: `${PAGE_BREAK_CONTAINER_DESCRIPTIONS[owner]} cannot be represented in the editor model`,
+		owner,
+		contentType: "break"
+	});
+}
+function assertParagraphPageBreakCanBeProjected({ paragraph, attrs, effectiveFrame, sourceDescendants }) {
+	const sourceFeatures = sourceDescendants.paragraphFeatures(paragraph);
+	if (!sourceFeatures.hasPageBreakRun) return;
+	const disposition = pageBreakRunParagraphProjectionDispositionForFeatures({
+		attrs,
+		effectiveFrame,
+		hasTextBoxAnchor: sourceFeatures.hasTextBoxShape && !sourceFeatures.pageBreakSharesTextBoxShape
+	});
+	if (disposition.status === "supported") return;
+	throw new UnsupportedDocxToProseMirrorConversionError({
+		message: disposition.message,
+		owner: PAGE_BREAK_PARAGRAPH_OWNERS[disposition.reason],
+		contentType: "break"
+	});
+}
+function assertPageBreakFieldResultIsRepresentable(field) {
+	if (field.type === "complexField") {
+		for (const run of field.fieldResult) assertRunContentIsRepresentableBesidePageBreak(run, "field-result");
+		return;
+	}
+	for (const content of field.content) {
+		if (content.type === "run") {
+			assertRunContentIsRepresentableBesidePageBreak(content, "field-result");
+			continue;
+		}
+		for (const child of content.children) if (child.type === "run") assertRunContentIsRepresentableBesidePageBreak(child, "field-result");
+	}
+}
+const PAGE_BREAK_OWNER_DESCRIPTIONS = {
+	"field-result": "A field result with an explicit page break",
+	"page-break-bearing-run": "A page-break-bearing run"
+};
+const unsupportedPageBreakContent = (owner, contentType) => {
+	const description = contentType === "shape" ? "a text-box shape" : contentType;
+	throw new UnsupportedDocxToProseMirrorConversionError({
+		message: `${PAGE_BREAK_OWNER_DESCRIPTIONS[owner]} containing ${description} cannot be represented in the editor model`,
+		owner,
+		contentType
+	});
+};
+function assertRunContentIsRepresentableBesidePageBreak(run, owner) {
+	for (const content of run.content) switch (content.type) {
+		case "break":
+		case "drawing":
+		case "endnoteRef":
+		case "footnoteRef":
+		case "renderedPageBreak":
+		case "symbol":
+		case "tab":
+		case "text": continue;
+		case "shape":
+			if (content.shape.textBody) unsupportedPageBreakContent(owner, content.type);
+			continue;
+		case "fieldChar":
+		case "instrText":
+		case "noBreakHyphen":
+		case "softHyphen": return unsupportedPageBreakContent(owner, content.type);
+		default: panic(`Unsupported page-break-bearing run content: ${JSON.stringify(content)}`);
+	}
+}
+const RUN_FORMATTING_INFERENCE = {
+	bold: "ordinary-toggle",
+	boldCs: "structural",
+	italic: "ordinary-toggle",
+	italicCs: "structural",
+	underline: "underline",
+	strike: "visible-boolean",
+	doubleStrike: "double-strike",
+	vertAlign: "visible-value",
+	smallCaps: "visible-boolean",
+	allCaps: "visible-boolean",
+	hidden: "visible-boolean",
+	color: "color",
+	highlight: "visible-value",
+	shading: "preserve",
+	fontSize: "font-size",
+	fontSizeCs: "structural",
+	fontFamily: "font-family",
+	language: "nested-visible-value",
+	spacing: "visible-value",
+	position: "visible-value",
+	scale: "scale",
+	kerning: "visible-value",
+	effect: "visible-value",
+	emphasisMark: "visible-value",
+	emboss: "visible-boolean",
+	imprint: "visible-boolean",
+	outline: "visible-boolean",
+	shadow: "visible-boolean",
+	rtl: "visible-boolean",
+	cs: "structural",
+	styleId: "structural"
+};
+const sameFormattingValue = (left, right) => {
+	if (left === right) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	if (Array.isArray(left) || Array.isArray(right)) {
+		if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+		return left.every((value, index) => sameFormattingValue(value, right.at(index)));
+	}
+	const leftEntries = Object.entries(left).filter(([, value]) => value !== void 0);
+	const rightEntries = Object.entries(right).filter(([, value]) => value !== void 0);
+	if (leftEntries.length !== rightEntries.length) return false;
+	return leftEntries.every(([property, value]) => Object.hasOwn(right, property) && sameFormattingValue(value, Reflect.get(right, property)));
+};
+const isReconstructibleFontFamily = (directValue, effectiveValue) => {
+	if (typeof directValue !== "object" || directValue === null || !sameFormattingValue(directValue, effectiveValue)) return false;
+	const properties = Object.keys(directValue).filter((property) => Reflect.get(directValue, property) !== void 0);
+	return properties.length === 2 && properties.includes("ascii") && properties.includes("hAnsi") && typeof Reflect.get(directValue, "ascii") === "string" && typeof Reflect.get(directValue, "hAnsi") === "string";
+};
+const canReconstructAuthoredRunFormatting = ({ directFormatting, effectiveFormatting, inheritedFormatting, paragraphMarkOverrides }) => {
+	if (paragraphMarkOverrides !== void 0) return false;
+	for (const property of Object.keys(directFormatting ?? {})) {
+		const directValue = directFormatting?.[property];
+		if (directValue === void 0 || property === "styleId") continue;
+		const inheritedValue = inheritedFormatting?.[property];
+		const effectiveValue = effectiveFormatting?.[property];
+		switch (RUN_FORMATTING_INFERENCE[property]) {
+			case "structural": continue;
+			case "ordinary-toggle":
+				if (directValue !== true || inheritedValue !== true) continue;
+				return false;
+			case "visible-boolean":
+				if (directValue === false || directValue === true && inheritedValue !== true) continue;
+				return false;
+			case "font-size":
+				if (typeof directValue === "number" && Number.isFinite(directValue) && directValue > 0) continue;
+				return false;
+			case "font-family":
+				if (isReconstructibleFontFamily(directValue, effectiveValue)) continue;
+				return false;
+			case "color":
+				if (typeof directValue === "object" && directValue !== null && Reflect.get(directValue, "auto") !== true && Reflect.get(directValue, "themeColor") === void 0 && sameFormattingValue(directValue, effectiveValue)) continue;
+				return false;
+			case "underline":
+				if (typeof directValue === "object" && directValue !== null && Reflect.get(directValue, "style") !== "none" && Reflect.get(directValue, "color") === void 0 && sameFormattingValue(directValue, effectiveValue) && !sameFormattingValue(directValue, inheritedValue)) continue;
+				return false;
+			case "double-strike":
+				if (directValue === false) continue;
+				if (directValue === true && inheritedFormatting?.strike !== true && inheritedFormatting?.doubleStrike !== true) continue;
+				return false;
+			case "scale":
+				if (normalizeHorizontalScalePercent(typeof directValue === "number" ? directValue : void 0) === directValue && directValue !== inheritedValue) continue;
+				return false;
+			case "nested-visible-value":
+				if (sameFormattingValue(directValue, effectiveValue) && !sameFormattingValue(directValue, inheritedValue)) continue;
+				return false;
+			case "visible-value":
+				if (directValue !== "none" && directValue !== "baseline" && sameFormattingValue(directValue, effectiveValue) && !sameFormattingValue(directValue, inheritedValue)) continue;
+				return false;
+			case "preserve": return false;
+		}
+	}
+	return true;
+};
 function buildRunMarks(runFormatting, inherited, styleResolver) {
+	if (runFormatting === void 0 && inherited.implicitCharacterStyleApplied === true && inherited.paragraphMarkOverrides === void 0) return {
+		marks: textFormattingToMarks(inherited.formatting, {
+			overrideFormatting: void 0,
+			directFormatting: void 0,
+			authoredCarrier: "reconstruct"
+		}),
+		mergedFormatting: inherited.formatting
+	};
 	const styleId = runFormatting?.styleId;
-	const characterStyleFormatting = styleId ? styleResolver?.getRunStyleOwnProperties(styleId) : styleResolver?.getDefaultCharacterStyle()?.rPr;
+	let characterStyleFormatting;
+	if (styleId) characterStyleFormatting = styleResolver?.getRunStyleOwnProperties(styleId);
+	else if (!inherited.implicitCharacterStyleApplied) characterStyleFormatting = styleResolver?.getDefaultCharacterStyle()?.rPr;
 	let ordinaryRunStyleFormatting = inherited.formatting ? { ...inherited.formatting } : {};
 	if (styleId) ordinaryRunStyleFormatting = mergeTextFormatting(inherited.formatting, characterStyleFormatting) ?? {};
 	const cascadedStyleFormatting = cascadeStyleTextFormatting([{
@@ -1281,20 +1446,28 @@ function buildRunMarks(runFormatting, inherited, styleResolver) {
 		formatting: runFormatting,
 		type: "direct"
 	}], { ordinaryFormatting: mergeTextFormatting(runStyleFormatting, runFormatting) }).formatting;
-	const marks = textFormattingToMarks(mergedFormatting, { overrideFormatting: getRunFormattingOverrides({
+	const authoredCarrier = canReconstructAuthoredRunFormatting({
+		directFormatting: runFormatting,
+		effectiveFormatting: mergedFormatting,
+		inheritedFormatting: runStyleFormatting,
+		paragraphMarkOverrides: inherited.paragraphMarkOverrides
+	}) ? "reconstruct" : "preserve";
+	const overrideFormatting = getRunFormattingOverrides({
 		directFormatting: runFormatting,
 		effectiveStyleFormatting: runStyleFormatting,
 		hasCharacterStyle: styleId !== void 0,
 		paragraphMarkOverrides: inherited.paragraphMarkOverrides
-	}) });
-	addDirectFontProvenance(marks, runFormatting);
-	if (styleId) {
-		const styleRPr = characterStyleFormatting ? marksToTextFormatting(textFormattingToMarks(characterStyleFormatting)) : void 0;
-		marks.push(schema.mark("characterStyle", {
-			styleId,
-			_styleRPr: styleRPr && Object.keys(styleRPr).length > 0 ? styleRPr : null
-		}));
+	});
+	if (authoredCarrier === "reconstruct") {
+		if (overrideFormatting?.bold === true) delete overrideFormatting.bold;
+		if (overrideFormatting?.italic === true) delete overrideFormatting.italic;
 	}
+	const marks = textFormattingToMarks(mergedFormatting, {
+		overrideFormatting,
+		directFormatting: runFormatting,
+		authoredCarrier
+	});
+	if (styleId) marks.push(schema.mark("characterStyle", { styleId }));
 	return {
 		marks,
 		mergedFormatting
@@ -1305,12 +1478,43 @@ const addDirectFontProvenance = (marks, directFormatting) => {
 	if (directFormatting?.fontFamily !== void 0) directFontProperties.push("fontFamily");
 	if (directFormatting?.fontSize !== void 0) directFontProperties.push("fontSize");
 	if (directFormatting?.color !== void 0) directFontProperties.push("color");
-	if (!directFormatting || !Object.keys(directFormatting).some((property) => property !== "styleId")) return;
+	if (directFontProperties.length === 0) return;
+	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
+	const existing = index >= 0 ? marks.at(index) : void 0;
+	const override = schema.mark("runFormattingOverride", {
+		...existing?.attrs,
+		directFontProperties
+	});
+	if (index >= 0) {
+		marks[index] = override;
+		return;
+	}
+	marks.push(override);
+};
+const COMPLEX_SCRIPT_MIRRORS = [
+	{
+		ordinary: "bold",
+		complex: "boldCs"
+	},
+	{
+		ordinary: "italic",
+		complex: "italicCs"
+	},
+	{
+		ordinary: "fontSize",
+		complex: "fontSizeCs"
+	}
+];
+const addComplexScriptAbsenceProvenance = (marks, directFormatting) => {
+	const absent = COMPLEX_SCRIPT_MIRRORS.filter(({ ordinary, complex }) => directFormatting?.[ordinary] !== void 0 && directFormatting[complex] === void 0).map(({ complex }) => complex);
+	if (absent.length === 0) return;
 	const index = marks.findIndex(({ type }) => type.name === "runFormattingOverride");
 	const existing = index >= 0 ? marks.at(index) : void 0;
+	const existingAbsences = new Set(existing?.attrs["complexScriptPropertyAbsences"] ?? []);
+	for (const property of absent) existingAbsences.add(property);
 	const override = schema.mark("runFormattingOverride", {
 		...existing?.attrs,
-		...directFontProperties.length > 0 && { directFontProperties }
+		complexScriptPropertyAbsences: COMPLEX_SCRIPT_RUN_PROPERTY_KEYS.filter((property) => existingAbsences.has(property))
 	});
 	if (index >= 0) {
 		marks[index] = override;
@@ -1319,8 +1523,6 @@ const addDirectFontProvenance = (marks, directFormatting) => {
 	marks.push(override);
 };
 const ORDINARY_STYLE_TOGGLE_KEYS = [
-	"bold",
-	"italic",
 	"strike",
 	"allCaps",
 	"smallCaps",
@@ -1334,8 +1536,6 @@ function getRunFormattingOverrides({ directFormatting, effectiveStyleFormatting,
 	const overrides = mergeTextFormatting(paragraphMarkOverrides, directFormatting);
 	if (!overrides || !directFormatting) return overrides;
 	for (const key of ORDINARY_STYLE_TOGGLE_KEYS) if (directFormatting[key] === true && (!hasCharacterStyle || effectiveStyleFormatting?.[key] !== true)) Reflect.deleteProperty(overrides, key);
-	if (directFormatting.boldCs === true && directFormatting.boldCs === directFormatting.bold && (!hasCharacterStyle || effectiveStyleFormatting?.boldCs === void 0)) Reflect.deleteProperty(overrides, "boldCs");
-	if (directFormatting.italicCs === true && directFormatting.italicCs === directFormatting.italic && (!hasCharacterStyle || effectiveStyleFormatting?.italicCs === void 0)) Reflect.deleteProperty(overrides, "italicCs");
 	return overrides;
 }
 /**
@@ -1347,12 +1547,21 @@ function convertRunContent(content, marks, formatting, textBoxAnchors) {
 			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 [];
+			if (content.breakType === "textWrapping" || !content.breakType) {
+				const attrs = {
+					...content.breakType !== void 0 ? { breakType: content.breakType } : {},
+					...content.clear !== void 0 ? { clear: content.clear } : {}
+				};
+				return [schema.node("hardBreak", attrs).mark(marks)];
+			}
+			if (content.breakType === "column") return [schema.node("hardBreak", {
+				breakType: "column",
+				...content.clear !== void 0 ? { clear: content.clear } : {}
+			}).mark(marks)];
+			return [schema.node("pageBreakRun", content.clear === void 0 ? void 0 : { clear: content.clear }).mark(marks)];
 		case "renderedPageBreak": return [schema.node("renderedPageBreak").mark(marks)];
 		case "tab": return [schema.node("tab", content.positional ? { positional: content.positional } : void 0).mark(marks)];
-		case "drawing": return [withHyperlinkBoundaryMarks(convertImage({
+		case "drawing": return [withRunBoundaryMarks(convertImage({
 			image: content.image,
 			rawXml: content.rawXml,
 			rawXmlMode: content.rawXmlMode
@@ -1363,7 +1572,7 @@ function convertRunContent(content, marks, formatting, textBoxAnchors) {
 				const anchorId = textBoxAnchors?.get(shp);
 				return anchorId ? [schema.node("textBoxAnchor", { anchorId }).mark(marks)] : [];
 			}
-			return [withHyperlinkBoundaryMarks(convertShape(shp), marks)];
+			return [withRunBoundaryMarks(convertShape(shp), marks)];
 		}
 		case "footnoteRef": {
 			const footnoteMark = schema.mark("footnoteRef", {
@@ -1391,8 +1600,8 @@ function convertRunContent(content, marks, formatting, textBoxAnchors) {
 		}).mark(marks)];
 	}
 }
-function withHyperlinkBoundaryMarks(node, marks) {
-	if (!marks.some((mark) => mark.type.name === "hyperlink")) return node;
+function withRunBoundaryMarks(node, marks) {
+	if (!marks.some(({ type }) => type.name === "hyperlink" || type.name === "pageBreakRunOwner")) return node;
 	return node.mark(marks);
 }
 function convertImage({ image, rawXml, rawXmlMode }) {
@@ -1500,7 +1709,7 @@ function convertImage({ image, rawXml, rawXmlMode }) {
 		_docxObjectPreview: rawXml !== void 0 && /<(?:[A-Za-z_][\w.-]*:)?object(?:\s|>)/u.test(rawXml)
 	});
 }
-function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver, hyperlinkIndex, textBoxAnchors }) {
+function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver, hyperlinkIndex, textBoxAnchors, nextPageBreakRunOwnerId }) {
 	const nodes = [];
 	const href = hyperlink.href || (hyperlink.anchor ? `#${hyperlink.anchor}` : "");
 	const linkMark = schema.mark("hyperlink", {
@@ -1528,8 +1737,11 @@ function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver,
 			continue;
 		}
 		if (child.type === "run") {
+			assertPageBreakSourceRunIsRepresentable(child);
 			const inheritedFormatting = getInheritedRunFormatting(child.formatting);
 			const { marks: runMarks, mergedFormatting } = buildRunMarks(child.formatting, inheritedFormatting, styleResolver);
+			if (child.propertyChanges && child.propertyChanges.length > 0) runMarks.push(schema.mark("runPropertyChange", { changes: [...child.propertyChanges] }));
+			if (child.content.some((content) => content.type === "break" && content.breakType === "page")) runMarks.push(schema.mark("pageBreakRunOwner", { id: nextPageBreakRunOwnerId() }));
 			const allMarks = [...runMarks, linkMark];
 			for (const content of child.content) nodes.push(...convertRunContent(content, allMarks, mergedFormatting, textBoxAnchors));
 		}
@@ -1539,7 +1751,14 @@ function convertHyperlink(hyperlink, { getInheritedRunFormatting, styleResolver,
 function textFormattingToMarks(formatting, options) {
 	if (!formatting) return [];
 	const marks = [];
-	const overrideAttrs = buildRunFormattingOverrideAttrs(options ? options.overrideFormatting : formatting);
+	const overrideFormatting = options ? options.overrideFormatting : formatting;
+	let overrideAttrs;
+	if (options?.authoredCarrier === "reconstruct") overrideAttrs = buildRunFormattingOverrideAttrs(overrideFormatting, { type: "structural-only" });
+	else if (options) overrideAttrs = buildRunFormattingOverrideAttrs(overrideFormatting, {
+		type: "authored-baseline",
+		formatting: options.directFormatting
+	});
+	else overrideAttrs = buildRunFormattingOverrideAttrs(overrideFormatting);
 	if (overrideAttrs) marks.push(schema.mark("runFormattingOverride", overrideAttrs));
 	if (formatting.bold) marks.push(schema.mark("bold"));
 	if (formatting.italic) marks.push(schema.mark("italic"));
@@ -1592,6 +1811,8 @@ function textFormattingToMarks(formatting, options) {
 	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 }));
+	addDirectFontProvenance(marks, options?.directFormatting);
+	if (options?.authoredCarrier === "preserve") addComplexScriptAbsenceProvenance(marks, options.directFormatting);
 	return marks;
 }
 /**
@@ -1701,7 +1922,7 @@ function convertShape(shape) {
 }
 function convertParagraphWithTextBoxes(block, styleResolver, { textBoxGroupId, context, extraRunFormatting, preserveEmptyWrapper, tableParagraphOverlay }) {
 	const { textBoxes, textBoxAnchors } = extractTextBoxesFromParagraph(block, textBoxGroupId);
-	const pmParagraph = convertParagraph(block, styleResolver, context.nextHyperlinkInstanceIndex, context.pairedBookmarkIds, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
+	const pmParagraph = convertParagraph(block, styleResolver, context, void 0, extraRunFormatting, tableParagraphOverlay, textBoxAnchors);
 	const nodes = [];
 	const isEmptyAfterExtraction = textBoxes.length > 0 && !hasContentBesidesTextBoxAnchors(pmParagraph);
 	const keepWrapperParagraph = isEmptyAfterExtraction && (preserveEmptyWrapper === true || hasParagraphBoundaryPayload(block, pmParagraph));
@@ -1854,6 +2075,7 @@ function textBoxFromShape(shape, textBody) {
 * Convert a TextBox to a ProseMirror textBox node
 */
 function convertTextBox(textBox, styleResolver, options) {
+	assertSourceContainerHasNoPageBreakRun(textBox.content, "text-box", options.context.pageBreakRunSourceDescendants);
 	const textBoxSize = textBox.size;
 	const widthPx = textBoxSize?.width ? emuToPixels(textBoxSize.width) : 200;
 	const heightPx = textBoxSize?.height ? emuToPixels(textBoxSize.height) : void 0;
@@ -1966,7 +2188,8 @@ function headerFooterToProseDoc(content, options) {
 		theme,
 		nextTextBoxGroupId,
 		nextHyperlinkInstanceIndex: createHyperlinkInstanceIndexAllocator(),
-		pairedBookmarkIds: collectPairedBookmarkIds(content)
+		pairedBookmarkIds: collectPairedBookmarkIds(content),
+		pageBreakRunSourceDescendants: buildPageBreakRunSourceDescendantIndex(content)
 	};
 	const convertBlocks = (blocks) => {
 		const out = [];
@@ -2000,100 +2223,10 @@ 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) {
-	if (!mayContainPageBreak(paragraph)) return null;
-	return findParagraphPageBreakPosition(paragraph);
-}
-function mayContainPageBreak(paragraph) {
-	for (const item of paragraph.content) {
-		if (item.type === "run") {
-			for (const content of item.content) if (content.type === "break" && content.breakType === "page") return true;
-			continue;
-		}
-		if (item.type === "hyperlink" || item.type === "simpleField" || item.type === "complexField" || item.type === "inlineSdt" || item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") return true;
-		if (item.type === "bookmarkStart" || item.type === "bookmarkEnd" || item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference" || item.type === "moveFromRangeStart" || item.type === "moveFromRangeEnd" || item.type === "moveToRangeStart" || item.type === "moveToRangeEnd" || item.type === "mathEquation") continue;
-	}
-	return false;
-}
-function findParagraphPageBreakPosition(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;
-			if (child.type === "simpleField") for (const fieldChild of child.content) {
-				if (fieldChild.type === "run" && visitRun(fieldChild)) return true;
-				if (fieldChild.type === "hyperlink" && visitHyperlinkChildren(fieldChild)) return true;
-			}
-			if (child.type === "complexField") {
-				for (const run of child.fieldCode) if (visitRun(run)) return true;
-				for (const run of child.fieldResult) if (visitRun(run)) return true;
-			}
-			if ((child.type === "insertion" || child.type === "deletion" || child.type === "moveFrom" || child.type === "moveTo") && visitRunOrHyperlinkList(child.content)) 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, standaloneTableCellToProseMirror, textFormattingToMarks, toProseDoc };
+export { UnsupportedDocxToProseMirrorConversionError, createEmptyDoc, footnoteToProseDoc, headerFooterToProseDoc, resolveParagraphDefaultTextFormatting, standaloneTableCellToProseMirror, textFormattingToMarks, toProseDoc };