@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/extensions/features/pastedHtmlLists.js

@@ -0,0 +1,124 @@
+import { mintListInstance } from "../../../docx/listNumberingInstances.js";
+import { createNumberingMap } from "../../../docx/numberingParser.js";
+import { expectParagraphAttrs } from "../../attrs/index.js";
+import { completeNumberingForDoc } from "../../listInstanceReferences.js";
+import { listItemAttrs } from "../../listNumbering.js";
+import { getPackageNumberingDefinitions } from "../../plugins/documentNumbering.js";
+import { panic } from "better-result";
+import { Fragment, Slice } from "prosemirror-model";
+//#region src/prosemirror/extensions/features/pastedHtmlLists.ts
+/** Convert browser list markup into the editor's numbered-paragraph model. */
+const isList = (element) => element.localName === "ul" || element.localName === "ol";
+const hasListHint = (node) => node?.type.name === "paragraph" && Boolean(expectParagraphAttrs(node)._pastedHtmlList);
+/**
+* Flatten only list containers. Other HTML remains in place for the normal
+* clipboard parser, including tables and inline formatting inside list items.
+*/
+const flattenPastedHtmlLists = (html) => {
+	if (!/<(?:ul|ol)\b/iu.test(html)) return html;
+	const host = document.createElement("div");
+	host.innerHTML = html;
+	let nextGroup = 0;
+	const flatten = (list, level) => {
+		const fragment = document.createDocumentFragment();
+		const group = ++nextGroup;
+		const kind = list.localName === "ul" ? "bullet" : "numbered";
+		const rawStart = Number(list.getAttribute("start"));
+		const start = Number.isSafeInteger(rawStart) && rawStart > 0 ? rawStart : void 0;
+		for (const item of Array.from(list.children)) {
+			if (item.localName !== "li") continue;
+			let paragraph = document.createElement("p");
+			let emitted = false;
+			const mark = (element) => {
+				element.setAttribute("data-folio-list-group", String(group));
+				element.setAttribute("data-folio-list-level", String(Math.min(level, 8)));
+				element.setAttribute("data-folio-list-kind", kind);
+				if (start !== void 0) element.setAttribute("data-folio-list-start", String(start));
+			};
+			const flush = () => {
+				if (!paragraph.hasChildNodes()) return;
+				mark(paragraph);
+				fragment.append(paragraph);
+				paragraph = document.createElement("p");
+				emitted = true;
+			};
+			for (const child of Array.from(item.childNodes)) if (child instanceof Element && isList(child)) {
+				flush();
+				fragment.append(flatten(child, level + 1));
+			} else if (child instanceof Element && child.localName === "p") {
+				flush();
+				mark(child);
+				fragment.append(child);
+				emitted = true;
+			} else if (child.nodeType !== Node.TEXT_NODE || child.textContent?.trim()) paragraph.append(child);
+			flush();
+			if (!emitted) {
+				mark(paragraph);
+				fragment.append(paragraph);
+			}
+		}
+		return fragment;
+	};
+	for (const list of Array.from(host.querySelectorAll("ul,ol"))) {
+		if (!list.parentNode || list.parentElement?.closest("ul,ol")) continue;
+		list.replaceWith(flatten(list, 0));
+	}
+	return host.innerHTML;
+};
+/** Resolve clipboard-only list hints against fresh document numbering ids. */
+const numberPastedHtmlLists = (slice, view) => {
+	let hasList = false;
+	slice.content.descendants((node) => {
+		if (hasListHint(node)) {
+			hasList = true;
+			return false;
+		}
+		return !hasList;
+	});
+	if (!hasList) return slice;
+	const startsWithList = hasListHint(slice.content.firstChild);
+	const endsWithList = hasListHint(slice.content.lastChild);
+	let definitions = completeNumberingForDoc(getPackageNumberingDefinitions(view.state) ?? void 0, view.state.doc);
+	let numbering = null;
+	const groups = /* @__PURE__ */ new Map();
+	let changed = false;
+	const convert = (node) => {
+		let result = node;
+		if (node.type.name === "paragraph") {
+			const attrs = expectParagraphAttrs(node);
+			const hint = attrs._pastedHtmlList;
+			if (hint) {
+				let group = groups.get(hint.group);
+				if (!group || group.kind !== hint.kind) {
+					const minted = mintListInstance(definitions, {
+						kind: hint.kind,
+						...hint.start === void 0 ? {} : { start: hint.start }
+					});
+					definitions = minted.definitions;
+					numbering = createNumberingMap(definitions);
+					group = {
+						numId: minted.numId,
+						kind: hint.kind
+					};
+					groups.set(hint.group, group);
+				}
+				if (!numbering) panic("Pasted list group has no numbering definition");
+				const { _pastedHtmlList: _consumed, ...unhinted } = attrs;
+				result = node.type.create(listItemAttrs(unhinted, {
+					numId: group.numId,
+					ilvl: hint.level
+				}, numbering), node.content, node.marks);
+				changed = true;
+			}
+		}
+		if (result.childCount === 0) return result;
+		const children = [];
+		result.forEach((child) => children.push(convert(child)));
+		return result.copy(Fragment.fromArray(children));
+	};
+	const children = [];
+	slice.content.forEach((node) => children.push(convert(node)));
+	return changed ? new Slice(Fragment.fromArray(children), startsWithList ? 0 : slice.openStart, endsWithList ? 0 : slice.openEnd) : slice;
+};
+//#endregion
+export { flattenPastedHtmlLists, numberPastedHtmlLists };

