@stll/folio-core 0.47.6 → 0.48.0

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

@@ -0,0 +1,227 @@
+import { calculateColumnWidths } from "../../layout-engine/paginator.js";
+import { resolveEffectiveParagraphSpacingTree } from "../../layout-engine/paragraphSpacing.js";
+import { stripFlowBlockPmAnchors } from "../../layout-engine/types.js";
+import { getMargins, getPageSize } from "../../paged-layout/sectionGeometry.js";
+import { getColumns } from "../sectionColumns.js";
+import { collectEndnoteRefs, convertFootnoteToContent, convertNoteStoryToFlowBlocks } from "./footnoteLayout.js";
+import { panic } from "better-result";
+//#region src/layout-bridge/convert/endnoteLayout.ts
+/**
+* Endnote areas (ECMA-376 §17.11).
+*
+* Endnotes are not reserved per page the way footnotes are. `w:pos` puts them
+* after the last body block of the document (`docEnd`, the default) or of each
+* section (`sectEnd`), where they paginate as body content does: they are
+* spliced into the body's block list and the same measure and paginate path
+* places them. Each area opens with the `w:separator` endnote story, and every
+* page it continues onto opens with the `w:continuationSeparator` story. The
+* parsed model keeps only normal notes, so both stories are the ones a package
+* is written with: one paragraph, no space after, single line spacing, holding
+* the separator mark.
+*
+* A note's blocks carry positions in the note's own document, so they are
+* stripped of them before joining the body flow: a click, a caret or a
+* selection in the body must never resolve into a note. The painted note is
+* addressed by its story instead, which is what the note editor opens.
+*/
+/**
+* The separator story a notes part is written with (folio writes it too):
+* `<w:p><w:pPr><w:spacing w:after="0" w:line="240" w:lineRule="auto"/></w:pPr>`
+* around the mark run, in the document's default paragraph style.
+*/
+const SEPARATOR_STORY = [{
+	type: "paragraph",
+	formatting: {
+		spaceAfter: 0,
+		lineSpacing: 240,
+		lineSpacingRule: "auto"
+	},
+	content: []
+}];
+/**
+* Convert and measure every referenced endnote into the areas `w:pos` asks
+* for. `undefined` when no reference names a note, so a document without
+* endnotes lays out exactly as it did before.
+*/
+function prepareEndnoteAreas(input) {
+	const notesById = /* @__PURE__ */ new Map();
+	for (const note of input.endnotes ?? []) if (note.noteType === "normal") notesById.set(note.id, note);
+	if (notesById.size === 0 || input.displayNumbers.size === 0) return;
+	const finalSection = countSectionBreaks(input.blocks);
+	const referenceSection = firstReferenceSections(input.blocks);
+	const notesBySection = /* @__PURE__ */ new Map();
+	for (const noteId of input.displayNumbers.keys()) {
+		if (!notesById.has(noteId)) continue;
+		const section = input.position === "sectEnd" ? collectingSection(referenceSection.get(noteId) ?? finalSection, finalSection, input) : finalSection;
+		const noteIds = notesBySection.get(section) ?? [];
+		noteIds.push(noteId);
+		notesBySection.set(section, noteIds);
+	}
+	const separatorBlockIds = /* @__PURE__ */ new Map();
+	const contentBlockIds = /* @__PURE__ */ new Set();
+	const noteStoryByBlockId = /* @__PURE__ */ new Map();
+	const areas = [];
+	for (const [section, noteIds] of [...notesBySection].sort(([left], [right]) => left - right)) {
+		const width = endnoteAreaWidth(section === finalSection ? input.sections.at(-1) : input.sections[section]);
+		const separator = convertSeparatorStory(`${`endnote-area-${String(section)}`}-separator`, width, input.options);
+		const blocks = [{
+			...separator.block,
+			attrs: {
+				...separator.block.attrs,
+				keepNext: true
+			}
+		}];
+		const measures = [separator.measure];
+		separatorBlockIds.set(String(separator.block.id), "separator");
+		for (const noteId of noteIds) {
+			const content = convertFootnoteToContent(notesById.get(noteId), input.displayNumbers.get(noteId) ?? 0, width, {
+				...input.options,
+				displayText: input.displayTexts.get(noteId) ?? String(noteId)
+			});
+			for (const [index, block] of content.blocks.entries()) {
+				const id = `endnote-${String(noteId)}-${String(index)}`;
+				blocks.push(withId(stripFlowBlockPmAnchors(block), id));
+				measures.push(content.measures[index]);
+				contentBlockIds.add(id);
+				noteStoryByBlockId.set(id, {
+					kind: "endnote",
+					noteId
+				});
+			}
+		}
+		areas.push({
+			beforeSectionBreak: section === finalSection ? null : section,
+			blocks: resolveEffectiveParagraphSpacingTree(blocks),
+			measures
+		});
+	}
+	const continuationSeparator = convertSeparatorStory("endnote-continuation-separator", endnoteAreaWidth(input.sections.at(-1)), input.options);
+	separatorBlockIds.set(String(continuationSeparator.block.id), "continuationSeparator");
+	return {
+		areas,
+		noteAreas: {
+			separatorBlockIds,
+			contentBlockIds,
+			continuationSeparator
+		},
+		noteStoryByBlockId
+	};
+}
+/**
+* The body blocks with each endnote area in place: before the section break
+* that ends the section it follows, or after the last body block.
+*/
+function spliceEndnoteAreas(blocks, measures, prepared) {
+	if (prepared === void 0 || prepared.areas.length === 0) return {
+		blocks,
+		measures
+	};
+	const areasByBreak = /* @__PURE__ */ new Map();
+	let documentEndArea;
+	for (const area of prepared.areas) if (area.beforeSectionBreak === null) documentEndArea = area;
+	else areasByBreak.set(area.beforeSectionBreak, area);
+	const splicedBlocks = [];
+	const splicedMeasures = [];
+	let sectionBreakIndex = 0;
+	for (const [index, block] of blocks.entries()) {
+		if (block.kind === "sectionBreak") {
+			const area = areasByBreak.get(sectionBreakIndex);
+			if (area !== void 0) {
+				splicedBlocks.push(...area.blocks);
+				splicedMeasures.push(...area.measures);
+			}
+			sectionBreakIndex += 1;
+		}
+		splicedBlocks.push(block);
+		splicedMeasures.push(measures[index]);
+	}
+	if (documentEndArea !== void 0) {
+		splicedBlocks.push(...documentEndArea.blocks);
+		splicedMeasures.push(...documentEndArea.measures);
+	}
+	return {
+		blocks: splicedBlocks,
+		measures: splicedMeasures
+	};
+}
+/**
+* The endnotes a `docEnd` area collects after the body's last block, for
+* `toFlowBlocks`' `trailingEndnoteIds`. Empty for `sectEnd`, whose final area
+* depends on where the references fall.
+*/
+function trailingEndnoteIds(endnotes, position) {
+	if (position !== "docEnd") return /* @__PURE__ */ new Set();
+	return new Set((endnotes ?? []).flatMap((note) => note.noteType === "normal" ? [note.id] : []));
+}
+/** `w:pos` for the document: the settings value, else the final section's. */
+function resolveEndnotePosition(settingsPosition, finalSection) {
+	return settingsPosition ?? finalSection?.endnotePr?.position ?? "docEnd";
+}
+/** The first column's width in a section: what an endnote area there wraps to. */
+function endnoteAreaWidth(section) {
+	const pageSize = getPageSize(section);
+	const margins = getMargins(section);
+	const [firstColumn] = calculateColumnWidths(pageSize.w, margins.left, margins.right, getColumns(section) ?? {
+		count: 1,
+		gap: 0
+	});
+	return firstColumn ?? pageSize.w - margins.left - margins.right;
+}
+function countSectionBreaks(blocks) {
+	let count = 0;
+	for (const block of blocks) if (block.kind === "sectionBreak") count += 1;
+	return count;
+}
+/** The section each endnote is first referenced in. */
+function firstReferenceSections(blocks) {
+	const sections = /* @__PURE__ */ new Map();
+	let section = 0;
+	for (const block of blocks) {
+		if (block.kind === "sectionBreak") {
+			section += 1;
+			continue;
+		}
+		for (const { endnoteId } of collectEndnoteRefs([block])) if (!sections.has(endnoteId)) sections.set(endnoteId, section);
+	}
+	return sections;
+}
+/**
+* The section whose end collects a note referenced in `section`: a section
+* with `w:noEndnote` passes its endnotes on to the next section that shows
+* them, and the document's end collects whatever is left.
+*/
+function collectingSection(section, finalSection, input) {
+	let target = section;
+	while (target < finalSection && input.sections[target]?.noEndnote === true) target += 1;
+	return target;
+}
+/** A separator story's paragraph, converted and measured as a note's text is. */
+function convertSeparatorStory(id, width, options) {
+	const converted = convertNoteStoryToFlowBlocks(SEPARATOR_STORY, options).flowBlocks.at(0);
+	const block = converted?.kind === "paragraph" ? {
+		...converted,
+		id
+	} : {
+		kind: "paragraph",
+		id,
+		runs: [{
+			kind: "text",
+			text: ""
+		}]
+	};
+	const [measure] = options.measureBlocks([block], width);
+	if (measure?.kind !== "paragraph") panic("An endnote separator paragraph must measure as a paragraph");
+	const { pmStart: _pmStart, pmEnd: _pmEnd, ...detached } = block;
+	return {
+		block: detached,
+		measure
+	};
+}
+function withId(block, id) {
+	return {
+		...block,
+		id
+	};
+}
+//#endregion
+export { endnoteAreaWidth, prepareEndnoteAreas, resolveEndnotePosition, spliceEndnoteAreas, trailingEndnoteIds };

