@portabletext/editor 6.1.2 → 6.3.0

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";
@@ -16,7 +16,7 @@ import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
 import { htmlToPortableText } from "@portabletext/html";
 import { toHTML } from "@portabletext/to-html";
 import { markdownToPortableText, portableTextToMarkdown } from "@portabletext/markdown";
-import { applyAll, unset, insert, setIfMissing, set, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
+import { applyAll, set, unset, insert, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
 import { EditorContext as EditorContext$1 } from "./_chunks-es/use-editor.js";
 import { useEditor } from "./_chunks-es/use-editor.js";
 const rootName = "pte:";
@@ -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:
@@ -906,42 +809,6 @@ const debug$1 = {
         }), transformSelection = !0;
         break;
       }
-      case "merge_node": {
-        const {
-          path: path2
-        } = op, index = path2[path2.length - 1], prevPath = Path.previous(path2), prevIndex = prevPath[prevPath.length - 1];
-        modifyChildren(editor, Path.parent(path2), editor.schema, (children) => {
-          const node2 = children[index], prev = children[prevIndex];
-          let newNode;
-          if (Text$1.isText(node2, editor.schema) && Text$1.isText(prev, editor.schema))
-            newNode = {
-              ...prev,
-              text: prev.text + node2.text
-            };
-          else if (!Text$1.isText(node2, editor.schema) && !Text$1.isText(prev, editor.schema))
-            newNode = {
-              ...prev,
-              children: prev.children.concat(node2.children)
-            };
-          else
-            throw new Error(`Cannot apply a "merge_node" operation at path [${path2}] to nodes of different interfaces: ${Scrubber.stringify(node2)} ${Scrubber.stringify(prev)}`);
-          return replaceChildren(children, prevIndex, 2, newNode);
-        }), transformSelection = !0;
-        break;
-      }
-      case "move_node": {
-        const {
-          path: path2,
-          newPath
-        } = op, index = path2[path2.length - 1];
-        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);
-        modifyChildren(editor, Path.parent(path2), editor.schema, (children) => removeChildren(children, index, 1));
-        const truePath = Path.transform(path2, op), newIndex = truePath[truePath.length - 1];
-        modifyChildren(editor, Path.parent(truePath), editor.schema, (children) => insertChildren(children, newIndex, node2)), transformSelection = !0;
-        break;
-      }
       case "remove_node": {
         const {
           path: path2
@@ -1051,40 +918,6 @@ const debug$1 = {
         editor.selection = selection;
         break;
       }
-      case "split_node": {
-        const {
-          path: path2,
-          position,
-          properties
-        } = op, index = path2[path2.length - 1];
-        if (path2.length === 0)
-          throw new Error(`Cannot apply a "split_node" operation at path [${path2}] because the root node cannot be split.`);
-        modifyChildren(editor, Path.parent(path2), editor.schema, (children) => {
-          const node2 = children[index];
-          let newNode, nextNode;
-          if (Text$1.isText(node2, editor.schema)) {
-            const before2 = node2.text.slice(0, position), after2 = node2.text.slice(position);
-            newNode = {
-              ...node2,
-              text: before2
-            }, nextNode = {
-              ...properties,
-              text: after2
-            };
-          } else {
-            const before2 = node2.children.slice(0, position), after2 = node2.children.slice(position);
-            newNode = {
-              ...node2,
-              children: before2
-            }, nextNode = {
-              ...properties,
-              children: after2
-            };
-          }
-          return replaceChildren(children, index, 1, newNode, nextNode);
-        }), transformSelection = !0;
-        break;
-      }
     }
     if (transformSelection && editor.selection) {
       const selection = {
@@ -1099,17 +932,8 @@ const debug$1 = {
   insertNodes(editor, nodes2, options) {
     editor.insertNodes(nodes2, options);
   },
-  mergeNodes(editor, options) {
-    editor.mergeNodes(options);
-  },
-  moveNodes(editor, options) {
-    editor.moveNodes(options);
-  },
   removeNodes(editor, options) {
     editor.removeNodes(options);
-  },
-  splitNodes(editor, options) {
-    editor.splitNodes(options);
   }
 }, SelectionTransforms = {
   collapse(editor, options) {
@@ -1477,43 +1301,12 @@ const apply$1 = (editor, op) => {
       } = op, levels2 = Path.levels(path2), descendants = Text$1.isText(node2, _editor.schema) ? [] : Array.from(Node$1.nodes(node2, _editor.schema), ([, p]) => path2.concat(p));
       return [...levels2, ...descendants];
     }
-    case "merge_node": {
-      const {
-        path: path2
-      } = op, ancestors = Path.ancestors(path2), previousPath = Path.previous(path2);
-      return [...ancestors, previousPath];
-    }
-    case "move_node": {
-      const {
-        path: path2,
-        newPath
-      } = op;
-      if (Path.equals(path2, newPath))
-        return [];
-      const oldAncestors = [], newAncestors = [];
-      for (const ancestor of Path.ancestors(path2)) {
-        const p = Path.transform(ancestor, op);
-        oldAncestors.push(p);
-      }
-      for (const ancestor of Path.ancestors(newPath)) {
-        const p = Path.transform(ancestor, op);
-        newAncestors.push(p);
-      }
-      const newParent = newAncestors[newAncestors.length - 1], newIndex = newPath[newPath.length - 1], resultPath = newParent.concat(newIndex);
-      return [...oldAncestors, ...newAncestors, resultPath];
-    }
     case "remove_node": {
       const {
         path: path2
       } = op;
       return [...Path.ancestors(path2)];
     }
-    case "split_node": {
-      const {
-        path: path2
-      } = op, levels2 = Path.levels(path2), nextPath = Path.next(path2);
-      return [...levels2, nextPath];
-    }
     default:
       return [];
   }
@@ -1522,7 +1315,143 @@ const apply$1 = (editor, op) => {
     selection
   } = editor;
   return selection ? Node$1.fragment(editor, selection, editor.schema) : [];
-}, normalizeNode = (editor, entry) => {
+};
+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());
+    }
+  }
+  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, 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
+    } : null;
+  }
+  if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
+    const action = savedPendingAction;
+    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 = transformPointForMerge(action.at.anchor, path2, position), focus = transformPointForMerge(action.at.focus, path2, position);
+      editorAny.pendingAction = anchor && focus ? {
+        ...action,
+        at: {
+          anchor,
+          focus
+        }
+      } : null;
+    }
+  }
+  const preTransformedPendingDiffs = editorAny.pendingDiffs, preTransformedPendingSelection = editorAny.pendingSelection, preTransformedPendingAction = editorAny.pendingAction;
+  editorAny.pendingDiffs = [], editorAny.pendingSelection = null, editorAny.pendingAction = null;
+  try {
+    Editor.withoutNormalizing(editor, () => {
+      if (Text$1.isText(node2, editor.schema))
+        node2.text.length > 0 && editor.apply({
+          type: "insert_text",
+          path: prevPath,
+          offset: position,
+          text: node2.text
+        }), editor.apply({
+          type: "remove_node",
+          path: path2,
+          node: node2
+        });
+      else if (Element$2.isElement(node2, editor.schema)) {
+        const children = node2.children;
+        for (let i = 0; i < children.length; i++)
+          editor.apply({
+            type: "insert_node",
+            path: [...prevPath, position + i],
+            node: children[i]
+          });
+        editor.apply({
+          type: "remove_node",
+          path: path2,
+          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);
+    editorAny.pendingDiffs = preTransformedPendingDiffs, editorAny.pendingSelection = preTransformedPendingSelection, editorAny.pendingAction = preTransformedPendingAction;
+  }
+}
+function transformTextDiffForMerge(textDiff, mergePath, position) {
+  const {
+    path: path2,
+    diff: diff2,
+    id
+  } = textDiff;
+  if (!Path.equals(mergePath, path2)) {
+    const newPath = transformPathForMerge(path2, mergePath, position);
+    return newPath ? {
+      diff: diff2,
+      id,
+      path: newPath
+    } : null;
+  }
+  return {
+    diff: {
+      start: diff2.start + position,
+      end: diff2.end + position,
+      text: diff2.text
+    },
+    id,
+    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) => {
   const [node2, path2] = entry;
   if (Text$1.isText(node2, editor.schema) || editor.isObjectNode(node2))
     return;
@@ -1539,20 +1468,26 @@ const apply$1 = (editor, op) => {
   if (element !== editor && (editor.isInline(element) || Text$1.isText(firstChild, editor.schema) || editor.isObjectNode(firstChild) || Element$2.isElement(firstChild, editor.schema) && editor.isInline(firstChild)))
     for (let n2 = 0; n2 < element.children.length; n2++) {
       const child = element.children[n2], prev = element.children[n2 - 1];
-      if (Text$1.isText(child, editor.schema))
-        prev != null && Text$1.isText(prev, editor.schema) && (child.text === "" ? (Transforms.removeNodes(editor, {
-          at: path2.concat(n2),
-          voids: !0
-        }), element = Node$1.get(editor, path2, editor.schema), n2--) : prev.text === "" ? (Transforms.removeNodes(editor, {
-          at: path2.concat(n2 - 1),
-          voids: !0
-        }), element = Node$1.get(editor, path2, editor.schema), n2--) : Text$1.equals(child, prev, {
-          loose: !0
-        }) && (Transforms.mergeNodes(editor, {
-          at: path2.concat(n2),
-          voids: !0
-        }), element = Node$1.get(editor, path2, editor.schema), n2--));
-      else if (Element$2.isElement(child, editor.schema))
+      if (Text$1.isText(child, editor.schema)) {
+        if (prev != null && Text$1.isText(prev, editor.schema)) {
+          if (child.text === "")
+            Transforms.removeNodes(editor, {
+              at: path2.concat(n2),
+              voids: !0
+            }), element = Node$1.get(editor, path2, editor.schema), n2--;
+          else if (prev.text === "")
+            Transforms.removeNodes(editor, {
+              at: path2.concat(n2 - 1),
+              voids: !0
+            }), element = Node$1.get(editor, path2, editor.schema), n2--;
+          else if (Text$1.equals(child, prev, {
+            loose: !0
+          })) {
+            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))
         if (editor.isInline(child)) {
           if (prev == null || !Text$1.isText(prev, editor.schema)) {
             const newChild = editor.createSpan();
@@ -2147,7 +2082,109 @@ const previous = (editor, options = {}) => {
     Editor.setNormalizing(editor, value);
   }
   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, insertNodes = (editor, nodes2, options = {}) => {
+}, 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);
+  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 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();
+  const savedSelection = editor.selection;
+  try {
+    Editor.withoutNormalizing(editor, () => {
+      if (Text$1.isText(node2, editor.schema)) {
+        const afterText = node2.text.slice(position), newNode = {
+          ...properties,
+          text: afterText
+        };
+        editor.apply({
+          type: "remove_text",
+          path: path2,
+          offset: position,
+          text: afterText
+        }), editor.apply({
+          type: "insert_node",
+          path: Path.next(path2),
+          node: newNode
+        });
+      } else if (Element$2.isElement(node2, editor.schema)) {
+        const afterChildren = node2.children.slice(position), newNode = {
+          ...properties,
+          children: afterChildren
+        };
+        for (let i = node2.children.length - 1; i >= position; i--)
+          editor.apply({
+            type: "remove_node",
+            path: [...path2, i],
+            node: node2.children[i]
+          });
+        editor.apply({
+          type: "insert_node",
+          path: Path.next(path2),
+          node: newNode
+        });
+      }
+    });
+  } 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 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 {
       hanging = !1,
@@ -2184,12 +2221,43 @@ const previous = (editor, options = {}) => {
       });
       if (entry) {
         const [, matchPath2] = entry, pathRef2 = Editor.pathRef(editor, matchPath2), isAtEnd = Editor.isEnd(editor, at, matchPath2);
-        Transforms.splitNodes(editor, {
-          at,
-          match: match2,
-          mode,
-          voids
-        });
+        {
+          const splitAt = at, beforeRef = Editor.pointRef(editor, splitAt, {
+            affinity: "backward"
+          });
+          let afterRef;
+          try {
+            const [highest] = Editor.nodes(editor, {
+              at: splitAt,
+              match: match2,
+              mode,
+              voids
+            });
+            if (highest) {
+              afterRef = Editor.pointRef(editor, splitAt);
+              const depth = splitAt.path.length, [, highestPath] = highest, lowestPath = splitAt.path.slice(0, depth);
+              let position = splitAt.offset;
+              for (const [node22, nodePath] of Editor.levels(editor, {
+                at: lowestPath,
+                reverse: !0,
+                voids
+              })) {
+                let split = !1;
+                if (nodePath.length < highestPath.length || nodePath.length === 0)
+                  break;
+                const point2 = beforeRef.current, isEndOfNode = Editor.isEnd(editor, point2, nodePath);
+                if (!Editor.isEdge(editor, point2, nodePath)) {
+                  split = !0;
+                  const properties = Node$1.extractProps(node22, editor.schema);
+                  applySplitNode(editor, nodePath, position, properties);
+                }
+                position = nodePath[nodePath.length - 1] + (split || isEndOfNode ? 1 : 0);
+              }
+            }
+          } finally {
+            beforeRef.unref(), afterRef?.unref();
+          }
+        }
         const path2 = pathRef2.unref();
         at = isAtEnd ? Path.next(path2) : path2;
       } else
@@ -2237,126 +2305,6 @@ const previous = (editor, options = {}) => {
       }
     }
   });
-}, hasSingleChildNest = (editor, node2) => {
-  if (Element$2.isElement(node2, editor.schema)) {
-    const element = node2;
-    return element.children.length === 1 ? hasSingleChildNest(editor, element.children[0]) : !1;
-  } else return !Editor.isEditor(node2);
-}, mergeNodes = (editor, options = {}) => {
-  Editor.withoutNormalizing(editor, () => {
-    let {
-      match: match2,
-      at = editor.selection
-    } = options;
-    const {
-      hanging = !1,
-      voids = !1,
-      mode = "lowest"
-    } = options;
-    if (!at)
-      return;
-    if (match2 == null)
-      if (Path.isPath(at)) {
-        const [parent2] = Editor.parent(editor, at);
-        match2 = (n2) => parent2.children.includes(n2);
-      } else
-        match2 = (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2);
-    if (!hanging && Range.isRange(at) && (at = Editor.unhangRange(editor, at, {
-      voids
-    })), Range.isRange(at))
-      if (Range.isCollapsed(at))
-        at = at.anchor;
-      else {
-        const [, end2] = Range.edges(at), pointRef2 = Editor.pointRef(editor, end2);
-        Transforms.delete(editor, {
-          at
-        }), at = pointRef2.unref(), options.at == null && Transforms.select(editor, at);
-      }
-    const [current] = Editor.nodes(editor, {
-      at,
-      match: match2,
-      voids,
-      mode
-    }), prev = Editor.previous(editor, {
-      at,
-      match: match2,
-      voids,
-      mode
-    });
-    if (!current || !prev)
-      return;
-    const [node2, path2] = current, [prevNode, prevPath] = prev;
-    if (path2.length === 0 || prevPath.length === 0)
-      return;
-    const newPath = Path.next(prevPath), commonPath = Path.common(path2, prevPath), isPreviousSibling = Path.isSibling(path2, prevPath), levels2 = Array.from(Editor.levels(editor, {
-      at: path2
-    }), ([n2]) => n2).slice(commonPath.length).slice(0, -1), emptyAncestor = Editor.above(editor, {
-      at: path2,
-      mode: "highest",
-      match: (n2) => levels2.includes(n2) && hasSingleChildNest(editor, n2)
-    }), emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);
-    let properties, position;
-    if (Text$1.isText(node2, editor.schema) && Text$1.isText(prevNode, editor.schema)) {
-      const {
-        text: _text,
-        ...rest
-      } = node2;
-      position = prevNode.text.length, properties = rest;
-    } else if (Element$2.isElement(node2, editor.schema) && Element$2.isElement(prevNode, editor.schema)) {
-      const {
-        children: _children,
-        ...rest
-      } = node2;
-      position = prevNode.children.length, properties = rest;
-    } else
-      throw new Error(`Cannot merge the node at path [${path2}] with the previous sibling because it is not the same kind: ${Scrubber.stringify(node2)} ${Scrubber.stringify(prevNode)}`);
-    isPreviousSibling || Transforms.moveNodes(editor, {
-      at: path2,
-      to: newPath,
-      voids
-    }), emptyRef && Transforms.removeNodes(editor, {
-      at: emptyRef.current,
-      voids
-    }), Editor.shouldMergeNodesRemovePrevNode(editor, prev, current) ? Transforms.removeNodes(editor, {
-      at: prevPath,
-      voids
-    }) : editor.apply({
-      type: "merge_node",
-      path: newPath,
-      position,
-      properties
-    }), emptyRef && emptyRef.unref();
-  });
-}, moveNodes = (editor, options) => {
-  Editor.withoutNormalizing(editor, () => {
-    const {
-      to,
-      at = editor.selection,
-      mode = "lowest",
-      voids = !1
-    } = options;
-    let {
-      match: match2
-    } = options;
-    if (!at)
-      return;
-    match2 == null && (match2 = Path.isPath(at) ? matchPath(editor, at) : (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2));
-    const toRef = Editor.pathRef(editor, to), targets = Editor.nodes(editor, {
-      at,
-      match: match2,
-      mode,
-      voids
-    }), pathRefs = Array.from(targets, ([, p]) => Editor.pathRef(editor, p));
-    for (const pathRef2 of pathRefs) {
-      const path2 = pathRef2.unref(), newPath = toRef.current;
-      path2.length !== 0 && editor.apply({
-        type: "move_node",
-        path: path2,
-        newPath
-      }), toRef.current && Path.isSibling(newPath, path2) && Path.isAfter(newPath, path2) && (toRef.current = Path.next(toRef.current));
-    }
-    toRef.unref();
-  });
 }, removeNodes = (editor, options = {}) => {
   Editor.withoutNormalizing(editor, () => {
     const {
@@ -2377,109 +2325,18 @@ const previous = (editor, options = {}) => {
       at,
       match: match2,
       mode,
-      voids
-    }), pathRefs = Array.from(depths, ([, p]) => Editor.pathRef(editor, p));
-    for (const pathRef2 of pathRefs) {
-      const path2 = pathRef2.unref();
-      if (path2) {
-        const [node2] = Editor.node(editor, path2);
-        editor.apply({
-          type: "remove_node",
-          path: path2,
-          node: node2
-        });
-      }
-    }
-  });
-}, deleteRange = (editor, range2) => {
-  if (Range.isCollapsed(range2))
-    return range2.anchor;
-  {
-    const [, end2] = Range.edges(range2), pointRef2 = Editor.pointRef(editor, end2);
-    return Transforms.delete(editor, {
-      at: range2
-    }), pointRef2.unref();
-  }
-}, splitNodes = (editor, options = {}) => {
-  Editor.withoutNormalizing(editor, () => {
-    const {
-      mode = "lowest",
-      voids = !1
-    } = options;
-    let {
-      match: match2,
-      at = editor.selection,
-      height = 0,
-      always = !1
-    } = options;
-    if (match2 == null && (match2 = (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2)), Range.isRange(at) && (at = deleteRange(editor, at)), Path.isPath(at)) {
-      const path2 = at, point2 = Editor.point(editor, path2), [parent2] = Editor.parent(editor, path2);
-      match2 = (n2) => n2 === parent2, height = point2.path.length - path2.length + 1, at = point2, always = !0;
-    }
-    if (!at)
-      return;
-    const beforeRef = Editor.pointRef(editor, at, {
-      affinity: "backward"
-    });
-    let afterRef;
-    try {
-      const [highest] = Editor.nodes(editor, {
-        at,
-        match: match2,
-        mode,
-        voids
-      });
-      if (!highest)
-        return;
-      const voidMatch = Editor.void(editor, {
-        at,
-        mode: "highest"
-      }), nudge = 0;
-      if (!voids && voidMatch) {
-        const [voidNode, voidPath] = voidMatch;
-        if (Element$2.isElement(voidNode, editor.schema) && editor.isInline(voidNode)) {
-          let after2 = Editor.after(editor, voidPath);
-          if (!after2) {
-            const text = editor.createSpan(), afterPath = Path.next(voidPath);
-            Transforms.insertNodes(editor, text, {
-              at: afterPath,
-              voids
-            }), after2 = Editor.point(editor, afterPath);
-          }
-          at = after2, always = !0;
-        }
-        height = at.path.length - voidPath.length + 1, always = !0;
-      }
-      afterRef = Editor.pointRef(editor, at);
-      const depth = at.path.length - height, [, highestPath] = highest, lowestPath = at.path.slice(0, depth);
-      let position = height === 0 ? at.offset : at.path[depth] + nudge;
-      for (const [node2, path2] of Editor.levels(editor, {
-        at: lowestPath,
-        reverse: !0,
-        voids
-      })) {
-        let split = !1;
-        if (path2.length < highestPath.length || path2.length === 0)
-          break;
-        const point2 = beforeRef.current, isEnd2 = Editor.isEnd(editor, point2, path2);
-        if (always || !beforeRef || !Editor.isEdge(editor, point2, path2)) {
-          split = !0;
-          const properties = Node$1.extractProps(node2, editor.schema);
-          editor.apply({
-            type: "split_node",
-            path: path2,
-            position,
-            properties
-          });
-        }
-        position = path2[path2.length - 1] + (split || isEnd2 ? 1 : 0);
-      }
-      if (options.at == null) {
-        const point2 = afterRef.current || Editor.end(editor, []);
-        Transforms.select(editor, point2);
+      voids
+    }), pathRefs = Array.from(depths, ([, p]) => Editor.pathRef(editor, p));
+    for (const pathRef2 of pathRefs) {
+      const path2 = pathRef2.unref();
+      if (path2) {
+        const [node2] = Editor.node(editor, path2);
+        editor.apply({
+          type: "remove_node",
+          path: path2,
+          node: node2
+        });
       }
-    } finally {
-      beforeRef.unref(), afterRef?.unref();
     }
   });
 }, collapse = (editor, options = {}) => {
@@ -2568,7 +2425,19 @@ const previous = (editor, options = {}) => {
       newProperties: newProps
     });
   }
-}, deleteText = (editor, options = {}) => {
+};
+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))
+    key !== "children" && (key === "text" && !Element$2.isElement(node2, editor.schema) && !editor.isObjectNode(node2) || propsRecord[key] !== node2[key] && (node2.hasOwnProperty(key) && (properties[key] = node2[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key])));
+  (Object.keys(newProperties).length > 0 || Object.keys(properties).length > 0) && editor.apply({
+    type: "set_node",
+    path: path2,
+    properties,
+    newProperties
+  });
+}
+const deleteText = (editor, options = {}) => {
   Editor.withoutNormalizing(editor, () => {
     const {
       reverse = !1,
@@ -2693,11 +2562,75 @@ const previous = (editor, options = {}) => {
         }), removedText = text);
       }
     }
