@stll/folio-core 0.45.0 → 0.47.0

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

@@ -6,20 +6,21 @@ import { partitionRunsAtPageBreaks } from "../../internal/pageBreakRunPartition.
 import { setHyperlinkInstanceIndex } from "../../layout-engine/measure/hyperlinkInstance.js";
 import { setParagraphFrame } from "../../layout-engine/paragraphFrame.js";
 import { setTextBoxGroupId } from "../../layout-engine/textBoxGroup.js";
-import { DEFAULT_TEXTBOX_MARGINS } from "../../layout-engine/types.js";
+import { DEFAULT_TEXTBOX_MARGINS, isListNumPr } from "../../layout-engine/types.js";
 import { getPageNumbering } from "../../paged-layout/sectionGeometry.js";
-import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectSymbolAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectParagraphAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectSymbolAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
 import { autospacingMatchesBase } from "../../prosemirror/autospacingBase.js";
 import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
 import { advanceListMarker, advanceVisibleListMarker, cloneListCounterState, formatCounter, resolveListTemplate } from "../../prosemirror/listMarker.js";
 import { resolveNumberedRefFields } from "../../prosemirror/numberedRefFields.js";
-import { pageBreakRunParagraphProjectionDisposition } from "../../prosemirror/pageBreakRunProjection.js";
-import { directionToBidi } from "../../prosemirror/paragraphDirection.js";
+import { directionIsRtl, directionToBidi } from "../../prosemirror/paragraphDirection.js";
 import { resolveEffectiveRunStyleFormatting } from "../../prosemirror/runStyleFormatting.js";
+import { parseSectionBreakType } from "../../prosemirror/sectionCarrier.js";
 import { expectTextBoxAnchorAttrs } from "../../prosemirror/textBoxAnchorAttrs.js";
 import { assertValidProseMirrorDocument } from "../../prosemirror/validation.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
+import { cssBorderStyle, cssBorderStyleOf } from "../../utils/borderCss.js";
 import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
 import { resolveThemeFont } from "../../utils/fontResolver.js";
 import { resolveShadingFill } from "../../utils/formatToStyle.js";
@@ -32,6 +33,7 @@ import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, poin
 import { getColumns } from "../sectionColumns.js";
 import { groupParagraphFrames } from "./paragraphFrames.js";
 import { panic } from "better-result";
