@portabletext/editor 8.0.2 → 8.1.0

package/lib/index.js

@@ -746,6 +746,40 @@ function move(editor, options = {}) {
 	}
 	editor.setSelection(props);
 }
+function subscribeToOperations(editor, listener, options) {
+	let phase = options?.phase ?? "after";
+	return editor.operationListeners[phase] = [...editor.operationListeners[phase], listener], () => {
+		let listeners = editor.operationListeners[phase], index = listeners.indexOf(listener);
+		index !== -1 && (editor.operationListeners[phase] = [...listeners.slice(0, index), ...listeners.slice(index + 1)]);
+	};
+}
+/**
+* Captures the operation together with the engine state that `after`
+* listeners can no longer read once the operation has been applied. All
+* engine flags are stable for the duration of a single apply call, so
+* capturing them at entry is equivalent to reading them at any point during
+* the apply.
+*/
+function createOperationEvent(editor, operation) {
+	let isNormalizingNode = !!editor.isNormalizingNode, isProcessingRemoteChanges = !!editor.isProcessingRemoteChanges, isUndoing = !!editor.isUndoing, isRedoing = !!editor.isRedoing;
+	return {
+		operation,
+		beforeValue: editor.snapshot.context.value,
+		beforeSelection: editor.snapshot.context.selection,
+		operationsInProgress: editor.operations.length > 0,
+		isNormalizingNode,
+		isPatching: !!editor.isPatching,
+		isProcessingRemoteChanges,
+		isUndoing,
+		isRedoing,
+		withHistory: !!editor.withHistory,
+		undoStepId: editor.undoStepId,
+		origin: isProcessingRemoteChanges ? "remote" : isUndoing ? "undo" : isRedoing ? "redo" : isNormalizingNode ? "normalization" : "local"
+	};
+}
+function emitOperationEvent(listeners, event) {
+	for (let index = 0; index < listeners.length; index++) listeners[index]?.(event);
+}
 const bold$1 = createKeyboardShortcut({
 	default: [{
 		key: "B",
@@ -1179,13 +1213,14 @@ function mapPointThroughStep(step, point, options = {}) {
 			};
 		}
 		case "rekey": {
-			let path;
-			for (let i = 0; i < point.path.length; i++) {
-				let segment = point.path[i];
-				isKeyedSegment(segment) && segment._key === step.oldKey && (path === void 0 && (path = [...point.path]), path[i] = { _key: step.newKey });
-			}
-			return path === void 0 ? point : {
-				path,
+			if (point.path.length <= step.path.length || !pathEquals(point.path.slice(0, step.path.length), step.path)) return point;
+			let segment = point.path[step.path.length];
+			return !isKeyedSegment(segment) || segment._key !== step.oldKey ? point : {
+				path: [
+					...step.path,
+					{ _key: step.newKey },
+					...point.path.slice(step.path.length + 1)
+				],
 				offset: point.offset
 			};
 		}
@@ -1303,6 +1338,7 @@ function operationToSteps(op) {
 				let oldKey = op.inverse?.type === "set" && typeof op.inverse.value == "string" ? op.inverse.value : void 0;
 				return oldKey ? [{
 					type: "rekey",
+					path: nodePath.slice(0, -1),
 					oldKey,
 					newKey: op.value
 				}] : [];
@@ -2787,9 +2823,12 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({ children }) => /* @__PU
 	editor.forceRender = forceRender, editor.readOnly = readOnly;
 	let state = useMemo(() => ({
 		isUpdatingSelection: !1,
-		latestElement: null
+		latestElement: null,
+		localContentChangePending: !1
 	}), []);
-	useEffect(() => {
+	useEffect(() => subscribeToOperations(editor, (event) => {
+		event.operation.type !== "set.selection" && (event.origin === "local" || event.origin === "undo" || event.origin === "redo") && (state.localContentChangePending = !0);
+	}), [editor, state]), useEffect(() => {
 		ref.current && autoFocus && ref.current.focus();
 	}, [autoFocus]);
 	/**
@@ -2844,6 +2883,8 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({ children }) => /* @__PU
 		onDOMSelectionChange,
 		scheduleOnDOMSelectionChange
 	}), useIsomorphicLayoutEffect(() => {
+		let hadPendingLocalContentChange = state.localContentChangePending;
+		state.localContentChangePending = !1;
 		let window = null;
 		ref.current && (window = getDefaultView(ref.current)) && (editor.domWindow = window, editor.domElement = ref.current);
 		let { selection } = editor.snapshot.context, root = DOMEditor.findDocumentOrShadowRoot(editor), domSelection = getSelection(root);
@@ -2862,7 +2903,13 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({ children }) => /* @__PU
 					exactMatch: !0,
 					suppressThrow: !0
 				});
-				if (editorSelection && rangeEquals(editorSelection, selection)) return;
+				if (editorSelection && rangeEquals(editorSelection, selection)) {
+					if (hadPendingLocalContentChange) try {
+						let domRange = DOMEditor.toDOMRange(editor, selection);
+						scrollSelectionIntoView(editor, domRange);
+					} catch {}
+					return;
+				}
 			}
 			if (selection && !DOMEditor.hasRange(editor, selection)) {
 				let fallbackRange = DOMEditor.toEditorSelection(editor, domSelection, {
@@ -4114,40 +4161,6 @@ function performHotkey({ editorActor, editor, portableTextEditor, hotkeys, event
 		}
 	});
 }
-function subscribeToOperations(editor, listener, options) {
-	let phase = options?.phase ?? "after";
-	return editor.operationListeners[phase] = [...editor.operationListeners[phase], listener], () => {
-		let listeners = editor.operationListeners[phase], index = listeners.indexOf(listener);
-		index !== -1 && (editor.operationListeners[phase] = [...listeners.slice(0, index), ...listeners.slice(index + 1)]);
-	};
-}
-/**
-* Captures the operation together with the engine state that `after`
-* listeners can no longer read once the operation has been applied. All
-* engine flags are stable for the duration of a single apply call, so
-* capturing them at entry is equivalent to reading them at any point during
-* the apply.
-*/
-function createOperationEvent(editor, operation) {
-	let isNormalizingNode = !!editor.isNormalizingNode, isProcessingRemoteChanges = !!editor.isProcessingRemoteChanges, isUndoing = !!editor.isUndoing, isRedoing = !!editor.isRedoing;
-	return {
-		operation,
-		beforeValue: editor.snapshot.context.value,
-		beforeSelection: editor.snapshot.context.selection,
-		operationsInProgress: editor.operations.length > 0,
-		isNormalizingNode,
-		isPatching: !!editor.isPatching,
-		isProcessingRemoteChanges,
-		isUndoing,
-		isRedoing,
-		withHistory: !!editor.withHistory,
-		undoStepId: editor.undoStepId,
-		origin: isProcessingRemoteChanges ? "remote" : isUndoing ? "undo" : isRedoing ? "redo" : isNormalizingNode ? "normalization" : "local"
-	};
-}
-function emitOperationEvent(listeners, event) {
-	for (let index = 0; index < listeners.length; index++) listeners[index]?.(event);
-}
 function isForwardRange(range, root) {
 	return !isBackwardRange(range, root);
 }
@@ -4190,7 +4203,12 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 		operation: event.operation,
 		origin: event.origin
 	});
-}, { phase: "before" }), rangeDecorationsMachine = setup({
+}, { phase: "before" });
+function mergeRangeDecoration(leaf, decoration) {
+	let { rangeDecoration } = decoration;
+	leaf.rangeDecorations = [...leaf.rangeDecorations ?? [], rangeDecoration];
+}
+const rangeDecorationsMachine = setup({
 	types: {
 		context: {},
 		input: {},
@@ -4211,6 +4229,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 				}
 				rangeDecorationState.push({
 					rangeDecoration,
+					merge: mergeRangeDecoration,
 					...rangeDecoration.selection
 				});
 			}
@@ -4230,6 +4249,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 				}
 				rangeDecorationState.push({
 					rangeDecoration,
+					merge: mergeRangeDecoration,
 					...rangeDecoration.selection
 				});
 			}
