@stll/folio-core 0.62.0 → 0.63.1

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

@@ -1,29 +1,10 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.d.ts
-/**
- * A bookmark boundary that stands between two blocks.
- *
- * The block-level twin of `bookmarkBoundary`. `CT_Body`, `CT_Tc` and
- * `CT_SdtContentBlock` declare `w:bookmarkStart`/`w:bookmarkEnd` beside their
- * paragraphs and tables, and Word writes them there whenever the selection was
- * whole blocks: `_GoBack` after an edit, a table-of-contents range around the
- * headings it lists. ProseMirror decides inline or block per node type, so the
- * inline atom cannot also sit here and this is its own node — with the same
- * attributes, read by the same reader, so the two levels cannot describe a
- * bookmark differently.
- *
- * **Position is structure, not an attribute**, for the reason
- * `PreservedBlockExtension` gives: the node sits between the same two blocks it
- * sat between in the source and ProseMirror's own mapping keeps it there, so an
- * edit inside the range cannot change what the range covers.
- *
- * Pairing is owned one level up. A bookmark may open at block level and close
- * inside a paragraph, which is the commoner shape in real documents, so the
- * 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 {};

package/dist/prosemirror/extensions/nodes/BlockBookmarkBoundaryExtension.js

@@ -28,19 +28,19 @@ const BLOCK_BOOKMARK_BOUNDARY_NODE_NAME = "blockBookmarkBoundary";
 const BlockBookmarkBoundaryExtension = createNodeExtension({
 	name: BLOCK_BOOKMARK_BOUNDARY_NODE_NAME,
 	schemaNodeName: BLOCK_BOOKMARK_BOUNDARY_NODE_NAME,
-	nodeSpec: {
+	nodeSpec: (options) => ({
 		group: "block",
 		atom: true,
 		selectable: false,
 		attrs: bookmarkBoundaryAttrSpec,
 		parseDOM: [{
 			tag: "div[data-docx-bookmark-boundary]",
-			getAttrs: parseBookmarkBoundaryDom
+			getAttrs: (dom) => parseBookmarkBoundaryDom(dom, options.getInternalClipboardToken?.())
 		}],
 		toDOM(node) {
-			return ["div", bookmarkBoundaryDomAttributes(node)];
+			return ["div", bookmarkBoundaryDomAttributes(node, options.getInternalClipboardToken?.())];
 		}
-	}
+	})
 });
 //#endregion
 export { BLOCK_BOOKMARK_BOUNDARY_NODE_NAME, BlockBookmarkBoundaryExtension };

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

@@ -1,6 +1,5 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/nodes/BlockCustomXmlExtension.d.ts
 /** An editable block sequence inside an authored custom XML wrapper. */
-declare const BlockCustomXmlExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-//#endregion
-export { BlockCustomXmlExtension };
+export declare const BlockCustomXmlExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion

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

@@ -0,0 +1,10 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/BlockMoveRangeBoundaryExtension.d.ts
+type BlockMoveRangeBoundaryOptions = {
+  getInternalClipboardToken?: () => string;
+};
+/** The node name, for callers asking what a block container holds. */
+export declare const BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME = "blockMoveRangeBoundary";
+export declare const BlockMoveRangeBoundaryExtension: (options?: Partial<BlockMoveRangeBoundaryOptions> | undefined) => NodeExtension;
+//#endregion
+export {};

package/dist/prosemirror/extensions/nodes/BlockMoveRangeBoundaryExtension.js

@@ -0,0 +1,59 @@
+import { INTERNAL_CLIPBOARD_TOKEN_ATTRIBUTE, isInternalClipboardDom } from "../../copyOriginDom.js";
+import { expectMoveRangeBoundaryAttrs, moveRangeMarkerForDom, readMoveRangeMarker, withoutUntrustedCopyOrigin } from "../../moveRangeBoundaryAttrs.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/BlockMoveRangeBoundaryExtension.ts
+/**
+* A tracked-move range boundary that stands between two blocks.
+*
+* The block-level twin of `moveRangeBoundary`, as `blockBookmarkBoundary` is
+* of `bookmarkBoundary`: `CT_Body`, `CT_Tc` and `CT_SdtContentBlock` declare
+* `w:moveFromRangeStart`/`End` and `w:moveToRangeStart`/`End` beside their
+* paragraphs and tables, and a move whose range opens or closes on whole
+* blocks is written there. The node carries the same marker, read by the same
+* reader, so the two levels cannot describe a move range differently.
+*
+* Position is structure, not an attribute: the node sits between the same two
+* blocks it sat between in the source, and ProseMirror's mapping keeps it
+* there.
+*/
+/** The node name, for callers asking what a block container holds. */
+const BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME = "blockMoveRangeBoundary";
+const BLOCK_MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE = "data-docx-block-move-range-boundary";
+const BlockMoveRangeBoundaryExtension = createNodeExtension({
+	name: BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME,
+	schemaNodeName: BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME,
+	nodeSpec: (options) => ({
+		group: "block",
+		atom: true,
+		selectable: false,
+		attrs: { marker: {} },
+		parseDOM: [{
+			tag: `div[${BLOCK_MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE}]`,
+			getAttrs(dom) {
+				const raw = dom.getAttribute(BLOCK_MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE);
+				if (raw === null) return false;
+				try {
+					const marker = JSON.parse(raw);
+					const markerForRead = isInternalClipboardDom(dom, options.getInternalClipboardToken?.()) ? marker : withoutUntrustedCopyOrigin(marker);
+					const result = readMoveRangeMarker(markerForRead);
+					return result.ok ? { marker: result.value } : false;
+				} catch {
+					return false;
+				}
+			}
+		}],
+		toDOM(node) {
+			const internalClipboardToken = options.getInternalClipboardToken?.();
+			const marker = moveRangeMarkerForDom(expectMoveRangeBoundaryAttrs(node), internalClipboardToken);
+			return ["div", {
+				[BLOCK_MOVE_RANGE_BOUNDARY_DOM_ATTRIBUTE]: JSON.stringify(marker),
+				"aria-hidden": "true",
+				contenteditable: "false",
+				style: "display: none;",
+				...internalClipboardToken ? { [INTERNAL_CLIPBOARD_TOKEN_ATTRIBUTE]: internalClipboardToken } : {}
+			}];
+		}
+	})
+});
+//#endregion
+export { BLOCK_MOVE_RANGE_BOUNDARY_NODE_NAME, BlockMoveRangeBoundaryExtension };

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