-    !isSingleText && isAcrossBlocks && endRef.current && startRef.current && Transforms.mergeNodes(editor, {
-      at: endRef.current,
-      hanging: !0,
-      voids
-    }), isCollapsed && reverse && unit === "character" && removedText.length > 1 && removedText.match(/[\u0980-\u09FF\u0E00-\u0E7F\u1000-\u109F\u0900-\u097F\u1780-\u17FF\u0D00-\u0D7F\u0B00-\u0B7F\u0A00-\u0A7F\u0B80-\u0BFF\u0C00-\u0C7F]+/) && Transforms.insertText(editor, removedText.slice(0, removedText.length - distance));
+    if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {
+      const mergeAt = endRef.current, mergeMatch = (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2), [current] = Editor.nodes(editor, {
+        at: mergeAt,
+        match: mergeMatch,
+        voids,
+        mode: "lowest"
+      }), prev = Editor.previous(editor, {
+        at: mergeAt,
+        match: mergeMatch,
+        voids,
+        mode: "lowest"
+      });
+      if (current && prev) {
+        const [mergeNode, mergePath] = current, [prevNode, prevPath] = prev;
+        if (mergePath.length !== 0 && prevPath.length !== 0) {
+          const newPath = Path.next(prevPath), commonPath = Path.common(mergePath, prevPath), isPreviousSibling = Path.isSibling(mergePath, prevPath), levels2 = Array.from(Editor.levels(editor, {
+            at: mergePath
+          }), ([n2]) => n2).slice(commonPath.length).slice(0, -1), hasSingleChildNest = (node2) => {
+            if (Element$2.isElement(node2, editor.schema)) {
+              const element = node2;
+              return element.children.length === 1 ? hasSingleChildNest(element.children[0]) : !1;
+            } else return !Editor.isEditor(node2);
+          }, emptyAncestor = Editor.above(editor, {
+            at: mergePath,
+            mode: "highest",
+            match: (n2) => levels2.includes(n2) && hasSingleChildNest(n2)
+          }), emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);
+          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) {
+            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))
+            Transforms.removeNodes(editor, {
+              at: prevPath,
+              voids
+            });
+          else {
+            const pteEditor = editor;
+            if (pteEditor.isTextBlock(mergeNode) && pteEditor.isTextBlock(prevNode) && Array.isArray(mergeNode.markDefs) && mergeNode.markDefs.length > 0) {
+              const targetPath = isPreviousSibling ? prevPath : Path.previous(newPath), oldDefs = Array.isArray(prevNode.markDefs) && prevNode.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...mergeNode.markDefs].map((def) => [def._key, def])).values()];
+              applySetNode(pteEditor, {
+                markDefs: newMarkDefs
+              }, targetPath);
+            }
+            applyMergeNode(pteEditor, newPath, position);
+          }
+          emptyRef && emptyRef.unref();
+        }
+      }
+    }
+    isCollapsed && reverse && unit === "character" && removedText.length > 1 && removedText.match(/[\u0980-\u09FF\u0E00-\u0E7F\u1000-\u109F\u0900-\u097F\u1780-\u17FF\u0D00-\u0D7F\u0B00-\u0B7F\u0A00-\u0A7F\u0B80-\u0BFF\u0C00-\u0C7F]+/) && Transforms.insertText(editor, removedText.slice(0, removedText.length - distance));
     const startUnref = startRef.unref(), endUnref = endRef.unref(), point2 = reverse ? startUnref || endUnref : endUnref || startUnref;
     options.at == null && point2 && Transforms.select(editor, point2);
   });
