@portabletext/editor 6.2.0 → 6.3.1

package/lib/index.js

@@ -1,7 +1,7 @@
-import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
-import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, Fragment, useReducer, useCallback, useMemo, memo, forwardRef, Component, startTransition } from "react";
+import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, useReducer, useCallback, useMemo, memo, forwardRef, Component, startTransition } from "react";
 import rawDebug from "debug";
 import { createKeyboardShortcut, code, underline, italic as italic$1, bold as bold$1, undo as undo$1, redo as redo$1 } from "@portabletext/keyboard-shortcuts";
 import { getBlockEndPoint, getBlockStartPoint, getBlockKeyFromSelectionPoint, isSelectionCollapsed, isKeyedSegment, isEqualSelectionPoints, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, isListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject, isEqualPathSegments } from "./_chunks-es/util.slice-blocks.js";
@@ -44,10 +44,6 @@ const debug$1 = {
         return Path.isPath(value.path) && isObject(value.node);
       case "insert_text":
         return typeof value.offset == "number" && typeof value.text == "string" && Path.isPath(value.path);
-      case "merge_node":
-        return typeof value.position == "number" && Path.isPath(value.path) && isObject(value.properties);
-      case "move_node":
-        return Path.isPath(value.path) && Path.isPath(value.newPath);
       case "remove_node":
         return Path.isPath(value.path) && isObject(value.node);
       case "remove_text":
@@ -56,8 +52,6 @@ const debug$1 = {
         return Path.isPath(value.path) && isObject(value.properties) && isObject(value.newProperties);
       case "set_selection":
         return value.properties === null && Range.isRange(value.newProperties) || value.newProperties === null && Range.isRange(value.properties) || isObject(value.properties) && isObject(value.newProperties);
-      case "split_node":
-        return Path.isPath(value.path) && typeof value.position == "number" && isObject(value.properties);
       default:
         return !1;
     }
@@ -77,32 +71,6 @@ const debug$1 = {
           ...op,
           type: "remove_text"
         };
-      case "merge_node":
-        return {
-          ...op,
-          type: "split_node",
-          path: Path.previous(op.path)
-        };
-      case "move_node": {
-        const {
-          newPath,
-          path: path2
-        } = op;
-        if (Path.equals(newPath, path2))
-          return op;
-        if (Path.isSibling(path2, newPath))
-          return {
-            ...op,
-            path: newPath,
-            newPath: path2
-          };
-        const inversePath = Path.transform(path2, op), inverseNewPath = Path.transform(Path.next(path2), op);
-        return {
-          ...op,
-          path: inversePath,
-          newPath: inverseNewPath
-        };
-      }
       case "remove_node":
         return {
           ...op,
@@ -143,12 +111,6 @@ const debug$1 = {
           newProperties: properties
         };
       }
-      case "split_node":
-        return {
-          ...op,
-          type: "merge_node",
-          path: Path.next(op.path)
-        };
     }
   }
 }, Range = {
@@ -505,14 +467,11 @@ const debug$1 = {
 }, PathRef = {
   transform(ref, op) {
     const {
-      current,
-      affinity
+      current
     } = ref;
     if (current == null)
       return;
-    const path2 = Path.transform(current, op, {
-      affinity
-    });
+    const path2 = Path.transform(current, op);
     ref.current = path2, path2 == null && ref.unref();
   }
 }, Path = {
@@ -595,9 +554,6 @@ const debug$1 = {
     switch (operation.type) {
       case "insert_node":
       case "remove_node":
-      case "merge_node":
-      case "split_node":
-      case "move_node":
         return !0;
       default:
         return !1;
@@ -616,12 +572,10 @@ const debug$1 = {
       throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
     return path2.slice(0, -1).concat(last - 1);
   },
-  transform(path2, operation, options = {}) {
+  transform(path2, operation) {
     if (!path2)
       return null;
-    const p = [...path2], {
-      affinity = "forward"
-    } = options;
+    const p = [...path2];
     if (path2.length === 0)
       return p;
     switch (operation.type) {
@@ -641,40 +595,6 @@ const debug$1 = {
         Path.endsBefore(op, p) && (p[op.length - 1] = p[op.length - 1] - 1);
         break;
       }
-      case "merge_node": {
-        const {
-          path: op,
-          position
-        } = operation;
-        Path.equals(op, p) || Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] - 1 : Path.isAncestor(op, p) && (p[op.length - 1] = p[op.length - 1] - 1, p[op.length] = p[op.length] + position);
-        break;
-      }
-      case "split_node": {
-        const {
-          path: op,
-          position
-        } = operation;
-        if (Path.equals(op, p)) {
-          if (affinity === "forward")
-            p[p.length - 1] = p[p.length - 1] + 1;
-          else if (affinity !== "backward")
-            return null;
-        } else Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] + 1 : Path.isAncestor(op, p) && path2[op.length] >= position && (p[op.length - 1] = p[op.length - 1] + 1, p[op.length] = p[op.length] - position);
-        break;
-      }
-      case "move_node": {
-        const {
-          path: op,
-          newPath: onp
-        } = operation;
-        if (Path.equals(op, onp))
-          return p;
-        if (Path.isAncestor(op, p) || Path.equals(op, p)) {
-          const copy = onp.slice();
-          return Path.endsBefore(op, onp) && op.length < onp.length && (copy[op.length - 1] = copy[op.length - 1] - 1), copy.concat(p.slice(op.length));
-        } else Path.isSibling(op, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p)) ? Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] - 1 : p[op.length - 1] = p[op.length - 1] + 1 : Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p) ? (Path.endsBefore(op, p) && (p[op.length - 1] = p[op.length - 1] - 1), p[onp.length - 1] = p[onp.length - 1] + 1) : Path.endsBefore(op, p) && (Path.equals(onp, p) && (p[onp.length - 1] = p[onp.length - 1] + 1), p[op.length - 1] = p[op.length - 1] - 1);
-        break;
-      }
     }
     return p;
   }
@@ -719,19 +639,14 @@ const debug$1 = {
       offset
     } = point2;
     switch (op.type) {
-      case "insert_node":
-      case "move_node": {
-        path2 = Path.transform(path2, op, options);
+      case "insert_node": {
+        path2 = Path.transform(path2, op);
         break;
       }
       case "insert_text": {
         Path.equals(op.path, path2) && (op.offset < offset || op.offset === offset && affinity === "forward") && (offset += op.text.length);
         break;
       }
-      case "merge_node": {
-        Path.equals(op.path, path2) && (offset += op.position), path2 = Path.transform(path2, op, options);
-        break;
-      }
       case "remove_text": {
         Path.equals(op.path, path2) && op.offset <= offset && (offset -= Math.min(offset - op.offset, op.text.length));
         break;
@@ -739,19 +654,7 @@ const debug$1 = {
       case "remove_node": {
         if (Path.equals(op.path, path2) || Path.isAncestor(op.path, path2))
           return null;
-        path2 = Path.transform(path2, op, options);
-        break;
-      }
-      case "split_node": {
-        if (Path.equals(op.path, path2)) {
-          if (op.position === offset && affinity == null)
-            return null;
-          (op.position < offset || op.position === offset && affinity === "forward") && (offset -= op.position, path2 = Path.transform(path2, op, {
-            ...options,
-            affinity: "forward"
-          }));
-        } else
-          path2 = Path.transform(path2, op, options);
+        path2 = Path.transform(path2, op);
         break;
       }
       default:
@@ -775,9 +678,24 @@ const debug$1 = {
     });
     ref.current = path2, path2 == null && ref.unref();
   }
-}, Scrubber = {
+};
+function safeStringify(value, space) {
+  try {
+    return JSON.stringify(value, null, space);
+  } catch (error) {
+    return console.error(error), "JSON.stringify failed";
+  }
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    return console.error(error), "JSON.parse failed";
+  }
+}
+const Scrubber = {
   stringify(value) {
-    return JSON.stringify(value);
+    return safeStringify(value);
   }
 }, Text$1 = {
   equals(text, another, options = {}) {
@@ -1413,38 +1331,38 @@ const apply$1 = (editor, op) => {
   } = editor;
   return selection ? Node$1.fragment(editor, selection, editor.schema) : [];
 };
-function applyMergeNode(editor, path2, position, properties) {
-  const node2 = Node$1.get(editor, path2, editor.schema), prevPath = Path.previous(path2), mergeOp = {
-    type: "merge_node",
-    path: path2,
-    position,
-    properties
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, mergeOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, mergeOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, mergeOp);
-  if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel)) {
-      const result = Point.transform(point2, mergeOp);
-      result && (sel[key] = result);
+function applyMergeNode(editor, path2, position) {
+  const node2 = Node$1.get(editor, path2, editor.schema), prevPath = Path.previous(path2);
+  for (const ref of Editor.pathRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPathForMerge(current, path2, position));
+  }
+  for (const ref of Editor.pointRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPointForMerge(current, path2, position));
+  }
+  for (const ref of Editor.rangeRefs(editor)) {
+    const current = ref.current;
+    if (current) {
+      const anchor = transformPointForMerge(current.anchor, path2, position), focus = transformPointForMerge(current.focus, path2, position);
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
     }
-    editor.selection = sel;
+  }
+  if (editor.selection) {
+    const anchor = transformPointForMerge(editor.selection.anchor, path2, position), focus = transformPointForMerge(editor.selection.focus, path2, position);
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
   }
   const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
   Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
   const savedSelection = editor.selection, editorAny = editor, savedPendingDiffs = editorAny.pendingDiffs, savedPendingSelection = editorAny.pendingSelection, savedPendingAction = editorAny.pendingAction;
