@stll/folio-core 0.33.2 → 0.34.0

package/dist/ai-edits/apply.js

@@ -1,4 +1,4 @@
-import { expectParagraphAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
+import { expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunPropertyChangeMarkAttrs } from "../prosemirror/attrs/index.js";
 import { PPR_CHANGE_SCOPED_ATTR_KEYS } from "../prosemirror/commands/propertyChangeScope.js";
 import { addedBreakCarrierBefore, finalParagraphsOf, paragraphEndsItsContainer } from "../prosemirror/containerFinalParagraph.js";
 import { marksToTextFormatting } from "../prosemirror/conversion/fromProseDoc.js";
@@ -154,24 +154,132 @@ const REPLACEMENT_BACKGROUND_CLEAR_FORMATTING = {
 	highlight: false,
 	runShading: false
 };
-const applyInlineFormatting = ({ tr, schema, from, to, formatting }) => {
-	for (const [name, enabled] of Object.entries(formatting)) {
-		const markType = schema.marks[name];
+const INLINE_FORMATTING_MARK_NAMES = {
+	bold: "bold",
+	italic: "italic",
+	underline: "underline",
+	strike: "strike",
+	fontFamily: "fontFamily",
+	fontSizePt: "fontSize",
+	color: "textColor",
+	highlight: "highlight",
+	runShading: "runShading"
+};
+const DIRECT_FONT_PROPERTIES = [
+	"fontFamily",
+	"fontSize",
+	"color"
+];
+const formattingMarkName = (property) => {
+	if (!Object.hasOwn(INLINE_FORMATTING_MARK_NAMES, property)) return null;
+	const name = Reflect.get(INLINE_FORMATTING_MARK_NAMES, property);
+	return typeof name === "string" ? name : null;
+};
+const formattingMarkAttrs = (property, value) => {
+	switch (property) {
+		case "underline": return { style: "single" };
+		case "fontFamily": return typeof value === "string" ? {
+			ascii: value,
+			hAnsi: value
+		} : null;
+		case "fontSizePt": return typeof value === "number" ? { size: value * 2 } : null;
+		case "color": return typeof value === "string" ? { rgb: value.replace(/^#/u, "").toUpperCase() } : null;
+		default: return {};
+	}
+};
+const applyInlineFormatting = ({ tr, schema, from, to, formatting, includedProperties }) => {
+	for (const [property, value] of Object.entries(formatting)) {
+		if (includedProperties && !includedProperties.includes(property)) continue;
+		const markName = formattingMarkName(property);
+		const markType = markName ? schema.marks[markName] : void 0;
 		if (!markType) continue;
-		if (enabled) {
-			tr.addMark(from, to, name === "underline" ? markType.create({ style: "single" }) : markType.create());
+		if (value !== false && value !== null) {
+			const attrs = formattingMarkAttrs(property, value);
+			if (attrs) tr.addMark(from, to, markType.create(attrs));
 			continue;
 		}
 		tr.removeMark(from, to, markType);
 	}
+	applyDirectFontProvenance({
+		tr,
+		schema,
+		from,
+		to,
+		formatting,
+		...includedProperties ? { includedProperties } : {}
+	});
 	return tr;
 };
-const formattingWouldChange = (marks, formatting) => Object.entries(formatting).some(([name, enabled]) => {
-	const mark = marks.find((candidate) => candidate.type.name === name);
-	if (!enabled) return mark !== void 0;
-	if (name === "underline") return mark?.attrs["style"] !== "single";
+const applyDirectFontProvenance = ({ tr, schema, from, to, formatting, includedProperties }) => {
+	if ("highlight" in formatting) return;
+	const changed = [
+		[
+			"fontFamily",
+			"fontFamily",
+			formatting.fontFamily
+		],
+		[
+			"fontSize",
+			"fontSizePt",
+			formatting.fontSizePt
+		],
+		[
+			"color",
+			"color",
+			formatting.color
+		]
+	].filter(([, inputProperty, value]) => value !== void 0 && (!includedProperties || includedProperties.includes(inputProperty)));
+	const markType = schema.marks["runFormattingOverride"];
+	if (!markType || changed.length === 0) return;
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!node.isText) return;
+		const segmentFrom = Math.max(from, pos);
+		const segmentTo = Math.min(to, pos + node.nodeSize);
+		const existing = node.marks.find((mark) => mark.type === markType);
+		const attrs = existing ? expectRunFormattingOverrideMarkAttrs(existing) : {};
+		const directFontProperties = new Set(attrs.directFontProperties);
+		for (const [property, , value] of changed) if (value === null) directFontProperties.delete(property);
+		else directFontProperties.add(property);
+		tr.removeMark(segmentFrom, segmentTo, markType);
+		const nextAttrs = {
+			...attrs,
+			directFontProperties: DIRECT_FONT_PROPERTIES.filter((property) => directFontProperties.has(property))
+		};
+		if (Object.entries(nextAttrs).some(([key, value]) => key === "directFontProperties" ? Array.isArray(value) && value.length > 0 : value !== null && value !== void 0)) tr.addMark(segmentFrom, segmentTo, markType.create(nextAttrs));
+	});
+};
+const directFontPropertyForFormattingProperty = (property) => {
+	switch (property) {
+		case "fontFamily": return "fontFamily";
+		case "fontSizePt": return "fontSize";
+		case "color": return "color";
+		default: return null;
+	}
+};
+const formattingPropertyWouldChange = (marks, property, value) => {
+	const markName = formattingMarkName(property);
+	const mark = marks.find((candidate) => candidate.type.name === markName);
+	const directFontProperty = directFontPropertyForFormattingProperty(property);
+	if (directFontProperty) {
+		const overrideMark = marks.find((candidate) => candidate.type.name === "runFormattingOverride");
+		const isDirect = overrideMark ? (expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties ?? []).includes(directFontProperty) : false;
+		if (value === false || value === null) return isDirect;
+		if (!isDirect) return true;
+	} else if (value === false || value === null) return mark !== void 0;
+	if (property === "underline") return mark?.attrs["style"] !== "single";
+	if (property === "fontFamily") return mark?.attrs["ascii"] !== value || mark?.attrs["hAnsi"] !== value;
+	if (property === "fontSizePt") return Number(mark?.attrs["size"]) !== Number(value) * 2;
+	if (property === "color") {
+		const current = mark?.attrs["rgb"];
+		return (typeof current === "string" ? current.replace(/^#/u, "").toUpperCase() : null) !== String(value).replace(/^#/u, "").toUpperCase();
+	}
 	return mark === void 0;
-});
+};
+const formattingChangesForMarks = (marks, formatting) => {
+	const changes = [];
+	for (const [property, value] of Object.entries(formatting)) if (formattingPropertyWouldChange(marks, property, value)) changes.push(property);
+	return changes;
+};
 const clearReplacementBackground = ({ tr, schema, from, to, mode, revisionId, author, date, initials, suggestionId = null }) => {
 	if (![schema.marks["highlight"], schema.marks["runShading"]].some((markType) => markType !== void 0 && tr.doc.rangeHasMark(from, to, markType))) return tr;
 	if (mode === "direct") return applyInlineFormatting({
@@ -200,7 +308,9 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 	if (!propertyChangeType) return tr;
 	const segments = [];
 	doc.nodesBetween(from, to, (node, pos) => {
-		if (!node.isText || !formattingWouldChange(node.marks, formatting)) return;
+		if (!node.isText) return;
+		const includedProperties = formattingChangesForMarks(node.marks, formatting);
+		if (includedProperties.length === 0) return;
 		const segmentFrom = Math.max(from, pos);
 		const segmentTo = Math.min(to, pos + node.nodeSize);
 		const previousFormatting = marksToTextFormatting(node.marks);
@@ -219,6 +329,7 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 		segments.push({
 			from: segmentFrom,
 			to: segmentTo,
+			includedProperties,
 			changes: [...existingChanges, change]
 		});
 	});
@@ -227,17 +338,20 @@ const applyTrackedInlineFormatting = ({ tr, schema, doc, from, to, formatting, r
 		provenance: "suggested",
 		suggestionId
 	};
-	applyInlineFormatting({
-		tr,
-		schema,
-		from,
-		to,
-		formatting
-	});
-	for (const segment of segments) tr.addMark(segment.from, segment.to, propertyChangeType.create({
-		changes: segment.changes,
-		...suggestionAttrs
-	}));
+	for (const segment of segments) {
+		applyInlineFormatting({
+			tr,
+			schema,
+			from: segment.from,
+			to: segment.to,
+			formatting,
+			includedProperties: segment.includedProperties
+		});
+		tr.addMark(segment.from, segment.to, propertyChangeType.create({
+			changes: segment.changes,
+			...suggestionAttrs
+		}));
+	}
 	return tr;
 };
 /**

package/dist/ai-edits/snapshot.js

@@ -1,3 +1,4 @@
+import { expectRunFormattingOverrideMarkAttrs } from "../prosemirror/attrs/index.js";
 import { deriveBlankBlockId, deriveBlockId } from "../types/block-id.js";
 import { buildCleanBlockText } from "./clean-text.js";
 import { TableMap } from "prosemirror-tables";
@@ -252,14 +253,16 @@ const getPreviewRuns = (node) => {
 		if (!child.isText || child.text === void 0) return true;
 		if (child.marks.some((mark) => mark.type.name === DELETION_MARK)) return false;
 		const style = getPreviewRunStyle(child.marks, defaultStyle);
+		const directFormatting = getDirectPreviewRunStyle(child.marks, defaultStyle);
 		const previous = runs.at(-1);
-		if (previous && samePreviewRunStyle(previous, style)) {
+		if (previous && samePreviewRunStyle(previous, style) && sameDirectFormatting(previous.directFormatting, directFormatting)) {
 			previous.text += child.text;
 			return false;
 		}
 		runs.push({
 			text: child.text,
-			...style
+			...style,
+			...!isEmptyPreviewRunStyle(directFormatting) && { directFormatting }
 		});
 		return false;
 	});
@@ -310,6 +313,23 @@ const getPreviewRunStyle = (marks, defaultStyle) => {
 	}
 	return style;
 };
+const getDirectPreviewRunStyle = (marks, inheritedStyle) => {
+	const markedStyle = getPreviewRunStyle(marks, {});
+	const directStyle = {};
+	const overrideMark = marks.find(({ type }) => type.name === "runFormattingOverride");
+	const hasFormattingProvenance = overrideMark !== void 0 || marks.some(({ type }) => type.name === "characterStyle");
+	const directFontProperties = overrideMark ? expectRunFormattingOverrideMarkAttrs(overrideMark).directFontProperties : void 0;
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	]) if (Boolean(markedStyle[property]) !== Boolean(inheritedStyle[property])) directStyle[property] = Boolean(markedStyle[property]);
+	if (markedStyle.fontFamily !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontFamily") : markedStyle.fontFamily !== inheritedStyle.fontFamily)) directStyle.fontFamily = markedStyle.fontFamily;
+	if (markedStyle.fontSizePt !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("fontSize") : markedStyle.fontSizePt !== inheritedStyle.fontSizePt)) directStyle.fontSizePt = markedStyle.fontSizePt;
+	if (markedStyle.color !== void 0 && (hasFormattingProvenance ? directFontProperties?.includes("color") : markedStyle.color !== inheritedStyle.color)) directStyle.color = markedStyle.color;
+	return directStyle;
+};
 const getBooleanTextFormatting = (formatting) => ({
 	...Reflect.get(formatting, "bold") === true && { bold: true },
 	...Reflect.get(formatting, "italic") === true && { italic: true },
@@ -352,6 +372,8 @@ const getColorFromAttrs = (attrs) => {
 	return `#${rgb}`;
 };
 const samePreviewRunStyle = (run, style) => run.bold === style.bold && run.italic === style.italic && run.underline === style.underline && run.strike === style.strike && run.fontFamily === style.fontFamily && run.fontSizePt === style.fontSizePt && run.color === style.color;
+const isEmptyPreviewRunStyle = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
+const sameDirectFormatting = (left, right) => left === void 0 && isEmptyPreviewRunStyle(right) || left !== void 0 && left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
 const isUnstyledPreviewRun = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color }) => bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0;
 //#endregion
 export { createFolioAIEditSnapshot, createFolioAITextRangeHandle, folioStoryTables, hashFolioAIBlockText, isFolioAIContentBlock, isHiddenTableRow, normalizeFolioAIBlockText, trailingBodyBlockId };

package/dist/ai-edits/types.d.ts

@@ -1,5 +1,10 @@
 //#region src/ai-edits/types.d.ts
 type FolioAIBlockKind = "heading" | "listItem" | "paragraph";
+type FolioAIInlineFormatting = Partial<Record<"bold" | "italic" | "underline" | "strike", boolean>> & {
+  fontFamily?: string | null;
+  fontSizePt?: number | null;
+  color?: string | null;
+};
 type FolioAIBlockPreviewRun = {
   text: string;
   bold?: boolean;
@@ -9,6 +14,7 @@ type FolioAIBlockPreviewRun = {
   fontFamily?: string;
   fontSizePt?: number;
   color?: string;
+  directFormatting?: FolioAIInlineFormatting;
 };
 /**
  * Where a block sits inside its innermost enclosing table. Every index is
@@ -165,12 +171,6 @@ type FolioDocumentNavigationTarget = {
   story: "main";
   blockId: string;
 } | FolioAITextRangeHandle;
-type FolioAIInlineFormatting = {
-  bold?: boolean;
-  italic?: boolean;
-  underline?: boolean;
-  strike?: boolean;
-};
 /**
  * A party in an `insertSignatureTable` op. Mirrors the
  * `signatureTable` helper in `docx-core/legal-source/compile.ts`:

package/dist/compare/formatting.d.ts

@@ -15,7 +15,7 @@ type InlineFormattingSegmentsOptions = {
   maxSegments: number;
 };
 /**
- * Segments where `targetBlock`'s bold / italic / underline / strike differs from
+ * Segments where `targetBlock`'s supported run formatting differs from
  * `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
  * when the diff would exceed `maxSegments`.
  *

package/dist/compare/formatting.js

@@ -1,12 +1,41 @@
+import { resolveColorToHex } from "../utils/colorResolver.js";
 //#region src/compare/formatting.ts
-const changedSupportedFormatting = (base, target) => ({
-	...Boolean(base.bold) !== Boolean(target.bold) && { bold: Boolean(target.bold) },
-	...Boolean(base.italic) !== Boolean(target.italic) && { italic: Boolean(target.italic) },
-	...Boolean(base.underline) !== Boolean(target.underline) && { underline: Boolean(target.underline) },
-	...Boolean(base.strike) !== Boolean(target.strike) && { strike: Boolean(target.strike) }
-});
-const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike;
-const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0 || formatting.strike !== void 0;
+const normalizeInlineFormattingColor = (color) => resolveColorToHex(color === void 0 ? void 0 : { rgb: color }, null);
+const changedStringValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
+	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
+	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
+};
+const changedNumberValue = (baseEffective, targetEffective, baseAuthored, targetAuthored) => {
+	if (baseAuthored !== targetAuthored) return targetAuthored ?? null;
+	return baseEffective === targetEffective ? void 0 : targetEffective ?? null;
+};
+const changedSupportedFormatting = (base, target) => {
+	const baseDirect = base.directFormatting ?? {};
+	const targetDirect = target.directFormatting ?? {};
+	const formatting = {};
+	const changedBoolean = (property) => {
+		if (baseDirect[property] !== targetDirect[property]) return targetDirect[property] === true;
+		return Boolean(base[property]) === Boolean(target[property]) ? void 0 : Boolean(target[property]);
+	};
+	for (const property of [
+		"bold",
+		"italic",
+		"underline",
+		"strike"
+	]) {
+		const changed = changedBoolean(property);
+		if (changed !== void 0) formatting[property] = changed;
+	}
+	const fontFamily = changedStringValue(base.fontFamily, target.fontFamily, baseDirect.fontFamily, targetDirect.fontFamily);
+	if (fontFamily !== void 0) formatting.fontFamily = fontFamily;
+	const fontSizePt = changedNumberValue(base.fontSizePt, target.fontSizePt, baseDirect.fontSizePt, targetDirect.fontSizePt);
+	if (fontSizePt !== void 0) formatting.fontSizePt = fontSizePt;
+	const color = changedStringValue(normalizeInlineFormattingColor(base.color), normalizeInlineFormattingColor(target.color), normalizeInlineFormattingColor(baseDirect.color ?? void 0), normalizeInlineFormattingColor(targetDirect.color ?? void 0));
+	if (color !== void 0) formatting.color = color;
+	return formatting;
+};
+const sameInlineFormatting = (left, right) => left.bold === right.bold && left.italic === right.italic && left.underline === right.underline && left.strike === right.strike && left.fontFamily === right.fontFamily && left.fontSizePt === right.fontSizePt && left.color === right.color;
+const hasInlineFormatting = (formatting) => formatting.bold !== void 0 || formatting.italic !== void 0 || formatting.underline !== void 0 || formatting.strike !== void 0 || formatting.fontFamily !== void 0 || formatting.fontSizePt !== void 0 || formatting.color !== void 0;
 /**
 * A block's runs, or `null` when they cannot describe the block's text.
 * Non-text inline content (a field, an image) leaves the concatenated run text
@@ -18,7 +47,7 @@ const previewRunsForBlock = (block) => {
 	return runs.map(({ text }) => text).join("") === block.text ? runs : null;
 };
 /**
-* Segments where `targetBlock`'s bold / italic / underline / strike differs from
+* Segments where `targetBlock`'s supported run formatting differs from
 * `baseBlock`'s, for two blocks that carry the same text. Returns `null` only
 * when the diff would exceed `maxSegments`.
 *

package/dist/compare/verification.js

@@ -1,3 +1,4 @@
+import { resolveColorToHex } from "../utils/colorResolver.js";
 import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 //#region src/compare/verification.ts
 /**
@@ -14,6 +15,7 @@ import { PARAGRAPH_MARK_CHANGE_KINDS } from "@stll/docx-core/model";
 * Never a phrase of either document, because a caller may log it, put it in a
 * report, or quote it in a review.
 */
+const normalizeInlineFormattingColor = (color) => resolveColorToHex(color === void 0 ? void 0 : { rgb: color }, null);
 /** The two directions of the round trip, each an invariant of its own. */
 const COMPARE_VERIFICATION_INVARIANTS = Object.freeze(["accept-reproduces-target", "reject-reproduces-base"]);
 /**
@@ -32,7 +34,22 @@ const COMPARE_VERIFICATION_CAUSES = Object.freeze([
 	"whitespace",
 	"text"
 ]);
-const supportedInlineStyle = ({ bold, italic, underline, strike }) => `${bold === true ? "b" : ""}${italic === true ? "i" : ""}${underline === true ? "u" : ""}${strike === true ? "s" : ""}`;
+const supportedInlineStyle = ({ bold, italic, underline, strike, fontFamily, fontSizePt, color, directFormatting }) => JSON.stringify([
+	bold === true,
+	italic === true,
+	underline === true,
+	strike === true,
+	fontFamily ?? null,
+	fontSizePt ?? null,
+	normalizeInlineFormattingColor(color) ?? null,
+	directFormatting?.bold === true,
+	directFormatting?.italic === true,
+	directFormatting?.underline === true,
+	directFormatting?.strike === true,
+	directFormatting?.fontFamily ?? null,
+	directFormatting?.fontSizePt ?? null,
+	normalizeInlineFormattingColor(directFormatting?.color ?? void 0) ?? null
+]);
 /** Effective supported formatting with equivalent adjacent runs normalized. */
 const projectSupportedInlineFormatting = ({ text, previewRuns }) => {
 	const projected = [];

package/dist/controller/headerFooterEditorManager.js

@@ -10,19 +10,21 @@ import { schema } from "../prosemirror/schema/index.js";
 import { EditorState } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
 //#region src/controller/headerFooterEditorManager.ts
-/**
-* Framework-neutral lifecycle owner for persistent header/footer EditorViews.
-*
-* Each distinct relationship id owns one off-screen ProseMirror view. Painted
-* header/footer instances that share that relationship therefore share live
-* editor state, and adapters only decide when to synchronize or destroy the
-* manager.
-*/
+const DETACHED_WATERMARK_HOST = Symbol.for("stll.detachedWatermarkHost");
+const headerFooterToProseDocWithDetachedWatermarkHost = (headerFooter, options) => {
+	return headerFooterToProseDoc(headerFooter.content.map((block, blockIndex) => {
+		if (blockIndex !== headerFooter.watermarkBlockIndex || block.type !== "paragraph") return block;
+		return {
+			...block,
+			[DETACHED_WATERMARK_HOST]: true
+		};
+	}), options);
+};
 const buildInitialState = (headerFooter, styles, theme, manager) => {
 	const proseDocOptions = {};
 	if (styles) proseDocOptions.styles = styles;
 	if (theme !== void 0) proseDocOptions.theme = theme;
-	const document = headerFooterToProseDoc(headerFooter.content, proseDocOptions);
+	const document = headerFooter.watermarkBlockIndex === void 0 ? headerFooterToProseDoc(headerFooter.content, proseDocOptions) : headerFooterToProseDocWithDetachedWatermarkHost(headerFooter, proseDocOptions);
 	return ensureBaseDirectionInState(ensureParaIdsInState(EditorState.create({
 		doc: document,
 		schema,

package/dist/controller/layoutPipeline.js

@@ -1,6 +1,7 @@
 import { createDisplayListPagePainter } from "../display-list/editor/displayListPagePainter.js";
 import { PAGE_RENDERER, displayListFurnitureFrom } from "../display-list/editor/pageRenderer.js";
 import { resolveDocumentGridLinePitch } from "../docx/documentGrid.js";
+import { formatOoxmlCounter } from "../docx/ooxmlCounterFormatter.js";
 import { buildBookmarkPageMap } from "../fields/bookmarkPages.js";
 import { buildBookmarkText } from "../fields/bookmarkText.js";
 import { buildHeaderFooterFieldValues, fieldValuesEqual, resolveFieldValues } from "../fields/resolveFieldValues.js";
@@ -26,6 +27,17 @@ import { getMargins, getPageNumbering, getPageSize, twipsToPixels } from "../pag
 import { templatePreviewValuesKey } from "../prosemirror/plugins/templatePreviewValues.js";
 import { getDocumentWatermark } from "../watermark/index.js";
 //#region src/controller/layoutPipeline.ts
+const formatEndnoteTexts = (numbers, formatNumber) => {
+	const texts = /* @__PURE__ */ new Map();
+	for (const [id, displayNumber] of numbers) texts.set(id, formatNumber(displayNumber));
+	return texts;
+};
+/** Resolve only package-owned picture-watermark bytes for the DOM painter. */
+const resolveWatermarkImageSrc = (document, watermark) => {
+	if (watermark?.kind !== "picture" || watermark.imageTargetExternal === true) return;
+	const target = watermark.imageTarget;
+	return target === void 0 ? void 0 : document.package.media?.get(target)?.dataUrl;
+};
 function bodyMarginsClearHeaderFooter({ authoredMargins, preparedHeader, preparedFooter }) {
 	const headerBottom = preparedHeader ? (authoredMargins.header ?? 0) + (preparedHeader.marginPushBottom ?? preparedHeader.height) : authoredMargins.top;
 	const footerClearance = preparedFooter ? (authoredMargins.footer ?? 0) + (preparedFooter.marginPushBottom ?? preparedFooter.height) : authoredMargins.bottom;
@@ -123,7 +135,10 @@ function runLayoutPipeline(deps, state, options = {}) {
 		};
 		const finalSectionDocumentGridLinePitchTwips = resolveDocumentGridLinePitch(document?.package.document.sections?.at(-1)?.properties.docGrid);
 		if (finalSectionDocumentGridLinePitchTwips !== void 0) flowOpts.finalSectionDocumentGridLinePitchTwips = finalSectionDocumentGridLinePitchTwips;
-		let newBlocks = toFlowBlocks(state.doc, flowOpts);
+		let newBlocks = toFlowBlocks(document === null ? state.doc.type.create({
+			...state.doc.attrs,
+			_finalSectionStart: sectionProperties?.sectionStart ?? null
+		}, state.doc.content, state.doc.marks) : state.doc, flowOpts);
 		const previewState = templatePreviewValuesKey.getState(state);
 		const previewEntries = previewState?.entries ?? EMPTY_TEMPLATE_PREVIEW_ENTRIES;
 		const previewMode = previewState?.preview?.mode ?? "plain";
@@ -144,9 +159,11 @@ function runLayoutPipeline(deps, state, options = {}) {
 		const footnoteDisplayNumbers = documentFootnotes ? computeNoteDisplayNumbers(documentFootnotes, footnoteRefs.map((ref) => ref.footnoteId)) : void 0;
 		const documentEndnotes = document?.package.endnotes;
 		const endnoteDisplayNumbers = documentEndnotes ? computeNoteDisplayNumbers(documentEndnotes, collectEndnoteRefs(newBlocks).map((ref) => ref.endnoteId)) : void 0;
+		const endnoteNumberFormat = document?.package.document.sections?.at(-1)?.properties.endnotePr?.numFmt ?? "lowerRoman";
+		const endnoteTexts = endnoteDisplayNumbers ? formatEndnoteTexts(endnoteDisplayNumbers, (displayNumber) => formatOoxmlCounter(displayNumber, endnoteNumberFormat)) : void 0;
 		newBlocks = remapNoteMarkerText(newBlocks, {
 			...footnoteDisplayNumbers ? { footnoteNumbers: footnoteDisplayNumbers } : {},
-			...endnoteDisplayNumbers ? { endnoteNumbers: endnoteDisplayNumbers } : {}
+			...endnoteTexts ? { endnoteTexts } : {}
 		});
 		outcome.blocks = newBlocks;
 		const hfMetricsHeader = {
@@ -479,12 +496,16 @@ function runLayoutPipeline(deps, state, options = {}) {
 			if (document) {
 				const watermark = getDocumentWatermark(document);
 				if (watermark) renderOpts.watermark = watermark;
+				let watermarkByHeaderRId;
 				const headers = document.package.headers;
 				if (headers) {
-					const watermarkByHeaderRId = /* @__PURE__ */ new Map();
+					watermarkByHeaderRId = /* @__PURE__ */ new Map();
 					for (const [rId, header] of headers) if (header.watermark) watermarkByHeaderRId.set(rId, header.watermark);
 					if (watermarkByHeaderRId.size > 0) renderOpts.watermarkByHeaderRId = watermarkByHeaderRId;
 				}
+				const pictureSources = new Set([watermark, ...watermarkByHeaderRId?.values() ?? []].filter((candidate) => candidate !== void 0).map((candidate) => resolveWatermarkImageSrc(document, candidate)));
+				const watermarkImageSrc = pictureSources.size === 1 ? [...pictureSources].at(0) : void 0;
+				if (watermarkImageSrc !== void 0) renderOpts.watermarkImageSrc = watermarkImageSrc;
 			}
 			if (pageRenderer === PAGE_RENDERER.displayList) renderOpts.paintPage = createDisplayListPagePainter({
 				layout: newLayout,

package/dist/display-list/build/watermarkPrimitives.js

@@ -1,4 +1,4 @@
-import { pxToPt } from "../../layout-engine/measure/measureHelpers.js";
+import { ptToPx, pxToPt } from "../../layout-engine/measure/measureHelpers.js";
 import { getFontMetrics } from "../../layout-engine/measure/measureProvider.js";
 import { parseDisplayColor } from "./colors.js";
 import { buildGlyphs, glyphRunText } from "./glyphs.js";
@@ -28,7 +28,7 @@ const TEXT_DEFAULT_COLOR = "#C0C0C0";
 const TEXT_DEFAULT_OPACITY = .5;
 const TEXT_DIAGONAL_DEGREES = -45;
 const PICTURE_NATIVE_SCALE = 1;
-const PICTURE_WASHOUT_OPACITY = .4;
+const PICTURE_WASHOUT_OPACITY = .18;
 const paintTextWatermark = (watermark, page, context) => {
 	if (watermark.text.length === 0) return [];
 	const style = {
@@ -98,6 +98,18 @@ const containedRect = (page, scale, pixelWidth, pixelHeight) => {
 		heightPx
 	};
 };
+/** The centred VML shape box, when both authored dimensions survived parsing. */
+const authoredPictureRect = (page, widthPt, heightPt) => {
+	if (widthPt === void 0 || heightPt === void 0) return;
+	const widthPx = ptToPx(widthPt);
+	const heightPx = ptToPx(heightPt);
+	return {
+		xPx: (page.size.w - widthPx) / 2,
+		yPx: (page.size.h - heightPx) / 2,
+		widthPx,
+		heightPx
+	};
+};
 const paintPictureWatermark = (watermark, page, imageSrc, context) => {
 	if (imageSrc === void 0) {
 		context.unsupported.report(UNSUPPORTED_CONSTRUCT.watermark, context.pageIndex, `picture watermark ${watermark.imageRId} has no resolved image source: the relationship id resolves in the package layer, not in the builder`);
@@ -113,7 +125,7 @@ const paintPictureWatermark = (watermark, page, imageSrc, context) => {
 	return [{
 		kind: "image",
 		image: ref,
-		rect: containedRect(page, watermark.scale ?? PICTURE_NATIVE_SCALE, source?.pixelWidth ?? 0, source?.pixelHeight ?? 0),
+		rect: authoredPictureRect(page, watermark.widthPt, watermark.heightPt) ?? containedRect(page, watermark.scale ?? PICTURE_NATIVE_SCALE, source?.pixelWidth ?? 0, source?.pixelHeight ?? 0),
 		opacity: watermark.washout === false ? 1 : PICTURE_WASHOUT_OPACITY
 	}];
 };

package/dist/document-operations.js

@@ -143,6 +143,24 @@ const readOptionalBoolean = (value, key, path) => {
 	if (typeof candidate === "boolean") return candidate;
 	return invalidBatch(`${path}.${key}`, "expected a boolean when provided");
 };
+const readClearableNonEmptyString = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0 || candidate === null) return candidate;
+	if (typeof candidate === "string" && candidate.trim().length > 0) return candidate.trim();
+	return invalidBatch(`${path}.${key}`, "expected a non-empty string or null when provided");
+};
+const readClearableFontSize = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0 || candidate === null) return candidate;
+	if (typeof candidate === "number" && candidate > 0 && Number.isInteger(candidate * 2)) return candidate;
+	return invalidBatch(`${path}.${key}`, "expected a positive half-point value or null");
+};
+const readClearableRgbColor = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0 || candidate === null) return candidate;
+	if (typeof candidate === "string" && /^#?[0-9a-fA-F]{6}$/u.test(candidate)) return candidate.replace(/^#/u, "").toUpperCase();
+	return invalidBatch(`${path}.${key}`, "expected a six-digit RGB color or null");
+};
 const readOptionalStringArray = (value, key, path) => {
 	const candidate = value[key];
 	if (candidate === void 0) return;
@@ -238,18 +256,27 @@ const readInlineFormatting = (value, path) => {
 		"bold",
 		"italic",
 		"underline",
-		"strike"
+		"strike",
+		"fontFamily",
+		"fontSizePt",
+		"color"
 	]);
 	const bold = readOptionalBoolean(candidate, "bold", formattingPath);
 	const italic = readOptionalBoolean(candidate, "italic", formattingPath);
 	const underline = readOptionalBoolean(candidate, "underline", formattingPath);
 	const strike = readOptionalBoolean(candidate, "strike", formattingPath);
-	if (bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0) return invalidBatch(formattingPath, "expected at least one formatting property");
+	const fontFamily = readClearableNonEmptyString(candidate, "fontFamily", formattingPath);
+	const fontSizePt = readClearableFontSize(candidate, "fontSizePt", formattingPath);
+	const color = readClearableRgbColor(candidate, "color", formattingPath);
+	if (bold === void 0 && italic === void 0 && underline === void 0 && strike === void 0 && fontFamily === void 0 && fontSizePt === void 0 && color === void 0) return invalidBatch(formattingPath, "expected at least one formatting property");
 	return {
 		...bold !== void 0 && { bold },
 		...italic !== void 0 && { italic },
 		...underline !== void 0 && { underline },
-		...strike !== void 0 && { strike }
+		...strike !== void 0 && { strike },
+		...fontFamily !== void 0 && { fontFamily },
+		...fontSizePt !== void 0 && { fontSizePt },
+		...color !== void 0 && { color }
 	};
 };
 const readOptionalComment = (value, path) => {

package/dist/docx/headerFooterParser.js

@@ -31,27 +31,21 @@ function parseHeader(headerXml, hdrFtrType = "default", styles = null, theme = n
 		result.rawWatermarkXml = watermarkResult.rawParagraphXml;
 		result.watermarkBlockIndex = watermarkResult.blockIndex;
 	}
-	result.content = parseBlockContent(watermarkResult ? withoutChild(rootElement, watermarkResult.hostingParagraph) : rootElement, styles, theme, numbering, rels, media, {
+	result.content = parseBlockContent(rootElement, styles, theme, numbering, rels, media, {
 		inHeaderFooter: true,
 		rootXmlns: collectXmlnsDeclarations(rootElement)
 	});
+	if (watermarkResult) {
+		const host = result.content.at(watermarkResult.blockIndex);
+		if (host?.type === "paragraph") result.content[watermarkResult.blockIndex] = {
+			...host,
+			content: []
+		};
+	}
 	assignHeaderFooterVerbatimXml(result, headerXml);
 	return result;
 }
 /**
-* Return a shallow copy of `parent` whose `elements` array omits the
-* single child reference `child`. Used to skip the watermark paragraph
-* when feeding the header into `parseBlockContent` — without this the
-* body parser would emit an empty placeholder paragraph where the
-* watermark sits in the source.
-*/
-function withoutChild(parent, child) {
-	return {
-		...parent,
-		elements: (parent.elements ?? []).filter((el) => el !== child)
-	};
-}
-/**
 * Parse a footer XML file (word/footer*.xml)
 *
 * @param footerXml - The raw XML content of the footer file