@stll/folio-core 0.58.5 → 0.60.0

package/dist/document-operations.js

@@ -1,13 +1,13 @@
 import { applyFolioAIEditOperations, previewFolioAIEditOperationsWithResult } from "./ai-edits/apply.js";
 import { describeModelError, findIntroducedModelErrors } from "./ai-edits/result-validation.js";
 import { LIST_KINDS } from "./docx/listNumberingInstances.js";
-import { isNumberingReference } from "./docx/numberingReference.js";
 import { completeNumberingForDoc } from "./prosemirror/listInstanceReferences.js";
 import { outlineLevelFromAttrValue } from "./prosemirror/outlineLevelAttr.js";
 import { getStatedDocumentNumbering } from "./prosemirror/plugins/documentNumbering.js";
 import { LINE_SPACING_RULE_VALUES, PARAGRAPH_ALIGNMENT_VALUES } from "./types/documentEnumValues.js";
 import { TaggedError } from "better-result";
 import { sanitizeXmlCharacters } from "@stll/docx-core";
+import { isNumberingReference, paragraphNumberingReference } from "@stll/docx-core/model";
 //#region src/document-operations.ts
 const FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION = 1;
 /** Direct paragraph-alignment values accepted by the operation contract. */
@@ -210,16 +210,6 @@ const readNonNegativeInteger = (value, key, path) => {
 	if (typeof candidate === "number" && Number.isSafeInteger(candidate) && candidate >= 0) return candidate;
 	return invalidBatch(`${path}.${key}`, "expected a non-negative safe 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);
-};
 const readClearableParagraphAlignment = ({ value, key, path }) => {
 	const candidate = value[key];
 	if (candidate === void 0 || candidate === null) return candidate;
@@ -302,43 +292,64 @@ const readClearableParagraphIndentation = ({ value, key, path }) => {
 const MAX_NEW_LIST_LEVEL = 8;
 const LIST_KIND_SET = new Set(LIST_KINDS);
 const isListKind = (value) => LIST_KIND_SET.has(value);
-/** `{ start: "new", kind, level? }`: a list the operation starts. */
+/** `{ kind: "newList", format, level? }`: a list the operation starts. */
 const readNewListReference = (candidate, numberingPath) => {
 	assertAllowedKeys(candidate, numberingPath, [
-		"start",
 		"kind",
+		"format",
 		"level"
 	]);
-	const kind = candidate["kind"];
-	if (typeof kind !== "string" || !isListKind(kind)) return invalidBatch(`${numberingPath}.kind`, `expected one of ${LIST_KINDS.join(", ")}`);
+	const format = candidate["format"];
+	if (typeof format !== "string" || !isListKind(format)) return invalidBatch(`${numberingPath}.format`, `expected one of ${LIST_KINDS.join(", ")}`);
 	if (candidate["level"] === void 0) return {
-		start: "new",
-		kind
+		kind: "newList",
+		format
 	};
 	const level = readNonNegativeInteger(candidate, "level", numberingPath);
 	if (level > MAX_NEW_LIST_LEVEL) return invalidBatch(`${numberingPath}.level`, `expected at most ${MAX_NEW_LIST_LEVEL}`);
 	return {
-		start: "new",
-		kind,
+		kind: "newList",
+		format,
 		level
 	};
 };
 const readClearableNumbering = ({ value, key, path }) => {
 	const candidate = value[key];
-	if (candidate === void 0 || candidate === null) return candidate;
+	if (candidate === void 0) return void 0;
 	const numberingPath = `${path}.${key}`;
-	if (!isPlainObject(candidate)) return invalidBatch(numberingPath, "expected an object or null when provided");
-	if (candidate["start"] !== void 0) {
-		if (candidate["start"] !== "new") return invalidBatch(`${numberingPath}.start`, "expected \"new\"");
-		return readNewListReference(candidate, numberingPath);
+	if (!isPlainObject(candidate)) return invalidBatch(numberingPath, "expected a numbering object");
+	const kind = candidate["kind"];
+	if (kind === "none" || kind === "inherit") {
+		assertAllowedKeys(candidate, numberingPath, ["kind"]);
+		return { kind };
 	}
-	assertAllowedKeys(candidate, numberingPath, ["numId", "level"]);
-	const numId = readNonNegativeInteger(candidate, "numId", numberingPath);
-	if (!isNumberingReference(numId)) return invalidBatch(`${numberingPath}.numId`, "expected a positive integer");
-	return {
-		numId,
-		level: readNonNegativeInteger(candidate, "level", numberingPath)
-	};
+	if (kind === "levelOnly") {
+		assertAllowedKeys(candidate, numberingPath, ["kind", "ilvl"]);
+		const ilvl = readNonNegativeInteger(candidate, "ilvl", numberingPath);
+		if (ilvl > MAX_NEW_LIST_LEVEL) return invalidBatch(`${numberingPath}.ilvl`, `expected at most ${MAX_NEW_LIST_LEVEL}`);
+		return {
+			kind,
+			ilvl
+		};
+	}
+	if (kind === "reference") {
+		assertAllowedKeys(candidate, numberingPath, [
+			"kind",
+			"numId",
+			"ilvl"
+		]);
+		const numId = readNonNegativeInteger(candidate, "numId", numberingPath);
+		if (!isNumberingReference(numId)) return invalidBatch(`${numberingPath}.numId`, "expected a positive integer");
+		if (candidate["ilvl"] === void 0) return paragraphNumberingReference({ numId });
+		const ilvl = readNonNegativeInteger(candidate, "ilvl", numberingPath);
+		if (ilvl > MAX_NEW_LIST_LEVEL) return invalidBatch(`${numberingPath}.ilvl`, `expected at most ${MAX_NEW_LIST_LEVEL}`);
+		return paragraphNumberingReference({
+			numId,
+			ilvl
+		});
+	}
+	if (kind === "newList") return readNewListReference(candidate, numberingPath);
+	return invalidBatch(`${numberingPath}.kind`, "expected \"none\", \"inherit\", \"levelOnly\", \"reference\", or \"newList\"");
 };
 /**
 * A rectangular grid of cell texts. Rectangular because a table whose rows
@@ -376,7 +387,6 @@ const readParagraphProperties = ({ value, key, path }) => {
 	assertAllowedKeys(candidate, propertiesPath, [
 		"styleId",
 		"outlineLevel",
-		"listLevel",
 		"numbering",
 		"alignment",
 		"spacing",
@@ -384,7 +394,6 @@ const readParagraphProperties = ({ value, key, path }) => {
 	]);
 	const styleId = candidate["styleId"] === null ? null : readOptionalString(candidate, "styleId", propertiesPath);
 	const outlineLevel = readClearableOutlineLevel(candidate, propertiesPath);
-	const listLevel = readClearableNonNegativeInteger(candidate, "listLevel", propertiesPath);
 	const numbering = readClearableNumbering({
 		value: candidate,
 		key: "numbering",
@@ -405,11 +414,10 @@ const readParagraphProperties = ({ value, key, path }) => {
 		key: "indentation",
 		path: propertiesPath
 	});
-	if (styleId === void 0 && outlineLevel === void 0 && listLevel === void 0 && numbering === void 0 && alignment === void 0 && spacing === void 0 && indentation === void 0) return invalidBatch(propertiesPath, "expected at least one property to set");
+	if (styleId === void 0 && outlineLevel === void 0 && numbering === void 0 && alignment === void 0 && spacing === void 0 && indentation === void 0) return invalidBatch(propertiesPath, "expected at least one property to set");
 	return {
 		...styleId !== void 0 && { styleId },
 		...outlineLevel !== void 0 && { outlineLevel },
-		...listLevel !== void 0 && { listLevel },
 		...numbering !== void 0 && { numbering },
 		...alignment !== void 0 && { alignment },
 		...spacing !== void 0 && { spacing },
@@ -555,7 +563,6 @@ const OPERATION_KEY_DECISIONS = {
 		indentation: true,
 		lineBreakMode: true,
 		formattingScope: true,
-		listLevel: true,
 		numbering: true,
 		moveId: true,
 		pageBreakBefore: true,
@@ -573,7 +580,6 @@ const OPERATION_KEY_DECISIONS = {
 		indentation: true,
 		lineBreakMode: true,
 		formattingScope: true,
-		listLevel: true,
 		numbering: true,
 		moveId: true,
 		pageBreakBefore: true,
@@ -833,7 +839,6 @@ const parseDocumentOperation = (value, index) => {
 		const styleId = value["styleId"] === null ? null : readOptionalString(value, "styleId", path);
 		const outlineLevel = readClearableOutlineLevel(value, path);
 		const moveId = readOptionalString(value, "moveId", path);
-		const listLevel = readClearableNonNegativeInteger(value, "listLevel", path);
 		const numbering = readClearableNumbering({
 			value,
 			key: "numbering",
@@ -874,7 +879,6 @@ const parseDocumentOperation = (value, index) => {
 			...indentation !== void 0 && { indentation },
 			...lineBreakMode !== void 0 && { lineBreakMode },
 			...formattingScope !== void 0 && { formattingScope },
-			...listLevel !== void 0 && { listLevel },
 			...numbering !== void 0 && { numbering },
 			...moveId !== void 0 && { moveId },
 			...pageBreakBefore !== void 0 && { pageBreakBefore },
@@ -1250,7 +1254,7 @@ const inOperationOrder = (operations, skipped) => {
 	const indexById = new Map(operations.map(({ id }, index) => [id, index]));
 	return [...skipped].sort((left, right) => (indexById.get(left.id) ?? -1) - (indexById.get(right.id) ?? -1));
 };
-const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedStyles }) => {
+const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", author, createCommentId, createUndoHandle, revisionStamp, wordDiff, tableTemplates, replacementBackground, undefinedReferences }) => {
 	const parsedBatch = parseFolioDocumentOperationBatch(batch);
 	const isAtomic = parsedBatch.atomic === true;
 	const beforeDoc = view.state.doc;
@@ -1265,7 +1269,7 @@ const applyFolioDocumentOperations = ({ view, snapshot, batch, story = "main", a
 			...wordDiff !== void 0 && { wordDiff },
 			...tableTemplates !== void 0 && { tableTemplates },
 			...replacementBackground !== void 0 && { replacementBackground },
-			...undefinedStyles !== void 0 && { undefinedStyles }
+			undefinedReferences
 		};
 		if (preview) return {
 			...previewFolioAIEditOperationsWithResult({

package/dist/docx/attributeRemainder.d.ts

@@ -1,5 +1,5 @@
-import { XmlElement } from "./xmlParser.js";
 import { ModelledAttributes } from "./propertyElementAttributes.js";
+import { XmlElement } from "./xmlParser.js";
 import { PreservedAttribute } from "@stll/docx-core/model";
 //#region src/docx/attributeRemainder.d.ts
 declare const InvalidPreservedAttributeError_base: import("better-result").TaggedErrorClass<"InvalidPreservedAttributeError">;

package/dist/docx/bookmarkIdNormalization.d.ts

@@ -0,0 +1,10 @@
+//#region src/docx/bookmarkIdNormalization.d.ts
+/**
+ * Give repeated bookmark ranges independent identities before editor pairing.
+ * The first range keeps its id. Ends close starts in encounter order, including
+ * overlapping ambiguous ranges. Only colliding ids are repaired: those require
+ * unique XML ids for a valid save. Every other source byte stays verbatim.
+ */
+declare const normalizeBookmarkIdsInXmlParts: (parts: ReadonlyMap<string, string>) => ReadonlyMap<string, string>;
+//#endregion
+export { normalizeBookmarkIdsInXmlParts };

package/dist/docx/bookmarkIdNormalization.js

@@ -0,0 +1,100 @@
+import { scanSelectedStreamingXmlElements } from "./selectedXmlIdentityScan.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, getLocalName, getNamespaceUri } from "./xmlParser.js";
+import { panic } from "better-result";
+//#region src/docx/bookmarkIdNormalization.ts
+const bookmarkIdentity = (element) => {
+	if (!WORDPROCESSINGML_NAMESPACE_URIS.has(getNamespaceUri(element) ?? "")) return null;
+	const name = getLocalName(element.name);
+	if (name !== "bookmarkStart" && name !== "bookmarkEnd") return null;
+	const attribute = findAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "id");
+	if (!attribute) return null;
+	const id = Number(attribute.value);
+	if (!Number.isSafeInteger(id) || id < 0) return null;
+	return {
+		name,
+		attribute: attribute.name,
+		id
+	};
+};
+/**
+* Give repeated bookmark ranges independent identities before editor pairing.
+* The first range keeps its id. Ends close starts in encounter order, including
+* overlapping ambiguous ranges. Only colliding ids are repaired: those require
+* unique XML ids for a valid save. Every other source byte stays verbatim.
+*/
+const normalizeBookmarkIdsInXmlParts = (parts) => {
+	const candidates = [...parts].filter(([, xml]) => /bookmark(?:Start|End)/u.test(xml));
+	const reserved = /* @__PURE__ */ new Set();
+	const repeated = /* @__PURE__ */ new Set();
+	const markersByPart = /* @__PURE__ */ new Map();
+	for (const [path, xml] of candidates) {
+		const starts = /* @__PURE__ */ new Set();
+		const markers = [];
+		if (scanSelectedStreamingXmlElements(xml, ({ element, attributeValueSpans }) => {
+			const marker = bookmarkIdentity(element);
+			if (!marker) return;
+			const span = attributeValueSpans.get(marker.attribute);
+			if (!span) panic("Missing bookmark identity source span");
+			markers.push({
+				marker,
+				...span
+			});
+			reserved.add(marker.id);
+			if (marker.name === "bookmarkStart") {
+				if (starts.has(marker.id)) repeated.add(path);
+				starts.add(marker.id);
+			}
+		}).status === "unsupported") {
+			repeated.delete(path);
+			continue;
+		}
+		markersByPart.set(path, markers);
+	}
+	if (repeated.size === 0) return parts;
+	let next = 0;
+	const allocate = () => {
+		while (reserved.has(next)) next += 1;
+		const id = next++;
+		reserved.add(id);
+		return id;
+	};
+	const normalized = new Map(parts);
+	for (const [path, xml] of candidates) {
+		if (!repeated.has(path)) continue;
+		const seen = /* @__PURE__ */ new Set();
+		const open = /* @__PURE__ */ new Map();
+		const chunks = [];
+		let cursor = 0;
+		for (const { marker, start, end } of markersByPart.get(path) ?? []) {
+			let id = marker.id;
+			if (marker.name === "bookmarkStart") {
+				if (seen.has(id)) id = allocate();
+				seen.add(marker.id);
+				let queue = open.get(marker.id);
+				if (!queue) {
+					queue = {
+						ids: [],
+						cursor: 0
+					};
+					open.set(marker.id, queue);
+				}
+				queue.ids.push(id);
+			} else {
+				const queue = open.get(marker.id);
+				const paired = queue?.ids.at(queue.cursor);
+				if (paired !== void 0 && queue) {
+					id = paired;
+					queue.cursor += 1;
+				}
+			}
+			if (id === marker.id) continue;
+			chunks.push(xml.slice(cursor, start), String(id));
+			cursor = end;
+		}
+		chunks.push(xml.slice(cursor));
+		normalized.set(path, chunks.join(""));
+	}
+	return normalized;
+};
+//#endregion
+export { normalizeBookmarkIdsInXmlParts };

package/dist/docx/bookmarkParser.js

@@ -31,8 +31,10 @@ function createBookmarkMap() {
 * @param bookmark - The bookmark start to add
 */
 function addBookmark(map, bookmark) {
-	map.byId.set(bookmark.id, bookmark);
-	if (bookmark.name) map.byName.set(bookmark.name, bookmark);
+	if (!map.byId.has(bookmark.id)) map.byId.set(bookmark.id, bookmark);
+	if (bookmark.name) {
+		if (!map.byName.has(bookmark.name)) map.byName.set(bookmark.name, bookmark);
+	}
 	map.bookmarks.push(bookmark);
 }
 /**

package/dist/docx/importedIdCollisions.d.ts

@@ -0,0 +1,136 @@
+import { ParseContext } from "./parseContext.js";
+//#region src/docx/importedIdCollisions.d.ts
+/** Definition sites only: paired markers and references never claim an identity. */
+declare const IMPORTED_ID_COLLISION_REGISTRY: {
+  readonly bookmark: {
+    readonly kind: "bookmark";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly comment: {
+    readonly kind: "comment";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly footnote: {
+    readonly kind: "footnote";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly endnote: {
+    readonly kind: "endnote";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly revision: {
+    readonly kind: "revision";
+    readonly scope: "package";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly paraId: {
+    readonly kind: "paraId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }, {
+      readonly namespace: "http://schemas.microsoft.com/office/word/2012/wordml";
+      readonly elements: Set<string>;
+    }, {
+      readonly namespace: string;
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "paraId";
+    readonly attributeNamespace: "http://schemas.microsoft.com/office/word/2010/wordml";
+    readonly encoding: "hex";
+  };
+  readonly textId: {
+    readonly kind: "textId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "textId";
+    readonly attributeNamespace: "http://schemas.microsoft.com/office/word/2010/wordml";
+    readonly encoding: "hex";
+  };
+  readonly numId: {
+    readonly kind: "numId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "numId";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly abstractNumId: {
+    readonly kind: "abstractNumId";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "abstractNumId";
+    readonly attributeNamespace: "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+    readonly encoding: "decimal";
+  };
+  readonly drawing: {
+    readonly kind: "drawing";
+    readonly scope: "package";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "id";
+    readonly attributeNamespace: null;
+    readonly encoding: "decimal";
+  };
+  readonly relationship: {
+    readonly kind: "relationship";
+    readonly scope: "part";
+    readonly sites: readonly [{
+      readonly namespace: "http://schemas.openxmlformats.org/package/2006/relationships";
+      readonly elements: Set<string>;
+    }];
+    readonly attribute: "Id";
+    readonly attributeNamespace: null;
+    readonly encoding: "string";
+  };
+};
+/** Reports repeated source definitions without changing the package or choosing a winner. */
+declare const diagnoseImportedIdCollisions: (parts: ReadonlyMap<string, string>, context: ParseContext) => void;
+//#endregion
+export { IMPORTED_ID_COLLISION_REGISTRY, diagnoseImportedIdCollisions };

package/dist/docx/importedIdCollisions.js

@@ -0,0 +1,215 @@
+import { paraIdAttribute, textIdAttribute } from "./paraIdAttribute.js";
+import { REVISION_ELEMENT_NAMES } from "./revisionIdNormalization.js";
+import { scanSelectedStreamingXmlElements } from "./selectedXmlIdentityScan.js";
+import { OOXML_NAMESPACES } from "./serializer/partNamespaces.js";
+import { toTransitionalNamespaceUri } from "./transitionalSpelling.js";
+import { resolveNamespaceUri } from "./xmlNamespaceContext.js";
+import { NAMESPACES, getLocalName, getNamespaceUri } from "./xmlParser.js";
+import { panic } from "better-result";
+import { IMPORTED_ID_COLLISION_KINDS, PARSE_WARNING_CODES } from "@stll/docx-core/model";
+//#region src/docx/importedIdCollisions.ts
+const WORD_2010_NAMESPACE = "http://schemas.microsoft.com/office/word/2010/wordml";
+const PACKAGE_RELATIONSHIP_NAMESPACE = "http://schemas.openxmlformats.org/package/2006/relationships";
+const paragraphIdentityForKind = (kind, element) => {
+	switch (kind) {
+		case IMPORTED_ID_COLLISION_KINDS.paraId: return paraIdAttribute(element);
+		case IMPORTED_ID_COLLISION_KINDS.textId: return textIdAttribute(element);
+		default: return;
+	}
+};
+/** Definition sites only: paired markers and references never claim an identity. */
+const IMPORTED_ID_COLLISION_REGISTRY = {
+	bookmark: {
+		kind: IMPORTED_ID_COLLISION_KINDS.bookmark,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["bookmarkStart"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	comment: {
+		kind: IMPORTED_ID_COLLISION_KINDS.comment,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["comment"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	footnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.footnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["footnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	endnote: {
+		kind: IMPORTED_ID_COLLISION_KINDS.endnote,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["endnote"])
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	revision: {
+		kind: IMPORTED_ID_COLLISION_KINDS.revision,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: REVISION_ELEMENT_NAMES
+		}],
+		attribute: "id",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	paraId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.paraId,
+		scope: "part",
+		sites: [
+			{
+				namespace: NAMESPACES.w,
+				elements: /* @__PURE__ */ new Set(["p"])
+			},
+			{
+				namespace: NAMESPACES.w15,
+				elements: /* @__PURE__ */ new Set(["commentEx"])
+			},
+			{
+				namespace: OOXML_NAMESPACES.w16cex.uri,
+				elements: /* @__PURE__ */ new Set(["comment"])
+			}
+		],
+		attribute: "paraId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	textId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.textId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["p"])
+		}],
+		attribute: "textId",
+		attributeNamespace: WORD_2010_NAMESPACE,
+		encoding: "hex"
+	},
+	numId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.numId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["num"])
+		}],
+		attribute: "numId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	abstractNumId: {
+		kind: IMPORTED_ID_COLLISION_KINDS.abstractNumId,
+		scope: "part",
+		sites: [{
+			namespace: NAMESPACES.w,
+			elements: /* @__PURE__ */ new Set(["abstractNum"])
+		}],
+		attribute: "abstractNumId",
+		attributeNamespace: NAMESPACES.w,
+		encoding: "decimal"
+	},
+	drawing: {
+		kind: IMPORTED_ID_COLLISION_KINDS.drawing,
+		scope: "package",
+		sites: [{
+			namespace: NAMESPACES.wp,
+			elements: /* @__PURE__ */ new Set(["docPr"])
+		}],
+		attribute: "id",
+		attributeNamespace: null,
+		encoding: "decimal"
+	},
+	relationship: {
+		kind: IMPORTED_ID_COLLISION_KINDS.relationship,
+		scope: "part",
+		sites: [{
+			namespace: PACKAGE_RELATIONSHIP_NAMESPACE,
+			elements: /* @__PURE__ */ new Set(["Relationship"])
+		}],
+		attribute: "Id",
+		attributeNamespace: null,
+		encoding: "string"
+	}
+};
+const normalizedIdentity = (value, encoding) => {
+	if (encoding === "string") return value;
+	if (encoding === "hex") return /^[0-9a-f]{8}$/iu.test(value) ? value.toUpperCase() : void 0;
+	const spelling = value.trim();
+	if (!/^[+-]?\d+$/u.test(spelling)) return void 0;
+	const digits = spelling.replace(/^[+-]?0*/u, "");
+	return digits === "" ? "0" : `${spelling.startsWith("-") ? "-" : ""}${digits}`;
+};
+/** Reports repeated source definitions without changing the package or choosing a winner. */
+const diagnoseImportedIdCollisions = (parts, context) => {
+	const rules = Object.values(IMPORTED_ID_COLLISION_REGISTRY);
+	const packageSeen = /* @__PURE__ */ new Map();
+	for (const [part, xml] of parts) {
+		const partSeen = /* @__PURE__ */ new Map();
+		const scoped = context.scoped({ part });
+		scanSelectedStreamingXmlElements(xml, ({ element, attributeValueSpans }) => {
+			if (element.name === void 0) return;
+			const namespace = toTransitionalNamespaceUri(getNamespaceUri(element) ?? "");
+			const localName = getLocalName(element.name);
+			for (const rule of rules) {
+				const kind = rule.kind;
+				if (!rule.sites.some((site) => namespace === site.namespace && site.elements.has(localName))) continue;
+				const paragraphIdentity = paragraphIdentityForKind(kind, element);
+				const seen = rule.scope === "package" ? packageSeen : partSeen;
+				for (const [name, rawValue] of Object.entries(element.attributes ?? {})) {
+					if (getLocalName(name) !== rule.attribute || rawValue === void 0) continue;
+					const colon = name.indexOf(":");
+					const attributeNamespace = colon < 0 ? null : toTransitionalNamespaceUri(resolveNamespaceUri(element.namespaceScope, name.slice(0, colon)) ?? "");
+					if (rule.encoding === "hex") {
+						if (String(rawValue) !== paragraphIdentity) continue;
+					} else if (attributeNamespace !== rule.attributeNamespace) continue;
+					const value = String(rawValue);
+					const identity = normalizedIdentity(value, rule.encoding);
+					if (identity === void 0) continue;
+					const key = `${kind}:${identity}`;
+					const span = attributeValueSpans.get(name);
+					if (span === void 0) panic("Missing imported identity source span");
+					const offset = span.start;
+					const first = seen.get(key);
+					if (first === void 0) {
+						seen.set(key, {
+							part,
+							offset
+						});
+						break;
+					}
+					scoped.warn({
+						code: PARSE_WARNING_CODES.duplicateImportedId,
+						identityKind: kind,
+						element: element.name,
+						at: `offset ${offset}`,
+						value,
+						detail: `${kind} identity repeats the definition at offset ${first.offset} in ${first.part}.`
+					});
+					break;
+				}
+			}
+		});
+	}
+};
+//#endregion
+export { IMPORTED_ID_COLLISION_REGISTRY, diagnoseImportedIdCollisions };