@stll/folio-core 0.28.1 → 0.30.0

package/dist/prosemirror/listMarker.js

@@ -0,0 +1,185 @@
+import { convertBulletToUnicode } from "../docx/bulletMarkers.js";
+import { formatOoxmlCounter } from "../docx/ooxmlCounterFormatter.js";
+//#region src/prosemirror/listMarker.ts
+const MAX_LIST_LEVEL = 8;
+function createListCounterState() {
+	return {
+		counters: /* @__PURE__ */ new Map(),
+		abstractCounters: /* @__PURE__ */ new Map(),
+		seenLevels: /* @__PURE__ */ new Set()
+	};
+}
+function cloneListCounterState(state) {
+	const counters = /* @__PURE__ */ new Map();
+	for (const [numId, values] of state.counters) counters.set(numId, [...values]);
+	const abstractCounters = /* @__PURE__ */ new Map();
+	for (const [abstractNumId, values] of state.abstractCounters) abstractCounters.set(abstractNumId, [...values]);
+	return {
+		counters,
+		abstractCounters,
+		seenLevels: new Set(state.seenLevels),
+		...state.lastAdvancedNumId !== void 0 ? { lastAdvancedNumId: state.lastAdvancedNumId } : {}
+	};
+}
+const isListNumPr = (value) => value !== void 0 && value !== null;
+const sameListNumPr = (left, right) => left.numId === right.numId && left.ilvl === right.ilvl;
+function previousListAttrs(attrs) {
+	const previous = (attrs._propertyChanges?.find(({ previousFormatting }) => {
+		const previousNumPr = previousFormatting?.numPr;
+		return isListNumPr(previousNumPr) && (!attrs.numPr || !sameListNumPr(previousNumPr, attrs.numPr));
+	}))?.previousFormatting;
+	if (!previous || !isListNumPr(previous.numPr)) return null;
+	return {
+		numPr: previous.numPr,
+		...previous.listIsBullet !== void 0 ? { listIsBullet: previous.listIsBullet } : {},
+		...previous.listIsLegal !== void 0 ? { listIsLegal: previous.listIsLegal } : {},
+		...previous.listNumFmt !== void 0 ? { listNumFmt: previous.listNumFmt } : {},
+		...previous.listMarker !== void 0 ? { listMarker: previous.listMarker } : {},
+		...previous.listMarkerHidden !== void 0 ? { listMarkerHidden: previous.listMarkerHidden } : {},
+		...previous.listLevelNumFmts !== void 0 ? { listLevelNumFmts: previous.listLevelNumFmts } : {},
+		...previous.listLevelStarts !== void 0 ? { listLevelStarts: previous.listLevelStarts } : {},
+		...previous.listAbstractNumId !== void 0 ? { listAbstractNumId: previous.listAbstractNumId } : {},
+		...previous.listStartOverride !== void 0 ? { listStartOverride: previous.listStartOverride } : {}
+	};
+}
+/**
+* Advance the counter stream that paints this paragraph's marker. Normal
+* paragraphs advance both final and original streams; inserted/deleted list
+* paragraphs advance only the document view in which they exist.
+*/
+function advanceVisibleListMarker(attrs, streams) {
+	const advances = [];
+	const advance = (counterAttrs, stream) => {
+		const counterState = streams[stream];
+		const advanced = {
+			marker: advanceListMarker(counterAttrs, counterState),
+			counterAttrs,
+			counterState,
+			stream
+		};
+		advances.push(advanced);
+		return advanced;
+	};
+	const previous = previousListAttrs(attrs);
+	if (!attrs.numPr) return {
+		...advance(previous ?? attrs, previous ? "original" : "final"),
+		advances
+	};
+	if (attrs.pPrMark?.kind === "del") return {
+		...advance(attrs, "original"),
+		advances
+	};
+	const numberingWasAdded = attrs._propertyChanges?.some(({ previousFormatting }) => previousFormatting && Object.hasOwn(previousFormatting, "numPr") && previousFormatting.numPr == null);
+	const numberingChanged = previous?.numPr !== void 0 && !sameListNumPr(previous.numPr, attrs.numPr);
+	const visible = advance(attrs, "final");
+	if (attrs.pPrMark?.kind !== "ins" && !numberingWasAdded && !numberingChanged) advance(attrs, "original");
+	else if (numberingChanged && previous) advance(previous, "original");
+	return {
+		...visible,
+		advances
+	};
+}
+function formatCounter(value, format) {
+	return formatOoxmlCounter(value, format);
+}
+function resolveListTemplate(options) {
+	return resolveListTemplateWithComponents(options).value;
+}
+function resolveListTemplateWithComponents({ template, counters, levelFormats, forceDecimal = false }) {
+	const components = [];
+	let value = "";
+	let sourceEnd = 0;
+	for (const match of template.matchAll(/%(?<digit>\d)(?<punct>[.):\]])?/gu)) {
+		const sourceStart = match.index;
+		const relativeStart = value.length;
+		value += template.slice(sourceEnd, sourceStart);
+		sourceEnd = sourceStart + match[0].length;
+		const index = Number.parseInt(match.groups?.["digit"] ?? "", 10) - 1;
+		if (index < 0) continue;
+		const counter = counters[index];
+		if (counter === void 0 || Number.isNaN(counter)) continue;
+		const formatted = formatCounter(counter, forceDecimal ? "decimal" : levelFormats?.[index]);
+		if (!formatted) continue;
+		const start = value.length;
+		value += formatted;
+		components.push({
+			level: index,
+			relativeStart,
+			start,
+			end: value.length
+		});
+		value += match.groups?.["punct"] ?? "";
+	}
+	value += template.slice(sourceEnd);
+	return {
+		value,
+		components
+	};
+}
+function getLastListCounters(state) {
+	return state.lastAdvancedNumId === void 0 ? void 0 : state.counters.get(state.lastAdvancedNumId);
+}
+function formatNumberedMarker(counters, level) {
+	const parts = [];
+	for (let index = 0; index <= level; index += 1) {
+		const value = counters[index] ?? 0;
+		if (!Number.isFinite(value) || value <= 0) break;
+		parts.push(value);
+	}
+	return parts.length === 0 ? "1." : `${parts.join(".")}.`;
+}
+function advanceListMarker(attrs, state) {
+	const level = attrs.numPr?.ilvl ?? 0;
+	if (!Number.isInteger(level) || level < 0 || level > 8) return null;
+	const numId = attrs.numPr?.numId;
+	if (numId === void 0 || numId === 0) {
+		if (attrs.listMarker?.includes("%") && !attrs.listIsBullet) {
+			const counters = getLastListCounters(state);
+			if (counters) return resolveListTemplate({
+				template: attrs.listMarker,
+				counters,
+				levelFormats: attrs.listLevelNumFmts,
+				forceDecimal: attrs.listIsLegal
+			});
+		}
+		return null;
+	}
+	if (attrs.listIsBullet) return convertBulletToUnicode(attrs.listMarker ?? "");
+	const counters = state.counters.get(numId) ?? Array.from({ length: 9 }, () => NaN);
+	const abstractNumId = attrs.listAbstractNumId;
+	if (level > 0) {
+		const latestAbstractCounters = abstractNumId === void 0 ? void 0 : state.abstractCounters.get(abstractNumId);
+		if (counters.slice(0, level).every((counter) => !Number.isFinite(counter))) for (let index = 0; index < level; index += 1) {
+			const latestCounter = latestAbstractCounters?.[index];
+			counters[index] = latestCounter !== void 0 && Number.isFinite(latestCounter) ? latestCounter : attrs.listLevelStarts?.[index] ?? 1;
+		}
+	}
+	const seenKey = `${numId}:${level}`;
+	if (!state.seenLevels.has(seenKey)) {
+		state.seenLevels.add(seenKey);
+		if (attrs.listStartOverride != null) counters[level] = attrs.listStartOverride - 1;
+	}
+	if (!Number.isFinite(counters[level])) counters[level] = (attrs.listLevelStarts?.[level] ?? 1) - 1;
+	counters[level] = (counters[level] ?? 0) + 1;
+	for (let index = level + 1; index < counters.length; index += 1) counters[index] = NaN;
+	const childAdvances = attrs.listImplicitChildLevelAdvances ?? 0;
+	if (childAdvances > 0 && level + 1 < counters.length) {
+		const childCounter = counters[level + 1];
+		counters[level + 1] = (childCounter === void 0 || !Number.isFinite(childCounter) ? 0 : childCounter) + childAdvances;
+	}
+	state.counters.set(numId, counters);
+	state.lastAdvancedNumId = numId;
+	if (abstractNumId !== void 0) state.abstractCounters.set(abstractNumId, [...counters]);
+	const levelFormats = attrs.listLevelNumFmts ?? (attrs.listNumFmt ? [attrs.listNumFmt] : void 0);
+	if (attrs.listMarker?.includes("%")) return resolveListTemplate({
+		template: attrs.listMarker,
+		counters,
+		levelFormats,
+		forceDecimal: attrs.listIsLegal
+	});
+	if (attrs.listMarker) return attrs.listMarker;
+	if ((levelFormats?.[level] ?? attrs.listNumFmt) === "none" || attrs.listMarker === "") return null;
+	return formatNumberedMarker(counters, level);
+}
+//#endregion
+export { MAX_LIST_LEVEL, advanceListMarker, advanceVisibleListMarker, cloneListCounterState, createListCounterState, formatCounter, resolveListTemplate, resolveListTemplateWithComponents };

