@stll/folio-core 0.45.0 → 0.47.0

package/dist/docx/commentAnchorIndex.js

@@ -0,0 +1,50 @@
+import { visitInlineContentSlots } from "./paragraphTraversal.js";
+//#region src/docx/commentAnchorIndex.ts
+const visitCommentMarkers = (blocks, visit) => {
+	const visitParagraph = (paragraph) => {
+		visitInlineContentSlots(paragraph, ({ content, index, item }) => {
+			if (item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference") visit({
+				content,
+				index,
+				item
+			});
+		});
+	};
+	const visitBlock = (block) => {
+		if (block.type === "paragraph") {
+			visitParagraph(block);
+			return;
+		}
+		if (block.type === "table") {
+			for (const row of block.rows) for (const cell of row.cells) visitBlocks(cell.content);
+			return;
+		}
+		if (block.type !== "blockSdt") return;
+		visitBlocks(block.content);
+	};
+	const visitBlocks = (nested) => {
+		for (const block of nested) visitBlock(block);
+	};
+	visitBlocks(blocks);
+};
+/**
+* Comments that open a range anywhere in these blocks.
+*
+* A `commentReference` whose id is absent has no highlight of its own — the
+* point-comment shape the model's `CommentReference` documents — and only that
+* one needs its mark anchored onto neighbouring text. Anchoring one whose range
+* exists stretches that range to wherever the reference sits, which is how a
+* comment on one word came back covering the rest of the sentence. The range
+* and the reference need not share a paragraph, so the question is asked of the
+* whole story: a reference that trails the end of a range three paragraphs back
+* is still not a point comment.
+*/
+const rangedCommentIds = (blocks) => {
+	const ids = /* @__PURE__ */ new Set();
+	visitCommentMarkers(blocks, ({ item }) => {
+		if (item.type === "commentRangeStart") ids.add(item.id);
+	});
+	return ids;
+};
+//#endregion
+export { rangedCommentIds, visitCommentMarkers };