package/dist/layout-bridge/convert/footnoteLayout.d.ts

@@ -15,6 +15,12 @@ type ConvertFootnoteOptions = {
   justificationCompatibility?: ToFlowBlocksOptions["justificationCompatibility"];
   tableIndentCompatibility?: ToFlowBlocksOptions["tableIndentCompatibility"];
   automaticHyphenation?: ToFlowBlocksOptions["automaticHyphenation"];
+  /**
+   * The note's reference text, when it is not the plain display number: an
+   * endnote's number in its `w:numFmt` (`i`, `ii`, …). The note shows the same
+   * text as its reference mark in the body.
+   */
+  displayText?: string;
 };
 /**
  * Scan FlowBlocks for runs with footnoteRefId set.
@@ -82,8 +88,18 @@ declare function mapFootnotesToPages(pages: Page[], footnoteRefs: {
  * Convert a Footnote's content paragraphs to FlowBlocks suitable for rendering.
  * Prepends the display number to the first run of the first paragraph.
  */
-declare function convertFootnoteToContent(footnote: document_d_exports.Footnote, displayNumber: number, contentWidth: number, options?: ConvertFootnoteOptions): FootnoteContent;
-declare function applyFootnotePresentation(blocks: FlowBlock[], displayNumber: number): FlowBlock[];
+declare function convertFootnoteToContent(footnote: document_d_exports.Footnote | document_d_exports.Endnote, displayNumber: number, contentWidth: number, options?: ConvertFootnoteOptions): FootnoteContent;
+/**
+ * A note story's content as flow blocks, through the same projection and
+ * conversion a note's text takes. `referenceMarkText` is what the story's own
+ * `w:footnoteRef`/`w:endnoteRef` mark shows; a story without one (a separator
+ * story) is converted as authored.
+ */
+declare function convertNoteStoryToFlowBlocks(content: document_d_exports.Footnote["content"], options: ConvertFootnoteOptions, referenceMarkText?: string): {
+  flowBlocks: FlowBlock[];
+  hasReferenceMark: boolean;
+};
+declare function applyFootnotePresentation(blocks: FlowBlock[], displayNumber: number | string): FlowBlock[];
 /**
  * Build footnote content for all footnotes referenced in the document.
  * Returns a Map<footnoteId, FootnoteContent>.
@@ -99,4 +115,4 @@ declare function calculateFootnoteReservedHeights(pageFootnoteMap: Map<number, n
   height: number;
 }>): Map<number, number>;
 //#endregion
-export { ConvertFootnoteOptions, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, MeasureBlocksFn, NoteDisplayNumberMaps, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectEndnoteRefs, collectFootnoteRefs, computeNoteDisplayNumbers, convertFootnoteToContent, mapFootnotesToPages, remapNoteMarkerText };
+export { ConvertFootnoteOptions, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, MeasureBlocksFn, NoteDisplayNumberMaps, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectEndnoteRefs, collectFootnoteRefs, computeNoteDisplayNumbers, convertFootnoteToContent, convertNoteStoryToFlowBlocks, mapFootnotesToPages, remapNoteMarkerText };

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

@@ -1,8 +1,9 @@
 import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
 import { layoutTextBoxContent } from "../../layout-engine/measure/textBoxParagraphLayout.js";
 import { DEFAULT_TEXTBOX_MARGINS, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, isFloatingImageRun, resolveTableWidthPx } from "../../layout-engine/types.js";
+import { expectPreservedXmlAttrs } from "../../prosemirror/attrs/index.js";
 import { footnoteToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
-import { toFlowBlocks } from "./toFlowBlocks.js";
+import { collectNoteRefs, isNoteReferenceMarkXml, toFlowBlocks } from "./toFlowBlocks.js";
 //#region src/layout-bridge/convert/footnoteLayout.ts
 /** Default footnote font size in points */
 const FOOTNOTE_FONT_SIZE = 8;
