@stll/folio-core 0.32.1 → 0.33.0

package/dist/document-operations.js

@@ -11,6 +11,11 @@ const FOLIO_DOCUMENT_OPERATION_TYPES = Object.freeze([
 	"insertBeforeBlock",
 	"replaceBlock",
 	"deleteBlock",
+	"splitBlock",
+	"mergeBlockWithNext",
+	"setBlockParagraphProperties",
+	"insertTable",
+	"deleteTable",
 	"commentOnBlock",
 	"insertSignatureTable",
 	"insertTableRow",
@@ -56,6 +61,11 @@ const FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE = Object.freeze({
 	insertBeforeBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
 	replaceBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
 	deleteBlock: DIRECT_TRACKED_AND_SUGGESTED_MODES,
+	splitBlock: DIRECT_AND_TRACKED_MODES,
+	mergeBlockWithNext: DIRECT_AND_TRACKED_MODES,
+	setBlockParagraphProperties: DIRECT_AND_TRACKED_MODES,
+	insertTable: DIRECT_AND_TRACKED_MODES,
+	deleteTable: DIRECT_AND_TRACKED_MODES,
 	commentOnBlock: DIRECT_AND_TRACKED_MODES,
 	insertSignatureTable: DIRECT_AND_SUGGESTED_MODES,
 	insertTableRow: DIRECT_TRACKED_AND_SUGGESTED_MODES,
@@ -147,6 +157,49 @@ const readNonNegativeInteger = (value, key, path) => {
 	if (typeof candidate === "number" && Number.isInteger(candidate) && candidate >= 0) return candidate;
 	return invalidBatch(`${path}.${key}`, "expected a non-negative integer");
 };
+/**
+* A non-negative integer that may also be cleared. `undefined` is "say
+* nothing"; `null` is "there is none", which is a different instruction and
+* the one absence alone cannot give.
+*/
+const readClearableNonNegativeInteger = (value, key, path) => {
+	const candidate = value[key];
+	if (candidate === void 0) return;
+	return candidate === null ? null : readNonNegativeInteger(value, key, path);
+};
+/**
+* A rectangular grid of cell texts. Rectangular because a table whose rows
+* hold different cell counts is not a table any consumer can lay out, and the
+* batch is the last place to catch that.
+*/
+const readTableRows = (value, path) => {
+	const rows = value["rows"];
+	const rowsPath = `${path}.rows`;
+	if (!Array.isArray(rows) || rows.length === 0) return invalidBatch(rowsPath, "expected a non-empty array");
+	const parsed = rows.map((row, index) => {
+		if (!Array.isArray(row) || row.length === 0) return invalidBatch(`${rowsPath}[${String(index)}]`, "expected a non-empty array");
+		return row.map((cell, cellIndex) => {
+			if (typeof cell !== "string") return invalidBatch(`${rowsPath}[${String(index)}][${String(cellIndex)}]`, "expected a string");
+			return cell;
+		});
+	});
+	const width = parsed[0]?.length ?? 0;
+	if (parsed.some((row) => row.length !== width)) return invalidBatch(rowsPath, "expected every row to hold the same number of cells");
+	return parsed;
+};
+const readParagraphProperties = (value, path) => {
+	const candidate = value["properties"];
+	const propertiesPath = `${path}.properties`;
+	if (!isPlainObject(candidate)) return invalidBatch(propertiesPath, "expected an object");
+	assertAllowedKeys(candidate, propertiesPath, ["styleId", "listLevel"]);
+	const styleId = candidate["styleId"] === null ? null : readOptionalString(candidate, "styleId", propertiesPath);
+	const listLevel = readClearableNonNegativeInteger(candidate, "listLevel", propertiesPath);
+	if (styleId === void 0 && listLevel === void 0) return invalidBatch(propertiesPath, "expected at least one property to set");
+	return {
+		...styleId !== void 0 && { styleId },
+		...listLevel !== void 0 && { listLevel }
+	};
+};
 const readTextRange = (value, path) => {
 	const candidate = value["range"];
 	const rangePath = `${path}.range`;
@@ -184,16 +237,19 @@ const readInlineFormatting = (value, path) => {
 	assertAllowedKeys(candidate, formattingPath, [
 		"bold",
 		"italic",
-		"underline"
+		"underline",
+		"strike"
 	]);
 	const bold = readOptionalBoolean(candidate, "bold", formattingPath);
 	const italic = readOptionalBoolean(candidate, "italic", formattingPath);
 	const underline = readOptionalBoolean(candidate, "underline", formattingPath);
-	if (bold === void 0 && italic === void 0 && underline === void 0) return invalidBatch(formattingPath, "expected at least one formatting property");
+	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");
 	return {
 		...bold !== void 0 && { bold },
 		...italic !== void 0 && { italic },
-		...underline !== void 0 && { underline }
+		...underline !== void 0 && { underline },
+		...strike !== void 0 && { strike }
 	};
 };
 const readOptionalComment = (value, path) => {
@@ -271,6 +327,8 @@ const FOLIO_DOCUMENT_OPERATION_KEYS_BY_TYPE = Object.freeze({
 		...COMMON_OPERATION_KEYS,
 		"text",
 		"inheritFormatting",
+		"listLevel",
+		"moveId",
 		"pageBreakBefore",
 		"styleId",
 		"comment"
@@ -279,6 +337,8 @@ const FOLIO_DOCUMENT_OPERATION_KEYS_BY_TYPE = Object.freeze({
 		...COMMON_OPERATION_KEYS,
 		"text",
 		"inheritFormatting",
+		"listLevel",
+		"moveId",
 		"pageBreakBefore",
 		"styleId",
 		"comment"
@@ -290,7 +350,24 @@ const FOLIO_DOCUMENT_OPERATION_KEYS_BY_TYPE = Object.freeze({
 		"styleId",
 		"comment"
 	],
-	deleteBlock: [...COMMON_OPERATION_KEYS, "comment"],
+	deleteBlock: [
+		...COMMON_OPERATION_KEYS,
+		"moveId",
+		"comment"
+	],
+	splitBlock: [
+		...COMMON_OPERATION_KEYS,
+		"offset",
+		"separator"
+	],
+	mergeBlockWithNext: [...COMMON_OPERATION_KEYS, "separator"],
+	setBlockParagraphProperties: [...COMMON_OPERATION_KEYS, "properties"],
+	insertTable: [
+		...COMMON_OPERATION_KEYS,
+		"position",
+		"rows"
+	],
+	deleteTable: COMMON_OPERATION_KEYS,
 	commentOnBlock: [
 		...COMMON_OPERATION_KEYS,
 		"quote",
@@ -383,6 +460,49 @@ const parseDocumentOperation = (value, index) => {
 		formatting: readInlineFormatting(value, path)
 	};
 	const blockId = readString(value, "blockId", path);
+	if (type === "insertTable") {
+		const position = value["position"];
+		if (position !== void 0 && position !== "after" && position !== "before") return invalidBatch(`${path}.position`, "expected \"after\" or \"before\" when provided");
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...position !== void 0 && { position },
+			rows: readTableRows(value, path)
+		};
+	}
+	if (type === "deleteTable") return {
+		...operationMeta,
+		id,
+		type,
+		blockId
+	};
+	if (type === "setBlockParagraphProperties") return {
+		...operationMeta,
+		id,
+		type,
+		blockId,
+		properties: readParagraphProperties(value, path)
+	};
+	if (type === "splitBlock" || type === "mergeBlockWithNext") {
+		const separator = readOptionalString(value, "separator", path);
+		if (type === "mergeBlockWithNext") return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...separator !== void 0 && { separator }
+		};
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			offset: readNonNegativeInteger(value, "offset", path),
+			...separator !== void 0 && { separator }
+		};
+	}
 	if (type === "replaceInBlock") return {
 		...operationMeta,
 		id,
@@ -395,7 +515,9 @@ const parseDocumentOperation = (value, index) => {
 	if (type === "insertAfterBlock" || type === "insertBeforeBlock") {
 		const inheritFormatting = readOptionalBoolean(value, "inheritFormatting", path);
 		const pageBreakBefore = readOptionalBoolean(value, "pageBreakBefore", path);
-		const styleId = readOptionalString(value, "styleId", path);
+		const styleId = value["styleId"] === null ? null : readOptionalString(value, "styleId", path);
+		const moveId = readOptionalString(value, "moveId", path);
+		const listLevel = readClearableNonNegativeInteger(value, "listLevel", path);
 		return {
 			...operationMeta,
 			id,
@@ -403,6 +525,8 @@ const parseDocumentOperation = (value, index) => {
 			blockId,
 			text: readString(value, "text", path),
 			...inheritFormatting !== void 0 && { inheritFormatting },
+			...listLevel !== void 0 && { listLevel },
+			...moveId !== void 0 && { moveId },
 			...pageBreakBefore !== void 0 && { pageBreakBefore },
 			...styleId !== void 0 && { styleId },
 			...comment !== void 0 && { comment }
@@ -422,13 +546,17 @@ const parseDocumentOperation = (value, index) => {
 			...comment !== void 0 && { comment }
 		};
 	}
-	if (type === "deleteBlock") return {
-		...operationMeta,
-		id,
-		type,
-		blockId,
-		...comment !== void 0 && { comment }
-	};
+	if (type === "deleteBlock") {
+		const moveId = readOptionalString(value, "moveId", path);
+		return {
+			...operationMeta,
+			id,
+			type,
+			blockId,
+			...moveId !== void 0 && { moveId },
+			...comment !== void 0 && { comment }
+		};
+	}
 	if (type === "commentOnBlock") {
 		if (comment === void 0) return invalidBatch(`${path}.comment`, "expected an object");
 		const quote = readOptionalString(value, "quote", path);
@@ -642,6 +770,14 @@ const getPrimaryAffectedTarget = (operation, story) => {
 			blockId: operation.blockId,
 			effect: "deleted"
 		};
+		case "setBlockParagraphProperties":
+		case "splitBlock":
+		case "mergeBlockWithNext": return {
+			type: "block",
+			story,
+			blockId: operation.blockId,
+			effect: "updated"
+		};
 		case "commentOnBlock": return {
 			type: "block",
 			story,
@@ -655,6 +791,19 @@ const getPrimaryAffectedTarget = (operation, story) => {
 			position: operation.position ?? "after",
 			content: "signatureTable"
 		};
+		case "insertTable": return {
+			type: "insertion",
+			story,
+			anchorBlockId: operation.blockId,
+			position: operation.position ?? "after",
+			content: "table"
+		};
+		case "deleteTable": return {
+			type: "block",
+			story,
+			blockId: operation.blockId,
+			effect: "deleted"
+		};
 		case "insertTableRow": return {
 			type: "insertion",
 			story,
@@ -730,7 +879,7 @@ const getFolioDocumentOperationReceiptsForStory = ({ operations, applied, story
 	});
 	return receipts;
 };
-const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle }) => {
+const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle, revisionStamp, wordDiff }) => {
 	const parsedBatch = parseFolioDocumentOperationBatch(batch);
 	const apply = ({ targetView, targetCreateCommentId = createCommentId, preview = false }) => {
 		return (preview ? previewFolioAIEditOperations : applyFolioAIEditOperations)({
@@ -739,7 +888,9 @@ const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", a
 			operations: parsedBatch.operations,
 			mode: parsedBatch.mode ?? "tracked-changes",
 			...author !== void 0 && { author },
-			...targetCreateCommentId !== void 0 && { createCommentId: targetCreateCommentId }
+			...targetCreateCommentId !== void 0 && { createCommentId: targetCreateCommentId },
+			...revisionStamp !== void 0 && { revisionStamp },
+			...wordDiff !== void 0 && { wordDiff }
 		});
 	};
 	const preview = () => apply({
@@ -759,7 +910,9 @@ const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", a
 			skipped,
 			issues: getFolioDocumentOperationIssues(parsedBatch.operations, skipped),
 			receipts: [],
-			undoHandle: null
+			...previewResult.normalizations !== void 0 && { normalizations: previewResult.normalizations },
+			undoHandle: null,
+			nextRevisionId: previewResult.nextRevisionId
 		};
 	};
 	if (parsedBatch.dryRun === true) {
@@ -776,7 +929,9 @@ const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", a
 				applied: previewResult.applied,
 				story
 			}),
-			undoHandle: null
+			...previewResult.normalizations !== void 0 && { normalizations: previewResult.normalizations },
+			undoHandle: null,
+			nextRevisionId: previewResult.nextRevisionId
 		};
 	}
 	if (parsedBatch.atomic === true) {

package/dist/document-stories.d.ts

@@ -4,6 +4,22 @@ type FolioDocumentStoryPair = {
   baseStory: FolioDocumentStoryHandle | null;
   revisedStory: FolioDocumentStoryHandle | null;
 };
+/**
+ * Pair two packages' stories: by identity first, then, for headers and
+ * footers, by kind and document order.
+ *
+ * A relationship id names a part inside ONE package. Two revisions of one file
+ * carry it forward, so matching on it pairs the right header exactly and is
+ * tried first. Two independently authored files do not: `rId6` in one has
+ * nothing to do with `rId6` in the other, and matching on it alone left every
+ * header and footer of such a pair reported as present on one side only —
+ * a comparison of two contracts covered their bodies and nothing else.
+ *
+ * Order is what is left to pair on. It is the order the package lists its
+ * parts in, so the nth header of one document answers to the nth header of the
+ * other, and a document with more of them than the other leaves its surplus
+ * unpaired rather than pairing a first-page header against a default one.
+ */
 declare const pairFolioDocumentStories: (baseStories: readonly FolioDocumentStoryHandle[], revisedStories: readonly FolioDocumentStoryHandle[]) => FolioDocumentStoryPair[];
 //#endregion
 export { FolioDocumentStoryPair, pairFolioDocumentStories };

package/dist/document-stories.js

@@ -4,18 +4,62 @@ const documentStoryKey = (story) => {
 	if (story.type === "header" || story.type === "footer") return `${story.type}:${story.relationshipId}`;
 	return `${story.type}:${String(story.noteId)}`;
 };
+/**
+* Pair two packages' stories: by identity first, then, for headers and
+* footers, by kind and document order.
+*
+* A relationship id names a part inside ONE package. Two revisions of one file
+* carry it forward, so matching on it pairs the right header exactly and is
+* tried first. Two independently authored files do not: `rId6` in one has
+* nothing to do with `rId6` in the other, and matching on it alone left every
+* header and footer of such a pair reported as present on one side only —
+* a comparison of two contracts covered their bodies and nothing else.
+*
+* Order is what is left to pair on. It is the order the package lists its
+* parts in, so the nth header of one document answers to the nth header of the
+* other, and a document with more of them than the other leaves its surplus
+* unpaired rather than pairing a first-page header against a default one.
+*/
 const pairFolioDocumentStories = (baseStories, revisedStories) => {
 	const revisedByKey = new Map(revisedStories.map((story) => [documentStoryKey(story), story]));
 	const pairedKeys = /* @__PURE__ */ new Set();
-	const pairs = [];
+	const pairedByIdentity = /* @__PURE__ */ new Map();
 	for (const baseStory of baseStories) {
 		const key = documentStoryKey(baseStory);
-		const revisedStory = revisedByKey.get(key) ?? null;
+		const revisedStory = revisedByKey.get(key);
+		if (revisedStory) {
+			pairedKeys.add(key);
+			pairedByIdentity.set(baseStory, revisedStory);
+		}
+	}
+	const unpairedRevisedOfKind = (kind) => revisedStories.filter((story) => story.type === kind && !pairedKeys.has(documentStoryKey(story)));
+	const remaining = {
+		header: unpairedRevisedOfKind("header"),
+		footer: unpairedRevisedOfKind("footer")
+	};
+	const pairs = [];
+	for (const baseStory of baseStories) {
+		const identityMatch = pairedByIdentity.get(baseStory);
+		if (identityMatch) {
+			pairs.push({
+				baseStory,
+				revisedStory: identityMatch
+			});
+			continue;
+		}
+		if (baseStory.type !== "header" && baseStory.type !== "footer") {
+			pairs.push({
+				baseStory,
+				revisedStory: null
+			});
+			continue;
+		}
+		const byOrder = remaining[baseStory.type].shift() ?? null;
+		if (byOrder) pairedKeys.add(documentStoryKey(byOrder));
 		pairs.push({
 			baseStory,
-			revisedStory
+			revisedStory: byOrder
 		});
-		if (revisedStory) pairedKeys.add(key);
 	}
 	for (const revisedStory of revisedStories) if (!pairedKeys.has(documentStoryKey(revisedStory))) pairs.push({
 		baseStory: null,

package/dist/docx/packageParts.d.ts

@@ -0,0 +1,35 @@
+import JSZip from "jszip";
+//#region src/docx/packageParts.d.ts
+/**
+ * Whether an entry path would escape the package when a host writes the archive
+ * to disk: absolute, backslash-separated, or climbing out through `..`. This is
+ * the only thing a save refuses, and it is about the archive, not the document.
+ *
+ * The full repack removes such an entry along with its references; the
+ * selective path bails to the full repack rather than overlay one part on top
+ * of a package carrying one. Both read this predicate, so neither can drift
+ * into passing what the other blocks.
+ */
+declare const isUnsafePackagePath: (path: string) => boolean;
+/** Drop the entries whose path a save refuses. Every other part survives. */
+declare const removeUnsafeEntries: (zip: JSZip) => void;
+/** What reconciliation removed to make the package internally consistent. */
+type PackageReferenceRepair = {
+  /** Parts a relationship named that the package does not hold. */
+  danglingRelationships: string[];
+  /** Parts a content-type override named that the package does not hold. */
+  danglingOverrides: string[];
+};
+/**
+ * Make the package internally consistent before it is written: every internal
+ * relationship target and every content-type override must name a part the
+ * output actually holds.
+ *
+ * A part is rewritten only when something was dropped from it, so a package
+ * that needs no repair leaves byte for byte as it arrived. Running this on an
+ * already-reconciled package therefore reports nothing and changes nothing,
+ * which is what the repack tests assert about their own output.
+ */
+declare const reconcilePackageReferences: (zip: JSZip, compressionLevel: number) => Promise<PackageReferenceRepair>;
+//#endregion
+export { PackageReferenceRepair, isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries };

package/dist/docx/packageParts.js

@@ -0,0 +1,120 @@
+import { resolveRelativePath } from "./relsParser.js";
+//#region src/docx/packageParts.ts
+const CONTENT_TYPE_ELEMENT = /<(?:Default|Override)\b[^>]*?\/?>/giu;
+const PART_NAME_ATTRIBUTE = /\bPartName\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
+const RELATIONSHIP_ELEMENT = /<Relationship\b[^>]*?(?:\/>|>\s*<\/Relationship>)/giu;
+const TARGET_ATTRIBUTE = /\bTarget\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
+const TARGET_MODE_ATTRIBUTE = /\bTargetMode\s*=\s*(?<quote>["'])(?<value>[^"']*)\k<quote>/u;
+const CONTENT_TYPES_PATTERN = /^\[Content_Types\]\.xml$/iu;
+/** Normalize a package path for comparison: lower case, no leading slash. */
+const normalizePartPath = (path) => (path.startsWith("/") ? path.slice(1) : path).toLowerCase();
+/**
+* Decode `%XX` escapes in a part name. `decodeURI` throws on a malformed
+* escape, and a malformed target is exactly the input this has to survive, so
+* the replacement is done by hand.
+*/
+const decodePartName = (name) => name.replaceAll(/%[0-9A-Fa-f]{2}/gu, (escape) => String.fromCharCode(Number.parseInt(escape.slice(1), 16)));
+/**
+* Whether an entry path would escape the package when a host writes the archive
+* to disk: absolute, backslash-separated, or climbing out through `..`. This is
+* the only thing a save refuses, and it is about the archive, not the document.
+*
+* The full repack removes such an entry along with its references; the
+* selective path bails to the full repack rather than overlay one part on top
+* of a package carrying one. Both read this predicate, so neither can drift
+* into passing what the other blocks.
+*/
+const isUnsafePackagePath = (path) => {
+	if (!path || path.startsWith("/") || path.includes("\\")) return true;
+	return path.split("/").some((segment) => segment === "..");
+};
+/** Drop the entries whose path a save refuses. Every other part survives. */
+const removeUnsafeEntries = (zip) => {
+	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && isUnsafePackagePath(path)) zip.remove(path);
+};
+const presentPartPaths = (zip) => {
+	const present = /* @__PURE__ */ new Set();
+	for (const [path, file] of Object.entries(zip.files)) if (!file.dir) present.add(normalizePartPath(path));
+	return present;
+};
+const isPresent = (present, partPath) => present.has(normalizePartPath(partPath)) || present.has(normalizePartPath(decodePartName(partPath)));
+/** The part a relationship names, or null when it points outside the package. */
+const relationshipTarget = (element, relsPath) => {
+	if (TARGET_MODE_ATTRIBUTE.exec(element)?.groups?.["value"] === "External") return null;
+	const target = TARGET_ATTRIBUTE.exec(element)?.groups?.["value"];
+	return target === void 0 ? null : resolveRelativePath(relsPath, target);
+};
+/**
+* Every `.rels` part with its text. Read one at a time rather than through
+* `Promise.all`: a package holds a handful of tiny relationship parts, and the
+* sequential read keeps the output order stable.
+*/
+const readRelationshipParts = async (zip) => {
+	const parts = [];
+	for (const [path, file] of Object.entries(zip.files)) {
+		if (file.dir || !normalizePartPath(path).endsWith(".rels")) continue;
+		parts.push({
+			path,
+			xml: await file.async("text")
+		});
+	}
+	return parts;
+};
+const writePart = ({ zip, path, xml, compressionLevel }) => {
+	zip.file(path, xml, {
+		compression: "DEFLATE",
+		compressionOptions: { level: compressionLevel }
+	});
+};
+/**
+* Make the package internally consistent before it is written: every internal
+* relationship target and every content-type override must name a part the
+* output actually holds.
+*
+* A part is rewritten only when something was dropped from it, so a package
+* that needs no repair leaves byte for byte as it arrived. Running this on an
+* already-reconciled package therefore reports nothing and changes nothing,
+* which is what the repack tests assert about their own output.
+*/
+const reconcilePackageReferences = async (zip, compressionLevel) => {
+	const present = presentPartPaths(zip);
+	const repair = {
+		danglingRelationships: [],
+		danglingOverrides: []
+	};
+	for (const { path, xml } of await readRelationshipParts(zip)) {
+		let dropped = false;
+		const pruned = xml.replaceAll(RELATIONSHIP_ELEMENT, (element) => {
+			const target = relationshipTarget(element, path);
+			if (target === null || isPresent(present, target)) return element;
+			repair.danglingRelationships.push(target);
+			dropped = true;
+			return "";
+		});
+		if (dropped) writePart({
+			zip,
+			path,
+			xml: pruned,
+			compressionLevel
+		});
+	}
+	const contentTypes = zip.file(CONTENT_TYPES_PATTERN)[0];
+	if (!contentTypes) return repair;
+	let droppedOverride = false;
+	const prunedContentTypes = (await contentTypes.async("text")).replaceAll(CONTENT_TYPE_ELEMENT, (element) => {
+		const partName = PART_NAME_ATTRIBUTE.exec(element)?.groups?.["value"];
+		if (partName === void 0 || isPresent(present, partName)) return element;
+		repair.danglingOverrides.push(normalizePartPath(decodePartName(partName)));
+		droppedOverride = true;
+		return "";
+	});
+	if (droppedOverride) writePart({
+		zip,
+		path: contentTypes.name,
+		xml: prunedContentTypes,
+		compressionLevel
+	});
+	return repair;
+};
+//#endregion
+export { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries };

package/dist/docx/paragraphParser.js

@@ -9,9 +9,9 @@ import { consolidateParagraphContent } from "./runConsolidator.js";
 import { parseRun, parseRunProperties } from "./runParser.js";
 import { parseSdtProperties } from "./sdtProperties.js";
 import { parseSectionProperties } from "./sectionParser.js";
-import { elementToXml, findChild, findChildren, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, elementToXml, findChild, findChildByNamespaceUri, findChildren, getAttribute, getChildElements, getLocalName, matchesName, mergeXmlnsDeclarations, parseBooleanElement, parseNumberingLevelAttribute, parseNumericAttribute } from "./xmlParser.js";
 import { panic } from "better-result";
-import { normalizeRevisionId } from "@stll/docx-core/model";
+import { PARAGRAPH_MARK_CHANGE_KINDS, normalizeRevisionId } from "@stll/docx-core/model";
 //#region src/docx/paragraphParser.ts
 /**
 * Extract plain text from a math element (recursive text content extraction)
@@ -528,19 +528,16 @@ function parseParagraphMarkChange(pPr) {
 	if (!pPr) return;
 	const rPr = findChild(pPr, "w", "rPr");
 	if (!rPr) return;
-	const ins = findChild(rPr, "w", "ins");
-	if (ins) return {
-		kind: "ins",
-		info: parseTrackedChangeInfo(ins)
-	};
-	const del = findChild(rPr, "w", "del");
-	if (del) return {
-		kind: "del",
-		info: parseTrackedChangeInfo(del)
-	};
+	for (const kind of PARAGRAPH_MARK_CHANGE_KINDS) {
+		const element = findChildByNamespaceUri(rPr, WORDPROCESSINGML_NAMESPACE_URIS, kind);
+		if (element) return {
+			kind,
+			info: parseTrackedChangeInfo(element)
+		};
+	}
 }
 function isTrackedChangeWrapperChild(content) {
-	return content.type === "run" || content.type === "hyperlink";
+	return content.type === "run" || content.type === "hyperlink" || content.type === "bookmarkStart" || content.type === "bookmarkEnd" || content.type === "simpleField" || content.type === "complexField" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo";
 }
 function isInlineSdtContent(content) {
 	return content.type === "run" || content.type === "hyperlink" || content.type === "simpleField" || content.type === "complexField" || content.type === "inlineSdt" || content.type === "insertion" || content.type === "deletion" || content.type === "moveFrom" || content.type === "moveTo" || content.type === "mathEquation";
@@ -980,16 +977,19 @@ function parseParagraph(node, styles, theme, numbering, rels = null, media = nul
 		if (sectPr) paragraph.sectionProperties = parseSectionProperties(sectPr);
 	}
 	paragraph.content = consolidateParagraphContent(parseParagraphContents(node, styles, theme, numbering, rels, media, "default", options?.rootXmlns ?? {}));
-	let effectiveNumPr = paragraph.formatting?.numPr;
+	const paragraphFormatting = paragraph.formatting;
+	const directNumPr = paragraphFormatting?.numPr;
+	const styleNumPr = paragraphFormatting?.styleId && styles ? styles.get(paragraphFormatting.styleId)?.pPr?.numPr : void 0;
+	let effectiveNumPr = directNumPr;
 	let numPrFromStyle = false;
-	if (!effectiveNumPr && paragraph.formatting?.styleId && styles) {
-		const style = styles.get(paragraph.formatting.styleId);
-		if (style?.pPr?.numPr) {
-			effectiveNumPr = style.pPr.numPr;
-			numPrFromStyle = true;
-			paragraph.formatting.numPr = effectiveNumPr;
-			paragraph.formatting.numPrFromStyle = effectiveNumPr;
-		}
+	if (paragraphFormatting && styleNumPr && directNumPr?.numId === void 0) {
+		effectiveNumPr = {
+			...styleNumPr,
+			...directNumPr
+		};
+		numPrFromStyle = true;
+		paragraphFormatting.numPr = effectiveNumPr;
+		paragraphFormatting.numPrFromStyle = styleNumPr;
 	}
 	if (effectiveNumPr && numbering) {
 		const { numId, ilvl = 0 } = effectiveNumPr;

package/dist/docx/paragraphTraversal.js

@@ -13,7 +13,7 @@ const visitParagraphRuns = (paragraph, visit) => {
 				visitRun(child);
 				continue;
 			}
-			visitHyperlink(child);
+			if (child.type === "hyperlink") visitHyperlink(child);
 		}
 	};
 	const visitParagraphContent = (content) => {

package/dist/docx/renderedPageBreakNormalization.js

@@ -37,7 +37,9 @@ const scanHyperlink = (hyperlink, scan) => {
 };
 const scanInlineContent = (content, scan) => {
 	for (const child of content) {
-		const result = child.type === "run" ? scanRun(child, scan) : scanHyperlink(child, scan);
+		let result;
+		if (child.type === "run") result = scanRun(child, scan);
+		else if (child.type === "hyperlink") result = scanHyperlink(child, scan);
 		if (result !== void 0) return result;
 	}
 };

package/dist/docx/revisionIdNormalization.d.ts

@@ -0,0 +1,13 @@
+//#region src/docx/revisionIdNormalization.d.ts
+declare const REVISION_ELEMENT_NAMES: Set<string>;
+/**
+ * Keep physical tracked-change element ids unique across a package.
+ *
+ * Live editor marks and operation receipts keep their logical revision IDs.
+ * Saving assigns fresh IDs only where one logical change was split into
+ * multiple physical OOXML wrappers; reopening therefore exposes the physical
+ * wrapper IDs that the file format requires.
+ */
+declare const normalizeRevisionIdsInXmlParts: (parts: ReadonlyMap<string, string>) => Map<string, string>;
+//#endregion
+export { REVISION_ELEMENT_NAMES, normalizeRevisionIdsInXmlParts };