-  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, mergeOp)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
-    const sel = savedPendingSelection, anchor = Point.transform(sel.anchor, mergeOp, {
-      affinity: "backward"
-    }), focus = Point.transform(sel.focus, mergeOp, {
-      affinity: "backward"
-    });
+  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, path2, position)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
+    const sel = savedPendingSelection, anchor = transformPointForMerge(sel.anchor, path2, position), focus = transformPointForMerge(sel.focus, path2, position);
     editorAny.pendingSelection = anchor && focus ? {
       anchor,
       focus
@@ -1452,20 +1370,14 @@ function applyMergeNode(editor, path2, position, properties) {
   }
   if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
     const action = savedPendingAction;
-    if (Point.isPoint(action.at)) {
-      const at = Point.transform(action.at, mergeOp, {
-        affinity: "backward"
-      });
+    if ("offset" in action.at && typeof action.at.offset == "number") {
+      const at = transformPointForMerge(action.at, path2, position);
       editorAny.pendingAction = at ? {
         ...action,
         at
       } : null;
     } else if (Range.isRange(action.at)) {
-      const anchor = Point.transform(action.at.anchor, mergeOp, {
-        affinity: "backward"
-      }), focus = Point.transform(action.at.focus, mergeOp, {
-        affinity: "backward"
-      });
+      const anchor = transformPointForMerge(action.at.anchor, path2, position), focus = transformPointForMerge(action.at.focus, path2, position);
       editorAny.pendingAction = anchor && focus ? {
         ...action,
         at: {
@@ -1516,14 +1428,14 @@ function applyMergeNode(editor, path2, position, properties) {
     editorAny.pendingDiffs = preTransformedPendingDiffs, editorAny.pendingSelection = preTransformedPendingSelection, editorAny.pendingAction = preTransformedPendingAction;
   }
 }
-function transformTextDiffForMerge(textDiff, op) {
+function transformTextDiffForMerge(textDiff, mergePath, position) {
   const {
     path: path2,
     diff: diff2,
     id
   } = textDiff;
-  if (!Path.equals(op.path, path2)) {
-    const newPath = Path.transform(path2, op);
+  if (!Path.equals(mergePath, path2)) {
+    const newPath = transformPathForMerge(path2, mergePath, position);
     return newPath ? {
       diff: diff2,
       id,
@@ -1532,12 +1444,26 @@ function transformTextDiffForMerge(textDiff, op) {
   }
   return {
     diff: {
-      start: diff2.start + op.position,
-      end: diff2.end + op.position,
+      start: diff2.start + position,
+      end: diff2.end + position,
       text: diff2.text
     },
     id,
-    path: Path.transform(path2, op)
+    path: transformPathForMerge(path2, mergePath, position)
+  };
+}
+function transformPathForMerge(path2, mergePath, position) {
+  const p = [...path2];
+  return Path.equals(mergePath, p) || Path.endsBefore(mergePath, p) ? p[mergePath.length - 1] = p[mergePath.length - 1] - 1 : Path.isAncestor(mergePath, p) && (p[mergePath.length - 1] = p[mergePath.length - 1] - 1, p[mergePath.length] = p[mergePath.length] + position), p;
+}
+function transformPointForMerge(point2, mergePath, position) {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return Path.equals(mergePath, path2) && (offset += position), path2 = transformPathForMerge(path2, mergePath, position), {
+    path: path2,
+    offset
   };
 }
 const normalizeNode = (editor, entry) => {
@@ -1572,11 +1498,8 @@ const normalizeNode = (editor, entry) => {
           else if (Text$1.equals(child, prev, {
             loose: !0
           })) {
-            const mergePath = path2.concat(n2), {
-              text: _text,
-              ...properties
-            } = child;
-            applyMergeNode(editor, mergePath, prev.text.length, properties), element = Node$1.get(editor, path2, editor.schema), n2--;
+            const mergePath = path2.concat(n2);
+            applyMergeNode(editor, mergePath, prev.text.length), element = Node$1.get(editor, path2, editor.schema), n2--;
           }
         }
       } else if (Element$2.isElement(child, editor.schema))
@@ -2175,26 +2098,44 @@ const previous = (editor, options = {}) => {
   }
   Editor.normalize(editor);
 }, shouldMergeNodesRemovePrevNode = (_editor, [prevNode, prevPath], [_curNode, _curNodePath]) => Element$2.isElement(prevNode, _editor.schema) && (prevNode.children.length === 0 || prevNode.children.length === 1 && Text$1.isText(prevNode.children[0], _editor.schema) && prevNode.children[0].text === "") || Text$1.isText(prevNode, _editor.schema) && prevNode.text === "" && prevPath[prevPath.length - 1] !== 0;
+function rangeRefAffinities(range2, affinity) {
+  if (affinity === "inward") {
+    const isCollapsed = Range.isCollapsed(range2);
+    if (Range.isForward(range2)) {
+      const anchorAffinity = "forward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "backward"];
+    } else {
+      const anchorAffinity = "backward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "forward"];
+    }
+  } else return affinity === "outward" ? Range.isForward(range2) ? ["backward", "forward"] : ["forward", "backward"] : [affinity, affinity];
+}
 function applySplitNode(editor, path2, position, properties) {
-  const node2 = Node$1.get(editor, path2, editor.schema), splitOp = {
-    type: "split_node",
-    path: path2,
-    position,
-    properties
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, splitOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, splitOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, splitOp);
+  const node2 = Node$1.get(editor, path2, editor.schema);
+  for (const ref of Editor.pathRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPathForSplit(current, path2, position, ref.affinity ?? "forward"));
+  }
+  for (const ref of Editor.pointRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPointForSplit(current, path2, position, ref.affinity ?? "forward"));
+  }
+  for (const ref of Editor.rangeRefs(editor)) {
+    const current = ref.current;
+    if (current) {
+      const [anchorAffinity, focusAffinity] = rangeRefAffinities(current, ref.affinity), anchor = transformPointForSplit(current.anchor, path2, position, anchorAffinity ?? "forward"), focus = transformPointForSplit(current.focus, path2, position, focusAffinity ?? "forward");
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
+    }
+  }
   if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel))
-      sel[key] = Point.transform(point2, splitOp);
-    editor.selection = sel;
+    const anchor = transformPointForSplit(editor.selection.anchor, path2, position, "forward"), focus = transformPointForSplit(editor.selection.focus, path2, position, "forward");
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
   }
   const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
   Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
@@ -2244,6 +2185,20 @@ function applySplitNode(editor, path2, position, properties) {
       Editor.rangeRefs(editor).add(ref);
   }
 }
+function transformPathForSplit(path2, splitPath, position, affinity = "forward") {
+  const p = [...path2];
+  return Path.equals(splitPath, p) ? affinity === "forward" && (p[p.length - 1] = p[p.length - 1] + 1) : Path.endsBefore(splitPath, p) ? p[splitPath.length - 1] = p[splitPath.length - 1] + 1 : Path.isAncestor(splitPath, p) && path2[splitPath.length] >= position && (p[splitPath.length - 1] = p[splitPath.length - 1] + 1, p[splitPath.length] = p[splitPath.length] - position), p;
+}
+function transformPointForSplit(point2, splitPath, position, affinity = "forward") {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return Path.equals(splitPath, path2) ? (position < offset || position === offset && affinity === "forward") && (offset -= position, path2 = transformPathForSplit(path2, splitPath, position, "forward")) : path2 = transformPathForSplit(path2, splitPath, position, affinity), {
+    path: path2,
+    offset
+  };
+}
 const insertNodes = (editor, nodes2, options = {}) => {
   Editor.withoutNormalizing(editor, () => {
     const {
@@ -2486,55 +2441,6 @@ const insertNodes = (editor, nodes2, options = {}) => {
     });
   }
 };
-function applyMoveNode(editor, path2, newPath) {
-  if (Path.equals(path2, newPath))
-    return;
-  if (Path.isAncestor(path2, newPath))
-    throw new Error(`Cannot move a path [${path2}] to new path [${newPath}] because the destination is inside itself.`);
-  const node2 = Node$1.get(editor, path2, editor.schema), moveOp = {
-    type: "move_node",
-    path: path2,
-    newPath
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, moveOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, moveOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, moveOp);
-  if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel))
-      sel[key] = Point.transform(point2, moveOp);
-    editor.selection = sel;
-  }
-  const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
-  Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
-  const savedSelection = editor.selection;
-  try {
-    Editor.withoutNormalizing(editor, () => {
-      editor.apply({
-        type: "remove_node",
-        path: path2,
-        node: node2
-      }), editor.apply({
-        type: "insert_node",
-        path: newPath,
-        node: node2
-      });
-    });
-  } finally {
-    editor.selection = savedSelection;
-    for (const ref of pathRefs)
-      Editor.pathRefs(editor).add(ref);
-    for (const ref of pointRefs)
-      Editor.pointRefs(editor).add(ref);
-    for (const ref of rangeRefs)
-      Editor.rangeRefs(editor).add(ref);
-  }
-}
 function applySetNode(editor, props, path2) {
   const node2 = Node$1.get(editor, path2, editor.schema), propsRecord = props, properties = {}, newProperties = {};
   for (const key of Object.keys(propsRecord))
@@ -2698,22 +2604,26 @@ const deleteText = (editor, options = {}) => {
             mode: "highest",
             match: (n2) => levels2.includes(n2) && hasSingleChildNest(n2)
           }), emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);