+import { headingLevelOf, paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering, statesNoBorder } from "@stll/docx-core/model";
 //#region src/layout-bridge/convert/toFlowBlocks.ts
 const DETACHED_WATERMARK_HOST_ATTR = "_detachedWatermarkHost";
 const expectDetachedWatermarkHostAttr = (attrs) => {
@@ -40,7 +42,14 @@ const expectDetachedWatermarkHostAttr = (attrs) => {
 	if (typeof value !== "boolean") panic("Invalid ProseMirror detached watermark host attrs:\nparagraph.attrs._detachedWatermarkHost: Expected a boolean.");
 	return value;
 };
-const DEFAULT_FONT = "Calibri";
+/**
+* Word's layout fallback when an imported OOXML style hierarchy never supplies
+* `w:sz`. ECMA-376 deliberately leaves that terminal fallback to the consumer;
+* this value matches Word and is therefore applied by the DOCX composition
+* roots, while standalone ProseMirror documents keep the layout engine's 11pt
+* default.
+*/
+const WORD_UNSPECIFIED_FONT_SIZE = 10;
 const TEXT_BOX_ANCHOR_BLOCK_ID = Symbol.for("stll.textBoxAnchorBlockId");
 const DEFAULT_TABLE_CELL_MARGIN_TWIPS = {
 	top: 0,
@@ -73,7 +82,6 @@ function constrainImageToPage(width, height, pageContentHeight) {
 		height: pageContentHeight
 	};
 }
-const DEFAULT_SIZE = 11;
 /**
 * Convert twips to pixels (1 twip = 1/1440 inch, 1 inch = 96 CSS px).
 * No rounding — precision prevents cumulative layout drift across paragraphs.
@@ -102,6 +110,86 @@ function resetBlockIdCounter() {
 	blockIdCounter = 0;
 }
 /**
+* What the painter does with each mark the schema declares.
+*
+* The switch below used to end in `default: break`, so a mark that reached it
+* was silently not painted whether that was the decision or an omission. The
+* table is total over {@link SchemaMarkName}: a mark added to the schema
+* without a paint decision does not compile, and a mark this table says is
+* painted but the switch does not handle panics rather than disappearing.
+*/
+const MARK_PAINT_DISPOSITIONS = {
+	bold: "runFormatting",
+	italic: "runFormatting",
+	underline: "runFormatting",
+	strike: "runFormatting",
+	textColor: "runFormatting",
+	runShading: "runFormatting",
+	highlight: "runFormatting",
+	fontSize: "runFormatting",
+	fontFamily: "runFormatting",
+	language: "runFormatting",
+	superscript: "runFormatting",
+	subscript: "runFormatting",
+	hyperlink: "runFormatting",
+	allCaps: "runFormatting",
+	smallCaps: "runFormatting",
+	footnoteRef: "runFormatting",
+	characterSpacing: "runFormatting",
+	emboss: "runFormatting",
+	imprint: "runFormatting",
+	hidden: "runFormatting",
+	textShadow: "runFormatting",
+	emphasisMark: "runFormatting",
+	textOutline: "runFormatting",
+	rtl: "runFormatting",
+	textEffect: "runFormatting",
+	runFormattingOverride: "runFormatting",
+	comment: "runFormatting",
+	insertion: "runFormatting",
+	deletion: "runFormatting",
+	inlineWrapper: "runFormatting",
+	characterStyle: "resolvedElsewhere",
+	runIdentity: "notPainted",
+	runPropertyChange: "notPainted"
+};
+const markPaintDisposition = (name) => {
+	return MARK_PAINT_DISPOSITIONS[name];
+};
+/**
+* Whether a layer states how its content is laid out.
+*
+* A smart tag and a custom-XML wrapper name an element in another vocabulary
+* and say nothing about layout, so the painter draws the text exactly as it
+* would without them. The `switch` is here rather than inline so a kind added
+* to the model has to answer the question.
+*/
+const paintedDirection = (layer) => {
+	switch (layer.kind) {
+		case "bidi": return layer.direction === void 0 ? { control: layer.control } : {
+			control: layer.control,
+			direction: layer.direction
+		};
+		case "smartTag":
+		case "customXml": return;
+		default: return;
+	}
+};
+/**
+* The direction the innermost bidirectional layer of a stack lays its content out in.
+*
+* Innermost wins: a bidirectional wrapper inside another is the one the text is
+* laid out in, and the outer layers are what the save leg rebuilds the nesting
+* from. The layers that state no direction are skipped rather than ending the
+* search, so a smart tag inside a `w:dir` still reads right to left.
+*/
+const innermostBidiWrapper = (stack) => {
+	for (const layer of stack.toReversed()) {
+		const direction = paintedDirection(layer);
+		if (direction !== void 0) return direction;
+	}
+};
+/**
 * Extract run formatting from ProseMirror marks.
 */
 function extractRunFormatting(marks, theme, fontAlternates) {
@@ -273,6 +361,7 @@ function extractRunFormatting(marks, theme, fontAlternates) {
 		case "deletion": {
 			const attrs = expectTrackedChangeMarkAttrs(mark);
 			formatting.isDeletion = true;
+			if (attrs._historicalFormatting) formatting.usesHistoricalFormatting = true;
 			formatting.changeAuthor = attrs.author;
 			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
 			formatting.changeRevisionId = attrs.revisionId;
@@ -282,7 +371,14 @@ function extractRunFormatting(marks, theme, fontAlternates) {
 			}
 			break;
 		}
-		default: break;
+		case "inlineWrapper": {
+			const bidiWrapper = innermostBidiWrapper(expectInlineWrapperMarkAttrs(mark).stack);
+			if (bidiWrapper) formatting.bidiWrapper = bidiWrapper;
+			break;
+		}
+		default:
+			if (markPaintDisposition(mark.type.name) === "runFormatting") panic(`Mark ${mark.type.name} is painted as run formatting but has no branch here`);
+			break;
 	}
 	if (runFormattingOverride) applyRunFormattingOverrides(formatting, runFormattingOverride);
 	if (hasNoteRef && formatting.subscript) delete formatting.superscript;
@@ -310,6 +406,7 @@ function markDefaultBlackTextColorSource(formatting, paraDefaults) {
 	};
 }
 function mergeRunFormatting(paraDefaults, formatting) {
+	if (formatting.isDeletion && formatting.usesHistoricalFormatting) return formatting;
 	const merged = {
 		...paraDefaults,
 		...markDefaultBlackTextColorSource(formatting, paraDefaults)
@@ -522,6 +619,7 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 	const run = {
 		kind: "image",
 		src: attrs.src,
+		...attrs.preview ? { preview: attrs.preview } : {},
 		width: constrained.width,
 		height: constrained.height,
 		pmStart,
@@ -530,6 +628,8 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 	if (attrs.alt !== void 0) run.alt = attrs.alt;
 	if (attrs.transform !== void 0) run.transform = attrs.transform;
 	if (attrs.opacity != null) run.opacity = attrs.opacity;
+	if (attrs.brightness != null) run.brightness = attrs.brightness;
+	if (attrs.contrast != null) run.contrast = attrs.contrast;
 	if (attrs.wrapType !== void 0) run.wrapType = attrs.wrapType;
 	if (attrs.displayMode !== void 0) run.displayMode = attrs.displayMode;
 	if (attrs.cssFloat !== void 0) run.cssFloat = attrs.cssFloat;
@@ -544,9 +644,10 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 	if (attrs.cropLeft != null) run.cropLeft = attrs.cropLeft;
 	if (attrs.borderWidth != null) run.borderWidth = attrs.borderWidth;
 	if (attrs.borderColor) run.borderColor = attrs.borderColor;
-	if (attrs.borderStyle) run.borderStyle = attrs.borderStyle;
+	const runBorderStyle = cssBorderStyleOf(attrs.borderStyle);
+	if (runBorderStyle) run.borderStyle = runBorderStyle;
 	if (attrs.position !== void 0) run.position = attrs.position;
-	if (attrs.layoutInCell !== void 0) run.layoutInCell = attrs.layoutInCell;
+	if (attrs.anchor?.layoutInCell !== void 0) run.layoutInCell = attrs.anchor.layoutInCell;
 	if (trackedChange?.isInsertion) run.isInsertion = true;
 	if (trackedChange?.isDeletion) run.isDeletion = true;
 	if (trackedChange?.changeAuthor !== void 0) run.changeAuthor = trackedChange.changeAuthor;
@@ -556,7 +657,11 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 }
 /** A package image whose bytes cannot paint still owns its authored line box. */
 const hasRelationshipBackedImageBox = (attrs) => typeof attrs.rId === "string" && attrs.rId.trim().length > 0 && typeof attrs.width === "number" && Number.isFinite(attrs.width) && attrs.width >= 0 && typeof attrs.height === "number" && Number.isFinite(attrs.height) && attrs.height >= 0;
-const hasPaintableImageSource = (src) => sanitizeImageSrc(src) !== void 0;
+/**
+* A preview counts as a source: the bytes are not in the attrs, but the
+* display list can produce them without I/O when it interns the descriptor.
+*/
+const hasPaintableImageSource = (attrs) => attrs.preview !== void 0 || sanitizeImageSrc(attrs.src) !== void 0;
 /**
 * In TOC paragraphs, strip the resolved Hyperlink character-style colour and
 * underline so the painter's link fallback doesn't fire. The PM doc keeps the
@@ -684,6 +789,25 @@ function paragraphToRuns(node, startPos, _options, pageBreaks) {
 			});
 			return;
 		}
+		if (child.type.name === "preservedXml") {
+			const { text } = expectPreservedXmlAttrs(child);
+			if (text === "") return;
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			runs.push({
+				kind: "text",
+				text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
 		if (child.type.name === "hardBreak") {
 			runs.push({
 				kind: "lineBreak",
@@ -711,7 +835,7 @@ function paragraphToRuns(node, startPos, _options, pageBreaks) {
 		}
 		if (child.type.name === "image") {
 			const attrs = expectImageAttrs(child);
-			if (!hasPaintableImageSource(attrs.src) && !hasRelationshipBackedImageBox(attrs)) return;
+			if (!hasPaintableImageSource(attrs) && !hasRelationshipBackedImageBox(attrs)) return;
 			const constrained = constrainImageToPage(attrs.width ?? 100, attrs.height ?? 100, _options.pageContentHeight);
 			const trackedFmt = extractRunFormatting(effectiveMarks, theme, fontAlternates);
 			const run = buildImageRun(attrs, constrained, childPos, childPos + child.nodeSize, trackedFmt);
@@ -790,6 +914,20 @@ function paragraphToRuns(node, startPos, _options, pageBreaks) {
 	node.forEach((child, childOffset) => {
 		pushRunsForChild(child, offset + childOffset);
 	});
+	const { defaultFont, defaultSize } = _options;
+	if (defaultFont !== void 0 || defaultSize !== void 0) for (const run of runs) switch (run.kind) {
+		case "text":
+		case "tab":
+		case "renderedPageBreak":
+		case "field":
+		case "math":
+			if (defaultFont !== void 0) run.fontFamily ??= defaultFont;
+			if (defaultSize !== void 0) run.fontSize ??= defaultSize;
+			break;
+		case "image":
+		case "lineBreak": break;
+		default:
+	}
 	return runs;
 }
 function toListMarkerRevision(kind, info) {
@@ -809,13 +947,7 @@ function isRemovedNumberingChange(change) {
 }
 function isChangedNumberingChange(currentNumPr, change) {
 	const previousFormatting = change.previousFormatting;
-	return previousFormatting != null && Object.hasOwn(previousFormatting, "numPr") && isListNumPr(previousFormatting.numPr) && !areListNumPrEqual(previousFormatting.numPr, currentNumPr);
-}
-function areListNumPrEqual(left, right) {
-	return left.numId === right.numId && left.ilvl === right.ilvl;
-}
-function isListNumPr(value) {
-	return value !== void 0 && value !== null;
+	return previousFormatting != null && Object.hasOwn(previousFormatting, "numPr") && isListNumPr(previousFormatting.numPr) && !sameStatedParagraphNumbering(previousFormatting.numPr, currentNumPr);
 }
 function toPreviousListAttrs(previousFormatting) {
 	const attrs = {};
@@ -876,7 +1008,20 @@ function applyDeletedListMarkerAttrs(attrs, change, listCounterState, theme, fon
 	if (previousListAttrs.listMarkerAlignment) attrs.listMarkerAlignment = previousListAttrs.listMarkerAlignment;
 	if (previousListAttrs.listMarkerSuffix) attrs.listMarkerSuffix = previousListAttrs.listMarkerSuffix;
 }
+/**
+* Every `ST_Jc` member, and the flow alignment that paints it.
+*
+* `start` and `end` stay unresolved here: they name an edge of the writing
+* direction, not a side of the page, so which of `left` and `right` paints
+* them depends on the paragraph's direction. `numTab` has no flow alignment at
+* all — it aligns the paragraph to the list number's tab stop, which the flow
+* engine does not model — so it falls back to the start edge, which is where a
+* numbered paragraph without one sits.
+*/
 const FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT = {
+	start: "start",
+	end: "end",
+	numTab: "start",
 	left: "left",
 	center: "center",
 	right: "right",
@@ -887,10 +1032,19 @@ const FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT = {
 	lowKashida: "justify",
 	thaiDistribute: "justify"
 };
+/** Resolve a logical alignment against the direction the paragraph runs in. */
+const resolveFlowAlignment = (alignment, rightToLeft) => {
+	const flow = FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT[alignment];
+	switch (flow) {
+		case "start": return rightToLeft ? "right" : "left";
+		case "end": return rightToLeft ? "left" : "right";
+		default: return flow;
+	}
+};
 function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStreams, defaultTabStopTwips }) {
 	const attrs = {};
-	if (pmAttrs.alignment) attrs.alignment = FLOW_ALIGNMENT_BY_PARAGRAPH_ALIGNMENT[pmAttrs.alignment];
-	if (typeof pmAttrs.outlineLevel === "number") attrs.outlineLevel = pmAttrs.outlineLevel;
+	if (pmAttrs.alignment) attrs.alignment = resolveFlowAlignment(pmAttrs.alignment, directionIsRtl(pmAttrs.direction));
+	if (pmAttrs.outlineLevel !== void 0) attrs.outlineLevel = pmAttrs.outlineLevel;
 	const spaceBefore = pmAttrs.spaceBefore;
 	const spaceAfter = pmAttrs.spaceAfter;
 	const lineSpacing = pmAttrs.lineSpacing;
@@ -927,8 +1081,8 @@ function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStre
 	let indentLeft = typeof pmAttrs.indentLeft === "number" ? pmAttrs.indentLeft : void 0;
 	let indentFirstLine = typeof pmAttrs.indentFirstLine === "number" ? pmAttrs.indentFirstLine : void 0;
 	let hangingIndent = pmAttrs.hangingIndent;
-	if (pmAttrs.numPr?.numId && indentLeft === void 0 && indentFirstLine === void 0) {
-		indentLeft = ((pmAttrs.numPr.ilvl ?? 0) + 1) * 720;
+	if (paragraphNumberingReferenceId(pmAttrs.numPr) !== void 0 && indentLeft === void 0 && indentFirstLine === void 0) {
+		indentLeft = ((paragraphNumberingLevel(pmAttrs.numPr) ?? 0) + 1) * 720;
 		if (indentFirstLine === void 0) {
 			indentFirstLine = -360;
 			hangingIndent = true;
@@ -962,14 +1116,17 @@ function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStre
 	}
 	const shadingRgb = pmAttrs.shading?.fill?.rgb?.toUpperCase();
 	if (shadingRgb && shadingRgb !== "FFFFFF" && shadingRgb !== "FFFFFE") attrs.shading = `#${pmAttrs.shading?.fill?.rgb}`;
-	if (pmAttrs.tabs && pmAttrs.tabs.length > 0) attrs.tabs = pmAttrs.tabs.map((tab) => {
-		const tabStop = {
-			val: mapTabAlignment(tab.alignment),
-			pos: tab.position
-		};
-		if (tab.leader) tabStop.leader = tab.leader;
-		return tabStop;
-	});
+	if (pmAttrs.tabs && pmAttrs.tabs.length > 0) {
+		const rightToLeft = directionIsRtl(pmAttrs.direction);
+		attrs.tabs = pmAttrs.tabs.map((tab) => {
+			const tabStop = {
+				val: resolveTabAlignment(tab.alignment, rightToLeft),
+				pos: tab.position
+			};
+			if (tab.leader) tabStop.leader = tab.leader;
+			return tabStop;
+		});
+	}
 	if (pmAttrs.pageBreakBefore) attrs.pageBreakBefore = true;
 	if (pmAttrs.kinsoku !== void 0 && pmAttrs.kinsoku !== null) attrs.kinsoku = pmAttrs.kinsoku;
 	if (pmAttrs.overflowPunctuation !== void 0 && pmAttrs.overflowPunctuation !== null) attrs.overflowPunctuation = pmAttrs.overflowPunctuation;
@@ -986,10 +1143,7 @@ function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStre
 	const propertyChanges = pmAttrs._propertyChanges ?? [];
 	let changedNumberingChange;
 	if (pmAttrs.numPr) {
-		const numPr = {};
-		if (pmAttrs.numPr.numId !== void 0) numPr.numId = pmAttrs.numPr.numId;
-		if (pmAttrs.numPr.ilvl !== void 0) numPr.ilvl = pmAttrs.numPr.ilvl;
-		attrs.numPr = numPr;
+		attrs.numPr = pmAttrs.numPr;
 		if (pmAttrs.pPrMark?.kind === "del") attrs.listMarkerRevision = toListMarkerRevision("del", pmAttrs.pPrMark.info);
 		else if (pmAttrs.pPrMark?.kind === "ins") attrs.listMarkerRevision = toListMarkerRevision("ins", pmAttrs.pPrMark.info);
 		else {
@@ -1036,20 +1190,35 @@ function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStre
 	return attrs;
 }
 /**
-* Map document TabStopAlignment to layout engine TabAlignment
+* Every `ST_TabJc` member, and the layout engine's name for it.
+*
+* The engine's `start` and `end` are its names for the left and right edges of
+* the line, not direction-aware ones, so `w:tab w:val="left"` maps to `start`
+* unconditionally. `ST_TabJc`'s own `start` and `end` *are* direction-aware
+* and stay unresolved here, under names the engine has no member for.
+* `num`, the tab a numbered paragraph's text hangs from, has no engine
+* alignment of its own and falls back to the line's start edge.
 */
-function mapTabAlignment(align) {
-	switch (align) {
-		case "left": return "start";
-		case "right": return "end";
-		case "center": return "center";
-		case "decimal": return "decimal";
-		case "bar": return "bar";
-		case "clear": return "clear";
-		case "num": return "start";
-		default: return "start";
+const TAB_ALIGNMENT_BY_TAB_STOP_ALIGNMENT = {
+	start: "logicalStart",
+	end: "logicalEnd",
+	num: "logicalStart",
+	left: "start",
+	right: "end",
+	center: "center",
+	decimal: "decimal",
+	bar: "bar",
+	clear: "clear"
+};
+/** Resolve a logical tab alignment against the direction the paragraph runs in. */
+const resolveTabAlignment = (alignment, rightToLeft) => {
+	const mapped = TAB_ALIGNMENT_BY_TAB_STOP_ALIGNMENT[alignment];
+	switch (mapped) {
+		case "logicalStart": return rightToLeft ? "end" : "start";
+		case "logicalEnd": return rightToLeft ? "start" : "end";
+		default: return mapped;
 	}
-}
+};
 /**
 * Convert a paragraph node to a ParagraphBlock.
 */
@@ -1071,6 +1240,8 @@ function convertParagraph(node, startPos, options, pageBreaks) {
 		listCounterStreams: options.listCounterStreams,
 		defaultTabStopTwips: options.defaultTabStopTwips
 	});
+	if (options.defaultFont !== void 0) attrs.defaultFontFamily ??= options.defaultFont;
+	if (options.defaultSize !== void 0) attrs.defaultFontSize ??= options.defaultSize;
 	if (options.lineBreakRules) attrs.lineBreakRules = options.lineBreakRules;
 	if (options.justificationCompatibility) attrs.justificationCompatibility = options.justificationCompatibility;
 	if (options.automaticHyphenation) attrs.automaticHyphenation = options.automaticHyphenation;
@@ -1275,7 +1446,7 @@ function suppressFinalParagraphInRepeatedEmptySuffix(blocks) {
 }
 function reserveLeadingEmptyOutlineHeight(blocks) {
 	const firstBlock = blocks.at(0);
-	if (firstBlock?.kind !== "paragraph" || firstBlock.runs.length !== 0 || firstBlock.attrs?.outlineLevel !== 0) return;
+	if (firstBlock?.kind !== "paragraph" || firstBlock.runs.length !== 0 || headingLevelOf(firstBlock.attrs?.outlineLevel) !== 0) return;
 	firstBlock.attrs = {
 		...firstBlock.attrs,
 		reserveEmptyOutlineHeight: true
@@ -1288,31 +1459,14 @@ function reserveLeadingEmptyOutlineHeight(blocks) {
 function borderWidthToPixels(eighthsOfPoint) {
 	return pointsToPixels(eighthsOfPoint / 8);
 }
-const OOXML_TO_CSS_BORDER = {
-	single: "solid",
-	double: "double",
-	dotted: "dotted",
-	dashed: "dashed",
-	thick: "solid",
-	dashSmallGap: "dashed",
-	dotDash: "dashed",
-	dotDotDash: "dotted",
-	triple: "double",
-	wave: "solid",
-	doubleWave: "double",
-	threeDEmboss: "ridge",
-	threeDEngrave: "groove",
-	outset: "outset",
-	inset: "inset"
-};
 /**
 * Convert an OOXML BorderSpec to a layout-engine BorderStyle.
 * Shared by paragraph borders, cell borders, and header/footer borders.
 */
 function convertBorderSpecToLayout(border, theme) {
-	if (!border.style || border.style === "none" || border.style === "nil") return;
+	if (border.style === void 0 || statesNoBorder(border.style)) return;
 	const result = {
-		style: OOXML_TO_CSS_BORDER[border.style] || "solid",
+		style: cssBorderStyle(border.style),
 		width: border.size === void 0 ? 1 : borderWidthToPixels(border.size),
 		color: border.color ? resolveColor(border.color, theme) : "#000000"
 	};
@@ -1357,8 +1511,7 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 	const blocks = [];
 	let offset = startPos + 1;
 	const authoredPageBreakPosition = options.firstPageBreakRunPosition(node);
-	const leadingParagraph = node.firstChild?.type.name === "paragraph" ? node.firstChild : void 0;
-	if (authoredPageBreakPosition !== void 0 && (leadingParagraph === void 0 || countPageBreakRuns(node) !== 1 || options.firstPageBreakRunPosition(leadingParagraph) !== authoredPageBreakPosition)) panic(`An explicit page-break run at ${String(authoredPageBreakPosition)} cannot be projected inside a table cell`);
+	const leadingParagraph = node.firstChild?.type.name === "paragraph" && countPageBreakRuns(node) === 1 && options.firstPageBreakRunPosition(node.firstChild) === authoredPageBreakPosition ? node.firstChild : void 0;
 	const pageBreaks = [];
 	node.forEach((child) => {
 		if (child.type.name === "paragraph") {
@@ -1406,24 +1559,41 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 	if (attrs.noWrap) cell.noWrap = true;
 	if (authoredPageBreakPosition === void 0 || pageBreaks.length === 0) return { cell };
 	const paragraph = blocks.at(0);
-	if (paragraph?.kind !== "paragraph" || !hasSingleLeadingProjectedPageBreak(paragraph.runs, pageBreaks)) panic(`An explicit page-break run at ${String(authoredPageBreakPosition)} cannot be projected inside a table cell`);
+	if (paragraph?.kind !== "paragraph" || !hasSingleLeadingProjectedPageBreak(paragraph.runs, pageBreaks)) return { cell };
 	return {
 		cell,
 		breakBefore: "page"
 	};
 }
 /**
-* Convert a table row node.
+* Resolve an `ST_JcTable` placement to the flow engine's logical alignment.
+*
+* `start` and `end` name an edge of the writing direction, not a side of the
+* page, the same distinction `ST_Jc` draws for a paragraph. The flow engine
+* applies `w:bidiVisual` when it resolves that logical alignment to a physical
+* side, so the bridge must not mirror it first.
 */
-function convertTableRow(node, startPos, options, tableCellMargins) {
+const resolveTablePlacement = (placement) => {
+	switch (placement) {
+		case "start": return "left";
+		case "end": return "right";
+		case "left":
+		case "center":
+		case "right": return placement;
+		default: return placement;
+	}
+};
+function convertTableRow(node, startPos, options, { cellMargins }) {
 	const cells = [];
 	let offset = startPos + 1;
 	let breakBefore;
 	node.forEach((child) => {
 		if (child.type.name === "tableCell" || child.type.name === "tableHeader") {
-			const converted = convertTableCell(child, offset, options, tableCellMargins);
-			if (converted.breakBefore !== void 0) breakBefore = converted.breakBefore;
-			cells.push(converted.cell);
+			if (!expectTableCellAttrs(child)._omittedGridSlot) {
+				const converted = convertTableCell(child, offset, options, cellMargins);
+				if (converted.breakBefore !== void 0) breakBefore = converted.breakBefore;
+				cells.push(converted.cell);
+			}
 		}
 		offset += child.nodeSize;
 	});
@@ -1441,7 +1611,7 @@ function convertTableRow(node, startPos, options, tableCellMargins) {
 	if (breakBefore !== void 0) row.breakBefore = breakBefore;
 	if (attrs.hidden) row.hidden = attrs.hidden;
 	const effectiveJustification = attrs._originalFormatting?.justification ?? attrs._resolvedJustification;
-	if (effectiveJustification) row.justification = effectiveJustification;
+	if (effectiveJustification) row.justification = resolveTablePlacement(effectiveJustification);
 	return row;
 }
 /**
@@ -1451,9 +1621,10 @@ function convertTable(node, startPos, options) {
 	const rows = [];
 	let offset = startPos + 1;
 	const attrs = expectTableAttrs(node);
-	const tableCellMargins = attrs.cellMargins;
+	const rightToLeft = (attrs._resolvedBidi ?? attrs._originalFormatting?.bidi) === true;
+	const rowContext = { ...attrs.cellMargins === void 0 ? {} : { cellMargins: attrs.cellMargins } };
 	node.forEach((child) => {
-		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, tableCellMargins));
+		if (child.type.name === "tableRow") rows.push(convertTableRow(child, offset, options, rowContext));
 		offset += child.nodeSize;
 	});
 	let columnWidths = attrs.columnWidths?.map(twipsToPixels);
@@ -1463,7 +1634,8 @@ function convertTable(node, startPos, options) {
 		const cellWidths = rows[0].cells.map((cell) => cell.width);
 		if (cellWidths.every((w) => w !== void 0 && w > 0)) columnWidths = cellWidths;
 	}
-	const justification = attrs.justification ?? attrs._resolvedJustification;
+	const authoredJustification = attrs.justification ?? attrs._resolvedJustification;
+	const justification = authoredJustification === void 0 ? void 0 : resolveTablePlacement(authoredJustification);
 	const originalFormatting = attrs._originalFormatting;
 	const effectiveIndent = attrs._resolvedIndent ?? originalFormatting?.indent;
 	const indentPx = effectiveIndent?.value !== void 0 && effectiveIndent?.type === "dxa" ? twipsToPixels(effectiveIndent.value) : void 0;
@@ -1499,7 +1671,7 @@ function convertTable(node, startPos, options) {
 	if (indentPx !== void 0) tableBlock.indent = indentPx;
 	if (options.tableIndentCompatibility && !dropsAuthoredIndent) tableBlock.indentCompatibility = options.tableIndentCompatibility;
 	if (floatingPx) tableBlock.floating = floatingPx;
-	if (attrs._resolvedBidi ?? originalFormatting?.bidi) tableBlock.bidi = true;
+	if (rightToLeft) tableBlock.bidi = true;
 	return tableBlock;
 }
 /**
@@ -1507,7 +1679,7 @@ function convertTable(node, startPos, options) {
 */
 function convertImage(node, startPos, pageContentHeight) {
 	const attrs = expectImageAttrs(node);
-	if (!hasPaintableImageSource(attrs.src) && !hasRelationshipBackedImageBox(attrs)) return;
+	if (!hasPaintableImageSource(attrs) && !hasRelationshipBackedImageBox(attrs)) return;
 	const wrapType = attrs.wrapType;
 	const shouldAnchor = wrapType === "behind" || wrapType === "inFront";
 	const constrained = constrainImageToPage(attrs.width ?? 100, attrs.height ?? 100, pageContentHeight);
@@ -1515,6 +1687,7 @@ function convertImage(node, startPos, pageContentHeight) {
 		kind: "image",
 		id: nextBlockId(),
 		src: attrs.src,
+		...attrs.preview ? { preview: attrs.preview } : {},
 		width: constrained.width,
 		height: constrained.height,
 		pmStart: startPos,
@@ -1523,6 +1696,8 @@ function convertImage(node, startPos, pageContentHeight) {
 	if (attrs.alt) imgBlock.alt = attrs.alt;
 	if (attrs.transform) imgBlock.transform = attrs.transform;
 	if (attrs.opacity != null) imgBlock.opacity = attrs.opacity;
+	if (attrs.brightness != null) imgBlock.brightness = attrs.brightness;
+	if (attrs.contrast != null) imgBlock.contrast = attrs.contrast;
 	if (shouldAnchor) {
 		const anchor = {
 			isAnchored: true,
@@ -1539,13 +1714,12 @@ function convertImage(node, startPos, pageContentHeight) {
 	if (attrs.cropLeft != null) imgBlock.cropLeft = attrs.cropLeft;
 	if (attrs.borderWidth != null) imgBlock.borderWidth = attrs.borderWidth;
 	if (attrs.borderColor) imgBlock.borderColor = attrs.borderColor;
-	if (attrs.borderStyle) imgBlock.borderStyle = attrs.borderStyle;
+	const imageBorderStyle = cssBorderStyleOf(attrs.borderStyle);
+	if (imageBorderStyle) imgBlock.borderStyle = imageBorderStyle;
 	return imgBlock;
 }
 /** Convert a textBox PM node to a TextBoxBlock. */
 function convertTextBoxNode(node, startPos, opts) {
-	const pageBreakPosition = opts.firstPageBreakRunPosition(node);
-	if (pageBreakPosition !== void 0) panic(`An explicit page-break run at ${String(pageBreakPosition)} cannot be projected inside a text box`);
 	const attrs = expectTextBoxAttrs(node);
 	const contentBlocks = [];
 	node.forEach((child, offset) => {
@@ -1650,15 +1824,13 @@ function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreak
 	}
 	return result;
 }
+/**
+* The last section's start mode, off a document attribute the schema types as
+* `any`. `parseSectionBreakType` owns the enumeration, so a member added to
+* `ST_SectionMark` reaches the paginator instead of being dropped here.
+*/
 function readFinalSectionStart(doc) {
-	const sectionStart = doc.attrs["_finalSectionStart"];
-	switch (sectionStart) {
-		case "continuous":
-		case "nextPage":
-		case "oddPage":
-		case "evenPage": return sectionStart;
-		default: return;
-	}
+	return parseSectionBreakType(doc.attrs["_finalSectionStart"]) ?? void 0;
 }
 /**
 * Convert a ProseMirror document to FlowBlock array.
@@ -1700,8 +1872,6 @@ function toFlowBlocks(doc, options = {}) {
 	const { firstPageBreakRunPosition } = buildPageBreakRunDescendantIndex(doc);
 	const opts = {
 		...options,
-		defaultFont: options.defaultFont ?? DEFAULT_FONT,
-		defaultSize: options.defaultSize ?? DEFAULT_SIZE,
 		listCounters: listCounterState.counters,
 		listAbstractCounters: listCounterState.abstractCounters,
 		listSeenNumIds: listCounterState.seenLevels,
@@ -1746,10 +1916,6 @@ function toFlowBlocks(doc, options = {}) {
 	const pushParagraphProjection = (node, pos, stripLeadingLineBreak = false) => {
 		const pageBreaks = [];
 		const paragraph = convertParagraph(node, pos, opts, pageBreaks);
-		if (pageBreaks.length > 0) {
-			const disposition = pageBreakRunParagraphProjectionDisposition(node);
-			if (disposition.status === "unsupported" && (disposition.reason === "textBoxAnchor" || !hasSingleLeadingProjectedPageBreak(paragraph.runs, pageBreaks))) panic(disposition.message);
-		}
 		if (stripLeadingLineBreak && paragraph.runs.at(0)?.kind === "lineBreak") paragraph.runs.shift();
 		for (const block of splitParagraphAtPageBreaks({
 			pageBreaks,
@@ -1765,7 +1931,7 @@ function toFlowBlocks(doc, options = {}) {
 			const child = parent.child(index);
 			const next = index + 1 < parent.childCount ? parent.child(index + 1) : void 0;
 			const paragraphAttrs = child.type.name === "paragraph" ? expectParagraphAttrs(child) : void 0;
-			if (paragraphAttrs && next?.type.name === "pageBreak" && paragraphAttrs._trailingPageBreak === true && (paragraphAttrs._sectionProperties || paragraphAttrs.sectionBreakType)) {
+			if (paragraphAttrs && next?.type.name === "pageBreak" && paragraphAttrs._trailingPageBreak === true && paragraphAttrs._sectionProperties !== void 0) {
 				trailingPageBreakSectionPositions.add(childStart);
 				consumedPageBreakPositions.add(childStart + child.nodeSize);
 			}
@@ -1834,7 +2000,7 @@ function toFlowBlocks(doc, options = {}) {
 			case "paragraph": {
 				const pmAttrs = expectParagraphAttrs(node);
 				const secProps = pmAttrs._sectionProperties;
-				const hasSectionBreak = secProps !== void 0 || pmAttrs.sectionBreakType !== null && pmAttrs.sectionBreakType !== void 0;
+				const hasSectionBreak = secProps !== void 0;
 				const hasListFormatting = pmAttrs.numPr !== null && pmAttrs.numPr !== void 0 || pmAttrs.listMarker !== null && pmAttrs.listMarker !== void 0;
 				const firstChild = node.firstChild;
 				const startsWithColumnBreak = firstChild?.type.name === "hardBreak" && expectHardBreakAttrs(firstChild).breakType === "column";
@@ -1897,7 +2063,7 @@ function toFlowBlocks(doc, options = {}) {
 						kind: "sectionBreak",
 						id: nextBlockId()
 					};
-					const breakType = secProps?.sectionStart ?? pmAttrs.sectionBreakType;
+					const breakType = secProps?.sectionStart;
 					if (breakType) sectionBreak.type = breakType;
 					if (secProps) {
 						sectionBreak.pageNumbering = getPageNumbering(secProps);
@@ -2068,4 +2234,4 @@ function mergeRunInParagraphs(blocks) {
 	return out;
 }
 //#endregion
-export { convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };
+export { WORD_UNSPECIFIED_FONT_SIZE, convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };