@stll/folio-core 0.62.0 → 0.63.0

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

@@ -1,6 +1,8 @@
 import { AUTHOR_COLORS, getAuthorColorIdx } from "../../../utils/authorColors.js";
 import { expectTrackedChangeMarkAttrs, isTrackedRevisionAncestorArray } from "../../attrs/index.js";
+import { mintRevisionId } from "../../plugins/revisionIds.js";
 import { createMarkExtension } from "../create.js";
+import { authorFromClipboardRevision } from "../features/clipboardTrackedRevisions.js";
 //#region src/prosemirror/extensions/marks/TrackedChangeExtensions.ts
 /**
 * Tracked Change Mark Extensions — insertion and deletion marks
@@ -40,6 +42,12 @@ const revisionAncestorsFromDom = (serialized) => {
 		return false;
 	}
 };
+const clipboardRevisionAttrs = (dom) => ({
+	revisionId: mintRevisionId(),
+	author: authorFromClipboardRevision(dom.getAttribute("cite")),
+	date: dom.getAttribute("datetime"),
+	_docxRevisionAncestors: null
+});
 /**
 * Insertion mark — text added in tracked changes
 * Renders with per-author colored underline.
@@ -59,10 +67,14 @@ const InsertionExtension = createMarkExtension({
 			suggestionId: { default: null },
 			_docxOuterWrapperCount: { default: null },
 			_docxResolutionJoins: { default: null },
-			_docxRevisionAncestors: { default: null }
+			_docxRevisionAncestors: { default: null },
+			_docxCommentRangeBoundaries: { default: void 0 }
 		},
 		inclusive: false,
 		parseDOM: [{
+			tag: "ins",
+			getAttrs: (dom) => clipboardRevisionAttrs(dom)
+		}, {
 			tag: "span.docx-insertion",
 			getAttrs(dom) {
 				const ancestors = revisionAncestorsFromDom(dom.dataset["revisionAncestors"]);
@@ -122,10 +134,14 @@ const DeletionExtension = createMarkExtension({
 			_historicalFormatting: { default: null },
 			_docxOuterWrapperCount: { default: null },
 			_docxResolutionJoins: { default: null },
-			_docxRevisionAncestors: { default: null }
+			_docxRevisionAncestors: { default: null },
+			_docxCommentRangeBoundaries: { default: void 0 }
 		},
 		inclusive: false,
 		parseDOM: [{
+			tag: "del",
+			getAttrs: (dom) => clipboardRevisionAttrs(dom)
+		}, {
 			tag: "span.docx-deletion",
 			getAttrs(dom) {
 				const ancestors = revisionAncestorsFromDom(dom.dataset["revisionAncestors"]);

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

@@ -3,6 +3,5 @@ import { MarkExtension } from "../types.js";
 /**
  * Underline Mark Extension
  */
-declare const UnderlineExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
-//#endregion
-export { UnderlineExtension };
+export declare const UnderlineExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion

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

@@ -1,7 +1,7 @@
 import { PLAIN_UNDERLINE, underlineDecorationCss, underlineStyleFromCssDecoration } from "../../../utils/formatToStyle.js";
 import { expectUnderlineMarkAttrs } from "../../attrs/index.js";
 import { createMarkExtension } from "../create.js";
