@stll/folio-core 0.53.0 → 0.54.1

package/dist/prosemirror/hyperlinkRemoval.js

@@ -0,0 +1,129 @@
+import { BUILT_IN_STYLE_NAME } from "../docx/builtInStyles.js";
+import { getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { isSuggestionModeActive, makeRevisionInfo, suggestRangeDeletion } from "./plugins/suggestionMode.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+//#region src/prosemirror/hyperlinkRemoval.ts
+/** Contiguous stretches of linked, not yet deleted, text in [`from`, `to`) of `doc`. */
+const linkedRanges = (doc, from, to) => {
+	const ranges = [];
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isText || !node.marks.some(({ type }) => type.name === "hyperlink") || node.marks.some(({ type }) => type.name === "deletion")) return true;
+		const start = Math.max(position, from);
+		const end = Math.min(position + node.nodeSize, to);
+		if (start >= end) return true;
+		const piece = {
+			from: start,
+			to: end,
+			node: node.cut(start - position, end - position)
+		};
+		const last = ranges.at(-1);
+		if (last && last.to === start) {
+			last.to = end;
+			last.pieces.push(piece);
+		} else ranges.push({
+			from: start,
+			to: end,
+			pieces: [piece]
+		});
+		return true;
+	});
+	return ranges;
+};
+/** A piece's marks once the Hyperlink character style is taken off it. */
+const withoutHyperlinkStyle = (state, doc, piece) => {
+	const styleResolver = getDocumentStyleResolver(state);
+	const builtInStyles = getDocumentBuiltInStyles(state);
+	const context = paragraphRunStyleContextAt({
+		doc,
+		pos: piece.from,
+		styleResolver
+	});
+	const previousFormatting = readAuthoredRunFormatting({
+		context,
+		marks: piece.node.marks,
+		styleResolver
+	});
+	const styleId = previousFormatting.styleId;
+	if (!(styleId !== void 0 && (builtInStyles.builtInNameOf(styleId) === BUILT_IN_STYLE_NAME.hyperlink || styleId === "Hyperlink"))) return {
+		marks: piece.node.marks,
+		previousFormatting: null
+	};
+	const { styleId: _removed, ...formatting } = previousFormatting;
+	return {
+		marks: reconcileRunFormattingMarks({
+			authoredFormatting: formatting,
+			context,
+			node: piece.node,
+			styleResolver
+		}),
+		previousFormatting
+	};
+};
+/** Replace the marks of the text at [`from`, `to`) of `tr.doc` with `marks`. */
+const setTextMarks = (tr, from, to, current, marks) => {
+	for (const mark of current) if (!mark.isInSet(marks)) tr.removeMark(from, to, mark);
+	for (const mark of marks) if (!mark.isInSet(current)) tr.addMark(from, to, mark);
+};
+/**
+* Remove the hyperlinks from [`from`, `to`) of `tr.doc`: directly, or, with
+* suggestions on, as a tracked replacement of the linked text by plain text.
+*/
+const removeHyperlinkInRange = (state, tr, from, to) => {
+	const { schema } = state;
+	const hyperlinkType = schema.marks["hyperlink"];
+	if (!hyperlinkType) return tr;
+	const insertionType = schema.marks["insertion"];
+	const deletionType = schema.marks["deletion"];
+	const propertyChangeType = schema.marks["runPropertyChange"];
+	const tracked = isSuggestionModeActive(state) && insertionType !== void 0 && deletionType !== void 0 && propertyChangeType !== void 0;
+	const revisionAttrs = () => {
+		const revision = makeRevisionInfo(state);
+		return revision ? {
+			id: revision.id,
+			author: revision.author,
+			date: revision.date
+		} : null;
+	};
+	const insertionInfo = tracked ? revisionAttrs() : null;
+	const insertion = insertionType && insertionInfo ? insertionType.create({
+		revisionId: insertionInfo.id,
+		author: insertionInfo.author,
+		date: insertionInfo.date
+	}) : null;
+	const propertyChange = (previousFormatting) => {
+		const info = revisionAttrs();
+		if (!propertyChangeType || !info) return null;
+		const change = {
+			type: "runPropertyChange",
+			info,
+			previousFormatting
+		};
+		return propertyChangeType.create({ changes: [change] });
+	};
+	const hasPendingPropertyChange = (marks) => marks.some(({ type }) => type === propertyChangeType);
+	for (const range of linkedRanges(tr.doc, from, to).toReversed()) {
+		const unlinked = range.pieces.map((piece) => ({
+			piece,
+			...withoutHyperlinkStyle(state, tr.doc, piece)
+		}));
+		if (!insertion || !deletionType) {
+			for (const { piece, marks } of unlinked) setTextMarks(tr, piece.from, piece.to, piece.node.marks, marks.filter(({ type }) => type !== hyperlinkType));
+			continue;
+		}
+		const plain = unlinked.map(({ piece, marks, previousFormatting }) => {
+			const change = previousFormatting && !hasPendingPropertyChange(marks) ? propertyChange(previousFormatting) : null;
+			const kept = marks.filter(({ type }) => type !== hyperlinkType && type !== insertionType && type !== deletionType);
+			return piece.node.mark(insertion.addToSet(change ? change.addToSet(kept) : kept));
+		});
+		tr.insert(range.to, plain);
+		for (const { piece, marks, previousFormatting } of unlinked.toReversed()) {
+			const change = previousFormatting && !hasPendingPropertyChange(piece.node.marks) ? propertyChange(previousFormatting) : null;
+			setTextMarks(tr, piece.from, piece.to, piece.node.marks, change ? change.addToSet(marks) : marks);
+		}
+		suggestRangeDeletion(state, tr, range.from, range.to);
+	}
+	return tr;
+};
+//#endregion
+export { removeHyperlinkInRange };

