@portabletext/editor 8.0.3 → 8.1.0

package/lib/{behavior.types.action-C6D8CCF9.d.ts → behavior.types.action-C0XDEQnB.d.ts}

@@ -1464,6 +1464,12 @@ interface RangeDecoration {
    * The component that renders the range decoration. It receives the
    * decorated text as its children.
    *
+   * The component can render more than once for one decoration: the range
+   * is split into segments at formatting boundaries and where it overlaps
+   * other decorations, and each segment gets its own wrapper. Where
+   * decorations overlap, their components nest, first in array order
+   * outermost.
+   *
    * @example
    * ```tsx
    * (rangeComponentProps: PropsWithChildren) => (
@@ -1901,6 +1907,7 @@ type OperationEvent = {
 type OperationListener = (event: OperationEvent) => void;
 type DecoratedRange = Range & {
   rangeDecoration: RangeDecoration;
+  merge: (leaf: PortableTextSpan, decoration: object) => void;
 };
 type HistoryItem = {
   operations: EngineOperation[];
@@ -2143,6 +2150,15 @@ type EditorEmittedEvent = {
    */
   type: 'operation';
   operation: Operation;
+  /**
+   * Where the change that produced this operation came from:
+   * `'local'` for changes made in this editor (edits, undo/redo),
+   * `'remote'` for changes applied from the outside (`patches`,
+   * `update value`, and the initial value sync). A normalization fix
+   * (a repaired key, a merged span) reports the origin of the change
+   * that triggered it.
+   */
+  origin: 'local' | 'remote';
 } | PatchEvent | {
   type: 'read only';
 } | {
@@ -2588,6 +2604,7 @@ declare const editorMachine: import("xstate").StateMachine<{
 } | {
   type: 'operation';
   operation: Operation;
+  origin: 'local' | 'remote';
 } | {
   type: 'read only';
 } | {
@@ -3395,4 +3412,4 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
 export { BehaviorGuard as $, defineBlockObject as $t, PortableTextSpan$1 as A, Annotation as At, usePortableTextEditor as B, DecoratorRender as Bt, ListDefinition as C, EditorSchema as Ct, PortableTextBlock$1 as D, RegisteredInlineObject as Dt, Patch$1 as E, RegisteredContainer as Et, defineSchema as F, BlockObjectRenderProps as Ft, Editor as G, RegistrableNode as Gt, useEditorSelector as H, InlineObject as Ht, BlockOffset as I, Container as It, EditorEmittedEvent as J, SpanRenderProps as Jt, EditorConfig as K, Span as Kt, useEditor as L, ContainerRender as Lt, SchemaDefinition$1 as M, AnnotationRenderProps as Mt, StyleDefinition as N, BlockObject as Nt, PortableTextChild$1 as O, RegisteredPositional as Ot, StyleSchemaType as P, BlockObjectRender as Pt, defineBehavior as Q, defineAnnotation as Qt, defaultKeyGenerator as R, ContainerRenderProps as Rt, InlineObjectSchemaType as S, Node$1 as St, OfDefinition$1 as T, RegisteredBlockObject as Tt, EditorProvider as U, InlineObjectRender as Ut, EditorSelector as V, DecoratorRenderProps as Vt, EditorProviderProps as W, InlineObjectRenderProps as Wt, Operation as X, TextBlockRender as Xt, MutationEvent as Y, TextBlock as Yt, Behavior as Z, TextBlockRenderProps as Zt, BlockObjectSchemaType as _, PortableTextEditable as _t, forward as a, AnnotationPath as an, EditorSelectionPoint as at, FieldDefinition$1 as b, PortableTextEditor as bt, CustomBehaviorEvent as c, KeyedSegment as cn, OnPasteFn as ct, SyntheticBehaviorEvent as d, PasteData as dt, defineContainer as en, EditorContext as et, PatchesEvent as f, RangeDecoration as ft, BlockObjectDefinition as g, ScrollSelectionIntoViewFunction as gt, BaseDefinition as h, RenderPlaceholderFunction as ht, execute as i, defineTextBlock as in, EditorSelection as it, PortableTextTextBlock$1 as j, AnnotationRender as jt, PortableTextObject$1 as k, RegisteredSpan as kt, InsertPlacement as l, Path as ln, OnPasteResult as lt, AnnotationSchemaType as m, RenderEditableFunction as mt, BehaviorActionSet as n, defineInlineObject as nn, AddedAnnotationPaths as nt, raise$1 as o, BlockPath as on, InvalidValueResolution as ot, AnnotationDefinition as p, RangeDecorationOnMovedDetails as pt, EditorEvent as q, SpanRender as qt, effect as r, defineSpan as rn, EditableAPIDeleteOptions as rt, BehaviorEvent as s, ChildPath as sn, OnCopyFn as st, BehaviorAction as t, defineDecorator as tn, EditorSnapshot as tt, NativeBehaviorEvent as u, PathSegment as un, OnPasteResultOrPromise as ut, DecoratorDefinition as v, PortableTextEditableProps as vt, ListSchemaType as w, Containers as wt, InlineObjectDefinition as x, TraversalSnapshot as xt, DecoratorSchemaType as y, HotkeyOptions as yt, usePortableTextEditorSelection as z, Decorator as zt };
-//# sourceMappingURL=behavior.types.action-C6D8CCF9.d.ts.map
+//# sourceMappingURL=behavior.types.action-C0XDEQnB.d.ts.map

package/lib/behavior.types.action-C0XDEQnB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behavior.types.action-C0XDEQnB.d.ts","names":[],"sources":["../src/internal-utils/mime-type.ts","../src/type-utils.ts","../src/converters/converter.types.ts","../src/types/paths.ts","../src/renderers/renderer.types.ts","../src/schema/container-types.ts","../src/editor/editor-schema.ts","../src/engine/interfaces/node.ts","../src/traversal/traversal-snapshot.ts","../src/editor/PortableTextEditor.tsx","../src/types/options.ts","../src/editor/Editable.tsx","../src/types/editor.ts","../src/engine/types/types.ts","../src/engine/interfaces/point.ts","../src/engine/interfaces/range.ts","../src/engine/interfaces/operation.ts","../src/engine/interfaces/range-ref.ts","../src/engine/dom/utils/diff-text.ts","../src/engine/dom/utils/dom.ts","../src/engine/dom/plugin/dom-editor.ts","../src/engine/interfaces/location.ts","../src/engine/interfaces/path-ref.ts","../src/engine/interfaces/point-ref.ts","../src/engine/interfaces/editor.ts","../src/engine/core/operation-channel.ts","../src/editor/range-decorations-machine.ts","../src/types/editor-engine.ts","../src/editor/editor-snapshot.ts","../src/behaviors/behavior.types.guard.ts","../src/behaviors/behavior.types.behavior.ts","../src/types/operation.ts","../src/editor/relay.ts","../src/editor.ts","../src/editor/editor-provider.tsx","../src/editor/editor-selector.ts","../src/editor/usePortableTextEditor.ts","../src/editor/usePortableTextEditorSelection.tsx","../src/utils/key-generator.ts","../src/editor/use-editor.ts","../src/types/block-offset.ts","../src/priority/priority.types.ts","../src/behaviors/behavior.config.ts","../src/editor/editor-machine.ts","../src/internal-utils/event-position.ts","../src/types/block-with-optional-key.ts","../src/behaviors/behavior.types.event.ts","../src/editor/editor-dom.ts","../src/behaviors/behavior.types.action.ts"],"mappings":"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"}

package/lib/behaviors/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-C6D8CCF9.js";
+import { $ as BehaviorGuard, Q as defineBehavior, Z as Behavior, a as forward, c as CustomBehaviorEvent, d as SyntheticBehaviorEvent, i as execute, l as InsertPlacement, n as BehaviorActionSet, o as raise, r as effect, s as BehaviorEvent, t as BehaviorAction, u as NativeBehaviorEvent } from "../behavior.types.action-C0XDEQnB.js";
 export { type Behavior, type BehaviorAction, type BehaviorActionSet, type BehaviorEvent, type BehaviorGuard, type CustomBehaviorEvent, type InsertPlacement, type NativeBehaviorEvent, type SyntheticBehaviorEvent, defineBehavior, effect, execute, forward, raise };

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-import { $t as defineBlockObject, A as PortableTextSpan, At as Annotation, B as usePortableTextEditor, Bt as DecoratorRender, C as ListDefinition, Ct as EditorSchema, D as PortableTextBlock, Dt as RegisteredInlineObject, E as Patch, Et as RegisteredContainer, F as defineSchema, Ft as BlockObjectRenderProps, G as Editor, Gt as RegistrableNode, H as useEditorSelector, Ht as InlineObject, I as BlockOffset, It as Container, J as EditorEmittedEvent, Jt as SpanRenderProps, K as EditorConfig, Kt as Span, L as useEditor, Lt as ContainerRender, M as SchemaDefinition, Mt as AnnotationRenderProps, N as StyleDefinition, Nt as BlockObject, O as PortableTextChild, Ot as RegisteredPositional, P as StyleSchemaType, Pt as BlockObjectRender, Qt as defineAnnotation, R as defaultKeyGenerator, Rt as ContainerRenderProps, S as InlineObjectSchemaType, T as OfDefinition, Tt as RegisteredBlockObject, U as EditorProvider, Ut as InlineObjectRender, V as EditorSelector, Vt as DecoratorRenderProps, W as EditorProviderProps, Wt as InlineObjectRenderProps, X as Operation, Xt as TextBlockRender, Y as MutationEvent, Yt as TextBlock, Zt as TextBlockRenderProps, _ as BlockObjectSchemaType, _t as PortableTextEditable, an as AnnotationPath, at as EditorSelectionPoint, b as FieldDefinition, bt as PortableTextEditor, ct as OnPasteFn, dt as PasteData, en as defineContainer, et as EditorContext, f as PatchesEvent, ft as RangeDecoration, g as BlockObjectDefinition, gt as ScrollSelectionIntoViewFunction, h as BaseDefinition, ht as RenderPlaceholderFunction, in as defineTextBlock, it as EditorSelection, j as PortableTextTextBlock, jt as AnnotationRender, k as PortableTextObject, kt as RegisteredSpan, ln as Path, lt as OnPasteResult, m as AnnotationSchemaType, mt as RenderEditableFunction, nn as defineInlineObject, nt as AddedAnnotationPaths, on as BlockPath, ot as InvalidValueResolution, p as AnnotationDefinition, pt as RangeDecorationOnMovedDetails, q as EditorEvent, qt as SpanRender, rn as defineSpan, rt as EditableAPIDeleteOptions, sn as ChildPath, st as OnCopyFn, tn as defineDecorator, tt as EditorSnapshot, ut as OnPasteResultOrPromise, v as DecoratorDefinition, vt as PortableTextEditableProps, w as ListSchemaType, wt as Containers, x as InlineObjectDefinition, y as DecoratorSchemaType, yt as HotkeyOptions, z as usePortableTextEditorSelection, zt as Decorator } from "./behavior.types.action-C6D8CCF9.js";
+import { $t as defineBlockObject, A as PortableTextSpan, At as Annotation, B as usePortableTextEditor, Bt as DecoratorRender, C as ListDefinition, Ct as EditorSchema, D as PortableTextBlock, Dt as RegisteredInlineObject, E as Patch, Et as RegisteredContainer, F as defineSchema, Ft as BlockObjectRenderProps, G as Editor, Gt as RegistrableNode, H as useEditorSelector, Ht as InlineObject, I as BlockOffset, It as Container, J as EditorEmittedEvent, Jt as SpanRenderProps, K as EditorConfig, Kt as Span, L as useEditor, Lt as ContainerRender, M as SchemaDefinition, Mt as AnnotationRenderProps, N as StyleDefinition, Nt as BlockObject, O as PortableTextChild, Ot as RegisteredPositional, P as StyleSchemaType, Pt as BlockObjectRender, Qt as defineAnnotation, R as defaultKeyGenerator, Rt as ContainerRenderProps, S as InlineObjectSchemaType, T as OfDefinition, Tt as RegisteredBlockObject, U as EditorProvider, Ut as InlineObjectRender, V as EditorSelector, Vt as DecoratorRenderProps, W as EditorProviderProps, Wt as InlineObjectRenderProps, X as Operation, Xt as TextBlockRender, Y as MutationEvent, Yt as TextBlock, Zt as TextBlockRenderProps, _ as BlockObjectSchemaType, _t as PortableTextEditable, an as AnnotationPath, at as EditorSelectionPoint, b as FieldDefinition, bt as PortableTextEditor, ct as OnPasteFn, dt as PasteData, en as defineContainer, et as EditorContext, f as PatchesEvent, ft as RangeDecoration, g as BlockObjectDefinition, gt as ScrollSelectionIntoViewFunction, h as BaseDefinition, ht as RenderPlaceholderFunction, in as defineTextBlock, it as EditorSelection, j as PortableTextTextBlock, jt as AnnotationRender, k as PortableTextObject, kt as RegisteredSpan, ln as Path, lt as OnPasteResult, m as AnnotationSchemaType, mt as RenderEditableFunction, nn as defineInlineObject, nt as AddedAnnotationPaths, on as BlockPath, ot as InvalidValueResolution, p as AnnotationDefinition, pt as RangeDecorationOnMovedDetails, q as EditorEvent, qt as SpanRender, rn as defineSpan, rt as EditableAPIDeleteOptions, sn as ChildPath, st as OnCopyFn, tn as defineDecorator, tt as EditorSnapshot, ut as OnPasteResultOrPromise, v as DecoratorDefinition, vt as PortableTextEditableProps, w as ListSchemaType, wt as Containers, x as InlineObjectDefinition, y as DecoratorSchemaType, yt as HotkeyOptions, z as usePortableTextEditorSelection, zt as Decorator } from "./behavior.types.action-C0XDEQnB.js";
 export { type AddedAnnotationPaths, type Annotation, type AnnotationDefinition, type AnnotationPath, type AnnotationRender, type AnnotationRenderProps, type AnnotationSchemaType, type BaseDefinition, type BlockObject, type BlockObjectDefinition, type BlockObjectRender, type BlockObjectRenderProps, type BlockObjectSchemaType, type BlockOffset, type BlockPath, type ChildPath, type Container, type ContainerRender, type ContainerRenderProps, type Containers, type Decorator, type DecoratorDefinition, type DecoratorRender, type DecoratorRenderProps, type DecoratorSchemaType, type EditableAPIDeleteOptions, type Editor, type EditorConfig, type EditorContext, type EditorEmittedEvent, type EditorEvent, EditorProvider, type EditorProviderProps, type EditorSchema, type EditorSelection, type EditorSelectionPoint, type EditorSelector, type EditorSnapshot, type FieldDefinition, type HotkeyOptions, type InlineObject, type InlineObjectDefinition, type InlineObjectRender, type InlineObjectRenderProps, type InlineObjectSchemaType, type InvalidValueResolution, type ListDefinition, type ListSchemaType, type MutationEvent, type OfDefinition, type OnCopyFn, type OnPasteFn, type OnPasteResult, type OnPasteResultOrPromise, type Operation, type PasteData, type Patch, type PatchesEvent, type Path, type PortableTextBlock, type PortableTextChild, PortableTextEditable, type PortableTextEditableProps, PortableTextEditor, type PortableTextObject, type PortableTextSpan, type PortableTextTextBlock, type RangeDecoration, type RangeDecorationOnMovedDetails, type RegisteredBlockObject, type RegisteredContainer, type RegisteredInlineObject, type RegisteredPositional, type RegisteredSpan, type RegistrableNode, type RenderEditableFunction, type RenderPlaceholderFunction, type SchemaDefinition, type ScrollSelectionIntoViewFunction, type Span, type SpanRender, type SpanRenderProps, type StyleDefinition, type StyleSchemaType, type TextBlock, type TextBlockRender, type TextBlockRenderProps, defineAnnotation, defineBlockObject, defineContainer, defineDecorator, defineInlineObject, defineSchema, defineSpan, defineTextBlock, defaultKeyGenerator as keyGenerator, useEditor, useEditorSelector, usePortableTextEditor, usePortableTextEditorSelection };

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",
@@ -2789,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]);
 	/**
@@ -2846,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);
@@ -2864,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, {
@@ -4116,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);
 }
@@ -4192,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: {},
@@ -4213,6 +4229,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 				}
 				rangeDecorationState.push({
 					rangeDecoration,
+					merge: mergeRangeDecoration,
 					...rangeDecoration.selection
 				});
 			}
@@ -4232,6 +4249,7 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 				}
 				rangeDecorationState.push({
 					rangeDecoration,
+					merge: mergeRangeDecoration,
 					...rangeDecoration.selection
 				});
 			}
@@ -4260,7 +4278,8 @@ const engineOperationCallback = ({ input, sendBack }) => subscribeToOperations(i
 					rangeDecoration: {
 						...decoratedRange.rangeDecoration,
 						selection: newRange || currentSelection
-					}
+					},
+					merge: mergeRangeDecoration
 				});
 			}
 			context.editorEngine.decoratedRanges = rangeDecorationState;
@@ -5168,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;
@@ -7543,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,
@@ -7553,7 +7575,7 @@ function applyMergeNode(editor, path, position) {
 						],
 						node: child,
 						position: "before"
-					}) : editor.apply({
+					} : {
 						type: "insert",
 						path: [
 							...prevPath,
@@ -7562,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",
@@ -11610,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
@@ -11942,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({
@@ -13138,7 +13235,7 @@ const abstractAnnotationBehaviors = [
 			}, previousBlockEndPoint = getBlockEndPoint({
 				context: snapshot.context,
 				block: previousBlock
-			}), { renamedBlock, renameActions } = planMergeKeyRenames({
+			}), { renamedBlock, renameActions } = planMergeKeyRenameActions({
 				context: snapshot.context,
 				mergingBlockPath: focusTextBlock.path,
 				mergingBlock: focusTextBlock.node,
@@ -13236,7 +13333,7 @@ const abstractAnnotationBehaviors = [
 			if (!focusTextBlock) return !1;
 			let nextSibling = getSibling(adjustedSnapshot, focusTextBlock.path, { direction: "next" });
 			if (!nextSibling || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlock(snapshot.context, nextSibling.node)) return !1;
-			let { renamedBlock, renameActions } = planMergeKeyRenames({
+			let { renamedBlock, renameActions } = planMergeKeyRenameActions({
 				context: snapshot.context,
 				mergingBlockPath: nextSibling.path,
 				mergingBlock: nextSibling.node,
@@ -13332,65 +13429,38 @@ const abstractAnnotationBehaviors = [
 	})
 ];
 /**
-* A block merge folds `mergingBlock`'s children (and markDefs) into
-* `destinationBlock` by key. Any key the merging block shares with the
-* destination has to be renamed before the merge, or `insert.block`'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.
-*
-* Renames are raised as `set`/`child.set` events against the still-living
-* `mergingBlock`, so they land on the wire before the merge's `unset`.
-* `renamedBlock` mirrors the same renames applied to the value the caller
-* already captured, since raising the rename events now doesn't change
-* that captured value.
+* 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 planMergeKeyRenames(args) {
-	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, destinationChildKeys = new Set(destinationBlock.children.map((child) => child._key)), destinationMarkDefKeys = new Set((destinationBlock.markDefs ?? []).map((markDef) => markDef._key)), markDefKeyMap = /* @__PURE__ */ new Map(), renamedMarkDefs = mergingBlock.markDefs?.map((markDef) => {
-		if (!destinationMarkDefKeys.has(markDef._key)) return markDef;
-		let newKey = context.keyGenerator();
-		return markDefKeyMap.set(markDef._key, newKey), {
-			...markDef,
-			_key: newKey
-		};
+function planMergeKeyRenameActions(args) {
+	let { context, mergingBlockPath, mergingBlock, destinationBlock } = args, { renamedBlock, childRenames, markDefRenames } = planMergeKeyRenames({
+		context,
+		mergingBlock,
+		destinationBlock,
+		dedupeEqualMarkDefs: !1
 	}), renameActions = [];
-	for (let markDef of mergingBlock.markDefs ?? []) {
-		let newKey = markDefKeyMap.get(markDef._key);
-		newKey && renameActions.push(raise$1({
-			type: "set",
-			at: [
-				...mergingBlockPath,
-				"markDefs",
-				{ _key: markDef._key },
-				"_key"
-			],
-			value: newKey
-		}));
-	}
-	let 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 && renameActions.push(raise$1({
-			type: "child.set",
-			at: [
-				...mergingBlockPath,
-				"children",
-				{ _key: child._key }
-			],
-			props
-		})), marksChanged ? {
-			...child,
-			_key: newKey,
-			marks: remappedMarks
-		} : {
-			...child,
-			_key: newKey
-		};
-	});
+	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: {
-			...mergingBlock,
-			children: renamedChildren,
-			...mergingBlock.markDefs ? { markDefs: renamedMarkDefs } : {}
-		},
+		renamedBlock,
 		renameActions
 	};
 }
@@ -16542,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) => {