-import { setMark, toggleUnderlineMark } from "./markUtils.js";
+import { canonicalSetMarkFormatting, setMark, toggleUnderlineMark, withRunFormattingLock } from "./markUtils.js";
 import { panic } from "better-result";
 //#region src/prosemirror/extensions/marks/UnderlineExtension.ts
 /**
@@ -43,10 +43,17 @@ const UnderlineExtension = createMarkExtension({
 		return {
 			commands: {
 				toggleUnderline: () => toggleUnderlineMark(underlineType),
-				setUnderlineStyle: (style, color) => setMark(underlineType, {
+				setUnderlineStyle: (style, color) => withRunFormattingLock(setMark(underlineType, {
 					style,
 					color
-				})
+				}), (state) => canonicalSetMarkFormatting({
+					state,
+					type: underlineType,
+					attrs: {
+						style,
+						color
+					}
+				}))
 			},
 			keyboardShortcuts: { "Mod-u": toggleUnderlineMark(underlineType) }
 		};

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

@@ -1,32 +1,96 @@
 import { document_d_exports } from "../../../types/document.js";
+import { CanonicalCommandIntent } from "../../canonicalCommands.js";
 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(type: MarkType, attrs: MarkAttrs): Command;
+export declare const withRunFormattingLock: (command: Command, describe: (state: EditorState) => readonly CanonicalCommandIntent[] | undefined) => Command;
+export declare function marksToTextFormatting(marks: readonly Mark[]): document_d_exports.TextFormatting;
+type CanonicalSetMarkFormattingOptions = {
+  state: EditorState;
+  type: MarkType;
+  attrs: MarkAttrs;
+};
+export declare const canonicalSetMarkFormatting: ({ state, type, attrs }: CanonicalSetMarkFormattingOptions) => {
+  type: "formatRun";
+  from: number;
+  to: number;
+  patch: import("@stll/docx-core/ops").FormattingPatch<{
+    bold?: boolean | undefined;
+    boldCs?: boolean | undefined;
+    italic?: boolean | undefined;
+    italicCs?: boolean | undefined;
+    underline?: {
+      style: document_d_exports.UnderlineStyle;
+      color?: import("@stll/docx-core/model").ColorValue;
+    } | undefined;
+    strike?: boolean | undefined;
+    doubleStrike?: boolean | undefined;
+    vertAlign?: "baseline" | "superscript" | "subscript" | undefined;
+    smallCaps?: boolean | undefined;
+    allCaps?: boolean | undefined;
+    hidden?: boolean | undefined;
+    noProof?: boolean | undefined;
+    color?: import("@stll/docx-core/model").ColorValue | undefined;
+    highlight?: "black" | "blue" | "cyan" | "darkBlue" | "darkCyan" | "darkGray" | "darkGreen" | "darkMagenta" | "darkRed" | "darkYellow" | "green" | "lightGray" | "magenta" | "none" | "red" | "white" | "yellow" | undefined;
+    shading?: import("@stll/docx-core/model").ShadingProperties | undefined;
+    fontSize?: number | undefined;
+    fontSizeCs?: number | undefined;
+    fontFamily?: {
+      ascii?: string;
+      hAnsi?: string;
+      eastAsia?: string;
+      cs?: string;
+      hint?: "default" | "eastAsia" | "cs";
+      asciiTheme?: "majorAscii" | "majorHAnsi" | "majorEastAsia" | "majorBidi" | "minorAscii" | "minorHAnsi" | "minorEastAsia" | "minorBidi";
+      hAnsiTheme?: string;
+      eastAsiaTheme?: string;
+      csTheme?: string;
+    } | undefined;
+    language?: {
+      val?: string;
+      eastAsia?: string;
+      bidi?: string;
+    } | undefined;
+    spacing?: number | undefined;
+    position?: number | undefined;
+    scale?: number | undefined;
+    kerning?: number | undefined;
+    effect?: import("@stll/docx-core/model").TextEffect | undefined;
+    emphasisMark?: import("@stll/docx-core/model").EmphasisMark | undefined;
+    emboss?: boolean | undefined;
+    imprint?: boolean | undefined;
+    outline?: boolean | undefined;
+    shadow?: boolean | undefined;
+    rtl?: boolean | undefined;
+    cs?: boolean | undefined;
+    styleId?: string | undefined;
+    preserved?: import("@stll/docx-core/model").PreservedMarkup | undefined;
+  }>;
+}[];
+export 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;
+export declare const toggleDocumentMark: (type: MarkType) => Command;
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
-declare const toggleMarkForAllScripts: (type: MarkType, property: PairedToggleProperty) => Command;
+export 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;
+export 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(type: MarkType): Command;
+export declare const clearFontSizeForAllScripts: (markType: MarkType) => Command;
+export declare function toggleUnderlineMark(markType: MarkType): Command;
+export declare function removeMark(type: MarkType): Command;
 /**
  * Check if a mark is active in the current selection
  */
-declare function isMarkActive(state: EditorState, type: MarkType, attrs?: Record<string, unknown>): boolean;
+export 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, type: MarkType, attr: string): unknown;
-type AuthoredRunFormattingCarrier = "preserve" | "reconstruct";
+export declare function getMarkAttr(state: EditorState, type: MarkType, attr: string): unknown;
+export 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;
+export type MarkFactory = (type: string, attrs?: Attrs | null) => Mark;
 /**
  * Convert TextFormatting to ProseMirror marks
  */
