@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/markupViewNotes.js

@@ -0,0 +1,49 @@
+import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
+import { proseDocToBlocks } from "./conversion/fromProseDoc.js";
+import { footnoteToProseDoc } from "./conversion/toProseDoc.js";
+import { markupViewResolutionMode } from "./markupViewProjection.js";
+import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+//#region src/prosemirror/markupViewNotes.ts
+const resolvedNotes = /* @__PURE__ */ new WeakMap();
+const resolvedNote = (note, mode, state, document) => {
+	const styleResolver = getDocumentStyleResolver(state);
+	const cached = resolvedNotes.get(note)?.get(mode);
+	if (cached?.styleResolver === styleResolver) return cached.note;
+	const { styles, theme } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const result = resolveWholeStory({
+		doc,
+		mode,
+		styleResolver,
+		numbering: getDocumentNumbering(state)
+	});
+	const resolved = result.failed || result.resolved.eq(doc) ? note : {
+		...note,
+		content: proseDocToBlocks(result.resolved, note.content, styles)
+	};
+	const byMode = resolvedNotes.get(note) ?? /* @__PURE__ */ new Map();
+	byMode.set(mode, {
+		styleResolver,
+		note: resolved
+	});
+	resolvedNotes.set(note, byMode);
+	return resolved;
+};
+/** The footnotes or endnotes as `view` shows them. */
+const markupViewNotes = (notes, view, state, document) => {
+	const mode = markupViewResolutionMode(view);
+	if (!notes || !mode || !document) return notes;
+	let changed = false;
+	const shown = notes.map((note) => {
+		const resolved = resolvedNote(note, mode, state, document);
+		changed ||= resolved !== note;
+		return resolved;
+	});
+	return changed ? shown : notes;
+};
+//#endregion
+export { markupViewNotes };

package/dist/prosemirror/markupViewProjection.d.ts

