@portabletext/editor 8.1.0 → 8.1.2

package/lib/index.js

@@ -1,9 +1,9 @@
-import { a as getNodeChildren, i as getChildren, l as serializePath, n as parentPath, r as getNode, t as getParent, u as isKeyedSegment } from "./get-parent-Ci5241qs.js";
-import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-CZd9VcVM.js";
-import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-D1nM_ww9.js";
-import { a as parseBlocks, b as childAtTextOffset, c as parseSpan, d as getSelectionEndPoint, f as isSelectionCollapsed, g as isEqualSelectionPoints, h as getBlockKeyFromSelectionPoint, i as parseBlock, l as defaultKeyGenerator, m as getBlockEndPoint, n as isListBlock, o as parseInlineObject, p as getBlockStartPoint, r as parseAnnotation, s as parseMarkDefs, u as getSelectionStartPoint, v as blockOffsetToSpanSelectionPoint, x as textOffsetOfChild } from "./util.slice-blocks-B2fZcNok.js";
-import { A as getSelectionEndPoint$1, B as getFocusBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionEndBlock, G as rangesOverlap, H as getFocusInlineObject, I as getFragment, L as getSelectedValue, M as isSelectionCollapsed$1, N as isOverlappingSelection, O as getSelectionStartPoint$1, P as getSelectionStartBlock, R as getRootAcceptedTypes, S as getActiveDecorators, T as getMarkState, U as getFocusChild, V as getFocusSpan, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isSelectionExpanded, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getFocusTextBlock } from "./selector.is-selecting-entire-blocks-DPnzucrd.js";
-import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-N1hxVUbE.js";
+import { a as getChildren, d as isKeyedSegment, i as resolveNode, n as parentPath, o as getNodeChildren, r as getNode, t as getParent, u as serializePath } from "./get-parent-DgaKcy8-.js";
+import { C as getAncestors, S as hasNode, _ as comparePoints, a as isInline, b as isEditableContainer, c as isSpanNode, d as resolveChildEntryIndex, f as isAncestorPath, g as isAfterPoint, h as isBackwardRange, i as getEnclosingBlock, l as getSibling, m as rangeEdges, n as getEnclosingContainer, o as getBlock, p as isTextBlockNode, s as isBlock, t as getPathSubSchema, u as getNodes, v as comparePaths, x as resolveContainerAt, y as isObject } from "./get-path-sub-schema-Dd0QYZ0m.js";
+import { _ as getAncestor, a as getTextBlock, c as pathContains, d as isRange, f as isPoint, g as isLeafObject, h as getLeaf, i as getFirstChild, l as getSpan, m as isPath, n as getUnionSchema, o as rangeIntersects, p as isObject$1, r as getLastChild, s as isBeforePoint, t as getContainer, u as getText } from "./get-container-D2pN5Npr.js";
+import { a as parseBlocks, b as childAtTextOffset, c as parseSpan, d as getSelectionEndPoint, f as isSelectionCollapsed, g as isEqualSelectionPoints, h as getBlockKeyFromSelectionPoint, i as parseBlock, l as defaultKeyGenerator, m as getBlockEndPoint, n as isListBlock, o as parseInlineObject, p as getBlockStartPoint, r as parseAnnotation, s as parseMarkDefs, u as getSelectionStartPoint, v as blockOffsetToSpanSelectionPoint, x as textOffsetOfChild } from "./util.slice-blocks-_ElaB53f.js";
+import { A as getSelectionEndPoint$1, B as getFocusBlock, C as getSelectedTextBlocks, D as getPreviousSpan, F as getSelectionEndBlock, G as rangesOverlap, H as getFocusInlineObject, I as getFragment, L as getSelectedValue, M as isSelectionCollapsed$1, N as isOverlappingSelection, O as getSelectionStartPoint$1, P as getSelectionStartBlock, R as getRootAcceptedTypes, S as getActiveDecorators, T as getMarkState, U as getFocusChild, V as getFocusSpan, a as isActiveListItem, b as getActiveAnnotations, c as getSelectionEndChild, d as getLastBlock, f as getFocusListBlock, i as isActiveStyle, j as isSelectionExpanded, k as getNextSpan, l as getPreviousBlock, m as getCaretWordSelection, n as isAtTheStartOfBlock, o as isActiveDecorator, p as getFocusBlockObject, r as isAtTheEndOfBlock, s as getSelectionStartChild, t as isSelectingEntireBlocks, u as getNextBlock, w as getActiveAnnotationsMarks, x as isActiveAnnotation, z as getFocusTextBlock } from "./selector.is-selecting-entire-blocks-BFhnnkHf.js";
+import { n as isEmptyTextBlock, r as getTextBlockText, t as isEqualSelections } from "./util.is-equal-selections-BdK98okY.js";
 import { a as raise$1, i as forward, n as effect, t as defineBehavior } from "./behavior.types.behavior-BxSLb73I.js";
 import { n as EditorContext$1, t as useEditor } from "./use-editor-CwNeVwVC.js";
 import { c } from "react/compiler-runtime";