@@ -39,23 +103,16 @@ type TextFormattingToMarksOptions = {
   /** Builds each mark; defaults to `schema.mark`. */
   createMark?: MarkFactory;
 };
-declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, schema: Schema, options?: TextFormattingToMarksOptions): Mark[];
-/**
- * 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;
+export declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting | undefined, schema: Schema, options?: TextFormattingToMarksOptions): Mark[];
+/** Clear character formatting from the selection. */
+export declare const clearFormatting: Command;
 /**
  * Create a command that sets a mark on the selection
  */
-declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string, unknown>): Command;
+export declare function createSetMarkCommand(markType: MarkType, attrs?: Record<string, unknown>): Command;
 /**
  * Create a command that removes a mark from the selection
  */
-declare function createRemoveMarkCommand(markType: MarkType): Command;
+export declare function createRemoveMarkCommand(markType: MarkType): Command;
 //#endregion
-export { AuthoredRunFormattingCarrier, MarkFactory, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleDocumentMark, toggleMarkForAllScripts, toggleUnderlineMark };
+export {};

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

@@ -1,9 +1,10 @@
+import { isContentLocked } from "../../../content-controls/mutateContentControls.js";
 import { FONT_THEME_VALUES } from "../../../types/documentEnumValues.js";
 import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
 import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.js";
 import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
 import { canonicalRunFormatting, withCanonicalCommand } from "../../canonicalCommands.js";
-import { canonicalSelectionRange } from "../../canonicalSelectionRange.js";
+import { canonicalSelectionRanges } from "../../canonicalSelectionRange.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
 import { documentMarkType } from "../../documentSchema.js";
 import { selectRunFormattingCarrierRepresentations } from "../../runFormattingInlineCarriers.js";
@@ -20,6 +21,31 @@ import { toggleMark } from "prosemirror-commands";
 * setMark, removeMark, isMarkActive, getMarkAttr, marksToTextFormatting,
 * textFormattingToMarks, clearFormatting
 */