@@ -32,23 +33,6 @@ function collectEndnoteRefs(blocks) {
 		pmPos
 	}));
 }
-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;
-}
 /**
 * Assign sequential display numbers (1, 2, 3, …) to notes in order of first
 * reference. Word numbers footnotes/endnotes by reference order, not by their
@@ -192,10 +176,33 @@ function mapFootnotesToPages(pages, footnoteRefs) {
 * Prepends the display number to the first run of the first paragraph.
 */
 function convertFootnoteToContent(footnote, displayNumber, contentWidth, options = {}) {
+	const displayText = options.displayText ?? String(displayNumber);
+	const { flowBlocks, hasReferenceMark } = convertNoteStoryToFlowBlocks(footnote.content, options, displayText);
+	const blocks = hasReferenceMark ? flowBlocks.map(applyFootnoteBlockPresentation) : applyFootnotePresentation(flowBlocks, displayText);
+	const measures = options.measureBlocks ? options.measureBlocks(blocks, contentWidth) : measureFootnoteBlocks(blocks, contentWidth);
+	let totalHeight = 0;
+	for (const measure of measures) if (measure.kind === "paragraph") totalHeight += measure.totalHeight;
+	else if (measure.kind === "table") totalHeight += measure.totalHeight;
+	else if (measure.kind === "image" || measure.kind === "textBox") totalHeight += measure.height;
+	return {
+		id: footnote.id,
+		displayNumber,
+		blocks,
+		measures,
+		height: totalHeight
+	};
+}
+/**
+* A note story's content as flow blocks, through the same projection and
+* conversion a note's text takes. `referenceMarkText` is what the story's own
+* `w:footnoteRef`/`w:endnoteRef` mark shows; a story without one (a separator
+* story) is converted as authored.
+*/
+function convertNoteStoryToFlowBlocks(content, options, referenceMarkText) {
 	const proseOptions = {};
 	if (options.styles) proseOptions.styles = options.styles;
 	if (options.theme !== void 0) proseOptions.theme = options.theme;
-	const pmDoc = footnoteToProseDoc(footnote.content, proseOptions);
+	const pmDoc = footnoteToProseDoc(content, proseOptions);
 	const flowOptions = {};
 	if (options.defaultSize !== void 0) flowOptions.defaultSize = options.defaultSize;
 	if (options.styles) flowOptions.styles = options.styles;
@@ -206,20 +213,22 @@ function convertFootnoteToContent(footnote, displayNumber, contentWidth, options
 	if (options.justificationCompatibility) flowOptions.justificationCompatibility = options.justificationCompatibility;
 	if (options.tableIndentCompatibility) flowOptions.tableIndentCompatibility = options.tableIndentCompatibility;
 	if (options.automaticHyphenation) flowOptions.automaticHyphenation = options.automaticHyphenation;
-	const blocks = applyFootnotePresentation(preserveAuthoredFootnoteTerminalParagraph(toFlowBlocks(pmDoc, flowOptions)), displayNumber);
-	const measures = options.measureBlocks ? options.measureBlocks(blocks, contentWidth) : measureFootnoteBlocks(blocks, contentWidth);
-	let totalHeight = 0;
-	for (const measure of measures) if (measure.kind === "paragraph") totalHeight += measure.totalHeight;
-	else if (measure.kind === "table") totalHeight += measure.totalHeight;
-	else if (measure.kind === "image" || measure.kind === "textBox") totalHeight += measure.height;
+	const hasReferenceMark = containsNoteReferenceMark(pmDoc);
+	if (hasReferenceMark && referenceMarkText !== void 0) flowOptions.noteReferenceMarkText = referenceMarkText;
 	return {
-		id: footnote.id,
-		displayNumber,
-		blocks,
-		measures,
-		height: totalHeight
+		flowBlocks: preserveAuthoredFootnoteTerminalParagraph(toFlowBlocks(pmDoc, flowOptions)),
+		hasReferenceMark
 	};
 }
+function containsNoteReferenceMark(doc) {
+	let found = false;
+	doc.descendants((node) => {
+		if (found) return false;
+		if (node.type.name === "preservedXml" && isNoteReferenceMarkXml(expectPreservedXmlAttrs(node).xml)) found = true;
+		return !found;
+	});
+	return found;
+}
 /** Restore an authored footnote line that the body-only terminal-table policy collapsed. */
 function preserveAuthoredFootnoteTerminalParagraph(blocks) {
 	const finalBlock = blocks.at(-1);
@@ -488,4 +497,4 @@ function calculateFootnoteReservedHeights(pageFootnoteMap, footnoteContentMap) {
 	return reserved;
 }
 //#endregion
-export { FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectEndnoteRefs, collectFootnoteRefs, computeNoteDisplayNumbers, convertFootnoteToContent, mapFootnotesToPages, remapNoteMarkerText };
+export { FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectEndnoteRefs, collectFootnoteRefs, computeNoteDisplayNumbers, convertFootnoteToContent, convertNoteStoryToFlowBlocks, mapFootnotesToPages, remapNoteMarkerText };

package/dist/layout-bridge/convert/headerFooterLayout.d.ts

@@ -13,12 +13,6 @@ type HeaderFooterMetrics = {
   margins: PageMargins;
 };
 declare function normalizeHeaderFooterMeasureBlocks(blocks: FlowBlock[], section?: HeaderFooterMetrics["section"]): FlowBlock[];
-/**
- * Header/footer auto-fit tables use `w:tblGrid` as a provisional ratio, not a
- * license to paint beyond the page furniture frame. Scale an oversized grid
- * for measurement while leaving the authored block untouched for round trips.
- */
-declare function fitHeaderFooterTablesToContentWidth(blocks: FlowBlock[], contentWidth: number): FlowBlock[];
 declare function resolveHeaderFooterPositionedVisualTop(position: ImageRunPosition | undefined, elementHeight: number, sourceY: number, flowHeight: number, metrics: HeaderFooterMetrics): number;
 declare function resolveHeaderFooterVisualTop(run: ImageRun, paragraphY: number, flowHeight: number, metrics: HeaderFooterMetrics): number;
 declare function calculateHeaderFooterVisualBounds(blocks: FlowBlock[], measures: Measure[], flowHeight: number, metrics: HeaderFooterMetrics): {
@@ -103,4 +97,4 @@ type ReserveHeaderFooterFullWidthWrapBandsOptions = {
 };
 declare function reserveHeaderFooterFullWidthWrapBands({ blocks, measures, contentWidth, metrics }: ReserveHeaderFooterFullWidthWrapBandsOptions): Measure[];
 //#endregion
-export { ConvertHeaderFooterOptions, HeaderFooterMetrics, calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, fitHeaderFooterTablesToContentWidth, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };
+export { ConvertHeaderFooterOptions, HeaderFooterMetrics, calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };

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

@@ -1,5 +1,5 @@
 import { cloneParagraphWithPropertySource } from "../../docx/paragraphPropertySource.js";
-import { isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun, tableColumnsArePinned } from "../../layout-engine/types.js";
+import { isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun } from "../../layout-engine/types.js";
 import { headerFooterToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
 import { emuToPixels } from "../../utils/units.js";
 import { toFlowBlocks } from "./toFlowBlocks.js";
@@ -33,23 +33,6 @@ function preservesInheritedSpacing(block) {
 function normalizeHeaderFooterMeasureBlocks(blocks, section = "header") {
 	return normalizeFlowBlockArray(blocks, { suppressTrailingEmptyAfterTable: section === "header" });
 }
-/**
-* Header/footer auto-fit tables use `w:tblGrid` as a provisional ratio, not a
-* license to paint beyond the page furniture frame. Scale an oversized grid
-* for measurement while leaving the authored block untouched for round trips.
-*/
-function fitHeaderFooterTablesToContentWidth(blocks, contentWidth) {
-	return blocks.map((block) => {
-		if (block.kind !== "table" || block.floating !== void 0 || tableColumnsArePinned(block) || block.columnWidths === void 0) return block;
-		const totalWidth = block.columnWidths.reduce((sum, width) => sum + width, 0);
-		if (totalWidth <= contentWidth || totalWidth <= 0) return block;
-		const scale = contentWidth / totalWidth;
-		return {
-			...block,
-			columnWidths: block.columnWidths.map((width) => width * scale)
-		};
-	});
-}
 function normalizeFlowBlockArray(blocks, normalization) {
 	const trailingEmptyAfterTable = /* @__PURE__ */ new Set();
 	const lastIndex = blocks.length - 1;
@@ -433,7 +416,7 @@ function reserveHeaderFooterFullWidthWrapBands({ blocks, measures, contentWidth,
 }
 function finalizeHeaderFooterContent(blocks, contentWidth, metrics, options) {
 	if (blocks.length === 0) return;
-	const blocksForMeasure = fitHeaderFooterTablesToContentWidth(normalizeHeaderFooterMeasureBlocks(blocks, metrics.section), contentWidth);
+	const blocksForMeasure = normalizeHeaderFooterMeasureBlocks(blocks, metrics.section);
 	const measures = reserveHeaderFooterFullWidthWrapBands({
 		blocks,
 		measures: options.measureBlocks(blocksForMeasure, contentWidth),
@@ -547,6 +530,7 @@ function serializeParagraphAttrs(attrs) {
 		"listMarkerFormatting",
 		"listMarkerAlignment",
 		"listMarkerSuffix",
+		"listLevelTabs",
 		"tabs"
 	];
 	const out = {};
@@ -575,6 +559,7 @@ function serializeRunFmt(run) {
 		"alternateFontFamily",
 		"eastAsiaFontFamily",
 		"eastAsiaAlternateFontFamily",
+		"eastAsiaHint",
 		"complexScriptFontFamily",
 		"complexScriptAlternateFontFamily",
 		"complexScriptFontSize",
@@ -594,4 +579,4 @@ function serializeRunFmt(run) {
 	return JSON.stringify(out);
 }
 //#endregion
-export { calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, fitHeaderFooterTablesToContentWidth, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };
+export { calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };

package/dist/layout-bridge/convert/paragraphMarkFormatting.d.ts

@@ -0,0 +1,10 @@
+import { document_d_exports } from "../../types/document.js";
+import { ParagraphAttrs } from "../../prosemirror/schema/nodes.js";
+import { RunStyleResolver } from "../../prosemirror/runStyleFormatting.js";
+//#region src/layout-bridge/convert/paragraphMarkFormatting.d.ts
+/** The mark's own properties: its `w:rStyle` character style under its direct `w:rPr`. */
+declare const resolveParagraphMarkOwnFormatting: (mark: document_d_exports.TextFormatting | undefined, styleResolver: RunStyleResolver) => document_d_exports.TextFormatting | undefined;
+/** The paragraph mark's fully resolved run properties. */
+declare const resolveParagraphMarkFormatting: (pmAttrs: ParagraphAttrs, styleResolver: RunStyleResolver) => document_d_exports.TextFormatting | undefined;
+//#endregion
+export { resolveParagraphMarkFormatting, resolveParagraphMarkOwnFormatting };

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

@@ -0,0 +1,59 @@
+import { resolveParagraphBodyRunFormatting } from "../../prosemirror/runStyleFormatting.js";
+import { cascadeStyleTextFormatting } from "../../prosemirror/styles/styleToggleCascade.js";
+import { mergeTextFormatting } from "../../utils/textFormattingMerge.js";
+//#region src/layout-bridge/convert/paragraphMarkFormatting.ts
+/**
+* Run properties of a paragraph mark (ECMA-376 §17.3.1.29 `w:pPr/w:rPr`).
+*
+* The mark resolves like any run of its paragraph: document defaults, the
+* table style, the paragraph style chain, then a character style the mark
+* names in `w:rStyle` (whose toggles combine per §17.7.3), then the mark's
+* direct properties. The default character style is not applied to the mark.
+*/
+/**
+* The properties of the character style a mark names in `w:rStyle`. An id that
+* is missing or names a style of another type contributes nothing.
+*/
+const markCharacterStyleFormatting = (mark, styleResolver) => {
+	const styleId = mark?.styleId;
+	if (styleId === void 0 || styleResolver.getStyle(styleId)?.type !== "character") return;
+	return styleResolver.getRunStyleOwnProperties(styleId);
+};
+/** The mark's own properties: its `w:rStyle` character style under its direct `w:rPr`. */
+const resolveParagraphMarkOwnFormatting = (mark, styleResolver) => {
+	const characterStyle = markCharacterStyleFormatting(mark, styleResolver);
+	if (characterStyle === void 0) return mark;
+	return cascadeStyleTextFormatting([{
+		formatting: characterStyle,
+		type: "style"
+	}, {
+		formatting: mark,
+		type: "direct"
+	}]).formatting;
+};
+/** The paragraph mark's fully resolved run properties. */
+const resolveParagraphMarkFormatting = (pmAttrs, styleResolver) => {
+	const mark = pmAttrs._originalFormatting?.runProperties;
+	const { baseFormatting, baseToggleCascade } = resolveParagraphBodyRunFormatting({
+		styleId: pmAttrs.styleId ?? void 0,
+		styleResolver,
+		tableRunFormatting: pmAttrs._tableRunFormatting
+	});
+	const characterStyle = markCharacterStyleFormatting(mark, styleResolver);
+	return cascadeStyleTextFormatting([
+		{
+			cascade: baseToggleCascade,
+			type: "carried"
+		},
+		{
+			formatting: characterStyle,
+			type: "style"
+		},
+		{
+			formatting: mark,
+			type: "direct"
+		}
+	], { ordinaryFormatting: mergeTextFormatting(mergeTextFormatting(baseFormatting, characterStyle), mark) }).formatting;
+};
+//#endregion
+export { resolveParagraphMarkFormatting, resolveParagraphMarkOwnFormatting };

package/dist/layout-bridge/convert/toFlowBlocks.d.ts

@@ -64,11 +64,39 @@ type ToFlowBlocksOptions = {
   justificationCompatibility?: NonNullable<ParagraphAttrs["justificationCompatibility"]>;
   /** Document-generation policy for where `w:tblInd` is measured from. */
   tableIndentCompatibility?: NonNullable<TableBlock["indentCompatibility"]>;
+  /**
+   * When set, every table-cell anchor lays out inside its cell regardless of
+   * an authored `wp:anchor/@layoutInCell="0"`. Compatibility mode 15 and
+   * above ignore that opt-out; see `resolveAnchorLayoutInCellCompatibility`.
+   */
+  forceAnchorLayoutInCell?: boolean;
   /** Document-wide automatic hyphenation policy. */
   automaticHyphenation?: NonNullable<ParagraphAttrs["automaticHyphenation"]>;
   /** Line pitch for the final body section, whose properties live outside the PM body. */
   finalSectionDocumentGridLinePitchTwips?: number;
+  /**
+   * The number a note story's `w:footnoteRef`/`w:endnoteRef` marks show. The
+   * mark stands for its note's reference number and shows it where it sits
+   * among the story's runs, in that run's formatting.
+   */
+  noteReferenceMarkText?: string;
+  /**
+   * Endnotes laid out after the body's last block (`w:pos="docEnd"`). A body
+   * that references one ends in its endnote area, so its final paragraph is no
+   * longer the document's last and keeps its height.
+   */
+  trailingEndnoteIds?: ReadonlySet<number>;
 };
+/**
+ * Runs with `idKey` set, in document order: the note references a block list
+ * makes, through table cells (and tables within cells) and text boxes.
+ */
+declare function collectNoteRefs(blocks: readonly FlowBlock[], idKey: "footnoteRefId" | "endnoteRefId"): {
+  noteId: number;
+  pmPos: number;
+}[];
+/** Whether captured run-child markup is a note story's `w:footnoteRef`/`w:endnoteRef`. */
+declare function isNoteReferenceMarkXml(xml: string): boolean;
 /**
  * Word's layout fallback when an imported OOXML style hierarchy never supplies
  * `w:sz`. ECMA-376 deliberately leaves that terminal fallback to the consumer;
@@ -101,4 +129,4 @@ declare function convertBorderSpecToLayout(border: ConvertibleBorder, theme?: do
  */
 declare function toFlowBlocks(doc: Node, options?: ToFlowBlocksOptions): FlowBlock[];
 //#endregion
-export { ToFlowBlocksOptions, WORD_UNSPECIFIED_FONT_SIZE, convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };
+export { ToFlowBlocksOptions, WORD_UNSPECIFIED_FONT_SIZE, collectNoteRefs, convertBorderSpecToLayout, formatCounter, isNoteReferenceMarkXml, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };