@stll/folio-core 0.54.2 → 0.56.0

package/dist/docx/foldedListNumberFields.js

@@ -0,0 +1,267 @@
+//#region src/docx/foldedListNumberFields.ts
+/** Zero-width markup that can stand between a field and its tab. */
+const RANGE_MARKER_TYPES = /* @__PURE__ */ new Set([
+	"bookmarkStart",
+	"bookmarkEnd",
+	"commentRangeStart",
+	"commentRangeEnd",
+	"commentReference"
+]);
+/** Markup that shows nothing and so does not end the start of a paragraph. */
+const ZERO_WIDTH_TYPES = /* @__PURE__ */ new Set([
+	...RANGE_MARKER_TYPES,
+	"moveFromRangeStart",
+	"moveFromRangeEnd",
+	"moveToRangeStart",
+	"moveToRangeEnd"
+]);
+/** Whether `content` is markup that may stand between a field and the tab that follows it. */
+const isListNumberGapMarker = (content) => RANGE_MARKER_TYPES.has(content.type);
+const isZeroWidth = (content) => ZERO_WIDTH_TYPES.has(content.type) || content.type === "preservedInline" && content.text === "";
+/** Whether `content` is a `LISTNUM` field, by its parsed type or its instruction. */
+const isListNumberField = (content) => content.type === "complexField" && (content.fieldType === "LISTNUM" || content.instruction.trim().toUpperCase().startsWith("LISTNUM"));
+/** A run that holds one tab and nothing else. */
+const isTabOnlyRun = (content) => content.type === "run" && content.content.length === 1 && content.content[0]?.type === "tab";
+/** The text a field's cached result puts in the marker. */
+const cachedListNumberText = (field) => {
+	let text = "";
+	for (const run of field.fieldResult) for (const piece of run.content) if (piece.type === "text") text += piece.text;
+	return text;
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+/** Whether `value` is what a capture stands for: a complex field, or a run. */
+const isFoldedListNumber = (value) => {
+	if (!isRecord(value)) return false;
+	if (value["kind"] === "field") {
+		const field = value["field"];
+		return isRecord(field) && field["type"] === "complexField" && typeof field["instruction"] === "string" && Array.isArray(field["fieldCode"]) && Array.isArray(field["fieldResult"]);
+	}
+	if (value["kind"] === "tab") {
+		const run = value["run"];
+		return isRecord(run) && run["type"] === "run" && Array.isArray(run["content"]);
+	}
+	return false;
+};
+/** What `content` stands for when it is a capture the fold left, else nothing. */
+const foldedListNumberOf = (content) => content.type === "preservedInline" ? content.foldedListNumber : void 0;
+/** Whether `content` is a capture the fold left in place of a field or its tab. */
+const isFoldedListNumberCapture = (content) => foldedListNumberOf(content) !== void 0;
+/**
+* Replace the `LISTNUM` fields that open a paragraph, and the tab after each,
+* by captures of the markup they were read from.
+*
+* Only what stands ahead of the first thing the line shows is folded: a field
+* after text is on the line where the text is. `sourceMarkupOf` answers the
+* markup; a field it has none for is left as the field it is, and ends the
+* fold. Bookmark and comment markers between a field and its tab stay where
+* they are, and the tab is still the field's when only they separate the two.
+*/
+const foldListNumberFields = (content, sourceMarkupOf) => {
+	const folded = [];
+	const cached = [];
+	let fieldCount = 0;
+	let leading = true;
+	let awaitingTab = false;
+	for (const item of content) {
+		if (isListNumberField(item)) fieldCount += 1;
+		if (!leading) {
+			folded.push(item);
+			continue;
+		}
+		if (awaitingTab && RANGE_MARKER_TYPES.has(item.type)) {
+			folded.push(item);
+			continue;
+		}
+		if (awaitingTab) {
+			awaitingTab = false;
+			const tabMarkup = isTabOnlyRun(item) ? sourceMarkupOf(item) : void 0;
+			if (isTabOnlyRun(item) && tabMarkup !== void 0) {
+				folded.push({
+					type: "preservedInline",
+					xml: tabMarkup,
+					text: "",
+					foldedListNumber: {
+						kind: "tab",
+						run: item
+					}
+				});
+				continue;
+			}
+		}
+		if (isListNumberField(item)) {
+			const markup = sourceMarkupOf(item);
+			if (markup !== void 0) {
+				folded.push({
+					type: "preservedInline",
+					xml: markup,
+					text: "",
+					foldedListNumber: {
+						kind: "field",
+						field: item
+					}
+				});
+				const text = cachedListNumberText(item);
+				if (text) cached.push(text);
+				awaitingTab = true;
+				continue;
+			}
+		}
+		folded.push(item);
+		leading = isZeroWidth(item);
+	}
+	return {
+		content: folded,
+		cached,
+		fieldCount
+	};
+};
+const isCapture = (item) => item?.kind === "field" || item?.kind === "tab";
+/**
+* Decide which captures of a paragraph stay hidden, and what its marker shows.
+*
+* `markerShowsFields` says whether the paragraph's marker shows folded fields
+* at all. When it does not, no capture is hidden.
+*
+* When it does, the captures it shows are the ones that open the paragraph:
+* those ahead of the first thing the line shows, each field followed at most
+* by its own tab. Text put in front of them was put in front of the body, not
+* of the marker, so if the first capture no longer opens the paragraph, it
+* and the captures that stand with it go back to the start. Every capture
+* further in is on the line.
+*/
+const planListNumberFold = (items, markerShowsFields) => {
+	const unmoved = items.map((_, index) => index);
+	const none = {
+		order: unmoved,
+		hidden: /* @__PURE__ */ new Set(),
+		suffix: void 0
+	};
+	const first = items.findIndex((item) => isCapture(item));
+	if (!markerShowsFields || first === -1) return none;
+	let order = unmoved;
+	if (items.slice(0, first).some((item) => item.kind === "shown")) {
+		let end = first + 1;
+		for (let index = first + 1; index < items.length; index += 1) {
+			const item = items[index];
+			if (item?.kind === "shown") break;
+			if (isCapture(item)) end = index + 1;
+		}
+		order = [
+			...unmoved.slice(first, end),
+			...unmoved.slice(0, first),
+			...unmoved.slice(end)
+		];
+	}
+	const hidden = /* @__PURE__ */ new Set();
+	const cached = [];
+	let fieldAwaitsTab = false;
+	for (const index of order) {
+		const item = items[index];
+		if (item?.kind === "hidden") continue;
+		if (item?.kind === "field") {
+			hidden.add(index);
+			if (item.cached) cached.push(item.cached);
+			fieldAwaitsTab = true;
+			continue;
+		}
+		if (item?.kind === "tab" && fieldAwaitsTab) {
+			hidden.add(index);
+			fieldAwaitsTab = false;
+			continue;
+		}
+		break;
+	}
+	return cached.length === 0 ? none : {
+		order,
+		hidden,
+		suffix: cached.join(" ")
+	};
+};
+/**
+* What a paragraph's marker says about folded fields. It shows them after a
+* tab its own level text does not have; a bullet shows only its glyph.
+*/
+const listMarkerFoldState = ({ marker, template, isBullet, numbered }) => {
+	const tab = marker?.indexOf("	") ?? -1;
+	if (!marker || !numbered || isBullet || !template || template.includes("	") || tab === -1) return {
+		showsFields: false,
+		base: marker ?? ""
+	};
+	return {
+		showsFields: true,
+		base: marker.slice(0, tab)
+	};
+};
+/** The marker text for `state` showing `suffix`. */
+const listMarkerWithFold = (state, suffix) => suffix === void 0 ? state.base : `${state.base}\t${suffix}`;
+const foldItemOf = (content) => {
+	const folded = foldedListNumberOf(content);
+	if (folded) return folded.kind === "field" ? {
+		kind: "field",
+		cached: cachedListNumberText(folded.field)
+	} : { kind: "tab" };
+	return isZeroWidth(content) ? { kind: "hidden" } : { kind: "shown" };
+};
+/** The item a capture stands for, which shows on the line; any other item is itself. */
+const unfoldedListNumberContent = (content) => {
+	const folded = foldedListNumberOf(content);
+	if (!folded) return content;
+	return folded.kind === "field" ? folded.field : folded.run;
+};
+/**
+* The one definition of a tracked change for the fold: content inserted,
+* deleted, or moved from or to a place under revision tracking.
+*/
+const isTrackedChange = (content) => content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo";
+/**
+* `content` with every capture inside a tracked change replaced by the item
+* it stands for. A tracked change is written with its own spellings (deleted
+* text is `w:delText`, a deleted instruction `w:delInstrText`), which markup
+* replayed as it was read does not have; the field and the run do.
+*/
+const withTrackedCapturesShown = (content) => {
+	let changed = false;
+	const next = content.map((item) => {
+		if (!isTrackedChange(item)) return item;
+		if (!item.content.some((child) => foldedListNumberOf(child) !== void 0)) return item;
+		changed = true;
+		return {
+			...item,
+			content: item.content.map((child) => {
+				const folded = foldedListNumberOf(child);
+				if (!folded) return child;
+				return structuredClone(folded.kind === "field" ? folded.field : folded.run);
+			})
+		};
+	});
+	return changed ? next : content;
+};
+/**
+* Bring `paragraph` to the one form the fold allows: the captures its marker
+* shows stand at its start, every other capture is the field or the tab it
+* stood for, and the marker shows exactly the fields still hidden behind it.
+* A capture under a tracked change is never hidden.
+*/
+const normalizeFoldedListNumbers = (paragraph) => {
+	paragraph.content = withTrackedCapturesShown(paragraph.content);
+	const rendering = paragraph.listRendering;
+	const state = listMarkerFoldState({
+		marker: rendering?.marker,
+		template: rendering?.markerTemplate,
+		isBullet: rendering?.isBullet === true,
+		numbered: rendering !== void 0
+	});
+	const content = paragraph.content;
+	if (!state.showsFields && !content.some(isFoldedListNumberCapture)) return;
+	const plan = planListNumberFold(content.map(foldItemOf), state.showsFields);
+	const next = [];
+	for (const index of plan.order) {
+		const item = content[index];
+		if (item === void 0) continue;
+		next.push(plan.hidden.has(index) || !isFoldedListNumberCapture(item) ? item : structuredClone(unfoldedListNumberContent(item)));
+	}
+	paragraph.content = next;
+	if (rendering && state.showsFields) rendering.marker = listMarkerWithFold(state, plan.suffix);
+};
+//#endregion
+export { foldListNumberFields, foldedListNumberOf, isFoldedListNumber, isFoldedListNumberCapture, isListNumberField, isListNumberGapMarker, isTabOnlyRun, normalizeFoldedListNumbers, planListNumberFold, unfoldedListNumberContent };

package/dist/docx/footnoteParser.d.ts

@@ -67,16 +67,6 @@ declare function parseFootnotes(footnotesXml: string | null, styles?: StyleMap |
  * @returns EndnoteMap with all endnotes
  */
 declare function parseEndnotes(endnotesXml: string | null, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null, context?: ParseContext, previews?: PreviewLedger): EndnoteMap;
-/**
- * Get plain text content of a footnote.
- *
- * Uses the accepted tracked-change view and recurses through every note block.
- */
-declare function getFootnoteText(footnote: document_d_exports.Footnote): string;
-/**
- * Get plain text content of an endnote.
- */
-declare function getEndnoteText(endnote: document_d_exports.Endnote): string;
 /**
  * Check if a footnote is a separator (not regular content)
  */
@@ -102,4 +92,4 @@ declare function mergeFootnoteMaps(...maps: FootnoteMap[]): FootnoteMap;
  */
 declare function mergeEndnoteMaps(...maps: EndnoteMap[]): EndnoteMap;
 //#endregion
-export { EndnoteMap, FootnoteMap, createEmptyEndnoteMap, createEmptyFootnoteMap, getEndnoteText, getFootnoteText, isSeparatorEndnote, isSeparatorFootnote, mergeEndnoteMaps, mergeFootnoteMaps, parseEndnoteProperties, parseEndnotes, parseFootnoteProperties, parseFootnotes };
+export { EndnoteMap, FootnoteMap, createEmptyEndnoteMap, createEmptyFootnoteMap, isSeparatorEndnote, isSeparatorFootnote, mergeEndnoteMaps, mergeFootnoteMaps, parseEndnoteProperties, parseEndnotes, parseFootnoteProperties, parseFootnotes };

package/dist/docx/footnoteParser.js

@@ -1,4 +1,3 @@
-import { blockPlainText } from "./blockPlainText.js";
 import { parseEndnoteProperties, parseFootnoteProperties } from "./notePropertiesParser.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { standalonePreviewLedger } from "./previewBudget.js";
@@ -196,20 +195,6 @@ function createEndnoteMap(byId, endnotes) {
 	};
 }
 /**
-* Get plain text content of a footnote.
-*
-* Uses the accepted tracked-change view and recurses through every note block.
-*/
-function getFootnoteText(footnote) {
-	return blockPlainText(footnote.content);
-}
-/**
-* Get plain text content of an endnote.
-*/
-function getEndnoteText(endnote) {
-	return blockPlainText(endnote.content);
-}
-/**
 * Check if a footnote is a separator (not regular content)
 */
 function isSeparatorFootnote(footnote) {
@@ -258,4 +243,4 @@ function mergeEndnoteMaps(...maps) {
 	return createEndnoteMap(byId, endnotes);
 }
 //#endregion
-export { createEmptyEndnoteMap, createEmptyFootnoteMap, getEndnoteText, getFootnoteText, isSeparatorEndnote, isSeparatorFootnote, mergeEndnoteMaps, mergeFootnoteMaps, parseEndnoteProperties, parseEndnotes, parseFootnoteProperties, parseFootnotes };
+export { createEmptyEndnoteMap, createEmptyFootnoteMap, isSeparatorEndnote, isSeparatorFootnote, mergeEndnoteMaps, mergeFootnoteMaps, parseEndnoteProperties, parseEndnotes, parseFootnoteProperties, parseFootnotes };

package/dist/docx/headerFooterParser.d.ts

@@ -81,14 +81,6 @@ declare function createEmptyHeaderFooterMap(): HeaderFooterMap;
  * @returns HeaderFooterMap with all parsed headers/footers
  */
 declare function buildHeaderFooterMap(references: (document_d_exports.HeaderReference | document_d_exports.FooterReference)[], xmlContents: Map<string, string>, isHeader: boolean, styles?: StyleMap | null, theme?: document_d_exports.Theme | null, numbering?: NumberingMap | null, rels?: document_d_exports.RelationshipMap | null, media?: Map<string, document_d_exports.MediaFile> | null): HeaderFooterMap;
-/**
- * Get plain text content of a header/footer.
- *
- * Shares one walk with the note stories: this used to read only text runs, so a
- * header's fields, hyperlinks, tabs and breaks were silently absent from its
- * text while the same paragraph in a footnote read in full.
- */
-declare function getHeaderFooterText(hf: document_d_exports.HeaderFooter): string;
 /**
  * Check if header/footer is empty (no content)
  */
@@ -129,4 +121,4 @@ declare function hasImages(hf: document_d_exports.HeaderFooter): boolean;
  */
 declare function hasTables(hf: document_d_exports.HeaderFooter): boolean;
 //#endregion
-export { HeaderFooterMap, buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderFooterText, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };
+export { HeaderFooterMap, buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };

package/dist/docx/headerFooterParser.js

@@ -1,5 +1,4 @@
 import { parseBlockContent } from "./blockContentParser.js";
-import { blockPlainText } from "./blockPlainText.js";
 import { parseFooterReference, parseFooterReferences, parseHeaderReference, parseHeaderReferences } from "./headerFooterRefParser.js";
 import { assignHeaderFooterVerbatimXml } from "./headerFooterVerbatim.js";
 import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
@@ -150,16 +149,6 @@ function buildHeaderFooterMap(references, xmlContents, isHeader, styles = null,
 	return createHeaderFooterMap(byId);
 }
 /**
-* Get plain text content of a header/footer.
-*
-* Shares one walk with the note stories: this used to read only text runs, so a
-* header's fields, hyperlinks, tabs and breaks were silently absent from its
-* text while the same paragraph in a footnote read in full.
-*/
-function getHeaderFooterText(hf) {
-	return blockPlainText(hf.content);
-}
-/**
 * Check if header/footer is empty (no content)
 */
 function isEmptyHeaderFooter(hf) {
@@ -254,4 +243,4 @@ function hasTables(hf) {
 	return false;
 }
 //#endregion
-export { buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderFooterText, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };
+export { buildHeaderFooterMap, createEmptyHeaderFooterMap, getFooterForPage, getHeaderForPage, hasImages, hasPageNumberField, hasTables, headerFooterMapToTypeMap, isEmptyHeaderFooter, parseFooter, parseFooterReference, parseFooterReferences, parseHeader, parseHeaderFooter, parseHeaderReference, parseHeaderReferences };

package/dist/docx/headerFooterVerbatim.d.ts

@@ -1,9 +1,47 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/headerFooterVerbatim.d.ts
+type HeaderFooterSourceBaseline = {
+  type: "missing";
+} | {
+  type: "mismatch";
+} | {
+  type: "captured";
+  content: readonly document_d_exports.BlockContent[];
+};
+declare const captureHeaderFooterPackageBaselines: (document: document_d_exports.Document) => void;
+/**
+ * Transfer body, header and footer capture handles across a trusted
+ * document graph clone. `structuredClone` drops symbol-keyed properties, so a
+ * clone would otherwise read an edited part as uncaptured ("missing") rather
+ * than as a mismatch against its source.
+ */
+declare const copyHeaderFooterBaselineHandles: (target: document_d_exports.Document, source: document_d_exports.Document) => void;
+/** Transfer the parsed package registry only across a trusted document graph clone. */
+declare const copyHeaderFooterPackageBaselines: (target: document_d_exports.Document, source: document_d_exports.Document) => void;
+declare const getHeaderFooterSourceBaseline: (hf: document_d_exports.HeaderFooter, originalBuffer?: ArrayBuffer) => HeaderFooterSourceBaseline;
+declare const canReplayHeaderFooterBlocks: (hf: document_d_exports.HeaderFooter, baselineContent: readonly document_d_exports.BlockContent[]) => boolean;
 declare const getHeaderFooterVerbatimXml: (hf: document_d_exports.HeaderFooter) => string | undefined;
 declare const canReplayHeaderFooterVerbatim: (hf: document_d_exports.HeaderFooter) => boolean;
 declare const assignHeaderFooterVerbatimXml: (hf: document_d_exports.HeaderFooter, xml: string) => void;
 declare const refreshHeaderFooterVerbatimFingerprint: (hf: document_d_exports.HeaderFooter) => void;
 declare const clearHeaderFooterVerbatimXml: (hf: document_d_exports.HeaderFooter) => void;
+/** Capture the body in the same trusted package registry as secondary stories. */
+declare const captureDocumentSourceBaseline: (document: document_d_exports.Document, xml: string) => void;
+declare const getDocumentSourceBaseline: (document: document_d_exports.Document) => {
+  type: "missing";
+} | {
+  type: "mismatch";
+} | {
+  type: "captured";
+  body: document_d_exports.Document["package"]["document"];
+  xml: string;
+  fingerprint: string;
+  resourceStyles: document_d_exports.Document["package"]["styles"];
+  resourceRelationships: document_d_exports.Document["package"]["relationships"];
+  resourceMedia: ReadonlyMap<string, {
+    data: ArrayBuffer;
+    mimeType: string;
+  }>;
+};
 //#endregion
-export { assignHeaderFooterVerbatimXml, canReplayHeaderFooterVerbatim, clearHeaderFooterVerbatimXml, getHeaderFooterVerbatimXml, refreshHeaderFooterVerbatimFingerprint };
+export { assignHeaderFooterVerbatimXml, canReplayHeaderFooterBlocks, canReplayHeaderFooterVerbatim, captureDocumentSourceBaseline, captureHeaderFooterPackageBaselines, clearHeaderFooterVerbatimXml, copyHeaderFooterBaselineHandles, copyHeaderFooterPackageBaselines, getDocumentSourceBaseline, getHeaderFooterSourceBaseline, getHeaderFooterVerbatimXml, refreshHeaderFooterVerbatimFingerprint };

package/dist/docx/headerFooterVerbatim.js

@@ -1,5 +1,117 @@
+import { canonicalJson } from "../utils/canonicalJson.js";
+import { Result } from "better-result";
 //#region src/docx/headerFooterVerbatim.ts
+const fingerprintBaselines = /* @__PURE__ */ new WeakMap();
+const readFingerprint = (hf) => {
+	const fingerprint = hf.verbatimFingerprint;
+	if (!fingerprint) return void 0;
+	const cached = fingerprintBaselines.get(hf);
+	if (cached?.fingerprint === fingerprint) return cached.value;
+	const parsed = Result.try(() => JSON.parse(fingerprint));
+	const value = parsed.isOk() ? parsed.value : void 0;
+	fingerprintBaselines.set(hf, {
+		fingerprint,
+		value
+	});
+	return value;
+};
+const BASELINE_HANDLE = Symbol("package-source-baseline");
+const contentBaselines = /* @__PURE__ */ new WeakMap();
+const captureContentBaseline = (hf) => {
+	const fingerprint = hf.verbatimFingerprint;
+	if (fingerprint === void 0) return;
+	const handle = {};
+	const content = structuredClone(hf.content);
+	contentBaselines.set(handle, {
+		type: "headerFooter",
+		fingerprint,
+		xml: hf.verbatimXml,
+		contentFingerprint: canonicalJson(content),
+		content
+	});
+	Object.defineProperty(hf, BASELINE_HANDLE, {
+		value: handle,
+		enumerable: true,
+		configurable: true
+	});
+};
+const packageBaselines = /* @__PURE__ */ new WeakMap();
+const captureHeaderFooterPackageBaselines = (document) => {
+	if (!document.originalBuffer) return;
+	const handles = /* @__PURE__ */ new Map();
+	for (const parts of [document.package.headers, document.package.footers]) for (const hf of parts?.values() ?? []) {
+		if (!(BASELINE_HANDLE in hf) || typeof hf[BASELINE_HANDLE] !== "object" || hf[BASELINE_HANDLE] === null || hf.verbatimFingerprint === void 0 || hf.verbatimXml === void 0) continue;
+		const bySource = handles.get(hf.verbatimFingerprint) ?? /* @__PURE__ */ new Map();
+		bySource.set(hf.verbatimXml, hf[BASELINE_HANDLE]);
+		handles.set(hf.verbatimFingerprint, bySource);
+	}
+	packageBaselines.set(document.originalBuffer, handles);
+};
+/**
+* Transfer body, header and footer capture handles across a trusted
+* document graph clone. `structuredClone` drops symbol-keyed properties, so a
+* clone would otherwise read an edited part as uncaptured ("missing") rather
+* than as a mismatch against its source.
+*/
+const copyHeaderFooterBaselineHandles = (target, source) => {
+	const sourceBody = source.package.document;
+	if (BASELINE_HANDLE in sourceBody) Object.defineProperty(target.package.document, BASELINE_HANDLE, {
+		value: sourceBody[BASELINE_HANDLE],
+		enumerable: true,
+		configurable: true
+	});
+	for (const kind of ["headers", "footers"]) {
+		const targets = target.package[kind];
+		for (const [rId, sourcePart] of source.package[kind] ?? []) {
+			if (!(BASELINE_HANDLE in sourcePart)) continue;
+			const targetPart = targets?.get(rId);
+			if (!targetPart) continue;
+			Object.defineProperty(targetPart, BASELINE_HANDLE, {
+				value: sourcePart[BASELINE_HANDLE],
+				enumerable: true,
+				configurable: true
+			});
+		}
+	}
+};
+/** Transfer the parsed package registry only across a trusted document graph clone. */
+const copyHeaderFooterPackageBaselines = (target, source) => {
+	if (!target.originalBuffer || !source.originalBuffer) return;
+	const baselines = packageBaselines.get(source.originalBuffer);
+	if (baselines) packageBaselines.set(target.originalBuffer, baselines);
+};
+const getHeaderFooterSourceBaseline = (hf, originalBuffer) => {
+	let handle;
+	if (BASELINE_HANDLE in hf) handle = hf[BASELINE_HANDLE];
+	else if (originalBuffer && hf.verbatimFingerprint !== void 0 && hf.verbatimXml !== void 0) handle = packageBaselines.get(originalBuffer)?.get(hf.verbatimFingerprint)?.get(hf.verbatimXml);
+	if (handle === void 0 && !(BASELINE_HANDLE in hf)) return { type: "missing" };
+	if (typeof handle !== "object" || handle === null) return { type: "mismatch" };
+	const baseline = contentBaselines.get(handle);
+	if (!baseline || baseline.type !== "headerFooter" || baseline.fingerprint !== hf.verbatimFingerprint || baseline.xml !== hf.verbatimXml || baseline.contentFingerprint !== canonicalJson(baseline.content)) return { type: "mismatch" };
+	return {
+		type: "captured",
+		content: baseline.content
+	};
+};
+const canReplayHeaderFooterBlocks = (hf, baselineContent) => {
+	if (hf.rawWatermarkXml !== void 0) {
+		const index = hf.watermarkBlockIndex;
+		if (index === void 0 || !Number.isInteger(index) || index < 0 || index >= baselineContent.length || baselineContent.length !== hf.content.length || canonicalJson(baselineContent.at(index)) !== canonicalJson(hf.content.at(index))) return false;
+	}
+	const baseline = readFingerprint(hf);
+	if (baseline === null || typeof baseline !== "object" || !("type" in baseline) || baseline.type !== hf.type) return false;
+	return canonicalJson({
+		watermark: "watermark" in baseline ? baseline.watermark : void 0,
+		watermarkBlockIndex: "watermarkBlockIndex" in baseline ? baseline.watermarkBlockIndex : void 0,
+		rawWatermarkXml: "rawWatermarkXml" in baseline ? baseline.rawWatermarkXml : void 0
+	}) === canonicalJson({
+		watermark: hf.watermark,
+		watermarkBlockIndex: hf.watermarkBlockIndex,
+		rawWatermarkXml: hf.rawWatermarkXml
+	});
+};
 const headerFooterSerializationFingerprint = (hf) => JSON.stringify({
+	type: hf.type,
 	content: hf.content,
 	watermark: hf.watermark,
 	watermarkBlockIndex: hf.watermarkBlockIndex,
@@ -9,22 +121,81 @@ const getHeaderFooterVerbatimXml = (hf) => hf.verbatimXml;
 const canReplayHeaderFooterVerbatim = (hf) => {
 	const ext = hf;
 	if (!ext.verbatimXml || !ext.verbatimFingerprint) return false;
-	return ext.verbatimFingerprint === headerFooterSerializationFingerprint(hf);
+	return canonicalJson(readFingerprint(hf)) === canonicalJson({
+		type: hf.type,
+		content: hf.content,
+		watermark: hf.watermark,
+		watermarkBlockIndex: hf.watermarkBlockIndex,
+		rawWatermarkXml: hf.rawWatermarkXml
+	});
 };
 const assignHeaderFooterVerbatimXml = (hf, xml) => {
 	const ext = hf;
 	ext.verbatimXml = xml;
 	ext.verbatimFingerprint = headerFooterSerializationFingerprint(hf);
+	captureContentBaseline(hf);
 };
 const refreshHeaderFooterVerbatimFingerprint = (hf) => {
 	const ext = hf;
 	if (!ext.verbatimXml) return;
 	ext.verbatimFingerprint = headerFooterSerializationFingerprint(hf);
+	captureContentBaseline(hf);
 };
 const clearHeaderFooterVerbatimXml = (hf) => {
 	const ext = hf;
 	delete ext.verbatimXml;
 	delete ext.verbatimFingerprint;
+	Reflect.deleteProperty(hf, BASELINE_HANDLE);
+};
+/** Capture the body in the same trusted package registry as secondary stories. */
+const captureDocumentSourceBaseline = (document, xml) => {
+	const body = structuredClone(document.package.document);
+	const handle = {};
+	contentBaselines.set(handle, {
+		type: "body",
+		fingerprint: { type: "pending" },
+		xml,
+		body,
+		resourceStyles: structuredClone(document.package.styles),
+		resourceRelationships: structuredClone(document.package.relationships),
+		resourceMedia: new Map([...document.package.media ?? []].map(([path, media]) => [path, {
+			data: media.data,
+			mimeType: media.mimeType
+		}]))
+	});
+	Object.defineProperty(document.package.document, BASELINE_HANDLE, {
+		value: handle,
+		enumerable: true,
+		configurable: true
+	});
+	if (document.originalBuffer) {
+		const registry = packageBaselines.get(document.originalBuffer) ?? /* @__PURE__ */ new Map();
+		registry.set("word/document.xml", /* @__PURE__ */ new Map([["body", handle]]));
+		packageBaselines.set(document.originalBuffer, registry);
+	}
+};
+const getDocumentSourceBaseline = (document) => {
+	const body = document.package.document;
+	const handle = BASELINE_HANDLE in body ? body[BASELINE_HANDLE] : document.originalBuffer && packageBaselines.get(document.originalBuffer)?.get("word/document.xml")?.get("body");
+	if (handle === void 0) return { type: "missing" };
+	if (typeof handle !== "object" || handle === null) return { type: "mismatch" };
+	const baseline = contentBaselines.get(handle);
+	if (!baseline || baseline.type !== "body") return { type: "mismatch" };
+	const fingerprint = JSON.stringify(baseline.body);
+	if (baseline.fingerprint.type === "pending") baseline.fingerprint = {
+		type: "captured",
+		value: fingerprint
+	};
+	if (baseline.fingerprint.value !== fingerprint) return { type: "mismatch" };
+	return {
+		type: "captured",
+		body: baseline.body,
+		xml: baseline.xml,
+		fingerprint,
+		resourceStyles: baseline.resourceStyles,
+		resourceRelationships: baseline.resourceRelationships,
+		resourceMedia: baseline.resourceMedia
+	};
 };
 //#endregion
-export { assignHeaderFooterVerbatimXml, canReplayHeaderFooterVerbatim, clearHeaderFooterVerbatimXml, getHeaderFooterVerbatimXml, refreshHeaderFooterVerbatimFingerprint };
+export { assignHeaderFooterVerbatimXml, canReplayHeaderFooterBlocks, canReplayHeaderFooterVerbatim, captureDocumentSourceBaseline, captureHeaderFooterPackageBaselines, clearHeaderFooterVerbatimXml, copyHeaderFooterBaselineHandles, copyHeaderFooterPackageBaselines, getDocumentSourceBaseline, getHeaderFooterSourceBaseline, getHeaderFooterVerbatimXml, refreshHeaderFooterVerbatimFingerprint };

package/dist/docx/imageParser.d.ts

@@ -22,6 +22,18 @@ declare function resolveImageData(rId: string | undefined, rels: document_d_expo
   mimeType?: string;
   filename?: string;
 };
+type ImageDerivedFactsOptions = {
+  id: string | undefined;
+  pictureNames: NonNullable<document_d_exports.Image["pictureNames"]>;
+  imageData: ReturnType<typeof resolveImageData>;
+};
+/** Facts the parser obtains from exported drawing markup and image relationships. */
+declare const imageDerivedFactsOf: ({ id, pictureNames, imageData }: ImageDerivedFactsOptions) => {
+  filename?: string;
+  mimeType?: string;
+  pictureNames?: import("@stll/docx-core/model").NonVisualDrawingNames;
+  id?: string;
+};
 /**
  * Parse a w:drawing element
  *
@@ -97,4 +109,4 @@ declare function getWrapDistancesPx(image: document_d_exports.Image): {
  */
 declare function needsTextWrapping(image: document_d_exports.Image): boolean;
 //#endregion
-export { DECORATIVE_EXTENSION_URI, DECORATIVE_NAMESPACE, getImageDimensionsPx, getImageHeightPx, getImageWidthPx, getWrapDistancesPx, hasAltText, isBehindText, isDecorativeImage, isFloatingImage, isInFrontOfText, isInlineImage, needsTextWrapping, parseDrawing, parseImage, resolveImageData };
+export { DECORATIVE_EXTENSION_URI, DECORATIVE_NAMESPACE, getImageDimensionsPx, getImageHeightPx, getImageWidthPx, getWrapDistancesPx, hasAltText, imageDerivedFactsOf, isBehindText, isDecorativeImage, isFloatingImage, isInFrontOfText, isInlineImage, needsTextWrapping, parseDrawing, parseImage, resolveImageData };