-          let properties, position;
-          if (Text$1.isText(mergeNode, editor.schema) && Text$1.isText(prevNode, editor.schema)) {
-            const {
-              text: _text,
-              ...rest
-            } = mergeNode;
-            position = prevNode.text.length, properties = rest;
-          } else if (Element$2.isElement(mergeNode, editor.schema) && Element$2.isElement(prevNode, editor.schema)) {
-            const {
-              children: _children,
-              ...rest
-            } = mergeNode;
-            position = prevNode.children.length, properties = rest;
-          } else
+          let position;
+          if (Text$1.isText(mergeNode, editor.schema) && Text$1.isText(prevNode, editor.schema))
+            position = prevNode.text.length;
+          else if (Element$2.isElement(mergeNode, editor.schema) && Element$2.isElement(prevNode, editor.schema))
+            position = prevNode.children.length;
+          else
             throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${Scrubber.stringify(mergeNode)} ${Scrubber.stringify(prevNode)}`);
-          if (isPreviousSibling || applyMoveNode(editor, mergePath, newPath), emptyRef && Transforms.removeNodes(editor, {
+          if (!isPreviousSibling) {
+            const moveNode = Node$1.get(editor, mergePath, editor.schema);
+            editor.apply({
+              type: "remove_node",
+              path: mergePath,
+              node: moveNode
+            }), editor.apply({
+              type: "insert_node",
+              path: newPath,
+              node: moveNode
+            });
+          }
+          if (emptyRef && Transforms.removeNodes(editor, {
             at: emptyRef.current,
             voids
           }), Editor.shouldMergeNodesRemovePrevNode(editor, prev, current))
@@ -2729,7 +2639,7 @@ const deleteText = (editor, options = {}) => {
                 markDefs: newMarkDefs
               }, targetPath);
             }
-            applyMergeNode(pteEditor, newPath, position, properties);
+            applyMergeNode(pteEditor, newPath, position);
           }
           emptyRef && emptyRef.unref();
         }
@@ -2823,7 +2733,7 @@ const deleteText = (editor, options = {}) => {
 }, isDOMSelection = (value) => {
   const window2 = value && value.anchorNode && getDefaultView(value.anchorNode);
   return !!window2 && value instanceof window2.Selection;
-}, isDOMText = (value) => isDOMNode(value) && value.nodeType === 3, isPlainTextOnlyPaste = (event) => event.clipboardData && event.clipboardData.getData("text/plain") !== "" && event.clipboardData.types.length === 1, normalizeDOMPoint = (domPoint) => {
+}, isPlainTextOnlyPaste = (event) => event.clipboardData && event.clipboardData.getData("text/plain") !== "" && event.clipboardData.types.length === 1, normalizeDOMPoint = (domPoint) => {
   let [node2, offset] = domPoint;
   if (isDOMElement(node2) && node2.childNodes.length) {
     let isLast = offset === node2.childNodes.length, index = isLast ? offset - 1 : offset;
@@ -2862,18 +2772,6 @@ const deleteText = (editor, options = {}) => {
 }, getEditableChild = (parent2, index, direction) => {
   const [child] = getEditableChildAndIndex(parent2, index, direction);
   return child;
-}, getPlainText = (domNode) => {
-  let text = "";
-  if (isDOMText(domNode) && domNode.nodeValue)
-    return domNode.nodeValue;
-  if (isDOMElement(domNode)) {
-    for (const childNode of Array.from(domNode.childNodes))
-      text += getPlainText(childNode);
-    const display = getComputedStyle(domNode).getPropertyValue("display");
-    (display === "block" || display === "list" || domNode.tagName === "BR") && (text += `
-`);
-  }
-  return text;
 }, getSelection = (root) => "getSelection" in root && typeof root.getSelection == "function" ? root.getSelection() : document.getSelection(), isTrackedMutation = (editor, mutation, batch) => {
   const {
     target
@@ -3075,7 +2973,6 @@ const DOMEditor = {
     const slateNode = DOMEditor.hasTarget(editor, target) && DOMEditor.toSlateNode(editor, target);
     return !!slateNode && editor.isObjectNode(slateNode);
   },
-  setFragmentData: (editor, data, originEvent) => editor.setFragmentData(data, originEvent),
   toDOMNode: (editor, node2) => {
     const domNode = Editor.isEditor(node2) ? editor.domElement : editor.keyToElement?.get(DOMEditor.findKey(editor, node2));
     if (!domNode)
@@ -3497,7 +3394,7 @@ function transformPendingPoint(editor, point2, op) {
   }, transformed = Point.transform(anchor, op, {
     affinity: "backward"
   });
-  return transformed ? op.type === "split_node" && Path.equals(op.path, point2.path) && anchor.offset < op.position && diff2.start < op.position ? transformed : {
+  return transformed ? {
     path: transformed.path,
     offset: transformed.offset + diff2.text.length - diff2.end + diff2.start
   } : null;
@@ -3618,39 +3515,6 @@ const withDOM = (editor) => {
       const [node2] = Editor.node(e, path2);
       e.nodeToKey.set(node2, key);
     }
-  }, e.setFragmentData = (data) => {
-    const {
-      selection
-    } = e;
-    if (!selection)
-      return;
-    const [start2, end2] = Range.edges(selection), startVoid = Editor.void(e, {
-      at: start2.path
-    }), endVoid = Editor.void(e, {
-      at: end2.path
-    });
-    if (Range.isCollapsed(selection) && !startVoid)
-      return;
-    const domRange = DOMEditor.toDOMRange(e, selection);
-    let contents = domRange.cloneContents(), attach = contents.childNodes[0];
-    if (contents.childNodes.forEach((node2) => {
-      node2.textContent && node2.textContent.trim() !== "" && (attach = node2);
-    }), endVoid) {
-      const [voidNode] = endVoid, r = domRange.cloneRange(), domNode = DOMEditor.toDOMNode(e, voidNode);
-      r.setEndAfter(domNode), contents = r.cloneContents();
-    }
-    if (startVoid && (attach = contents.querySelector("[data-slate-spacer]")), Array.from(contents.querySelectorAll("[data-slate-zero-width]")).forEach((zw) => {
-      const isNewline = zw.getAttribute("data-slate-zero-width") === "n";
-      zw.textContent = isNewline ? `
-` : "";
-    }), isDOMText(attach)) {
-      const span = attach.ownerDocument.createElement("span");
-      span.style.whiteSpace = "pre", span.appendChild(attach), contents.appendChild(span), attach = span;
-    }
-    const fragment = e.getFragment(), string2 = JSON.stringify(fragment), encoded = window.btoa(encodeURIComponent(string2));
-    attach.setAttribute("data-slate-fragment", encoded), data.setData("application/x-slate-fragment", encoded);
-    const div = contents.ownerDocument.createElement("div");
-    return div.appendChild(contents), div.setAttribute("hidden", "true"), contents.ownerDocument.body.appendChild(div), data.setData("text/html", div.innerHTML), data.setData("text/plain", getPlainText(div)), contents.ownerDocument.body.removeChild(div), data;
   }, e.insertData = (data) => {
     e.insertTextData(data);
   }, e.insertTextData = (data) => {
@@ -5200,480 +5064,6 @@ const MUTATION_OBSERVER_CONFIG$1 = {
   }));
   return useMutationObserver(node2, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1), editor.scheduleFlush = inputManager.scheduleFlush, isMounted && inputManager.flush(), inputManager;
 } : () => null;
-class ChildrenHelper {
-  /**
-   * Sparse array of Slate node keys, each index corresponding to an index in
-   * the children array
-   *
-   * Fetching the key for a Slate node is expensive, so we cache them here.
-   */
-  /**
-   * The index of the next node to be read in the children array
-   */
-  constructor(editor, children) {
-    this.editor = editor, this.children = children, this.cachedKeys = new Array(children.length), this.pointerIndex = 0;
-  }
-  /**
-   * Read a given number of nodes, advancing the pointer by that amount
-   */
-  read(n2) {
-    if (n2 === 1)
-      return [this.children[this.pointerIndex++]];
-    const slicedChildren = this.remaining(n2);
-    return this.pointerIndex += n2, slicedChildren;
-  }
-  /**
-   * Get the remaining children without advancing the pointer
-   *
-   * @param [maxChildren] Limit the number of children returned.
-   */
-  remaining(maxChildren) {
-    return maxChildren === void 0 ? this.children.slice(this.pointerIndex) : this.children.slice(this.pointerIndex, this.pointerIndex + maxChildren);
-  }
-  /**
-   * Whether all children have been read
-   */
-  get reachedEnd() {
-    return this.pointerIndex >= this.children.length;
-  }
-  /**
-   * Determine whether a node with a given key appears in the unread part of the
-   * children array, and return its index relative to the current pointer if so
-   *
-   * Searching for the node object itself using indexOf is most efficient, but
-   * will fail to locate nodes that have been modified. In this case, nodes
-   * should be identified by their keys instead.
-   *
-   * Searching an array of keys using indexOf is very inefficient since fetching
-   * the keys for all children in advance is very slow. Insead, if the node
-   * search fails to return a value, fetch the keys of each remaining child one
-   * by one and compare it to the known key.
-   */
-  lookAhead(node2, key) {
-    const elementResult = this.children.indexOf(node2, this.pointerIndex);
-    if (elementResult > -1)
-      return elementResult - this.pointerIndex;
-    for (let i = this.pointerIndex; i < this.children.length; i++) {
-      const candidateNode = this.children[i];
-      if (this.findKey(candidateNode, i) === key)
-        return i - this.pointerIndex;
-    }
-    return -1;
-  }
-  /**
-   * Convert an array of Slate nodes to an array of chunk leaves, each
-   * containing the node and its key
-   */
-  toChunkLeaves(nodes2, startIndex) {
-    return nodes2.map((node2, i) => ({
-      type: "leaf",
-      node: node2,
-      key: this.findKey(node2, startIndex + i),
-      index: startIndex + i
-    }));
-  }
-  /**
-   * Get the key for a Slate node, cached using the node's index
-   */
-  findKey(node2, index) {
-    const cachedKey = this.cachedKeys[index];
-    if (cachedKey)
-      return cachedKey;
-    const key = ReactEditor.findKey(this.editor, node2);
-    return this.cachedKeys[index] = key, key;
-  }
-}
-class ChunkTreeHelper {
-  /**
-   * The root of the chunk tree
-   */
-  /**
-   * The ideal size of a chunk
-   */
-  /**
-   * Whether debug mode is enabled
-   *
-   * If enabled, the pointer state will be checked for internal consistency
-   * after each mutating operation.
-   */
-  /**
-   * Whether the traversal has reached the end of the chunk tree
-   *
-   * When this is true, the pointerChunk and pointerIndex point to the last
-   * top-level node in the chunk tree, although pointerNode returns null.
-   */
-  /**
-   * The chunk containing the current node
-   */
-  /**
-   * The index of the current node within pointerChunk
-   *
-   * Can be -1 to indicate that the pointer is before the start of the tree.
-   */
-  /**
-   * Similar to a Slate path; tracks the path of pointerChunk relative to the
-   * root.
-   *
-   * Used to move the pointer from the current chunk to the parent chunk more
-   * efficiently.
-   */
-  /**
-   * Indexing the current chunk's children has a slight time cost, which adds up
-   * when traversing very large trees, so the current node is cached.
-   *
-   * A value of undefined means that the current node is not cached. This
-   * property must be set to undefined whenever the pointer is moved, unless
-   * the pointer is guaranteed to point to the same node that it did previously.
-   */
-  constructor(chunkTree, {
-    chunkSize,
-    debug: debug2
-  }) {
-    this.root = chunkTree, this.chunkSize = chunkSize, this.debug = debug2 ?? !1, this.pointerChunk = chunkTree, this.pointerIndex = -1, this.pointerIndexStack = [], this.reachedEnd = !1, this.validateState();
-  }
-  /**
-   * Move the pointer to the next leaf in the chunk tree
-   */
-  readLeaf() {
-    if (this.reachedEnd)
-      return null;
-    for (; ; )
-      if (this.pointerIndex + 1 < this.pointerSiblings.length) {
-        this.pointerIndex++, this.cachedPointerNode = void 0;
-        break;
-      } else {
-        if (this.pointerChunk.type === "root")
-          return this.reachedEnd = !0, null;
-        this.exitChunk();
-      }
-    return this.validateState(), this.enterChunkUntilLeaf(!1), this.pointerNode;
-  }
-  /**
-   * Move the pointer to the previous leaf in the chunk tree
-   */
-  returnToPreviousLeaf() {
-    if (this.reachedEnd) {
-      this.reachedEnd = !1, this.enterChunkUntilLeaf(!0);
-      return;
-    }
-    for (; ; )
-      if (this.pointerIndex >= 1) {
-        this.pointerIndex--, this.cachedPointerNode = void 0;
-        break;
-      } else if (this.pointerChunk.type === "root") {
-        this.pointerIndex = -1;
-        return;
-      } else
-        this.exitChunk();
-    this.validateState(), this.enterChunkUntilLeaf(!0);
-  }
-  /**
-   * Insert leaves before the current leaf, leaving the pointer unchanged
-   */
-  insertBefore(leaves) {
-    this.returnToPreviousLeaf(), this.insertAfter(leaves), this.readLeaf();
-  }
-  /**
-   * Insert leaves after the current leaf, leaving the pointer on the last
-   * inserted leaf
-   *
-   * The insertion algorithm first checks for any chunk we're currently at the
-   * end of that can receive additional leaves. Next, it tries to insert leaves
-   * at the starts of any subsequent chunks.
-   *
-   * Any remaining leaves are passed to rawInsertAfter to be chunked and
-   * inserted at the highest possible level.
-   */
-  insertAfter(leaves) {
-    if (leaves.length === 0)
-      return;
-    let beforeDepth = 0, afterDepth = 0;
-    for (; this.pointerChunk.type === "chunk" && this.pointerIndex === this.pointerSiblings.length - 1; ) {
-      const remainingCapacity = this.chunkSize - this.pointerSiblings.length, toInsertCount = Math.min(remainingCapacity, leaves.length);
-      if (toInsertCount > 0) {
-        const leavesToInsert = leaves.splice(0, toInsertCount);
-        this.rawInsertAfter(leavesToInsert, beforeDepth);
-      }
-      this.exitChunk(), beforeDepth++;
-    }
-    if (leaves.length === 0)
-      return;
-    const rawInsertPointer = this.savePointer();
-    let finalPointer = null;
-    if (this.readLeaf())
-      for (; this.pointerChunk.type === "chunk" && this.pointerIndex === 0; ) {
-        const remainingCapacity = this.chunkSize - this.pointerSiblings.length, toInsertCount = Math.min(remainingCapacity, leaves.length);
-        if (toInsertCount > 0) {
-          const leavesToInsert = leaves.splice(-toInsertCount, toInsertCount);
-          this.pointerIndex = -1, this.cachedPointerNode = void 0, this.rawInsertAfter(leavesToInsert, afterDepth), finalPointer || (finalPointer = this.savePointer());
-        }
-        this.exitChunk(), afterDepth++;
-      }
-    this.restorePointer(rawInsertPointer);
-    const minDepth = Math.max(beforeDepth, afterDepth);
-    this.rawInsertAfter(leaves, minDepth), finalPointer && this.restorePointer(finalPointer), this.validateState();
-  }
-  /**
-   * Remove the current node and decrement the pointer, deleting any ancestor
-   * chunk that becomes empty as a result
-   */
-  remove() {
-    this.pointerSiblings.splice(this.pointerIndex--, 1), this.cachedPointerNode = void 0, this.pointerSiblings.length === 0 && this.pointerChunk.type === "chunk" ? (this.exitChunk(), this.remove()) : this.invalidateChunk(), this.validateState();
-  }
-  /**
-   * Add the current chunk and all ancestor chunks to the list of modified
-   * chunks
-   */
-  invalidateChunk() {
-    for (let c2 = this.pointerChunk; c2.type === "chunk"; c2 = c2.parent)
-      this.root.modifiedChunks.add(c2);
-  }
-  /**
-   * Whether the pointer is at the start of the tree
-   */
-  get atStart() {
-    return this.pointerChunk.type === "root" && this.pointerIndex === -1;
-  }
-  /**
-   * The siblings of the current node
-   */
-  get pointerSiblings() {
-    return this.pointerChunk.children;
-  }
-  /**
-   * Get the current node (uncached)
-   *
-   * If the pointer is at the start or end of the document, returns null.
-   *
-   * Usually, the current node is a chunk leaf, although it can be a chunk
-   * while insertions are in progress.
-   */
-  getPointerNode() {
-    return this.reachedEnd || this.pointerIndex === -1 ? null : this.pointerSiblings[this.pointerIndex] ?? null;
-  }
-  /**
-   * Cached getter for the current node
-   */
-  get pointerNode() {
-    if (this.cachedPointerNode !== void 0)
-      return this.cachedPointerNode;
-    const pointerNode = this.getPointerNode();
-    return this.cachedPointerNode = pointerNode, pointerNode;
-  }
-  /**
-   * Get the path of a chunk relative to the root, returning null if the chunk
-   * is not connected to the root
-   */
-  getChunkPath(chunk) {
-    const path2 = [];
-    for (let c2 = chunk; c2.type === "chunk"; c2 = c2.parent) {
-      const index = c2.parent.children.indexOf(c2);
-      if (index === -1)
-        return null;
-      path2.unshift(index);
-    }
-    return path2;
-  }
-  /**
-   * Save the current pointer to be restored later
-   */
-  savePointer() {
-    if (this.atStart)
-      return "start";
-    if (!this.pointerNode)
-      throw new Error("Cannot save pointer when pointerNode is null");
-    return {
-      chunk: this.pointerChunk,
-      node: this.pointerNode
-    };
-  }
-  /**
-   * Restore the pointer to a previous state
-   */
-  restorePointer(savedPointer) {
-    if (savedPointer === "start") {
-      this.pointerChunk = this.root, this.pointerIndex = -1, this.pointerIndexStack = [], this.reachedEnd = !1, this.cachedPointerNode = void 0;
-      return;
-    }
-    const {
-      chunk,
-      node: node2
-    } = savedPointer, index = chunk.children.indexOf(node2);
-    if (index === -1)
-      throw new Error("Cannot restore point because saved node is no longer in saved chunk");
-    const indexStack = this.getChunkPath(chunk);
-    if (!indexStack)
-      throw new Error("Cannot restore point because saved chunk is no longer connected to root");
-    this.pointerChunk = chunk, this.pointerIndex = index, this.pointerIndexStack = indexStack, this.reachedEnd = !1, this.cachedPointerNode = node2, this.validateState();
-  }
-  /**
-   * Assuming the current node is a chunk, move the pointer into that chunk
-   *
-   * @param end If true, place the pointer on the last node of the chunk.
-   * Otherwise, place the pointer on the first node.
-   */
-  enterChunk(end2) {
-    if (this.pointerNode?.type !== "chunk")
-      throw new Error("Cannot enter non-chunk");
-    if (this.pointerIndexStack.push(this.pointerIndex), this.pointerChunk = this.pointerNode, this.pointerIndex = end2 ? this.pointerSiblings.length - 1 : 0, this.cachedPointerNode = void 0, this.validateState(), this.pointerChunk.children.length === 0)
-      throw new Error("Cannot enter empty chunk");
-  }
-  /**
-   * Assuming the current node is a chunk, move the pointer into that chunk
-   * repeatedly until the current node is a leaf
-   *
-   * @param end If true, place the pointer on the last node of the chunk.
-   * Otherwise, place the pointer on the first node.
-   */
-  enterChunkUntilLeaf(end2) {
-    for (; this.pointerNode?.type === "chunk"; )
-      this.enterChunk(end2);
-  }
-  /**
-   * Move the pointer to the parent chunk
-   */
-  exitChunk() {
-    if (this.pointerChunk.type === "root")
-      throw new Error("Cannot exit root");
-    const previousPointerChunk = this.pointerChunk;
-    this.pointerChunk = previousPointerChunk.parent, this.pointerIndex = this.pointerIndexStack.pop(), this.cachedPointerNode = void 0, this.validateState();
-  }
-  /**
-   * Insert leaves immediately after the current node, leaving the pointer on
-   * the last inserted leaf
-   *
-   * Leaves are chunked according to the number of nodes already in the parent
-   * plus the number of nodes being inserted, or the minimum depth if larger
-   */
-  rawInsertAfter(leaves, minDepth) {
-    if (leaves.length === 0)
-      return;
-    const groupIntoChunks = (leaves2, parent2, perChunk) => {
-      if (perChunk === 1)
-        return leaves2;
-      const chunks2 = [];
-      for (let i = 0; i < this.chunkSize; i++) {
-        const chunkNodes = leaves2.slice(i * perChunk, (i + 1) * perChunk);
-        if (chunkNodes.length === 0)
-          break;
-        const chunk = {
-          type: "chunk",
-          key: new Key(),
-          parent: parent2,
-          children: []
-        };
-        chunk.children = groupIntoChunks(chunkNodes, chunk, perChunk / this.chunkSize), chunks2.push(chunk);
-      }
-      return chunks2;
-    }, newTotal = this.pointerSiblings.length + leaves.length;
-    let depthForTotal = 0;
-    for (let i = this.chunkSize; i < newTotal; i *= this.chunkSize)
-      depthForTotal++;
-    const depth = Math.max(depthForTotal, minDepth), perTopLevelChunk = this.chunkSize ** depth, chunks = groupIntoChunks(leaves, this.pointerChunk, perTopLevelChunk);
-    this.pointerSiblings.splice(this.pointerIndex + 1, 0, ...chunks), this.pointerIndex += chunks.length, this.cachedPointerNode = void 0, this.invalidateChunk(), this.validateState();
-  }
-  /**
-   * If debug mode is enabled, ensure that the state is internally consistent
-   */
-  // istanbul ignore next
-  validateState() {
-    if (!this.debug)
-      return;
-    const validateDescendant = (node2) => {
-      if (node2.type === "chunk") {
-        const {
-          parent: parent2,
-          children
-        } = node2;
-        if (!parent2.children.includes(node2))
-          throw new Error(`Debug: Chunk ${node2.key.id} has an incorrect parent property`);
-        children.forEach(validateDescendant);
-      }
-    };
-    if (this.root.children.forEach(validateDescendant), this.cachedPointerNode !== void 0 && this.cachedPointerNode !== this.getPointerNode())
-      throw new Error("Debug: The cached pointer is incorrect and has not been invalidated");
-    const actualIndexStack = this.getChunkPath(this.pointerChunk);
-    if (!actualIndexStack)
-      throw new Error("Debug: The pointer chunk is not connected to the root");
-    if (!Path.equals(this.pointerIndexStack, actualIndexStack))
-      throw new Error(`Debug: The cached index stack [${this.pointerIndexStack.join(", ")}] does not match the path of the pointer chunk [${actualIndexStack.join(", ")}]`);
-  }
-}
-const reconcileChildren = (editor, {
-  chunkTree,
-  children,
-  chunkSize,
-  rerenderChildren = [],
-  onInsert,
-  onUpdate,
-  onIndexChange,
-  debug: debug2
-}) => {
-  chunkTree.modifiedChunks.clear();
-  const chunkTreeHelper = new ChunkTreeHelper(chunkTree, {
-    chunkSize,
-    debug: debug2
-  }), childrenHelper = new ChildrenHelper(editor, children);
-  let treeLeaf;
-  for (; treeLeaf = chunkTreeHelper.readLeaf(); ) {
-    const lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
-    if (lookAhead === -1) {
-      chunkTreeHelper.remove();
-      continue;
-    }
-    const insertedChildrenStartIndex = childrenHelper.pointerIndex, insertedChildren = childrenHelper.read(lookAhead + 1), matchingChild = insertedChildren.pop();
-    if (insertedChildren.length) {
-      const leavesToInsert = childrenHelper.toChunkLeaves(insertedChildren, insertedChildrenStartIndex);
-      chunkTreeHelper.insertBefore(leavesToInsert), insertedChildren.forEach((node2, relativeIndex) => {
-        onInsert?.(node2, insertedChildrenStartIndex + relativeIndex);
-      });
-    }
-    const matchingChildIndex = childrenHelper.pointerIndex - 1;
-    treeLeaf.node !== matchingChild && (treeLeaf.node = matchingChild, chunkTreeHelper.invalidateChunk(), onUpdate?.(matchingChild, matchingChildIndex)), treeLeaf.index !== matchingChildIndex && (treeLeaf.index = matchingChildIndex, onIndexChange?.(matchingChild, matchingChildIndex)), rerenderChildren.includes(matchingChildIndex) && chunkTreeHelper.invalidateChunk();
-  }
-  if (!childrenHelper.reachedEnd) {
-    const remainingChildren = childrenHelper.remaining(), leavesToInsert = childrenHelper.toChunkLeaves(remainingChildren, childrenHelper.pointerIndex);
-    chunkTreeHelper.returnToPreviousLeaf(), chunkTreeHelper.insertAfter(leavesToInsert), remainingChildren.forEach((node2, relativeIndex) => {
-      onInsert?.(node2, childrenHelper.pointerIndex + relativeIndex);
-    });
-  }
-}, getChunkTreeForNode = (editor, node2, options = {}) => {
-  const key = ReactEditor.findKey(editor, node2);
-  let chunkTree = editor.keyToChunkTree.get(key);
-  return chunkTree || (chunkTree = {
-    type: "root",
-    modifiedChunks: /* @__PURE__ */ new Set(),
-    children: []
-  }, editor.keyToChunkTree.set(key, chunkTree)), options.reconcile && reconcileChildren(editor, {
-    chunkTree,
-    children: node2.children,
-    ...options.reconcile
-  }), chunkTree;
-}, defaultRenderChunk = ({
-  children
-}) => children, ChunkAncestor = (props) => {
-  const {
-    root,
-    ancestor,
-    renderElement,
-    renderChunk = defaultRenderChunk
-  } = props;
-  return ancestor.children.map((chunkNode) => {
-    if (chunkNode.type === "chunk") {
-      const key = chunkNode.key.id, renderedChunk = renderChunk({
-        highest: ancestor === root,
-        lowest: chunkNode.children.some((c2) => c2.type === "leaf"),
-        attributes: {
-          "data-slate-chunk": !0
-        },
-        children: /* @__PURE__ */ jsx(MemoizedChunk, { root, ancestor: chunkNode, renderElement, renderChunk })
-      });
-      return /* @__PURE__ */ jsx(Fragment, { children: renderedChunk }, key);
-    }
-    const element = chunkNode.node;
-    return renderElement(element, chunkNode.index, chunkNode.key);
-  });
-}, ChunkTree = ChunkAncestor, MemoizedChunk = React.memo(ChunkAncestor, (prev, next2) => prev.root === next2.root && prev.renderElement === next2.renderElement && prev.renderChunk === next2.renderChunk && !next2.root.modifiedChunks.has(next2.ancestor));
 function useGenericSelector(selector, equalityFn) {
   const [, forceRender] = useReducer((s) => s + 1, 0), latestSubscriptionCallbackError = useRef(void 0), latestSelector = useRef(() => null), latestSelectedState = useRef(null);
   let selectedState;
@@ -5743,7 +5133,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations: parentDecorations,
     element,
     renderElement = defaultRenderElement$1,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5753,7 +5142,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations,
     node: element,
     renderElement,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5770,7 +5158,7 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     children,
     element
   });
-}, MemoizedElement = React.memo(Element$1, (prev, next2) => prev.element === next2.element && prev.renderElement === next2.renderElement && prev.renderChunk === next2.renderChunk && prev.renderText === next2.renderText && prev.renderLeaf === next2.renderLeaf && prev.renderPlaceholder === next2.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next2.decorations)), DefaultElement = (props) => {
+}, MemoizedElement = React.memo(Element$1, (prev, next2) => prev.element === next2.element && prev.renderElement === next2.renderElement && prev.renderText === next2.renderText && prev.renderLeaf === next2.renderLeaf && prev.renderPlaceholder === next2.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next2.decorations)), DefaultElement = (props) => {
   const {
     attributes,
     children,
@@ -5966,58 +5354,34 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
     decorations,
     node: node2,
     renderElement,
-    renderChunk,
     renderPlaceholder,
     renderText,
     renderLeaf
   } = props, editor = useSlateStatic();
   editor.isNodeMapDirty = !1;
-  const isEditor2 = Editor.isEditor(node2), chunkSize = !isEditor2 && Element$2.isElement(node2, editor.schema) && !editor.isInline(node2) && Editor.hasInlines(editor, node2) ? null : editor.getChunkSize(node2), chunking = !!chunkSize, {
-    decorationsByChild,
-    childrenToRedecorate
-  } = useDecorationsByChild(editor, node2, decorations);
-  chunking || node2.children.forEach((n2, i) => {
+  const isEditor2 = Editor.isEditor(node2), decorationsByChild = useDecorationsByChild(editor, node2, decorations);
+  node2.children.forEach((n2, i) => {
     editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
   });
   const renderElementComponent = useCallback((n2, i, cachedKey) => {
     const key = cachedKey ?? ReactEditor.findKey(editor, n2);
-    return /* @__PURE__ */ jsx(ElementContext.Provider, { value: n2, children: /* @__PURE__ */ jsx(MemoizedElement, { decorations: decorationsByChild[i] ?? [], element: n2, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText }, key.id) }, `provider-${key.id}`);
-  }, [editor, decorationsByChild, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText]), renderTextComponent = (n2, i) => {
+    return /* @__PURE__ */ jsx(ElementContext.Provider, { value: n2, children: /* @__PURE__ */ jsx(MemoizedElement, { decorations: decorationsByChild[i] ?? [], element: n2, renderElement, renderPlaceholder, renderLeaf, renderText }, key.id) }, `provider-${key.id}`);
+  }, [editor, decorationsByChild, renderElement, renderPlaceholder, renderLeaf, renderText]), renderTextComponent = (n2, i) => {
     const key = ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(MemoizedText, { decorations: decorationsByChild[i] ?? [], isLast: i === node2.children.length - 1, parent: node2, renderPlaceholder, renderLeaf, renderText, text: n2 }, key.id);
   }, renderObjectNodeComponent = (n2, i) => {
     const key = ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(MemoizedObjectNode, { decorations: decorationsByChild[i] ?? [], isInline: !isEditor2, objectNode: n2, renderElement }, key.id);
   };
-  if (!chunking)
-    return node2.children.map((n2, i) => Element$2.isElement(n2, editor.schema) ? renderElementComponent(n2, i) : Node$1.isObjectNode(n2, editor.schema) ? renderObjectNodeComponent(n2, i) : renderTextComponent(n2, i));
-  const chunkTree = getChunkTreeForNode(editor, node2, {
-    reconcile: {
-      chunkSize,
-      rerenderChildren: childrenToRedecorate,
-      onInsert: (n2, i) => {
-        editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
-      },
-      onUpdate: (n2, i) => {
-        editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
-      },
-      onIndexChange: (n2, i) => {
-        editor.nodeToIndex.set(n2, i);
-      }
-    }
-  });
-  return /* @__PURE__ */ jsx(ChunkTree, { root: chunkTree, ancestor: chunkTree, renderElement: renderElementComponent, renderChunk });
+  return node2.children.map((n2, i) => Element$2.isElement(n2, editor.schema) ? renderElementComponent(n2, i) : Node$1.isObjectNode(n2, editor.schema) ? renderObjectNodeComponent(n2, i) : renderTextComponent(n2, i));
 }, useDecorationsByChild = (editor, node2, decorations) => {
-  const decorationsByChild = splitDecorationsByChild(editor, node2, decorations), mutableDecorationsByChild = useRef(decorationsByChild).current, childrenToRedecorate = [];
+  const decorationsByChild = splitDecorationsByChild(editor, node2, decorations), mutableDecorationsByChild = useRef(decorationsByChild).current;
   mutableDecorationsByChild.length = decorationsByChild.length;
   for (let i = 0; i < decorationsByChild.length; i++) {
     const decorations2 = decorationsByChild[i], previousDecorations = mutableDecorationsByChild[i] ?? null;
-    isElementDecorationsEqual(previousDecorations, decorations2) || (mutableDecorationsByChild[i] = decorations2, childrenToRedecorate.push(i));
+    isElementDecorationsEqual(previousDecorations, decorations2) || (mutableDecorationsByChild[i] = decorations2);
   }
-  return {
-    decorationsByChild: mutableDecorationsByChild,
-    childrenToRedecorate
-  };
+  return mutableDecorationsByChild;
 }, ComposingContext = createContext(!1), ReadOnlyContext = createContext(!1), useReadOnly = () => useContext(ReadOnlyContext), SlateSelectorContext = createContext({}), refEquality = (a, b) => a === b;
 function useSlateSelector(selector, equalityFn = refEquality, {
   deferred
@@ -6197,7 +5561,7 @@ class RestoreDOMComponent extends Component {
 }
 const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
   children
-}) => /* @__PURE__ */ jsx(Fragment$1, { children }), Children = (props) => /* @__PURE__ */ jsx(React.Fragment, { children: useChildren(props) }), Editable = forwardRef((props, forwardedRef) => {
+}) => /* @__PURE__ */ jsx(Fragment, { children }), Children = (props) => /* @__PURE__ */ jsx(React.Fragment, { children: useChildren(props) }), Editable = forwardRef((props, forwardedRef) => {
   const defaultRenderPlaceholder = useCallback((props2) => /* @__PURE__ */ jsx(DefaultPlaceholder, { ...props2 }), []), {
     autoFocus,
     decorate = defaultDecorate,
@@ -6206,7 +5570,6 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     placeholder,
     readOnly = !1,
     renderElement,
-    renderChunk,
     renderLeaf,
     renderText,
     renderPlaceholder = defaultRenderPlaceholder,
@@ -6221,7 +5584,6 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
   } = useTrackUserInput(), [, forceRender] = useReducer((s) => s + 1, 0);
   editor.forceRender = forceRender, editor.readOnly = readOnly;
   const state = useMemo(() => ({
-    isDraggingInternally: !1,
     isUpdatingSelection: !1,
     latestElement: null,
     hasMarkPlaceholder: !1
@@ -6240,7 +5602,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       return;
     }
     const androidInputManager = androidInputManagerRef.current;
-    if ((IS_ANDROID || !ReactEditor.isComposing(editor)) && (!state.isUpdatingSelection || androidInputManager?.isFlushing()) && !state.isDraggingInternally) {
+    if ((IS_ANDROID || !ReactEditor.isComposing(editor)) && (!state.isUpdatingSelection || androidInputManager?.isFlushing())) {
       const root2 = ReactEditor.findDocumentOrShadowRoot(editor), {
         activeElement
       } = root2, el2 = ReactEditor.toDOMNode(editor, editor), domSelection = getSelection(root2);
@@ -6598,14 +5960,10 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       const targetTagName = (target instanceof HTMLElement ? target : null)?.tagName;
       targetTagName === "INPUT" || targetTagName === "TEXTAREA" || scheduleOnDOMSelectionChange();
     };
-    window2.document.addEventListener("selectionchange", onSelectionChange);
-    const stoppedDragging = () => {
-      state.isDraggingInternally = !1;
-    };
-    return window2.document.addEventListener("dragend", stoppedDragging), window2.document.addEventListener("drop", stoppedDragging), () => {
-      window2.document.removeEventListener("selectionchange", onSelectionChange), window2.document.removeEventListener("dragend", stoppedDragging), window2.document.removeEventListener("drop", stoppedDragging);
+    return window2.document.addEventListener("selectionchange", onSelectionChange), () => {
+      window2.document.removeEventListener("selectionchange", onSelectionChange);
     };
-  }, [scheduleOnDOMSelectionChange, state]);
+  }, [scheduleOnDOMSelectionChange]);
   const decorations = decorate([editor, []]), decorateContext = useDecorateContext(decorate), showPlaceholder = placeholder && editor.children.length === 1 && Array.from(Node$1.texts(editor, editor.schema)).length === 1 && Node$1.string(editor, editor.schema) === "" && !isComposing, placeHolderResizeHandler = useCallback((placeholderEl) => {
     setPlaceholderHeight(placeholderEl && showPlaceholder ? placeholderEl.getBoundingClientRect()?.height : void 0);
   }, [showPlaceholder]);
@@ -6813,74 +6171,12 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           }
         }
       }, [attributes.onCompositionStart, editor, editorActor]),
-      onCopy: useCallback((event) => {
-        ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCopy) && !isDOMEventTargetInput(event) && (event.preventDefault(), ReactEditor.setFragmentData(editor, event.clipboardData, "copy"));
-      }, [attributes.onCopy, editor]),
-      onCut: useCallback((event) => {
-        if (!readOnly && ReactEditor.hasSelectableTarget(editor, event.target) && !isEventHandled(event, attributes.onCut) && !isDOMEventTargetInput(event)) {
-          event.preventDefault(), ReactEditor.setFragmentData(editor, event.clipboardData, "cut");
-          const {
-            selection
-          } = editor;
-          if (selection)
-            if (Range.isExpanded(selection))
-              editorActor.send({
-                type: "behavior event",
-                behaviorEvent: {
-                  type: "delete",
-                  direction: "forward"
-                },
-                editor
-              });
-            else {
-              const node2 = Node$1.get(editor, selection.anchor.path, editor.schema);
-              editor.isObjectNode(node2) && Transforms.delete(editor);
-            }
-        }
-      }, [readOnly, editor, editorActor, attributes.onCut]),
-      onDragOver: useCallback((event) => {
-        if (ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragOver)) {
-          const node2 = ReactEditor.toSlateNode(editor, event.target);
-          editor.isObjectNode(node2) && event.preventDefault();
-        }
-      }, [attributes.onDragOver, editor]),
-      onDragStart: useCallback((event) => {
-        if (!readOnly && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDragStart)) {
-          const node2 = ReactEditor.toSlateNode(editor, event.target), path2 = ReactEditor.findPath(editor, node2);
-          if (editor.isObjectNode(node2) || Editor.void(editor, {
-            at: path2,
-            voids: !0
-          })) {
-            const range2 = Editor.range(editor, path2);
-            Transforms.select(editor, range2);
-          }
-          state.isDraggingInternally = !0, ReactEditor.setFragmentData(editor, event.dataTransfer, "drag");
-        }
-      }, [readOnly, editor, attributes.onDragStart, state]),
-      onDrop: useCallback((event) => {
-        if (!readOnly && ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onDrop)) {
-          event.preventDefault();
-          const draggedRange = editor.selection, range2 = ReactEditor.findEventRange(editor, event), data = event.dataTransfer;
-          Transforms.select(editor, range2), state.isDraggingInternally && draggedRange && !Range.equals(draggedRange, range2) && !Editor.void(editor, {
-            at: range2,
-            voids: !0
-          }) && Transforms.delete(editor, {
-            at: draggedRange
-          }), editorActor.send({
-            type: "behavior event",
-            behaviorEvent: {
-              type: "input.*",
-              originEvent: {
-                dataTransfer: data
-              }
-            },
-            editor
-          }), ReactEditor.isFocused(editor) || ReactEditor.focus(editor);
-        }
-      }, [readOnly, editor, editorActor, attributes.onDrop, state]),
-      onDragEnd: useCallback((event) => {
-        !readOnly && state.isDraggingInternally && attributes.onDragEnd && ReactEditor.hasTarget(editor, event.target) && attributes.onDragEnd(event);
-      }, [readOnly, state, attributes, editor]),
+      onCopy: attributes.onCopy,
+      onCut: attributes.onCut,
+      onDragOver: attributes.onDragOver,
+      onDragStart: attributes.onDragStart,
+      onDrop: attributes.onDrop,
+      onDragEnd: attributes.onDragEnd,
       onFocus: useCallback((event) => {
         if (!readOnly && !state.isUpdatingSelection && ReactEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onFocus)) {
           const el = ReactEditor.toDOMNode(editor, editor), root = ReactEditor.findDocumentOrShadowRoot(editor);
@@ -6902,26 +6198,6 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           const {
             selection
           } = editor, element = editor.children[selection !== null ? selection.focus.path[0] : 0], isRTL = getDirection(Node$1.string(element, editor.schema)) === "rtl";
-          if (Hotkeys.isRedo(nativeEvent)) {
-            event.preventDefault(), editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "history.redo"
-              },
-              editor
-            });
-            return;
-          }
-          if (Hotkeys.isUndo(nativeEvent)) {
-            event.preventDefault(), editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "history.undo"
-              },
-              editor
-            });
-            return;
-          }
           if (Hotkeys.isMoveLineBackward(nativeEvent)) {
             event.preventDefault(), Transforms.move(editor, {
               unit: "line",
@@ -7147,7 +6423,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           editor
         }));
       }, [readOnly, editor, editorActor, attributes.onPaste]),
-      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText })
+      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, renderElement, renderPlaceholder, renderLeaf, renderText })
     }
   ) }) }) }) });
 }), DefaultPlaceholder = ({
@@ -7546,7 +6822,7 @@ const withReact = (editor) => {
     apply: apply2,
     insertText: insertText2
   } = e;
-  return e.getChunkSize = () => null, e.keyToChunkTree = /* @__PURE__ */ new WeakMap(), IS_ANDROID && (e.insertText = (text, options) => (e.pendingSelection = null, insertText2(text, options))), e.onChange = (options) => {
+  return IS_ANDROID && (e.insertText = (text, options) => (e.pendingSelection = null, insertText2(text, options))), e.onChange = (options) => {
     (REACT_MAJOR_VERSION < 18 ? ReactDOM.unstable_batchedUpdates : (callback) => callback())(() => {
       onChange(options);
     });
@@ -8769,7 +8045,7 @@ function RenderLeaf(props) {
     let t2;
     $[4] !== t1 ? (t2 = /* @__PURE__ */ jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: t1 }), $[4] = t1, $[5] = t2) : t2 = $[5];
     let t3;
-    return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment, { children: [
       t2,
       renderedSpan
     ] }), $[6] = renderedSpan, $[7] = t2, $[8] = t3) : t3 = $[8], t3;
@@ -9102,7 +8378,7 @@ function validateSelection(slateEditor, editorElement) {
   }
 }
 const PortableTextEditable = forwardRef(function(props, forwardedRef) {
-  const $ = c(180);
+  const $ = c(181);
   let hotkeys, onBeforeInput, onBlur, onClick, onCopy, onCut, onDrag, onDragEnd, onDragEnter, onDragLeave, onDragOver, onDragStart, onDrop, onFocus, onPaste, propsSelection, rangeDecorations, renderAnnotation, renderBlock, renderChild, renderDecorator, renderListItem, renderPlaceholder, renderStyle, restProps, scrollSelectionIntoView, spellCheck;
   $[0] !== props ? ({
     hotkeys,
@@ -9185,10 +8461,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   let t13;
   $[64] !== editorActor || $[65] !== propsSelection || $[66] !== slateEditor ? (t13 = () => {
     if (propsSelection) {
-      debug$1.selection(`Selection from props ${JSON.stringify(propsSelection)}`);
+      debug$1.selection(`Selection from props ${safeStringify(propsSelection)}`);
       const normalizedSelection = normalizeSelection(propsSelection, slateEditor.children);
       if (normalizedSelection !== null) {
-        debug$1.selection(`Normalized selection from props ${JSON.stringify(normalizedSelection)}`);
+        debug$1.selection(`Normalized selection from props ${safeStringify(normalizedSelection)}`);
         const slateRange = toSlateRange({
           context: {
             schema: editorActor.getSnapshot().context.schema,
@@ -9226,61 +8502,65 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   }, t17 = [hasInvalidValue, propsSelection, restoreSelectionFromProps], $[73] = hasInvalidValue, $[74] = propsSelection, $[75] = restoreSelectionFromProps, $[76] = t16, $[77] = t17) : (t16 = $[76], t17 = $[77]), useEffect(t16, t17);
   let t18;
   $[78] !== editorActor || $[79] !== onCopy || $[80] !== slateEditor ? (t18 = (event) => {
-    if (onCopy)
-      onCopy(event) !== void 0 && event.preventDefault();
-    else if (event.nativeEvent.clipboardData) {
-      event.stopPropagation(), event.preventDefault();
-      const selection = slateEditor.selection ? slateRangeToSelection({
-        schema: editorActor.getSnapshot().context.schema,
-        editor: slateEditor,
-        range: slateEditor.selection
-      }) : void 0, position = selection ? {
-        selection
-      } : void 0;
-      if (!position) {
-        console.warn("Could not find position for copy event");
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "clipboard.copy",
-          originEvent: {
-            dataTransfer: event.nativeEvent.clipboardData
+    if (ReactEditor.hasSelectableTarget(slateEditor, event.target)) {
+      if (onCopy)
+        onCopy(event) !== void 0 && event.preventDefault();
+      else if (event.nativeEvent.clipboardData) {
+        event.stopPropagation(), event.preventDefault();
+        const selection = slateEditor.selection ? slateRangeToSelection({
+          schema: editorActor.getSnapshot().context.schema,
+          editor: slateEditor,
+          range: slateEditor.selection
+        }) : void 0, position = selection ? {
+          selection
+        } : void 0;
+        if (!position) {
+          console.warn("Could not find position for copy event");
+          return;
+        }
+        editorActor.send({
+          type: "behavior event",
+          behaviorEvent: {
+            type: "clipboard.copy",
+            originEvent: {
+              dataTransfer: event.nativeEvent.clipboardData
+            },
+            position
           },
-          position
-        },
-        editor: slateEditor,
-        nativeEvent: event
-      });
+          editor: slateEditor,
+          nativeEvent: event
+        });
+      }
     }
   }, $[78] = editorActor, $[79] = onCopy, $[80] = slateEditor, $[81] = t18) : t18 = $[81];
   const handleCopy = t18;
   let t19;
   $[82] !== editorActor || $[83] !== onCut || $[84] !== slateEditor ? (t19 = (event_0) => {
-    if (onCut)
-      onCut(event_0) !== void 0 && event_0.preventDefault();
-    else if (event_0.nativeEvent.clipboardData) {
-      event_0.stopPropagation(), event_0.preventDefault();
-      const selection_0 = editorActor.getSnapshot().context.selection, position_0 = selection_0 ? {
-        selection: selection_0
-      } : void 0;
-      if (!position_0) {
-        console.warn("Could not find position for cut event");
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "clipboard.cut",
-          originEvent: {
-            dataTransfer: event_0.nativeEvent.clipboardData
+    if (ReactEditor.hasSelectableTarget(slateEditor, event_0.target)) {
+      if (onCut)
+        onCut(event_0) !== void 0 && event_0.preventDefault();
+      else if (event_0.nativeEvent.clipboardData) {
+        event_0.stopPropagation(), event_0.preventDefault();
+        const selection_0 = editorActor.getSnapshot().context.selection, position_0 = selection_0 ? {
+          selection: selection_0
+        } : void 0;
+        if (!position_0) {
+          console.warn("Could not find position for cut event");
+          return;
+        }
+        editorActor.send({
+          type: "behavior event",
+          behaviorEvent: {
+            type: "clipboard.cut",
+            originEvent: {
+              dataTransfer: event_0.nativeEvent.clipboardData
+            },
+            position: position_0
           },
-          position: position_0
-        },
-        editor: slateEditor,
-        nativeEvent: event_0
-      });
+          editor: slateEditor,
+          nativeEvent: event_0
+        });
+      }
     }
   }, $[82] = editorActor, $[83] = onCut, $[84] = slateEditor, $[85] = t19) : t19 = $[85];
   const handleCut = t19;
@@ -9491,8 +8771,8 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
     };
   }, t29 = [slateEditor, editorActor], $[119] = editorActor, $[120] = slateEditor, $[121] = t28, $[122] = t29) : (t28 = $[121], t29 = $[122]), useEffect(t28, t29);
   let t30;
-  $[123] !== editorActor || $[124] !== onDragStart || $[125] !== slateEditor ? (t30 = (event_8) => {
-    if (onDragStart?.(event_8), event_8.isDefaultPrevented() || event_8.isPropagationStopped())
+  $[123] !== editorActor || $[124] !== onDragStart || $[125] !== readOnly || $[126] !== slateEditor ? (t30 = (event_8) => {
+    if (readOnly || !ReactEditor.hasTarget(slateEditor, event_8.target) || (onDragStart?.(event_8), event_8.isDefaultPrevented() || event_8.isPropagationStopped()))
       return;
     const position_4 = getEventPosition({
       editorActor,
@@ -9519,10 +8799,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
       },
       editor: slateEditor
     }), !0;
-  }, $[123] = editorActor, $[124] = onDragStart, $[125] = slateEditor, $[126] = t30) : t30 = $[126];
+  }, $[123] = editorActor, $[124] = onDragStart, $[125] = readOnly, $[126] = slateEditor, $[127] = t30) : t30 = $[127];
   const handleDragStart = t30;
   let t31;
-  $[127] !== editorActor || $[128] !== onDrag || $[129] !== slateEditor ? (t31 = (event_9) => {
+  $[128] !== editorActor || $[129] !== onDrag || $[130] !== slateEditor ? (t31 = (event_9) => {
     if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped() || !getEventPosition({
       editorActor,
       slateEditor,
@@ -9538,10 +8818,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         },
         editor: slateEditor
       }), !0;
-  }, $[127] = editorActor, $[128] = onDrag, $[129] = slateEditor, $[130] = t31) : t31 = $[130];
+  }, $[128] = editorActor, $[129] = onDrag, $[130] = slateEditor, $[131] = t31) : t31 = $[131];
   const handleDrag = t31;
   let t32;
-  $[131] !== editorActor || $[132] !== onDragEnd || $[133] !== slateEditor ? (t32 = (event_10) => {
+  $[132] !== editorActor || $[133] !== onDragEnd || $[134] !== slateEditor ? (t32 = (event_10) => {
     if (onDragEnd?.(event_10), !(event_10.isDefaultPrevented() || event_10.isPropagationStopped()))
       return editorActor.send({
         type: "behavior event",
@@ -9553,10 +8833,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         },
         editor: slateEditor
       }), !0;
-  }, $[131] = editorActor, $[132] = onDragEnd, $[133] = slateEditor, $[134] = t32) : t32 = $[134];
+  }, $[132] = editorActor, $[133] = onDragEnd, $[134] = slateEditor, $[135] = t32) : t32 = $[135];
   const handleDragEnd = t32;
   let t33;
-  $[135] !== editorActor || $[136] !== onDragEnter || $[137] !== slateEditor ? (t33 = (event_11) => {
+  $[136] !== editorActor || $[137] !== onDragEnter || $[138] !== slateEditor ? (t33 = (event_11) => {
     if (onDragEnter?.(event_11), event_11.isDefaultPrevented() || event_11.isPropagationStopped())
       return;
     const position_6 = getEventPosition({
@@ -9576,10 +8856,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         },
         editor: slateEditor
       }), !0;
-  }, $[135] = editorActor, $[136] = onDragEnter, $[137] = slateEditor, $[138] = t33) : t33 = $[138];
+  }, $[136] = editorActor, $[137] = onDragEnter, $[138] = slateEditor, $[139] = t33) : t33 = $[139];
   const handleDragEnter = t33;
   let t34;
-  $[139] !== editorActor || $[140] !== onDragOver || $[141] !== slateEditor ? (t34 = (event_12) => {
+  $[140] !== editorActor || $[141] !== onDragOver || $[142] !== slateEditor ? (t34 = (event_12) => {
     if (onDragOver?.(event_12), event_12.isDefaultPrevented() || event_12.isPropagationStopped())
       return;
     const position_7 = getEventPosition({
@@ -9601,10 +8881,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         editor: slateEditor,
         nativeEvent: event_12
       }), !0;
-  }, $[139] = editorActor, $[140] = onDragOver, $[141] = slateEditor, $[142] = t34) : t34 = $[142];
+  }, $[140] = editorActor, $[141] = onDragOver, $[142] = slateEditor, $[143] = t34) : t34 = $[143];
   const handleDragOver = t34;
   let t35;
-  $[143] !== editorActor || $[144] !== onDrop || $[145] !== slateEditor ? (t35 = (event_13) => {
+  $[144] !== editorActor || $[145] !== onDrop || $[146] !== slateEditor ? (t35 = (event_13) => {
     if (onDrop?.(event_13), event_13.isDefaultPrevented() || event_13.isPropagationStopped())
       return;
     const position_8 = getEventPosition({
@@ -9629,10 +8909,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
       editor: slateEditor,
       nativeEvent: event_13
     }), !0;
-  }, $[143] = editorActor, $[144] = onDrop, $[145] = slateEditor, $[146] = t35) : t35 = $[146];
+  }, $[144] = editorActor, $[145] = onDrop, $[146] = slateEditor, $[147] = t35) : t35 = $[147];
   const handleDrop = t35;
   let t36;
-  $[147] !== editorActor || $[148] !== onDragLeave || $[149] !== slateEditor ? (t36 = (event_14) => {
+  $[148] !== editorActor || $[149] !== onDragLeave || $[150] !== slateEditor ? (t36 = (event_14) => {
     if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped() || !getEventPosition({
       editorActor,
       slateEditor,
@@ -9648,10 +8928,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         },
         editor: slateEditor
       }), !0;
-  }, $[147] = editorActor, $[148] = onDragLeave, $[149] = slateEditor, $[150] = t36) : t36 = $[150];
+  }, $[148] = editorActor, $[149] = onDragLeave, $[150] = slateEditor, $[151] = t36) : t36 = $[151];
   const handleDragLeave = t36;
   let t37;
-  $[151] !== forwardedRef || $[152] !== validateSelectionActor ? (t37 = (editorElement) => {
+  $[152] !== forwardedRef || $[153] !== validateSelectionActor ? (t37 = (editorElement) => {
     if (typeof forwardedRef == "function" ? forwardedRef(editorElement) : forwardedRef && (forwardedRef.current = editorElement), editorElement) {
       const mutationObserver = new MutationObserver(() => {
         validateSelectionActor.send({
@@ -9669,12 +8949,12 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         mutationObserver.disconnect();
       };
     }
-  }, $[151] = forwardedRef, $[152] = validateSelectionActor, $[153] = t37) : t37 = $[153];
+  }, $[152] = forwardedRef, $[153] = validateSelectionActor, $[154] = t37) : t37 = $[154];
   const callbackRef = t37;
   if (!portableTextEditor)
     return null;
   let t38;
-  return $[154] !== callbackRef || $[155] !== decorate || $[156] !== editorActor || $[157] !== handleClick || $[158] !== handleCopy || $[159] !== handleCut || $[160] !== handleDrag || $[161] !== handleDragEnd || $[162] !== handleDragEnter || $[163] !== handleDragLeave || $[164] !== handleDragOver || $[165] !== handleDragStart || $[166] !== handleDrop || $[167] !== handleKeyDown || $[168] !== handleKeyUp || $[169] !== handleOnBeforeInput || $[170] !== handleOnBlur || $[171] !== handleOnFocus || $[172] !== handlePaste || $[173] !== hasInvalidValue || $[174] !== readOnly || $[175] !== renderElement || $[176] !== renderLeaf || $[177] !== restProps || $[178] !== scrollSelectionIntoViewToSlate ? (t38 = hasInvalidValue ? null : /* @__PURE__ */ jsx(SelectionStateProvider, { children: /* @__PURE__ */ jsx(Editable, { ...restProps, ref: callbackRef, editorActor, "data-read-only": readOnly, autoFocus: !1, className: restProps.className || "pt-editable", decorate, onBlur: handleOnBlur, onCopy: handleCopy, onCut: handleCut, onClick: handleClick, onDOMBeforeInput: handleOnBeforeInput, onDragStart: handleDragStart, onDrag: handleDrag, onDragEnd: handleDragEnd, onDragEnter: handleDragEnter, onDragOver: handleDragOver, onDrop: handleDrop, onDragLeave: handleDragLeave, onFocus: handleOnFocus, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp, onPaste: handlePaste, readOnly, renderPlaceholder: void 0, renderElement, renderLeaf, renderText, scrollSelectionIntoView: scrollSelectionIntoViewToSlate }) }), $[154] = callbackRef, $[155] = decorate, $[156] = editorActor, $[157] = handleClick, $[158] = handleCopy, $[159] = handleCut, $[160] = handleDrag, $[161] = handleDragEnd, $[162] = handleDragEnter, $[163] = handleDragLeave, $[164] = handleDragOver, $[165] = handleDragStart, $[166] = handleDrop, $[167] = handleKeyDown, $[168] = handleKeyUp, $[169] = handleOnBeforeInput, $[170] = handleOnBlur, $[171] = handleOnFocus, $[172] = handlePaste, $[173] = hasInvalidValue, $[174] = readOnly, $[175] = renderElement, $[176] = renderLeaf, $[177] = restProps, $[178] = scrollSelectionIntoViewToSlate, $[179] = t38) : t38 = $[179], t38;
+  return $[155] !== callbackRef || $[156] !== decorate || $[157] !== editorActor || $[158] !== handleClick || $[159] !== handleCopy || $[160] !== handleCut || $[161] !== handleDrag || $[162] !== handleDragEnd || $[163] !== handleDragEnter || $[164] !== handleDragLeave || $[165] !== handleDragOver || $[166] !== handleDragStart || $[167] !== handleDrop || $[168] !== handleKeyDown || $[169] !== handleKeyUp || $[170] !== handleOnBeforeInput || $[171] !== handleOnBlur || $[172] !== handleOnFocus || $[173] !== handlePaste || $[174] !== hasInvalidValue || $[175] !== readOnly || $[176] !== renderElement || $[177] !== renderLeaf || $[178] !== restProps || $[179] !== scrollSelectionIntoViewToSlate ? (t38 = hasInvalidValue ? null : /* @__PURE__ */ jsx(SelectionStateProvider, { children: /* @__PURE__ */ jsx(Editable, { ...restProps, ref: callbackRef, editorActor, "data-read-only": readOnly, autoFocus: !1, className: restProps.className || "pt-editable", decorate, onBlur: handleOnBlur, onCopy: handleCopy, onCut: handleCut, onClick: handleClick, onDOMBeforeInput: handleOnBeforeInput, onDragStart: handleDragStart, onDrag: handleDrag, onDragEnd: handleDragEnd, onDragEnter: handleDragEnter, onDragOver: handleDragOver, onDrop: handleDrop, onDragLeave: handleDragLeave, onFocus: handleOnFocus, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp, onPaste: handlePaste, readOnly, renderPlaceholder: void 0, renderElement, renderLeaf, renderText, scrollSelectionIntoView: scrollSelectionIntoViewToSlate }) }), $[155] = callbackRef, $[156] = decorate, $[157] = editorActor, $[158] = handleClick, $[159] = handleCopy, $[160] = handleCut, $[161] = handleDrag, $[162] = handleDragEnd, $[163] = handleDragEnter, $[164] = handleDragLeave, $[165] = handleDragOver, $[166] = handleDragStart, $[167] = handleDrop, $[168] = handleKeyDown, $[169] = handleKeyUp, $[170] = handleOnBeforeInput, $[171] = handleOnBlur, $[172] = handleOnFocus, $[173] = handlePaste, $[174] = hasInvalidValue, $[175] = readOnly, $[176] = renderElement, $[177] = renderLeaf, $[178] = restProps, $[179] = scrollSelectionIntoViewToSlate, $[180] = t38) : t38 = $[180], t38;
 });
 PortableTextEditable.displayName = "ForwardRef(PortableTextEditable)";
 function noop() {
@@ -9772,7 +9052,7 @@ const converterJson = {
       originEvent: event.originEvent
     } : {
       type: "serialization.success",
-      data: JSON.stringify(blocks),
+      data: safeStringify(blocks),
       mimeType: "application/x-portable-text",
       originEvent: event.originEvent
     };
@@ -9781,7 +9061,7 @@ const converterJson = {
     snapshot,
     event
   }) => {
-    const blocks = JSON.parse(event.data);
+    const blocks = safeParse(event.data);
     if (!Array.isArray(blocks))
       return {
         type: "deserialization.failure",
@@ -10539,8 +9819,6 @@ function createBehaviorApiPlugin(editorActor) {
         },
         editor
       });
-    }, editor.setFragmentData = () => {
-      console.error("Unexpected call to .setFragmentData(...)");
     }, editor.undo = () => {
       if (editor.isNormalizingNode || editor.isPerformingBehaviorOperation) {
         console.error("Unexpected call to .undo(...)");
@@ -10674,21 +9952,18 @@ function createHistoryPlugin({
     }, editor;
   };
 }
-function applyInsertNodeAtPath(editor, node2, path2, options = {}) {
-  if (editor.apply({
+function applyInsertNodeAtPath(editor, node2, path2) {
+  editor.apply({
     type: "insert_node",
     path: path2,
     node: node2
-  }), options.select) {
-    const point2 = Editor.end(editor, path2);
-    point2 && applySelect(editor, point2);
-  }
+  });
+  const point2 = Editor.end(editor, path2);
+  point2 && applySelect(editor, point2);
 }
-function applyInsertNodeAtPoint(editor, node2, at, options = {}) {
+function applyInsertNodeAtPoint(editor, node2, at) {
   Editor.withoutNormalizing(editor, () => {
-    let match2;
-    Text$1.isText(node2, editor.schema) ? match2 = (n2) => Text$1.isText(n2, editor.schema) : Element$2.isElement(node2, editor.schema) && editor.isInline(node2) ? match2 = (n2) => Text$1.isText(n2, editor.schema) || Element$2.isElement(n2, editor.schema) && Editor.isInline(editor, n2) : editor.isObjectNode(node2) ? match2 = (n2) => Text$1.isText(n2, editor.schema) || editor.isObjectNode(n2) || Element$2.isElement(n2, editor.schema) && Editor.isInline(editor, n2) : match2 = (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2) || editor.isObjectNode(n2);
-    const [entry] = Editor.nodes(editor, {
+    const match2 = Text$1.isText(node2, editor.schema) ? (n2) => Text$1.isText(n2, editor.schema) : (n2) => Text$1.isText(n2, editor.schema) || editor.isObjectNode(n2), [entry] = Editor.nodes(editor, {
       at: at.path,
       match: match2,
       mode: "lowest",
@@ -10702,14 +9977,13 @@ function applyInsertNodeAtPoint(editor, node2, at, options = {}) {
       applySplitNode(editor, at.path, at.offset, properties);
     }
     const path2 = pathRef2.unref(), insertPath = isAtEnd ? Path.next(path2) : path2;
-    if (editor.apply({
+    editor.apply({
       type: "insert_node",
       path: insertPath,
       node: node2
-    }), options.select) {
-      const point2 = Editor.end(editor, insertPath);
-      point2 && applySelect(editor, point2);
-    }
+    });
+    const point2 = Editor.end(editor, insertPath);
+    point2 && applySelect(editor, point2);
   });
 }
 function withNormalizeNode(editor, fn) {
@@ -10730,9 +10004,7 @@ function createNormalizationPlugin(editorActor) {
       const [node2, path2] = nodeEntry;
       if (Editor.isEditor(node2) && node2.children.length === 0 && withoutPatching(editor, () => {
         withNormalizeNode(editor, () => {
-          applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0], {
-            select: !0
-          });
+          applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0]);
         });
       }), editor.isTextBlock(node2)) {
         const children = Node$1.children(editor, path2, editor.schema);
@@ -10740,11 +10012,8 @@ function createNormalizationPlugin(editorActor) {
           const nextNode = node2.children[childPath[1] + 1];
           if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
             debug$1.normalization("merging spans with same marks"), withNormalizeNode(editor, () => {
-              const mergePath = [childPath[0], childPath[1] + 1], {
-                text: _text,
-                ...properties
-              } = nextNode;
-              applyMergeNode(editor, mergePath, child.text.length, properties);
+              const mergePath = [childPath[0], childPath[1] + 1];
+              applyMergeNode(editor, mergePath, child.text.length);
             });
             return;
           }
@@ -12040,7 +11309,7 @@ function setNodePatch(schema, children, operation) {
     }
     throw new Error("Could not find a valid block");
   } else
-    throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
+    throw new Error(`Unexpected path encountered: ${safeStringify(operation.path)}`);
 }
 function insertNodePatch(schema, children, operation, beforeValue) {
   const block = beforeValue[operation.path[0]];
@@ -12077,7 +11346,7 @@ function removeNodePatch(schema, beforeValue, operation) {
     schema
   }, block) && operation.path.length === 2) {
     const spanToRemove = block.children[operation.path[1]];
-    return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(`Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)), []) : [unset([{
+    return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(`Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`, safeStringify(block, 2)), []) : [unset([{
       _key: block._key
     }, "children", {
       _key: spanToRemove._key
@@ -12118,9 +11387,9 @@ function createPatchesPlugin({
             pluginWithoutHistory(editor, () => {
               for (const patch of patches)
                 try {
-                  changed = applyPatch(editor, patch), changed ? debug$1.syncPatch(`(applied) ${JSON.stringify(patch, null, 2)}`) : debug$1.syncPatch(`(ignored) ${JSON.stringify(patch, null, 2)}`);
+                  changed = applyPatch(editor, patch), changed ? debug$1.syncPatch(`(applied) ${safeStringify(patch, 2)}`) : debug$1.syncPatch(`(ignored) ${safeStringify(patch, 2)}`);
                 } catch (error) {
-                  console.error(`Applying patch ${JSON.stringify(patch)} failed due to: ${error instanceof Error ? error.message : error}`);
+                  console.error(`Applying patch ${safeStringify(patch)} failed due to: ${error instanceof Error ? error.message : error}`);
                 }
             });
           });
@@ -12387,7 +11656,7 @@ function updateValuePlugin(context, editor) {
   } = editor;
   return editor.apply = (operation) => {
     if (editor.isNormalizingNode && debug$1.normalization(`(slate operation)
-${JSON.stringify(operation, null, 2)}`), operation.type === "set_selection") {
+${safeStringify(operation, 2)}`), operation.type === "set_selection") {
       apply2(operation);
       return;
     }
@@ -13944,7 +13213,7 @@ const addAnnotationOperationImplementation = ({
     }
   });
   if (!parsedAnnotation)
-    throw new Error(`Failed to parse annotation ${JSON.stringify(operation.annotation)}`);
+    throw new Error(`Failed to parse annotation ${safeStringify(operation.annotation)}`);
   const editor = operation.editor, at = operation.at ? toSlateRange({
     context: {
       schema: context.schema,
@@ -14096,10 +13365,10 @@ const addAnnotationOperationImplementation = ({
 }) => {
   const blockIndex = operation.editor.blockIndexMap.get(operation.at[0]._key);
   if (blockIndex === void 0)
-    throw new Error(`Unable to find block index for block at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find block index for block at ${safeStringify(operation.at)}`);
   const slateBlock = operation.editor.children.at(blockIndex);
   if (!slateBlock)
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
   if (isTextBlock(context, slateBlock)) {
     const filteredProps = {};
     for (const key of Object.keys(operation.props))
@@ -14154,7 +13423,7 @@ const addAnnotationOperationImplementation = ({
     throw new Error(`Unable to find block index for block key ${blockKey}`);
   const slateBlock = blockIndex !== void 0 ? operation.editor.children.at(blockIndex) : void 0;
   if (!slateBlock)
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
   if (isTextBlock(context, slateBlock)) {
     const propsToRemove = operation.props.filter((prop) => prop !== "_type" && prop !== "_key" && prop !== "children"), unsetProps2 = {};
     for (const prop of propsToRemove)
@@ -14190,12 +13459,12 @@ const addAnnotationOperationImplementation = ({
     blockIndexMap: operation.editor.blockIndexMap
   });
   if (!location)
-    throw new Error(`Unable to convert ${JSON.stringify(operation.at)} into a Slate Range`);
+    throw new Error(`Unable to convert ${safeStringify(operation.at)} into a Slate Range`);
   const childEntry = Editor.node(operation.editor, location, {
     depth: 2
   }), child = childEntry?.[0], childPath = childEntry?.[1];
   if (!child || !childPath)
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find child at ${safeStringify(operation.at)}`);
   if (operation.editor.isTextSpan(child)) {
     const {
       _type,
@@ -14236,7 +13505,7 @@ const addAnnotationOperationImplementation = ({
     }, childPath);
     return;
   }
-  throw new Error(`Unable to determine the type of child at ${JSON.stringify(operation.at)}`);
+  throw new Error(`Unable to determine the type of child at ${safeStringify(operation.at)}`);
 }, childUnsetOperationImplementation = ({
   context,
   operation
@@ -14246,20 +13515,20 @@ const addAnnotationOperationImplementation = ({
     throw new Error(`Unable to find block index for block key ${blockKey}`);
   const block = blockIndex !== void 0 ? operation.editor.children.at(blockIndex) : void 0;
   if (!block)
-    throw new Error(`Unable to find block at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
   if (!isTextBlock(context, block))
-    throw new Error(`Block ${JSON.stringify(blockKey)} is not a text block`);
+    throw new Error(`Block ${safeStringify(blockKey)} is not a text block`);
   const childKey = operation.at[2]._key;
   if (!childKey)
-    throw new Error(`Unable to find child key at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find child key at ${safeStringify(operation.at)}`);
   const childIndex = block.children.findIndex((child2) => child2._key === childKey);
   if (childIndex === -1)
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find child at ${safeStringify(operation.at)}`);
   const childEntry = Editor.node(operation.editor, [blockIndex, childIndex], {
     depth: 2
   }), child = childEntry?.[0], childPath = childEntry?.[1];
   if (!child || !childPath)
-    throw new Error(`Unable to find child at ${JSON.stringify(operation.at)}`);
+    throw new Error(`Unable to find child at ${safeStringify(operation.at)}`);
   if (operation.editor.isTextSpan(child)) {
     const newNode = {};
     for (const prop of operation.props)
@@ -14285,7 +13554,7 @@ const addAnnotationOperationImplementation = ({
     applySetNode(operation.editor, unsetProps, childPath);
     return;
   }
-  throw new Error(`Unable to determine the type of child at ${JSON.stringify(operation.at)}`);
+  throw new Error(`Unable to determine the type of child at ${safeStringify(operation.at)}`);
 }, decoratorAddOperationImplementation = ({
   context,
   operation
@@ -14875,7 +14144,7 @@ const historyUndoOperationImplementation = ({
     }
   });
   if (!parsedBlock)
-    throw new Error(`Failed to parse block ${JSON.stringify(operation.block)}`);
+    throw new Error(`Failed to parse block ${safeStringify(operation.block)}`);
   const block = toSlateBlock(parsedBlock, {
     schemaTypes: context.schema
   });
@@ -15358,13 +14627,7 @@ function deleteSameBlockRange(editor, start2, end2) {
     });
   }
   const startNodeAfter = Node$1.get(editor, start2.path, editor.schema), endNodeAfter = Node$1.get(editor, newEndPath, editor.schema);
-  if (Text$1.isText(startNodeAfter, editor.schema) && Text$1.isText(endNodeAfter, editor.schema)) {
-    const {
-      text: _,
-      ...properties
-    } = endNodeAfter;
-    applyMergeNode(editor, newEndPath, startNodeAfter.text.length, properties);
-  }
+  Text$1.isText(startNodeAfter, editor.schema) && Text$1.isText(endNodeAfter, editor.schema) && applyMergeNode(editor, newEndPath, startNodeAfter.text.length);
 }
 function deleteCrossBlockRange(editor, start2, end2) {
   const startBlockPath = [start2.path[0]];
@@ -15408,11 +14671,7 @@ function deleteCrossBlockRange(editor, start2, end2) {
         markDefs: newMarkDefs
       }, startBlockPath);
     }
-    const {
-      children: _,
-      ...properties
-    } = endBlock;
-    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length, properties);
+    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length);
   });
 }
 function deleteExpandedRange(editor, range2) {
@@ -15472,11 +14731,7 @@ const insertChildOperationImplementation = ({
     const [focusSpan] = getFocusSpan({
       editor: operation.editor
     });
-    focusSpan ? applyInsertNodeAtPoint(operation.editor, span, focus, {
-      select: !0
-    }) : applyInsertNodeAtPath(operation.editor, span, [focusBlockIndex, focusChildIndex + 1], {
-      select: !0
-    }), operation.editor.pendingSelection = operation.editor.selection;
+    focusSpan ? applyInsertNodeAtPoint(operation.editor, span, focus) : applyInsertNodeAtPath(operation.editor, span, [focusBlockIndex, focusChildIndex + 1]), operation.editor.pendingSelection = operation.editor.selection;
     return;
   }
   const inlineObject = parseInlineObject({
@@ -15498,11 +14753,7 @@ const insertChildOperationImplementation = ({
     }, [focusSpan] = getFocusSpan({
       editor: operation.editor
     });
-    focusSpan ? applyInsertNodeAtPoint(operation.editor, inlineNode, focus, {
-      select: !0
-    }) : applyInsertNodeAtPath(operation.editor, inlineNode, [focusBlockIndex, focusChildIndex + 1], {
-      select: !0
-    });
+    focusSpan ? applyInsertNodeAtPoint(operation.editor, inlineNode, focus) : applyInsertNodeAtPath(operation.editor, inlineNode, [focusBlockIndex, focusChildIndex + 1]);
     return;
   }
   throw new Error("Unable to parse child");
@@ -15596,7 +14847,34 @@ const moveBackwardOperationImplementation = ({
   const destinationBlockIndex = operation.editor.blockIndexMap.get(destinationKey);
   if (destinationBlockIndex === void 0)
     throw new Error("Failed to get block index from block key");
-  applyMoveNode(operation.editor, [originBlockIndex], [destinationBlockIndex]);
+  const editor = operation.editor, node2 = Node$1.get(editor, [originBlockIndex], editor.schema), savedSelection = editor.selection ? {
+    anchor: {
+      ...editor.selection.anchor
+    },
+    focus: {
+      ...editor.selection.focus
+    }
+  } : null;
+  if (Editor.withoutNormalizing(editor, () => {
+    editor.apply({
+      type: "remove_node",
+      path: [originBlockIndex],
+      node: node2
+    }), editor.apply({
+      type: "insert_node",
+      path: [destinationBlockIndex],
+      node: node2
+    });
+  }), savedSelection) {
+    const fixPoint = (point2) => point2.path[0] === originBlockIndex ? {
+      ...point2,
+      path: [destinationBlockIndex, ...point2.path.slice(1)]
+    } : point2;
+    editor.selection = {
+      anchor: fixPoint(savedSelection.anchor),
+      focus: fixPoint(savedSelection.focus)
+    };
+  }
 }, moveForwardOperationImplementation = ({
   operation
 }) => {
@@ -17629,7 +16907,7 @@ function performEvent({
   nativeEvent,
   sendBack
 }) {
-  mode === "send" && !isNativeBehaviorEvent(event) && (editor.undoStepId = defaultKeyGenerator()), debug$1.behaviors(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  mode === "send" && !isNativeBehaviorEvent(event) && (editor.undoStepId = defaultKeyGenerator()), debug$1.behaviors(`(${mode}:${eventCategory(event)})`, safeStringify(event, 2));
   const eventBehaviors = [...remainingEventBehaviors, ...abstractBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
@@ -17638,7 +16916,7 @@ function performEvent({
   });
   if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
     nativeEvent?.preventDefault(), mode === "send" && (editor.undoStepId = void 0), withPerformingBehaviorOperation(editor, () => {
-      debug$1.operation(JSON.stringify(event, null, 2)), performOperation({
+      debug$1.operation(safeStringify(event, 2)), performOperation({
         context: {
           keyGenerator,
           schema
@@ -17764,7 +17042,7 @@ function performEvent({
     break;
   }
   !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), mode === "send" && (editor.undoStepId = void 0), withPerformingBehaviorOperation(editor, () => {
-    debug$1.operation(JSON.stringify(event, null, 2)), performOperation({
+    debug$1.operation(safeStringify(event, 2)), performOperation({
       context: {
         keyGenerator,
         schema
@@ -19052,7 +18330,7 @@ const syncValueCallback = ({
       context
     }) => {
       const isBusy = context.slateEditor.isDeferringMutations || context.slateEditor.isProcessingRemoteChanges;
-      return debug$1.syncValue(JSON.stringify({
+      return debug$1.syncValue(safeStringify({
         isBusy,
         isDeferringMutations: context.slateEditor.isDeferringMutations,
         isProcessingRemoteChanges: context.slateEditor.isProcessingRemoteChanges