@@ -2753,9 +2686,7 @@ const previous = (editor, options = {}) => {
     isStart: (...args) => isStart(e, ...args),
     leaf: (...args) => leaf(e, ...args),
     levels: (...args) => levels(e, ...args),
-    mergeNodes: (...args) => mergeNodes(e, ...args),
     move: (...args) => move(e, ...args),
-    moveNodes: (...args) => moveNodes(e, ...args),
     next: (...args) => next(e, ...args),
     node: (...args) => node(e, ...args),
     nodes: (...args) => nodes(e, ...args),
@@ -2773,7 +2704,6 @@ const previous = (editor, options = {}) => {
     select: (...args) => select(e, ...args),
     setNormalizing: (...args) => setNormalizing(e, ...args),
     setSelection: (...args) => setSelection$1(e, ...args),
-    splitNodes: (...args) => splitNodes(e, ...args),
     start: (...args) => start(e, ...args),
     string: (...args) => string(e, ...args),
     unhangRange: (...args) => unhangRange(e, ...args),
@@ -3462,7 +3392,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;
@@ -3525,46 +3455,6 @@ function transformTextDiff(textDiff, op) {
         id,
         path: path2
       };
-    case "split_node":
-      return !Path.equals(op.path, path2) || op.position >= diff2.end ? {
-        diff: diff2,
-        id,
-        path: Path.transform(path2, op, {
-          affinity: "backward"
-        })
-      } : op.position > diff2.start ? {
-        diff: {
-          start: diff2.start,
-          end: Math.min(op.position, diff2.end),
-          text: diff2.text
-        },
-        id,
-        path: path2
-      } : {
-        diff: {
-          start: diff2.start - op.position,
-          end: diff2.end - op.position,
-          text: diff2.text
-        },
-        id,
-        path: Path.transform(path2, op, {
-          affinity: "forward"
-        })
-      };
-    case "merge_node":
-      return Path.equals(op.path, path2) ? {
-        diff: {
-          start: diff2.start + op.position,
-          end: diff2.end + op.position,
-          text: diff2.text
-        },
-        id,
-        path: Path.transform(path2, op)
-      } : {
-        diff: diff2,
-        id,
-        path: Path.transform(path2, op)
-      };
   }
   const newPath = Path.transform(path2, op);
   return newPath ? {
@@ -3579,7 +3469,7 @@ const withDOM = (editor) => {
     onChange
   } = e;
   return e.isNodeMapDirty = !1, e.domWindow = null, e.domElement = null, e.domPlaceholder = "", e.domPlaceholderElement = null, e.keyToElement = /* @__PURE__ */ new WeakMap(), e.nodeToIndex = /* @__PURE__ */ new WeakMap(), e.nodeToParent = /* @__PURE__ */ new WeakMap(), e.elementToNode = /* @__PURE__ */ new WeakMap(), e.nodeToElement = /* @__PURE__ */ new WeakMap(), e.nodeToKey = /* @__PURE__ */ new WeakMap(), e.readOnly = !1, e.focused = !1, e.composing = !1, e.userSelection = null, e.onContextChange = null, e.scheduleFlush = null, e.pendingInsertionMarks = null, e.userMarks = null, e.pendingDiffs = [], e.pendingAction = null, e.pendingSelection = null, e.forceRender = null, e.apply = (op) => {
-    const matches = [], pathRefMatches = [], pendingDiffs = e.pendingDiffs;
+    const matches = [], pendingDiffs = e.pendingDiffs;
     if (pendingDiffs?.length) {
       const transformed = pendingDiffs.map((textDiff) => transformTextDiff(textDiff, op)).filter(Boolean);
       e.pendingDiffs = transformed;
@@ -3597,8 +3487,7 @@ const withDOM = (editor) => {
     switch (op.type) {
       case "insert_text":
       case "remove_text":
-      case "set_node":
-      case "split_node": {
+      case "set_node": {
         matches.push(...getMatches(e, op.path));
         break;
       }
@@ -3611,27 +3500,10 @@ const withDOM = (editor) => {
         matches.push(...getMatches(e, Path.parent(op.path)));
         break;
       }
-      case "merge_node": {
-        const prevPath = Path.previous(op.path);
-        matches.push(...getMatches(e, prevPath));
-        break;
-      }
-      case "move_node": {
-        const commonPath = Path.common(Path.parent(op.path), Path.parent(op.newPath));
-        matches.push(...getMatches(e, commonPath));
-        let changedPath;
-        Path.isBefore(op.path, op.newPath) ? (matches.push(...getMatches(e, Path.parent(op.path))), changedPath = op.newPath) : (matches.push(...getMatches(e, Path.parent(op.newPath))), changedPath = op.path);
-        const changedNode = Node$1.get(editor, Path.parent(changedPath), editor.schema), changedNodeKey = DOMEditor.findKey(e, changedNode), changedPathRef = Editor.pathRef(e, Path.parent(changedPath));
-        pathRefMatches.push([changedPathRef, changedNodeKey]);
-        break;
-      }
     }
     switch (apply2(op), op.type) {
       case "insert_node":
       case "remove_node":
-      case "merge_node":
-      case "move_node":
-      case "split_node":
       case "insert_text":
       case "remove_text":
       case "set_selection":
@@ -3641,13 +3513,6 @@ const withDOM = (editor) => {
       const [node2] = Editor.node(e, path2);
       e.nodeToKey.set(node2, key);
     }
-    for (const [pathRef2, key] of pathRefMatches) {
-      if (pathRef2.current) {
-        const [node2] = Editor.node(e, pathRef2.current);
-        e.nodeToKey.set(node2, key);
-      }
-      pathRef2.unref();
-    }
   }, e.setFragmentData = (data) => {
     const {
       selection
@@ -3689,8 +3554,53 @@ const withDOM = (editor) => {
       const lines = text.split(/\r\n|\r|\n/);
       let split = !1;
       for (const line of lines)
-        split && Transforms.splitNodes(e, {
-          always: !0
+        split && Editor.withoutNormalizing(e, () => {
+          let splitAt = null;
+          if (e.selection)
+            if (Range.isCollapsed(e.selection))
+              splitAt = e.selection.anchor;
+            else {
+              const [, end2] = Range.edges(e.selection), pointRef2 = Editor.pointRef(e, end2);
+              Transforms.delete(e, {
+                at: e.selection
+              }), splitAt = pointRef2.unref();
+            }
+          if (!splitAt)
+            return;
+          const splitMatch = (n2) => Element$2.isElement(n2, e.schema) && Editor.isBlock(e, n2), beforeRef = Editor.pointRef(e, splitAt, {
+            affinity: "backward"
+          });
+          let afterRef;
+          try {
+            const [highest] = Editor.nodes(e, {
+              at: splitAt,
+              match: splitMatch,
+              mode: "lowest",
+              voids: !1
+            });
+            if (!highest)
+              return;
+            afterRef = Editor.pointRef(e, splitAt);
+            const depth = splitAt.path.length, [, highestPath] = highest, lowestPath = splitAt.path.slice(0, depth);
+            let position = splitAt.offset;
+            for (const [node2, nodePath] of Editor.levels(e, {
+              at: lowestPath,
+              reverse: !0,
+              voids: !1
+            })) {
+              let didSplit = !1;
+              if (nodePath.length < highestPath.length || nodePath.length === 0)
+                break;
+              const point22 = beforeRef.current, isEndOfNode = Editor.isEnd(e, point22, nodePath);
+              didSplit = !0;
+              const properties = Node$1.extractProps(node2, e.schema);
+              applySplitNode(e, nodePath, position, properties), position = nodePath[nodePath.length - 1] + (didSplit || isEndOfNode ? 1 : 0);
+            }
+            const point2 = afterRef.current || Editor.end(e, []);
+            Transforms.select(e, point2);
+          } finally {
+            beforeRef.unref(), afterRef?.unref();
+          }
         }), e.insertText(line), split = !0;
       return !0;
     }
@@ -5130,537 +5040,61 @@ function createAndroidInputManager({
           editor
         }), {
           at: targetRange2
-        });
-      }
-    }
-  }, hasPendingAction = () => !!editor.pendingAction, hasPendingDiffs = () => !!editor.pendingDiffs?.length, hasPendingChanges = () => hasPendingAction() || hasPendingDiffs(), isFlushing = () => flushing, handleUserSelect = (range2) => {
-    editor.pendingSelection = range2, flushTimeoutId && (clearTimeout(flushTimeoutId), flushTimeoutId = null);
-    const {
-      selection
-    } = editor;
-    if (!range2)
-      return;
-    const pathChanged = !selection || !Path.equals(selection.anchor.path, range2.anchor.path), parentPathChanged = !selection || !Path.equals(selection.anchor.path.slice(0, -1), range2.anchor.path.slice(0, -1));
-    (pathChanged && insertPositionHint || parentPathChanged) && (insertPositionHint = !1), (pathChanged || hasPendingDiffs()) && (flushTimeoutId = setTimeout(flush, FLUSH_DELAY));
-  }, handleInput = () => {
-    (hasPendingAction() || !hasPendingDiffs()) && flush();
-  }, handleKeyDown = (_) => {
-    hasPendingDiffs() || (updatePlaceholderVisibility(!0), setTimeout(updatePlaceholderVisibility));
-  }, scheduleFlush = () => {
-    hasPendingAction() || (actionTimeoutId = setTimeout(flush));
-  };
-  return {
-    flush,
-    scheduleFlush,
-    hasPendingDiffs,
-    hasPendingAction,
-    hasPendingChanges,
-    isFlushing,
-    handleUserSelect,
-    handleCompositionEnd,
-    handleCompositionStart,
-    handleDOMBeforeInput,
-    handleKeyDown,
-    handleDomMutations: (mutations) => {
-      hasPendingDiffs() || hasPendingAction() || mutations.some((mutation) => isTrackedMutation(editor, mutation, mutations)) && editor.forceRender?.();
-    },
-    handleInput
-  };
-}
-const MUTATION_OBSERVER_CONFIG$1 = {
-  subtree: !0,
-  childList: !0,
-  characterData: !0
-}, useAndroidInputManager = IS_ANDROID ? ({
-  editorActor,
-  node: node2,
-  ...options
-}) => {
-  if (!IS_ANDROID)
-    return null;
-  const editor = useSlateStatic(), isMounted = useIsMounted(), [inputManager] = useState(() => createAndroidInputManager({
-    editor,
-    editorActor,
-    ...options
-  }));
-  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;
+        });
+      }
     }
+  }, hasPendingAction = () => !!editor.pendingAction, hasPendingDiffs = () => !!editor.pendingDiffs?.length, hasPendingChanges = () => hasPendingAction() || hasPendingDiffs(), isFlushing = () => flushing, handleUserSelect = (range2) => {
+    editor.pendingSelection = range2, flushTimeoutId && (clearTimeout(flushTimeoutId), flushTimeoutId = null);
     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)
+      selection
+    } = editor;
+    if (!range2)
       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 pathChanged = !selection || !Path.equals(selection.anchor.path, range2.anchor.path), parentPathChanged = !selection || !Path.equals(selection.anchor.path.slice(0, -1), range2.anchor.path.slice(0, -1));