package/dist/prosemirror/numberedRefFields.d.ts

@@ -0,0 +1,24 @@
+import { ListCounterState } from "./listMarker.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/numberedRefFields.d.ts
+type NumberSwitch = "n" | "r" | "w";
+type NumberedRefSpec = {
+  bookmark: string;
+  numberSwitch: NumberSwitch;
+};
+type NumberedRefResolutionOptions = {
+  /** Counter snapshot at the start of this body story. The resolver consumes it in place. */
+  listCounterState?: ListCounterState;
+  /** Counter snapshot for tracked deletions in the original document view. */
+  originalListCounterState?: ListCounterState;
+};
+declare function parseNumberedRefInstruction(instruction: string): NumberedRefSpec | null;
+/** Stamp only proven numbered REF fields with clone-safe calibration state. */
+declare function stampNumberedRefFieldBaselines(doc: Node): Node;
+/**
+ * Resolve bounded, numbered REF fields against bookmarks in the ProseMirror body story.
+ * Unsupported or uncalibrated fields are absent from the returned map and retain their cache.
+ */
+declare function resolveNumberedRefFields(doc: Node, options?: NumberedRefResolutionOptions): ReadonlyMap<Node, string>;
+//#endregion
+export { NumberedRefResolutionOptions, parseNumberedRefInstruction, resolveNumberedRefFields, stampNumberedRefFieldBaselines };

