@stll/folio-core 0.47.7 → 0.48.0

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

@@ -17,6 +17,7 @@ import { directionIsRtl, directionToBidi } from "../../prosemirror/paragraphDire
 import { resolveEffectiveRunStyleFormatting } from "../../prosemirror/runStyleFormatting.js";
 import { parseSectionBreakType } from "../../prosemirror/sectionCarrier.js";
 import { expectTextBoxAnchorAttrs } from "../../prosemirror/textBoxAnchorAttrs.js";
+import { textBoxHostParagraph } from "../../prosemirror/textBoxHostParagraph.js";
 import { assertValidProseMirrorDocument } from "../../prosemirror/validation.js";
 import { createStyleEngine } from "../../style-engine/styleEngine.js";
 import { normalizeShapeTextAnchor } from "../../types/documentEnumValues.js";
@@ -26,12 +27,14 @@ import { resolveThemeFont } from "../../utils/fontResolver.js";
 import { resolveShadingFill } from "../../utils/formatToStyle.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { decodeOoxmlSymbolCharacter } from "../../utils/ooxmlSymbol.js";
+import { mergeParagraphTabStops } from "../../utils/paragraphFormattingMerge.js";
 import { sanitizeImageSrc } from "../../utils/sanitizeImageSrc.js";
 import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
-import { STYLE_TOGGLE_KEYS } from "../../utils/textFormattingMerge.js";
+import { STYLE_TOGGLE_KEYS, mergeTextFormatting } from "../../utils/textFormattingMerge.js";
 import { AUTO_PARAGRAPH_SPACING_PX, halfPointsToPixels, halfPointsToPoints, pointsToPixels } from "../../utils/units.js";
 import { getColumns } from "../sectionColumns.js";
 import { groupParagraphFrames } from "./paragraphFrames.js";
+import { resolveParagraphMarkFormatting, resolveParagraphMarkOwnFormatting } from "./paragraphMarkFormatting.js";
 import { panic } from "better-result";
 import { headingLevelOf, paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering, statesNoBorder } from "@stll/docx-core/model";
 //#region src/layout-bridge/convert/toFlowBlocks.ts
@@ -42,6 +45,32 @@ const expectDetachedWatermarkHostAttr = (attrs) => {
 	if (typeof value !== "boolean") panic("Invalid ProseMirror detached watermark host attrs:\nparagraph.attrs._detachedWatermarkHost: Expected a boolean.");
 	return value;
 };
+const NOTE_REFERENCE_MARK_XML = /^<(?:[^\s:/>]+:)?(?:footnoteRef|endnoteRef)[\s/>]/u;
+/**
+* Runs with `idKey` set, in document order: the note references a block list
+* makes, through table cells (and tables within cells) and text boxes.
+*/
+function collectNoteRefs(blocks, idKey) {
+	const refs = [];
+	const walk = (containerBlocks) => {
+		for (const block of containerBlocks) if (block.kind === "paragraph") for (const run of block.runs) {
+			if (run.kind !== "text") continue;
+			const noteId = run[idKey];
+			if (noteId !== void 0) refs.push({
+				noteId,
+				pmPos: run.pmStart ?? 0
+			});
+		}
+		else if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) walk(cell.blocks);
+		else if (block.kind === "textBox") walk(block.content);
+	};
+	walk(blocks);
+	return refs;
+}
+/** Whether captured run-child markup is a note story's `w:footnoteRef`/`w:endnoteRef`. */
+function isNoteReferenceMarkXml(xml) {
+	return NOTE_REFERENCE_MARK_XML.test(xml);
+}
 /**
 * Word's layout fallback when an imported OOXML style hierarchy never supplies
 * `w:sz`. ECMA-376 deliberately leaves that terminal fallback to the consumer;
@@ -256,6 +285,7 @@ function extractRunFormatting(marks, theme, fontAlternates) {
 				const alternate = getFontAlternate(eastAsiaFont, fontAlternates);
 				if (alternate) formatting.eastAsiaAlternateFontFamily = alternate;
 			}
+			if (attrs.hint) formatting.eastAsiaHint = attrs.hint === "eastAsia";
 			const complexScriptFont = resolveComplexScriptThemeFont(attrs, theme);
 			if (complexScriptFont) {
 				formatting.complexScriptFontFamily = complexScriptFont;
@@ -564,6 +594,7 @@ function textFormattingToRunFormatting(defaultTextFormatting, theme, fontAlterna
 		const alternate = getFontAlternate(eastAsiaFontFamily, fontAlternates);
 		if (alternate) result.eastAsiaAlternateFontFamily = alternate;
 	}
+	if (defaultTextFormatting.fontFamily?.hint) result.eastAsiaHint = defaultTextFormatting.fontFamily.hint === "eastAsia";
 	const complexScriptFontFamily = defaultTextFormatting.fontFamily ? resolveComplexScriptThemeFont(defaultTextFormatting.fontFamily, theme) : void 0;
 	if (complexScriptFontFamily) {
 		result.complexScriptFontFamily = complexScriptFontFamily;
@@ -608,6 +639,34 @@ function textFormattingToRunFormatting(defaultTextFormatting, theme, fontAlterna
 	if (defaultTextFormatting.emphasisMark && defaultTextFormatting.emphasisMark !== "none") result.emphasisMark = defaultTextFormatting.emphasisMark;
 	return result;
 }
+const LIST_MARKER_FORMATTING_KEYS = [
+	"fontFamily",
+	"alternateFontFamily",
+	"eastAsiaFontFamily",
+	"eastAsiaAlternateFontFamily",
+	"complexScriptFontFamily",
+	"complexScriptAlternateFontFamily",
+	"fontSize",
+	"complexScriptFontSize",
+	"bold",
+	"complexScriptBold",
+	"italic",
+	"complexScriptItalic",
+	"rtl",
+	"forceComplexScript",
+	"color"
+];
+/**
+* The numbering symbol's typography: the numbering level's `w:rPr` applied
+* over the paragraph mark's run properties (ECMA-376 §17.9.24, §17.3.1.29).
+* Text runs of the paragraph play no part.
+*/
+function listMarkerFormattingFor(levelFormatting, paragraphMarkFormatting, theme, fontAlternates) {
+	const runFormatting = textFormattingToRunFormatting(mergeTextFormatting(paragraphMarkFormatting, levelFormatting), theme, fontAlternates);
+	const formatting = {};
+	for (const key of LIST_MARKER_FORMATTING_KEYS) if (runFormatting[key] !== void 0) Reflect.set(formatting, key, runFormatting[key]);
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
 function paragraphRunDefaults(pmAttrs, theme, fontAlternates) {
 	return textFormattingToRunFormatting(pmAttrs.defaultTextFormatting, theme, fontAlternates);
 }
@@ -615,7 +674,7 @@ function paragraphRunDefaults(pmAttrs, theme, fontAlternates) {
 * Build an ImageRun from ProseMirror node attrs, applying conditional property assignment
 * to satisfy exactOptionalPropertyTypes.
 */
-function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
+function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange, forceLayoutInCell) {
 	const run = {
 		kind: "image",
 		src: attrs.src,
@@ -647,7 +706,8 @@ function buildImageRun(attrs, constrained, pmStart, pmEnd, trackedChange) {
 	const runBorderStyle = cssBorderStyleOf(attrs.borderStyle);
 	if (runBorderStyle) run.borderStyle = runBorderStyle;
 	if (attrs.position !== void 0) run.position = attrs.position;
-	if (attrs.anchor?.layoutInCell !== void 0) run.layoutInCell = attrs.anchor.layoutInCell;
+	if (forceLayoutInCell) run.layoutInCell = true;
+	else 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;
@@ -790,7 +850,8 @@ function paragraphToRuns(node, startPos, _options, pageBreaks) {
 			return;
 		}
 		if (child.type.name === "preservedXml") {
-			const { text } = expectPreservedXmlAttrs(child);
+			const { xml, text: capturedText } = expectPreservedXmlAttrs(child);
+			const text = capturedText === "" && _options.noteReferenceMarkText !== void 0 && isNoteReferenceMarkXml(xml) ? _options.noteReferenceMarkText : capturedText;
 			if (text === "") return;
 			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
 			applyCharacterStyleToggleFormatting({
@@ -838,7 +899,7 @@ function paragraphToRuns(node, startPos, _options, pageBreaks) {
 			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);
+			const run = buildImageRun(attrs, constrained, childPos, childPos + child.nodeSize, trackedFmt, _options.forceAnchorLayoutInCell);
 			runs.push(run);
 			return;
 		}
@@ -996,7 +1057,7 @@ function resolveDeletedListMarker(previousListAttrs, listCounterState) {
 	if (previousListAttrs.listIsBullet) return "•";
 	return null;
 }
-function applyDeletedListMarkerAttrs(attrs, change, listCounterState, theme, fontAlternates) {
+function applyDeletedListMarkerAttrs(attrs, change, listCounterState, theme, fontAlternates, paragraphMarkFormatting) {
 	const previousListAttrs = toPreviousListAttrs(change.previousFormatting);
 	const marker = resolveDeletedListMarker(previousListAttrs, listCounterState);
 	if (!marker) return;
@@ -1004,7 +1065,8 @@ function applyDeletedListMarkerAttrs(attrs, change, listCounterState, theme, fon
 	attrs.listMarkerRevision = toListMarkerRevision("del", change.info);
 	if (previousListAttrs.listIsBullet !== void 0) attrs.listIsBullet = previousListAttrs.listIsBullet;
 	if (previousListAttrs.listMarkerHidden !== void 0) attrs.listMarkerHidden = previousListAttrs.listMarkerHidden;
-	if (previousListAttrs.listMarkerFormatting) attrs.listMarkerFormatting = textFormattingToRunFormatting(previousListAttrs.listMarkerFormatting, theme, fontAlternates);
+	const listMarkerFormatting = listMarkerFormattingFor(previousListAttrs.listMarkerFormatting, paragraphMarkFormatting(), theme, fontAlternates);
+	if (listMarkerFormatting) attrs.listMarkerFormatting = listMarkerFormatting;
 	if (previousListAttrs.listMarkerAlignment) attrs.listMarkerAlignment = previousListAttrs.listMarkerAlignment;
 	if (previousListAttrs.listMarkerSuffix) attrs.listMarkerSuffix = previousListAttrs.listMarkerSuffix;
 }
@@ -1041,7 +1103,7 @@ const resolveFlowAlignment = (alignment, rightToLeft) => {
 		default: return flow;
 	}
 };
-function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStreams, defaultTabStopTwips }) {
+function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStreams, defaultTabStopTwips, paragraphMarkFormatting }) {
 	const attrs = {};
 	if (pmAttrs.alignment) attrs.alignment = resolveFlowAlignment(pmAttrs.alignment, directionIsRtl(pmAttrs.direction));
 	if (pmAttrs.outlineLevel !== void 0) attrs.outlineLevel = pmAttrs.outlineLevel;
@@ -1116,9 +1178,10 @@ 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) {
+	const tabs = mergeParagraphTabStops(pmAttrs.listLevelTabs ?? void 0, pmAttrs.tabs ?? void 0);
+	if (tabs && tabs.length > 0) {
 		const rightToLeft = directionIsRtl(pmAttrs.direction);
-		attrs.tabs = pmAttrs.tabs.map((tab) => {
+		attrs.tabs = tabs.map((tab) => {
 			const tabStop = {
 				val: resolveTabAlignment(tab.alignment, rightToLeft),
 				pos: tab.position
@@ -1159,14 +1222,17 @@ function convertParagraphAttrs(pmAttrs, { theme, fontAlternates, listCounterStre
 	else if (pmAttrs.listMarker) attrs.listMarker = pmAttrs.listIsBullet ? convertBulletToUnicode(pmAttrs.listMarker) : pmAttrs.listMarker;
 	if (pmAttrs.listIsBullet !== void 0) attrs.listIsBullet = pmAttrs.listIsBullet;
 	if (pmAttrs.listMarkerHidden) attrs.listMarkerHidden = true;
-	if (pmAttrs.listMarkerFormatting) attrs.listMarkerFormatting = textFormattingToRunFormatting(pmAttrs.listMarkerFormatting, theme, fontAlternates);
+	if (attrs.listMarker !== void 0 || pmAttrs.listMarkerFormatting) {
+		const listMarkerFormatting = listMarkerFormattingFor(pmAttrs.listMarkerFormatting, paragraphMarkFormatting(), theme, fontAlternates);
+		if (listMarkerFormatting) attrs.listMarkerFormatting = listMarkerFormatting;
+	}
 	if (pmAttrs.listMarkerAlignment) attrs.listMarkerAlignment = pmAttrs.listMarkerAlignment;
 	if (pmAttrs.listMarkerSuffix) attrs.listMarkerSuffix = pmAttrs.listMarkerSuffix;
 	if (pmAttrs.listMarkerSecondSlotOffsetTwips !== void 0) attrs.listMarkerSecondSlotOffsetTwips = pmAttrs.listMarkerSecondSlotOffsetTwips;
 	if (!pmAttrs.numPr) {
 		const numberingRemovedChange = propertyChanges.find(isRemovedNumberingChange);
 		if (numberingRemovedChange) {
-			applyDeletedListMarkerAttrs(attrs, numberingRemovedChange, void 0, theme, fontAlternates);
+			applyDeletedListMarkerAttrs(attrs, numberingRemovedChange, void 0, theme, fontAlternates, paragraphMarkFormatting);
 			if (resolvedMarker !== null) {
 				attrs.listMarker = resolvedMarker;
 				attrs.listMarkerRevision = toListMarkerRevision("del", numberingRemovedChange.info);
@@ -1231,6 +1297,18 @@ function hasOnlyHiddenTextRuns(runs) {
 function hasVisibleParagraphPayload(attrs) {
 	return attrs.listMarker !== void 0 && !attrs.listMarkerHidden || attrs.borders?.top !== void 0 || attrs.borders?.bottom !== void 0 || attrs.borders?.left !== void 0 || attrs.borders?.right !== void 0 || attrs.borders?.between !== void 0 || attrs.borders?.bar !== void 0 || attrs.shading !== void 0;
 }
+/** Whether any `w:pBdr` side draws a rule (`none`/`nil` sides draw nothing). */
+function drawsParagraphBorder(borders) {
+	if (!borders) return false;
+	return [
+		borders.top,
+		borders.bottom,
+		borders.left,
+		borders.right,
+		borders.between,
+		borders.bar
+	].some((border) => border?.style !== void 0 && !statesNoBorder(border.style));
+}
 function convertParagraph(node, startPos, options, pageBreaks) {
 	const pmAttrs = expectParagraphAttrs(node);
 	const runs = paragraphToRuns(node, startPos, options, pageBreaks);
@@ -1238,8 +1316,10 @@ function convertParagraph(node, startPos, options, pageBreaks) {
 		theme: options.theme,
 		fontAlternates: options.fontAlternates,
 		listCounterStreams: options.listCounterStreams,
-		defaultTabStopTwips: options.defaultTabStopTwips
+		defaultTabStopTwips: options.defaultTabStopTwips,
+		paragraphMarkFormatting: () => resolveParagraphMarkFormatting(pmAttrs, options.styleResolver)
 	});
+	if (options.numberingTabIgnoresIndent && attrs.listMarker !== void 0) attrs.listNumberingTabIgnoresIndent = true;
 	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;
@@ -1248,8 +1328,9 @@ function convertParagraph(node, startPos, options, pageBreaks) {
 	const defaultTextFormatting = pmAttrs.defaultTextFormatting;
 	if (runs.length === 0 || hasOnlyVisuallyEmptyTextRuns(runs)) {
 		if (pmAttrs._originalFormatting && Object.entries(pmAttrs._originalFormatting).some(([key, value]) => key !== "runProperties" && value !== void 0 && value !== null)) attrs.hasDirectParagraphFormatting = true;
-		const paragraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
-		if (paragraphMarkFormatting && Object.values(paragraphMarkFormatting).some((value) => value !== void 0 && value !== null)) attrs.hasDirectParagraphMarkFormatting = true;
+		const directParagraphMarkFormatting = pmAttrs._originalFormatting?.runProperties;
+		if (directParagraphMarkFormatting && Object.values(directParagraphMarkFormatting).some((value) => value !== void 0 && value !== null)) attrs.hasDirectParagraphMarkFormatting = true;
+		const paragraphMarkFormatting = resolveParagraphMarkOwnFormatting(directParagraphMarkFormatting, options.styleResolver);
 		if (paragraphMarkFormatting?.fontSize !== void 0) attrs.defaultFontSize = paragraphMarkFormatting.fontSize / 2;
 		const paragraphMarkFontFamily = paragraphMarkFormatting?.fontFamily ? resolveWesternThemeFont(paragraphMarkFormatting.fontFamily, options.theme) : void 0;
 		if (paragraphMarkFontFamily) {
@@ -1393,14 +1474,18 @@ function splitParagraphAtPageBreaks({ pageBreaks, paragraph, splitPageBreakAndPa
 		fragmentStart = pageBreak.pmEnd;
 	}
 	const remainingRuns = partitioned.remaining;
+	let paragraphMarkCarrier;
 	if (remainingRuns.length > 0) appendParagraph(remainingRuns, fragmentStart, paragraph.pmEnd ?? fragmentStart);
 	else if (paragraph.runs.length === 0 || splitPageBreakAndParagraphMark && pageBreaks.at(-1)?.pmEnd === (paragraph.pmEnd ?? fragmentStart) - 1) {
 		appendParagraph([], fragmentStart, paragraph.pmEnd ?? fragmentStart);
 		const carrier = result.at(-1);
-		if (carrier?.kind === "paragraph" && !splitPageBreakAndParagraphMark && !hasVisibleParagraphPayload(carrier.attrs ?? {})) carrier.attrs = {
-			...carrier.attrs,
-			suppressEmptyParagraphHeight: true
-		};
+		if (carrier?.kind === "paragraph" && !splitPageBreakAndParagraphMark && !hasVisibleParagraphPayload(carrier.attrs ?? {})) {
+			carrier.attrs = {
+				...carrier.attrs,
+				suppressEmptyParagraphHeight: true
+			};
+			paragraphMarkCarrier = carrier;
+		}
 	}
 	const fragments = result.filter((block) => block.kind === "paragraph");
 	for (let index = 0; index < fragments.length; index += 1) {
@@ -1410,8 +1495,20 @@ function splitParagraphAtPageBreaks({ pageBreaks, paragraph, splitPageBreakAndPa
 		if (attrs) fragment.attrs = attrs;
 		else delete fragment.attrs;
 	}
+	if (paragraphMarkCarrier?.attrs) paragraphMarkCarrier.attrs = withoutParagraphSpacing(paragraphMarkCarrier.attrs);
 	return result;
 }
+function withoutParagraphSpacing(source) {
+	const attrs = { ...source };
+	if (attrs.spacing) {
+		const { before: _before, after: _after, ...lineSpacing } = attrs.spacing;
+		if (Object.keys(lineSpacing).length > 0) attrs.spacing = lineSpacing;
+		else delete attrs.spacing;
+	}
+	delete attrs.automaticSpacing;
+	delete attrs.spacingExplicit;
+	return attrs;
+}
 /**
 * Word keeps a final empty body paragraph after a table as an editable anchor,
 * but that final anchor does not create a page of its own. Earlier authored
@@ -1513,12 +1610,22 @@ function convertTableCell(node, startPos, options, tableCellMargins) {
 	const authoredPageBreakPosition = options.firstPageBreakRunPosition(node);
 	const leadingParagraph = node.firstChild?.type.name === "paragraph" && countPageBreakRuns(node) === 1 && options.firstPageBreakRunPosition(node.firstChild) === authoredPageBreakPosition ? node.firstChild : void 0;
 	const pageBreaks = [];
-	node.forEach((child) => {
+	const convertCellChild = (child, childStart) => {
 		if (child.type.name === "paragraph") {
-			const block = convertParagraph(child, offset, options, child === leadingParagraph ? pageBreaks : void 0);
+			const block = convertParagraph(child, childStart, options, child === leadingParagraph ? pageBreaks : void 0);
 			blocks.push(block);
-		} else if (child.type.name === "table") blocks.push(convertTable(child, offset, options));
-		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, offset, options));
+		} else if (child.type.name === "table") blocks.push(convertTable(child, childStart, options));
+		else if (child.type.name === "textBox") blocks.push(convertTextBoxNode(child, childStart, options));
+		else if (child.type.name === "blockSdt") {
+			let sdtChildStart = childStart + 1;
+			child.forEach((sdtChild) => {
+				convertCellChild(sdtChild, sdtChildStart);
+				sdtChildStart += sdtChild.nodeSize;
+			});
+		}
+	};
+	node.forEach((child) => {
+		convertCellChild(child, offset);
 		offset += child.nodeSize;
 	});
 	const trailingBlock = blocks.at(-1);
@@ -1669,6 +1776,8 @@ function convertTable(node, startPos, options) {
 	if (originalFormatting?.layout !== void 0) tableBlock.layout = originalFormatting.layout;
 	if (justification) tableBlock.justification = justification;
 	if (indentPx !== void 0) tableBlock.indent = indentPx;
+	const cellSpacing = originalFormatting?.cellSpacing;
+	if (cellSpacing?.type === "dxa" && cellSpacing.value > 0) tableBlock.cellSpacing = twipsToPixels(cellSpacing.value);
 	if (options.tableIndentCompatibility && !dropsAuthoredIndent) tableBlock.indentCompatibility = options.tableIndentCompatibility;
 	if (floatingPx) tableBlock.floating = floatingPx;
 	if (rightToLeft) tableBlock.bidi = true;
@@ -1718,6 +1827,26 @@ function convertImage(node, startPos, pageContentHeight) {
 	if (imageBorderStyle) imgBlock.borderStyle = imageBorderStyle;
 	return imgBlock;
 }
+const EMUS_PER_PIXEL = 9525;
+/**
+* The `wp:effectExtent` of an inline (`wp:inline`) box, in unrounded pixels.
+*
+* An inline object occupies its extent plus the effect extent on every side,
+* so the box itself sits `l`/`t` inside the space the line gives it. On a
+* `wp:anchor` the position offsets already locate the shape's own extent, so
+* the reservation only affects wrapping and is not applied here.
+*/
+function inlineEffectExtentPx(wrapType, extent) {
+	if (wrapType !== void 0 && wrapType !== "inline" || extent === void 0) return;
+	const px = (emu) => Math.max(0, (emu ?? 0) / EMUS_PER_PIXEL);
+	const resolved = {
+		top: px(extent.top),
+		bottom: px(extent.bottom),
+		left: px(extent.left),
+		right: px(extent.right)
+	};
+	return resolved.top === 0 && resolved.bottom === 0 && resolved.left === 0 && resolved.right === 0 ? void 0 : resolved;
+}
 /** Convert a textBox PM node to a TextBoxBlock. */
 function convertTextBoxNode(node, startPos, opts) {
 	const attrs = expectTextBoxAttrs(node);
@@ -1763,6 +1892,19 @@ function convertTextBoxNode(node, startPos, opts) {
 	if (attrs.distLeft !== void 0) textBox.distLeft = attrs.distLeft;
 	if (attrs.distRight !== void 0) textBox.distRight = attrs.distRight;
 	if (attrs.position !== void 0) textBox.position = attrs.position;
+	const effectExtent = inlineEffectExtentPx(attrs.wrapType, attrs.wrapEffectExtentSlots?.drawing);
+	if (effectExtent !== void 0) textBox.effectExtent = effectExtent;
+	const host = textBoxHostParagraph(node);
+	if (host && attrs.position === void 0 && (attrs.wrapType ?? "inline") === "inline") {
+		const hostAttrs = expectParagraphAttrs(host);
+		textBox.hostParagraph = convertParagraphAttrs(hostAttrs, {
+			theme: opts.theme,
+			fontAlternates: opts.fontAlternates,
+			listCounterStreams: opts.listCounterStreams,
+			defaultTabStopTwips: opts.defaultTabStopTwips,
+			paragraphMarkFormatting: () => resolveParagraphMarkFormatting(hostAttrs, opts.styleResolver)
+		});
+	}
 	if (attrs._docxGroupId !== void 0) setTextBoxGroupId(textBox, attrs._docxGroupId);
 	const anchorBlockId = attrs._docxAnchorId ? opts.textBoxAnchorBlockIds.get(attrs._docxAnchorId) : void 0;
 	if (anchorBlockId !== void 0) Reflect.set(textBox, TEXT_BOX_ANCHOR_BLOCK_ID, anchorBlockId);
@@ -1804,8 +1946,12 @@ function applySectionStartsToBoundaries(blocks, finalSectionStart) {
 * continuous section resumes there too. Accept both the legacy generated
 * carrier and the inline atom's one-token paragraph-mark fragment; neither is
 * a physical layout boundary.
+*
+* A section break in `breaksWithoutMarker` ends at an empty w:sectPr paragraph
+* that projected no block, so a page break just before it ends an earlier
+* paragraph and still starts the next page.
 */
-function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreakAndParagraphMark) {
+function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreakAndParagraphMark, breaksWithoutMarker) {
 	if (splitPageBreakAndParagraphMark) return [...blocks];
 	const result = [];
 	for (let index = 0; index < blocks.length; index += 1) {
@@ -1815,8 +1961,8 @@ function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreak
 		const isLegacyGeneratedCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmStart !== void 0 && block.pmStart === carrier.pmStart && carrier.pmStart === carrier.pmEnd;
 		const isInlineParagraphMarkCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmEnd !== void 0 && carrier.pmStart === block.pmEnd && carrier.pmEnd === block.pmEnd + 1;
 		const isUnresolvedInsertion = block?.kind === "pageBreak" && block.isInsertion === true;
-		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && carrier?.kind === "sectionBreak" && carrier.type === "continuous") continue;
-		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && (isLegacyGeneratedCarrier || isInlineParagraphMarkCarrier) && section?.kind === "sectionBreak" && section.type === "continuous") {
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && carrier?.kind === "sectionBreak" && carrier.type === "continuous" && !breaksWithoutMarker.has(carrier.id)) continue;
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && (isLegacyGeneratedCarrier || isInlineParagraphMarkCarrier) && section?.kind === "sectionBreak" && section.type === "continuous" && !breaksWithoutMarker.has(section.id)) {
 			index += 1;
 			continue;
 		}
@@ -1884,6 +2030,7 @@ function toFlowBlocks(doc, options = {}) {
 		},
 		firstPageBreakRunPosition,
 		textBoxAnchorBlockIds: /* @__PURE__ */ new Map(),
+		numberingTabIgnoresIndent: doc.attrs["_doNotUseIndentAsNumberingTabStop"] === true,
 		styleResolver: createStyleEngine(options.styles),
 		numberedRefResults: resolveNumberedRefFields(doc, {
 			listCounterState: cloneListCounterState(listCounterState),
@@ -1917,11 +2064,72 @@ function toFlowBlocks(doc, options = {}) {
 		const pageBreaks = [];
 		const paragraph = convertParagraph(node, pos, opts, pageBreaks);
 		if (stripLeadingLineBreak && paragraph.runs.at(0)?.kind === "lineBreak") paragraph.runs.shift();
-		for (const block of splitParagraphAtPageBreaks({
+		const projected = splitParagraphAtPageBreaks({
 			pageBreaks,
 			paragraph,
 			splitPageBreakAndParagraphMark: options.splitPageBreakAndParagraphMark === true
-		})) trackedPush(block);
+		});
+		if (pageBreaks.length > 0) placeTextBoxAnchorsBeforePageBreaks(node, pos, projected);
+		for (const block of projected) trackedPush(block);
+	};
+	/** Blocks emitted before the current section's first block. */
+	let sectionStartBlockCount = 0;
+	/** Section breaks whose empty w:sectPr paragraph projected no block. */
+	const sectionBreaksWithoutMarker = /* @__PURE__ */ new Set();
+	/**
+	* The page break a text box anchored in an earlier part of its paragraph
+	* must be laid out before, keyed by `_docxAnchorId`.
+	*/
+	const textBoxPageBreakByAnchorId = /* @__PURE__ */ new Map();
+	/** Text boxes held back until every block is projected. */
+	const textBoxesBeforePageBreak = /* @__PURE__ */ new Map();
+	/**
+	* An anchored object sits on the page holding its anchor run. When that run
+	* precedes a `w:br w:type="page"` in the same paragraph, the object belongs
+	* to the page the break ends. Either way its paragraph-relative position is
+	* measured from the part of the paragraph holding the anchor.
+	*/
+	const placeTextBoxAnchorsBeforePageBreaks = (node, pos, projected) => {
+		let breakIndex = 0;
+		node.descendants((child, childOffset) => {
+			if (child.type.name !== "textBoxAnchor") return true;
+			const anchorPos = pos + 1 + childOffset;
+			while (breakIndex < projected.length) {
+				const block = projected[breakIndex];
+				if (block?.kind === "pageBreak" && (block.pmStart ?? 0) > anchorPos) break;
+				breakIndex += 1;
+			}
+			const { anchorId } = expectTextBoxAnchorAttrs(child);
+			const pageBreak = projected[breakIndex];
+			if (pageBreak?.kind === "pageBreak") textBoxPageBreakByAnchorId.set(anchorId, pageBreak);
+			const anchorFragment = pageBreak ? projected[breakIndex - 1] : projected.at(-1);
+			if (anchorFragment?.kind === "paragraph") opts.textBoxAnchorBlockIds.set(anchorId, anchorFragment.id);
+			else opts.textBoxAnchorBlockIds.delete(anchorId);
+			return false;
+		});
+	};
+	const pushTextBox = (node, pos) => {
+		const textBox = convertTextBoxNode(node, pos, opts);
+		const anchorId = expectTextBoxAttrs(node)._docxAnchorId;
+		const pageBreak = anchorId === void 0 ? void 0 : textBoxPageBreakByAnchorId.get(anchorId);
+		if (!pageBreak) {
+			trackedPush(textBox);
+			return;
+		}
+		tagBlockWithSdtStack(textBox);
+		const heldBack = textBoxesBeforePageBreak.get(pageBreak);
+		if (heldBack) heldBack.push(textBox);
+		else textBoxesBeforePageBreak.set(pageBreak, [textBox]);
+	};
+	/** Put every held-back text box just before its page break, in one pass. */
+	const releaseTextBoxesBeforePageBreaks = () => {
+		if (textBoxesBeforePageBreak.size === 0) return;
+		const inFlowOrder = blocks.splice(0);
+		for (const block of inFlowOrder) {
+			const heldBack = block.kind === "pageBreak" ? textBoxesBeforePageBreak.get(block) : void 0;
+			for (const textBox of heldBack ?? []) blocks.push(textBox);
+			blocks.push(block);
+		}
 	};
 	const trailingPageBreakSectionPositions = /* @__PURE__ */ new Set();
 	const consumedPageBreakPositions = /* @__PURE__ */ new Set();
@@ -2004,7 +2212,11 @@ function toFlowBlocks(doc, options = {}) {
 				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";
-				if (node.childCount === 1 && startsWithColumnBreak) {
+				const isStandaloneColumnBreak = node.childCount === 1 && startsWithColumnBreak;
+				const isEmptySectionMark = hasSectionBreak && node.content.size === 0;
+				const opensSection = blocks.length === sectionStartBlockCount;
+				let markerDropped = false;
+				if (isStandaloneColumnBreak) {
 					const columnBreak = {
 						kind: "columnBreak",
 						id: nextBlockId(),
@@ -2021,7 +2233,12 @@ function toFlowBlocks(doc, options = {}) {
 					};
 					trackedPush(columnBreak);
 					pushParagraphProjection(node, pos, true);
-				} else if (node.content.size > 0 || hasListFormatting || !hasSectionBreak) pushParagraphProjection(node, pos);
+				} else if (!isEmptySectionMark) pushParagraphProjection(node, pos);
+				else if (hasListFormatting || drawsParagraphBorder(pmAttrs.borders) || opensSection) {
+					pushParagraphProjection(node, pos);
+					const mark = blocks.at(-1);
+					if (!opensSection && mark?.kind === "paragraph" && mark.attrs?.pageBreakBefore) delete mark.attrs.pageBreakBefore;
+				} else markerDropped = true;
 				if (hasSectionBreak) {
 					if (trailingPageBreakSectionPositions.has(pos)) {
 						const sourceParagraph = blocks.at(-1);
@@ -2093,6 +2310,8 @@ function toFlowBlocks(doc, options = {}) {
 						if (columns) sectionBreak.columns = columns;
 					}
 					trackedPush(sectionBreak);
+					sectionStartBlockCount = blocks.length;
+					if (markerDropped) sectionBreaksWithoutMarker.add(sectionBreak.id);
 				}
 				break;
 			}
@@ -2105,7 +2324,7 @@ function toFlowBlocks(doc, options = {}) {
 				break;
 			}
 			case "textBox":
-				trackedPush(convertTextBoxNode(node, pos, opts));
+				pushTextBox(node, pos);
 				break;
 			case "horizontalRule":
 			case "pageBreak": {
@@ -2125,15 +2344,19 @@ function toFlowBlocks(doc, options = {}) {
 	doc.forEach((node, nodeOffset) => {
 		visit(node, offset + nodeOffset);
 	});
+	releaseTextBoxesBeforePageBreaks();
 	reserveLeadingEmptyOutlineHeight(blocks);
-	suppressFinalEmptyParagraphAfterTable(blocks);
-	suppressFinalParagraphInRepeatedEmptySuffix(blocks);
+	const trailingEndnoteIds = options.trailingEndnoteIds;
+	if (!(trailingEndnoteIds !== void 0 && trailingEndnoteIds.size > 0 && collectNoteRefs(blocks, "endnoteRefId").some(({ noteId }) => trailingEndnoteIds.has(noteId)))) {
+		suppressFinalEmptyParagraphAfterTable(blocks);
+		suppressFinalParagraphInRepeatedEmptySuffix(blocks);
+	}
 	const mergedBlocks = mergeRunInParagraphs(blocks);
 	const tableCellLinePitch = doc.attrs["_adjustLineHeightInTable"] === true ? "sectionGrid" : void 0;
 	return groupParagraphFrames(coalesceTrailingPageBreakBeforeContinuousSection(applySectionStartsToBoundaries(applySectionDocumentGrid(mergedBlocks, {
 		finalLinePitchTwips: opts.finalSectionDocumentGridLinePitchTwips,
 		tableCellLinePitch
-	}), readFinalSectionStart(doc)), options.splitPageBreakAndParagraphMark === true), nextBlockId);
+	}), readFinalSectionStart(doc)), options.splitPageBreakAndParagraphMark === true, sectionBreaksWithoutMarker), nextBlockId);
 }
 function applySectionDocumentGrid(blocks, { finalLinePitchTwips, tableCellLinePitch }) {
 	const result = [...blocks];
@@ -2234,4 +2457,4 @@ function mergeRunInParagraphs(blocks) {
 	return out;
 }
 //#endregion
-export { WORD_UNSPECIFIED_FONT_SIZE, convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };
+export { WORD_UNSPECIFIED_FONT_SIZE, collectNoteRefs, convertBorderSpecToLayout, formatCounter, isNoteReferenceMarkXml, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };

package/dist/layout-bridge/engine/hitTest.js

@@ -1,7 +1,7 @@
 import { getHeaderRowsHeight } from "../../layout-engine/index.js";
 import { measuredLineRangeHeight } from "../../layout-engine/lineFlow.js";
 import { getTableCellContentWidth } from "../../layout-engine/measure/tableCellFloating.js";
-import { buildTableCellGrid, buildTableCellPlacements } from "../../layout-engine/measure/tableCellGrid.js";
+import { buildTableCellGrid, buildTableCellPlacements, getTableCellSpacingInsetsY } from "../../layout-engine/measure/tableCellGrid.js";
 import { resolveTableCellPadding } from "../../layout-engine/types.js";
 //#region src/layout-bridge/engine/hitTest.ts
 /**
@@ -222,7 +222,8 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 		const cellPlacements = buildTableCellPlacements({
 			grid: buildTableCellGrid(tableBlock.rows, tableMeasure.columnWidths.length),
 			columnWidths: tableMeasure.columnWidths,
-			bidi: tableBlock.bidi === true
+			bidi: tableBlock.bidi === true,
+			cellSpacing: tableBlock.cellSpacing
 		});
 		let nearestDistance = Infinity;
 		for (let c = 0; c < row.cells.length; c++) {
@@ -267,7 +268,8 @@ function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
 		const cellLocalX = localX - cellLeft - padLeft;
 		const cellContentWidth = getTableCellContentWidth(cell, cellMeasure);
 		const clipOffset = isClickOnHeader ? 0 : tableFragment.topClip ?? 0;
-		const cellLocalY = localY - rowTop + clipOffset;
+		const cellSpacingTop = getTableCellSpacingInsetsY(tableBlock.cellSpacing, rowIndex, cell.rowSpan ?? 1, tableBlock.rows.length).top;
+		const cellLocalY = localY - rowTop + clipOffset - cellSpacingTop;
 		return {
 			fragment: tableFragment,
 			block: tableBlock,

package/dist/layout-bridge/engine/selectionRects.js

@@ -4,7 +4,7 @@ import { buildRunFontStyle } from "../../layout-engine/measure/measureHelpers.js
 import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
 import { measureRun } from "../../layout-engine/measure/measureProvider.js";
 import { buildTableCellFloatingZones, getTableCellContentWidth, getTableCellFloatingImages } from "../../layout-engine/measure/tableCellFloating.js";
-import { buildTableCellGrid, buildTableCellPlacements } from "../../layout-engine/measure/tableCellGrid.js";
+import { buildTableCellGrid, buildTableCellPlacements, getTableCellSpacingInsetsY } from "../../layout-engine/measure/tableCellGrid.js";
 import { resolveTableCellPadding } from "../../layout-engine/types.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
 import { resolvePhysicalParagraphInlineLayout } from "../../utils/paragraphInlineLayout.js";
@@ -312,7 +312,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 					cellPlacements = buildTableCellPlacements({
 						grid: buildTableCellGrid(tableBlock.rows, tableMeasure.columnWidths.length),
 						columnWidths: tableMeasure.columnWidths,
-						bidi: tableBlock.bidi === true
+						bidi: tableBlock.bidi === true,
+						cellSpacing: tableBlock.cellSpacing
 					});
 					tableCellPlacements.set(tableBlock, cellPlacements);
 				}
@@ -333,7 +334,8 @@ function selectionToRects(layout, blocks, measures, from, to) {
 						const contentWidth = getTableCellContentWidth(cell, cellMeasure);
 						const floatingZones = buildTableCellFloatingZones(getTableCellFloatingImages(cell, cellMeasure, contentWidth), contentWidth);
 						const contentOffsetX = getCellContentOffsetX(cell);
-						const contentOffsetY = getCellContentOffsetY(cell, cellMeasure, rowMeasure.height);
+						const spacing = getTableCellSpacingInsetsY(tableBlock.cellSpacing, rowIndex, cell.rowSpan ?? 1, tableBlock.rows.length);
+						const contentOffsetY = spacing.top + getCellContentOffsetY(cell, cellMeasure, Math.max(0, rowMeasure.height - spacing.top - spacing.bottom));
 						let blockY = 0;
 						for (let blockIdx = 0; blockIdx < cell.blocks.length; blockIdx++) {
 							const cellBlock = cell.blocks[blockIdx];

package/dist/layout-engine/anchorLayoutInCellCompatibility.d.ts

@@ -0,0 +1,10 @@
+//#region src/layout-engine/anchorLayoutInCellCompatibility.d.ts
+/**
+ * `true` when the document's compatibility mode forces every table-cell
+ * anchor to lay out inside its cell, ignoring an authored
+ * `layoutInCell="0"`. `false` means the authored attribute (or its
+ * OOXML default of "confined to the cell") should be honoured as stated.
+ */
+declare const resolveAnchorLayoutInCellCompatibility: (compatibilityMode: number | undefined) => boolean;
+//#endregion
+export { resolveAnchorLayoutInCellCompatibility };

package/dist/layout-engine/anchorLayoutInCellCompatibility.js

@@ -0,0 +1,22 @@
+//#region src/layout-engine/anchorLayoutInCellCompatibility.ts
+/**
+* First `compatibilityMode` that ignores `wp:anchor/@layoutInCell="0"`.
+*
+* From `compatibilityMode` 15 onward, an anchor inside a table cell is laid
+* out in the cell regardless of what `wp:anchor/@layoutInCell` states: the
+* attribute stops opting the anchor out of the cell's coordinate space.
+* Earlier modes still honour an explicit `layoutInCell="0"` and let the
+* anchor position itself relative to the page. A document that declares no
+* `compatSetting` at all is read with the oldest semantics, so it honours
+* the attribute too.
+*/
+const FIRST_ALWAYS_IN_CELL_COMPATIBILITY_MODE = 15;
+/**
+* `true` when the document's compatibility mode forces every table-cell
+* anchor to lay out inside its cell, ignoring an authored
+* `layoutInCell="0"`. `false` means the authored attribute (or its
+* OOXML default of "confined to the cell") should be honoured as stated.
+*/
+const resolveAnchorLayoutInCellCompatibility = (compatibilityMode) => compatibilityMode !== void 0 && compatibilityMode >= FIRST_ALWAYS_IN_CELL_COMPATIBILITY_MODE;
+//#endregion
+export { resolveAnchorLayoutInCellCompatibility };