package/dist/prosemirror/extensions/marks/FootnoteRefExtension.js

@@ -1,5 +1,7 @@
 import { expectFootnoteRefMarkAttrs } from "../../attrs/index.js";
+import { suggestRangeDeletion, suggestionModeKey } from "../../plugins/suggestionMode.js";
 import { createMarkExtension } from "../create.js";
+import { expandNoteReferenceDeletionRange, noteReferenceRanges } from "./noteReferenceDeletion.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/FootnoteRefExtension.ts
 /**
@@ -57,11 +59,19 @@ const FootnoteRefExtension = createMarkExtension({
 			];
 		}
 	},
-	onSchemaReady(ctx) {
-		const { schema } = ctx;
+	onSchemaReady() {
+		const deleteWholeNoteReference = (direction) => (state, dispatch) => {
+			if (suggestionModeKey.getState(state)?.active) return false;
+			const { from, to, empty } = state.selection;
+			const range = expandNoteReferenceDeletionRange(state.doc, empty && direction === "backward" ? Math.max(0, from - 1) : from, empty && direction === "forward" ? Math.min(state.doc.content.size, to + 1) : to);
+			if (!range) return false;
+			dispatch?.(state.tr.delete(range.from, range.to).scrollIntoView());
+			return true;
+		};
 		function makeInsertNote(noteType) {
 			return (id) => (state, dispatch) => {
 				if (!dispatch) return true;
+				const { schema } = state;
 				const footnoteRefType = schema.marks["footnoteRef"];
 				if (!footnoteRefType) panic("Missing mark type: footnoteRef");
 				const mark = footnoteRefType.create({
@@ -74,20 +84,32 @@ const FootnoteRefExtension = createMarkExtension({
 				return true;
 			};
 		}
+		/**
+		* Delete the note references the selection touches (the one beside a
+		* caret), each whole: tracked as a deletion of the reference run when
+		* suggesting, removed outright otherwise.
+		*/
 		const deleteNoteRef = (state, dispatch) => {
-			const { $from, $to } = state.selection;
+			const { from, to, empty } = state.selection;
+			const references = noteReferenceRanges(state.doc, empty ? Math.max(0, from - 1) : from, empty ? Math.min(state.doc.content.size, to + 1) : to);
+			if (references.length === 0) return false;
 			if (!dispatch) return true;
-			let tr = state.tr;
-			const markType = schema.marks["footnoteRef"];
-			tr = tr.removeMark($from.pos, $to.pos, markType);
+			const tr = state.tr;
+			for (const reference of references.toReversed()) if (!suggestRangeDeletion(state, tr, reference.from, reference.to)) tr.delete(reference.from, reference.to);
 			dispatch(tr.scrollIntoView());
 			return true;
 		};
-		return { commands: {
-			insertFootnote: makeInsertNote("footnote"),
-			insertEndnote: makeInsertNote("endnote"),
-			deleteNoteRef: () => deleteNoteRef
-		} };
+		return {
+			keyboardShortcuts: {
+				Backspace: deleteWholeNoteReference("backward"),
+				Delete: deleteWholeNoteReference("forward")
+			},
+			commands: {
+				insertFootnote: makeInsertNote("footnote"),
+				insertEndnote: makeInsertNote("endnote"),
+				deleteNoteRef: () => deleteNoteRef
+			}
+		};
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/marks/HyperlinkExtension.js

@@ -1,5 +1,6 @@
 import { anchorTargetAttrs, normalizeUserUrl, sanitizeExternalUrl } from "../../../utils/urlSecurity.js";
 import { expectHyperlinkMarkAttrs } from "../../attrs/index.js";
+import { removeHyperlinkInRange } from "../../hyperlinkRemoval.js";
 import { createMarkExtension } from "../create.js";
 import { isMarkActive } from "./markUtils.js";
 import { panic } from "better-result";
@@ -118,9 +119,10 @@ const HyperlinkExtension = createMarkExtension({
 		}
 	},
 	onSchemaReady(ctx) {
-		const hlType = ctx.schema.marks["hyperlink"];
-		if (!hlType) panic("Missing mark type: hyperlink");
+		if (!ctx.schema.marks["hyperlink"]) panic("Missing mark type: hyperlink");
+		const documentHyperlinkType = (state) => state.schema.marks["hyperlink"] ?? panic("Missing mark type: hyperlink");
 		const setHyperlink = (href, tooltip) => (state, dispatch) => {
+			const hlType = documentHyperlinkType(state);
 			const { from, to, empty } = state.selection;
 			if (empty) return false;
 			if (dispatch) {
@@ -136,6 +138,7 @@ const HyperlinkExtension = createMarkExtension({
 			return true;
 		};
 		const removeHyperlink = (state, dispatch) => {
+			const hlType = documentHyperlinkType(state);
 			const { from, to, empty } = state.selection;
 			if (empty) {
 				const $pos = state.selection.$from;
@@ -154,13 +157,14 @@ const HyperlinkExtension = createMarkExtension({
 						}
 					}
 				});
-				if (dispatch) dispatch(state.tr.removeMark(start, end, hlType).scrollIntoView());
+				if (dispatch) dispatch(removeHyperlinkInRange(state, state.tr, start, end).scrollIntoView());
 				return true;
 			}
-			if (dispatch) dispatch(state.tr.removeMark(from, to, hlType).scrollIntoView());
+			if (dispatch) dispatch(removeHyperlinkInRange(state, state.tr, from, to).scrollIntoView());
 			return true;
 		};
 		const insertHyperlink = (text, href, tooltip) => (state, dispatch) => {
+			const hlType = documentHyperlinkType(state);
 			if (dispatch) {
 				const mark = hlType.create({
 					href: normalizeHyperlinkInput(href),

package/dist/prosemirror/extensions/marks/RunIdentityExtension.d.ts

@@ -1,26 +1,29 @@
 import { MarkExtension } from "../types.js";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/marks/RunIdentityExtension.d.ts
+type InsertedRange = {
+  from: number;
+  to: number;
+};
 /**
- * Editor-side identity for one authored `w:r`, and the payload that element
- * carried which no formatting mark holds.
+ * Every range `transactions` inserted, in the document they produced.
  *
- * Ordinary formatting marks cannot tell two adjacent source runs with
- * identical properties apart, so the save leg would fold them into one and
- * discard whichever record it did not keep. This mark is what keeps them
- * apart: it is in `getMarksKey`, so a change of identity is a run boundary,
- * and `joinsOwnedSourceRun` rejoins the leaves a page break cut out of one
- * authored run.
+ * A step map reports each replacement as an old span and the new span it
+ * became; a new span longer than nothing is content the step put there, which
+ * is exactly the text that may not claim an authored run. Each range is then
+ * carried through the steps that followed it — the rest of its own
+ * transaction, then every later one — so a batch applied together reports
+ * positions in the document this hook is looking at rather than in an
+ * intermediate one.
  *
- * `inclusive: false` settles the edges. The interior is settled by the strip
- * below: ProseMirror's stored marks at a position inside a span include every
- * mark of the preceding character, so text typed inside an authored run would
- * otherwise ride that run's `w:rsidR` — a claim about which editing session
- * wrote it. folio cannot register a session (`settings.xml`'s `w:rsids` is
- * copied through on every repack, and no save path mints one), so it must
- * never write a session id it did not read. Typed text becomes its own run
- * with no attributes instead, and `w:rsidRDefault` on the parent `w:p`
- * supplies the session the format itself says such a run belongs to.
+ * An undo is not an insertion: it puts back what an edit took away, identity
+ * included, and stripping that would leave the restored text claiming no run
+ * it came from. `skip` names the transactions to pass over; they still carry
+ * the ranges of the others forward.
+ *
+ * @internal Exported for the per-step equivalence test.
  */
+declare const insertedRanges: (transactions: readonly Transaction[], skip?: (transaction: Transaction) => boolean) => InsertedRange[];
 declare const RunIdentityExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
 //#endregion
-export { RunIdentityExtension };
+export { RunIdentityExtension, insertedRanges };

package/dist/prosemirror/extensions/marks/RunIdentityExtension.js

@@ -1,7 +1,10 @@
 import { expectRunIdentityMarkAttrs } from "../../attrs/index.js";
+import { nodesBetweenIndexed } from "../../indexedNodeLookup.js";
+import { sweepPositions } from "../../positionSweep.js";
 import { RUN_IDENTITY_ATTRIBUTE, RUN_IDENTITY_MARK_NAME, runIdentityAttrs } from "../../runIdentity.js";
 import { createMarkExtension } from "../create.js";
 import { Plugin, PluginKey } from "prosemirror-state";
+import { isHistoryTransaction, undoDepth } from "prosemirror-history";
 //#region src/prosemirror/extensions/marks/RunIdentityExtension.ts
 /**
 * Editor-side identity for one authored `w:r`, and the payload that element
@@ -36,27 +39,43 @@ const runIdentityStripKey = new PluginKey("runIdentityStrip");
 * transaction, then every later one — so a batch applied together reports
 * positions in the document this hook is looking at rather than in an
 * intermediate one.
+*
+* An undo is not an insertion: it puts back what an edit took away, identity
+* included, and stripping that would leave the restored text claiming no run
+* it came from. `skip` names the transactions to pass over; they still carry
+* the ranges of the others forward.
+*
+* @internal Exported for the per-step equivalence test.
 */
-const insertedRanges = (transactions) => {
-	const ranges = [];
-	for (const [transactionIndex, transaction] of transactions.entries()) {
-		const later = transactions.slice(transactionIndex + 1);
-		const carryForward = (pos, bias) => {
-			let mapped = pos;
-			for (const next of later) mapped = next.mapping.map(mapped, bias);
-			return mapped;
-		};
+const insertedRanges = (transactions, skip = () => false) => {
+	const queries = [];
+	let stepOffset = 0;
+	for (const transaction of transactions) {
+		const offset = stepOffset;
+		stepOffset += transaction.mapping.maps.length;
+		if (skip(transaction)) continue;
 		transaction.mapping.maps.forEach((stepMap, stepIndex) => {
-			const rest = transaction.mapping.slice(stepIndex + 1);
+			const from = offset + stepIndex + 1;
 			stepMap.forEach((_oldStart, _oldEnd, newStart, newEnd) => {
 				if (newEnd <= newStart) return;
-				ranges.push({
-					from: carryForward(rest.map(newStart, -1), -1),
-					to: carryForward(rest.map(newEnd, 1), 1)
+				queries.push({
+					pos: newStart,
+					assoc: -1,
+					from
+				}, {
+					pos: newEnd,
+					assoc: 1,
+					from
 				});
 			});
 		});
 	}
+	const mapped = sweepPositions(transactions.map((transaction) => transaction.mapping), queries);
+	const ranges = [];
+	for (let index = 0; index < mapped.length; index += 2) ranges.push({
+		from: mapped[index].pos,
+		to: mapped[index + 1].pos
+	});
 	return ranges;
 };
 /**
@@ -69,11 +88,12 @@ const insertedRanges = (transactions) => {
 */
 const createRunIdentityStripPlugin = () => new Plugin({
 	key: runIdentityStripKey,
-	appendTransaction(transactions, _oldState, newState) {
+	appendTransaction(transactions, oldState, newState) {
 		if (!transactions.some((transaction) => transaction.docChanged)) return null;
 		const markType = newState.schema.marks[RUN_IDENTITY_MARK_NAME];
 		if (markType === void 0) return null;
-		const ranges = insertedRanges(transactions);
+		const undoing = undoDepth(newState) < undoDepth(oldState);
+		const ranges = insertedRanges(transactions, (transaction) => undoing && isHistoryTransaction(transaction));
 		if (ranges.length === 0) return null;
 		const tr = newState.tr;
 		const stripRange = ({ from, to }) => {
@@ -81,7 +101,7 @@ const createRunIdentityStripPlugin = () => new Plugin({
 			const clampedFrom = Math.min(from, clampedTo);
 			if (clampedFrom === clampedTo) return false;
 			let rangeStripped = false;
-			newState.doc.nodesBetween(clampedFrom, clampedTo, (node, pos) => {
+			nodesBetweenIndexed(newState.doc, clampedFrom, clampedTo, (node, pos) => {
 				if (!node.isInline || !markType.isInSet(node.marks)) return true;
 				tr.removeMark(Math.max(pos, clampedFrom), Math.min(pos + node.nodeSize, clampedTo), markType);
 				rangeStripped = true;
@@ -132,4 +152,4 @@ const RunIdentityExtension = createMarkExtension({
 	}
 });
 //#endregion
-export { RunIdentityExtension };
+export { RunIdentityExtension, insertedRanges };

package/dist/prosemirror/extensions/marks/StrikeExtension.js

@@ -1,6 +1,6 @@
 import { createMarkExtension } from "../create.js";
+import { toggleDocumentMark } from "./markUtils.js";
 import { panic } from "better-result";
-import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/StrikeExtension.ts
 /**
 * Strikethrough Mark Extension
@@ -26,7 +26,7 @@ const StrikeExtension = createMarkExtension({
 	onSchemaReady(ctx) {
 		const strikeType = ctx.schema.marks["strike"];
 		if (!strikeType) panic("Missing mark type: strike");
-		return { commands: { toggleStrike: () => toggleMark(strikeType) } };
+		return { commands: { toggleStrike: () => toggleDocumentMark(strikeType) } };
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/marks/SubscriptExtension.js

@@ -1,6 +1,6 @@
 import { createMarkExtension } from "../create.js";
+import { toggleDocumentMark } from "./markUtils.js";
 import { panic } from "better-result";
-import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/SubscriptExtension.ts
 /**
 * Subscript Mark Extension
@@ -18,7 +18,7 @@ const SubscriptExtension = createMarkExtension({
 	onSchemaReady(ctx) {
 		const subscriptType = ctx.schema.marks["subscript"];
 		if (!subscriptType) panic("Missing mark type: subscript");
-		return { commands: { toggleSubscript: () => toggleMark(subscriptType) } };
+		return { commands: { toggleSubscript: () => toggleDocumentMark(subscriptType) } };
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/marks/SuperscriptExtension.js

@@ -1,6 +1,6 @@
 import { createMarkExtension } from "../create.js";
+import { toggleDocumentMark } from "./markUtils.js";
 import { panic } from "better-result";
-import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/SuperscriptExtension.ts
 /**
 * Superscript Mark Extension
@@ -18,7 +18,7 @@ const SuperscriptExtension = createMarkExtension({
 	onSchemaReady(ctx) {
 		const superscriptType = ctx.schema.marks["superscript"];
 		if (!superscriptType) panic("Missing mark type: superscript");
-		return { commands: { toggleSuperscript: () => toggleMark(superscriptType) } };
+		return { commands: { toggleSuperscript: () => toggleDocumentMark(superscriptType) } };
 	}
 });
 //#endregion

package/dist/prosemirror/extensions/marks/TextColorExtension.js

@@ -1,7 +1,8 @@
 import { textToStyle } from "../../../utils/formatToStyle.js";
 import { expectTextColorMarkAttrs } from "../../attrs/index.js";
+import { clearRunColor } from "../../clearRunColor.js";
 import { createMarkExtension } from "../create.js";
-import { removeMark, setMark } from "./markUtils.js";
+import { setMark } from "./markUtils.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/TextColorExtension.ts
 /**
@@ -39,10 +40,10 @@ const TextColorExtension = createMarkExtension({
 		if (!textColorType) panic("Missing mark type: textColor");
 		return { commands: {
 			setTextColor: (attrs) => {
-				if (!attrs.rgb && !attrs.themeColor) return removeMark(textColorType);
+				if (!attrs.rgb && !attrs.themeColor) return clearRunColor();
 				return setMark(textColorType, attrs);
 			},
-			clearTextColor: () => removeMark(textColorType)
+			clearTextColor: () => clearRunColor()
 		} };
 	}
 });

package/dist/prosemirror/extensions/marks/markUtils.d.ts

@@ -1,27 +1,29 @@
 import { document_d_exports } from "../../../types/document.js";
-import { Command, EditorState } from "prosemirror-state";
 import { Attrs, Mark, MarkType, Schema } from "prosemirror-model";
+import { Command, EditorState } from "prosemirror-state";
 //#region src/prosemirror/extensions/marks/markUtils.d.ts
 type MarkAttrs = Record<string, unknown>;
 declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
-declare function setMark(markType: MarkType, attrs: MarkAttrs): Command;
+declare function setMark(type: MarkType, attrs: MarkAttrs): Command;
 type PairedToggleProperty = "bold" | "italic";
+/** `toggleMark` for the document's own counterpart of `type`. */
+declare const toggleDocumentMark: (type: MarkType) => Command;
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
-declare const toggleMarkForAllScripts: (markType: MarkType, property: PairedToggleProperty) => Command;
+declare const toggleMarkForAllScripts: (type: MarkType, property: PairedToggleProperty) => Command;
 /** UI size command whose direct-formatting contract explicitly targets both script families. */
 declare const setFontSizeForAllScripts: (markType: MarkType, size: number) => Command;
 /** Clears both ordinary and complex-script direct size through the UI command boundary. */
 declare const clearFontSizeForAllScripts: (markType: MarkType) => Command;
 declare function toggleUnderlineMark(markType: MarkType): Command;
-declare function removeMark(markType: MarkType): Command;
+declare function removeMark(type: MarkType): Command;
 /**
  * Check if a mark is active in the current selection
  */
-declare function isMarkActive(state: EditorState, markType: MarkType, attrs?: Record<string, unknown>): boolean;
+declare function isMarkActive(state: EditorState, type: MarkType, attrs?: Record<string, unknown>): boolean;
 /**
  * Get the current value of a mark attribute
  */
-declare function getMarkAttr(state: EditorState, markType: MarkType, attr: string): unknown;
+declare function getMarkAttr(state: EditorState, type: MarkType, attr: string): unknown;
 type AuthoredRunFormattingCarrier = "preserve" | "reconstruct";
 /** Builds a mark by type name; a conversion passes one that shares equal marks. */
 type MarkFactory = (type: string, attrs?: Attrs | null) => Mark;
@@ -39,7 +41,12 @@ type TextFormattingToMarksOptions = {
 };
 declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, schema: Schema, options?: TextFormattingToMarksOptions): Mark[];
 /**
- * Clear all text formatting (remove all marks)
+ * Clear character formatting from the selection.
+ *
+ * Only the marks that carry run formatting go. A comment anchor, a hyperlink,
+ * a note reference, a tracked insertion or deletion and a run's identity are
+ * not formatting, and removing them deleted the comment's range, unlinked the
+ * text, orphaned the note and silently resolved the revision.
  */
 declare const clearFormatting: Command;
 /**
@@ -51,4 +58,4 @@ declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string,
  */
 declare function createRemoveMarkCommand(markType: MarkType): Command;
 //#endregion
-export { AuthoredRunFormattingCarrier, MarkFactory, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };
+export { AuthoredRunFormattingCarrier, MarkFactory, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleDocumentMark, toggleMarkForAllScripts, toggleUnderlineMark };

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -3,7 +3,9 @@ import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
 import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.js";
 import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
+import { documentMarkType } from "../../documentSchema.js";
 import { selectRunFormattingCarrierRepresentations } from "../../runFormattingInlineCarriers.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
 import { hasRunFormattingOverrideAttrs } from "../../runFormattingProvenance.js";
 import { COMPLEX_SCRIPT_RUN_PROPERTY_KEYS } from "../../schema/marks.js";
 import { applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs } from "./RunFormattingOverrideExtension.js";
@@ -177,8 +179,9 @@ function createMarkWithMergedAttrs(markType, currentMark, nextAttrs) {
 	if (!markRequiresAttrMerge(markType)) return markType.create(nextAttrs);
 	return markType.create(mergeMarkAttrs(markType, currentMark, nextAttrs));
 }
-function setMark(markType, attrs) {
+function setMark(type, attrs) {
 	return (state, dispatch) => {
+		const markType = documentMarkType(state, type);
 		const { from, to, empty } = state.selection;
 		if (empty) {
 			if (dispatch) {
@@ -200,7 +203,8 @@ function setMark(markType, attrs) {
 				if (!node.isText) return;
 				const start = Math.max(from, pos);
 				const end = Math.min(to, pos + node.nodeSize);
-				const mark = createMarkWithMergedAttrs(markType, markType.isInSet(node.marks), attrs);
+				const currentMark = markType.isInSet(node.marks);
+				const mark = createMarkWithMergedAttrs(markType, currentMark, attrs);
 				tr = tr.addMark(start, end, mark);
 			});
 			dispatch(tr.scrollIntoView());
@@ -282,8 +286,11 @@ const updateRunFormattingOverride = (state, tr, update) => {
 const withRunFormattingOverride = (command, update) => (state, dispatch) => command(state, dispatch ? (tr) => {
 	dispatch(updateRunFormattingOverride(state, tr, update));
 } : void 0);
+/** `toggleMark` for the document's own counterpart of `type`. */
+const toggleDocumentMark = (type) => (state, dispatch, view) => toggleMark(documentMarkType(state, type))(state, dispatch, view);
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
-const toggleMarkForAllScripts = (markType, property) => (state, dispatch) => {
+const toggleMarkForAllScripts = (type, property) => (state, dispatch) => {
+	const markType = documentMarkType(state, type);
 	const enabled = !isMarkActive(state, markType);
 	return withRunFormattingOverride(toggleMark(markType), (attrs) => updatePairedToggleAttrs(attrs, property, enabled))(state, dispatch);
 };
@@ -310,10 +317,11 @@ function selectionHasVisibleUnderline(state, markType) {
 	return hasVisibleUnderline;
 }
 function toggleUnderlineMark(markType) {
-	return (state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, markType) ? "none" : "single" })(state, dispatch);
+	return (state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" })(state, dispatch);
 }
-function removeMark(markType) {
+function removeMark(type) {
 	return (state, dispatch) => {
+		const markType = documentMarkType(state, type);
 		const { from, to, empty } = state.selection;
 		if (empty) {
 			if (dispatch) dispatchStoredMarks(state, dispatch, (state.storedMarks ?? state.selection.$from.marks()).filter((m) => m.type !== markType));
@@ -326,7 +334,8 @@ function removeMark(markType) {
 /**
 * Check if a mark is active in the current selection
 */
-function isMarkActive(state, markType, attrs) {
+function isMarkActive(state, type, attrs) {
+	const markType = documentMarkType(state, type);
 	const { from, to, empty } = state.selection;
 	if (empty) return (state.storedMarks ?? state.selection.$from.marks()).some((mark) => {
 		if (mark.type !== markType) return false;
@@ -355,7 +364,8 @@ function isMarkActive(state, markType, attrs) {
 /**
 * Get the current value of a mark attribute
 */
-function getMarkAttr(state, markType, attr) {
+function getMarkAttr(state, type, attr) {
+	const markType = documentMarkType(state, type);
 	const { empty, $from, from, to } = state.selection;
 	if (empty) {
 		const marks = state.storedMarks ?? $from.marks();
@@ -480,7 +490,12 @@ function textFormattingToMarks(formatting, schema, options) {
 	return marks;
 }
 /**
-* Clear all text formatting (remove all marks)
+* Clear character formatting from the selection.
+*
+* Only the marks that carry run formatting go. A comment anchor, a hyperlink,
+* a note reference, a tracked insertion or deletion and a run's identity are
+* not formatting, and removing them deleted the comment's range, unlinked the
+* text, orphaned the note and silently resolved the revision.
 */
 const clearFormatting = (state, dispatch) => {
 	const { from, to, empty } = state.selection;
@@ -498,7 +513,7 @@ const clearFormatting = (state, dispatch) => {
 			if (node.isText && node.marks.length > 0) {
 				const start = Math.max(from, pos);
 				const end = Math.min(to, pos + node.nodeSize);
-				for (const mark of node.marks) tr = tr.removeMark(start, end, mark.type);
+				for (const mark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr = tr.removeMark(start, end, mark.type);
 			}
 		});
 		dispatch(tr.scrollIntoView());
@@ -518,4 +533,4 @@ function createRemoveMarkCommand(markType) {
 	return removeMark(markType);
 }
 //#endregion
-export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleMarkForAllScripts, toggleUnderlineMark };
+export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleDocumentMark, toggleMarkForAllScripts, toggleUnderlineMark };

package/dist/prosemirror/extensions/marks/noteReferenceDeletion.d.ts

@@ -0,0 +1,12 @@
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/extensions/marks/noteReferenceDeletion.d.ts
+type DeletionRange = {
+  from: number;
+  to: number;
+};
+/** Keep the text carrying one OOXML note reference together during deletion. */
+declare const expandNoteReferenceDeletionRange: (doc: Node, from: number, to: number) => DeletionRange | null;
+/** Each whole note reference [`from`, `to`) of `doc` touches, in document order. */
+declare const noteReferenceRanges: (doc: Node, from: number, to: number) => DeletionRange[];
+//#endregion
+export { expandNoteReferenceDeletionRange, noteReferenceRanges };