package/dist/prosemirror/numberedRefFields.js

@@ -0,0 +1,276 @@
+import { expectFieldAttrs, expectParagraphAttrs } from "./attrs/index.js";
+import { expectBookmarkBoundaryAttrs } from "./bookmarkBoundaryAttrs.js";
+import { advanceVisibleListMarker, createListCounterState, resolveListTemplateWithComponents } from "./listMarker.js";
+import { Fragment } from "prosemirror-model";
+//#region src/prosemirror/numberedRefFields.ts
+const MAX_FIELD_INSTRUCTION_CHARS = 2048;
+const MAX_BOOKMARK_NAME_CHARS = 256;
+const MAX_NUMBERED_REF_FIELDS = 1024;
+const MAX_BOOKMARK_TARGETS = 2048;
+function tokenizeInstruction(instruction) {
+	const tokens = [];
+	let index = 0;
+	while (index < instruction.length) {
+		while (/\s/u.test(instruction[index] ?? "")) index += 1;
+		if (index >= instruction.length) break;
+		if (instruction[index] === "\"") {
+			const close = instruction.indexOf("\"", index + 1);
+			if (close === -1) return null;
+			tokens.push(instruction.slice(index + 1, close));
+			index = close + 1;
+			continue;
+		}
+		let end = index;
+		while (end < instruction.length && !/\s/u.test(instruction[end] ?? "")) end += 1;
+		tokens.push(instruction.slice(index, end));
+		index = end;
+	}
+	return tokens;
+}
+function parseNumberedRefInstruction(instruction) {
+	if (instruction.length > MAX_FIELD_INSTRUCTION_CHARS) return null;
+	const tokens = tokenizeInstruction(instruction);
+	if (tokens === null || tokens.length < 3 || tokens.at(0)?.toUpperCase() !== "REF") return null;
+	const bookmark = tokens.at(1);
+	if (!bookmark || bookmark.length > MAX_BOOKMARK_NAME_CHARS || bookmark.startsWith("\\")) return null;
+	let numberSwitch = null;
+	for (let index = 2; index < tokens.length; index += 1) {
+		const token = tokens[index]?.toUpperCase();
+		if (token === "\\N" || token === "\\R" || token === "\\W") {
+			if (numberSwitch !== null) return null;
+			if (token === "\\N") numberSwitch = "n";
+			else if (token === "\\R") numberSwitch = "r";
+			else numberSwitch = "w";
+			continue;
+		}
+		if (token === "\\H") continue;
+		if (token === "\\*MERGEFORMAT") continue;
+		if (token === "\\*" && tokens[index + 1]?.toUpperCase() === "MERGEFORMAT") {
+			index += 1;
+			continue;
+		}
+		return null;
+	}
+	return numberSwitch === null ? null : {
+		bookmark,
+		numberSwitch
+	};
+}
+function trimTrailingPeriod(value) {
+	return value.length > 1 && value.endsWith(".") ? value.slice(0, -1) : value;
+}
+function firstReferencedLevel(template) {
+	let first = null;
+	for (const match of template.matchAll(/%(?<level>[1-9])/gu)) {
+		const level = Number.parseInt(match.groups?.["level"] ?? "", 10) - 1;
+		if (Number.isNaN(level)) continue;
+		first = first === null ? level : Math.min(first, level);
+	}
+	return first;
+}
+function numberTargetForParagraph(node, contextStreams, streams) {
+	const resolution = advanceVisibleListMarker(expectParagraphAttrs(node), streams);
+	let visibleTarget = null;
+	for (const advanced of resolution.advances) {
+		const target = numberTargetForAdvancedMarker(advanced.counterAttrs, advanced.marker, advanced.counterState, contextStreams[advanced.stream]);
+		if (advanced.stream === resolution.stream && advanced.counterAttrs === resolution.counterAttrs) visibleTarget = target;
+	}
+	return visibleTarget;
+}
+function numberTargetForAdvancedMarker(attrs, resolvedMarker, state, contexts) {
+	const numId = attrs.numPr?.numId;
+	if (numId === void 0 || numId === 0 || attrs.listIsBullet || attrs.listMarkerHidden || attrs.listNumFmt === "none" || !resolvedMarker) return null;
+	const marker = attrs.listMarkerAllCaps ? resolvedMarker.toLocaleUpperCase() : resolvedMarker;
+	const level = attrs.numPr?.ilvl ?? 0;
+	if (!Number.isInteger(level) || level < 0 || level > 8) return null;
+	const counters = state.counters.get(numId)?.slice(0, level + 1);
+	const levelFormats = attrs.listLevelNumFmts ?? (attrs.listNumFmt ? [attrs.listNumFmt] : void 0);
+	let renderedMarker = {
+		value: marker,
+		components: []
+	};
+	if (attrs.listMarker?.includes("%") && counters?.length === level + 1) {
+		const rendered = resolveListTemplateWithComponents({
+			template: attrs.listMarker,
+			counters,
+			levelFormats,
+			forceDecimal: attrs.listIsLegal
+		});
+		if ((attrs.listMarkerAllCaps ? rendered.value.toLocaleUpperCase() : rendered.value) === marker) renderedMarker = {
+			value: marker,
+			components: rendered.components
+		};
+	}
+	const abstractContexts = attrs.listAbstractNumId === void 0 ? void 0 : contexts.byAbstractNumId.get(attrs.listAbstractNumId);
+	const ownContexts = contexts.byNumId.get(numId) ?? [...abstractContexts ?? []];
+	const firstLevel = firstReferencedLevel(attrs.listMarker ?? "");
+	let renderedFull;
+	if (level === 0 || firstLevel === 0) renderedFull = renderedMarker;
+	else {
+		const parentLevel = (firstLevel ?? level) - 1;
+		const prefix = ownContexts[parentLevel] ?? abstractContexts?.[parentLevel];
+		renderedFull = prefix === void 0 ? null : {
+			value: `${prefix.value}${marker}`,
+			components: [...prefix.components, ...renderedMarker.components.map((component) => ({
+				level: component.level,
+				relativeStart: component.relativeStart + prefix.value.length,
+				start: component.start + prefix.value.length,
+				end: component.end + prefix.value.length
+			}))]
+		};
+	}
+	ownContexts[level] = renderedFull ?? void 0;
+	ownContexts.splice(level + 1);
+	contexts.byNumId.set(numId, ownContexts);
+	if (attrs.listAbstractNumId !== void 0) contexts.byAbstractNumId.set(attrs.listAbstractNumId, [...ownContexts]);
+	const path = counters?.length === level + 1 && counters.every(Number.isFinite) && renderedFull !== null ? {
+		scheme: attrs.listAbstractNumId === void 0 ? {
+			type: "instance",
+			id: numId
+		} : {
+			type: "abstract",
+			id: attrs.listAbstractNumId
+		},
+		counters,
+		rendered: renderedFull
+	} : null;
+	return {
+		current: trimTrailingPeriod(marker),
+		full: renderedFull === null ? null : trimTrailingPeriod(renderedFull.value),
+		path
+	};
+}
+function sameNumberingScheme(left, right) {
+	return left.type === right.type && left.id === right.id;
+}
+function relativeNumber(target, source) {
+	if (source === null || source.path === null || target.path === null) return target.full;
+	if (!sameNumberingScheme(source.path.scheme, target.path.scheme)) return target.full;
+	let sharedLevels = 0;
+	const comparedLevels = Math.min(source.path.counters.length, target.path.counters.length);
+	while (sharedLevels < comparedLevels && source.path.counters[sharedLevels] === target.path.counters[sharedLevels]) sharedLevels += 1;
+	if (sharedLevels === 0) return target.full;
+	if (sharedLevels >= target.path.counters.length) return null;
+	const firstRelativeComponent = target.path.rendered.components.find((component) => component.level >= sharedLevels);
+	if (firstRelativeComponent === void 0) return null;
+	const suffix = target.path.rendered.value.slice(firstRelativeComponent.relativeStart).replace(/^[\s,.:;/-]+/u, "");
+	return suffix.length === 0 ? null : trimTrailingPeriod(suffix);
+}
+function normalizeCachedResult(value) {
+	return value.replaceAll("\xA0", " ").replace(/\s+/gu, " ").trim();
+}
+function collectNumberedRefCandidates(doc, options) {
+	const fields = [];
+	doc.descendants((node) => {
+		if (node.type.name !== "field" && node.type.name !== "structuredField") return true;
+		if (fields.length >= MAX_NUMBERED_REF_FIELDS) return false;
+		const attrs = expectFieldAttrs(node);
+		if (attrs.fieldType !== "REF" || attrs.fldLock) return false;
+		const spec = parseNumberedRefInstruction(attrs.instruction);
+		if (spec !== null) fields.push({
+			node,
+			spec,
+			cached: attrs.displayText
+		});
+		return false;
+	});
+	if (fields.length === 0) return [];
+	const referencedBookmarks = new Set(fields.map(({ spec }) => spec.bookmark));
+	const fieldNodes = new Set(fields.map(({ node }) => node));
+	const sourceByField = /* @__PURE__ */ new WeakMap();
+	const targets = /* @__PURE__ */ new Map();
+	const streams = {
+		final: options.listCounterState ?? createListCounterState(),
+		original: options.originalListCounterState ?? createListCounterState()
+	};
+	const createContexts = () => ({
+		byNumId: /* @__PURE__ */ new Map(),
+		byAbstractNumId: /* @__PURE__ */ new Map()
+	});
+	const contextStreams = {
+		final: createContexts(),
+		original: createContexts()
+	};
+	doc.descendants((node) => {
+		if (node.type.name !== "paragraph") return true;
+		const target = numberTargetForParagraph(node, contextStreams, streams);
+		node.descendants((descendant) => {
+			if (descendant.type.name === "bookmarkBoundary") {
+				const attrs = expectBookmarkBoundaryAttrs(descendant);
+				if (attrs.type === "start" && targets.size < MAX_BOOKMARK_TARGETS && referencedBookmarks.has(attrs.name) && !targets.has(attrs.name)) targets.set(attrs.name, target);
+				return false;
+			}
+			if (descendant.type.name !== "field" && descendant.type.name !== "structuredField") return true;
+			if (fieldNodes.has(descendant)) sourceByField.set(descendant, target);
+			return true;
+		});
+		const paragraphAttrs = expectParagraphAttrs(node);
+		if (targets.size < MAX_BOOKMARK_TARGETS) {
+			for (const bookmark of paragraphAttrs.bookmarks ?? []) if (referencedBookmarks.has(bookmark.name) && !targets.has(bookmark.name)) targets.set(bookmark.name, target);
+		}
+		return false;
+	});
+	const candidates = [];
+	for (const field of fields) {
+		const target = targets.get(field.spec.bookmark);
+		if (target === void 0 || target === null) continue;
+		let value;
+		if (field.spec.numberSwitch === "n") value = target.current;
+		else if (field.spec.numberSwitch === "r") value = relativeNumber(target, sourceByField.get(field.node) ?? null);
+		else value = target.full;
+		if (value !== null) candidates.push({
+			node: field.node,
+			cached: field.cached,
+			value
+		});
+	}
+	return candidates;
+}
+const isCalibratedCandidate = ({ node, cached, value }) => {
+	const normalizedCache = normalizeCachedResult(cached);
+	const baseline = expectFieldAttrs(node)._numberedRefBaseline;
+	return normalizedCache.length === 0 || normalizedCache === normalizeCachedResult(value) || baseline !== void 0 && normalizedCache === normalizeCachedResult(baseline);
+};
+const mapDocument = (node, transform) => {
+	let mapped = node;
+	if (node.childCount > 0) {
+		const children = [];
+		let changed = false;
+		node.forEach((child) => {
+			const mappedChild = mapDocument(child, transform);
+			children.push(mappedChild);
+			changed ||= mappedChild !== child;
+		});
+		if (changed) mapped = node.copy(Fragment.fromArray(children));
+	}
+	return transform(mapped);
+};
+/** Stamp only proven numbered REF fields with clone-safe calibration state. */
+function stampNumberedRefFieldBaselines(doc) {
+	const baselines = /* @__PURE__ */ new WeakMap();
+	let hasBaselines = false;
+	for (const candidate of collectNumberedRefCandidates(doc, {})) if (isCalibratedCandidate(candidate)) {
+		baselines.set(candidate.node, candidate.cached);
+		hasBaselines = true;
+	}
+	if (!hasBaselines) return doc;
+	return mapDocument(doc, (node) => {
+		const baseline = baselines.get(node);
+		if (baseline === void 0 || node.type.name !== "field" && node.type.name !== "structuredField") return node;
+		return node.type.create({
+			...node.attrs,
+			_numberedRefBaseline: baseline
+		}, node.content, node.marks);
+	});
+}
+/**
+* Resolve bounded, numbered REF fields against bookmarks in the ProseMirror body story.
+* Unsupported or uncalibrated fields are absent from the returned map and retain their cache.
+*/
+function resolveNumberedRefFields(doc, options = {}) {
+	const results = /* @__PURE__ */ new Map();
+	for (const candidate of collectNumberedRefCandidates(doc, options)) if (isCalibratedCandidate(candidate)) results.set(candidate.node, candidate.value);
+	return results;
+}
+//#endregion
+export { parseNumberedRefInstruction, resolveNumberedRefFields, stampNumberedRefFieldBaselines };