+const isContentLockedControl = (node) => (node.type.name === "sdt" || node.type.name === "blockSdt") && isContentLocked(node.attrs["lock"]);
+const selectionTouchesContentLockedControl = (state) => {
+	const { $from, $to } = state.selection;
+	const hasLockedAncestor = (position) => {
+		for (let depth = 1; depth <= position.depth; depth += 1) if (isContentLockedControl(position.node(depth))) return true;
+		return false;
+	};
+	if (hasLockedAncestor($from) || hasLockedAncestor($to)) return true;
+	if (state.selection.empty) return false;
+	let touchesLockedControl = false;
+	canonicalSelectionRanges(state).forEach(({ from, to }) => {
+		state.doc.nodesBetween(from, to, (node) => {
+			if (isContentLockedControl(node)) {
+				touchesLockedControl = true;
+				return false;
+			}
+			return true;
+		});
+	});
+	return touchesLockedControl;
+};
+const withRunFormattingLock = (command, describe) => {
+	const guarded = (state, dispatch, view) => selectionTouchesContentLockedControl(state) ? false : command(state, dispatch, view);
+	return withCanonicalCommand(guarded, (state) => selectionTouchesContentLockedControl(state) ? [] : describe(state));
+};
 const isFontTheme = (value) => value !== void 0 && FONT_THEME_VALUES.some((theme) => theme === value);
 const fontFamilyAttrsToFormatting = ({ ascii, hAnsi, eastAsia, cs, hint, asciiTheme, hAnsiTheme, eastAsiaTheme, csTheme }) => ({
 	...ascii !== void 0 ? { ascii } : {},
@@ -135,10 +161,7 @@ function marksToTextFormatting(marks) {
 		case "runFormattingOverride":
 			applyRunFormattingOverrideMark(formatting, mark);
 			break;
-		case "characterStyle":
-			formatting.styleId = expectCharacterStyleMarkAttrs(mark).styleId;
-			break;
-		default: break;
+		case "characterStyle": formatting.styleId = expectCharacterStyleMarkAttrs(mark).styleId;
 	}
 	return formatting;
 }
@@ -173,7 +196,11 @@ function compactAttrs(attrs) {
 function mergeMarkAttrs(markType, currentMark, nextAttrs) {
 	const next = compactAttrs(nextAttrs);
 	switch (markType.name) {
-		case "fontFamily": return mergeFontFamily(currentMark ? fontFamilyAttrsToFormatting(expectFontFamilyMarkAttrs(currentMark)) : void 0, fontFamilyAttrsToFormatting(expectFontFamilyMarkAttrs(markType.create(next))));
+		case "fontFamily": {
+			const current = currentMark ? fontFamilyAttrsToFormatting(expectFontFamilyMarkAttrs(currentMark)) : void 0;
+			const incoming = fontFamilyAttrsToFormatting(expectFontFamilyMarkAttrs(markType.create(next)));
+			return mergeFontFamily(current, incoming);
+		}
 		case "underline": return {
 			...compactAttrs(currentMark?.attrs),
 			...next
@@ -191,9 +218,11 @@ function createMarkWithMergedAttrs(markType, currentMark, nextAttrs) {
 const canonicalSetMarkFormatting = ({ state, type, attrs }) => {
 	const markType = documentMarkType(state, type);
 	const { empty } = state.selection;
-	const { from, to } = canonicalSelectionRange(state);
-	if (empty) return canonicalRunFormatting(state, marksToTextFormatting([createMarkWithMergedAttrs(markType, markType.isInSet(state.storedMarks ?? state.selection.$from.marks()), attrs)]));
-	return selectRunFormattingCarrierRepresentations({
+	if (empty) {
+		const current = markType.isInSet(state.storedMarks ?? state.selection.$from.marks());
+		return canonicalRunFormatting(state, marksToTextFormatting([createMarkWithMergedAttrs(markType, current, attrs)]));
+	}
+	return canonicalSelectionRanges(state).flatMap(({ from, to }) => selectRunFormattingCarrierRepresentations({
 		doc: state.doc,
 		from,
 		to
@@ -202,12 +231,12 @@ const canonicalSetMarkFormatting = ({ state, type, attrs }) => {
 		from: representation.from,
 		to: representation.to,
 		patch: marksToTextFormatting([createMarkWithMergedAttrs(markType, markType.isInSet(representation.node.marks), attrs)])
-	}));
+	})));
 };
 function setMark(type, attrs) {
 	const command = (state, dispatch) => {
 		const markType = documentMarkType(state, type);
-		const { from, to, empty } = state.selection;
+		const { empty } = state.selection;
 		if (empty) {
 			if (dispatch) {
 				const current = state.storedMarks ?? state.selection.$from.marks();
@@ -220,24 +249,30 @@ function setMark(type, attrs) {
 		}
 		if (dispatch) {
 			if (!markRequiresAttrMerge(markType)) {
-				dispatch(state.tr.addMark(from, to, markType.create(attrs)).scrollIntoView());
+				let tr = state.tr;
+				canonicalSelectionRanges(state).forEach(({ from, to }) => {
+					tr = tr.addMark(from, to, markType.create(attrs));
+				});
+				dispatch(tr.scrollIntoView());
 				return true;
 			}
 			let tr = state.tr;
-			state.doc.nodesBetween(from, to, (node, pos) => {
-				if (!node.isText) return;
-				const start = Math.max(from, pos);
-				const end = Math.min(to, pos + node.nodeSize);
-				const currentMark = markType.isInSet(node.marks);
-				const mark = createMarkWithMergedAttrs(markType, currentMark, attrs);
-				tr = tr.addMark(start, end, mark);
+			canonicalSelectionRanges(state).forEach(({ from, to }) => {
+				state.doc.nodesBetween(from, to, (node, pos) => {
+					if (!node.isText) return;
+					const start = Math.max(from, pos);
+					const end = Math.min(to, pos + node.nodeSize);
+					const currentMark = markType.isInSet(node.marks);
+					const mark = createMarkWithMergedAttrs(markType, currentMark, attrs);
+					tr = tr.addMark(start, end, mark);
+				});
 			});
 			dispatch(tr.scrollIntoView());
 		}
 		return true;
 	};
 	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
-	return withCanonicalCommand(command, (state) => canonicalSetMarkFormatting({
+	return withRunFormattingLock(command, (state) => canonicalSetMarkFormatting({
 		state,
 		type,
 		attrs
@@ -289,18 +324,18 @@ const updateRunFormattingOverrideMarks = (marks, overrideType, update) => {
 const updateRunFormattingOverride = (state, tr, update) => {
 	const overrideType = state.schema.marks["runFormattingOverride"];
 	if (!overrideType) return tr;
-	const { from, to, empty } = state.selection;
+	const { empty } = state.selection;
 	if (empty) {
 		const marks = updateRunFormattingOverrideMarks(tr.storedMarks ?? state.storedMarks ?? state.selection.$from.marks(), overrideType, update);
 		saveStoredMarksToParagraph(state, tr, marks);
 		tr.setStoredMarks(marks);
 		return tr;
 	}
-	const representations = selectRunFormattingCarrierRepresentations({
+	const representations = canonicalSelectionRanges(state).flatMap(({ from, to }) => selectRunFormattingCarrierRepresentations({
 		doc: tr.doc,
 		from,
 		to
-	});
+	}));
 	for (const representation of representations) {
 		const { node, position } = representation;
 		const nextMarks = updateRunFormattingOverrideMarks(node.marks, overrideType, update);
@@ -319,9 +354,12 @@ const withRunFormattingOverride = (command, update) => (state, dispatch) => comm
 } : void 0);
 /** `toggleMark` for the document's own counterpart of `type`. */
 const toggleDocumentMark = (type) => {
-	const command = (state, dispatch, view) => toggleMark(documentMarkType(state, type))(state, dispatch, view);
+	const command = (state, dispatch, view) => {
+		const markType = documentMarkType(state, type);
+		return (isMarkActive(state, markType) ? removeMark(markType) : setMark(markType, {}))(state, dispatch, view);
+	};
 	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
-	return withCanonicalCommand(command, (state) => {
+	return withRunFormattingLock(command, (state) => {
 		const markType = documentMarkType(state, type);
 		const formatting = marksToTextFormatting([markType.create()]);
 		if (!isMarkActive(state, markType)) return canonicalRunFormatting(state, formatting);
@@ -330,7 +368,7 @@ const toggleDocumentMark = (type) => {
 	});
 };
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
-const toggleMarkForAllScripts = (type, property) => withCanonicalCommand((state, dispatch) => {
+const toggleMarkForAllScripts = (type, property) => withRunFormattingLock((state, dispatch) => {
 	const markType = documentMarkType(state, type);
 	const enabled = !isMarkActive(state, markType);
 	return withRunFormattingOverride(toggleMark(markType), (attrs) => updatePairedToggleAttrs(attrs, property, enabled))(state, dispatch);
@@ -345,35 +383,37 @@ const toggleMarkForAllScripts = (type, property) => withCanonicalCommand((state,
 	});
 });
 /** UI size command whose direct-formatting contract explicitly targets both script families. */
-const setFontSizeForAllScripts = (markType, size) => withCanonicalCommand(withRunFormattingOverride(setMark(markType, { size }), (attrs) => updateFontSizeCompanionAttrs(attrs, size)), (state) => canonicalRunFormatting(state, {
+const setFontSizeForAllScripts = (markType, size) => withRunFormattingLock(withRunFormattingOverride(setMark(markType, { size }), (attrs) => updateFontSizeCompanionAttrs(attrs, size)), (state) => canonicalRunFormatting(state, {
 	fontSize: size,
 	fontSizeCs: size
 }));
 /** Clears both ordinary and complex-script direct size through the UI command boundary. */
-const clearFontSizeForAllScripts = (markType) => withCanonicalCommand(withRunFormattingOverride(removeMark(markType), (attrs) => updateFontSizeCompanionAttrs(attrs, void 0)), (state) => canonicalRunFormatting(state, {
+const clearFontSizeForAllScripts = (markType) => withRunFormattingLock(withRunFormattingOverride(removeMark(markType), (attrs) => updateFontSizeCompanionAttrs(attrs, void 0)), (state) => canonicalRunFormatting(state, {
 	fontSize: null,
 	fontSizeCs: null
 }));
 function selectionHasVisibleUnderline(state, markType) {
-	const { from, to, empty, $from } = state.selection;
+	const { empty, $from } = state.selection;
 	if (empty) {
 		const mark = markType.isInSet(state.storedMarks ?? $from.marks());
 		return mark !== void 0 && mark.attrs["style"] !== "none";
 	}
 	let hasVisibleUnderline = false;
-	state.doc.nodesBetween(from, to, (node) => {
-		if (!node.isText) return true;
-		const mark = markType.isInSet(node.marks);
-		if (mark && mark.attrs["style"] !== "none") {
-			hasVisibleUnderline = true;
-			return false;
-		}
-		return true;
+	canonicalSelectionRanges(state).forEach(({ from, to }) => {
+		state.doc.nodesBetween(from, to, (node) => {
+			if (!node.isText) return true;
+			const mark = markType.isInSet(node.marks);
+			if (mark && mark.attrs["style"] !== "none") {
+				hasVisibleUnderline = true;
+				return false;
+			}
+			return true;
+		});
 	});
 	return hasVisibleUnderline;
 }
 function toggleUnderlineMark(markType) {
-	return withCanonicalCommand((state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" })(state, dispatch), (state) => canonicalSetMarkFormatting({
+	return withRunFormattingLock((state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" })(state, dispatch), (state) => canonicalSetMarkFormatting({
 		state,
 		type: markType,
 		attrs: { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" }
@@ -382,18 +422,25 @@ function toggleUnderlineMark(markType) {
 function removeMark(type) {
 	const command = (state, dispatch) => {
 		const markType = documentMarkType(state, type);
-		const { from, to, empty } = state.selection;
+		const { empty } = state.selection;
 		if (empty) {
 			if (dispatch) dispatchStoredMarks(state, dispatch, (state.storedMarks ?? state.selection.$from.marks()).filter((m) => m.type !== markType));
 			return true;
 		}
-		if (dispatch) dispatch(state.tr.removeMark(from, to, markType).scrollIntoView());
+		if (dispatch) {
+			let tr = state.tr;
+			canonicalSelectionRanges(state).forEach(({ from, to }) => {
+				tr = tr.removeMark(from, to, markType);
+			});
+			dispatch(tr.scrollIntoView());
+		}
 		return true;
 	};
 	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
-	return withCanonicalCommand(command, (state) => {
+	return withRunFormattingLock(command, (state) => {
 		const formatting = marksToTextFormatting([documentMarkType(state, type).create()]);
-		return canonicalRunFormatting(state, Object.fromEntries(Object.keys(formatting).map((key) => [key, null])));
+		const patch = Object.fromEntries(Object.keys(formatting).map((key) => [key, null]));
+		return canonicalRunFormatting(state, patch);
 	});
 }
 /**
@@ -401,28 +448,30 @@ function removeMark(type) {
 */
 function isMarkActive(state, type, attrs) {
 	const markType = documentMarkType(state, type);
-	const { from, to, empty } = state.selection;
+	const { empty } = state.selection;
 	if (empty) return (state.storedMarks ?? state.selection.$from.marks()).some((mark) => {
 		if (mark.type !== markType) return false;
 		if (!attrs) return true;
 		return Object.entries(attrs).every(([key, value]) => mark.attrs[key] === value);
 	});
 	let hasMark = false;
-	state.doc.nodesBetween(from, to, (node) => {
-		if (node.isText && !(RUN_FORMATTING_MARK_NAMES.has(markType.name) && node.marks.some((mark) => mark.type.name === "footnoteRef"))) {
-			const mark = markType.isInSet(node.marks);
-			if (mark) {
-				if (!attrs) {
-					hasMark = true;
-					return false;
-				}
-				if (Object.entries(attrs).every(([key, value]) => mark.attrs[key] === value)) {
-					hasMark = true;
-					return false;
+	canonicalSelectionRanges(state).forEach(({ from, to }) => {
+		state.doc.nodesBetween(from, to, (node) => {
+			if (node.isText && !(RUN_FORMATTING_MARK_NAMES.has(markType.name) && node.marks.some((mark) => mark.type.name === "footnoteRef"))) {
+				const mark = markType.isInSet(node.marks);
+				if (mark) {
+					if (!attrs) {
+						hasMark = true;
+						return false;
+					}
+					if (Object.entries(attrs).every(([key, value]) => mark.attrs[key] === value)) {
+						hasMark = true;
+						return false;
+					}
 				}
 			}
-		}
-		return true;
+			return true;
+		});
 	});
 	return hasMark;
 }
@@ -431,22 +480,24 @@ function isMarkActive(state, type, attrs) {
 */
 function getMarkAttr(state, type, attr) {
 	const markType = documentMarkType(state, type);
-	const { empty, $from, from, to } = state.selection;
+	const { empty, $from } = state.selection;
 	if (empty) {
 		const marks = state.storedMarks ?? $from.marks();
 		for (const mark of marks) if (mark.type === markType) return mark.attrs[attr];
 		return null;
 	}
 	let value = null;
-	state.doc.nodesBetween(from, to, (node) => {
-		if (node.isText && value === null) {
-			const mark = markType.isInSet(node.marks);
-			if (mark) {
-				value = mark.attrs[attr];
-				return false;
+	canonicalSelectionRanges(state).forEach(({ from, to }) => {
+		state.doc.nodesBetween(from, to, (node) => {
+			if (node.isText && value === null) {
+				const mark = markType.isInSet(node.marks);
+				if (mark) {
+					value = mark.attrs[attr];
+					return false;
+				}
 			}
-		}
-		return true;
+			return value === null;
+		});
 	});
 	return value;
 }
@@ -562,8 +613,8 @@ function textFormattingToMarks(formatting, schema, options) {
 * 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;
+const clearFormattingCommand = (state, dispatch) => {
+	const { empty } = state.selection;
 	if (empty) {
 		if (dispatch) {
 			const tr = saveStoredMarksToParagraph(state, state.tr, []);
@@ -574,17 +625,30 @@ const clearFormatting = (state, dispatch) => {
 	}
 	if (dispatch) {
 		let tr = state.tr;
-		state.doc.nodesBetween(from, to, (node, pos) => {
-			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) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr = tr.removeMark(start, end, mark.type);
-			}
+		canonicalSelectionRanges(state).forEach(({ from, to }) => {
+			state.doc.nodesBetween(from, to, (node, pos) => {
+				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) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr = tr.removeMark(start, end, mark.type);
+				}
+			});
 		});
 		dispatch(tr.scrollIntoView());
 	}
 	return true;
 };
+/** Clear character formatting from the selection. */
+const clearFormatting = withRunFormattingLock(clearFormattingCommand, (state) => canonicalSelectionRanges(state).flatMap(({ from, to }) => selectRunFormattingCarrierRepresentations({
+	doc: state.doc,
+	from,
+	to
+}).map((representation) => ({
+	type: "formatRun",
+	from: representation.from,
+	to: representation.to,
+	patch: Object.fromEntries(Object.keys(marksToTextFormatting(representation.node.marks)).map((key) => [key, null]))
+}))));
 /**
 * Create a command that sets a mark on the selection
 */
@@ -598,4 +662,4 @@ function createRemoveMarkCommand(markType) {
 	return removeMark(markType);
 }
 //#endregion
-export { clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleDocumentMark, toggleMarkForAllScripts, toggleUnderlineMark };
+export { canonicalSetMarkFormatting, clearFontSizeForAllScripts, clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, marksToTextFormatting, removeMark, setFontSizeForAllScripts, setMark, textFormattingToMarks, toggleDocumentMark, toggleMarkForAllScripts, toggleUnderlineMark, withRunFormattingLock };

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

@@ -5,8 +5,8 @@ type DeletionRange = {
   to: number;
 };
 /** Keep the text carrying one OOXML note reference together during deletion. */
-declare const expandNoteReferenceDeletionRange: (doc: Node, from: number, to: number) => DeletionRange | null;
+export 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[];
+export declare const noteReferenceRanges: (doc: Node, from: number, to: number) => DeletionRange[];
 //#endregion
-export { expandNoteReferenceDeletionRange, noteReferenceRanges };
+export {};

package/dist/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.d.ts

@@ -22,8 +22,11 @@ import { NodeExtension } from "../types.js";
  * integrity pass in `BookmarkBoundaryExtension` reads both node types together;
  * a rule enforced here would see half of each such pair and delete it.
  */
+type BlockBookmarkBoundaryOptions = {
+  getInternalClipboardToken?: () => string;
+};
 /** The node name, for callers asking what a block container holds. */
-declare const BLOCK_BOOKMARK_BOUNDARY_NODE_NAME = "blockBookmarkBoundary";
-declare const BlockBookmarkBoundaryExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+export declare const BLOCK_BOOKMARK_BOUNDARY_NODE_NAME = "blockBookmarkBoundary";
+export declare const BlockBookmarkBoundaryExtension: (options?: Partial<BlockBookmarkBoundaryOptions> | undefined) => NodeExtension;
 //#endregion
-export { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME, BlockBookmarkBoundaryExtension };
+export {};