@@ -0,0 +1,97 @@
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { RemovedSectionReference } from "../internal/sectionEndpointResolution.js";
+import { indexedPositionMap } from "../internal/indexedPositionMap.js";
+import { RevisionResolutionMode } from "../internal/revisionResolutionInline.js";
+import { Node } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+import { StepMap } from "prosemirror-transform";
+//#region src/prosemirror/markupViewProjection.d.ts
+/** Resolve every revision in the state's story with the state's own styles and numbering. */
+declare const resolveStateStory: (state: EditorState, mode: RevisionResolutionMode) => {
+  resolved: Node;
+  mapping: import("prosemirror-transform").Mapping;
+  positionMap: StepMap;
+  steps: import("prosemirror-transform").Step[];
+  changedRanges: {
+    from: number;
+    to: number;
+  }[];
+  inlineMap: StepMap;
+  tableRanges: {
+    node: Node;
+    inputNode: Node;
+    sourceNodeSize: number;
+    position: number;
+    inputMap: StepMap;
+    positionMap: StepMap;
+    ranges: readonly {
+      from: number;
+      to: number;
+    }[];
+    paragraphOffsets: readonly {
+      source: number;
+      final: number;
+    }[];
+  }[];
+  transfers: {
+    displacedToken: string | null;
+    selectedToken: string | null;
+  }[];
+  structuralRanges: {
+    from: number;
+    to: number;
+  }[];
+  structuralMap: StepMap;
+  structural: boolean;
+  failed: boolean;
+  removedEndpointCount: number;
+  removedReferences: RemovedSectionReference[];
+};
+type PositionRange = {
+  from: number;
+  to: number;
+};
+type MarkupViewProjection =
+/** The view lays the authored document out as it stands. */
+{
+  type: "authored";
+} | {
+  type: "resolved";
+  /** The document as the view reads it. */
+  doc: Node;
+  /** Authored (editor) positions to `doc` positions. */
+  positionMap: StepMap;
+  /** `positionMap`, indexed for lookups. */
+  toView: ReturnType<typeof indexedPositionMap>;
+  /** `positionMap` inverted and indexed: `doc` positions to editor positions. */
+  toEditor: ReturnType<typeof indexedPositionMap>;
+  /**
+   * Ranges of `doc` whose paragraphs carry a change indicator (Simple
+   * Markup's change bar); empty for a view without indicators.
+   */
+  changeBarRanges: readonly PositionRange[];
+  /**
+   * Whether the resolver left part of the story as authored (a table
+   * revision it cannot resolve). The projection still shows every revision
+   * it could resolve; the caller reports the rest.
+   */
+  completeness: "complete" | "partial";
+};
+/**
+ * The document a markup view lays out, for the state's current document.
+ * Cached per editor state: the resolver also reads its styles and numbering
+ * plugins, which may change while the document node stays the same.
+ */
+/** How a view resolves the revisions it reads, or null when it shows them inline. */
+declare const markupViewResolutionMode: (view: DisplayMode) => RevisionResolutionMode | null;
+declare const projectMarkupView: (state: EditorState, view: DisplayMode) => MarkupViewProjection;
+/**
+ * Where a caret at editor `position` is painted in a view. A position the view
+ * shows is its own; one inside text the view does not show (a deletion in No
+ * Markup, an insertion in Original, typed there with tracking on) moves to the
+ * nearest place the view shows before it, the way the caret sits at the edge
+ * of text it cannot enter.
+ */
+declare const visibleCaretPosition: (projection: MarkupViewProjection, position: number) => number;
+//#endregion
+export { MarkupViewProjection, markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/markupViewProjection.js

@@ -0,0 +1,88 @@
+import { indexedPositionMap } from "../internal/indexedPositionMap.js";
+import { finalRevisionParagraphRanges } from "../internal/revisionResolutionTracking.js";
+import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
+import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { Selection } from "prosemirror-state";
+//#region src/prosemirror/markupViewProjection.ts
+/** Resolve every revision in the state's story with the state's own styles and numbering. */
+const resolveStateStory = (state, mode) => resolveWholeStory({
+	doc: state.doc,
+	mode,
+	styleResolver: getDocumentStyleResolver(state),
+	numbering: getDocumentNumbering(state)
+});
+/**
+* Every view's reading of the document. Total over `DisplayMode`, so a new view
+* cannot ship without a decision about what it lays out.
+*/
+const MARKUP_VIEW_RESOLUTIONS = {
+	"all-markup": { type: "authored" },
+	"simple-markup": {
+		type: "resolved",
+		mode: "accept",
+		indicators: "change-bars"
+	},
+	"no-markup": {
+		type: "resolved",
+		mode: "accept",
+		indicators: "none"
+	},
+	original: {
+		type: "resolved",
+		mode: "reject",
+		indicators: "none"
+	}
+};
+const AUTHORED = { type: "authored" };
+const projectionCache = /* @__PURE__ */ new WeakMap();
+/**
+* The document a markup view lays out, for the state's current document.
+* Cached per editor state: the resolver also reads its styles and numbering
+* plugins, which may change while the document node stays the same.
+*/
+/** How a view resolves the revisions it reads, or null when it shows them inline. */
+const markupViewResolutionMode = (view) => {
+	const resolution = MARKUP_VIEW_RESOLUTIONS[view];
+	return resolution.type === "resolved" ? resolution.mode : null;
+};
+const projectMarkupView = (state, view) => {
+	const resolution = MARKUP_VIEW_RESOLUTIONS[view];
+	if (resolution.type === "authored") return AUTHORED;
+	let byView = projectionCache.get(state);
+	const cached = byView?.get(view);
+	if (cached) return cached;
+	const result = resolveStateStory(state, resolution.mode);
+	const projection = result.resolved.eq(state.doc) ? AUTHORED : {
+		type: "resolved",
+		doc: result.resolved,
+		positionMap: result.positionMap,
+		toView: indexedPositionMap(result.positionMap),
+		toEditor: indexedPositionMap(result.positionMap.invert()),
+		changeBarRanges: resolution.indicators === "change-bars" ? finalRevisionParagraphRanges(result) : [],
+		completeness: result.failed ? "partial" : "complete"
+	};
+	if (!byView) {
+		byView = /* @__PURE__ */ new Map();
+		projectionCache.set(state, byView);
+	}
+	byView.set(view, projection);
+	return projection;
+};
+/**
+* Where a caret at editor `position` is painted in a view. A position the view
+* shows is its own; one inside text the view does not show (a deletion in No
+* Markup, an insertion in Original, typed there with tracking on) moves to the
+* nearest place the view shows before it, the way the caret sits at the edge
+* of text it cannot enter.
+*/
+const visibleCaretPosition = (projection, position) => {
+	if (projection.type === "authored") return position;
+	const { pos: viewPosition, deletedAcross } = projection.toView.mapResult(position, -1);
+	if (!deletedAcross) return position;
+	const bounded = Math.max(0, Math.min(viewPosition, projection.doc.content.size));
+	const near = Selection.near(projection.doc.resolve(bounded), -1);
+	return projection.toEditor(near.head, -1);
+};
+//#endregion
+export { markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/noteReferenceReview.d.ts

@@ -0,0 +1,77 @@
+import { document_d_exports } from "../types/document.js";
+import { Mark, Node } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/noteReferenceReview.d.ts
+type NoteKind = "footnote" | "endnote";
+/** `footnote:<id>` or `endnote:<id>`. */
+type NoteKey = `${NoteKind}:${number}`;
+/**
+ * The notes a story's text refers to, and whether each reference is pending
+ * deletion: a reference is deleted when every character of it is.
+ */
+declare const noteReferenceStates: (doc: Node) => Map<NoteKey, "live" | "deleted">;
+/** The notes whose reference a change took from pending deletion back to live. */
+declare const noteReferencesRestored: (before: Node, after: Node) => NoteKey[];
+/**
+ * The revisions that deleted a note along with its reference: its text and
+ * its paragraph marks, deleted by the reference deletion's author at its
+ * date. A deletion in the note made some other time is a change of its own,
+ * which resolving the reference leaves alone.
+ */
+declare const noteDeletionRevisions: (doc: Node, reference: Mark) => number[];
+/**
+ * The document with the named notes' deletions that went with their
+ * reference rejected: the notes whose reference's deletion was rejected get
+ * their text back. `before` is the body that still had those deletions.
+ */
+declare const restoreNotes: (document: document_d_exports.Document, keys: Iterable<NoteKey>, before: Node) => document_d_exports.Document;
+/** The deletion each pending-deleted note reference carries. */
+declare const referenceDeletions: (doc: Node) => Map<NoteKey, Mark>;
+/**
+ * Delete a note's text and its paragraph marks along with its reference: by
+ * the reference deletion's author at its date, so resolving the reference
+ * resolves them too (see {@link noteDeletionRevisions}).
+ */
+declare const deleteNoteWithReference: <T extends Transform>(transform: T, reference: Mark) => T;
+/**
+ * Keeps an editor's notes following their references across body edits. The
+ * editor reports the body as it was before the edits it has not yet written
+ * back, and reconciles the document it writes back:
+ *
+ * - a reference whose deletion is rejected gives its note back its text;
+ * - a reference deleted again, as undoing that reject does, takes the note's
+ *   text with it: the note returns to what it was, or, when the note changed
+ *   since, its text is deleted along with the reference.
+ */
+type NoteReferenceFollower = {
+  /** The body before the edits the next {@link reconcile} writes back. */
+  noteBase: (before: Node) => void;
+  /** The document to write back, its notes following the body's references. */
+  reconcile: (document: document_d_exports.Document, body: Node) => document_d_exports.Document;
+  /**
+   * `document` with the note changes an earlier {@link reconcile} wrote back
+   * and the editor's document has not taken in yet: a save reads the editor
+   * right after a write-back, before the host hands the result back.
+   */
+  withPending: (document: document_d_exports.Document) => document_d_exports.Document;
+  /** Forget the pending base and what earlier restores replaced (a new document). */
+  reset: () => void;
+};
+declare const createNoteReferenceFollower: () => NoteReferenceFollower;
+/** The notes model content refers to, live or pending deletion. */
+declare const noteKeysReferencedIn: (content: unknown) => Set<NoteKey>;
+/**
+ * The notes anything refers to, live or pending deletion: the main story, and
+ * the stories the body does not hold (headers, footers, comments, notes).
+ * References inside the `skipped` notes do not count: those notes are going.
+ */
+declare const referencedNotes: (document: document_d_exports.Document, skipped?: ReadonlySet<string>) => Set<NoteKey>;
+/**
+ * The document without the notes nothing refers to any more: a note goes
+ * with its reference, so accepting the reference's deletion leaves a note no
+ * reader can reach, and saving drops it, with the comments anchored only in
+ * it. Separators stay.
+ */
+declare const withoutUnreferencedNotes: (document: document_d_exports.Document) => document_d_exports.Document;
+//#endregion
+export { NoteKey, NoteReferenceFollower, createNoteReferenceFollower, deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes, restoreNotes, withoutUnreferencedNotes };

package/dist/prosemirror/noteReferenceReview.js

@@ -0,0 +1,332 @@
+import { withoutLostCommentThreads } from "../ai-edits/comment-lifecycle.js";
+import { visitCommentMarkers } from "../docx/commentAnchorIndex.js";
+import { isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.js";
+import { pluginsForHeadlessRevisionResolution } from "../internal/headlessRevisionResolutionGuard.js";
+import { expectFootnoteRefMarkAttrs, expectParagraphAttrs } from "./attrs/index.js";
+import { rejectAIEditRevision } from "./commands/comments.js";
+import { proseDocToBlocks } from "./conversion/fromProseDoc.js";
+import { footnoteToProseDoc } from "./conversion/toProseDoc.js";
+import { createDocumentNumberingPlugin } from "./plugins/documentNumbering.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
+import { mintRevisionId } from "./plugins/revisionIds.js";
+import { schema, singletonManager } from "./schema/index.js";
+import { Transform } from "prosemirror-transform";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/noteReferenceReview.ts
+const noteKey = (kind, id) => `${kind}:${id}`;
+/**
+* The notes a story's text refers to, and whether each reference is pending
+* deletion: a reference is deleted when every character of it is.
+*/
+const noteReferenceStates = (doc) => {
+	const states = /* @__PURE__ */ new Map();
+	doc.descendants((node) => {
+		if (!node.isText) return true;
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		if (!reference) return false;
+		const { id, noteType } = expectFootnoteRefMarkAttrs(reference);
+		const key = noteKey(noteType === "endnote" ? "endnote" : "footnote", Number(id));
+		if (!node.marks.some((mark) => mark.type.name === "deletion") || states.get(key) === "live") states.set(key, "live");
+		else states.set(key, "deleted");
+		return false;
+	});
+	return states;
+};
+/** The notes whose reference a change took from pending deletion back to live. */
+const noteReferencesRestored = (before, after) => {
+	const was = noteReferenceStates(before);
+	return [...noteReferenceStates(after)].flatMap(([key, state]) => state === "live" && was.get(key) === "deleted" ? [key] : []);
+};
+/**
+* The revisions that deleted a note along with its reference: its text and
+* its paragraph marks, deleted by the reference deletion's author at its
+* date. A deletion in the note made some other time is a change of its own,
+* which resolving the reference leaves alone.
+*/
+const noteDeletionRevisions = (doc, reference) => {
+	const author = String(reference.attrs["author"] ?? "");
+	const date = String(reference.attrs["date"] ?? "");
+	const ids = /* @__PURE__ */ new Set();
+	doc.descendants((node) => {
+		if (node.type.name === "paragraph") {
+			const mark = expectParagraphAttrs(node).pPrMark;
+			if (mark?.kind === "del" && mark.info.author === author && mark.info.date === date) ids.add(mark.info.id);
+		}
+		for (const mark of node.marks) if (mark.type.name === "deletion" && String(mark.attrs["author"] ?? "") === author && String(mark.attrs["date"] ?? "") === date) {
+			const id = mark.attrs["revisionId"];
+			if (typeof id === "number") ids.add(id);
+		}
+		return true;
+	});
+	return [...ids];
+};
+const restoredNote = (note, document, reference) => {
+	const { styles, theme, numbering } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const revisions = noteDeletionRevisions(doc, reference);
+	if (revisions.length === 0) return note;
+	let state = EditorState.create({
+		schema,
+		doc,
+		plugins: [
+			...pluginsForHeadlessRevisionResolution(singletonManager.getPlugins()),
+			createDocumentStylesPlugin(styles),
+			createDocumentNumberingPlugin(numbering)
+		]
+	});
+	rejectAIEditRevision(revisions)(state, (transaction) => {
+		state = state.apply(transaction);
+	});
+	if (state.doc.eq(doc)) return note;
+	return {
+		...note,
+		content: proseDocToBlocks(state.doc, note.content, styles)
+	};
+};
+/**
+* The document with the named notes' deletions that went with their
+* reference rejected: the notes whose reference's deletion was rejected get
+* their text back. `before` is the body that still had those deletions.
+*/
+const restoreNotes = (document, keys, before) => {
+	const deletions = referenceDeletions(before);
+	const wanted = new Set([...keys].filter((key) => deletions.has(key)));
+	if (wanted.size === 0) return document;
+	const restore = (kind, notes) => {
+		if (!notes?.some((note) => wanted.has(noteKey(kind, note.id)))) return notes;
+		return notes.map((note) => {
+			const reference = deletions.get(noteKey(kind, note.id));
+			return reference ? restoredNote(note, document, reference) : note;
+		});
+	};
+	const footnotes = restore("footnote", document.package.footnotes);
+	const endnotes = restore("endnote", document.package.endnotes);
+	if (footnotes === document.package.footnotes && endnotes === document.package.endnotes) return document;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...footnotes !== void 0 && { footnotes },
+			...endnotes !== void 0 && { endnotes }
+		}
+	};
+};
+/** The deletion each pending-deleted note reference carries. */
+const referenceDeletions = (doc) => {
+	const deletions = /* @__PURE__ */ new Map();
+	doc.descendants((node) => {
+		if (!node.isText) return true;
+		const reference = node.marks.find((mark) => mark.type.name === "footnoteRef");
+		const deletion = node.marks.find((mark) => mark.type.name === "deletion");
+		if (reference && deletion) {
+			const { id, noteType } = expectFootnoteRefMarkAttrs(reference);
+			deletions.set(noteKey(noteType === "endnote" ? "endnote" : "footnote", Number(id)), deletion);
+		}
+		return false;
+	});
+	return deletions;
+};
+/**
+* Delete a note's text and its paragraph marks along with its reference: by
+* the reference deletion's author at its date, so resolving the reference
+* resolves them too (see {@link noteDeletionRevisions}).
+*/
+const deleteNoteWithReference = (transform, reference) => {
+	const doc = transform.doc;
+	const markInfo = {
+		id: mintRevisionId(),
+		author: String(reference.attrs["author"] ?? ""),
+		date: String(reference.attrs["date"] ?? "")
+	};
+	const { utcDate, initials } = reference.attrs;
+	const deletion = (doc.type.schema.marks["deletion"] ?? reference.type).create({
+		revisionId: mintRevisionId(),
+		author: markInfo.author,
+		date: markInfo.date,
+		...utcDate != null && { utcDate },
+		...initials != null && { initials }
+	});
+	doc.descendants((node, position) => {
+		if (node.type.name === "paragraph" && expectParagraphAttrs(node).pPrMark == null) transform.setNodeAttribute(position, "pPrMark", {
+			kind: "del",
+			info: markInfo
+		});
+		if (node.isInline && !deletion.type.isInSet(node.marks)) transform.addMark(position, position + node.nodeSize, deletion);
+		return !node.isInline;
+	});
+	return transform;
+};
+/**
+* A note whose reference was deleted: its text and its paragraph marks are
+* deleted too, by the reference's author at the reference's date.
+*/
+const deletedNote = (note, document, reference) => {
+	const { styles, theme } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const transform = deleteNoteWithReference(new Transform(doc), reference);
+	if (!transform.docChanged) return note;
+	return {
+		...note,
+		content: proseDocToBlocks(transform.doc, note.content, styles)
+	};
+};
+const editNotes = (document, edits) => {
+	if (edits.size === 0) return document;
+	const edit = (kind, notes) => {
+		if (!notes?.some((note) => edits.has(noteKey(kind, note.id)))) return notes;
+		return notes.map((note) => edits.get(noteKey(kind, note.id))?.(note) ?? note);
+	};
+	const footnotes = edit("footnote", document.package.footnotes);
+	const endnotes = edit("endnote", document.package.endnotes);
+	if (footnotes === document.package.footnotes && endnotes === document.package.endnotes) return document;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...footnotes !== void 0 && { footnotes },
+			...endnotes !== void 0 && { endnotes }
+		}
+	};
+};
+const createNoteReferenceFollower = () => {
+	let base = null;
+	const replaced = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	const recorded = (key, edit) => (note) => {
+		const result = edit(note);
+		if (result !== note) pending.set(key, {
+			from: note,
+			to: result
+		});
+		return result;
+	};
+	return {
+		noteBase: (before) => {
+			base ??= before;
+		},
+		reconcile: (document, body) => {
+			const before = base;
+			base = null;
+			if (!before) return document;
+			const was = noteReferenceStates(before);
+			const now = noteReferenceStates(body);
+			const deletions = referenceDeletions(body);
+			const rejected = referenceDeletions(before);
+			const edits = /* @__PURE__ */ new Map();
+			for (const [key, state] of now) {
+				const previous = was.get(key);
+				const rejectedDeletion = rejected.get(key);
+				if (state === "live" && previous === "deleted" && rejectedDeletion) edits.set(key, recorded(key, (note) => {
+					const restored = restoredNote(note, document, rejectedDeletion);
+					if (restored !== note) replaced.set(key, {
+						restored,
+						previous: note
+					});
+					return restored;
+				}));
+				const reference = deletions.get(key);
+				if (state === "deleted" && previous === "live" && reference) edits.set(key, recorded(key, (note) => {
+					const earlier = replaced.get(key);
+					replaced.delete(key);
+					return earlier?.restored === note ? earlier.previous : deletedNote(note, document, reference);
+				}));
+			}
+			return editNotes(document, edits);
+		},
+		withPending: (document) => {
+			const edits = /* @__PURE__ */ new Map();
+			for (const [key, { from, to }] of pending) edits.set(key, (note) => {
+				if (note !== from) pending.delete(key);
+				return note === from ? to : note;
+			});
+			return editNotes(document, edits);
+		},
+		reset: () => {
+			base = null;
+			replaced.clear();
+			pending.clear();
+		}
+	};
+};
+/** The notes model content refers to, live or pending deletion. */
+const noteKeysReferencedIn = (content) => {
+	const keys = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (Array.isArray(node)) {
+			for (const item of node) visit(item);
+			return;
+		}
+		if (node === null || typeof node !== "object") return;
+		const { type, id } = node;
+		if ((type === "footnoteRef" || type === "endnoteRef") && typeof id === "number") keys.add(noteKey(type === "footnoteRef" ? "footnote" : "endnote", id));
+		for (const value of Object.values(node)) visit(value);
+	};
+	visit(content);
+	return keys;
+};
+/**
+* The notes anything refers to, live or pending deletion: the main story, and
+* the stories the body does not hold (headers, footers, comments, notes).
+* References inside the `skipped` notes do not count: those notes are going.
+*/
+const referencedNotes = (document, skipped = /* @__PURE__ */ new Set()) => {
+	const { headers, footers, footnotes, endnotes } = document.package;
+	const kept = (kind) => (note) => !skipped.has(noteKey(kind, note.id));
+	return noteKeysReferencedIn([
+		document.package.document.content,
+		[...headers?.values() ?? [], ...footers?.values() ?? []],
+		document.package.document.comments ?? [],
+		(footnotes ?? []).filter(kept("footnote")),
+		(endnotes ?? []).filter(kept("endnote"))
+	]);
+};
+/** Ids of the comments anchored anywhere in these stories. */
+const anchoredComments = (stories) => {
+	const ids = /* @__PURE__ */ new Set();
+	for (const blocks of stories) visitCommentMarkers(blocks, ({ item }) => ids.add(item.id));
+	return ids;
+};
+/**
+* The document without the notes nothing refers to any more: a note goes
+* with its reference, so accepting the reference's deletion leaves a note no
+* reader can reach, and saving drops it, with the comments anchored only in
+* it. Separators stay.
+*/
+const withoutUnreferencedNotes = (document) => {
+	const referenced = referencedNotes(document);
+	const { footnotes, endnotes, headers, footers } = document.package;
+	const keeps = (kind) => (note) => (kind === "footnote" ? isSeparatorFootnote(note) : isSeparatorEndnote(note)) || referenced.has(noteKey(kind, note.id));
+	const keptFootnotes = footnotes?.filter(keeps("footnote"));
+	const keptEndnotes = endnotes?.filter(keeps("endnote"));
+	if (keptFootnotes?.length === footnotes?.length && keptEndnotes?.length === endnotes?.length) return document;
+	const removed = [...(footnotes ?? []).filter((note) => !keeps("footnote")(note)), ...(endnotes ?? []).filter((note) => !keeps("endnote")(note))];
+	const comments = document.package.document.comments;
+	const keptComments = comments ? withoutLostCommentThreads(comments, {
+		anchoredBefore: anchoredComments(removed.map((note) => note.content)),
+		anchoredNow: anchoredComments([
+			document.package.document.content,
+			...[...headers?.values() ?? [], ...footers?.values() ?? []].map((part) => part.content),
+			...[...keptFootnotes ?? [], ...keptEndnotes ?? []].map((note) => note.content)
+		])
+	}) : void 0;
+	return {
+		...document,
+		package: {
+			...document.package,
+			...keptFootnotes !== void 0 && { footnotes: keptFootnotes },
+			...keptEndnotes !== void 0 && { endnotes: keptEndnotes },
+			...keptComments !== void 0 && keptComments.length !== comments?.length && { document: {
+				...document.package.document,
+				comments: keptComments
+			} }
+		}
+	};
+};
+//#endregion
+export { createNoteReferenceFollower, deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes, restoreNotes, withoutUnreferencedNotes };