package/dist/prosemirror/paraText.js

@@ -3,9 +3,15 @@
 function getVanillaNodeText(node) {
 	const parts = [];
 	node.descendants((child) => {
-		if (!child.isText || !child.text) return true;
 		if (child.marks.some((m) => m.type.name === "insertion")) return false;
-		parts.push(child.text);
+		if (child.isText && child.text) {
+			parts.push(child.text);
+			return false;
+		}
+		if (child.isLeaf && child.textContent) {
+			parts.push(child.textContent);
+			return false;
+		}
 		return true;
 	});
 	return parts.join("");
@@ -15,11 +21,18 @@ function getVanillaTextBetween(doc, from, to) {
 	if (from >= to) return "";
 	const parts = [];
 	doc.nodesBetween(from, to, (child, pos) => {
-		if (!child.isText || !child.text) return;
-		if (child.marks.some((m) => m.type.name === "insertion")) return;
-		const start = Math.max(from, pos);
-		const end = Math.min(to, pos + child.text.length);
-		if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+		if (child.marks.some((m) => m.type.name === "insertion")) return false;
+		if (child.isText && child.text) {
+			const start = Math.max(from, pos);
+			const end = Math.min(to, pos + child.text.length);
+			if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+			return false;
+		}
+		if (child.isLeaf && child.textContent) {
+			parts.push(child.textContent);
+			return false;
+		}
+		return true;
 	});
 	return parts.join("");
 }
@@ -41,25 +54,51 @@ function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
 	let fullText = "";
 	const textPositions = [];
 	doc.nodesBetween(paragraphFrom, paragraphTo, (node, pos) => {
-		if (!node.isText || !node.text) return;
-		if (node.marks.some((m) => m.type.name === "insertion")) return;
-		textPositions.push({
-			pos,
-			len: node.text.length
-		});
-		fullText += node.text;
+		if (node.marks.some((m) => m.type.name === "insertion")) return false;
+		if (node.isText && node.text) {
+			textPositions.push({
+				text: node.text,
+				pos,
+				pmLength: node.text.length,
+				atomic: false
+			});
+			fullText += node.text;
+			return false;
+		}
+		if (node.isLeaf && node.textContent) {
+			textPositions.push({
+				text: node.textContent,
+				pos,
+				pmLength: node.nodeSize,
+				atomic: true
+			});
+			fullText += node.textContent;
+			return false;
+		}
+		return true;
 	});
 	const firstMatch = fullText.indexOf(searchText);
 	if (firstMatch === -1) return null;
 	if (fullText.indexOf(searchText, firstMatch + 1) !== -1) return null;
+	const matchEnd = firstMatch + searchText.length;
+	let segmentStart = 0;
+	for (const position of textPositions) {
+		const segmentEnd = segmentStart + position.text.length;
+		if (position.atomic && (segmentStart < firstMatch && firstMatch < segmentEnd || segmentStart < matchEnd && matchEnd < segmentEnd)) return null;
+		segmentStart = segmentEnd;
+	}
 	let charOffset = 0;
 	let fromPos = paragraphFrom;
 	let toPos = paragraphFrom;
 	for (const tp of textPositions) {
-		const segEnd = charOffset + tp.len;
-		if (charOffset <= firstMatch && firstMatch < segEnd) fromPos = tp.pos + (firstMatch - charOffset);
+		const segEnd = charOffset + tp.text.length;
+		if (charOffset <= firstMatch && firstMatch < segEnd) {
+			const localOffset = firstMatch - charOffset;
+			fromPos = tp.atomic ? tp.pos : tp.pos + localOffset;
+		}
 		if (charOffset <= firstMatch + searchText.length && firstMatch + searchText.length <= segEnd) {
-			toPos = tp.pos + (firstMatch + searchText.length - charOffset);
+			const localOffset = firstMatch + searchText.length - charOffset;
+			toPos = tp.atomic ? tp.pos + tp.pmLength : tp.pos + localOffset;
 			break;
 		}
 		charOffset = segEnd;

package/dist/prosemirror/plugins/anonymizationDecorations.js

@@ -36,7 +36,7 @@ const buildMatches = (doc, terms) => {
 			let match = regex.exec(joined);
 			while (match !== null) {
 				const from = offsetToDocPos(chunks, match.index);
-				const to = offsetToDocPos(chunks, match.index + match[0].length);
+				const to = offsetToDocPos(chunks, match.index + match[0].length, "end");
 				matches.push({
 					from,
 					to,

package/dist/prosemirror/plugins/pmTextScan.d.ts

@@ -4,6 +4,8 @@ type TextChunk = {
   text: string;
   /** PM doc position where this chunk's first char lives. */
   start: number;
+  /** PM position after this chunk; differs from text length for atomic fields. */
+  end?: number;
 };
 /**
  * Collect every block-level node's text content as an array of
@@ -12,7 +14,7 @@ type TextChunk = {
  */
 declare const collectBlockChunks: (doc: Node) => TextChunk[][];
 /** Map a joined-string offset back to its PM doc position. */
-declare const offsetToDocPos: (chunks: TextChunk[], offset: number) => number;
+declare const offsetToDocPos: (chunks: TextChunk[], offset: number, bias?: "start" | "end") => number;
 /** Join a block's chunks into the single string callers scan. */
 declare const joinChunks: (chunks: TextChunk[]) => string;
 //#endregion

package/dist/prosemirror/plugins/pmTextScan.js

@@ -10,10 +10,24 @@ const collectBlockChunks = (doc) => {
 		if (node.isTextblock) {
 			const chunks = [];
 			node.descendants((child, offset) => {
-				if (child.isText && child.text !== void 0) chunks.push({
-					text: child.text,
-					start: pos + 1 + offset
-				});
+				if (child.isText && child.text !== void 0) {
+					const start = pos + 1 + offset;
+					chunks.push({
+						text: child.text,
+						start,
+						end: start + child.text.length
+					});
+					return false;
+				}
+				if (child.isLeaf && child.textContent) {
+					const start = pos + 1 + offset;
+					chunks.push({
+						text: child.textContent,
+						start,
+						end: start + child.nodeSize
+					});
+					return false;
+				}
 				return true;
 			});
 			if (chunks.length > 0) blocks.push(chunks);
@@ -24,14 +38,21 @@ const collectBlockChunks = (doc) => {
 	return blocks;
 };
 /** Map a joined-string offset back to its PM doc position. */
-const offsetToDocPos = (chunks, offset) => {
+const offsetToDocPos = (chunks, offset, bias = "start") => {
 	let consumed = 0;
 	for (const chunk of chunks) {
-		if (offset <= consumed + chunk.text.length) return chunk.start + (offset - consumed);
+		if (offset <= consumed + chunk.text.length) {
+			const localOffset = offset - consumed;
+			const end = chunk.end ?? chunk.start + chunk.text.length;
+			if (end - chunk.start === chunk.text.length) return chunk.start + localOffset;
+			if (localOffset === 0) return chunk.start;
+			if (localOffset === chunk.text.length || bias === "end") return end;
+			return chunk.start;
+		}
 		consumed += chunk.text.length;
 	}
 	const last = chunks.at(-1);
-	return last ? last.start + last.text.length : 0;
+	return last ? last.end ?? last.start + last.text.length : 0;
 };
 /** Join a block's chunks into the single string callers scan. */
 const joinChunks = (chunks) => chunks.map((c) => c.text).join("");