@@ -1,22 +1,4 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/nodes/BlockSdtExtension.d.ts
-/**
- * BlockSdt Extension — block-level content control node.
- *
- * Mirrors OOXML's block `w:sdt` wrapping paragraphs/tables. `isolating: true`
- * keeps user edits scoped to the control (a backspace at the start of an
- * inner paragraph cannot merge through the boundary into a sibling), and
- * `defining: true` preserves the wrapper across split/lift.
- *
- * Attributes:
- * - `sdtType` / `alias` / `tag` / `lock` / `placeholder` /
- *   `showingPlaceholder` / `dateFormat` / `listItems` / `checked` — modeled
- *   projection of `w:sdtPr`; drives addressing and widget UX.
- * - `_preserved` — the `w:sdtPr` children folio does not model, at their
- *   schema ordinal, so `w:dataBinding`, `w15:repeatingSection` and the
- *   control-kind element round-trip without being enumerated here.
- * - `rawEndPropertiesXml` — the verbatim `<w:sdtEndPr>`.
- */
-declare const BlockSdtExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
-//#endregion
-export { BlockSdtExtension };
+export declare const BlockSdtExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion

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

@@ -1,11 +1,10 @@
 import { NodeExtension } from "../types.js";
 //#region src/prosemirror/extensions/nodes/BookmarkBoundaryExtension.d.ts
-/** Zero-width bookmark boundary that preserves its position through ProseMirror edits. */
 type BookmarkBoundaryOptions = {
   getInternalClipboardToken?: () => string;
 };
 /** The node name, for callers asking whether a paragraph holds any content. */
-declare const BOOKMARK_BOUNDARY_NODE_NAME = "bookmarkBoundary";
-declare const BookmarkBoundaryExtension: (options?: Partial<BookmarkBoundaryOptions> | undefined) => NodeExtension;
+export declare const BOOKMARK_BOUNDARY_NODE_NAME = "bookmarkBoundary";
+export declare const BookmarkBoundaryExtension: (options?: Partial<BookmarkBoundaryOptions> | undefined) => NodeExtension;
 //#endregion
-export { BOOKMARK_BOUNDARY_NODE_NAME, BookmarkBoundaryExtension };
+export {};

package/dist/prosemirror/extensions/nodes/BookmarkBoundaryExtension.js

@@ -70,7 +70,7 @@ const BookmarkBoundaryExtension = createNodeExtension({
 		attrs: bookmarkBoundaryAttrSpec,
 		parseDOM: [{
 			tag: "span[data-docx-bookmark-boundary]",
-			getAttrs: parseBookmarkBoundaryDom
+			getAttrs: (dom) => parseBookmarkBoundaryDom(dom, options.getInternalClipboardToken?.())
 		}],
 		toDOM(node) {
 			return ["span", bookmarkBoundaryDomAttributes(node, options.getInternalClipboardToken?.())];

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

@@ -0,0 +1,10 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/CommentRangeBoundaryExtension.d.ts
+type CommentRangeBoundaryOptions = {
+  getInternalClipboardToken?: () => string;
+};
+export declare const COMMENT_RANGE_BOUNDARY_NODE_NAME = "commentRangeBoundary";
+export declare const COMMENT_RANGE_BOUNDARY_DOM_ATTRIBUTE = "data-docx-comment-range-boundary";
+export declare const CommentRangeBoundaryExtension: (options?: Partial<CommentRangeBoundaryOptions> | undefined) => NodeExtension;
+//#endregion
+export {};