@portabletext/editor 6.1.2 → 6.2.0

package/lib/index.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:";
@@ -906,42 +906,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 +1015,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 +1029,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 +1398,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 +1412,135 @@ const apply$1 = (editor, op) => {
     selection
   } = editor;
   return selection ? Node$1.fragment(editor, selection, editor.schema) : [];
-}, normalizeNode = (editor, entry) => {
+};
+function applyMergeNode(editor, path2, position, properties) {
+  const node2 = Node$1.get(editor, path2, editor.schema), prevPath = Path.previous(path2), mergeOp = {
+    type: "merge_node",
+    path: path2,
+    position,
+    properties
+  };
+  for (const ref of Editor.pathRefs(editor))
+    PathRef.transform(ref, mergeOp);
+  for (const ref of Editor.pointRefs(editor))
+    PointRef.transform(ref, mergeOp);
+  for (const ref of Editor.rangeRefs(editor))
+    RangeRef.transform(ref, mergeOp);
+  if (editor.selection) {
+    const sel = {
+      ...editor.selection
+    };
+    for (const [point2, key] of Range.points(sel)) {
+      const result = Point.transform(point2, mergeOp);
+      result && (sel[key] = result);
+    }
+    editor.selection = sel;
+  }
+  const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
+  Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
+  const savedSelection = editor.selection, editorAny = editor, savedPendingDiffs = editorAny.pendingDiffs, savedPendingSelection = editorAny.pendingSelection, savedPendingAction = editorAny.pendingAction;
+  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, mergeOp)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
+    const sel = savedPendingSelection, anchor = Point.transform(sel.anchor, mergeOp, {
+      affinity: "backward"
+    }), focus = Point.transform(sel.focus, mergeOp, {
+      affinity: "backward"
+    });
+    editorAny.pendingSelection = anchor && focus ? {
+      anchor,
+      focus
+    } : null;
+  }
+  if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
+    const action = savedPendingAction;
+    if (Point.isPoint(action.at)) {
+      const at = Point.transform(action.at, mergeOp, {
+        affinity: "backward"
+      });
+      editorAny.pendingAction = at ? {
+        ...action,
+        at
+      } : null;
+    } else if (Range.isRange(action.at)) {
+      const anchor = Point.transform(action.at.anchor, mergeOp, {
+        affinity: "backward"
+      }), focus = Point.transform(action.at.focus, mergeOp, {
+        affinity: "backward"
+      });
+      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, op) {
+  const {
+    path: path2,
+    diff: diff2,
+    id
+  } = textDiff;
+  if (!Path.equals(op.path, path2)) {
+    const newPath = Path.transform(path2, op);
+    return newPath ? {
+      diff: diff2,
+      id,
+      path: newPath
+    } : null;
+  }
+  return {
+    diff: {
+      start: diff2.start + op.position,
+      end: diff2.end + op.position,
+      text: diff2.text
+    },
+    id,
+    path: Path.transform(path2, op)
+  };
+}
+const normalizeNode = (editor, entry) => {
   const [node2, path2] = entry;
   if (Text$1.isText(node2, editor.schema) || editor.isObjectNode(node2))
     return;
@@ -1539,20 +1557,29 @@ 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), {
+              text: _text,
+              ...properties
+            } = child;
+            applyMergeNode(editor, mergePath, prev.text.length, properties), 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 +2174,77 @@ 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 applySplitNode(editor, path2, position, properties) {
+  const node2 = Node$1.get(editor, path2, editor.schema), splitOp = {
+    type: "split_node",
+    path: path2,
+    position,
+    properties
+  };
+  for (const ref of Editor.pathRefs(editor))
+    PathRef.transform(ref, splitOp);
+  for (const ref of Editor.pointRefs(editor))
+    PointRef.transform(ref, splitOp);
+  for (const ref of Editor.rangeRefs(editor))
+    RangeRef.transform(ref, splitOp);
+  if (editor.selection) {
+    const sel = {
+      ...editor.selection
+    };
+    for (const [point2, key] of Range.points(sel))
+      sel[key] = Point.transform(point2, splitOp);
+    editor.selection = sel;
+  }
+  const 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);
+  }
+}
+const insertNodes = (editor, nodes2, options = {}) => {
   Editor.withoutNormalizing(editor, () => {
     const {
       hanging = !1,
@@ -2184,12 +2281,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 +2365,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 {
@@ -2391,97 +2399,6 @@ const previous = (editor, options = {}) => {
       }
     }
   });
-}, 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);
-      }
-    } finally {
-      beforeRef.unref(), afterRef?.unref();
-    }
-  });
 }, collapse = (editor, options = {}) => {
   const {
     edge = "anchor"
@@ -2568,7 +2485,68 @@ const previous = (editor, options = {}) => {
       newProperties: newProps
     });
   }