package/dist/prosemirror/numberingAttr.d.ts

@@ -22,6 +22,14 @@ type ParagraphNumberingAttr = ParagraphNumberingOverride & {
 };
 /** Mint the attr value for a stated override: the one model-to-attr crossing. */
 declare const paragraphNumberingAttr: (numbering: ParagraphNumberingOverride) => ParagraphNumberingAttr;
+/**
+ * The `numPr` that takes a paragraph out of its list. When its style supplies
+ * the numbering, the paragraph has to state the cancellation (`w:numId="0"`):
+ * clearing the attr would uncover the style tier, and the next save hands the
+ * numbering straight back. A cancellation states no level (17.9.18: there is
+ * no id left for a level to belong to).
+ */
+declare const removedNumberingAttr: (numPrFromStyle: ParagraphNumberingOverride | null | undefined) => ParagraphNumberingAttr | null;
 /**
  * The one shape check over a persisted `numPr` attr.
  *
@@ -52,4 +60,4 @@ declare const paragraphNumberingFromAttrValue: (value: unknown) => ParagraphNumb
  */
 declare const readParagraphNumberingAttr: (value: unknown) => ParagraphNumberingAttr | null;
 //#endregion
-export { ParagraphNumberingAttr, paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr };
+export { ParagraphNumberingAttr, paragraphNumberingAttr, paragraphNumberingFromAttrValue, readParagraphNumberingAttr, removedNumberingAttr };