+    (pathChanged && insertPositionHint || parentPathChanged) && (insertPositionHint = !1), (pathChanged || hasPendingDiffs()) && (flushTimeoutId = setTimeout(flush, FLUSH_DELAY));
+  }, handleInput = () => {
+    (hasPendingAction() || !hasPendingDiffs()) && flush();
+  }, handleKeyDown = (_) => {
+    hasPendingDiffs() || (updatePlaceholderVisibility(!0), setTimeout(updatePlaceholderVisibility));
+  }, scheduleFlush = () => {
+    hasPendingAction() || (actionTimeoutId = setTimeout(flush));
+  };
+  return {
+    flush,
+    scheduleFlush,
+    hasPendingDiffs,
+    hasPendingAction,
+    hasPendingChanges,
+    isFlushing,
+    handleUserSelect,
+    handleCompositionEnd,
+    handleCompositionStart,
+    handleDOMBeforeInput,
+    handleKeyDown,
+    handleDomMutations: (mutations) => {
+      hasPendingDiffs() || hasPendingAction() || mutations.some((mutation) => isTrackedMutation(editor, mutation, mutations)) && editor.forceRender?.();
+    },
+    handleInput
+  };
 }
-const reconcileChildren = (editor, {
-  chunkTree,
-  children,
-  chunkSize,
-  rerenderChildren = [],
-  onInsert,
-  onUpdate,
-  onIndexChange,
-  debug: debug2
+const MUTATION_OBSERVER_CONFIG$1 = {
+  subtree: !0,
+  childList: !0,
+  characterData: !0
+}, useAndroidInputManager = IS_ANDROID ? ({
+  editorActor,
+  node: node2,
+  ...options
 }) => {
-  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), wasMoved = lookAhead > 0 && chunkTree.movedNodeKeys.has(treeLeaf.key);
-    if (lookAhead === -1 || wasMoved) {
-      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);
-    });
-  }
-  chunkTree.movedNodeKeys.clear();
-}, getChunkTreeForNode = (editor, node2, options = {}) => {
-  const key = ReactEditor.findKey(editor, node2);
-  let chunkTree = editor.keyToChunkTree.get(key);
-  return chunkTree || (chunkTree = {
-    type: "root",
-    movedNodeKeys: /* @__PURE__ */ new Set(),
-    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));
+  if (!IS_ANDROID)
+    return null;
+  const editor = useSlateStatic(), isMounted = useIsMounted(), [inputManager] = useState(() => createAndroidInputManager({
+    editor,
+    editorActor,
+    ...options
+  }));
+  return useMutationObserver(node2, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1), editor.scheduleFlush = inputManager.scheduleFlush, isMounted && inputManager.flush(), inputManager;
+} : () => null;
 function useGenericSelector(selector, equalityFn) {
   const [, forceRender] = useReducer((s) => s + 1, 0), latestSubscriptionCallbackError = useRef(void 0), latestSelector = useRef(() => null), latestSelectedState = useRef(null);
   let selectedState;
@@ -5730,7 +5164,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations: parentDecorations,
     element,
     renderElement = defaultRenderElement$1,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5740,7 +5173,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations,
     node: element,
     renderElement,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5757,7 +5189,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,
@@ -5953,58 +5385,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
@@ -6184,7 +5592,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,
@@ -6193,7 +5601,6 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     placeholder,
     readOnly = !1,
     renderElement,
-    renderChunk,
     renderLeaf,
     renderText,
     renderPlaceholder = defaultRenderPlaceholder,
@@ -7134,7 +6541,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 = ({
@@ -7533,18 +6940,11 @@ 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);
     });
   }, e.apply = (operation) => {
-    if (operation.type === "move_node") {
-      const parent2 = Node$1.parent(e, operation.path, e.schema);
-      if (e.getChunkSize(parent2)) {
-        const node2 = Node$1.get(e, operation.path, e.schema), chunkTree = getChunkTreeForNode(e, parent2), key = ReactEditor.findKey(e, node2);
-        chunkTree.movedNodeKeys.add(key);
-      }
-    }
     apply2(operation);
   }, e;
 }, EditorActorContext = createContext({}), IS_MAC = typeof window < "u" && /Mac|iPod|iPhone|iPad/.test(window.navigator.userAgent), modifiers = {
@@ -8763,7 +8163,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;
@@ -10668,21 +10068,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",
@@ -10693,33 +10090,16 @@ function applyInsertNodeAtPoint(editor, node2, at, options = {}) {
     const [, matchPath2] = entry, pathRef2 = Editor.pathRef(editor, matchPath2), isAtEnd = Editor.isEnd(editor, at, matchPath2);
     if (!Editor.isEdge(editor, at, matchPath2)) {
       const textNode = Node$1.get(editor, at.path, editor.schema), properties = Node$1.extractProps(textNode, editor.schema);
-      editor.apply({
-        type: "split_node",
-        path: at.path,
-        position: at.offset,
-        properties
-      });
+      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);
-    }
-  });
-}
-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))
-    key !== "children" && (key === "text" && !Element$2.isElement(node2, editor.schema) && !editor.isObjectNode(node2) || propsRecord[key] !== node2[key] && (node2.hasOwnProperty(key) && (properties[key] = node2[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key])));
-  (Object.keys(newProperties).length > 0 || Object.keys(properties).length > 0) && editor.apply({
-    type: "set_node",
-    path: path2,
-    properties,
-    newProperties
+    });
+    const point2 = Editor.end(editor, insertPath);
+    point2 && applySelect(editor, point2);
   });
 }
 function withNormalizeNode(editor, fn) {
@@ -10740,9 +10120,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);
@@ -10750,16 +10128,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;
-              editor.apply({
-                type: "merge_node",
-                path: mergePath,
-                position: child.text.length,
-                properties
-              });
+              const mergePath = [childPath[0], childPath[1] + 1];
+              applyMergeNode(editor, mergePath, child.text.length);
             });
             return;
           }
