@portabletext/editor 6.1.1 → 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:";
@@ -36,9 +36,6 @@ const debug$1 = {
   syncValue: createDebugger("sync:value"),
   syncPatch: createDebugger("sync:patch")
 }, Operation = {
-  isNodeOperation(value) {
-    return Operation.isOperation(value) && value.type.endsWith("_node");
-  },
   isOperation(value) {
     if (!isObject(value))
       return !1;
@@ -68,12 +65,6 @@ const debug$1 = {
   isOperationList(value) {
     return Array.isArray(value) && value.every((val) => Operation.isOperation(val));
   },
-  isSelectionOperation(value) {
-    return Operation.isOperation(value) && value.type.endsWith("_selection");
-  },
-  isTextOperation(value) {
-    return Operation.isOperation(value) && value.type.endsWith("_text");
-  },
   inverse(op) {
     switch (op.type) {
       case "insert_node":
@@ -177,10 +168,6 @@ const debug$1 = {
   equals(range2, another) {
     return Point.equals(range2.anchor, another.anchor) && Point.equals(range2.focus, another.focus);
   },
-  surrounds(range2, target) {
-    const intersectionRange = Range.intersection(range2, target);
-    return intersectionRange ? Range.equals(intersectionRange, target) : !1;
-  },
   includes(range2, target) {
     if (Range.isRange(target)) {
       if (Range.includes(range2, target.anchor) || Range.includes(range2, target.focus))
@@ -280,18 +267,6 @@ const debug$1 = {
   },
   isElement(value, schema) {
     return isObject(value) && value._type === schema.block.name;
-  },
-  isElementList(value, schema) {
-    return Array.isArray(value) && value.every((val) => Element$2.isElement(val, schema));
-  },
-  isElementProps(props) {
-    return props.children !== void 0;
-  },
-  matches(element, props) {
-    for (const key in props)
-      if (key !== "children" && element[key] !== props[key])
-        return !1;
-    return !0;
   }
 }, Span = {
   isSpan(value) {
@@ -331,10 +306,6 @@ const debug$1 = {
       throw new Error(`Cannot get the ancestor node at path [${path2}] because it refers to a leaf node instead: ${Scrubber.stringify(node2)}`);
     return node2;
   },
-  *ancestors(root, path2, schema, options = {}) {
-    for (const p of Path.ancestors(path2, options))
-      yield [Node$1.ancestor(root, p, schema), p];
-  },
   child(root, index, schema) {
     if (Text$1.isText(root, schema) || Node$1.isObjectNode(root, schema))
       throw new Error(`Cannot get the child of a leaf node: ${Scrubber.stringify(root)}`);
@@ -355,24 +326,6 @@ const debug$1 = {
       yield [child, childPath], index = reverse ? index - 1 : index + 1;
     }
   },
-  common(root, path2, another, schema) {
-    const p = Path.common(path2, another);
-    return [Node$1.get(root, p, schema), p];
-  },
-  descendant(root, path2, schema) {
-    const node2 = Node$1.get(root, path2, schema);
-    if (Editor.isEditor(node2))
-      throw new Error(`Cannot get the descendant node at path [${path2}] because it refers to the root editor node instead: ${Scrubber.stringify(node2)}`);
-    return node2;
-  },
-  *descendants(root, schema, options = {}) {
-    for (const [node2, path2] of Node$1.nodes(root, schema, options))
-      path2.length !== 0 && (yield [node2, path2]);
-  },
-  *elements(root, schema, options = {}) {
-    for (const [node2, path2] of Node$1.nodes(root, schema, options))
-      Element$2.isElement(node2, schema) && (yield [node2, path2]);
-  },
   extractProps(node2, schema) {
     if (Element$2.isAncestor(node2, schema)) {
       const {
@@ -503,9 +456,6 @@ const debug$1 = {
     for (const p of Path.levels(path2, options))
       yield [Node$1.get(root, p, schema), p];
   },
-  matches(node2, props, schema) {
-    return Element$2.isElement(node2, schema) && Element$2.isElementProps(props) && Element$2.matches(node2, props) || Text$1.isText(node2, schema) && Text$1.isTextProps(props) && Text$1.matches(node2, props);
-  },
   *nodes(root, schema, options = {}) {
     const {
       pass,
@@ -593,14 +543,6 @@ const debug$1 = {
     }
     return 0;
   },
-  endsAfter(path2, another) {
-    const i = path2.length - 1, as = path2.slice(0, i), bs = another.slice(0, i), av = path2[i], bv = another[i];
-    return Path.equals(as, bs) && av > bv;
-  },
-  endsAt(path2, another) {
-    const i = path2.length, as = path2.slice(0, i), bs = another.slice(0, i);
-    return Path.equals(as, bs);
-  },
   endsBefore(path2, another) {
     const i = path2.length - 1, as = path2.slice(0, i), bs = another.slice(0, i), av = path2[i], bv = another[i];
     return Path.equals(as, bs) && av < bv;
@@ -620,18 +562,12 @@ const debug$1 = {
   isBefore(path2, another) {
     return Path.compare(path2, another) === -1;
   },
-  isChild(path2, another) {
-    return path2.length === another.length + 1 && Path.compare(path2, another) === 0;
-  },
   isCommon(path2, another) {
     return path2.length <= another.length && Path.compare(path2, another) === 0;
   },
   isDescendant(path2, another) {
     return path2.length > another.length && Path.compare(path2, another) === 0;
   },
-  isParent(path2, another) {
-    return path2.length + 1 === another.length && Path.compare(path2, another) === 0;
-  },
   isPath(value) {
     return Array.isArray(value) && (value.length === 0 || typeof value[0] == "number");
   },
@@ -680,11 +616,6 @@ 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);
   },
-  relative(path2, ancestor) {
-    if (!Path.isAncestor(ancestor, path2) && !Path.equals(path2, ancestor))
-      throw new Error(`Cannot get the relative path of [${path2}] inside ancestor [${ancestor}], because it is not above or equal to the path.`);
-    return path2.slice(ancestor.length);
-  },
   transform(path2, operation, options = {}) {
     if (!path2)
       return null;
@@ -844,14 +775,9 @@ const debug$1 = {
     });
     ref.current = path2, path2 == null && ref.unref();
   }
-};
-let _scrubber;
-const Scrubber = {
-  setScrubber(scrubber) {
-    _scrubber = scrubber;
-  },
+}, Scrubber = {
   stringify(value) {
-    return JSON.stringify(value, _scrubber);
+    return JSON.stringify(value);
   }
 }, Text$1 = {
   equals(text, another, options = {}) {
@@ -870,18 +796,6 @@ const Scrubber = {
   isText(value, schema) {
     return isObject(value) && value._type === schema.span.name;
   },
-  isTextList(value, schema) {
-    return Array.isArray(value) && value.every((val) => Text$1.isText(val, schema));
-  },
-  isTextProps(props) {
-    return props.text !== void 0;
-  },
-  matches(text, props) {
-    for (const key in props)
-      if (key !== "text" && (!text.hasOwnProperty(key) || text[key] !== props[key]))
-        return !1;
-    return !0;
-  },
   decorations(node2, decorations) {
     let leaves = [{
       leaf: {
@@ -992,42 +906,6 @@ const Scrubber = {
         }), 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
@@ -1137,40 +1015,6 @@ const Scrubber = {
         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 = {
@@ -1185,17 +1029,8 @@ const Scrubber = {
   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) {
@@ -1431,9 +1266,6 @@ const endingEmojiZWJ = new RegExp("\\p{ExtPict}[\\p{Gr_Ext}\\p{EMod}]*\\u200D$",
   levels(editor, options) {
     return editor.levels(options);
   },
-  marks(editor) {
-    return editor.getMarks();
-  },
   next(editor, options) {
     return editor.next(options);
   },
@@ -1566,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 [];
   }
@@ -1611,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;
@@ -1628,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();
@@ -1775,13 +1713,13 @@ const apply$1 = (editor, op) => {
 }, hasInlines = (editor, element) => element.children.some((n2) => Text$1.isText(n2, editor.schema) || Editor.isInline(editor, n2)), hasPath = (editor, path2) => Node$1.has(editor, path2, editor.schema), insertText = (editor, text, options = {}) => {
   const {
     selection,
-    marks: marks2
+    marks
   } = editor;
   if (selection) {
-    if (marks2) {
+    if (marks) {
       const node2 = {
         text,
-        ...marks2
+        ...marks
       };
       Transforms.insertNodes(editor, node2, {
         at: options.at,
@@ -1818,64 +1756,7 @@ function* levels(editor, options = {}) {
     match2(n2, p) && levels2.push([n2, p]);
   reverse && levels2.reverse(), yield* levels2;
 }
-const marks = (editor, _options = {}) => {
-  const {
-    marks: marks2,
-    selection
-  } = editor;
-  if (!selection)
-    return null;
-  let {
-    anchor,
-    focus
-  } = selection;
-  if (marks2)
-    return marks2;
-  if (Range.isExpanded(selection)) {
-    if (Range.isBackward(selection) && ([focus, anchor] = [anchor, focus]), Editor.isEnd(editor, anchor, anchor.path)) {
-      const after2 = Editor.after(editor, anchor);
-      after2 && (anchor = after2);
-    }
-    const [match2] = Editor.nodes(editor, {
-      match: (n2) => Text$1.isText(n2, editor.schema),
-      at: {
-        anchor,
-        focus
-      }
-    });
-    if (match2) {
-      const [node22] = match2, {
-        text: _text,
-        ...rest2
-      } = node22;
-      return rest2;
-    } else
-      return {};
-  }
-  const {
-    path: path2
-  } = anchor;
-  let [node2] = Editor.leaf(editor, path2);
-  if (!Text$1.isText(node2, editor.schema))
-    return {};
-  if (anchor.offset === 0) {
-    const prev = Editor.previous(editor, {
-      at: path2,
-      match: (n2) => Text$1.isText(n2, editor.schema)
-    }), block = Editor.above(editor, {
-      match: (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2)
-    });
-    if (prev && block) {
-      const [prevNode, prevPath] = prev, [, blockPath] = block;
-      Path.isAncestor(blockPath, prevPath) && (node2 = prevNode);
-    }
-  }
-  const {
-    text: _text2,
-    ...rest
-  } = node2;
-  return rest;
-}, next = (editor, options = {}) => {
+const next = (editor, options = {}) => {
   const {
     mode = "lowest",
     voids = !1
@@ -2293,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,
@@ -2330,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
@@ -2383,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 {
@@ -2528,104 +2390,13 @@ const previous = (editor, options = {}) => {
     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);
+        const [node2] = Editor.node(editor, path2);
+        editor.apply({
+          type: "remove_node",
+          path: path2,
+          node: node2
+        });
       }
-    } finally {
-      beforeRef.unref(), afterRef?.unref();
     }
   });
 }, collapse = (editor, options = {}) => {
@@ -2714,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,
@@ -2839,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);
   });
@@ -2889,7 +2781,6 @@ const previous = (editor, options = {}) => {
     deselect: (...args) => deselect(e, ...args),
     elementReadOnly: (...args) => elementReadOnly(e, ...args),
     end: (...args) => end(e, ...args),
-    getMarks: (...args) => marks(e, ...args),
     hasInlines: (...args) => hasInlines(e, ...args),
     hasPath: (...args) => hasPath(e, ...args),
     insertNodes: (...args) => insertNodes(e, ...args),
@@ -2900,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),
@@ -2920,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),
@@ -3048,10 +2936,7 @@ const previous = (editor, options = {}) => {
   }
   return !1;
 }, IS_IOS = typeof navigator < "u" && typeof window < "u" && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream, IS_ANDROID = typeof navigator < "u" && /Android/.test(navigator.userAgent), IS_FIREFOX = typeof navigator < "u" && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent), IS_WEBKIT = typeof navigator < "u" && /AppleWebKit(?!.*Chrome)/i.test(navigator.userAgent), IS_EDGE_LEGACY = typeof navigator < "u" && /Edge?\/(?:[0-6][0-9]|[0-7][0-8])(?:\.)/i.test(navigator.userAgent), IS_CHROME = typeof navigator < "u" && /Chrome/i.test(navigator.userAgent), IS_CHROME_LEGACY = typeof navigator < "u" && /Chrome?\/(?:[0-7][0-5]|[0-6][0-9])(?:\.)/i.test(navigator.userAgent), IS_ANDROID_CHROME_LEGACY = IS_ANDROID && typeof navigator < "u" && /Chrome?\/(?:[0-5]?\d)(?:\.)/i.test(navigator.userAgent), IS_FIREFOX_LEGACY = typeof navigator < "u" && /^(?!.*Seamonkey)(?=.*Firefox\/(?:[0-7][0-9]|[0-8][0-6])(?:\.)).*/i.test(navigator.userAgent), IS_UC_MOBILE = typeof navigator < "u" && /.*UCBrowser/.test(navigator.userAgent), IS_WECHATBROWSER = typeof navigator < "u" && /.*Wechat/.test(navigator.userAgent) && !/.*MacWechat/.test(navigator.userAgent) && // avoid lookbehind (buggy in safari < 16.4)
-(!IS_CHROME || IS_CHROME_LEGACY), CAN_USE_DOM = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u";
-typeof navigator < "u" && /Safari/.test(navigator.userAgent) && /Version\/(\\d+)/.test(navigator.userAgent) && (navigator.userAgent.match(/Version\/(\\d+)/)?.[1] && // biome-ignore lint/suspicious/noNonNullAssertedOptionalChain: Slate upstream — regex match guaranteed by outer test
-parseInt(navigator.userAgent.match(/Version\/(\\d+)/)?.[1], 10) < 17);
-const HAS_BEFORE_INPUT_SUPPORT = (!IS_CHROME_LEGACY || !IS_ANDROID_CHROME_LEGACY) && !IS_EDGE_LEGACY && // globalThis is undefined in older browsers
+(!IS_CHROME || IS_CHROME_LEGACY), CAN_USE_DOM = typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", HAS_BEFORE_INPUT_SUPPORT = (!IS_CHROME_LEGACY || !IS_ANDROID_CHROME_LEGACY) && !IS_EDGE_LEGACY && // globalThis is undefined in older browsers
 typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent.prototype.getTargetRanges == "function";
 let n = 0;
 class Key {
@@ -3060,20 +2945,10 @@ class Key {
   }
 }
 const DOMEditor = {
-  androidPendingDiffs: (editor) => editor.pendingDiffs,
-  androidScheduleFlush: (editor) => {
-    editor.scheduleFlush?.();
-  },
   blur: (editor) => {
     const el = DOMEditor.toDOMNode(editor, editor), root = DOMEditor.findDocumentOrShadowRoot(editor);
     editor.focused = !1, root.activeElement === el && el.blur();
   },
-  deselect: (editor) => {
-    const {
-      selection
-    } = editor, root = DOMEditor.findDocumentOrShadowRoot(editor), domSelection = getSelection(root);
-    domSelection && domSelection.rangeCount > 0 && domSelection.removeAllRanges(), selection && Transforms.deselect(editor);
-  },
   findDocumentOrShadowRoot: (editor) => {
     const el = DOMEditor.toDOMNode(editor, editor), root = el.getRootNode();
     return root instanceof Document || root instanceof ShadowRoot ? root : el.ownerDocument;
@@ -3194,7 +3069,6 @@ const DOMEditor = {
   hasTarget: (editor, target) => isDOMNode(target) && DOMEditor.hasDOMNode(editor, target),
   isComposing: (editor) => !!editor.composing,
   isFocused: (editor) => !!editor.focused,
-  isReadOnly: (editor) => !!editor.readOnly,
   isTargetInsideNonReadonlyVoid: (editor, target) => {
     if (editor.readOnly)
       return !1;
@@ -3686,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 ? {
@@ -3734,15 +3568,13 @@ function transformTextDiff(textDiff, op) {
     id
   } : null;
 }
-const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
+const withDOM = (editor) => {
   const e = editor, {
     apply: apply2,
     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.changeVersion = {
-    current: 0
-  }, 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;
+  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 = [], pendingDiffs = e.pendingDiffs;
     if (pendingDiffs?.length) {
       const transformed = pendingDiffs.map((textDiff) => transformTextDiff(textDiff, op)).filter(Boolean);
       e.pendingDiffs = transformed;
@@ -3760,8 +3592,7 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
     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;
       }
@@ -3774,27 +3605,10 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
         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":
@@ -3804,13 +3618,6 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
       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
@@ -3841,7 +3648,7 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
       span.style.whiteSpace = "pre", span.appendChild(attach), contents.appendChild(span), attach = span;
     }
     const fragment = e.getFragment(), string2 = JSON.stringify(fragment), encoded = window.btoa(encodeURIComponent(string2));
-    attach.setAttribute("data-slate-fragment", encoded), data.setData(`application/${clipboardFormatKey}`, encoded);
+    attach.setAttribute("data-slate-fragment", encoded), data.setData("application/x-slate-fragment", encoded);
     const div = contents.ownerDocument.createElement("div");
     return div.appendChild(contents), div.setAttribute("hidden", "true"), contents.ownerDocument.body.appendChild(div), data.setData("text/html", div.innerHTML), data.setData("text/plain", getPlainText(div)), contents.ownerDocument.body.removeChild(div), data;
   }, e.insertData = (data) => {
@@ -3852,8 +3659,53 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
       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;
     }
@@ -4018,22 +3870,6 @@ const withDOM = (editor, clipboardFormatKey = "x-slate-fragment") => {
     meta: !1,
     alt: !1
   }]
-}), extendBackward = createKeyboardShortcut({
-  default: [{
-    key: "ArrowLeft",
-    shift: !0,
-    ctrl: !1,
-    meta: !1,
-    alt: !1
-  }]
-}), extendForward = createKeyboardShortcut({
-  default: [{
-    key: "ArrowRight",
-    shift: !0,
-    ctrl: !1,
-    meta: !1,
-    alt: !1
-  }]
 }), italic = createKeyboardShortcut({
   default: [{
     key: "I",
@@ -4241,8 +4077,6 @@ var Hotkeys = {
   isDeleteLineForward: deleteLineForward.guard,
   isDeleteWordBackward: deleteWordBackward.guard,
   isDeleteWordForward: deleteWordForward.guard,
-  isExtendBackward: extendBackward.guard,
-  isExtendForward: extendForward.guard,
   isExtendLineBackward: extendLineBackward.guard,
   isExtendLineForward: extendLineForward.guard,
   isItalic: italic.guard,
@@ -5782,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;
     }
@@ -5803,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, {
@@ -6788,9 +6620,9 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     });
   }
   const {
-    marks: marks2
+    marks
   } = editor;
-  if (state.hasMarkPlaceholder = !1, editor.selection && Range.isCollapsed(editor.selection) && marks2) {
+  if (state.hasMarkPlaceholder = !1, editor.selection && Range.isCollapsed(editor.selection) && marks) {
     const {
       anchor
     } = editor.selection, leaf2 = Node$1.leaf(editor, anchor.path, editor.schema);
@@ -6799,7 +6631,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         text: _text,
         ...rest
       } = leaf2;
-      if (!Text$1.equals(leaf2, marks2, {
+      if (!Text$1.equals(leaf2, marks, {
         loose: !0
       })) {
         state.hasMarkPlaceholder = !0;
@@ -6807,7 +6639,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         decorations.push({
           [MARK_PLACEHOLDER_SYMBOL]: !0,
           ...unset2,
-          ...marks2,
+          ...marks,
           anchor,
           focus: anchor
         });
@@ -6825,10 +6657,10 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         } = selection, text = Node$1.leaf(editor, anchor.path, editor.schema);
         if (!Text$1.isText(text, editor.schema))
           return;
-        if (marks2 && !Text$1.equals(text, marks2, {
+        if (marks && !Text$1.equals(text, marks, {
           loose: !0
         })) {
-          editor.pendingInsertionMarks = marks2;
+          editor.pendingInsertionMarks = marks;
           return;
         }
       }
@@ -7706,9 +7538,9 @@ function requireReactDom() {
   return process.env.NODE_ENV === "production" ? (checkDCE(), reactDom.exports = requireReactDom_production()) : reactDom.exports = requireReactDom_development(), reactDom.exports;
 }
 var reactDomExports = requireReactDom(), ReactDOM = /* @__PURE__ */ getDefaultExportFromCjs(reactDomExports);
-const withReact = (editor, clipboardFormatKey = "x-slate-fragment") => {
+const withReact = (editor) => {
   let e = editor;
-  e = withDOM(e, clipboardFormatKey);
+  e = withDOM(e);
   const {
     onChange,
     apply: apply2,
@@ -7719,13 +7551,6 @@ const withReact = (editor, clipboardFormatKey = "x-slate-fragment") => {
       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 = {
@@ -10874,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({
@@ -10892,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;
@@ -10935,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;
           }
@@ -10985,11 +10789,11 @@ function createNormalizationPlugin(editorActor) {
         const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name);
         for (const [child, childPath] of Node$1.children(editor, path2, editor.schema))
           if (editor.isTextSpan(child)) {
-            const marks2 = child.marks ?? [], orphanedAnnotations = marks2.filter((mark) => !decorators.includes(mark) && !node2.markDefs?.find((def) => def._key === mark));
+            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !node2.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
               debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
                 applySetNode(editor, {
-                  marks: marks2.filter((mark) => !orphanedAnnotations.includes(mark))
+                  marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
                 }, childPath);
               });
               return;
@@ -10999,11 +10803,11 @@ function createNormalizationPlugin(editorActor) {
       if (editor.isTextSpan(node2)) {
         const blockPath = Path.parent(path2), [block] = Editor.node(editor, blockPath);
         if (editor.isTextBlock(block)) {
-          const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks2 = node2.marks ?? [], orphanedAnnotations = marks2.filter((mark) => !decorators.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node2.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
             debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
               applySetNode(editor, {
-                marks: marks2.filter((mark) => !orphanedAnnotations.includes(mark))
+                marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
               }, path2);
             });
             return;
@@ -11023,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, () => {
@@ -11071,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;
   };
@@ -12271,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) {
@@ -12343,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;
@@ -12494,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)
@@ -12599,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,
@@ -12633,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 marks2 = child.marks?.map((mark) => markDefKeyMap.get(mark) || mark) ?? [];
-            isEqualMarks(child.marks, marks2) || applySetNode(editor, {
-              marks: marks2
-            }, [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;
@@ -13069,10 +12657,10 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
     const startChild = getSelectionStartChild(effectiveSnapshot), startPoint = getSelectionStartPoint(effectiveSnapshot), endChild = getSelectionEndChild(effectiveSnapshot), endPoint = getSelectionEndPoint(effectiveSnapshot);
     if (!startChild || !endChild || !startPoint || !endPoint || startChild.path[2]._key !== endChild.path[2]._key || !isSpan(snapshot.context, startChild.node) || !(startPoint.offset === 0 && endPoint.offset === startChild.node.text.length))
       return !1;
-    const decorators = snapshot.context.schema.decorators.map((decorator) => decorator.name), marks2 = startChild.node.marks ?? [];
-    if (!marks2.some((mark) => !decorators.includes(mark)))
+    const decorators = snapshot.context.schema.decorators.map((decorator) => decorator.name), marks = startChild.node.marks ?? [];
+    if (!marks.some((mark) => !decorators.includes(mark)))
       return !1;
-    const previousSpan = getPreviousSpan(effectiveSnapshot), nextSpan = getNextSpan(effectiveSnapshot), previousSpanHasSameAnnotation = previousSpan ? previousSpan.node.marks?.some((mark) => !decorators.includes(mark) && marks2.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.node.marks?.some((mark) => !decorators.includes(mark) && marks2.includes(mark)) : !1;
+    const previousSpan = getPreviousSpan(effectiveSnapshot), nextSpan = getNextSpan(effectiveSnapshot), previousSpanHasSameAnnotation = previousSpan ? previousSpan.node.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.node.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
     if (previousSpanHasSameAnnotation || nextSpanHasSameAnnotation)
       return !1;
     const activeDecorators = getActiveDecorators(effectiveSnapshot);
@@ -14394,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);
@@ -14418,9 +13996,9 @@ const addAnnotationOperationImplementation = ({
     for (const [span, path2] of children) {
       if (!editor.isTextSpan(span) || !selectionRange || !Range.includes(selectionRange, path2))
         continue;
-      const marks2 = span.marks ?? [];
+      const marks = span.marks ?? [];
       applySetNode(editor, {
-        marks: [...marks2, annotationKey]
+        marks: [...marks, annotationKey]
       }, path2);
     }
     blockIndex++;
@@ -14485,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);
@@ -14514,8 +14082,8 @@ const addAnnotationOperationImplementation = ({
         for (const [child, childPath] of children) {
           if (!editor.isTextSpan(child) || !selectionRange || !Range.includes(selectionRange, childPath))
             continue;
-          const markDefs = block.markDefs ?? [], marks2 = child.marks ?? [], marksWithoutAnnotation = marks2.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== operation.annotation.name);
-          marksWithoutAnnotation.length !== marks2.length && applySetNode(editor, {
+          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== operation.annotation.name);
+          marksWithoutAnnotation.length !== marks.length && applySetNode(editor, {
             marks: marksWithoutAnnotation
           }, childPath);
         }
@@ -14738,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");
@@ -14762,9 +14320,9 @@ const addAnnotationOperationImplementation = ({
         match: (n2) => Text$1.isText(n2, editor.schema)
       });
       for (const [node2, path2] of splitTextNodes) {
-        const marks2 = [...(Array.isArray(node2.marks) ? node2.marks : []).filter((eMark) => eMark !== mark), mark];
+        const marks = [...(Array.isArray(node2.marks) ? node2.marks : []).filter((eMark) => eMark !== mark), mark];
         applySetNode(editor, {
-          marks: marks2
+          marks
         }, path2);
       }
     } else {
@@ -14816,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();
@@ -15448,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",
@@ -15544,12 +15082,12 @@ function insertBlock(options) {
       return markDef;
     }), adjustedChildren = block.children.map((child) => {
       if (isSpan(context, child)) {
-        const marks2 = child.marks?.map((mark) => markDefKeyMap.get(mark) || mark) ?? [];
-        if (!isEqualMarks(child.marks, marks2))
+        const marks = child.marks?.map((mark) => markDefKeyMap.get(mark) || mark) ?? [];
+        if (!isEqualMarks(child.marks, marks))
           return {
             ...child,
             _key: endBlockChildKeys.includes(child._key) ? context.keyGenerator() : child._key,
-            marks: marks2
+            marks
           };
       }
       return endBlockChildKeys.includes(child._key) ? {
@@ -15657,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 {
@@ -15675,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)) {
@@ -15688,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({
@@ -15840,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) {
@@ -15883,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);
@@ -15910,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);
@@ -16082,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
 }) => {