package/dist/prosemirror/index.d.ts

@@ -25,7 +25,8 @@ import { SelectionChangeCallback, SelectionContext, createSelectionTrackerPlugin
 import { ensureParaIdsInState } from "./extensions/features/ParaIdAllocatorExtension.js";
 import "./styles/index.js";
 import { SelectionState, extractSelectionState } from "./selectionState.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
 import "./plugins/index.js";
 import { insertPageBreakInView, insertTableInView, insertTableOfContentsInView } from "./insertOperations.js";
 import { TextSelection } from "prosemirror-state";

package/dist/prosemirror/index.js

@@ -15,7 +15,8 @@ import { getTableContext, isInTable as isInTableCell } from "./extensions/nodes/
 import { insertPageBreakInView, insertTableInView, insertTableOfContentsInView } from "./insertOperations.js";
 import { NO_LIST_NUMBERING_MENU, listNumberingMenuState } from "./listNumbering.js";
 import { NO_LIST_STATE, isInListState, listStateLevel, resolveListState, sameListState } from "./listState.js";
-import { createDocumentStylesPlugin, documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { documentStylesKey, getDocumentBuiltInStyles, getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { createDocumentStylesPlugin } from "./plugins/documentStyles.js";
 import { createSelectionTrackerPlugin, extractSelectionContext, getSelectionContext, selectionTrackerKey } from "./plugins/selectionTracker.js";
 import { schema, singletonManager } from "./schema/index.js";
 import { extractSelectionState } from "./selectionState.js";

package/dist/prosemirror/listNumbering.d.ts

@@ -1,5 +1,5 @@
 import { ListKind, ListLevelFormat } from "../docx/listNumberingInstances.js";
-import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { ParagraphAttrs } from "./schema/nodes.js";
 import { NumberingMap } from "../docx/numberingParser.js";
 import { Node, ResolvedPos } from "prosemirror-model";
 import { Command, EditorState, Transaction } from "prosemirror-state";
@@ -15,24 +15,6 @@ type ListRequest = {
   /** The value a new list's first item shows. */
   start?: number | undefined;
 };
-type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
-/**
- * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
- * reject restores the recorded numbering, but the rendering attrs sit outside
- * the scope it restores wholesale, so a record that does not state them (one
- * written by an operation, or read from a file) would leave the rendering of
- * the numbering it undoes: a paragraph restored to no numbering still showed
- * the marker it was given. When the reject changes the numbering, the
- * rendering is recomputed from the restored numbering; otherwise it stays.
- */
-type RejectedListRenderingOptions = {
-  /** The paragraph's attrs before the reject. */
-  current: Pick<ParagraphAttrs, "numPr">;
-  /** The previous state the rejected record restores. */
-  previousFormatting: PreviousFormatting | null | undefined;
-  numbering: NumberingMap | null;
-};
-declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
 /** Where the paragraphs a command numbers go. */
 type ListTarget = {
   numId: number;
@@ -56,7 +38,7 @@ type ResolveListTargetOptions = {
  */
 declare const resolveListTarget: ({ numbering, $from, $to, requests }: ResolveListTargetOptions) => ListTarget | null;
 /** A paragraph's attrs as an item of `numId` at `ilvl`, resolved in `numbering`. */
-declare const listItemAttrs: (attrs: Record<string, unknown>, { numId, ilvl }: {
+declare const listItemAttrs: (attrs: Readonly<ParagraphAttrs>, { numId, ilvl }: {
   numId: number;
   ilvl: number;
 }, numbering: NumberingMap) => Record<string, unknown>;
@@ -107,4 +89,4 @@ declare const NO_LIST_NUMBERING_MENU: {
  */
 declare const listNumberingMenuState: (state: EditorState) => ListNumberingMenuState;
 //#endregion
-export { ListNumberingMenuState, ListRequest, NO_LIST_NUMBERING_MENU, RejectedListRenderingOptions, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };
+export { ListNumberingMenuState, ListRequest, NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listNumbering.js

@@ -1,13 +1,15 @@
 import { mintListInstance, restartListInstance } from "../docx/listNumberingInstances.js";
 import { createNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
-import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
+import { paragraphNumberingLevel, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
 import { paragraphPropertiesSnapshot } from "./commands/propertyChangeScope.js";
-import { CLEARED_LIST_RENDERING_ATTRS } from "./listMarker.js";
+import { listRenderingFor, recordsListRendering } from "./listRendering.js";
 import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
+import { directParagraphIndentation } from "./paragraphIndentation.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
 import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
-import { listAttrsFromNumbering } from "./styles/resolvedStyleAttrs.js";
+import { listAttrsFromNumbering, listLevelIndentAttrPatch } from "./styles/resolvedStyleAttrs.js";
 //#region src/prosemirror/listNumbering.ts
 const PARAGRAPH_NODE = "paragraph";
 /**
@@ -19,45 +21,18 @@ const PARAGRAPH_NODE = "paragraph";
 */
 const listChangeSnapshot = (node, attrs) => {
 	const previousFormatting = paragraphPropertiesSnapshot(node.type.create(attrs, node.content, node.marks));
-	previousFormatting["numPr"] = attrs["numPr"] ?? null;
+	previousFormatting["numPr"] ??= null;
 	for (const key of LIST_RENDERING_ATTR_KEYS) previousFormatting[key] = attrs[key] ?? null;
 	return previousFormatting;
 };
-/**
-* The original state a pending record describes, completed with the list
-* attrs it may not state. A record written by a list command states them all.
-* One written for another property (or read from a file) states the scope
-* only: its numbering is the original's, and an absent one means the original
-* had none, so the rendering is recomputed from it rather than copied from
-* the live paragraph, whose list may since have changed.
-*/
-const originalListFormatting = (record, numbering) => {
+const originalListFormatting = ({ record, numbering, styleResolver }) => {
 	const original = { ...record };
 	if (recordsListRendering(record)) return original;
-	Object.assign(original, listRenderingFor(record.numPr, numbering));
+	const inherited = styleResolver?.resolveParagraphStyle(record.styleId ?? void 0).paragraphFormatting?.numPr;
+	Object.assign(original, listRenderingFor(record.numPr ?? inherited, numbering));
 	original["numPr"] = record.numPr ?? null;
 	return original;
 };
-/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
-const recordsListRendering = (record) => LIST_RENDERING_ATTR_KEYS.some((key) => Object.hasOwn(record, key));
-/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
-const listRenderingFor = (numPr, numbering) => {
-	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
-	const rendering = numId === void 0 ? CLEARED_LIST_RENDERING_ATTRS : listAttrsFromNumbering({
-		numId,
-		ilvl: paragraphNumberingLevel(numPr ?? void 0) ?? 0
-	}, numbering);
-	const attrs = {};
-	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
-	return attrs;
-};
-const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
-	const record = previousFormatting ?? {};
-	if (recordsListRendering(record)) return {};
-	const restored = record.numPr ?? void 0;
-	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
-	return listRenderingFor(restored, numbering);
-};
 const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested !== null && typeof nested === "object" && !Array.isArray(nested) ? Object.fromEntries(Object.entries(nested).filter(([, entry]) => entry !== null && entry !== void 0).toSorted(([left], [right]) => left.localeCompare(right))) : nested);
 /**
 * `next` with the list change recorded as a tracked paragraph-property change.
@@ -73,12 +48,16 @@ const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested
 * the file) keeps its author, id and date: the change joins that revision
 * rather than re-attributing it, and it is never dropped.
 */
-const trackListChange = ({ current, next, rev, numbering }) => {
+const trackListChange = ({ current, next, rev, numbering, styleResolver }) => {
 	const currentAttrs = expectParagraphAttrs(current);
 	const existing = currentAttrs._propertyChanges ?? [];
 	const pending = existing.find(({ info }) => info.provenance !== "suggested");
 	const retained = existing.filter((change) => change !== pending);
-	const previousFormatting = pending?.previousFormatting ? originalListFormatting(pending.previousFormatting, numbering) : listChangeSnapshot(current, currentAttrs);
+	const previousFormatting = pending?.previousFormatting ? originalListFormatting({
+		record: pending.previousFormatting,
+		numbering,
+		styleResolver
+	}) : listChangeSnapshot(current, currentAttrs);
 	const ownPending = pending !== void 0 && pending.info.author === rev.author;
 	if (ownPending && canonicalJson(previousFormatting) === canonicalJson(listChangeSnapshot(current, next))) return {
 		...next,
@@ -203,6 +182,10 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 		numId,
 		ilvl
 	}, numbering),
+	...listLevelIndentAttrPatch(directParagraphIndentation(attrs), {
+		numId,
+		ilvl
+	}, numbering),
 	listImplicitChildLevelAdvances: attrs["listImplicitChildLevelAdvances"] ?? null,
 	listMarkerSecondSlotOffsetTwips: attrs["listMarkerSecondSlotOffsetTwips"] ?? null
 });
@@ -213,12 +196,14 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 const applyParagraphUpdates = ({ tr, state, updates }) => {
 	const rev = makeRevisionInfo(state);
 	const numbering = getDocumentNumbering(state);
+	const styleResolver = getDocumentStyleResolver(state);
 	for (const { pos, node, next } of updates) {
 		const attrs = rev ? trackListChange({
 			current: node,
 			next,
 			rev,
-			numbering
+			numbering,
+			styleResolver
 		}) : next;
 		tr.setNodeMarkup(pos, void 0, attrs);
 	}
@@ -261,7 +246,7 @@ const moveItems = ({ state, items, numId, numbering }) => {
 		updates: items.map(({ pos, node, membership }) => ({
 			pos,
 			node,
-			next: listItemAttrs(node.attrs, {
+			next: listItemAttrs(expectParagraphAttrs(node), {
 				numId,
 				ilvl: membership.ilvl
 			}, numbering)
@@ -342,4 +327,4 @@ const listNumberingMenuState = (state) => restartNumbering(state) ? {
 	canContinue: continueNumbering(state)
 } : NO_LIST_NUMBERING_MENU;
 //#endregion
-export { NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };
+export { NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listRendering.d.ts

@@ -0,0 +1,29 @@
+import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { ParagraphNumberingOverride } from "../docx/numberingReference.js";
+//#region src/prosemirror/listRendering.d.ts
+type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
+/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
+declare const recordsListRendering: (record: PreviousFormatting) => boolean;
+/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
+declare const listRenderingFor: (numPr: ParagraphNumberingOverride | null | undefined, numbering: NumberingMap | null) => Record<string, unknown>;
+/**
+ * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
+ * reject restores the recorded numbering, but the rendering attrs sit outside
+ * the scope it restores wholesale, so a record that does not state them (one
+ * written by an operation, or read from a file) would leave the rendering of
+ * the numbering it undoes: a paragraph restored to no numbering still showed
+ * the marker it was given. When the reject changes the numbering, the
+ * rendering is recomputed from the restored numbering; otherwise it stays.
+ */
+type RejectedListRenderingOptions = {
+  /** The paragraph's attrs before the reject. */
+  current: Pick<ParagraphAttrs, "numPr">;
+  /** The previous state the rejected record restores. */
+  previousFormatting: PreviousFormatting | null | undefined;
+  numbering: NumberingMap | null;
+  restoredNumbering: ParagraphAttrs["numPr"] | null;
+};
+declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering, restoredNumbering }: RejectedListRenderingOptions) => Record<string, unknown>;
+//#endregion
+export { RejectedListRenderingOptions, listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/listRendering.js

@@ -0,0 +1,26 @@
+import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
+import { CLEARED_LIST_RENDERING_ATTRS } from "./listMarker.js";
+import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
+import { listAttrsFromNumbering } from "./styles/resolvedStyleAttrs.js";
+//#region src/prosemirror/listRendering.ts
+/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
+const recordsListRendering = (record) => LIST_RENDERING_ATTR_KEYS.some((key) => Object.hasOwn(record, key));
+/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
+const listRenderingFor = (numPr, numbering) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const rendering = numId === void 0 ? CLEARED_LIST_RENDERING_ATTRS : listAttrsFromNumbering({
+		numId,
+		ilvl: paragraphNumberingLevel(numPr ?? void 0) ?? 0
+	}, numbering);
+	const attrs = {};
+	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
+	return attrs;
+};
+const rejectedListRenderingPatch = ({ current, previousFormatting, numbering, restoredNumbering }) => {
+	if (recordsListRendering(previousFormatting ?? {})) return {};
+	const restored = restoredNumbering ?? void 0;
+	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
+	return listRenderingFor(restored, numbering);
+};
+//#endregion
+export { listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/markupViewNotes.d.ts

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../types/document.js";
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/markupViewNotes.d.ts
+/** The footnotes or endnotes as `view` shows them. */
+declare const markupViewNotes: <TNote extends document_d_exports.Footnote | document_d_exports.Endnote>(notes: TNote[] | undefined, view: DisplayMode, state: EditorState, document: document_d_exports.Document | null) => TNote[] | undefined;
+//#endregion
+export { markupViewNotes };

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

@@ -82,6 +82,8 @@ type MarkupViewProjection =
  * 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
@@ -92,4 +94,4 @@ declare const projectMarkupView: (state: EditorState, view: DisplayMode) => Mark
  */
 declare const visibleCaretPosition: (projection: MarkupViewProjection, position: number) => number;
 //#endregion
-export { MarkupViewProjection, projectMarkupView, resolveStateStory, visibleCaretPosition };
+export { MarkupViewProjection, markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/markupViewProjection.js

@@ -2,7 +2,7 @@ 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/documentStyles.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. */
@@ -41,6 +41,11 @@ const projectionCache = /* @__PURE__ */ new WeakMap();
 * 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;
@@ -80,4 +85,4 @@ const visibleCaretPosition = (projection, position) => {
 	return projection.toEditor(near.head, -1);
 };
 //#endregion
-export { projectMarkupView, resolveStateStory, visibleCaretPosition };
+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 };