@@ -10842,7 +10212,7 @@ function createNormalizationPlugin(editorActor) {
           return;
         }
       }
-      if (editor.isTextBlock(node2) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
+      if (editor.isTextBlock(node2)) {
         const newMarkDefs = (node2.markDefs || []).filter((def) => node2.children.find((child) => Text$1.isText(child, editor.schema) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node2.markDefs && !isEqualMarkDefs(newMarkDefs, node2.markDefs)) {
           debug$1.normalization("removing markDef not in use"), withNormalizeNode(editor, () => {
@@ -10890,16 +10260,6 @@ function createNormalizationPlugin(editorActor) {
           }
         } else
           editor.decoratorState = {};
-      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === editorActor.getSnapshot().context.schema.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
-        const [targetBlock, targetPath] = Editor.node(editor, [op.path[0] - 1]);
-        if (editor.isTextBlock(targetBlock)) {
-          const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...op.properties.markDefs].map((def) => [def._key, def])).values()];
-          debug$1.normalization("copying markDefs over to merged block", op), applySetNode(editor, {
-            markDefs: newMarkDefs
-          }, targetPath), apply2(op);
-          return;
-        }
-      }
       apply2(op);
     }, editor;
   };
@@ -12090,58 +11450,6 @@ function insertNodePatch(schema, children, operation, beforeValue) {
   }
   return [];
 }