@@ -465,17 +465,19 @@ const IS_IOS = typeof navigator < "u" && typeof window < "u" && /iPad|iPhone|iPo
 	},
 	toEditorSelection: (editor, domRange, options) => {
 		let { exactMatch, suppressThrow } = options, el = isDOMSelection(domRange) ? domRange.anchorNode : domRange.startContainer, anchorNode = null, anchorOffset = 0, focusNode = null, focusOffset = 0, isCollapsed = !1;
-		if (el) if (isDOMSelection(domRange)) {
-			if (IS_FIREFOX && domRange.rangeCount > 1) {
-				focusNode = domRange.focusNode;
-				let firstRange = domRange.getRangeAt(0), lastRange = domRange.getRangeAt(domRange.rangeCount - 1);
-				if (focusNode instanceof HTMLTableRowElement && firstRange.startContainer instanceof HTMLTableRowElement && lastRange.startContainer instanceof HTMLTableRowElement) {
-					let getLastChildren = (element) => element.childElementCount > 0 ? getLastChildren(element.children[0]) : element, firstNodeRow = firstRange.startContainer, lastNodeRow = lastRange.startContainer, firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]), lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]);
-					focusOffset = 0, anchorNode = lastNode.childNodes.length > 0 ? lastNode.childNodes[0] ?? null : lastNode, focusNode = firstNode.childNodes.length > 0 ? firstNode.childNodes[0] ?? null : firstNode, anchorOffset = lastNode instanceof HTMLElement ? lastNode.innerHTML.length : 0;
-				} else firstRange.startContainer === focusNode ? (anchorNode = lastRange.endContainer, anchorOffset = lastRange.endOffset, focusOffset = firstRange.startOffset) : (anchorNode = firstRange.startContainer, anchorOffset = firstRange.endOffset, focusOffset = lastRange.startOffset);
-			} else anchorNode = domRange.anchorNode, anchorOffset = domRange.anchorOffset, focusNode = domRange.focusNode, focusOffset = domRange.focusOffset;
-			isCollapsed = IS_CHROME && hasShadowRoot(anchorNode) || IS_FIREFOX ? domRange.anchorNode === domRange.focusNode && domRange.anchorOffset === domRange.focusOffset : domRange.isCollapsed;
-		} else anchorNode = domRange.startContainer, anchorOffset = domRange.startOffset, focusNode = domRange.endContainer, focusOffset = domRange.endOffset, isCollapsed = domRange.collapsed;
+		if (el) {
+			if (isDOMSelection(domRange)) {
+				if (IS_FIREFOX && domRange.rangeCount > 1) {
+					focusNode = domRange.focusNode;
+					let firstRange = domRange.getRangeAt(0), lastRange = domRange.getRangeAt(domRange.rangeCount - 1);
+					if (focusNode instanceof HTMLTableRowElement && firstRange.startContainer instanceof HTMLTableRowElement && lastRange.startContainer instanceof HTMLTableRowElement) {
+						let getLastChildren = (element) => element.childElementCount > 0 ? getLastChildren(element.children[0]) : element, firstNodeRow = firstRange.startContainer, lastNodeRow = lastRange.startContainer, firstNode = getLastChildren(firstNodeRow.children[firstRange.startOffset]), lastNode = getLastChildren(lastNodeRow.children[lastRange.startOffset]);
+						focusOffset = 0, anchorNode = lastNode.childNodes.length > 0 ? lastNode.childNodes[0] ?? null : lastNode, focusNode = firstNode.childNodes.length > 0 ? firstNode.childNodes[0] ?? null : firstNode, anchorOffset = lastNode instanceof HTMLElement ? lastNode.innerHTML.length : 0;
+					} else firstRange.startContainer === focusNode ? (anchorNode = lastRange.endContainer, anchorOffset = lastRange.endOffset, focusOffset = firstRange.startOffset) : (anchorNode = firstRange.startContainer, anchorOffset = firstRange.endOffset, focusOffset = lastRange.startOffset);
+				} else anchorNode = domRange.anchorNode, anchorOffset = domRange.anchorOffset, focusNode = domRange.focusNode, focusOffset = domRange.focusOffset;
+				isCollapsed = IS_CHROME && hasShadowRoot(anchorNode) || IS_FIREFOX ? domRange.anchorNode === domRange.focusNode && domRange.anchorOffset === domRange.focusOffset : domRange.isCollapsed;
+			} else anchorNode = domRange.startContainer, anchorOffset = domRange.startOffset, focusNode = domRange.endContainer, focusOffset = domRange.endOffset, isCollapsed = domRange.collapsed;
+		}
 		if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {
 			if (suppressThrow) return null;
 			throw Error(`Cannot map DOM range to an editor selection: ${domRange}`);
@@ -2863,12 +2865,14 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({ children }) => /* @__PU
 					exactMatch: !1,
 					suppressThrow: !0
 				});
-				if (range) if (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing()) {
-					if (editor.select(range), domSelection.isCollapsed && anchorNode && anchorNode.nodeType === Node.ELEMENT_NODE) try {
-						let canonicalRange = DOMEditor.toDOMRange(editor, range);
-						domSelection.setBaseAndExtent(canonicalRange.startContainer, canonicalRange.startOffset, canonicalRange.startContainer, canonicalRange.startOffset);
-					} catch {}
-				} else androidInputManager?.handleUserSelect(range);
+				if (range) {
+					if (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing()) {
+						if (editor.select(range), domSelection.isCollapsed && anchorNode && anchorNode.nodeType === Node.ELEMENT_NODE) try {
+							let canonicalRange = DOMEditor.toDOMRange(editor, range);
+							domSelection.setBaseAndExtent(canonicalRange.startContainer, canonicalRange.startOffset, canonicalRange.startContainer, canonicalRange.startOffset);
+						} catch {}
+					} else androidInputManager?.handleUserSelect(range);
+				}
 			}
 			readOnly && (!anchorNodeSelectable || !focusNodeInEditor) && deselect(editor);
 		}
@@ -5644,11 +5648,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[105] = editorActor, $[106] = editorEngine, $[107] = onDragStart, $[108] = readOnly, $[109] = t28) : t28 = $[109];
 	let handleDragStart = t28, t29;
 	$[110] !== editorActor || $[111] !== editorEngine || $[112] !== onDrag ? (t29 = (event_9) => {
-		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && getEventPosition({
-			editorActor,
-			editorEngine,
-			event: event_9.nativeEvent
-		})) return editorActor.send({
+		if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_9.target))) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.drag",
@@ -5671,17 +5671,17 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragEnd = t30, t31;
 	$[118] !== editorActor || $[119] !== editorEngine || $[120] !== onDragEnter ? (t31 = (event_11) => {
 		if (onDragEnter?.(event_11), event_11.isDefaultPrevented() || event_11.isPropagationStopped()) return;
-		let position_6 = getEventPosition({
+		let position_5 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_11.nativeEvent
 		});
-		if (position_6) return editorActor.send({
+		if (position_5) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragenter",
 				originEvent: { dataTransfer: event_11.dataTransfer },
-				position: position_6
+				position: position_5
 			},
 			editor: editorEngine
 		}), !0;
@@ -5689,18 +5689,18 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragEnter = t31, t32;
 	$[122] !== editorActor || $[123] !== editorEngine || $[124] !== onDragOver ? (t32 = (event_12) => {
 		if (onDragOver?.(event_12), event_12.isDefaultPrevented() || event_12.isPropagationStopped()) return;
-		let position_7 = getEventPosition({
+		let position_6 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_12.nativeEvent
 		});
-		if (position_7) return editorActor.send({
+		if (position_6) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragover",
 				originEvent: { dataTransfer: event_12.dataTransfer },
 				dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
-				position: position_7
+				position: position_6
 			},
 			editor: editorEngine,
 			nativeEvent: event_12
@@ -5709,12 +5709,12 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	let handleDragOver = t32, t33;
 	$[126] !== editorActor || $[127] !== editorEngine || $[128] !== onDrop ? (t33 = (event_13) => {
 		if (onDrop?.(event_13), event_13.isDefaultPrevented() || event_13.isPropagationStopped()) return;
-		let position_8 = getEventPosition({
+		let position_7 = getEventPosition({
 			editorActor,
 			editorEngine,
 			event: event_13.nativeEvent
 		});
-		if (!position_8) {
+		if (!position_7) {
 			console.warn("Could not find position for drop event");
 			return;
 		}
@@ -5724,7 +5724,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 				type: "drag.drop",
 				originEvent: { dataTransfer: event_13.dataTransfer },
 				dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
-				position: position_8
+				position: position_7
 			},
 			editor: editorEngine,
 			nativeEvent: event_13
@@ -5732,11 +5732,7 @@ const PortableTextEditable = forwardRef(function PortableTextEditable(props, for
 	}, $[126] = editorActor, $[127] = editorEngine, $[128] = onDrop, $[129] = t33) : t33 = $[129];
 	let handleDrop = t33, t34;
 	$[130] !== editorActor || $[131] !== editorEngine || $[132] !== onDragLeave ? (t34 = (event_14) => {
-		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && getEventPosition({
-			editorActor,
-			editorEngine,
-			event: event_14.nativeEvent
-		})) return editorActor.send({
+		if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped()) && !(editorActor.getSnapshot().matches({ setup: "setting up" }) || !DOMEditor.hasTarget(editorEngine, event_14.target))) return editorActor.send({
 			type: "behavior event",
 			behaviorEvent: {
 				type: "drag.dragleave",
@@ -6945,14 +6941,15 @@ function applyOperation(editor, op) {
 				typeof value == "object" && value && !Array.isArray(value) && modifyDescendant(editor, setNodePath, () => value), transformSelection = !0;
 				break;
 			}
-			if (getNode(editor.snapshot, setNodePath)) if (setPropertyPath.length === 1) {
-				let propertyName = setPropertyPath[0];
-				modifyDescendant(editor, setNodePath, (node) => ({
-					...node,
-					[propertyName]: value
-				}));
-			} else modifyDescendant(editor, setNodePath, (node) => deepSet(node, setPropertyPath, value));
-			else {
+			if (getNode(editor.snapshot, setNodePath)) {
+				if (setPropertyPath.length === 1) {
+					let propertyName = setPropertyPath[0];
+					modifyDescendant(editor, setNodePath, (node) => ({
+						...node,
+						[propertyName]: value
+					}));
+				} else modifyDescendant(editor, setNodePath, (node) => deepSet(node, setPropertyPath, value));
+			} else {
 				let blockSegment = findBlockSegment(path);
 				if (!blockSegment) break;
 				let blockIndex = resolveBlockIndex(editor, blockSegment);
@@ -7042,14 +7039,15 @@ function applyOperation(editor, op) {
 					value: previousValue
 				};
 			}
-			if (getNode(editor.snapshot, unsetNodePath)) if (unsetPropertyPath.length === 1) {
-				let propertyName = unsetPropertyPath[0];
-				modifyDescendant(editor, unsetNodePath, (node) => {
-					let newNode = { ...node };
-					return delete newNode[propertyName], newNode;
-				});
-			} else modifyDescendant(editor, unsetNodePath, (node) => deepUnset(node, unsetPropertyPath));
-			else {
+			if (getNode(editor.snapshot, unsetNodePath)) {
+				if (unsetPropertyPath.length === 1) {
+					let propertyName = unsetPropertyPath[0];
+					modifyDescendant(editor, unsetNodePath, (node) => {
+						let newNode = { ...node };
+						return delete newNode[propertyName], newNode;
+					});
+				} else modifyDescendant(editor, unsetNodePath, (node) => deepUnset(node, unsetPropertyPath));
+			} else {
 				let blockSegment = findBlockSegment(path);
 				if (!blockSegment) break;
 				let blockIndex = resolveBlockIndex(editor, blockSegment);
@@ -7253,23 +7251,25 @@ const apply$1 = (editor, op) => {
 	for (let ref of editor.pathRefs) PathRef.transform(ref, op);
 	for (let ref of editor.pointRefs) PointRef.transform(ref, op);
 	for (let ref of editor.rangeRefs) transformRangeRef(ref, op, editor.snapshot.context);
-	if (applyOperation(editor, op), updateDirtyPaths(editor, getDirtyPaths(editor.snapshot.context, op)), editor.operations.push(op), normalize(editor, { operation: op }), op.type === "set.selection") if (op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
-		let previousSelectionIsCollapsed = isCollapsedRange({
-			anchor: op.properties.anchor,
-			focus: op.properties.focus
-		}), newSelectionIsCollapsed = isCollapsedRange({
-			anchor: op.newProperties.anchor,
-			focus: op.newProperties.focus
-		});
-		if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-			let focusSpan = getSpan(editor.snapshot, op.properties.focus.path)?.node, newFocusSpan = getSpan(editor.snapshot, op.newProperties.focus.path)?.node, sameParent = pathEquals(parentPath(op.properties.focus.path), parentPath(op.newProperties.focus.path)), movedToNextSpan = !1, movedToPreviousSpan = !1;
-			if (sameParent && focusSpan && newFocusSpan) {
-				let nextSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "next" }), previousSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "previous" });
-				movedToNextSpan = nextSibling !== void 0 && pathEquals(nextSibling.path, op.newProperties.focus.path) && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = previousSibling !== void 0 && pathEquals(previousSibling.path, op.newProperties.focus.path) && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+	if (applyOperation(editor, op), updateDirtyPaths(editor, getDirtyPaths(editor.snapshot.context, op)), editor.operations.push(op), normalize(editor, { operation: op }), op.type === "set.selection") {
+		if (op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+			let previousSelectionIsCollapsed = isCollapsedRange({
+				anchor: op.properties.anchor,
+				focus: op.properties.focus
+			}), newSelectionIsCollapsed = isCollapsedRange({
+				anchor: op.newProperties.anchor,
+				focus: op.newProperties.focus
+			});
+			if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
+				let focusSpan = getSpan(editor.snapshot, op.properties.focus.path)?.node, newFocusSpan = getSpan(editor.snapshot, op.newProperties.focus.path)?.node, sameParent = pathEquals(parentPath(op.properties.focus.path), parentPath(op.newProperties.focus.path)), movedToNextSpan = !1, movedToPreviousSpan = !1;
+				if (sameParent && focusSpan && newFocusSpan) {
+					let nextSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "next" }), previousSibling = getSibling(editor.snapshot, op.properties.focus.path, { direction: "previous" });
+					movedToNextSpan = nextSibling !== void 0 && pathEquals(nextSibling.path, op.newProperties.focus.path) && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = previousSibling !== void 0 && pathEquals(previousSibling.path, op.newProperties.focus.path) && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+				}
+				!movedToNextSpan && !movedToPreviousSpan && (editor.snapshot.decoratorState = {});
 			}
-			!movedToNextSpan && !movedToPreviousSpan && (editor.snapshot.decoratorState = {});
-		}
-	} else editor.snapshot.decoratorState = {};
+		} else editor.snapshot.decoratorState = {};
+	}
 	editor.flushing || (editor.flushing = !0, Promise.resolve().then(() => {
 		editor.flushing = !1, editor.onChange({ operation: op }), editor.operations = [];
 	})), operationEvent && emitOperationEvent(editor.operationListeners.after, operationEvent);
@@ -7662,6 +7662,49 @@ function transformPointForMerge(point, mergePath, prevKey, position) {
 	};
 }
 /**
+* Apply property changes at a known path using primitive `set` and `unset`
+* operations.
+*
+* Properties set to `null` are treated as deletions.
+* When `_key` is among the properties, it is processed first so that
+* downstream patch consumers see the key change before any property
+* mutations that reference the new key.
+*/
+function applyNodeProperties(editor, props, path) {
+	let result = resolveNode(editor.snapshot, path);
+	if (result.status === "unreachable") throw Error(`Unable to apply properties at structurally unreachable path ${safeStringify(path)}`);
+	if (result.status === "missing") return;
+	let nodeRecord = result.entry.node, propsRecord = props, keys = Object.keys(propsRecord), keyIndex = keys.indexOf("_key");
+	keyIndex !== -1 && (keys.splice(keyIndex, 1), keys.unshift("_key"));
+	let currentPath = path;
+	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) {
+		if (propsRecord[key] != null) {
+			let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
+			editor.apply({
+				type: "set",
+				path: [...currentPath, key],
+				value: propsRecord[key],
+				inverse: hadProperty ? {
+					type: "set",
+					path: inversePath,
+					value: nodeRecord[key]
+				} : {
+					type: "unset",
+					path: inversePath
+				}
+			}), renamedPath && (currentPath = renamedPath);
+		} else nodeRecord.hasOwnProperty(key) && editor.apply({
+			type: "unset",
+			path: [...currentPath, key],
+			inverse: {
+				type: "set",
+				path: [...currentPath, key],
+				value: nodeRecord[key]
+			}
+		});
+	}
+}
+/**
 * Create a placeholder text block -- the empty initial block used when the
 * editor value is empty or when a container needs a default child.
 *
@@ -7689,46 +7732,6 @@ function resolveDefaultStyle(snapshot, path) {
 	return path ? getPathSubSchema(snapshot, path).styles[0]?.name ?? rootFallback : rootFallback;
 }
 /**
-* Apply property changes at a known path using primitive `set` and `unset`
-* operations.
-*
-* Properties set to `null` are treated as deletions.
-* When `_key` is among the properties, it is processed first so that
-* downstream patch consumers see the key change before any property
-* mutations that reference the new key.
-*/
-function setNodeProperties(editor, props, path) {
-	let nodeEntry = getNode(editor.snapshot, path);
-	if (!nodeEntry) return;
-	let nodeRecord = nodeEntry.node, propsRecord = props, keys = Object.keys(propsRecord), keyIndex = keys.indexOf("_key");
-	keyIndex !== -1 && (keys.splice(keyIndex, 1), keys.unshift("_key"));
-	let currentPath = path;
-	for (let key of keys) if (propsRecord[key] !== nodeRecord[key]) if (propsRecord[key] != null) {
-		let hadProperty = nodeRecord.hasOwnProperty(key), lastSegment = currentPath[currentPath.length - 1], renamedPath = key === "_key" && typeof propsRecord[key] == "string" && isKeyedSegment(lastSegment) ? [...currentPath.slice(0, -1), { _key: propsRecord[key] }] : void 0, inversePath = renamedPath ? [...renamedPath, key] : [...currentPath, key];
-		editor.apply({
-			type: "set",
-			path: [...currentPath, key],
-			value: propsRecord[key],
-			inverse: hadProperty ? {
-				type: "set",
-				path: inversePath,
-				value: nodeRecord[key]
-			} : {
-				type: "unset",
-				path: inversePath
-			}
-		}), renamedPath && (currentPath = renamedPath);
-	} else nodeRecord.hasOwnProperty(key) && editor.apply({
-		type: "unset",
-		path: [...currentPath, key],
-		inverse: {
-			type: "set",
-			path: [...currentPath, key],
-			value: nodeRecord[key]
-		}
-	});
-}
-/**
 * Read the `_type` from a pre-resolved `of` entry.
 */
 function entryType(entry) {
@@ -7818,7 +7821,7 @@ function richDescentToParent(input, path) {
 * 3. **Global fallback with position-validity.** Falls back to the
 *    top-level rich `containers` map keyed by `_type`. Activates only
 *    when schema-at-position permits the registered `arrayField`
-*    (for containers) or simply declares `_type` (for leaves).
+*    (for containers) or declares `_type` (for leaves).
 *    Registration is type-keyed; activation is position-gated.
 */
 function resolveContainerByPath(input, path, node) {
@@ -7959,7 +7962,7 @@ const normalizeNode = (editor, entry) => {
 	* Add missing .markDefs to text block nodes
 	*/
 	if (!editor.isProcessingRemoteChanges && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.markDefs)) {
-		debug.normalization("adding .markDefs to block node"), setNodeProperties(editor, { markDefs: [] }, path);
+		debug.normalization("adding .markDefs to block node"), applyNodeProperties(editor, { markDefs: [] }, path);
 		return;
 	}
 	/**
@@ -7968,7 +7971,7 @@ const normalizeNode = (editor, entry) => {
 	if (!editor.isProcessingRemoteChanges && isTextBlockNode({ schema: editor.snapshot.context.schema }, node) && node.style === void 0) {
 		let defaultStyle = getPathSubSchema(editor.snapshot, path).styles.at(0)?.name;
 		if (defaultStyle) {
-			debug.normalization("adding .style to block node"), setNodeProperties(editor, { style: defaultStyle }, path);
+			debug.normalization("adding .style to block node"), applyNodeProperties(editor, { style: defaultStyle }, path);
 			return;
 		}
 	}
@@ -7991,7 +7994,7 @@ const normalizeNode = (editor, entry) => {
 	* Add missing .marks to span nodes
 	*/
 	if (!editor.isProcessingRemoteChanges && isSpan({ schema: editor.snapshot.context.schema }, node) && !Array.isArray(node.marks)) {
-		debug.normalization("Adding .marks to span node"), setNodeProperties(editor, { marks: [] }, path);
+		debug.normalization("Adding .marks to span node"), applyNodeProperties(editor, { marks: [] }, path);
 		return;
 	}
 	/**
@@ -8002,7 +8005,7 @@ const normalizeNode = (editor, entry) => {
 		if (!blockEntry) return;
 		let annotations = node.marks?.filter((mark) => blockEntry.node.markDefs?.some((markDef) => markDef._key === mark));
 		if (node.text === "" && annotations && annotations.length > 0) {
-			debug.normalization("removing annotations from empty span node"), setNodeProperties(editor, { marks: node.marks?.filter((mark) => !annotations.includes(mark)) }, path);
+			debug.normalization("removing annotations from empty span node"), applyNodeProperties(editor, { marks: node.marks?.filter((mark) => !annotations.includes(mark)) }, path);
 			return;
 		}
 	}
@@ -8013,7 +8016,7 @@ const normalizeNode = (editor, entry) => {
 		let markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
 		for (let markDef of markDefs) markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
 		if (markDefs.length !== newMarkDefs.length) {
-			debug.normalization("removing duplicate markDefs"), setNodeProperties(editor, { markDefs: newMarkDefs }, path);
+			debug.normalization("removing duplicate markDefs"), applyNodeProperties(editor, { markDefs: newMarkDefs }, path);
 			return;
 		}
 	}
@@ -8023,7 +8026,7 @@ const normalizeNode = (editor, entry) => {
 	if (!editor.isProcessingRemoteChanges && isTextBlock({ schema: editor.snapshot.context.schema }, node)) {
 		let newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => isSpan({ schema: editor.snapshot.context.schema }, child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
 		if (node.markDefs && !isEqualMarkDefs(newMarkDefs, node.markDefs)) {
-			debug.normalization("removing markDef not in use"), setNodeProperties(editor, { markDefs: newMarkDefs }, path);
+			debug.normalization("removing markDef not in use"), applyNodeProperties(editor, { markDefs: newMarkDefs }, path);
 			return;
 		}
 	}
@@ -8063,11 +8066,11 @@ const normalizeNode = (editor, entry) => {
 					_type: firstChildType.type === "object" && "name" in firstChildType ? firstChildType.name : firstChildType.type,
 					_key: editor.snapshot.context.keyGenerator()
 				}), needsField && childNode) {
-					setNodeProperties(editor, { [arrayField.name]: [childNode] }, path);
+					applyNodeProperties(editor, { [arrayField.name]: [childNode] }, path);
 					return;
 				}
 				if (needsField) {
-					setNodeProperties(editor, { [arrayField.name]: [] }, path);
+					applyNodeProperties(editor, { [arrayField.name]: [] }, path);
 					return;
 				}
 				if (childNode) {
@@ -8758,8 +8761,10 @@ function bitap(text, pattern, loc, opts = {}) {
 			let charMatch = s[text.charAt(j - 1)];
 			if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | (lastRd[j + 1] | lastRd[j]) << 1 | 1 | lastRd[j + 1], rd[j] & matchmask) {
 				let score = getBitapScore(d, j - 1);
-				if (score <= scoreThreshold) if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
-				else break;
+				if (score <= scoreThreshold) {
+					if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc) start = Math.max(1, 2 * loc - bestLoc);
+					else break;
+				}
 			}
 		}
 		if (getBitapScore(d + 1, loc) > scoreThreshold) break;
@@ -10386,9 +10391,9 @@ function isBlockLike(value) {
 * drag origin in a way that would make the drop a no-op.
 *
 * Two expanded selections that only touch at a single endpoint are not treated
-* as a self-drop — the drop position covers an adjacent block (typical when
+* as a self-drop: the drop position covers an adjacent block (typical when
 * dragging a block-object onto the next block via the expanded fallback in
-* `getEventPosition`), and the user genuinely wants the drop to happen.
+* `getEventPosition`), so the drop should go through.
 *
 * Chrome drags emit a collapsed selection pointing AT the dragged container.
 * A drop position whose path descends into that container is dropping the
@@ -11189,7 +11194,7 @@ const addAnnotationOperationImplementation = ({ snapshot, operation }) => {
 		for (let { node: block, path: blockPath } of selectedBlocks) {
 			if (!isTextBlock({ schema: editor.snapshot.context.schema }, block) || block.children.length === 0 || block.children.length === 1 && block.children[0]?.text === "" || !getPathSubSchema(snapshot, blockPath).annotations.some((annotation) => annotation.name === parsedAnnotation._type)) continue;
 			let annotationKey = blockIndex === 0 ? parsedAnnotation._key : context.keyGenerator(), markDefs = block.markDefs ?? [];
-			markDefs.find((markDef) => markDef._type === parsedAnnotation._type && markDef._key === annotationKey) === void 0 && setNodeProperties(editor, { markDefs: [...markDefs, {
+			markDefs.find((markDef) => markDef._type === parsedAnnotation._type && markDef._key === annotationKey) === void 0 && applyNodeProperties(editor, { markDefs: [...markDefs, {
 				...parsedAnnotation,
 				_key: annotationKey
 			}] }, blockPath);
@@ -11207,7 +11212,7 @@ const addAnnotationOperationImplementation = ({ snapshot, operation }) => {
 			for (let { node: span, path: spanPath } of children) {
 				if (!isSpan({ schema: editor.snapshot.context.schema }, span) || !selectionRange || !rangeIntersects(editor.snapshot, selectionRange, spanPath)) continue;
 				let marks = span.marks ?? [];
-				setNodeProperties(editor, { marks: [...marks, annotationKey] }, spanPath);
+				applyNodeProperties(editor, { marks: [...marks, annotationKey] }, spanPath);
 			}
 			blockIndex++;
 		}
@@ -11221,59 +11226,65 @@ function isBeforePath(path, another, root) {
 }
 const removeAnnotationOperationImplementation = ({ snapshot, operation }) => {
 	let editor = operation.editor, at = operation.at ? resolveSelection(operation.editor, operation.at) : null, effectiveSelection = at ?? editor.snapshot.context.selection;
-	if (effectiveSelection) if (isCollapsedRange(effectiveSelection)) {
-		let blockEntry = getParent(snapshot, effectiveSelection.focus.path, { match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node) });
-		if (!blockEntry) return;
-		let { node: block, path: blockPath } = blockEntry, potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), selectedChildEntry = getNode(editor.snapshot, effectiveSelection.focus.path);
-		if (!selectedChildEntry) return;
-		let { node: selectedChild, path: selectedChildPath } = selectedChildEntry;
-		if (!isSpan({ schema: editor.snapshot.context.schema }, selectedChild)) return;
-		let annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
-		if (!annotationToRemove) return;
-		let previousSpansWithSameAnnotation = [], reversedChildren = getChildren(editor.snapshot, blockPath);
-		for (let index = reversedChildren.length - 1; index >= 0; index--) {
-			let entry = reversedChildren[index];
-			if (!entry) continue;
-			let { node: child, path: childPath } = entry;
-			if (isSpan({ schema: editor.snapshot.context.schema }, child) && isBeforePath(childPath, selectedChildPath, editor.snapshot.context)) if (child.marks?.includes(annotationToRemove)) previousSpansWithSameAnnotation.push([child, childPath]);
-			else break;
-		}
-		let nextSpansWithSameAnnotation = [];
-		for (let { node: child, path: childPath } of getChildren(editor.snapshot, blockPath)) if (isSpan({ schema: editor.snapshot.context.schema }, child) && isAfterPath(childPath, selectedChildPath, editor.snapshot.context)) if (child.marks?.includes(annotationToRemove)) nextSpansWithSameAnnotation.push([child, childPath]);
-		else break;
-		for (let [child, childPath] of [
-			...previousSpansWithSameAnnotation,
-			[selectedChild, selectedChildPath],
-			...nextSpansWithSameAnnotation
-		]) setNodeProperties(editor, { marks: child.marks?.filter((mark) => mark !== annotationToRemove) }, childPath);
-	} else {
-		let ref = at ? rangeRef(editor, at, { affinity: "inward" }) : null;
-		withoutNormalizing(editor, () => {
-			let splitRange = at ?? editor.snapshot.context.selection;
-			if (splitRange && isRange(splitRange)) {
-				let splitLeaf = getNode(editor.snapshot, splitRange.anchor.path)?.node;
-				if (!(splitLeaf && isCollapsedRange(splitRange) && isSpan({ schema: editor.snapshot.context.schema }, splitLeaf) && splitLeaf.text.length > 0)) {
-					let splitRangeRef = rangeRef(editor, splitRange, { affinity: "inward" }), [splitStart, splitEnd] = rangeEdges(splitRange, editor.snapshot.context);
-					(!isEnd(editor, splitEnd, splitEnd.path) || !isEdge(editor, splitEnd, splitEnd.path)) && applySplitNode(editor, splitEnd.path, splitEnd.offset), (!isStart(editor, splitStart, splitStart.path) || !isEdge(editor, splitStart, splitStart.path)) && applySplitNode(editor, splitStart.path, splitStart.offset);
-					let updatedSplitRange = splitRangeRef.unref();
-					!at && updatedSplitRange && applySelect(editor, updatedSplitRange);
+	if (effectiveSelection) {
+		if (isCollapsedRange(effectiveSelection)) {
+			let blockEntry = getParent(snapshot, effectiveSelection.focus.path, { match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node) });
+			if (!blockEntry) return;
+			let { node: block, path: blockPath } = blockEntry, potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), selectedChildEntry = getNode(editor.snapshot, effectiveSelection.focus.path);
+			if (!selectedChildEntry) return;
+			let { node: selectedChild, path: selectedChildPath } = selectedChildEntry;
+			if (!isSpan({ schema: editor.snapshot.context.schema }, selectedChild)) return;
+			let annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
+			if (!annotationToRemove) return;
+			let previousSpansWithSameAnnotation = [], reversedChildren = getChildren(editor.snapshot, blockPath);
+			for (let index = reversedChildren.length - 1; index >= 0; index--) {
+				let entry = reversedChildren[index];
+				if (!entry) continue;
+				let { node: child, path: childPath } = entry;
+				if (isSpan({ schema: editor.snapshot.context.schema }, child) && isBeforePath(childPath, selectedChildPath, editor.snapshot.context)) {
+					if (child.marks?.includes(annotationToRemove)) previousSpansWithSameAnnotation.push([child, childPath]);
+					else break;
 				}
 			}
-			let blocks = Array.from(getNodes(editor.snapshot, {
-				from: rangeStart(effectiveSelection, editor.snapshot.context).path,
-				to: rangeEnd(effectiveSelection, editor.snapshot.context).path,
-				match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node)
-			})), selectionRange = ref?.current ?? editor.snapshot.context.selection;
-			for (let { node: block, path: blockPath } of blocks) {
-				if (!isTextBlock({ schema: editor.snapshot.context.schema }, block)) continue;
-				let children = getChildren(editor.snapshot, blockPath);
-				for (let { node: child, path: childPath } of children) {
-					if (!isSpan({ schema: editor.snapshot.context.schema }, child) || !selectionRange || !rangeIntersects(editor.snapshot, selectionRange, childPath)) continue;
-					let markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef) => markDef._key === mark)?._type !== operation.annotation.name);
-					marksWithoutAnnotation.length !== marks.length && setNodeProperties(editor, { marks: marksWithoutAnnotation }, childPath);
-				}
+			let nextSpansWithSameAnnotation = [];
+			for (let { node: child, path: childPath } of getChildren(editor.snapshot, blockPath)) if (isSpan({ schema: editor.snapshot.context.schema }, child) && isAfterPath(childPath, selectedChildPath, editor.snapshot.context)) {
+				if (child.marks?.includes(annotationToRemove)) nextSpansWithSameAnnotation.push([child, childPath]);
+				else break;
 			}
-		}), ref?.unref();
+			for (let [child, childPath] of [
+				...previousSpansWithSameAnnotation,
+				[selectedChild, selectedChildPath],
+				...nextSpansWithSameAnnotation
+			]) applyNodeProperties(editor, { marks: child.marks?.filter((mark) => mark !== annotationToRemove) }, childPath);
+		} else {
+			let ref = at ? rangeRef(editor, at, { affinity: "inward" }) : null;
+			withoutNormalizing(editor, () => {
+				let splitRange = at ?? editor.snapshot.context.selection;
+				if (splitRange && isRange(splitRange)) {
+					let splitLeaf = getNode(editor.snapshot, splitRange.anchor.path)?.node;
+					if (!(splitLeaf && isCollapsedRange(splitRange) && isSpan({ schema: editor.snapshot.context.schema }, splitLeaf) && splitLeaf.text.length > 0)) {
+						let splitRangeRef = rangeRef(editor, splitRange, { affinity: "inward" }), [splitStart, splitEnd] = rangeEdges(splitRange, editor.snapshot.context);
+						(!isEnd(editor, splitEnd, splitEnd.path) || !isEdge(editor, splitEnd, splitEnd.path)) && applySplitNode(editor, splitEnd.path, splitEnd.offset), (!isStart(editor, splitStart, splitStart.path) || !isEdge(editor, splitStart, splitStart.path)) && applySplitNode(editor, splitStart.path, splitStart.offset);
+						let updatedSplitRange = splitRangeRef.unref();
+						!at && updatedSplitRange && applySelect(editor, updatedSplitRange);
+					}
+				}
+				let blocks = Array.from(getNodes(editor.snapshot, {
+					from: rangeStart(effectiveSelection, editor.snapshot.context).path,
+					to: rangeEnd(effectiveSelection, editor.snapshot.context).path,
+					match: (node) => isTextBlock({ schema: editor.snapshot.context.schema }, node)
+				})), selectionRange = ref?.current ?? editor.snapshot.context.selection;
+				for (let { node: block, path: blockPath } of blocks) {
+					if (!isTextBlock({ schema: editor.snapshot.context.schema }, block)) continue;
+					let children = getChildren(editor.snapshot, blockPath);
+					for (let { node: child, path: childPath } of children) {
+						if (!isSpan({ schema: editor.snapshot.context.schema }, child) || !selectionRange || !rangeIntersects(editor.snapshot, selectionRange, childPath)) continue;
+						let markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef) => markDef._key === mark)?._type !== operation.annotation.name);
+						marksWithoutAnnotation.length !== marks.length && applyNodeProperties(editor, { marks: marksWithoutAnnotation }, childPath);
+					}
+				}
+			}), ref?.unref();
+		}
 	}
 };
 /**
@@ -11333,7 +11344,7 @@ const blockSetOperationImplementation = ({ snapshot, operation }) => {
 			}
 			context.schema.block.fields?.some((field) => field.name === key) && (filteredProps[key] = operation.props[key]);
 		}
-		setNodeProperties(operation.editor, filteredProps, blockEntry.path);
+		applyNodeProperties(operation.editor, filteredProps, blockEntry.path);
 	} else {
 		let schemaDefinition = getBlockObjectSchema(snapshot, engineBlock, blockEntry.path), filteredProps = {};
 		for (let key of Object.keys(operation.props)) if (key !== "_type") {
@@ -11344,7 +11355,7 @@ const blockSetOperationImplementation = ({ snapshot, operation }) => {
 			schemaDefinition?.fields?.some((field) => field.name === key) && (filteredProps[key] = operation.props[key]);
 		}
 		let patches = Object.entries(filteredProps).map(([key, value]) => set(value, [key])), updatedEngineBlock = applyAll(engineBlock, patches);
-		setNodeProperties(operation.editor, updatedEngineBlock, blockEntry.path);
+		applyNodeProperties(operation.editor, updatedEngineBlock, blockEntry.path);
 	}
 }, blockUnsetOperationImplementation = ({ snapshot, operation }) => {
 	let { context } = snapshot, blockEntry = getNode(operation.editor.snapshot, operation.at);
@@ -11353,12 +11364,12 @@ const blockSetOperationImplementation = ({ snapshot, operation }) => {
 	if (isTextBlockNode(context, engineBlock)) {
 		let propsToRemove = operation.props.filter((prop) => prop !== "_type" && prop !== "_key"), unsetProps = {};
 		for (let prop of propsToRemove) unsetProps[prop] = null;
-		setNodeProperties(operation.editor, unsetProps, blockEntry.path), operation.props.includes("_key") && setNodeProperties(operation.editor, { _key: context.keyGenerator() }, blockEntry.path);
+		applyNodeProperties(operation.editor, unsetProps, blockEntry.path), operation.props.includes("_key") && applyNodeProperties(operation.editor, { _key: context.keyGenerator() }, blockEntry.path);
 		return;
 	}
 	let unsetProps = {};
 	for (let key of operation.props) key !== "_type" && (key === "_key" ? unsetProps._key = context.keyGenerator() : unsetProps[key] = null);
-	setNodeProperties(operation.editor, unsetProps, blockEntry.path);
+	applyNodeProperties(operation.editor, unsetProps, blockEntry.path);
 };
 /**
 * Compute the canonical path that a new node will have when inserted as a
@@ -11385,7 +11396,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 	let { node: child, path: childPath } = childEntry;
 	if (isSpan({ schema: operation.editor.snapshot.context.schema }, child)) {
 		let { _type, text, ...rest } = operation.props;
-		setNodeProperties(operation.editor, {
+		applyNodeProperties(operation.editor, {
 			...child,
 			...rest
 		}, childPath);
@@ -11408,7 +11419,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 		if (!definition) return;
 		let { _type, _key, ...rest } = operation.props;
 		for (let prop in rest) definition.fields.some((field) => field.name === prop) || delete rest[prop];
-		setNodeProperties(operation.editor, {
+		applyNodeProperties(operation.editor, {
 			...child,
 			_key: typeof _key == "string" ? _key : child._key,
 			...rest
@@ -11429,13 +11440,13 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 			}
 			newNode[prop] = null;
 		}
-		setNodeProperties(operation.editor, newNode, childPath);
+		applyNodeProperties(operation.editor, newNode, childPath);
 		return;
 	}
 	if (isObject(operation.editor.snapshot, child)) {
 		let unsetProps = {};
 		for (let prop of operation.props) prop !== "_type" && (prop === "_key" ? unsetProps._key = context.keyGenerator() : unsetProps[prop] = null);
-		setNodeProperties(operation.editor, unsetProps, childPath);
+		applyNodeProperties(operation.editor, unsetProps, childPath);
 		return;
 	}
 	throw Error(`Unable to determine the type of child at ${safeStringify(operation.at)}`);
@@ -11458,7 +11469,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 					let blockPath = parentPath(spanPath);
 					if (!getPathSubSchema(snapshot, blockPath).decorators.some((decorator) => decorator.name === mark)) continue;
 					let marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
-					setNodeProperties(editor, { marks }, spanPath);
+					applyNodeProperties(editor, { marks }, spanPath);
 				}
 			});
 		} else {
@@ -11477,7 +11488,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 				for (let { path: spanPath } of Array.from(getNodes(editor.snapshot, {
 					at: blockPath,
 					match: (node) => isSpan({ schema: editor.snapshot.context.schema }, node)
-				}))) setNodeProperties(editor, { marks: newMarks }, spanPath);
+				}))) applyNodeProperties(editor, { marks: newMarks }, spanPath);
 			} else editor.snapshot.decoratorState[mark] = !0;
 		}
 		if (editor.snapshot.context.selection) {
@@ -11506,7 +11517,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 					for (let { node, path: nodePath } of splitTextNodes) {
 						if (!isSpan({ schema: editor.snapshot.context.schema }, node)) continue;
 						let blockPath = parentPath(nodePath), block = getNode(editor.snapshot, blockPath)?.node;
-						isTextBlock({ schema: editor.snapshot.context.schema }, block) && block.children.includes(node) && setNodeProperties(editor, {
+						isTextBlock({ schema: editor.snapshot.context.schema }, block) && block.children.includes(node) && applyNodeProperties(editor, {
 							marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
 							_type: context.schema.span.name
 						}, nodePath);
@@ -11522,7 +11533,7 @@ const childSetOperationImplementation = ({ snapshot, operation }) => {
 				for (let { path: spanPath } of Array.from(getNodes(editor.snapshot, {
 					at: blockPath,
 					match: (node) => isSpan({ schema: editor.snapshot.context.schema }, node)
-				}))) setNodeProperties(editor, { marks: existingMarksWithoutDecorator }, spanPath);
+				}))) applyNodeProperties(editor, { marks: existingMarksWithoutDecorator }, spanPath);
 			} else editor.snapshot.decoratorState[mark] = !1;
 		}
 		if (editor.snapshot.context.selection) {
@@ -11637,21 +11648,31 @@ function fieldAcceptsTextBlock(editor, node, _path) {
 * `destinationBlock` by key. Any child key the merging block shares with
 * the destination has to be renamed before the merge, or the engine's own
 * collision handling mints a fresh key for it, which reads on the wire as
-* that node being destroyed and a new one created instead of moved. There
-* is no such backstop for markDefs: an unrenamed collision either loses
-* one of the two defs to last-wins replacement, or, on the `insert.block`
-* path, gets silently re-minted by `adjustFragmentKeys` (see
-* `dedupeEqualMarkDefs` below).
+* that node being destroyed and a new one created instead of moved.
+*
+* A colliding markDef that is deeply equal to the destination's is left
+* unrenamed and reported in `dedupedMarkDefKeys` instead: the merge keeps
+* a single copy under the original `_key` rather than duplicating
+* identical content under two keys. A colliding markDef that differs gets
+* renamed like a child would.
+*
+* `renamedBlock` keeps every deduped def in its own `markDefs`, even
+* though the destination already carries it: `renamedBlock` feeds
+* `insert.block` on some callers' paths, and that path parses the block
+* standalone, stripping any mark that doesn't resolve in the block's own
+* `markDefs`. A caller that appends `renamedBlock.markDefs` onto the
+* destination's must skip the keys listed in `dedupedMarkDefKeys`, or the
+* def duplicates.
 *
 * Pure: computes the renames and the block they produce without touching
 * an editor. Callers raise or apply the renames themselves, ahead of the
 * merge, against the still-living `mergingBlock`.
 */
 function planMergeKeyRenames(args) {
-	let { context, mergingBlock, destinationBlock, dedupeEqualMarkDefs } = args, destinationChildKeys = new Set(destinationBlock.children.map((child) => child._key)), destinationMarkDefsByKey = new Map((destinationBlock.markDefs ?? []).map((markDef) => [markDef._key, markDef])), markDefKeyMap = /* @__PURE__ */ new Map(), renamedMarkDefs = mergingBlock.markDefs?.flatMap((markDef) => {
+	let { context, mergingBlock, destinationBlock } = args, destinationChildKeys = new Set(destinationBlock.children.map((child) => child._key)), destinationMarkDefsByKey = new Map((destinationBlock.markDefs ?? []).map((markDef) => [markDef._key, markDef])), markDefKeyMap = /* @__PURE__ */ new Map(), dedupedMarkDefKeys = [], renamedMarkDefs = mergingBlock.markDefs?.flatMap((markDef) => {
 		let destinationMarkDef = destinationMarkDefsByKey.get(markDef._key);
 		if (!destinationMarkDef) return [markDef];
-		if (dedupeEqualMarkDefs && isDeepEqual(markDef, destinationMarkDef)) return [];
+		if (isDeepEqual(markDef, destinationMarkDef)) return dedupedMarkDefKeys.push(markDef._key), [markDef];
 		let newKey = context.keyGenerator();
 		return markDefKeyMap.set(markDef._key, newKey), [{
 			...markDef,
@@ -11686,7 +11707,8 @@ function planMergeKeyRenames(args) {
 			...mergingBlock.markDefs ? { markDefs: renamedMarkDefs } : {}
 		},
 		childRenames,
-		markDefRenames
+		markDefRenames,
+		dedupedMarkDefKeys
 	};
 }
 /**
@@ -12022,11 +12044,10 @@ function mergeBlock(editor, startBlockPath, endBlockPath, removeEmptyStartBlock)
 		removeNodeAt(editor, startBlockPath);
 		return;
 	}
-	let { renamedBlock, childRenames, markDefRenames } = planMergeKeyRenames({
+	let { renamedBlock, childRenames, markDefRenames, dedupedMarkDefKeys } = planMergeKeyRenames({
 		context: editor.snapshot.context,
 		mergingBlock: endBlock.node,
-		destinationBlock: startBlock.node,
-		dedupeEqualMarkDefs: !0
+		destinationBlock: startBlock.node
 	});
 	for (let { markDefKey, newKey } of markDefRenames) editor.apply({
 		type: "set",
@@ -12038,13 +12059,13 @@ function mergeBlock(editor, startBlockPath, endBlockPath, removeEmptyStartBlock)
 		],
 		value: newKey
 	});
-	for (let { childKey, props } of childRenames) setNodeProperties(editor, props, [
+	for (let { childKey, props } of childRenames) applyNodeProperties(editor, props, [
 		...endBlockPath,
 		"children",
 		{ _key: childKey }
 	]);
-	let endMarkDefs = renamedBlock.markDefs;
-	Array.isArray(endMarkDefs) && endMarkDefs.length > 0 && setNodeProperties(editor, { markDefs: [...startBlock.node.markDefs ?? [], ...endMarkDefs] }, startBlockPath), applyMergeNode(editor, endBlockPath, startBlock.node.children.length);
+	let endMarkDefs = renamedBlock.markDefs?.filter((markDef) => !dedupedMarkDefKeys.includes(markDef._key));
+	Array.isArray(endMarkDefs) && endMarkDefs.length > 0 && applyNodeProperties(editor, { markDefs: [...startBlock.node.markDefs ?? [], ...endMarkDefs] }, startBlockPath), applyMergeNode(editor, endBlockPath, startBlock.node.children.length);
 }
 function removeNodeAt(editor, path) {
 	getNode(editor.snapshot, path) && editor.apply({
@@ -12733,7 +12754,7 @@ function mergeTextBlockFragment(args) {
 		block,
 		endBlock
 	});
-	setNodeProperties(editor, { markDefs: [...endBlock.markDefs ?? [], ...adjustedMarkDefs ?? []] }, endBlockPath);
+	applyNodeProperties(editor, { markDefs: [...endBlock.markDefs ?? [], ...adjustedMarkDefs ?? []] }, endBlockPath);
 	let atPathRef = pathRef(editor, at.path), atBlockStart = pointEquals(at, start(editor, endBlockPath)), firstInsertedKey = insertFragmentChildren(editor, adjustedBlock, at), resolvedAtPath = atPathRef.unref();
 	if (select === "none") {
 		(wasCrossBlock || !atBlockStart) && applySelect(editor, at);
@@ -12841,8 +12862,12 @@ function resolveChildIndex(children, segment) {
 }
 /**
 * Reassign keys on spans, inline objects and markDefs that collide with the
-* end block's existing keys. Returns the adjusted block and the adjusted
-* markDefs (to be merged into the end block).
+* end block's existing keys. A colliding markDef that is deeply equal to
+* the end block's is left out of the returned `adjustedMarkDefs` instead
+* of renamed, since the end block already carries it; its key isn't
+* remapped, so the fragment's marks keep pointing at it unchanged. The
+* caller must merge the returned `adjustedMarkDefs` into the end block's
+* own `markDefs`, or the deduped defs are lost.
 */
 function adjustFragmentKeys(args) {
 	let { context, block, endBlock } = args;
@@ -12854,15 +12879,15 @@ function adjustFragmentKeys(args) {
 		adjustedBlock: block,
 		adjustedMarkDefs: block.markDefs
 	};
-	let endBlockChildKeys = endBlock.children.map((child) => child._key), endBlockMarkDefsKeys = endBlock.markDefs?.map((markDef) => markDef._key) ?? [], markDefKeyMap = /* @__PURE__ */ new Map(), adjustedMarkDefs = block.markDefs?.map((markDef) => {
-		if (endBlockMarkDefsKeys.includes(markDef._key)) {
-			let newKey = context.keyGenerator();
-			return markDefKeyMap.set(markDef._key, newKey), {
-				...markDef,
-				_key: newKey
-			};
-		}
-		return markDef;
+	let endBlockChildKeys = endBlock.children.map((child) => child._key), endBlockMarkDefsByKey = new Map((endBlock.markDefs ?? []).map((markDef) => [markDef._key, markDef])), markDefKeyMap = /* @__PURE__ */ new Map(), adjustedMarkDefs = block.markDefs?.flatMap((markDef) => {
+		let endBlockMarkDef = endBlockMarkDefsByKey.get(markDef._key);
+		if (!endBlockMarkDef) return [markDef];
+		if (isDeepEqual(markDef, endBlockMarkDef)) return [];
+		let newKey = context.keyGenerator();
+		return markDefKeyMap.set(markDef._key, newKey), [{
+			...markDef,
+			_key: newKey
+		}];
 	}), adjustedChildren = block.children.map((child) => {
 		if (isSpan(context, child)) {
 			let marks = child.marks?.map((mark) => markDefKeyMap.get(mark) ?? mark) ?? [];
@@ -12999,12 +13024,13 @@ const insertChildOperationImplementation = ({ snapshot, operation }) => {
 	let node = nodeEntry.node;
 	if (isLeafObject(editor.snapshot, node, nodeEntry.path)) {
 		let nextSibling = getSibling(editor.snapshot, nodeEntry.path, { direction: "next" });
-		if (nextSibling) if (getSpan(editor.snapshot, nextSibling.path)) path = nextSibling.path, offset = 0, applySelect(editor, {
-			path,
-			offset
-		});
-		else return;
-		else return;
+		if (nextSibling) {
+			if (getSpan(editor.snapshot, nextSibling.path)) path = nextSibling.path, offset = 0, applySelect(editor, {
+				path,
+				offset
+			});
+			else return;
+		} else return;
 	}
 	operation.text.length > 0 && editor.apply({
 		type: "insert.text",
@@ -13437,8 +13463,7 @@ function planMergeKeyRenameActions(args) {
 	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, { renamedBlock, childRenames, markDefRenames } = planMergeKeyRenames({
 		context,
 		mergingBlock,
-		destinationBlock,
-		dedupeEqualMarkDefs: !1
+		destinationBlock
 	}), renameActions = [];
 	for (let { markDefKey, newKey } of markDefRenames) renameActions.push(raise$1({
 		type: "set",
@@ -16128,49 +16153,51 @@ async function updateValue({ context, sendBack, editorEngine, streamBlocks, valu
 	if ((!value || value.length === 0) && (clearEditor({
 		editorEngine,
 		doneSyncing
-	}), isChanged = !0), value && value.length > 0) if (streamBlocks) await new Promise((resolve) => {
-		if (doneSyncing) {
-			resolve();
-			return;
-		}
-		isChanged = removeExtraBlocks({
-			editorEngine,
-			value
+	}), isChanged = !0), value && value.length > 0) {
+		if (streamBlocks) await new Promise((resolve) => {
+			if (doneSyncing) {
+				resolve();
+				return;
+			}
+			isChanged = removeExtraBlocks({
+				editorEngine,
+				value
+			});
+			let processBlocks = async () => {
+				for await (let [currentBlock, currentBlockIndex] of getStreamedBlocks({ value })) {
+					let { blockChanged, blockValid } = syncBlock({
+						context,
+						sendBack,
+						block: currentBlock,
+						index: currentBlockIndex,
+						editorEngine,
+						value
+					});
+					if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !isValid) break;
+				}
+				resolve();
+			};
+			processBlocks();
 		});
-		let processBlocks = async () => {
-			for await (let [currentBlock, currentBlockIndex] of getStreamedBlocks({ value })) {
+		else {
+			if (doneSyncing) return;
+			isChanged = removeExtraBlocks({
+				editorEngine,
+				value
+			});
+			let index = 0;
+			for (let block of value) {
 				let { blockChanged, blockValid } = syncBlock({
 					context,
 					sendBack,
-					block: currentBlock,
-					index: currentBlockIndex,
+					block,
+					index,
 					editorEngine,
 					value
 				});
-				if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !isValid) break;
+				if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !blockValid) break;
+				index++;
 			}
-			resolve();
-		};
-		processBlocks();
-	});
-	else {
-		if (doneSyncing) return;
-		isChanged = removeExtraBlocks({
-			editorEngine,
-			value
-		});
-		let index = 0;
-		for (let block of value) {
-			let { blockChanged, blockValid } = syncBlock({
-				context,
-				sendBack,
-				block,
-				index,
-				editorEngine,
-				value
-			});
-			if (isChanged = blockChanged || isChanged, isValid &&= blockValid, !blockValid) break;
-			index++;
 		}
 	}
 	if (!isValid) {
@@ -16369,13 +16396,13 @@ function replaceBlock({ context, editorEngine, block, index }) {
 }
 function updateBlock({ context, editorEngine, oldEngineBlock, block, index: _index }) {
 	let engineBlock = toEngineBlock(block, { schemaTypes: context.schema }), { children: _children, ...blockProps } = engineBlock;
-	setNodeProperties(editorEngine, blockProps, [{ _key: oldEngineBlock._key }]);
+	applyNodeProperties(editorEngine, blockProps, [{ _key: oldEngineBlock._key }]);
 	let oldRecord = oldEngineBlock, newRecord = engineBlock, removedProperties = {};
 	for (let key of Object.keys(oldRecord)) key !== "children" && key !== "text" && (newRecord.hasOwnProperty(key) || (removedProperties[key] = null));
-	if (Object.keys(removedProperties).length > 0 && setNodeProperties(editorEngine, removedProperties, [{ _key: oldEngineBlock._key }]), isTextBlock({ schema: editorEngine.snapshot.context.schema }, engineBlock) && isTextBlock({ schema: editorEngine.snapshot.context.schema }, oldEngineBlock)) {
+	if (Object.keys(removedProperties).length > 0 && applyNodeProperties(editorEngine, removedProperties, [{ _key: oldEngineBlock._key }]), isTextBlock({ schema: editorEngine.snapshot.context.schema }, engineBlock) && isTextBlock({ schema: editorEngine.snapshot.context.schema }, oldEngineBlock)) {
 		let oldKeys = oldEngineBlock.children.map((c) => c._key), newKeys = engineBlock.children.map((c) => c._key), oldKeySet = new Set(oldKeys), hasSharedKeys = newKeys.some((key) => oldKeySet.has(key));
 		if (oldKeys.length === newKeys.length && oldKeys.length > 0 && oldKeySet.size === oldKeys.length && oldKeys.some((key, i) => key !== newKeys[i]) && newKeys.every((key) => oldKeySet.has(key)) || newKeys.length > 0 && !hasSharedKeys) {
-			debug.syncValue("Replacing children via set"), setNodeProperties(editorEngine, { children: engineBlock.children }, [{ _key: oldEngineBlock._key }]), editorEngine.onChange();
+			debug.syncValue("Replacing children via set"), applyNodeProperties(editorEngine, { children: engineBlock.children }, [{ _key: oldEngineBlock._key }]), editorEngine.onChange();
 			return;
 		}
 		let oldBlockChildrenLength = oldEngineBlock.children.length;
@@ -16404,7 +16431,7 @@ function updateBlock({ context, editorEngine, oldEngineBlock, block, index: _ind
 				if (currentBlockChild._key === oldBlockChild?._key && currentBlockChild._type === oldBlockChild?._type) {
 					debug.syncValue("Updating changed child", currentBlockChild, oldBlockChild);
 					let isSpanNode = isSpan({ schema: context.schema }, currentBlockChild) && isSpan({ schema: context.schema }, oldBlockChild), childProps = { ...currentBlockChild };
-					isSpanNode && delete childProps.text, setNodeProperties(editorEngine, childProps, path), isSpanNode && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(editorEngine, {
+					isSpanNode && delete childProps.text, applyNodeProperties(editorEngine, childProps, path), isSpanNode && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(editorEngine, {
 						focus: {
 							path,
 							offset: 0