@stll/folio-core 0.54.1 → 0.55.0

package/dist/docx/parser.js

@@ -8,24 +8,26 @@ import { DANGLING_COMMENT_REFERENCE_WARNING, UNBALANCED_COMMENT_RANGE_WARNING, n
 import { detectDocxConformanceClass } from "./conformance.js";
 import { parseCoreProperties } from "./corePropertiesParser.js";
 import { countDanglingRelationshipReferences } from "./danglingRelationshipReferences.js";
-import { extractAllTemplateVariables, parseDocumentBody } from "./documentParser.js";
+import { extractAllTemplateVariables, parseDocumentBody, parseDocumentBodyTree } from "./documentParser.js";
 import { normalizeDrawingIds } from "./drawingIdNormalization.js";
 import { DocxEncryptionError } from "./encryption/errors.js";
 import { parseFontTable } from "./fontTableParser.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
 import { parseFooter, parseHeader } from "./headerFooterParser.js";
 import { DANGLING_FOOTER_REFERENCE_WARNING, DANGLING_HEADER_REFERENCE_WARNING, assignHeaderFooterRoles, normalizeHeaderFooterReferences } from "./headerFooterReferenceNormalization.js";
-import { assignHeaderFooterVerbatimXml, canReplayHeaderFooterVerbatim, refreshHeaderFooterVerbatimFingerprint } from "./headerFooterVerbatim.js";
+import { assignHeaderFooterVerbatimXml, canReplayHeaderFooterVerbatim, captureHeaderFooterPackageBaselines, refreshHeaderFooterVerbatimFingerprint } from "./headerFooterVerbatim.js";
 import { extractMetafileRaster, isMetafileMimeType } from "./metafileRaster.js";
 import { renderEmfSvg } from "./metafileSvg.js";
 import { DocxModelValidationError, formatDocumentModelIssues, validateFolioDocumentModel } from "./modelValidation.js";
 import { parseNumbering } from "./numberingParser.js";
 import { UNNUMBERED_PARAGRAPH_WARNING, UNNUMBERED_STYLE_WARNING, normalizeNumberingReferences, normalizeStyleNumberingReferences } from "./numberingReferenceNormalization.js";
+import { normalizeRawDocxNumericIds } from "./numericIdNormalization.js";
 import { countOpaqueRevisionWrappers } from "./opaqueCarrier.js";
 import { assignDocumentParagraphPropertySourceContract } from "./paragraphPropertySource.js";
 import { createParseWarningCollector } from "./parseContext.js";
 import { formatParseWarnings } from "./parseWarningMessage.js";
 import { createPackagePreviewBudget } from "./previewBudget.js";
+import { detectRasterMimeType } from "./rasterMime.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { normalizeRenderedPageBreakHints } from "./renderedPageBreakNormalization.js";
 import { parseSettings } from "./settingsParser.js";
@@ -33,7 +35,7 @@ import { parseStylesPackage } from "./styleParser.js";
 import { applyThemeFontLang, parseTheme } from "./themeParser.js";
 import { UNBALANCED_MOVE_RANGE_WARNING, normalizeTrackedMoveRanges } from "./trackedMoveRangeNormalization.js";
 import { getEntryUncompressedSize, getMediaMimeType, mediaToDataUrl, unzipDocx } from "./unzip.js";
-import { getAttribute, getChildElements, getLocalName, parseXmlDocument } from "./xmlParser.js";
+import { getAttribute, getChildElements, getLocalName, parseXml, parseXmlDocument } from "./xmlParser.js";
 import { FOLIO_XML_RESOURCE_LIMITS } from "./xmlResourceLimits.js";
 import { TaggedError, panic } from "better-result";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
@@ -184,13 +186,14 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 	try {
 		const timeStage = (_name, fn) => fn();
 		const timeStageAsync = async (_name, fn) => await fn();
-		const paragraphPropertySourceDigest = sha256Hex(buffer);
 		onProgress("Extracting DOCX...", 0);
 		const raw = await timeStageAsync("unzip", () => unzipDocx(buffer, {
 			...unzipLimits,
 			password,
 			extractAllXml: false
 		}));
+		const repairedDocumentTree = await normalizeRawDocxNumericIds(raw);
+		const paragraphPropertySourceDigest = sha256Hex(raw.originalBuffer);
 		if (raw.wasEncrypted) parseContext.warn({ code: PARSE_WARNING_CODES.packageDecrypted });
 		for (const message of raw.warnings) parseContext.warn({
 			code: PARSE_WARNING_CODES.packageArchive,
@@ -227,7 +230,16 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 		onProgress("Parsing document body...", 40);
 		let documentBody = { content: [] };
 		timeStage("documentBody", () => {
-			if (raw.documentXml) documentBody = parseDocumentBody(raw.documentXml, styles, theme, numbering, rels, media, parseContext.scoped({ part: "word/document.xml" }), previews.ledger);
+			if (raw.documentXml) documentBody = parseDocumentBodyTree({
+				doc: repairedDocumentTree ?? parseXml(raw.documentXml),
+				styles,
+				theme,
+				numbering,
+				rels,
+				media,
+				context: parseContext.scoped({ part: "word/document.xml" }),
+				previews: previews.ledger
+			});
 			else parseContext.warn({ code: PARSE_WARNING_CODES.documentPartMissing });
 		});
 		onProgress("Parsed document body", 55);
@@ -461,6 +473,7 @@ async function parseDocxWithPreviewBudget(input, options, previewBudget) {
 			document.warnings = formatParseWarnings(parseWarnings);
 		}
 		onProgress("Complete", 100);
+		captureHeaderFooterPackageBaselines(document);
 		return document;
 	} catch (error) {
 		if (error instanceof DocxEncryptionError) throw error;
@@ -507,7 +520,7 @@ async function buildMediaMap(raw, rels) {
 	let remainingEmfPreviewBytes = MAX_PACKAGE_EMF_PREVIEW_BYTES;
 	for (const [path, data] of raw.media.entries()) {
 		const filename = path.split("/").pop() || path;
-		const mimeType = getMediaMimeType(path);
+		const mimeType = detectRasterMimeType(data) ?? getMediaMimeType(path);
 		const isReferenced = referenced.has(path.toLowerCase());
 		if (isReferenced && isTiffMimeType(mimeType) && remainingTiffPixels > 0) {
 			const converted = await convertTiffToPngDataUrl(data, remainingTiffPixels);

package/dist/docx/rasterMime.d.ts

@@ -0,0 +1,64 @@
+//#region src/docx/rasterMime.d.ts
+declare const RASTER_SIGNATURES: readonly [{
+  readonly mimeType: "image/png";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [137, 80, 78, 71];
+  }];
+}, {
+  readonly mimeType: "image/jpeg";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [255, 216];
+  }];
+}, {
+  readonly mimeType: "image/gif";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [71, 73, 70, 56];
+  }];
+}, {
+  readonly mimeType: "image/bmp";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [66, 77];
+  }];
+}, {
+  readonly mimeType: "image/webp";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [82, 73, 70, 70];
+  }, {
+    readonly offset: 8;
+    readonly bytes: readonly [87, 69, 66, 80];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [73, 73, 42, 0];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [77, 77, 0, 42];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [73, 73, 43, 0];
+  }];
+}, {
+  readonly mimeType: "image/tiff";
+  readonly chunks: readonly [{
+    readonly offset: 0;
+    readonly bytes: readonly [77, 77, 0, 43];
+  }];
+}];
+type RasterMimeType = (typeof RASTER_SIGNATURES)[number]["mimeType"];
+declare const RASTER_MIME_TYPES: ReadonlySet<string>;
+declare const detectRasterMimeType: (data: ArrayBuffer) => RasterMimeType | undefined;
+//#endregion
+export { RASTER_MIME_TYPES, RasterMimeType, detectRasterMimeType };