-function splitNodePatch(schema, children, operation, beforeValue) {
-  const patches = [], splitBlock2 = children[operation.path[0]];
-  if (!isTextBlock({
-    schema
-  }, splitBlock2))
-    throw new Error(`Block with path ${JSON.stringify(operation.path[0])} is not a text block and can't be split`);
-  if (operation.path.length === 1) {
-    const oldBlock = beforeValue[operation.path[0]];
-    if (isTextBlock({
-      schema
-    }, oldBlock)) {
-      const nextBlock = children[operation.path[0] + 1];
-      if (!nextBlock)
-        return patches;
-      const targetValue = nextBlock;
-      targetValue && (patches.push(insert([targetValue], "after", [{
-        _key: splitBlock2._key
-      }])), oldBlock.children.slice(operation.position).forEach((span) => {
-        const path2 = [{
-          _key: oldBlock._key
-        }, "children", {
-          _key: span._key
-        }];
-        patches.push(unset(path2));
-      }));
-    }
-    return patches;
-  }
-  if (operation.path.length === 2) {
-    const splitSpan = splitBlock2.children[operation.path[1]];
-    if (isSpan({
-      schema
-    }, splitSpan)) {
-      const targetSpans = {
-        children: splitBlock2.children.slice(operation.path[1] + 1, operation.path[1] + 2)
-      }.children;
-      patches.push(setIfMissing([], [{
-        _key: splitBlock2._key
-      }, "children"])), patches.push(insert(targetSpans, "after", [{
-        _key: splitBlock2._key
-      }, "children", {
-        _key: splitSpan._key
-      }])), patches.push(set(splitSpan.text, [{
-        _key: splitBlock2._key
-      }, "children", {
-        _key: splitSpan._key
-      }, "text"]));
-    }
-    return patches;
-  }
-  return patches;
-}
 function removeNodePatch(schema, beforeValue, operation) {
   const block = beforeValue[operation.path[0]];
   if (operation.path.length === 1) {
@@ -12162,86 +11470,6 @@ function removeNodePatch(schema, beforeValue, operation) {
   } else
     return [];
 }
-function mergeNodePatch(schema, children, operation, beforeValue) {
-  const patches = [], block = beforeValue[operation.path[0]], updatedBlock = children[operation.path[0]];
-  if (operation.path.length === 1)
-    if (block?._key) {
-      const prevBlock = children[operation.path[0] - 1];
-      if (!prevBlock)
-        throw new Error("Previous block not found!");
-      const newBlock = prevBlock;
-      patches.push(set(newBlock, [{
-        _key: newBlock._key
-      }])), patches.push(unset([{
-        _key: block._key
-      }]));
-    } else
-      throw new Error("Target key not found!");
-  else if (isTextBlock({
-    schema
-  }, block) && isTextBlock({
-    schema
-  }, updatedBlock) && operation.path.length === 2) {
-    const updatedSpan = updatedBlock.children[operation.path[1] - 1] && isSpan({
-      schema
-    }, updatedBlock.children[operation.path[1] - 1]) ? updatedBlock.children[operation.path[1] - 1] : void 0, removedSpan = block.children[operation.path[1]] && isSpan({
-      schema
-    }, block.children[operation.path[1]]) ? block.children[operation.path[1]] : void 0;
-    if (updatedSpan) {
-      const spansMatchingKey = block.children.filter((span) => span._key === updatedSpan._key);
-      if (spansMatchingKey.length === 1) {
-        const prevSpan = spansMatchingKey[0];
-        isSpan({
-          schema
-        }, prevSpan) && prevSpan.text !== updatedSpan.text && patches.push(set(updatedSpan.text, [{
-          _key: block._key
-        }, "children", {
-          _key: updatedSpan._key
-        }, "text"]));
-      } else
-        console.warn(`Multiple spans have \`_key\` ${updatedSpan._key}. It's ambiguous which one to update.`, JSON.stringify(block, null, 2));
-    }
-    removedSpan && (block.children.filter((span) => span._key === removedSpan._key).length === 1 ? patches.push(unset([{
-      _key: block._key
-    }, "children", {
-      _key: removedSpan._key
-    }])) : console.warn(`Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)));
-  }
-  return patches;
-}
-function moveNodePatch(schema, beforeValue, operation) {
-  const patches = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
-  if (!targetBlock || !block)
-    return patches;
-  if (operation.path.length === 1) {
-    const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
-    patches.push(unset([{
-      _key: block._key
-    }])), patches.push(insert([block], position, [{
-      _key: targetBlock._key
-    }]));
-  } else if (operation.path.length === 2 && isTextBlock({
-    schema
-  }, block) && isTextBlock({
-    schema
-  }, targetBlock)) {
-    const child = block.children[operation.path[1]], targetChild = targetBlock.children[operation.newPath[1]], position = operation.newPath[1] === targetBlock.children.length ? "after" : "before", childToInsert = block.children[operation.path[1]];
-    if (!child || !targetChild || !childToInsert)
-      return patches;
-    patches.push(unset([{
-      _key: block._key
-    }, "children", {
-      _key: child._key
-    }])), patches.push(setIfMissing([], [{
-      _key: targetBlock._key
-    }, "children"])), patches.push(insert([childToInsert], position, [{
-      _key: targetBlock._key
-    }, "children", {
-      _key: targetChild._key
-    }]));
-  }
-  return patches;
-}
 function withRemoteChanges(editor, fn) {
   const prev = editor.isProcessingRemoteChanges;
   editor.isProcessingRemoteChanges = !0, fn(), editor.isProcessingRemoteChanges = prev;
@@ -12313,23 +11541,14 @@ function createPatchesPlugin({
         case "remove_node":
           patches = [...patches, ...removeNodePatch(editorActor.getSnapshot().context.schema, previousValue, operation)];
           break;
-        case "split_node":
-          patches = [...patches, ...splitNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousValue)];
-          break;
         case "insert_node":
           patches = [...patches, ...insertNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousValue)];
           break;
         case "set_node":
           patches = [...patches, ...setNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation)];
           break;
-        case "merge_node":
-          patches = [...patches, ...mergeNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousValue)];
-          break;
-        case "move_node":
-          patches = [...patches, ...moveNodePatch(editorActor.getSnapshot().context.schema, previousValue, operation)];
-          break;
       }
-      if (!editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], relayActor.send({
+      if (!editorWasEmpty && editorIsEmpty && ["set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], relayActor.send({
         type: "unset",
         previousValue
       })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0)
@@ -12418,23 +11637,6 @@ function createUniqueKeysPlugin(editorActor) {
         apply2(operation);
         return;
       }
-      if (operation.type === "split_node") {
-        const _key = operation.properties._key && keyExistsAtPath({
-          blockIndexMap: editor.blockIndexMap,
-          context: {
-            schema: context.schema,
-            value: editor.children
-          }
-        }, operation.path, operation.properties._key) ? void 0 : operation.properties._key;
-        apply2({
-          ...operation,
-          properties: {
-            ...operation.properties,
-            _key: _key === void 0 ? editorActor.getSnapshot().context.keyGenerator() : _key
-          }
-        });
-        return;
-      }
       if (operation.type === "insert_node" && !Editor.isEditor(operation.node)) {
         const _key = operation.node._key && keyExistsAtPath({
           blockIndexMap: editor.blockIndexMap,
@@ -12452,54 +11654,6 @@ function createUniqueKeysPlugin(editorActor) {
         });
         return;
       }
-      if (operation.type === "merge_node") {
-        const index = operation.path[operation.path.length - 1], prevPath = Path.previous(operation.path), prevIndex = prevPath[prevPath.length - 1];
-        if (operation.path.length !== 1 || prevPath.length !== 1) {
-          apply2(operation);
-          return;
-        }
-        const block = editor.children.at(index), previousBlock = editor.children.at(prevIndex);
-        if (!block || !previousBlock) {
-          apply2(operation);
-          return;
-        }
-        if (!isTextBlock(editorActor.getSnapshot().context, block) || !isTextBlock(editorActor.getSnapshot().context, previousBlock)) {
-          apply2(operation);
-          return;
-        }
-        const previousBlockChildKeys = previousBlock.children.map((child) => child._key), previousBlockMarkDefKeys = previousBlock.markDefs?.map((markDef) => markDef._key) ?? [], markDefKeyMap = /* @__PURE__ */ new Map(), adjustedMarkDefs = block.markDefs?.map((markDef) => {
-          if (previousBlockMarkDefKeys.includes(markDef._key)) {
-            const newKey = editorActor.getSnapshot().context.keyGenerator();
-            return markDefKeyMap.set(markDef._key, newKey), {
-              ...markDef,
-              _key: newKey
-            };
-          }
-          return markDef;
-        });
-        let childIndex = 0;
-        for (const child of block.children) {
-          if (isSpan(editorActor.getSnapshot().context, child)) {
-            const marks = child.marks?.map((mark) => markDefKeyMap.get(mark) || mark) ?? [];
-            isEqualMarks(child.marks, marks) || applySetNode(editor, {
-              marks
-            }, [index, childIndex]);
-          }
-          previousBlockChildKeys.includes(child._key) && applySetNode(editor, {
-            _key: editorActor.getSnapshot().context.keyGenerator()
-          }, [index, childIndex]), childIndex++;
-        }
-        apply2({
-          ...operation,
-          properties: {
-            ...operation.properties,
-            // Make sure the adjusted markDefs are carried along for the merge
-            // operation
-            markDefs: adjustedMarkDefs
-          }
-        });
-        return;
-      }
       apply2(operation);
     }, editor.normalizeNode = (entry) => {
       const [node2, path2] = entry;
@@ -14213,21 +13367,11 @@ const addAnnotationOperationImplementation = ({
         }), [splitStart, splitEnd] = Range.edges(splitRange);
         if (!Editor.isEnd(editor, splitEnd, splitEnd.path) || !Editor.isEdge(editor, splitEnd, splitEnd.path)) {
           const [endNode] = Editor.node(editor, splitEnd.path);
-          editor.apply({
-            type: "split_node",
-            path: splitEnd.path,
-            position: splitEnd.offset,
-            properties: Node$1.extractProps(endNode, editor.schema)
-          });
+          applySplitNode(editor, splitEnd.path, splitEnd.offset, Node$1.extractProps(endNode, editor.schema));
         }
         if (!Editor.isStart(editor, splitStart, splitStart.path) || !Editor.isEdge(editor, splitStart, splitStart.path)) {
           const [startNode] = Editor.node(editor, splitStart.path);
-          editor.apply({
-            type: "split_node",
-            path: splitStart.path,
-            position: splitStart.offset,
-            properties: Node$1.extractProps(startNode, editor.schema)
-          });
+          applySplitNode(editor, splitStart.path, splitStart.offset, Node$1.extractProps(startNode, editor.schema));
         }
         const updatedSplitRange = splitRangeRef.unref();
         !at && updatedSplitRange && applySelect(editor, updatedSplitRange);
@@ -14304,21 +13448,11 @@ const addAnnotationOperationImplementation = ({
           }), [splitStart, splitEnd] = Range.edges(splitRange);
           if (!Editor.isEnd(editor, splitEnd, splitEnd.path) || !Editor.isEdge(editor, splitEnd, splitEnd.path)) {
             const [endNode] = Editor.node(editor, splitEnd.path);
-            editor.apply({
-              type: "split_node",
-              path: splitEnd.path,
-              position: splitEnd.offset,
-              properties: Node$1.extractProps(endNode, editor.schema)
-            });
+            applySplitNode(editor, splitEnd.path, splitEnd.offset, Node$1.extractProps(endNode, editor.schema));
           }
           if (!Editor.isStart(editor, splitStart, splitStart.path) || !Editor.isEdge(editor, splitStart, splitStart.path)) {
             const [startNode] = Editor.node(editor, splitStart.path);
-            editor.apply({
-              type: "split_node",
-              path: splitStart.path,
-              position: splitStart.offset,
-              properties: Node$1.extractProps(startNode, editor.schema)
-            });
+            applySplitNode(editor, splitStart.path, splitStart.offset, Node$1.extractProps(startNode, editor.schema));
           }
           const updatedSplitRange = splitRangeRef.unref();
           !at && updatedSplitRange && applySelect(editor, updatedSplitRange);
@@ -14557,21 +13691,11 @@ const addAnnotationOperationImplementation = ({
       }), [start2, end2] = Range.edges(at);
       if (!Editor.isEnd(editor, end2, end2.path) || !Editor.isEdge(editor, end2, end2.path)) {
         const [endNode] = Editor.node(editor, end2.path);
-        editor.apply({
-          type: "split_node",
-          path: end2.path,
-          position: end2.offset,
-          properties: Node$1.extractProps(endNode, editor.schema)
-        });
+        applySplitNode(editor, end2.path, end2.offset, Node$1.extractProps(endNode, editor.schema));
       }
       if (!Editor.isStart(editor, start2, start2.path) || !Editor.isEdge(editor, start2, start2.path)) {
         const [startNode] = Editor.node(editor, start2.path);
-        editor.apply({
-          type: "split_node",
-          path: start2.path,
-          position: start2.offset,
-          properties: Node$1.extractProps(startNode, editor.schema)
-        });
+        applySplitNode(editor, start2.path, start2.offset, Node$1.extractProps(startNode, editor.schema));
       }
       if (at = rangeRef2.unref(), !at)
         throw new Error("Unable to add decorator without a selection");
@@ -14635,21 +13759,11 @@ const addAnnotationOperationImplementation = ({
         const [start2, end2] = Range.edges(at);
         if (!Editor.isEnd(editor, end2, end2.path) || !Editor.isEdge(editor, end2, end2.path)) {
           const [endNode] = Editor.node(editor, end2.path);
-          editor.apply({
-            type: "split_node",
-            path: end2.path,
-            position: end2.offset,
-            properties: Node$1.extractProps(endNode, editor.schema)
-          });
+          applySplitNode(editor, end2.path, end2.offset, Node$1.extractProps(endNode, editor.schema));
         }
         if (!Editor.isStart(editor, start2, start2.path) || !Editor.isEdge(editor, start2, start2.path)) {
           const [startNode] = Editor.node(editor, start2.path);
-          editor.apply({
-            type: "split_node",
-            path: start2.path,
-            position: start2.offset,
-            properties: Node$1.extractProps(startNode, editor.schema)
-          });
+          applySplitNode(editor, start2.path, start2.offset, Node$1.extractProps(startNode, editor.schema));
         }
       }
       const updatedAt = rangeRef2.unref();
@@ -15267,24 +14381,14 @@ function insertBlock(options) {
             text: _2,
             ...properties
           } = textNode;
-          editor.apply({
-            type: "split_node",
-            path: selectionPoint.path,
-            position: childOffset,
-            properties
-          });
+          applySplitNode(editor, selectionPoint.path, childOffset, properties);
         }
       }
       const splitAtIndex = childOffset > 0 ? childIndex + 1 : childIndex, {
         children: _,
         ...blockProperties
       } = currentBlock;
-      editor.apply({
-        type: "split_node",
-        path: blockPath,
-        position: splitAtIndex,
-        properties: blockProperties
-      });
+      applySplitNode(editor, blockPath, splitAtIndex, blockProperties);
       const insertPath = [blockPath[0] + 1];
       if (editor.apply({
         type: "insert_node",
@@ -15476,12 +14580,7 @@ function insertBlock(options) {
             text: _,
             ...properties
           } = nodeToSplit;
-          editor.apply({
-            type: "split_node",
-            path: startPoint.path,
-            position: startPoint.offset,
-            properties
-          });
+          applySplitNode(editor, startPoint.path, startPoint.offset, properties);
         }
         insertTextBlockFragment(editor, block, startPoint), select2 === "none" ? setSelectionToRange(editor, at) : setSelection(editor, [endBlockPath[0] + 1], "start");
       } else {
@@ -15494,12 +14593,7 @@ function insertBlock(options) {
             text: _,
             ...properties
           } = textNode;
-          editor.apply({
-            type: "split_node",
-            path: currentPath,
-            position: currentOffset,
-            properties
-          }), currentPath = Path.next(currentPath), currentOffset = 0;
+          applySplitNode(editor, currentPath, currentOffset, properties), currentPath = Path.next(currentPath), currentOffset = 0;
         }
         const splitAtIndex = currentOffset > 0 ? currentPath[1] + 1 : currentPath[1], blockToSplit = Node$1.get(editor, blockPath, editor.schema);
         if (splitAtIndex < blockToSplit.children.length && Element$2.isElement(blockToSplit, editor.schema)) {
@@ -15507,12 +14601,7 @@ function insertBlock(options) {
             children: _,
             ...blockProperties
           } = blockToSplit;
-          editor.apply({
-            type: "split_node",
-            path: blockPath,
-            position: splitAtIndex,
-            properties: blockProperties
-          });
+          applySplitNode(editor, blockPath, splitAtIndex, blockProperties);
         }
         const currentFirstBlockPath = firstBlockPathRef.unref(), insertPath = currentFirstBlockPath ? [currentFirstBlockPath[0] + 1] : [blockPath[0] + 1];
         if (editor.apply({
@@ -15654,18 +14743,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;
-    editor.apply({
-      type: "merge_node",
-      path: newEndPath,
-      position: 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]];
@@ -15702,18 +14780,15 @@ function deleteCrossBlockRange(editor, start2, end2) {
     }
   }
   const startBlock = Node$1.get(editor, startBlockPath, editor.schema), endBlock = Node$1.get(editor, adjustedEndBlockPath, editor.schema);
-  if (editor.isTextBlock(startBlock) && editor.isTextBlock(endBlock)) {
-    const {
-      children: _,
-      ...properties
-    } = endBlock;
-    editor.apply({
-      type: "merge_node",
-      path: adjustedEndBlockPath,
-      position: startBlock.children.length,
-      properties
-    });
-  }
+  editor.isTextBlock(startBlock) && editor.isTextBlock(endBlock) && Editor.withoutNormalizing(editor, () => {
+    if (Array.isArray(endBlock.markDefs) && endBlock.markDefs.length > 0) {
+      const oldDefs = Array.isArray(startBlock.markDefs) && startBlock.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...endBlock.markDefs].map((def) => [def._key, def])).values()];
+      applySetNode(editor, {
+        markDefs: newMarkDefs
+      }, startBlockPath);
+    }
+    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length);
+  });
 }
 function deleteExpandedRange(editor, range2) {
   const [start2, end2] = Range.edges(range2);
@@ -15729,12 +14804,7 @@ function insertTextBlockFragment(editor, block, at) {
         text: _,
         ...properties
       } = textNode;
-      editor.apply({
-        type: "split_node",
-        path: at.path,
-        position: at.offset,
-        properties
-      });
+      applySplitNode(editor, at.path, at.offset, properties);
     }
   }
   const parentPath = Path.parent(at.path);
@@ -15777,11 +14847,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({
@@ -15803,11 +14869,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");
@@ -15901,11 +14963,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");
-  operation.editor.apply({
-    type: "move_node",
-    path: [originBlockIndex],
-    newPath: [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
 }) => {