package/dist/docx/commentParser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/commentParser.d.ts
 type CommentExtendedInfo = {
   parentParaId?: string;

package/dist/docx/commentParser.js

@@ -1,8 +1,10 @@
 import { commentThreadParaId } from "./commentThreadKey.js";
+import { CAPTURE, dispatchChildren } from "./containerChildren.js";
+import { PARA_ID_NAMESPACE_URIS, paraIdAttribute, paraIdParentAttribute } from "./paraIdAttribute.js";
 import { parseParagraph } from "./paragraphParser.js";
 import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
-import { parseRunProperties } from "./runParser.js";
-import { NAMESPACES, WORDPROCESSINGML_NAMESPACE_URIS, findChild, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, parseOnOffValue, parseXml } from "./xmlParser.js";
+import { RUN_PROPERTY_OWNERS, parseRunProperties } from "./runParser.js";
+import { findChild, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, parseOnOffValue, parseXml } from "./xmlParser.js";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/docx/commentParser.ts
 /**
@@ -26,26 +28,6 @@ import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 /** The whole lexical form of `ST_DecimalNumber`: an optional sign and digits. */
 const DECIMAL_NUMBER = /^[+-]?\d+$/u;
 const DEFAULT_ANNOTATION_REFERENCE_STYLE_ID = "CommentReference";
-/**
-* The namespaces a paraId may be written in: Word 2010 and Word 2012 wordml.
-*
-* Resolved by URI rather than by prefix, because the value is a thread key: an
-* unrelated `vendor:paraId` picked up by local name alone would key a comment
-* to the wrong thread and carry that thread's date, parent and resolved state.
-*/
-const PARA_ID_NAMESPACE_URIS = /* @__PURE__ */ new Set([NAMESPACES.w14, NAMESPACES.w15]);
-/**
-* A paraId join key, wherever an exporter writes it: on `w:comment` or `w:p`.
-*
-* One reading for both, so the wrapper and the paragraphs cannot come to
-* disagree about what counts as a key. The literal reads are the fallback for
-* a part that writes a conventional prefix without binding it, which no URI
-* lookup can resolve.
-*/
-const paraIdAttribute = (element) => {
-	const raw = getAttributeByNamespaceUri(element, PARA_ID_NAMESPACE_URIS, "paraId") ?? element.attributes?.["w14:paraId"] ?? element.attributes?.["w15:paraId"] ?? getAttributeByNamespaceUri(element, WORDPROCESSINGML_NAMESPACE_URIS, "paraId") ?? element.attributes?.["w:paraId"];
-	return raw === null || raw === void 0 ? void 0 : String(raw);
-};
 const normalizeAnnotationReferenceFormatting = (formatting) => {
 	if (formatting?.styleId === DEFAULT_ANNOTATION_REFERENCE_STYLE_ID && Object.keys(formatting).length === 1) return;
 	return formatting;
@@ -54,10 +36,10 @@ const normalizeFirstCommentParagraph = (paragraphElement, paragraph, theme) => {
 	const firstContentElement = getChildElements(paragraphElement).find((element) => getLocalName(element.name) !== "pPr");
 	if (!firstContentElement || getLocalName(firstContentElement.name) !== "r" || !findChild(firstContentElement, "w", "annotationRef")) return { paragraph };
 	const runProperties = findChild(firstContentElement, "w", "rPr");
-	const annotationReferenceFormatting = normalizeAnnotationReferenceFormatting(runProperties ? parseRunProperties(runProperties, theme) : void 0);
+	const annotationReferenceFormatting = normalizeAnnotationReferenceFormatting(runProperties ? parseRunProperties(runProperties, theme, RUN_PROPERTY_OWNERS.standalone) : void 0);
 	const firstParsedContent = paragraph.content.at(0);
 	return {
-		paragraph: firstParsedContent?.type === "run" && firstParsedContent.content.length === 0 ? cloneParagraphWithPropertySource(paragraph, { content: paragraph.content.slice(1) }) : paragraph,
+		paragraph: firstParsedContent?.type === "run" && firstParsedContent.content.every((item) => item.type === "preservedXml" && item.text === "") ? cloneParagraphWithPropertySource(paragraph, { content: paragraph.content.slice(1) }) : paragraph,
 		...annotationReferenceFormatting !== void 0 ? { annotationReferenceFormatting } : {}
 	};
 };
@@ -75,9 +57,9 @@ function parseCommentsExtensible(xml) {
 	const container = findChild(root, "w16cex", "commentsExtensible") ?? root;
 	for (const child of getChildElements(container)) {
 		if ((child.name?.replace(/^.*:/u, "") ?? "") !== "comment") continue;
-		const paraId = getAttribute(child, "w16cex", "paraId") ?? getAttribute(child, "w15", "paraId") ?? child.attributes?.["w16cex:paraId"] ?? child.attributes?.["w15:paraId"];
-		const dateUtc = getAttribute(child, "w16cex", "dateUtc") ?? getAttribute(child, "w15", "dateUtc") ?? child.attributes?.["w16cex:dateUtc"] ?? child.attributes?.["w15:dateUtc"];
-		const key = paraId === null || paraId === void 0 ? null : String(paraId).toUpperCase();
+		const paraId = paraIdAttribute(child);
+		const dateUtc = getAttributeByNamespaceUri(child, PARA_ID_NAMESPACE_URIS, "dateUtc") ?? child.attributes?.["w16cex:dateUtc"] ?? child.attributes?.["w15:dateUtc"];
+		const key = paraId === void 0 ? null : paraId.toUpperCase();
 		if (key && dateUtc && !dateUtcByParaId.has(key)) dateUtcByParaId.set(key, String(dateUtc));
 	}
 	return dateUtcByParaId;
@@ -102,11 +84,11 @@ function parseCommentsExtended(xml) {
 	const container = findChild(root, "w15", "commentsEx") ?? root;
 	for (const child of getChildElements(container)) {
 		if ((child.name?.replace(/^.*:/u, "") ?? "") !== "commentEx") continue;
-		const paraId = getAttribute(child, "w15", "paraId") ?? child.attributes?.["w15:paraId"];
+		const paraId = paraIdAttribute(child);
 		if (!paraId) continue;
-		const key = String(paraId).toUpperCase();
+		const key = paraId.toUpperCase();
 		if (infoByParaId.has(key)) continue;
-		const parentParaId = getAttribute(child, "w15", "paraIdParent") ?? child.attributes?.["w15:paraIdParent"];
+		const parentParaId = paraIdParentAttribute(child);
 		const doneAttr = getAttribute(child, "w15", "done") ?? child.attributes?.["w15:done"];
 		const info = {};
 		if (parentParaId) info.parentParaId = String(parentParaId).toUpperCase();
@@ -155,16 +137,50 @@ function parseComments(commentsXml, styles, theme, rels, media, commentsExtensib
 		const done = (paraId ? extendedByParaId.get(paraId) : void 0)?.done;
 		const paragraphs = [];
 		let annotationReferenceFormatting;
-		for (const contentChild of getChildElements(child)) if ((contentChild.name?.replace(/^.*:/u, "") ?? "") === "p") {
-			const paragraph = parseParagraph(contentChild, styles, theme, null, rels, media);
-			if (paragraphs.length > 0) {
-				paragraphs.push(paragraph);
-				continue;
+		const preserved = dispatchChildren({
+			element: child,
+			container: "w:comment",
+			capturePosition: () => paragraphs.length,
+			handlers: {
+				p: (contentChild) => {
+					const paragraph = parseParagraph(contentChild, styles, theme, null, rels, media);
+					if (paragraphs.length > 0) {
+						paragraphs.push(paragraph);
+						return;
+					}
+					const normalized = normalizeFirstCommentParagraph(contentChild, paragraph, theme);
+					annotationReferenceFormatting = normalized.annotationReferenceFormatting;
+					paragraphs.push(normalized.paragraph);
+				},
+				altChunk: CAPTURE,
+				bookmarkEnd: CAPTURE,
+				bookmarkStart: CAPTURE,
+				commentRangeEnd: CAPTURE,
+				commentRangeStart: CAPTURE,
+				customXml: CAPTURE,
+				customXmlDelRangeEnd: CAPTURE,
+				customXmlDelRangeStart: CAPTURE,
+				customXmlInsRangeEnd: CAPTURE,
+				customXmlInsRangeStart: CAPTURE,
+				customXmlMoveFromRangeEnd: CAPTURE,
+				customXmlMoveFromRangeStart: CAPTURE,
+				customXmlMoveToRangeEnd: CAPTURE,
+				customXmlMoveToRangeStart: CAPTURE,
+				del: CAPTURE,
+				ins: CAPTURE,
+				moveFrom: CAPTURE,
+				moveFromRangeEnd: CAPTURE,
+				moveFromRangeStart: CAPTURE,
+				moveTo: CAPTURE,
+				moveToRangeEnd: CAPTURE,
+				moveToRangeStart: CAPTURE,
+				permEnd: CAPTURE,
+				permStart: CAPTURE,
+				proofErr: CAPTURE,
+				sdt: CAPTURE,
+				tbl: CAPTURE
 			}
-			const normalized = normalizeFirstCommentParagraph(contentChild, paragraph, theme);
-			annotationReferenceFormatting = normalized.annotationReferenceFormatting;
-			paragraphs.push(normalized.paragraph);
-		}
+		});
 		if (paraId && !commentIdByParaId.has(paraId)) commentIdByParaId.set(paraId, id);
 		parsed.push({
 			comment: {
@@ -174,6 +190,7 @@ function parseComments(commentsXml, styles, theme, rels, media, commentsExtensib
 				...date !== void 0 ? { date } : {},
 				...done !== void 0 ? { done } : {},
 				...annotationReferenceFormatting !== void 0 ? { annotationReferenceFormatting } : {},
+				...preserved !== void 0 ? { preserved } : {},
 				content: paragraphs
 			},
 			threadParaId: paraId

package/dist/docx/commentRangeIntegrity.d.ts

@@ -1,5 +1,20 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/docx/commentRangeIntegrity.d.ts
+/**
+ * Comment ids whose range is not a start followed by an end in this story's
+ * XML. Either half alone is invalid OOXML and anchors nothing: Word shows no
+ * comment for a range that never opens.
+ */
+declare const unbalancedCommentRangeIds: (xml: string) => Set<string>;
+/**
+ * Whether rewriting `originalXml` into `patchedXml` left a comment range with
+ * only one half. A save patches the paragraphs an edit touched and keeps the
+ * rest of the part byte-for-byte, so an edit that moves a range's only start
+ * out of a patched paragraph and into an untouched one writes an end with no
+ * start. Ranges the source already had unbalanced are not this save's doing
+ * and stay tolerated.
+ */
+declare const patchBreaksCommentRangeBalance: (originalXml: string, patchedXml: string) => boolean;
 declare const withoutOrphanCommentRanges: (doc: document_d_exports.Document) => document_d_exports.Document;
 //#endregion
-export { withoutOrphanCommentRanges };
+export { patchBreaksCommentRangeBalance, unbalancedCommentRangeIds, withoutOrphanCommentRanges };

package/dist/docx/commentRangeIntegrity.js

@@ -1,5 +1,45 @@
 import { cloneParagraphWithPropertySource } from "./paragraphPropertySource.js";
 //#region src/docx/commentRangeIntegrity.ts
+const COMMENT_RANGE_MARKER_PATTERN = /<w:commentRange(Start|End)\s[^>]*w:id="(\d+)"/gu;
+/**
+* Comment ids whose range is not a start followed by an end in this story's
+* XML. Either half alone is invalid OOXML and anchors nothing: Word shows no
+* comment for a range that never opens.
+*/
+const unbalancedCommentRangeIds = (xml) => {
+	const firstStart = /* @__PURE__ */ new Map();
+	const lastEnd = /* @__PURE__ */ new Map();
+	for (const match of xml.matchAll(COMMENT_RANGE_MARKER_PATTERN)) {
+		const [, half, id] = match;
+		if (id === void 0) continue;
+		if (half === "Start") {
+			if (!firstStart.has(id)) firstStart.set(id, match.index);
+			continue;
+		}
+		lastEnd.set(id, match.index);
+	}
+	const unbalanced = /* @__PURE__ */ new Set();
+	for (const id of /* @__PURE__ */ new Set([...firstStart.keys(), ...lastEnd.keys()])) {
+		const start = firstStart.get(id);
+		const end = lastEnd.get(id);
+		if (start === void 0 || end === void 0 || end < start) unbalanced.add(id);
+	}
+	return unbalanced;
+};
+/**
+* Whether rewriting `originalXml` into `patchedXml` left a comment range with
+* only one half. A save patches the paragraphs an edit touched and keeps the
+* rest of the part byte-for-byte, so an edit that moves a range's only start
+* out of a patched paragraph and into an untouched one writes an end with no
+* start. Ranges the source already had unbalanced are not this save's doing
+* and stay tolerated.
+*/
+const patchBreaksCommentRangeBalance = (originalXml, patchedXml) => {
+	const introduced = unbalancedCommentRangeIds(patchedXml);
+	if (introduced.size === 0) return false;
+	const preexisting = unbalancedCommentRangeIds(originalXml);
+	return [...introduced].some((id) => !preexisting.has(id));
+};
 const withoutOrphanCommentRanges = (doc) => {
 	const validCommentIds = new Set((doc.package.document.comments ?? []).map((comment) => comment.id));
 	const document = withoutOrphanDocumentBodyMarkers(doc.package.document, validCommentIds);
@@ -107,6 +147,7 @@ const withoutOrphanBlockMarkers = (blocks, validCommentIds) => {
 const withoutOrphanBlockMarker = (block, validCommentIds) => {
 	if (block.type === "paragraph") return withoutOrphanParagraphMarkers(block, validCommentIds);
 	if (block.type === "table") return withoutOrphanTableMarkers(block, validCommentIds);
+	if (block.type !== "blockSdt") return block;
 	const content = withoutOrphanBlockMarkers(block.content, validCommentIds);
 	if (!content) return block;
 	return {
@@ -180,4 +221,4 @@ const withoutOrphanParagraphMarkers = (paragraph, validCommentIds) => {
 };
 const isCommentMarker = (content) => content.type === "commentRangeStart" || content.type === "commentRangeEnd" || content.type === "commentReference";
 //#endregion
-export { withoutOrphanCommentRanges };
+export { patchBreaksCommentRangeBalance, unbalancedCommentRangeIds, withoutOrphanCommentRanges };

package/dist/docx/commentRangeJoin.d.ts

@@ -0,0 +1,9 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/commentRangeJoin.d.ts
+/**
+ * Collapse each comment's range markers to its first start and its last end.
+ * Answers how many markers were dropped.
+ */
+declare const joinCommentRangesAcrossParagraphs: (blocks: readonly document_d_exports.BlockContent[]) => number;
+//#endregion
+export { joinCommentRangesAcrossParagraphs };

package/dist/docx/commentRangeJoin.js

@@ -0,0 +1,33 @@
+import { visitCommentMarkers } from "./commentAnchorIndex.js";
+import { InlineContentRemovals } from "./inlineContentRemovals.js";
+//#region src/docx/commentRangeJoin.ts
+/**
+* Collapse each comment's range markers to its first start and its last end.
+* Answers how many markers were dropped.
+*/
+const joinCommentRangesAcrossParagraphs = (blocks) => {
+	const startsById = /* @__PURE__ */ new Map();
+	const endsById = /* @__PURE__ */ new Map();
+	visitCommentMarkers(blocks, ({ content, index, item }) => {
+		if (item.type === "commentReference") return;
+		const slotsById = item.type === "commentRangeStart" ? startsById : endsById;
+		const slots = slotsById.get(item.id);
+		if (slots) {
+			slots.push({
+				content,
+				index
+			});
+			return;
+		}
+		slotsById.set(item.id, [{
+			content,
+			index
+		}]);
+	});
+	const removals = new InlineContentRemovals();
+	for (const slots of startsById.values()) for (const slot of slots.slice(1)) removals.mark(slot);
+	for (const slots of endsById.values()) for (const slot of slots.slice(0, -1)) removals.mark(slot);
+	return removals.apply();
+};
+//#endregion
+export { joinCommentRangesAcrossParagraphs };

package/dist/docx/commentReferenceCompletion.d.ts

@@ -0,0 +1,9 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/docx/commentReferenceCompletion.d.ts
+/**
+ * Give every comment that a `commentRangeEnd` closes but no `commentReference`
+ * names a reference after its last end. Answers how many were added.
+ */
+declare const completeCommentReferences: (blocks: readonly document_d_exports.BlockContent[]) => number;
+//#endregion
+export { completeCommentReferences };

package/dist/docx/commentReferenceCompletion.js

@@ -0,0 +1,47 @@
+import { visitCommentMarkers } from "./commentAnchorIndex.js";
+//#region src/docx/commentReferenceCompletion.ts
+/**
+* Give every comment that a `commentRangeEnd` closes but no `commentReference`
+* names a reference after its last end. Answers how many were added.
+*/
+const completeCommentReferences = (blocks) => {
+	const lastRangeEnds = /* @__PURE__ */ new Map();
+	const referencedIds = /* @__PURE__ */ new Set();
+	visitCommentMarkers(blocks, ({ content, index, item }) => {
+		if (item.type === "commentReference") {
+			referencedIds.add(item.id);
+			return;
+		}
+		if (item.type === "commentRangeEnd") lastRangeEnds.set(item.id, {
+			content,
+			index
+		});
+	});
+	const insertionsByContent = /* @__PURE__ */ new Map();
+	for (const [id, { content, index }] of lastRangeEnds) {
+		if (referencedIds.has(id)) continue;
+		const pending = insertionsByContent.get(content);
+		if (pending) {
+			pending.push({
+				index,
+				id
+			});
+			continue;
+		}
+		insertionsByContent.set(content, [{
+			index,
+			id
+		}]);
+	}
+	let added = 0;
+	for (const [content, pending] of insertionsByContent) for (const { index, id } of pending.toSorted((first, second) => second.index - first.index || second.id - first.id)) {
+		content.splice(index + 1, 0, {
+			type: "commentReference",
+			id
+		});
+		added += 1;
+	}
+	return added;
+};
+//#endregion
+export { completeCommentReferences };

package/dist/docx/commentReferenceNormalization.js

@@ -1,4 +1,5 @@
-import { InlineContentRemovals, visitInlineContentSlots } from "./paragraphTraversal.js";
+import { InlineContentRemovals } from "./inlineContentRemovals.js";
+import { visitInlineContentSlots } from "./paragraphTraversal.js";
 import { PARSE_WARNING_CODES } from "@stll/docx-core/model";
 //#region src/docx/commentReferenceNormalization.ts
 /** The codes this normalisation is reported under, owned here, not at the caller. */
@@ -39,6 +40,7 @@ const normalizeCommentReferences = ({ documentBody, comments, headers, footers,
 			normalizeTable(block);
 			return;
 		}
+		if (block.type !== "blockSdt") return;
 		normalizeBlocks(block.content);
 	};
 	const normalizeBlocks = (blocks) => {

package/dist/docx/commentReplyMarkers.js

@@ -25,34 +25,26 @@ const eachParagraph = (blocks, visit) => {
 			for (const row of block.rows ?? []) for (const cell of row.cells ?? []) eachParagraph(cell.content ?? [], visit);
 			continue;
 		}
+		if (block.type !== "blockSdt") continue;
 		eachParagraph(block.content ?? [], visit);
 	}
 };
-const scanAnchors = (surfaces) => {
-	const rangeIds = /* @__PURE__ */ new Set();
+/** Comment ids with any anchor (a range start OR a `commentReference` run). */
+const scanAnchoredIds = (surfaces) => {
 	const anchoredIds = /* @__PURE__ */ new Set();
 	for (const group of surfaceBlockGroups(surfaces)) eachParagraph(group, (paragraph) => {
-		for (const item of paragraph.content ?? []) if (item.type === "commentRangeStart") {
-			rangeIds.add(item.id);
-			anchoredIds.add(item.id);
-		} else if (item.type === "commentReference") anchoredIds.add(item.id);
+		for (const item of paragraph.content ?? []) if (item.type === "commentRangeStart" || item.type === "commentReference") anchoredIds.add(item.id);
 	});
-	return {
-		rangeIds,
-		anchoredIds
-	};
+	return anchoredIds;
 };
 /** Replies whose parent is another comment (the threaded-discussion shape). */
 const commentParentedReplies = (comments) => {
 	const commentIds = new Set(comments.map((comment) => comment.id));
 	return comments.filter((comment) => comment.parentId !== void 0 && commentIds.has(comment.parentId));
 };
-const injectIntoParagraph = (paragraph, replyIdsByParent, parentsWithRange) => {
+const injectIntoParagraph = (paragraph, replyIdsByParent) => {
 	const content = paragraph.content ?? [];
-	if (!content.some((item) => {
-		if (item.type === "commentRangeStart" || item.type === "commentRangeEnd") return replyIdsByParent.has(item.id);
-		return item.type === "commentReference" && !parentsWithRange.has(item.id) ? replyIdsByParent.has(item.id) : false;
-	})) return 0;
+	if (!content.some((item) => (item.type === "commentRangeStart" || item.type === "commentRangeEnd" || item.type === "commentReference") && replyIdsByParent.has(item.id))) return 0;
 	const next = [];
 	let injected = 0;
 	for (const item of content) {
@@ -68,7 +60,7 @@ const injectIntoParagraph = (paragraph, replyIdsByParent, parentsWithRange) => {
 			type: "commentRangeEnd",
 			id: replyId
 		});
-		else if (item.type === "commentReference" && !parentsWithRange.has(item.id)) for (const replyId of replyIdsByParent.get(item.id) ?? []) {
+		else if (item.type === "commentReference") for (const replyId of replyIdsByParent.get(item.id) ?? []) {
 			next.push({
 				type: "commentReference",
 				id: replyId
@@ -82,7 +74,7 @@ const injectIntoParagraph = (paragraph, replyIdsByParent, parentsWithRange) => {
 const synthesizeReplyRangeMarkers = (surfaces) => {
 	const replies = commentParentedReplies(surfaces.comments);
 	if (replies.length === 0) return 0;
-	const { rangeIds, anchoredIds } = scanAnchors(surfaces);
+	const anchoredIds = scanAnchoredIds(surfaces);
 	const replyIdsByParent = /* @__PURE__ */ new Map();
 	for (const reply of replies) {
 		if (anchoredIds.has(reply.id) || reply.parentId === void 0) continue;
@@ -93,7 +85,7 @@ const synthesizeReplyRangeMarkers = (surfaces) => {
 	if (replyIdsByParent.size === 0) return 0;
 	let injected = 0;
 	const visit = (paragraph) => {
-		injected += injectIntoParagraph(paragraph, replyIdsByParent, rangeIds);
+		injected += injectIntoParagraph(paragraph, replyIdsByParent);
 	};
 	for (const group of surfaceBlockGroups(surfaces)) eachParagraph(group, visit);
 	return injected;
@@ -116,7 +108,7 @@ const hasUnsynthesizedReplyRanges = (doc) => {
 	const surfaces = surfacesFromDocument(doc);
 	const replies = commentParentedReplies(surfaces.comments);
 	if (replies.length === 0) return false;
-	const { anchoredIds } = scanAnchors(surfaces);
+	const anchoredIds = scanAnchoredIds(surfaces);
 	return replies.some((reply) => !anchoredIds.has(reply.id));
 };
 //#endregion

package/dist/docx/compatibility.js

@@ -1,4 +1,5 @@
 import { DRAWING_SAFETY_CLASSES, classifyDrawingSafety } from "./imageRawXml.js";
+import { panic } from "better-result";
 import { DOCX_CONFORMANCE_CLASSES } from "@stll/docx-core/model";
 //#region src/docx/compatibility.ts
 /**
@@ -97,6 +98,7 @@ function inspectBlocks(blocks, context) {
 			});
 			continue;
 		}
+		if (block.type !== "blockSdt") continue;
 		inspectBlocks(block.content, {
 			part: context.part,
 			path: `${blockPath}.content`,
@@ -113,53 +115,66 @@ function inspectParagraphContent(content, context) {
 			...context,
 			path: `${context.path}[${itemIndex}]`
 		};
-		if (item.type === "run") {
-			inspectRun(item, itemContext);
-			continue;
-		}
-		if (item.type === "hyperlink") {
-			inspectHyperlink(item, itemContext);
-			continue;
-		}
-		if (item.type === "inlineSdt") {
-			inspectParagraphContent(item.content, {
-				...itemContext,
-				path: `${itemContext.path}.content`
-			});
-			continue;
+		switch (item.type) {
+			case "run":
+				inspectRun(item, itemContext);
+				continue;
+			case "hyperlink":
+				inspectHyperlink(item, itemContext);
+				continue;
+			case "inlineSdt":
+			case "inlineWrapper":
+			case "insertion":
+			case "deletion":
+			case "moveFrom":
+			case "moveTo":
+			case "simpleField":
+				inspectParagraphContent(item.content, {
+					...itemContext,
+					path: `${itemContext.path}.content`
+				});
+				continue;
+			case "complexField":
+				for (const [runIndex, run] of item.fieldCode.entries()) inspectRun(run, {
+					...itemContext,
+					path: `${itemContext.path}.fieldCode[${runIndex}]`
+				});
+				for (const [runIndex, run] of item.fieldResult.entries()) inspectRun(run, {
+					...itemContext,
+					path: `${itemContext.path}.fieldResult[${runIndex}]`
+				});
+				continue;
+			case "bookmarkStart":
+			case "bookmarkEnd":
+			case "commentRangeStart":
+			case "commentRangeEnd":
+			case "commentReference":
+			case "moveFromRangeStart":
+			case "moveFromRangeEnd":
+			case "moveToRangeStart":
+			case "moveToRangeEnd":
+			case "mathEquation":
+			case "preservedInline": continue;
+			default: panic(`Unsupported paragraph content: ${JSON.stringify(item)}`);
 		}
-		if (item.type === "insertion" || item.type === "deletion" || item.type === "moveFrom" || item.type === "moveTo") {
-			inspectParagraphContent(item.content, {
-				...itemContext,
-				path: `${itemContext.path}.content`
-			});
-			continue;
-		}
-		if (item.type === "simpleField") {
-			inspectParagraphContent(item.content, {
-				...itemContext,
-				path: `${itemContext.path}.content`
+	}
+}
+function inspectHyperlink(hyperlink, context) {
+	for (const [childIndex, child] of hyperlink.children.entries()) {
+		const path = `${context.path}.children[${childIndex}]`;
+		if (child.type === "run") {
+			inspectRun(child, {
+				...context,
+				path
 			});
 			continue;
 		}
-		if (item.type === "complexField") {
-			for (const [runIndex, run] of item.fieldCode.entries()) inspectRun(run, {
-				...itemContext,
-				path: `${itemContext.path}.fieldCode[${runIndex}]`
-			});
-			for (const [runIndex, run] of item.fieldResult.entries()) inspectRun(run, {
-				...itemContext,
-				path: `${itemContext.path}.fieldResult[${runIndex}]`
-			});
-		}
+		if (child.type === "inlineWrapper") inspectParagraphContent(child.content, {
+			...context,
+			path: `${path}.content`
+		});
 	}
 }
-function inspectHyperlink(hyperlink, context) {
-	for (const [childIndex, child] of hyperlink.children.entries()) if (child.type === "run") inspectRun(child, {
-		...context,
-		path: `${context.path}.children[${childIndex}]`
-	});
-}
 function inspectRun(run, context) {
 	for (const [contentIndex, content] of run.content.entries()) {
 		if (content.type !== "drawing") continue;