package/dist/docx/rasterMime.js

@@ -0,0 +1,116 @@
+//#region src/docx/rasterMime.ts
+const RASTER_SIGNATURES = [
+	{
+		mimeType: "image/png",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				137,
+				80,
+				78,
+				71
+			]
+		}]
+	},
+	{
+		mimeType: "image/jpeg",
+		chunks: [{
+			offset: 0,
+			bytes: [255, 216]
+		}]
+	},
+	{
+		mimeType: "image/gif",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				71,
+				73,
+				70,
+				56
+			]
+		}]
+	},
+	{
+		mimeType: "image/bmp",
+		chunks: [{
+			offset: 0,
+			bytes: [66, 77]
+		}]
+	},
+	{
+		mimeType: "image/webp",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				82,
+				73,
+				70,
+				70
+			]
+		}, {
+			offset: 8,
+			bytes: [
+				87,
+				69,
+				66,
+				80
+			]
+		}]
+	},
+	{
+		mimeType: "image/tiff",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				73,
+				73,
+				42,
+				0
+			]
+		}]
+	},
+	{
+		mimeType: "image/tiff",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				77,
+				77,
+				0,
+				42
+			]
+		}]
+	},
+	{
+		mimeType: "image/tiff",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				73,
+				73,
+				43,
+				0
+			]
+		}]
+	},
+	{
+		mimeType: "image/tiff",
+		chunks: [{
+			offset: 0,
+			bytes: [
+				77,
+				77,
+				0,
+				43
+			]
+		}]
+	}
+];
+const RASTER_MIME_TYPES = new Set(RASTER_SIGNATURES.map(({ mimeType }) => mimeType));
+const detectRasterMimeType = (data) => {
+	const bytes = new Uint8Array(data);
+	return RASTER_SIGNATURES.find(({ chunks }) => chunks.every(({ offset, bytes: signature }) => signature.every((byte, index) => bytes[offset + index] === byte)))?.mimeType;
+};
+//#endregion
+export { RASTER_MIME_TYPES, detectRasterMimeType };