-}, deleteText = (editor, options = {}) => {
+};
+function applyMoveNode(editor, path2, newPath) {
+  if (Path.equals(path2, newPath))
+    return;
+  if (Path.isAncestor(path2, newPath))
+    throw new Error(`Cannot move a path [${path2}] to new path [${newPath}] because the destination is inside itself.`);
+  const node2 = Node$1.get(editor, path2, editor.schema), moveOp = {
+    type: "move_node",
+    path: path2,
+    newPath
+  };
+  for (const ref of Editor.pathRefs(editor))
+    PathRef.transform(ref, moveOp);
+  for (const ref of Editor.pointRefs(editor))
+    PointRef.transform(ref, moveOp);
+  for (const ref of Editor.rangeRefs(editor))
+    RangeRef.transform(ref, moveOp);
+  if (editor.selection) {
+    const sel = {
+      ...editor.selection
+    };
+    for (const [point2, key] of Range.points(sel))
+      sel[key] = Point.transform(point2, moveOp);
+    editor.selection = sel;
+  }
+  const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
+  Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
+  const savedSelection = editor.selection;
+  try {
+    Editor.withoutNormalizing(editor, () => {
+      editor.apply({
+        type: "remove_node",
+        path: path2,
+        node: node2
+      }), editor.apply({
+        type: "insert_node",
+        path: newPath,
+        node: node2
+      });
+    });
+  } finally {
+    editor.selection = savedSelection;
+    for (const ref of pathRefs)
+      Editor.pathRefs(editor).add(ref);
+    for (const ref of pointRefs)
+      Editor.pointRefs(editor).add(ref);
+    for (const ref of rangeRefs)
+      Editor.rangeRefs(editor).add(ref);
+  }
+}
+function applySetNode(editor, props, path2) {
+  const node2 = Node$1.get(editor, path2, editor.schema), propsRecord = props, properties = {}, newProperties = {};
+  for (const key of Object.keys(propsRecord))
+    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 +2671,71 @@ 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 properties, position;
+          if (Text$1.isText(mergeNode, editor.schema) && Text$1.isText(prevNode, editor.schema)) {
+            const {
+              text: _text,
+              ...rest
+            } = mergeNode;
+            position = prevNode.text.length, properties = rest;
+          } else if (Element$2.isElement(mergeNode, editor.schema) && Element$2.isElement(prevNode, editor.schema)) {
+            const {
+              children: _children,
+              ...rest
+            } = mergeNode;
+            position = prevNode.children.length, properties = rest;
+          } else
+            throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${Scrubber.stringify(mergeNode)} ${Scrubber.stringify(prevNode)}`);
+          if (isPreviousSibling || applyMoveNode(editor, mergePath, newPath), emptyRef && Transforms.removeNodes(editor, {
+            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, properties);
+          }
+          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 +2791,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 +2809,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),
@@ -3525,46 +3560,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 +3574,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 +3592,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 +3605,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 +3618,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 +3659,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;
     }
@@ -5601,8 +5616,8 @@ const reconcileChildren = (editor, {
   }), 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) {
+    const lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
+    if (lookAhead === -1) {
       chunkTreeHelper.remove();
       continue;
     }
@@ -5622,13 +5637,11 @@ const reconcileChildren = (editor, {
       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, {
@@ -7538,13 +7551,6 @@ const withReact = (editor) => {
       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 = {
@@ -10693,12 +10699,7 @@ 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({
@@ -10711,17 +10712,6 @@ function applyInsertNodeAtPoint(editor, node2, at, 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
-  });
-}
 function withNormalizeNode(editor, fn) {
   const prev = editor.isNormalizingNode;
   editor.isNormalizingNode = !0, fn(), editor.isNormalizingNode = prev;
@@ -10754,12 +10744,7 @@ function createNormalizationPlugin(editorActor) {
                 text: _text,
                 ...properties
               } = nextNode;
-              editor.apply({
-                type: "merge_node",
-                path: mergePath,
-                position: child.text.length,
-                properties
-              });
+              applyMergeNode(editor, mergePath, child.text.length, properties);
             });
             return;
           }
@@ -10842,7 +10827,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 +10875,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 +12065,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 +12085,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 +12156,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 +12252,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 +12269,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 +13982,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 +14063,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 +14306,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 +14374,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 +14996,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 +15195,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 +15208,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 +15216,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({
@@ -15659,12 +15363,7 @@ function deleteSameBlockRange(editor, start2, end2) {
       text: _,
       ...properties
     } = endNodeAfter;
-    editor.apply({
-      type: "merge_node",
-      path: newEndPath,
-      position: startNodeAfter.text.length,
-      properties
-    });
+    applyMergeNode(editor, newEndPath, startNodeAfter.text.length, properties);
   }
 }
 function deleteCrossBlockRange(editor, start2, end2) {
@@ -15702,18 +15401,19 @@ 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)) {
+  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);
+    }
     const {
       children: _,
       ...properties
     } = endBlock;
-    editor.apply({
-      type: "merge_node",
-      path: adjustedEndBlockPath,
-      position: startBlock.children.length,
-      properties
-    });
-  }
+    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length, properties);
+  });
 }
 function deleteExpandedRange(editor, range2) {
   const [start2, end2] = Range.edges(range2);
@@ -15729,12 +15429,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);
@@ -15901,11 +15596,7 @@ 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]
-  });
+  applyMoveNode(operation.editor, [originBlockIndex], [destinationBlockIndex]);
 }, moveForwardOperationImplementation = ({
   operation
 }) => {