@@ -4258,7 +4278,8 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 					rangeDecoration: {
 						...decoratedRange.rangeDecoration,
 						selection: newRange || currentSelection
-					}
+					},
+					merge: mergeRangeDecoration
 				});
 			}
 			context.editorEngine.decoratedRanges = rangeDecorationState;
@@ -5166,29 +5187,33 @@ const PLACEHOLDER_STYLE = {
 	right: 0
 };
 function RenderLeaf(props) {
-	let $ = c(12), schema = props.schema;
+	let $ = c(16), schema = props.schema;
 	if (props.leaf._type !== schema.span.name) return props.children;
 	let t0;
 	$[0] === props ? t0 = $[1] : (t0 = /* @__PURE__ */ jsx(RenderSpan, { ...props }), $[0] = props, $[1] = t0);
-	let renderedSpan = t0;
-	if (props.renderPlaceholder && props.leaf.placeholder && props.text.text === "") {
-		let t1;
-		$[2] === props.renderPlaceholder ? t1 = $[3] : (t1 = props.renderPlaceholder(), $[2] = props.renderPlaceholder, $[3] = t1);
-		let t2;
-		$[4] === t1 ? t2 = $[5] : (t2 = /* @__PURE__ */ jsx("span", {
-			style: PLACEHOLDER_STYLE,
-			contentEditable: !1,
-			children: t1
-		}), $[4] = t1, $[5] = t2);
-		let t3;
-		return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment, { children: [t2, renderedSpan] }), $[6] = renderedSpan, $[7] = t2, $[8] = t3) : t3 = $[8], t3;
-	}
-	let rangeDecoration = props.leaf.rangeDecoration;
-	if (rangeDecoration) {
-		let t1;
-		$[9] !== rangeDecoration || $[10] !== renderedSpan ? (t1 = rangeDecoration.component({ children: renderedSpan }), $[9] = rangeDecoration, $[10] = renderedSpan, $[11] = t1) : t1 = $[11], renderedSpan = t1;
-	}
-	return renderedSpan;
+	let renderedSpan, t1;
+	if ($[2] !== props.leaf.placeholder || $[3] !== props.leaf.rangeDecorations || $[4] !== props.renderPlaceholder || $[5] !== props.text || $[6] !== t0) {
+		t1 = Symbol.for("react.early_return_sentinel");
+		bb0: {
+			if (renderedSpan = t0, props.renderPlaceholder && props.leaf.placeholder && props.text.text === "") {
+				let t2;
+				$[9] === props.renderPlaceholder ? t2 = $[10] : (t2 = props.renderPlaceholder(), $[9] = props.renderPlaceholder, $[10] = t2);
+				let t3;
+				$[11] === t2 ? t3 = $[12] : (t3 = /* @__PURE__ */ jsx("span", {
+					style: PLACEHOLDER_STYLE,
+					contentEditable: !1,
+					children: t2
+				}), $[11] = t2, $[12] = t3);
+				let t4;
+				$[13] !== renderedSpan || $[14] !== t3 ? (t4 = /* @__PURE__ */ jsxs(Fragment, { children: [t3, renderedSpan] }), $[13] = renderedSpan, $[14] = t3, $[15] = t4) : t4 = $[15], t1 = t4;
+				break bb0;
+			}
+			let rangeDecorations = props.leaf.rangeDecorations;
+			if (rangeDecorations) for (let rangeDecoration of [...rangeDecorations].reverse()) renderedSpan = rangeDecoration.component({ children: renderedSpan });
+		}
+		$[2] = props.leaf.placeholder, $[3] = props.leaf.rangeDecorations, $[4] = props.renderPlaceholder, $[5] = props.text, $[6] = t0, $[7] = renderedSpan, $[8] = t1;
+	} else renderedSpan = $[7], t1 = $[8];
+	return t1 === Symbol.for("react.early_return_sentinel") ? renderedSpan : t1;
 }
 function RenderText(props) {
 	let $ = c(3), t0;
@@ -6892,13 +6917,17 @@ function applyOperation(editor, op) {
 		case "set": {
 			let { path, value } = op;
 			if (!op.inverse && !editor.isProcessingRemoteChanges) {
-				let previousValue = getValue(editor.snapshot.context.value, path);
+				let previousValue = getValue(editor.snapshot.context.value, path), inversePath = path[path.length - 1] === "_key" && typeof value == "string" && isKeyedSegment(path[path.length - 2]) ? [
+					...path.slice(0, -2),
+					{ _key: value },
+					"_key"
+				] : path;
 				op.inverse = previousValue === void 0 ? {
 					type: "unset",
-					path
+					path: inversePath
 				} : {
 					type: "set",
-					path,
+					path: inversePath,
 					value: previousValue
 				};
 			}
@@ -7537,8 +7566,7 @@ function applyMergeNode(editor, path, position) {
 				if (!prevEntry || !isTextBlock({ schema: editor.snapshot.context.schema }, prevEntry.node)) return;
 				let prevChildren = prevEntry.node.children, lastInsertedKey = prevChildren.length > 0 ? prevChildren[prevChildren.length - 1]._key : void 0;
 				for (let i = 0; i < node.children.length; i++) {
-					let child = node.children[i];
-					lastInsertedKey === void 0 ? editor.apply({
+					let child = node.children[i], operation = lastInsertedKey === void 0 ? {
 						type: "insert",
 						path: [
 							...prevPath,
@@ -7547,7 +7575,7 @@ function applyMergeNode(editor, path, position) {
 						],
 						node: child,
 						position: "before"
-					}) : editor.apply({
+					} : {
 						type: "insert",
 						path: [
 							...prevPath,
@@ -7556,7 +7584,8 @@ function applyMergeNode(editor, path, position) {
 						],
 						node: child,
 						position: "after"
-					}), lastInsertedKey = child._key;
+					};
+					editor.apply(operation), lastInsertedKey = operation.node._key;
 				}
 				editor.apply({
 					type: "unset",
@@ -7675,23 +7704,20 @@ function setNodeProperties(editor, props, path) {
 	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);
-		if (editor.apply({
+		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: [...currentPath, key],
+				path: inversePath,
 				value: nodeRecord[key]
 			} : {
 				type: "unset",
-				path: [...currentPath, key]
+				path: inversePath
 			}
-		}), key === "_key" && typeof propsRecord[key] == "string") {
-			let lastSegment = currentPath[currentPath.length - 1];
-			isKeyedSegment(lastSegment) && (currentPath = [...currentPath.slice(0, -1), { _key: propsRecord[key] }]);
-		}
+		}), renamedPath && (currentPath = renamedPath);
 	} else nodeRecord.hasOwnProperty(key) && editor.apply({
 		type: "unset",
 		path: [...currentPath, key],
@@ -11607,6 +11633,63 @@ function fieldAcceptsTextBlock(editor, node, _path) {
 	return container ? container.field.of.some((member) => member.type === editor.snapshot.context.schema.block.name) : !1;
 }
 /**
+* A block merge folds `mergingBlock`'s children (and markDefs) into
+* `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).
+*
+* 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 destinationMarkDef = destinationMarkDefsByKey.get(markDef._key);
+		if (!destinationMarkDef) return [markDef];
+		if (dedupeEqualMarkDefs && isDeepEqual(markDef, destinationMarkDef)) return [];
+		let newKey = context.keyGenerator();
+		return markDefKeyMap.set(markDef._key, newKey), [{
+			...markDef,
+			_key: newKey
+		}];
+	}), markDefRenames = [];
+	for (let markDef of mergingBlock.markDefs ?? []) {
+		let newKey = markDefKeyMap.get(markDef._key);
+		newKey && markDefRenames.push({
+			markDefKey: markDef._key,
+			newKey
+		});
+	}
+	let childRenames = [], renamedChildren = mergingBlock.children.map((child) => {
+		let currentMarks = isSpan(context, child) ? child.marks : void 0, remappedMarks = currentMarks?.map((mark) => markDefKeyMap.get(mark) ?? mark), marksChanged = !!(remappedMarks && !isEqualMarks(remappedMarks, currentMarks)), newKey = destinationChildKeys.has(child._key) ? context.keyGenerator() : child._key, props = {};
+		return newKey !== child._key && (props._key = newKey), marksChanged && (props.marks = remappedMarks), Object.keys(props).length > 0 && childRenames.push({
+			childKey: child._key,
+			props
+		}), marksChanged ? {
+			...child,
+			_key: newKey,
+			marks: remappedMarks
+		} : {
+			...child,
+			_key: newKey
+		};
+	});
+	return {
+		renamedBlock: {
+			...mergingBlock,
+			children: renamedChildren,
+			...mergingBlock.markDefs ? { markDefs: renamedMarkDefs } : {}
+		},
+		childRenames,
+		markDefRenames
+	};
+}
+/**
 * Indic scripts whose grapheme clusters span multiple code points. Backward
 * character delete on these scripts removes one code point at a time instead
 * of the entire cluster. Besides the script ranges, the class lists the BMP
@@ -11939,12 +12022,29 @@ function mergeBlock(editor, startBlockPath, endBlockPath, removeEmptyStartBlock)
 		removeNodeAt(editor, startBlockPath);
 		return;
 	}
-	let endMarkDefs = endBlock.node.markDefs;
-	if (Array.isArray(endMarkDefs) && endMarkDefs.length > 0) {
-		let oldDefs = startBlock.node.markDefs ?? [];
-		setNodeProperties(editor, { markDefs: [...new Map([...oldDefs, ...endMarkDefs].map((def) => [def._key, def])).values()] }, startBlockPath);
-	}
-	applyMergeNode(editor, endBlockPath, startBlock.node.children.length);
+	let { renamedBlock, childRenames, markDefRenames } = planMergeKeyRenames({
+		context: editor.snapshot.context,
+		mergingBlock: endBlock.node,
+		destinationBlock: startBlock.node,
+		dedupeEqualMarkDefs: !0
+	});
+	for (let { markDefKey, newKey } of markDefRenames) editor.apply({
+		type: "set",
+		path: [
+			...endBlockPath,
+			"markDefs",
+			{ _key: markDefKey },
+			"_key"
+		],
+		value: newKey
+	});
+	for (let { childKey, props } of childRenames) setNodeProperties(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);
 }
 function removeNodeAt(editor, path) {
 	getNode(editor.snapshot, path) && editor.apply({
@@ -13132,16 +13232,24 @@ const abstractAnnotationBehaviors = [
 			let previousBlock = {
 				node: previousSibling.node,
 				path: previousSibling.path
-			};
+			}, previousBlockEndPoint = getBlockEndPoint({
+				context: snapshot.context,
+				block: previousBlock
+			}), { renamedBlock, renameActions } = planMergeKeyRenameActions({
+				context: snapshot.context,
+				mergingBlockPath: focusTextBlock.path,
+				mergingBlock: focusTextBlock.node,
+				destinationBlock: previousBlock.node
+			});
 			return {
-				previousBlockEndPoint: getBlockEndPoint({
-					context: snapshot.context,
-					block: previousBlock
-				}),
-				focusTextBlock
+				previousBlockEndPoint,
+				focusTextBlock,
+				renamedBlock,
+				renameActions
 			};
 		},
-		actions: [(_, { previousBlockEndPoint, focusTextBlock }) => [
+		actions: [(_, { previousBlockEndPoint, focusTextBlock, renamedBlock, renameActions }) => [
+			...renameActions,
 			raise$1({
 				type: "delete.block",
 				at: focusTextBlock.path
@@ -13155,7 +13263,7 @@ const abstractAnnotationBehaviors = [
 			}),
 			raise$1({
 				type: "insert.block",
-				block: focusTextBlock.node,
+				block: renamedBlock,
 				placement: "auto",
 				select: "start"
 			})
@@ -13224,20 +13332,32 @@ const abstractAnnotationBehaviors = [
 			}, focusTextBlock = getFocusTextBlock(adjustedSnapshot);
 			if (!focusTextBlock) return !1;
 			let nextSibling = getSibling(adjustedSnapshot, focusTextBlock.path, { direction: "next" });
-			return !nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlockNode(snapshot.context, nextSibling.node) ? !1 : { nextBlock: {
-				node: nextSibling.node,
-				path: nextSibling.path
-			} };
+			if (!nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlock(snapshot.context, nextSibling.node)) return !1;
+			let { renamedBlock, renameActions } = planMergeKeyRenameActions({
+				context: snapshot.context,
+				mergingBlockPath: nextSibling.path,
+				mergingBlock: nextSibling.node,
+				destinationBlock: focusTextBlock.node
+			});
+			return {
+				nextBlockPath: nextSibling.path,
+				renamedBlock,
+				renameActions
+			};
 		},
-		actions: [(_, { nextBlock }) => [raise$1({
-			type: "delete.block",
-			at: nextBlock.path
-		}), raise$1({
-			type: "insert.block",
-			block: nextBlock.node,
-			placement: "auto",
-			select: "none"
-		})]]
+		actions: [(_, { nextBlockPath, renamedBlock, renameActions }) => [
+			...renameActions,
+			raise$1({
+				type: "delete.block",
+				at: nextBlockPath
+			}),
+			raise$1({
+				type: "insert.block",
+				block: renamedBlock,
+				placement: "auto",
+				select: "none"
+			})
+		]]
 	}),
 	defineBehavior({
 		on: "delete.block",
@@ -13307,7 +13427,44 @@ const abstractAnnotationBehaviors = [
 			type: "delete"
 		})]]
 	})
-], mimeTypePriority = [
+];
+/**
+* Raise the child/markDef renames `planMergeKeyRenames` computed as
+* `set`/`child.set` events against the still-living `mergingBlock`, so
+* they land on the wire before the merge's `unset`.
+*/
+function planMergeKeyRenameActions(args) {
+	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, { renamedBlock, childRenames, markDefRenames } = planMergeKeyRenames({
+		context,
+		mergingBlock,
+		destinationBlock,
+		dedupeEqualMarkDefs: !1
+	}), renameActions = [];
+	for (let { markDefKey, newKey } of markDefRenames) renameActions.push(raise$1({
+		type: "set",
+		at: [
+			...mergingBlockPath,
+			"markDefs",
+			{ _key: markDefKey },
+			"_key"
+		],
+		value: newKey
+	}));
+	for (let { childKey, props } of childRenames) renameActions.push(raise$1({
+		type: "child.set",
+		at: [
+			...mergingBlockPath,
+			"children",
+			{ _key: childKey }
+		],
+		props
+	}));
+	return {
+		renamedBlock,
+		renameActions
+	};
+}
+const mimeTypePriority = [
 	"application/x-portable-text",
 	"application/json",
 	"text/markdown",
@@ -16455,7 +16612,8 @@ function createActors(config) {
 	return config.subscriptions.push(mutationBatcher.subscribe), config.subscriptions.push(() => subscribeToOperations(config.editorEngine, (event) => {
 		isPublicOperation(event.operation) && config.relay.send({
 			type: "operation",
-			operation: event.operation
+			operation: event.operation,
+			origin: event.origin === "remote" ? "remote" : "local"
 		});
 	})), config.subscriptions.push(() => {
 		let subscription = syncActor.on("*", (event) => {