package/dist/docx/replyToComment.js

@@ -1,10 +1,16 @@
+import { allocateCommentId, seedCommentIdAbove } from "../prosemirror/commentIdAllocator.js";
 import { generateHexId } from "../utils/hexId.js";
 //#region src/docx/replyToComment.ts
-const nextCommentId = (comments) => {
-	let max = 0;
-	for (const comment of comments) if (comment.id > max) max = comment.id;
-	return max + 1;
-};
+/**
+* Create a threaded reply to an existing comment.
+*
+* Produces a new `Comment` whose `parentId` points at the target comment and
+* whose last paragraph carries a fresh `w14:paraId`, and guarantees the parent
+* has a paraId too — the two ids Word uses to link a reply to its thread in
+* `commentsExtended.xml` (`w15:paraId` / `w15:paraIdParent`). The reply's
+* `document.xml` range markers are synthesized at save time by
+* {@link applyReplyThreadMarkers}, so no anchor work is needed here.
+*/
 const usedParaIds = (comments) => {
 	const ids = /* @__PURE__ */ new Set();
 	for (const comment of comments) for (const paragraph of comment.content) if (paragraph.paraId) ids.add(paragraph.paraId.toUpperCase());
@@ -32,6 +38,7 @@ const createReply = (comments, parentCommentId, input) => {
 	const threadRootId = parent.parentId ?? parent.id;
 	const rootLastParagraph = ((comments.find((comment) => comment.id === threadRootId) ?? parent).content ?? []).at(-1);
 	if (!rootLastParagraph) return null;
+	for (const { id } of comments) seedCommentIdAbove(id);
 	const used = usedParaIds(comments);
 	if (!rootLastParagraph.paraId) rootLastParagraph.paraId = freshParaId(used);
 	const replyParagraph = {
@@ -48,7 +55,7 @@ const createReply = (comments, parentCommentId, input) => {
 		}]
 	};
 	return {
-		id: nextCommentId(comments),
+		id: allocateCommentId(),
 		author: input.author,
 		date: input.date ?? (/* @__PURE__ */ new Date()).toISOString(),
 		parentId: threadRootId,

package/dist/docx/reviewHistoryNamespace.d.ts

@@ -0,0 +1,4 @@
+//#region src/docx/reviewHistoryNamespace.d.ts
+declare const FOLIO_REVIEW_HISTORY_NAMESPACE = "urn:stella:folio:review-history:1";
+//#endregion
+export { FOLIO_REVIEW_HISTORY_NAMESPACE };

package/dist/docx/reviewHistoryNamespace.js

@@ -0,0 +1,4 @@
+//#region src/docx/reviewHistoryNamespace.ts
+const FOLIO_REVIEW_HISTORY_NAMESPACE = "urn:stella:folio:review-history:1";
+//#endregion
+export { FOLIO_REVIEW_HISTORY_NAMESPACE };

package/dist/docx/reviewResolutionProvenance.d.ts

@@ -0,0 +1,25 @@
+import { document_d_exports } from "../types/document.js";
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/reviewResolutionProvenance.d.ts
+type ResolutionJoins = NonNullable<document_d_exports.Insertion["resolutionJoins"]>;
+type BoundaryJoins = NonNullable<document_d_exports.RunPropertyChange["boundaryJoins"]>;
+declare const isResolutionJoins: (value: unknown) => value is ResolutionJoins;
+declare const isParagraphMarkResolutionJoin: (value: unknown) => value is NonNullable<document_d_exports.ParagraphMarkChange["resolutionJoin"]>;
+declare const isBoundaryJoins: (value: unknown) => value is BoundaryJoins;
+declare const ReviewResolutionProvenanceError_base: import("better-result").TaggedErrorClass<"ReviewResolutionProvenanceError">;
+declare class ReviewResolutionProvenanceError extends ReviewResolutionProvenanceError_base<{
+  message: string;
+  attribute: string;
+  reason: "invalid" | "unsupportedVersion" | "unrepresentable";
+}> {}
+declare const parseResolutionJoins: (node: XmlElement) => ResolutionJoins | undefined;
+declare const parseBoundaryJoins: (node: XmlElement) => BoundaryJoins | undefined;
+declare const serializeResolutionJoins: (value: document_d_exports.Insertion["resolutionJoins"]) => string;
+declare const serializeBoundaryJoins: (value: document_d_exports.RunPropertyChange["boundaryJoins"]) => string;
+/** Null carries an owned undefined depth; a missing attribute carries no field. */
+declare const parseParagraphMarkResolutionJoin: (node: XmlElement) => Pick<document_d_exports.ParagraphMarkChange, "resolutionJoin">;
+declare const serializeParagraphMarkResolutionJoin: (mark: document_d_exports.ParagraphMarkChange) => string;
+/** Captured paragraph properties compose the same envelope into a parsed XML element. */
+declare const paragraphMarkResolutionJoinAttributes: (mark: document_d_exports.ParagraphMarkChange) => Record<string, string>;
+//#endregion
+export { ReviewResolutionProvenanceError, isBoundaryJoins, isParagraphMarkResolutionJoin, isResolutionJoins, paragraphMarkResolutionJoinAttributes, parseBoundaryJoins, parseParagraphMarkResolutionJoin, parseResolutionJoins, serializeBoundaryJoins, serializeParagraphMarkResolutionJoin, serializeResolutionJoins };

package/dist/docx/reviewResolutionProvenance.js

@@ -0,0 +1,153 @@
+import { FOLIO_REVIEW_HISTORY_NAMESPACE } from "./reviewHistoryNamespace.js";
+import { getAttributeByNamespaceUri } from "./xmlParser.js";
+import { Result, TaggedError } from "better-result";
+import { escapeXmlAttribute } from "@stll/docx-core";
+import { MAX_REVISION_ID } from "@stll/docx-core/model";
+//#region src/docx/reviewResolutionProvenance.ts
+const NAMESPACES = /* @__PURE__ */ new Set([FOLIO_REVIEW_HISTORY_NAMESPACE]);
+const VERSION = 1;
+const MAX_ATTRIBUTE_LENGTH = 32768;
+const SLOT_FIELDS = {
+	space: true,
+	id: true
+};
+const RETAINED_FIELDS = {
+	depth: true,
+	source: true,
+	target: true
+};
+const JOIN_FIELDS = {
+	before: true,
+	after: true,
+	remove: true,
+	retainedAfter: true,
+	deferredRemove: true,
+	acceptance: true
+};
+const ACCEPTANCE_POLICIES = { "merge-plain-runs": true };
+const PARAGRAPH_MARK_FIELDS = {
+	kind: { type: "ooxml" },
+	info: { type: "ooxml" },
+	resolutionJoin: {
+		type: "private",
+		attribute: "resolutionJoin"
+	}
+};
+const DEFERRED_REMOVAL_FIELDS = {
+	depth: true,
+	blockers: true
+};
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const natural = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const slots = (value) => Array.isArray(value) && value.every((slot) => record(slot) && Object.keys(slot).every((key) => Object.hasOwn(SLOT_FIELDS, key)) && (slot["space"] === "revision" || slot["space"] === "control") && natural(slot["id"]) && slot["id"] <= MAX_REVISION_ID);
+const retained = (value) => Array.isArray(value) && value.every((item) => {
+	if (!record(item)) return false;
+	const source = item["source"];
+	const target = item["target"];
+	return Object.keys(item).every((key) => Object.hasOwn(RETAINED_FIELDS, key)) && natural(item["depth"]) && slots(source) && slots(target) && source.length === target.length && source.every((slot, index) => slot.space === target.at(index)?.space);
+});
+const deferredRemoval = (value) => {
+	if (!record(value) || Object.keys(value).some((key) => !Object.hasOwn(DEFERRED_REMOVAL_FIELDS, key))) return false;
+	const depth = value["depth"];
+	const blockers = value["blockers"];
+	return natural(depth) && depth <= MAX_REVISION_ID && Array.isArray(blockers) && blockers.length > 0 && !blockers.includes(void 0) && new Set(blockers).size === blockers.length && blockers.every((blocker) => natural(blocker) && blocker <= MAX_REVISION_ID);
+};
+const deferredRemovals = (value) => {
+	if (!Array.isArray(value) || value.length === 0 || value.includes(void 0) || !value.every(deferredRemoval)) return false;
+	const groups = value.map(({ depth, blockers }) => JSON.stringify({
+		depth,
+		blockers
+	}));
+	return new Set(groups).size === groups.length;
+};
+const isResolutionJoins = (value) => record(value) && Object.keys(value).every((key) => Object.hasOwn(JOIN_FIELDS, key)) && natural(value["before"]) && natural(value["after"]) && natural(value["remove"]) && (!Object.hasOwn(value, "acceptance") || typeof value["acceptance"] === "string" && Object.hasOwn(ACCEPTANCE_POLICIES, value["acceptance"])) && (value["retainedAfter"] === void 0 || retained(value["retainedAfter"])) && (!Object.hasOwn(value, "deferredRemove") || deferredRemovals(value["deferredRemove"]));
+const isParagraphMarkResolutionJoin = (value) => natural(value) && value <= MAX_REVISION_ID;
+const isEncodedParagraphMarkResolutionJoin = (value) => value === null || isParagraphMarkResolutionJoin(value);
+const isBoundaryJoins = (value) => Array.isArray(value) && value.length <= 2 && new Set(value).size === value.length && value.every((side) => side === "before" || side === "after");
+var ReviewResolutionProvenanceError = class extends TaggedError("ReviewResolutionProvenanceError") {};
+const parseAttribute = ({ node, attribute, valid }) => {
+	const encoded = getAttributeByNamespaceUri(node, NAMESPACES, attribute);
+	if (encoded === null) return void 0;
+	const failed = (reason = "invalid") => new ReviewResolutionProvenanceError({
+		attribute,
+		message: `Invalid or unsupported ${attribute} review provenance.`,
+		reason
+	});
+	if (encoded.length > MAX_ATTRIBUTE_LENGTH) throw failed();
+	const parsed = Result.try({
+		try: () => JSON.parse(encoded),
+		catch: () => failed()
+	});
+	if (parsed.isErr()) throw parsed.error;
+	const decoded = parsed.value;
+	if (!record(decoded) || Object.keys(decoded).some((key) => key !== "version" && key !== "value")) throw failed();
+	const value = decoded["value"];
+	if (!valid(value)) throw failed();
+	if (decoded["version"] !== VERSION) throw failed("unsupportedVersion");
+	return value;
+};
+const encodeAttribute = ({ attribute, value, valid }) => {
+	if (value === void 0) return void 0;
+	if (!valid(value)) throw new ReviewResolutionProvenanceError({
+		attribute,
+		reason: "invalid",
+		message: `Invalid or oversized ${attribute} review provenance.`
+	});
+	const encoded = JSON.stringify({
+		version: VERSION,
+		value
+	});
+	if (encoded.length > MAX_ATTRIBUTE_LENGTH) throw new ReviewResolutionProvenanceError({
+		attribute,
+		reason: "invalid",
+		message: `Oversized ${attribute} review provenance.`
+	});
+	return encoded;
+};
+const serializeAttribute = (options) => {
+	const encoded = encodeAttribute(options);
+	return encoded === void 0 ? "" : ` folio:${options.attribute}="${escapeXmlAttribute(encoded)}"`;
+};
+const parseResolutionJoins = (node) => parseAttribute({
+	node,
+	attribute: "resolutionJoins",
+	valid: isResolutionJoins
+});
+const parseBoundaryJoins = (node) => parseAttribute({
+	node,
+	attribute: "boundaryJoins",
+	valid: isBoundaryJoins
+});
+const serializeResolutionJoins = (value) => serializeAttribute({
+	attribute: "resolutionJoins",
+	value,
+	valid: isResolutionJoins
+});
+const serializeBoundaryJoins = (value) => serializeAttribute({
+	attribute: "boundaryJoins",
+	value,
+	valid: isBoundaryJoins
+});
+/** Null carries an owned undefined depth; a missing attribute carries no field. */
+const parseParagraphMarkResolutionJoin = (node) => {
+	const value = parseAttribute({
+		node,
+		attribute: PARAGRAPH_MARK_FIELDS.resolutionJoin.attribute,
+		valid: isEncodedParagraphMarkResolutionJoin
+	});
+	return value === void 0 ? {} : { resolutionJoin: value === null ? void 0 : value };
+};
+const paragraphMarkResolutionJoinOptions = (mark) => ({
+	attribute: PARAGRAPH_MARK_FIELDS.resolutionJoin.attribute,
+	value: Object.hasOwn(mark, "resolutionJoin") ? mark.resolutionJoin ?? null : void 0,
+	valid: isEncodedParagraphMarkResolutionJoin
+});
+const serializeParagraphMarkResolutionJoin = (mark) => serializeAttribute(paragraphMarkResolutionJoinOptions(mark));
+/** Captured paragraph properties compose the same envelope into a parsed XML element. */
+const paragraphMarkResolutionJoinAttributes = (mark) => {
+	const options = paragraphMarkResolutionJoinOptions(mark);
+	const encoded = encodeAttribute(options);
+	return encoded === void 0 ? {} : { [`folio:${options.attribute}`]: encoded };
+};
+//#endregion
+export { ReviewResolutionProvenanceError, isBoundaryJoins, isParagraphMarkResolutionJoin, isResolutionJoins, paragraphMarkResolutionJoinAttributes, parseBoundaryJoins, parseParagraphMarkResolutionJoin, parseResolutionJoins, serializeBoundaryJoins, serializeParagraphMarkResolutionJoin, serializeResolutionJoins };

package/dist/docx/rezip.d.ts

@@ -1,4 +1,5 @@
 import { document_d_exports } from "../types/document.js";
+import { SaveDiagnosticOptions } from "./saveDiagnostics.js";
 import { BlockContent, Hyperlink } from "../types/content.js";
 import { RawDocxContent } from "./unzip.js";
 import JSZip from "jszip";
@@ -46,7 +47,7 @@ declare const hasUnmaterializedInlineResources: (blocks: BlockContent[]) => bool
 /**
  * Options for repacking DOCX
  */
-type RepackOptions = {
+type RepackOptions = SaveDiagnosticOptions & {
   /** Compression level (0-9, default: 6) */
   compressionLevel?: number;
   /** Whether to update modification date in docProps/core.xml */
@@ -185,7 +186,10 @@ declare function hasModelDrivenPictureWatermark(doc: document_d_exports.Document
  * `sourceZip` supplies each part as it stands before the save so the rebuilt
  * root can keep any prefix binding only the source document declared.
  */
-declare function collectHeaderFooterUpdates(doc: document_d_exports.Document, sourceZip: JSZip): Promise<Map<string, string>>;
+type CollectHeaderFooterUpdatesOptions = SaveDiagnosticOptions & {
+  sourceZip: JSZip;
+};
+declare function collectHeaderFooterUpdates(doc: document_d_exports.Document, { sourceZip, onDiagnostic }: CollectHeaderFooterUpdatesOptions): Promise<Map<string, string>>;
 /** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
 declare function notePartRelsPath(partPath: string): string;
 /** Update existing core-property values without synthesizing absent metadata. */
@@ -219,7 +223,7 @@ declare function isDocxBuffer(buffer: ArrayBuffer): boolean;
  * ignored for a document that carries a source package, which keeps the
  * properties that package already states.
  */
-type DocumentPropertiesOptions = {
+type DocumentPropertiesOptions = SaveDiagnosticOptions & {
   /** `dc:creator` in `docProps/core.xml`. Omitted when absent. */
   creator?: string;
   /** `Application` in `docProps/app.xml`. Omitted, with `AppVersion`, when absent. */