@portabletext/editor 6.2.0 → 6.3.0

package/lib/index.js

@@ -1,7 +1,7 @@
-import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
-import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, Fragment, useReducer, useCallback, useMemo, memo, forwardRef, Component, startTransition } from "react";
+import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, useReducer, useCallback, useMemo, memo, forwardRef, Component, startTransition } from "react";
 import rawDebug from "debug";
 import { createKeyboardShortcut, code, underline, italic as italic$1, bold as bold$1, undo as undo$1, redo as redo$1 } from "@portabletext/keyboard-shortcuts";
 import { getBlockEndPoint, getBlockStartPoint, getBlockKeyFromSelectionPoint, isSelectionCollapsed, isKeyedSegment, isEqualSelectionPoints, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, isListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject, isEqualPathSegments } from "./_chunks-es/util.slice-blocks.js";
@@ -44,10 +44,6 @@ const debug$1 = {
         return Path.isPath(value.path) && isObject(value.node);
       case "insert_text":
         return typeof value.offset == "number" && typeof value.text == "string" && Path.isPath(value.path);
-      case "merge_node":
-        return typeof value.position == "number" && Path.isPath(value.path) && isObject(value.properties);
-      case "move_node":
-        return Path.isPath(value.path) && Path.isPath(value.newPath);
       case "remove_node":
         return Path.isPath(value.path) && isObject(value.node);
       case "remove_text":
@@ -56,8 +52,6 @@ const debug$1 = {
         return Path.isPath(value.path) && isObject(value.properties) && isObject(value.newProperties);
       case "set_selection":
         return value.properties === null && Range.isRange(value.newProperties) || value.newProperties === null && Range.isRange(value.properties) || isObject(value.properties) && isObject(value.newProperties);
-      case "split_node":
-        return Path.isPath(value.path) && typeof value.position == "number" && isObject(value.properties);
       default:
         return !1;
     }
@@ -77,32 +71,6 @@ const debug$1 = {
           ...op,
           type: "remove_text"
         };
-      case "merge_node":
-        return {
-          ...op,
-          type: "split_node",
-          path: Path.previous(op.path)
-        };
-      case "move_node": {
-        const {
-          newPath,
-          path: path2
-        } = op;
-        if (Path.equals(newPath, path2))
-          return op;
-        if (Path.isSibling(path2, newPath))
-          return {
-            ...op,
-            path: newPath,
-            newPath: path2
-          };
-        const inversePath = Path.transform(path2, op), inverseNewPath = Path.transform(Path.next(path2), op);
-        return {
-          ...op,
-          path: inversePath,
-          newPath: inverseNewPath
-        };
-      }
       case "remove_node":
         return {
           ...op,
@@ -143,12 +111,6 @@ const debug$1 = {
           newProperties: properties
         };
       }
-      case "split_node":
-        return {
-          ...op,
-          type: "merge_node",
-          path: Path.next(op.path)
-        };
     }
   }
 }, Range = {
@@ -505,14 +467,11 @@ const debug$1 = {
 }, PathRef = {
   transform(ref, op) {
     const {
-      current,
-      affinity
+      current
     } = ref;
     if (current == null)
       return;
-    const path2 = Path.transform(current, op, {
-      affinity
-    });
+    const path2 = Path.transform(current, op);
     ref.current = path2, path2 == null && ref.unref();
   }
 }, Path = {
@@ -595,9 +554,6 @@ const debug$1 = {
     switch (operation.type) {
       case "insert_node":
       case "remove_node":
-      case "merge_node":
-      case "split_node":
-      case "move_node":
         return !0;
       default:
         return !1;
@@ -616,12 +572,10 @@ const debug$1 = {
       throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
     return path2.slice(0, -1).concat(last - 1);
   },
-  transform(path2, operation, options = {}) {
+  transform(path2, operation) {
     if (!path2)
       return null;
-    const p = [...path2], {
-      affinity = "forward"
-    } = options;
+    const p = [...path2];
     if (path2.length === 0)
       return p;
     switch (operation.type) {
@@ -641,40 +595,6 @@ const debug$1 = {
         Path.endsBefore(op, p) && (p[op.length - 1] = p[op.length - 1] - 1);
         break;
       }
-      case "merge_node": {
-        const {
-          path: op,
-          position
-        } = operation;
-        Path.equals(op, p) || Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] - 1 : Path.isAncestor(op, p) && (p[op.length - 1] = p[op.length - 1] - 1, p[op.length] = p[op.length] + position);
-        break;
-      }
-      case "split_node": {
-        const {
-          path: op,
-          position
-        } = operation;
-        if (Path.equals(op, p)) {
-          if (affinity === "forward")
-            p[p.length - 1] = p[p.length - 1] + 1;
-          else if (affinity !== "backward")
-            return null;
-        } else Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] + 1 : Path.isAncestor(op, p) && path2[op.length] >= position && (p[op.length - 1] = p[op.length - 1] + 1, p[op.length] = p[op.length] - position);
-        break;
-      }
-      case "move_node": {
-        const {
-          path: op,
-          newPath: onp
-        } = operation;
-        if (Path.equals(op, onp))
-          return p;
-        if (Path.isAncestor(op, p) || Path.equals(op, p)) {
-          const copy = onp.slice();
-          return Path.endsBefore(op, onp) && op.length < onp.length && (copy[op.length - 1] = copy[op.length - 1] - 1), copy.concat(p.slice(op.length));
-        } else Path.isSibling(op, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p)) ? Path.endsBefore(op, p) ? p[op.length - 1] = p[op.length - 1] - 1 : p[op.length - 1] = p[op.length - 1] + 1 : Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p) ? (Path.endsBefore(op, p) && (p[op.length - 1] = p[op.length - 1] - 1), p[onp.length - 1] = p[onp.length - 1] + 1) : Path.endsBefore(op, p) && (Path.equals(onp, p) && (p[onp.length - 1] = p[onp.length - 1] + 1), p[op.length - 1] = p[op.length - 1] - 1);
-        break;
-      }
     }
     return p;
   }
@@ -719,19 +639,14 @@ const debug$1 = {
       offset
     } = point2;
     switch (op.type) {
-      case "insert_node":
-      case "move_node": {
-        path2 = Path.transform(path2, op, options);
+      case "insert_node": {
+        path2 = Path.transform(path2, op);
         break;
       }
       case "insert_text": {
         Path.equals(op.path, path2) && (op.offset < offset || op.offset === offset && affinity === "forward") && (offset += op.text.length);
         break;
       }
-      case "merge_node": {
-        Path.equals(op.path, path2) && (offset += op.position), path2 = Path.transform(path2, op, options);
-        break;
-      }
       case "remove_text": {
         Path.equals(op.path, path2) && op.offset <= offset && (offset -= Math.min(offset - op.offset, op.text.length));
         break;
@@ -739,19 +654,7 @@ const debug$1 = {
       case "remove_node": {
         if (Path.equals(op.path, path2) || Path.isAncestor(op.path, path2))
           return null;
-        path2 = Path.transform(path2, op, options);
-        break;
-      }
-      case "split_node": {
-        if (Path.equals(op.path, path2)) {
-          if (op.position === offset && affinity == null)
-            return null;
-          (op.position < offset || op.position === offset && affinity === "forward") && (offset -= op.position, path2 = Path.transform(path2, op, {
-            ...options,
-            affinity: "forward"
-          }));
-        } else
-          path2 = Path.transform(path2, op, options);
+        path2 = Path.transform(path2, op);
         break;
       }
       default:
@@ -1413,38 +1316,38 @@ const apply$1 = (editor, op) => {
   } = editor;
   return selection ? Node$1.fragment(editor, selection, editor.schema) : [];
 };
-function applyMergeNode(editor, path2, position, properties) {
-  const node2 = Node$1.get(editor, path2, editor.schema), prevPath = Path.previous(path2), mergeOp = {
-    type: "merge_node",
-    path: path2,
-    position,
-    properties
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, mergeOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, mergeOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, mergeOp);
-  if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel)) {
-      const result = Point.transform(point2, mergeOp);
-      result && (sel[key] = result);
+function applyMergeNode(editor, path2, position) {
+  const node2 = Node$1.get(editor, path2, editor.schema), prevPath = Path.previous(path2);
+  for (const ref of Editor.pathRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPathForMerge(current, path2, position));
+  }
+  for (const ref of Editor.pointRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPointForMerge(current, path2, position));
+  }
+  for (const ref of Editor.rangeRefs(editor)) {
+    const current = ref.current;
+    if (current) {
+      const anchor = transformPointForMerge(current.anchor, path2, position), focus = transformPointForMerge(current.focus, path2, position);
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
     }
-    editor.selection = sel;
+  }
+  if (editor.selection) {
+    const anchor = transformPointForMerge(editor.selection.anchor, path2, position), focus = transformPointForMerge(editor.selection.focus, path2, position);
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
   }
   const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
   Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
   const savedSelection = editor.selection, editorAny = editor, savedPendingDiffs = editorAny.pendingDiffs, savedPendingSelection = editorAny.pendingSelection, savedPendingAction = editorAny.pendingAction;
-  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, mergeOp)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
-    const sel = savedPendingSelection, anchor = Point.transform(sel.anchor, mergeOp, {
-      affinity: "backward"
-    }), focus = Point.transform(sel.focus, mergeOp, {
-      affinity: "backward"
-    });
+  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, path2, position)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
+    const sel = savedPendingSelection, anchor = transformPointForMerge(sel.anchor, path2, position), focus = transformPointForMerge(sel.focus, path2, position);
     editorAny.pendingSelection = anchor && focus ? {
       anchor,
       focus
@@ -1452,20 +1355,14 @@ function applyMergeNode(editor, path2, position, properties) {
   }
   if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
     const action = savedPendingAction;
-    if (Point.isPoint(action.at)) {
-      const at = Point.transform(action.at, mergeOp, {
-        affinity: "backward"
-      });
+    if ("offset" in action.at && typeof action.at.offset == "number") {
+      const at = transformPointForMerge(action.at, path2, position);
       editorAny.pendingAction = at ? {
         ...action,
         at
       } : null;
     } else if (Range.isRange(action.at)) {
-      const anchor = Point.transform(action.at.anchor, mergeOp, {
-        affinity: "backward"
-      }), focus = Point.transform(action.at.focus, mergeOp, {
-        affinity: "backward"
-      });
+      const anchor = transformPointForMerge(action.at.anchor, path2, position), focus = transformPointForMerge(action.at.focus, path2, position);
       editorAny.pendingAction = anchor && focus ? {
         ...action,
         at: {
@@ -1516,14 +1413,14 @@ function applyMergeNode(editor, path2, position, properties) {
     editorAny.pendingDiffs = preTransformedPendingDiffs, editorAny.pendingSelection = preTransformedPendingSelection, editorAny.pendingAction = preTransformedPendingAction;
   }
 }
-function transformTextDiffForMerge(textDiff, op) {
+function transformTextDiffForMerge(textDiff, mergePath, position) {
   const {
     path: path2,
     diff: diff2,
     id
   } = textDiff;
-  if (!Path.equals(op.path, path2)) {
-    const newPath = Path.transform(path2, op);
+  if (!Path.equals(mergePath, path2)) {
+    const newPath = transformPathForMerge(path2, mergePath, position);
     return newPath ? {
       diff: diff2,
       id,
@@ -1532,12 +1429,26 @@ function transformTextDiffForMerge(textDiff, op) {
   }
   return {
     diff: {
-      start: diff2.start + op.position,
-      end: diff2.end + op.position,
+      start: diff2.start + position,
+      end: diff2.end + position,
       text: diff2.text
     },
     id,
-    path: Path.transform(path2, op)
+    path: transformPathForMerge(path2, mergePath, position)
+  };
+}
+function transformPathForMerge(path2, mergePath, position) {
+  const p = [...path2];
+  return Path.equals(mergePath, p) || Path.endsBefore(mergePath, p) ? p[mergePath.length - 1] = p[mergePath.length - 1] - 1 : Path.isAncestor(mergePath, p) && (p[mergePath.length - 1] = p[mergePath.length - 1] - 1, p[mergePath.length] = p[mergePath.length] + position), p;
+}
+function transformPointForMerge(point2, mergePath, position) {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return Path.equals(mergePath, path2) && (offset += position), path2 = transformPathForMerge(path2, mergePath, position), {
+    path: path2,
+    offset
   };
 }
 const normalizeNode = (editor, entry) => {
@@ -1572,11 +1483,8 @@ const normalizeNode = (editor, entry) => {
           else if (Text$1.equals(child, prev, {
             loose: !0
           })) {
-            const mergePath = path2.concat(n2), {
-              text: _text,
-              ...properties
-            } = child;
-            applyMergeNode(editor, mergePath, prev.text.length, properties), element = Node$1.get(editor, path2, editor.schema), n2--;
+            const mergePath = path2.concat(n2);
+            applyMergeNode(editor, mergePath, prev.text.length), element = Node$1.get(editor, path2, editor.schema), n2--;
           }
         }
       } else if (Element$2.isElement(child, editor.schema))
@@ -2175,26 +2083,44 @@ const previous = (editor, options = {}) => {
   }
   Editor.normalize(editor);
 }, shouldMergeNodesRemovePrevNode = (_editor, [prevNode, prevPath], [_curNode, _curNodePath]) => Element$2.isElement(prevNode, _editor.schema) && (prevNode.children.length === 0 || prevNode.children.length === 1 && Text$1.isText(prevNode.children[0], _editor.schema) && prevNode.children[0].text === "") || Text$1.isText(prevNode, _editor.schema) && prevNode.text === "" && prevPath[prevPath.length - 1] !== 0;
+function rangeRefAffinities(range2, affinity) {
+  if (affinity === "inward") {
+    const isCollapsed = Range.isCollapsed(range2);
+    if (Range.isForward(range2)) {
+      const anchorAffinity = "forward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "backward"];
+    } else {
+      const anchorAffinity = "backward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "forward"];
+    }
+  } else return affinity === "outward" ? Range.isForward(range2) ? ["backward", "forward"] : ["forward", "backward"] : [affinity, affinity];
+}
 function applySplitNode(editor, path2, position, properties) {
-  const node2 = Node$1.get(editor, path2, editor.schema), splitOp = {
-    type: "split_node",
-    path: path2,
-    position,
-    properties
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, splitOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, splitOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, splitOp);
+  const node2 = Node$1.get(editor, path2, editor.schema);
+  for (const ref of Editor.pathRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPathForSplit(current, path2, position, ref.affinity ?? "forward"));
+  }
+  for (const ref of Editor.pointRefs(editor)) {
+    const current = ref.current;
+    current && (ref.current = transformPointForSplit(current, path2, position, ref.affinity ?? "forward"));
+  }
+  for (const ref of Editor.rangeRefs(editor)) {
+    const current = ref.current;
+    if (current) {
+      const [anchorAffinity, focusAffinity] = rangeRefAffinities(current, ref.affinity), anchor = transformPointForSplit(current.anchor, path2, position, anchorAffinity ?? "forward"), focus = transformPointForSplit(current.focus, path2, position, focusAffinity ?? "forward");
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
+    }
+  }
   if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel))
-      sel[key] = Point.transform(point2, splitOp);
-    editor.selection = sel;
+    const anchor = transformPointForSplit(editor.selection.anchor, path2, position, "forward"), focus = transformPointForSplit(editor.selection.focus, path2, position, "forward");
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
   }
   const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
   Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
@@ -2244,6 +2170,20 @@ function applySplitNode(editor, path2, position, properties) {
       Editor.rangeRefs(editor).add(ref);
   }
 }
+function transformPathForSplit(path2, splitPath, position, affinity = "forward") {
+  const p = [...path2];
+  return Path.equals(splitPath, p) ? affinity === "forward" && (p[p.length - 1] = p[p.length - 1] + 1) : Path.endsBefore(splitPath, p) ? p[splitPath.length - 1] = p[splitPath.length - 1] + 1 : Path.isAncestor(splitPath, p) && path2[splitPath.length] >= position && (p[splitPath.length - 1] = p[splitPath.length - 1] + 1, p[splitPath.length] = p[splitPath.length] - position), p;
+}
+function transformPointForSplit(point2, splitPath, position, affinity = "forward") {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return Path.equals(splitPath, path2) ? (position < offset || position === offset && affinity === "forward") && (offset -= position, path2 = transformPathForSplit(path2, splitPath, position, "forward")) : path2 = transformPathForSplit(path2, splitPath, position, affinity), {
+    path: path2,
+    offset
+  };
+}
 const insertNodes = (editor, nodes2, options = {}) => {
   Editor.withoutNormalizing(editor, () => {
     const {
@@ -2486,55 +2426,6 @@ const insertNodes = (editor, nodes2, options = {}) => {
     });
   }
 };
-function applyMoveNode(editor, path2, newPath) {
-  if (Path.equals(path2, newPath))
-    return;
-  if (Path.isAncestor(path2, newPath))
-    throw new Error(`Cannot move a path [${path2}] to new path [${newPath}] because the destination is inside itself.`);
-  const node2 = Node$1.get(editor, path2, editor.schema), moveOp = {
-    type: "move_node",
-    path: path2,
-    newPath
-  };
-  for (const ref of Editor.pathRefs(editor))
-    PathRef.transform(ref, moveOp);
-  for (const ref of Editor.pointRefs(editor))
-    PointRef.transform(ref, moveOp);
-  for (const ref of Editor.rangeRefs(editor))
-    RangeRef.transform(ref, moveOp);
-  if (editor.selection) {
-    const sel = {
-      ...editor.selection
-    };
-    for (const [point2, key] of Range.points(sel))
-      sel[key] = Point.transform(point2, moveOp);
-    editor.selection = sel;
-  }
-  const pathRefs = new Set(Editor.pathRefs(editor)), pointRefs = new Set(Editor.pointRefs(editor)), rangeRefs = new Set(Editor.rangeRefs(editor));
-  Editor.pathRefs(editor).clear(), Editor.pointRefs(editor).clear(), Editor.rangeRefs(editor).clear();
-  const savedSelection = editor.selection;
-  try {
-    Editor.withoutNormalizing(editor, () => {
-      editor.apply({
-        type: "remove_node",
-        path: path2,
-        node: node2
-      }), editor.apply({
-        type: "insert_node",
-        path: newPath,
-        node: node2
-      });
-    });
-  } finally {
-    editor.selection = savedSelection;
-    for (const ref of pathRefs)
-      Editor.pathRefs(editor).add(ref);
-    for (const ref of pointRefs)
-      Editor.pointRefs(editor).add(ref);
-    for (const ref of rangeRefs)
-      Editor.rangeRefs(editor).add(ref);
-  }
-}
 function applySetNode(editor, props, path2) {
   const node2 = Node$1.get(editor, path2, editor.schema), propsRecord = props, properties = {}, newProperties = {};
   for (const key of Object.keys(propsRecord))
@@ -2698,22 +2589,26 @@ const deleteText = (editor, options = {}) => {
             mode: "highest",
             match: (n2) => levels2.includes(n2) && hasSingleChildNest(n2)
           }), emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);
-          let properties, position;
-          if (Text$1.isText(mergeNode, editor.schema) && Text$1.isText(prevNode, editor.schema)) {
-            const {
-              text: _text,
-              ...rest
-            } = mergeNode;
-            position = prevNode.text.length, properties = rest;
-          } else if (Element$2.isElement(mergeNode, editor.schema) && Element$2.isElement(prevNode, editor.schema)) {
-            const {
-              children: _children,
-              ...rest
-            } = mergeNode;
-            position = prevNode.children.length, properties = rest;
-          } else
+          let position;
+          if (Text$1.isText(mergeNode, editor.schema) && Text$1.isText(prevNode, editor.schema))
+            position = prevNode.text.length;
+          else if (Element$2.isElement(mergeNode, editor.schema) && Element$2.isElement(prevNode, editor.schema))
+            position = prevNode.children.length;
+          else
             throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${Scrubber.stringify(mergeNode)} ${Scrubber.stringify(prevNode)}`);
-          if (isPreviousSibling || applyMoveNode(editor, mergePath, newPath), emptyRef && Transforms.removeNodes(editor, {
+          if (!isPreviousSibling) {
+            const moveNode = Node$1.get(editor, mergePath, editor.schema);
+            editor.apply({
+              type: "remove_node",
+              path: mergePath,
+              node: moveNode
+            }), editor.apply({
+              type: "insert_node",
+              path: newPath,
+              node: moveNode
+            });
+          }
+          if (emptyRef && Transforms.removeNodes(editor, {
             at: emptyRef.current,
             voids
           }), Editor.shouldMergeNodesRemovePrevNode(editor, prev, current))
@@ -2729,7 +2624,7 @@ const deleteText = (editor, options = {}) => {
                 markDefs: newMarkDefs
               }, targetPath);
             }
-            applyMergeNode(pteEditor, newPath, position, properties);
+            applyMergeNode(pteEditor, newPath, position);
           }
           emptyRef && emptyRef.unref();
         }
@@ -3497,7 +3392,7 @@ function transformPendingPoint(editor, point2, op) {
   }, transformed = Point.transform(anchor, op, {
     affinity: "backward"
   });
-  return transformed ? op.type === "split_node" && Path.equals(op.path, point2.path) && anchor.offset < op.position && diff2.start < op.position ? transformed : {
+  return transformed ? {
     path: transformed.path,
     offset: transformed.offset + diff2.text.length - diff2.end + diff2.start
   } : null;
@@ -5200,480 +5095,6 @@ const MUTATION_OBSERVER_CONFIG$1 = {
   }));
   return useMutationObserver(node2, inputManager.handleDomMutations, MUTATION_OBSERVER_CONFIG$1), editor.scheduleFlush = inputManager.scheduleFlush, isMounted && inputManager.flush(), inputManager;
 } : () => null;
-class ChildrenHelper {
-  /**
-   * Sparse array of Slate node keys, each index corresponding to an index in
-   * the children array
-   *
-   * Fetching the key for a Slate node is expensive, so we cache them here.
-   */
-  /**
-   * The index of the next node to be read in the children array
-   */
-  constructor(editor, children) {
-    this.editor = editor, this.children = children, this.cachedKeys = new Array(children.length), this.pointerIndex = 0;
-  }
-  /**
-   * Read a given number of nodes, advancing the pointer by that amount
-   */
-  read(n2) {
-    if (n2 === 1)
-      return [this.children[this.pointerIndex++]];
-    const slicedChildren = this.remaining(n2);
-    return this.pointerIndex += n2, slicedChildren;
-  }
-  /**
-   * Get the remaining children without advancing the pointer
-   *
-   * @param [maxChildren] Limit the number of children returned.
-   */
-  remaining(maxChildren) {
-    return maxChildren === void 0 ? this.children.slice(this.pointerIndex) : this.children.slice(this.pointerIndex, this.pointerIndex + maxChildren);
-  }
-  /**
-   * Whether all children have been read
-   */
-  get reachedEnd() {
-    return this.pointerIndex >= this.children.length;
-  }
-  /**
-   * Determine whether a node with a given key appears in the unread part of the
-   * children array, and return its index relative to the current pointer if so
-   *
-   * Searching for the node object itself using indexOf is most efficient, but
-   * will fail to locate nodes that have been modified. In this case, nodes
-   * should be identified by their keys instead.
-   *
-   * Searching an array of keys using indexOf is very inefficient since fetching
-   * the keys for all children in advance is very slow. Insead, if the node
-   * search fails to return a value, fetch the keys of each remaining child one
-   * by one and compare it to the known key.
-   */
-  lookAhead(node2, key) {
-    const elementResult = this.children.indexOf(node2, this.pointerIndex);
-    if (elementResult > -1)
-      return elementResult - this.pointerIndex;
-    for (let i = this.pointerIndex; i < this.children.length; i++) {
-      const candidateNode = this.children[i];
-      if (this.findKey(candidateNode, i) === key)
-        return i - this.pointerIndex;
-    }
-    return -1;
-  }
-  /**
-   * Convert an array of Slate nodes to an array of chunk leaves, each
-   * containing the node and its key
-   */
-  toChunkLeaves(nodes2, startIndex) {
-    return nodes2.map((node2, i) => ({
-      type: "leaf",
-      node: node2,
-      key: this.findKey(node2, startIndex + i),
-      index: startIndex + i
-    }));
-  }
-  /**
-   * Get the key for a Slate node, cached using the node's index
-   */
-  findKey(node2, index) {
-    const cachedKey = this.cachedKeys[index];
-    if (cachedKey)
-      return cachedKey;
-    const key = ReactEditor.findKey(this.editor, node2);
-    return this.cachedKeys[index] = key, key;
-  }
-}
-class ChunkTreeHelper {
-  /**
-   * The root of the chunk tree
-   */
-  /**
-   * The ideal size of a chunk
-   */
-  /**
-   * Whether debug mode is enabled
-   *
-   * If enabled, the pointer state will be checked for internal consistency
-   * after each mutating operation.
-   */
-  /**
-   * Whether the traversal has reached the end of the chunk tree
-   *
-   * When this is true, the pointerChunk and pointerIndex point to the last
-   * top-level node in the chunk tree, although pointerNode returns null.
-   */
-  /**
-   * The chunk containing the current node
-   */
-  /**
-   * The index of the current node within pointerChunk
-   *
-   * Can be -1 to indicate that the pointer is before the start of the tree.
-   */
-  /**
-   * Similar to a Slate path; tracks the path of pointerChunk relative to the
-   * root.
-   *
-   * Used to move the pointer from the current chunk to the parent chunk more
-   * efficiently.
-   */
-  /**
-   * Indexing the current chunk's children has a slight time cost, which adds up
-   * when traversing very large trees, so the current node is cached.
-   *
-   * A value of undefined means that the current node is not cached. This
-   * property must be set to undefined whenever the pointer is moved, unless
-   * the pointer is guaranteed to point to the same node that it did previously.
-   */
-  constructor(chunkTree, {
-    chunkSize,
-    debug: debug2
-  }) {
-    this.root = chunkTree, this.chunkSize = chunkSize, this.debug = debug2 ?? !1, this.pointerChunk = chunkTree, this.pointerIndex = -1, this.pointerIndexStack = [], this.reachedEnd = !1, this.validateState();
-  }
-  /**
-   * Move the pointer to the next leaf in the chunk tree
-   */
-  readLeaf() {
-    if (this.reachedEnd)
-      return null;
-    for (; ; )
-      if (this.pointerIndex + 1 < this.pointerSiblings.length) {
-        this.pointerIndex++, this.cachedPointerNode = void 0;
-        break;
-      } else {
-        if (this.pointerChunk.type === "root")
-          return this.reachedEnd = !0, null;
-        this.exitChunk();
-      }
-    return this.validateState(), this.enterChunkUntilLeaf(!1), this.pointerNode;
-  }
-  /**
-   * Move the pointer to the previous leaf in the chunk tree
-   */
-  returnToPreviousLeaf() {
-    if (this.reachedEnd) {
-      this.reachedEnd = !1, this.enterChunkUntilLeaf(!0);
-      return;
-    }
-    for (; ; )
-      if (this.pointerIndex >= 1) {
-        this.pointerIndex--, this.cachedPointerNode = void 0;
-        break;
-      } else if (this.pointerChunk.type === "root") {
-        this.pointerIndex = -1;
-        return;
-      } else
-        this.exitChunk();
-    this.validateState(), this.enterChunkUntilLeaf(!0);
-  }
-  /**
-   * Insert leaves before the current leaf, leaving the pointer unchanged
-   */
-  insertBefore(leaves) {
-    this.returnToPreviousLeaf(), this.insertAfter(leaves), this.readLeaf();
-  }
-  /**
-   * Insert leaves after the current leaf, leaving the pointer on the last
-   * inserted leaf
-   *
-   * The insertion algorithm first checks for any chunk we're currently at the
-   * end of that can receive additional leaves. Next, it tries to insert leaves
-   * at the starts of any subsequent chunks.
-   *
-   * Any remaining leaves are passed to rawInsertAfter to be chunked and
-   * inserted at the highest possible level.
-   */
-  insertAfter(leaves) {
-    if (leaves.length === 0)
-      return;
-    let beforeDepth = 0, afterDepth = 0;
-    for (; this.pointerChunk.type === "chunk" && this.pointerIndex === this.pointerSiblings.length - 1; ) {
-      const remainingCapacity = this.chunkSize - this.pointerSiblings.length, toInsertCount = Math.min(remainingCapacity, leaves.length);
-      if (toInsertCount > 0) {
-        const leavesToInsert = leaves.splice(0, toInsertCount);
-        this.rawInsertAfter(leavesToInsert, beforeDepth);
-      }
-      this.exitChunk(), beforeDepth++;
-    }
-    if (leaves.length === 0)
-      return;
-    const rawInsertPointer = this.savePointer();
-    let finalPointer = null;
-    if (this.readLeaf())
-      for (; this.pointerChunk.type === "chunk" && this.pointerIndex === 0; ) {
-        const remainingCapacity = this.chunkSize - this.pointerSiblings.length, toInsertCount = Math.min(remainingCapacity, leaves.length);
-        if (toInsertCount > 0) {
-          const leavesToInsert = leaves.splice(-toInsertCount, toInsertCount);
-          this.pointerIndex = -1, this.cachedPointerNode = void 0, this.rawInsertAfter(leavesToInsert, afterDepth), finalPointer || (finalPointer = this.savePointer());
-        }
-        this.exitChunk(), afterDepth++;
-      }
-    this.restorePointer(rawInsertPointer);
-    const minDepth = Math.max(beforeDepth, afterDepth);
-    this.rawInsertAfter(leaves, minDepth), finalPointer && this.restorePointer(finalPointer), this.validateState();
-  }
-  /**
-   * Remove the current node and decrement the pointer, deleting any ancestor
-   * chunk that becomes empty as a result
-   */
-  remove() {
-    this.pointerSiblings.splice(this.pointerIndex--, 1), this.cachedPointerNode = void 0, this.pointerSiblings.length === 0 && this.pointerChunk.type === "chunk" ? (this.exitChunk(), this.remove()) : this.invalidateChunk(), this.validateState();
-  }
-  /**
-   * Add the current chunk and all ancestor chunks to the list of modified
-   * chunks
-   */
-  invalidateChunk() {
-    for (let c2 = this.pointerChunk; c2.type === "chunk"; c2 = c2.parent)
-      this.root.modifiedChunks.add(c2);
-  }
-  /**
-   * Whether the pointer is at the start of the tree
-   */
-  get atStart() {
-    return this.pointerChunk.type === "root" && this.pointerIndex === -1;
-  }
-  /**
-   * The siblings of the current node
-   */
-  get pointerSiblings() {
-    return this.pointerChunk.children;
-  }
-  /**
-   * Get the current node (uncached)
-   *
-   * If the pointer is at the start or end of the document, returns null.
-   *
-   * Usually, the current node is a chunk leaf, although it can be a chunk
-   * while insertions are in progress.
-   */
-  getPointerNode() {
-    return this.reachedEnd || this.pointerIndex === -1 ? null : this.pointerSiblings[this.pointerIndex] ?? null;
-  }
-  /**
-   * Cached getter for the current node
-   */
-  get pointerNode() {
-    if (this.cachedPointerNode !== void 0)
-      return this.cachedPointerNode;
-    const pointerNode = this.getPointerNode();
-    return this.cachedPointerNode = pointerNode, pointerNode;
-  }
-  /**
-   * Get the path of a chunk relative to the root, returning null if the chunk
-   * is not connected to the root
-   */
-  getChunkPath(chunk) {
-    const path2 = [];
-    for (let c2 = chunk; c2.type === "chunk"; c2 = c2.parent) {
-      const index = c2.parent.children.indexOf(c2);
-      if (index === -1)
-        return null;
-      path2.unshift(index);
-    }
-    return path2;
-  }
-  /**
-   * Save the current pointer to be restored later
-   */
-  savePointer() {
-    if (this.atStart)
-      return "start";
-    if (!this.pointerNode)
-      throw new Error("Cannot save pointer when pointerNode is null");
-    return {
-      chunk: this.pointerChunk,
-      node: this.pointerNode
-    };
-  }
-  /**
-   * Restore the pointer to a previous state
-   */
-  restorePointer(savedPointer) {
-    if (savedPointer === "start") {
-      this.pointerChunk = this.root, this.pointerIndex = -1, this.pointerIndexStack = [], this.reachedEnd = !1, this.cachedPointerNode = void 0;
-      return;
-    }
-    const {
-      chunk,
-      node: node2
-    } = savedPointer, index = chunk.children.indexOf(node2);
-    if (index === -1)
-      throw new Error("Cannot restore point because saved node is no longer in saved chunk");
-    const indexStack = this.getChunkPath(chunk);
-    if (!indexStack)
-      throw new Error("Cannot restore point because saved chunk is no longer connected to root");
-    this.pointerChunk = chunk, this.pointerIndex = index, this.pointerIndexStack = indexStack, this.reachedEnd = !1, this.cachedPointerNode = node2, this.validateState();
-  }
-  /**
-   * Assuming the current node is a chunk, move the pointer into that chunk
-   *
-   * @param end If true, place the pointer on the last node of the chunk.
-   * Otherwise, place the pointer on the first node.
-   */
-  enterChunk(end2) {
-    if (this.pointerNode?.type !== "chunk")
-      throw new Error("Cannot enter non-chunk");
-    if (this.pointerIndexStack.push(this.pointerIndex), this.pointerChunk = this.pointerNode, this.pointerIndex = end2 ? this.pointerSiblings.length - 1 : 0, this.cachedPointerNode = void 0, this.validateState(), this.pointerChunk.children.length === 0)
-      throw new Error("Cannot enter empty chunk");
-  }
-  /**
-   * Assuming the current node is a chunk, move the pointer into that chunk
-   * repeatedly until the current node is a leaf
-   *
-   * @param end If true, place the pointer on the last node of the chunk.
-   * Otherwise, place the pointer on the first node.
-   */
-  enterChunkUntilLeaf(end2) {
-    for (; this.pointerNode?.type === "chunk"; )
-      this.enterChunk(end2);
-  }
-  /**
-   * Move the pointer to the parent chunk
-   */
-  exitChunk() {
-    if (this.pointerChunk.type === "root")
-      throw new Error("Cannot exit root");
-    const previousPointerChunk = this.pointerChunk;
-    this.pointerChunk = previousPointerChunk.parent, this.pointerIndex = this.pointerIndexStack.pop(), this.cachedPointerNode = void 0, this.validateState();
-  }
-  /**
-   * Insert leaves immediately after the current node, leaving the pointer on
-   * the last inserted leaf
-   *
-   * Leaves are chunked according to the number of nodes already in the parent
-   * plus the number of nodes being inserted, or the minimum depth if larger
-   */
-  rawInsertAfter(leaves, minDepth) {
-    if (leaves.length === 0)
-      return;
-    const groupIntoChunks = (leaves2, parent2, perChunk) => {
-      if (perChunk === 1)
-        return leaves2;
-      const chunks2 = [];
-      for (let i = 0; i < this.chunkSize; i++) {
-        const chunkNodes = leaves2.slice(i * perChunk, (i + 1) * perChunk);
-        if (chunkNodes.length === 0)
-          break;
-        const chunk = {
-          type: "chunk",
-          key: new Key(),
-          parent: parent2,
-          children: []
-        };
-        chunk.children = groupIntoChunks(chunkNodes, chunk, perChunk / this.chunkSize), chunks2.push(chunk);
-      }
-      return chunks2;
-    }, newTotal = this.pointerSiblings.length + leaves.length;
-    let depthForTotal = 0;
-    for (let i = this.chunkSize; i < newTotal; i *= this.chunkSize)
-      depthForTotal++;
-    const depth = Math.max(depthForTotal, minDepth), perTopLevelChunk = this.chunkSize ** depth, chunks = groupIntoChunks(leaves, this.pointerChunk, perTopLevelChunk);
-    this.pointerSiblings.splice(this.pointerIndex + 1, 0, ...chunks), this.pointerIndex += chunks.length, this.cachedPointerNode = void 0, this.invalidateChunk(), this.validateState();
-  }
-  /**
-   * If debug mode is enabled, ensure that the state is internally consistent
-   */
-  // istanbul ignore next
-  validateState() {
-    if (!this.debug)
-      return;
-    const validateDescendant = (node2) => {
-      if (node2.type === "chunk") {
-        const {
-          parent: parent2,
-          children
-        } = node2;
-        if (!parent2.children.includes(node2))
-          throw new Error(`Debug: Chunk ${node2.key.id} has an incorrect parent property`);
-        children.forEach(validateDescendant);
-      }
-    };
-    if (this.root.children.forEach(validateDescendant), this.cachedPointerNode !== void 0 && this.cachedPointerNode !== this.getPointerNode())
-      throw new Error("Debug: The cached pointer is incorrect and has not been invalidated");
-    const actualIndexStack = this.getChunkPath(this.pointerChunk);
-    if (!actualIndexStack)
-      throw new Error("Debug: The pointer chunk is not connected to the root");
-    if (!Path.equals(this.pointerIndexStack, actualIndexStack))
-      throw new Error(`Debug: The cached index stack [${this.pointerIndexStack.join(", ")}] does not match the path of the pointer chunk [${actualIndexStack.join(", ")}]`);
-  }
-}
-const reconcileChildren = (editor, {
-  chunkTree,
-  children,
-  chunkSize,
-  rerenderChildren = [],
-  onInsert,
-  onUpdate,
-  onIndexChange,
-  debug: debug2
-}) => {
-  chunkTree.modifiedChunks.clear();
-  const chunkTreeHelper = new ChunkTreeHelper(chunkTree, {
-    chunkSize,
-    debug: debug2
-  }), childrenHelper = new ChildrenHelper(editor, children);
-  let treeLeaf;
-  for (; treeLeaf = chunkTreeHelper.readLeaf(); ) {
-    const lookAhead = childrenHelper.lookAhead(treeLeaf.node, treeLeaf.key);
-    if (lookAhead === -1) {
-      chunkTreeHelper.remove();
-      continue;
-    }
-    const insertedChildrenStartIndex = childrenHelper.pointerIndex, insertedChildren = childrenHelper.read(lookAhead + 1), matchingChild = insertedChildren.pop();
-    if (insertedChildren.length) {
-      const leavesToInsert = childrenHelper.toChunkLeaves(insertedChildren, insertedChildrenStartIndex);
-      chunkTreeHelper.insertBefore(leavesToInsert), insertedChildren.forEach((node2, relativeIndex) => {
-        onInsert?.(node2, insertedChildrenStartIndex + relativeIndex);
-      });
-    }
-    const matchingChildIndex = childrenHelper.pointerIndex - 1;
-    treeLeaf.node !== matchingChild && (treeLeaf.node = matchingChild, chunkTreeHelper.invalidateChunk(), onUpdate?.(matchingChild, matchingChildIndex)), treeLeaf.index !== matchingChildIndex && (treeLeaf.index = matchingChildIndex, onIndexChange?.(matchingChild, matchingChildIndex)), rerenderChildren.includes(matchingChildIndex) && chunkTreeHelper.invalidateChunk();
-  }
-  if (!childrenHelper.reachedEnd) {
-    const remainingChildren = childrenHelper.remaining(), leavesToInsert = childrenHelper.toChunkLeaves(remainingChildren, childrenHelper.pointerIndex);
-    chunkTreeHelper.returnToPreviousLeaf(), chunkTreeHelper.insertAfter(leavesToInsert), remainingChildren.forEach((node2, relativeIndex) => {
-      onInsert?.(node2, childrenHelper.pointerIndex + relativeIndex);
-    });
-  }
-}, getChunkTreeForNode = (editor, node2, options = {}) => {
-  const key = ReactEditor.findKey(editor, node2);
-  let chunkTree = editor.keyToChunkTree.get(key);
-  return chunkTree || (chunkTree = {
-    type: "root",
-    modifiedChunks: /* @__PURE__ */ new Set(),
-    children: []
-  }, editor.keyToChunkTree.set(key, chunkTree)), options.reconcile && reconcileChildren(editor, {
-    chunkTree,
-    children: node2.children,
-    ...options.reconcile
-  }), chunkTree;
-}, defaultRenderChunk = ({
-  children
-}) => children, ChunkAncestor = (props) => {
-  const {
-    root,
-    ancestor,
-    renderElement,
-    renderChunk = defaultRenderChunk
-  } = props;
-  return ancestor.children.map((chunkNode) => {
-    if (chunkNode.type === "chunk") {
-      const key = chunkNode.key.id, renderedChunk = renderChunk({
-        highest: ancestor === root,
-        lowest: chunkNode.children.some((c2) => c2.type === "leaf"),
-        attributes: {
-          "data-slate-chunk": !0
-        },
-        children: /* @__PURE__ */ jsx(MemoizedChunk, { root, ancestor: chunkNode, renderElement, renderChunk })
-      });
-      return /* @__PURE__ */ jsx(Fragment, { children: renderedChunk }, key);
-    }
-    const element = chunkNode.node;
-    return renderElement(element, chunkNode.index, chunkNode.key);
-  });
-}, ChunkTree = ChunkAncestor, MemoizedChunk = React.memo(ChunkAncestor, (prev, next2) => prev.root === next2.root && prev.renderElement === next2.renderElement && prev.renderChunk === next2.renderChunk && !next2.root.modifiedChunks.has(next2.ancestor));
 function useGenericSelector(selector, equalityFn) {
   const [, forceRender] = useReducer((s) => s + 1, 0), latestSubscriptionCallbackError = useRef(void 0), latestSelector = useRef(() => null), latestSelectedState = useRef(null);
   let selectedState;
@@ -5743,7 +5164,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations: parentDecorations,
     element,
     renderElement = defaultRenderElement$1,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5753,7 +5173,6 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     decorations,
     node: element,
     renderElement,
-    renderChunk,
     renderPlaceholder,
     renderLeaf,
     renderText
@@ -5770,7 +5189,7 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     children,
     element
   });
-}, MemoizedElement = React.memo(Element$1, (prev, next2) => prev.element === next2.element && prev.renderElement === next2.renderElement && prev.renderChunk === next2.renderChunk && prev.renderText === next2.renderText && prev.renderLeaf === next2.renderLeaf && prev.renderPlaceholder === next2.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next2.decorations)), DefaultElement = (props) => {
+}, MemoizedElement = React.memo(Element$1, (prev, next2) => prev.element === next2.element && prev.renderElement === next2.renderElement && prev.renderText === next2.renderText && prev.renderLeaf === next2.renderLeaf && prev.renderPlaceholder === next2.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next2.decorations)), DefaultElement = (props) => {
   const {
     attributes,
     children,
@@ -5966,58 +5385,34 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
     decorations,
     node: node2,
     renderElement,
-    renderChunk,
     renderPlaceholder,
     renderText,
     renderLeaf
   } = props, editor = useSlateStatic();
   editor.isNodeMapDirty = !1;
-  const isEditor2 = Editor.isEditor(node2), chunkSize = !isEditor2 && Element$2.isElement(node2, editor.schema) && !editor.isInline(node2) && Editor.hasInlines(editor, node2) ? null : editor.getChunkSize(node2), chunking = !!chunkSize, {
-    decorationsByChild,
-    childrenToRedecorate
-  } = useDecorationsByChild(editor, node2, decorations);
-  chunking || node2.children.forEach((n2, i) => {
+  const isEditor2 = Editor.isEditor(node2), decorationsByChild = useDecorationsByChild(editor, node2, decorations);
+  node2.children.forEach((n2, i) => {
     editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
   });
   const renderElementComponent = useCallback((n2, i, cachedKey) => {
     const key = cachedKey ?? ReactEditor.findKey(editor, n2);
-    return /* @__PURE__ */ jsx(ElementContext.Provider, { value: n2, children: /* @__PURE__ */ jsx(MemoizedElement, { decorations: decorationsByChild[i] ?? [], element: n2, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText }, key.id) }, `provider-${key.id}`);
-  }, [editor, decorationsByChild, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText]), renderTextComponent = (n2, i) => {
+    return /* @__PURE__ */ jsx(ElementContext.Provider, { value: n2, children: /* @__PURE__ */ jsx(MemoizedElement, { decorations: decorationsByChild[i] ?? [], element: n2, renderElement, renderPlaceholder, renderLeaf, renderText }, key.id) }, `provider-${key.id}`);
+  }, [editor, decorationsByChild, renderElement, renderPlaceholder, renderLeaf, renderText]), renderTextComponent = (n2, i) => {
     const key = ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(MemoizedText, { decorations: decorationsByChild[i] ?? [], isLast: i === node2.children.length - 1, parent: node2, renderPlaceholder, renderLeaf, renderText, text: n2 }, key.id);
   }, renderObjectNodeComponent = (n2, i) => {
     const key = ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(MemoizedObjectNode, { decorations: decorationsByChild[i] ?? [], isInline: !isEditor2, objectNode: n2, renderElement }, key.id);
   };
-  if (!chunking)
-    return node2.children.map((n2, i) => Element$2.isElement(n2, editor.schema) ? renderElementComponent(n2, i) : Node$1.isObjectNode(n2, editor.schema) ? renderObjectNodeComponent(n2, i) : renderTextComponent(n2, i));
-  const chunkTree = getChunkTreeForNode(editor, node2, {
-    reconcile: {
-      chunkSize,
-      rerenderChildren: childrenToRedecorate,
-      onInsert: (n2, i) => {
-        editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
-      },
-      onUpdate: (n2, i) => {
-        editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
-      },
-      onIndexChange: (n2, i) => {
-        editor.nodeToIndex.set(n2, i);
-      }
-    }
-  });
-  return /* @__PURE__ */ jsx(ChunkTree, { root: chunkTree, ancestor: chunkTree, renderElement: renderElementComponent, renderChunk });
+  return node2.children.map((n2, i) => Element$2.isElement(n2, editor.schema) ? renderElementComponent(n2, i) : Node$1.isObjectNode(n2, editor.schema) ? renderObjectNodeComponent(n2, i) : renderTextComponent(n2, i));
 }, useDecorationsByChild = (editor, node2, decorations) => {
-  const decorationsByChild = splitDecorationsByChild(editor, node2, decorations), mutableDecorationsByChild = useRef(decorationsByChild).current, childrenToRedecorate = [];
+  const decorationsByChild = splitDecorationsByChild(editor, node2, decorations), mutableDecorationsByChild = useRef(decorationsByChild).current;
   mutableDecorationsByChild.length = decorationsByChild.length;
   for (let i = 0; i < decorationsByChild.length; i++) {
     const decorations2 = decorationsByChild[i], previousDecorations = mutableDecorationsByChild[i] ?? null;
-    isElementDecorationsEqual(previousDecorations, decorations2) || (mutableDecorationsByChild[i] = decorations2, childrenToRedecorate.push(i));
+    isElementDecorationsEqual(previousDecorations, decorations2) || (mutableDecorationsByChild[i] = decorations2);
   }
-  return {
-    decorationsByChild: mutableDecorationsByChild,
-    childrenToRedecorate
-  };
+  return mutableDecorationsByChild;
 }, ComposingContext = createContext(!1), ReadOnlyContext = createContext(!1), useReadOnly = () => useContext(ReadOnlyContext), SlateSelectorContext = createContext({}), refEquality = (a, b) => a === b;
 function useSlateSelector(selector, equalityFn = refEquality, {
   deferred
@@ -6197,7 +5592,7 @@ class RestoreDOMComponent extends Component {
 }
 const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
   children
-}) => /* @__PURE__ */ jsx(Fragment$1, { children }), Children = (props) => /* @__PURE__ */ jsx(React.Fragment, { children: useChildren(props) }), Editable = forwardRef((props, forwardedRef) => {
+}) => /* @__PURE__ */ jsx(Fragment, { children }), Children = (props) => /* @__PURE__ */ jsx(React.Fragment, { children: useChildren(props) }), Editable = forwardRef((props, forwardedRef) => {
   const defaultRenderPlaceholder = useCallback((props2) => /* @__PURE__ */ jsx(DefaultPlaceholder, { ...props2 }), []), {
     autoFocus,
     decorate = defaultDecorate,
@@ -6206,7 +5601,6 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     placeholder,
     readOnly = !1,
     renderElement,
-    renderChunk,
     renderLeaf,
     renderText,
     renderPlaceholder = defaultRenderPlaceholder,
@@ -7147,7 +6541,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           editor
         }));
       }, [readOnly, editor, editorActor, attributes.onPaste]),
-      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, renderElement, renderChunk, renderPlaceholder, renderLeaf, renderText })
+      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, renderElement, renderPlaceholder, renderLeaf, renderText })
     }
   ) }) }) }) });
 }), DefaultPlaceholder = ({
@@ -7546,7 +6940,7 @@ const withReact = (editor) => {
     apply: apply2,
     insertText: insertText2
   } = e;
-  return e.getChunkSize = () => null, e.keyToChunkTree = /* @__PURE__ */ new WeakMap(), IS_ANDROID && (e.insertText = (text, options) => (e.pendingSelection = null, insertText2(text, options))), e.onChange = (options) => {
+  return IS_ANDROID && (e.insertText = (text, options) => (e.pendingSelection = null, insertText2(text, options))), e.onChange = (options) => {
     (REACT_MAJOR_VERSION < 18 ? ReactDOM.unstable_batchedUpdates : (callback) => callback())(() => {
       onChange(options);
     });
@@ -8769,7 +8163,7 @@ function RenderLeaf(props) {
     let t2;
     $[4] !== t1 ? (t2 = /* @__PURE__ */ jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: t1 }), $[4] = t1, $[5] = t2) : t2 = $[5];
     let t3;
-    return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+    return $[6] !== renderedSpan || $[7] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Fragment, { children: [
       t2,
       renderedSpan
     ] }), $[6] = renderedSpan, $[7] = t2, $[8] = t3) : t3 = $[8], t3;
@@ -10674,21 +10068,18 @@ function createHistoryPlugin({
     }, editor;
   };
 }
-function applyInsertNodeAtPath(editor, node2, path2, options = {}) {
-  if (editor.apply({
+function applyInsertNodeAtPath(editor, node2, path2) {
+  editor.apply({
     type: "insert_node",
     path: path2,
     node: node2
-  }), options.select) {
-    const point2 = Editor.end(editor, path2);
-    point2 && applySelect(editor, point2);
-  }
+  });
+  const point2 = Editor.end(editor, path2);
+  point2 && applySelect(editor, point2);
 }
-function applyInsertNodeAtPoint(editor, node2, at, options = {}) {
+function applyInsertNodeAtPoint(editor, node2, at) {
   Editor.withoutNormalizing(editor, () => {
-    let match2;
-    Text$1.isText(node2, editor.schema) ? match2 = (n2) => Text$1.isText(n2, editor.schema) : Element$2.isElement(node2, editor.schema) && editor.isInline(node2) ? match2 = (n2) => Text$1.isText(n2, editor.schema) || Element$2.isElement(n2, editor.schema) && Editor.isInline(editor, n2) : editor.isObjectNode(node2) ? match2 = (n2) => Text$1.isText(n2, editor.schema) || editor.isObjectNode(n2) || Element$2.isElement(n2, editor.schema) && Editor.isInline(editor, n2) : match2 = (n2) => Element$2.isElement(n2, editor.schema) && Editor.isBlock(editor, n2) || editor.isObjectNode(n2);
-    const [entry] = Editor.nodes(editor, {
+    const match2 = Text$1.isText(node2, editor.schema) ? (n2) => Text$1.isText(n2, editor.schema) : (n2) => Text$1.isText(n2, editor.schema) || editor.isObjectNode(n2), [entry] = Editor.nodes(editor, {
       at: at.path,
       match: match2,
       mode: "lowest",
@@ -10702,14 +10093,13 @@ function applyInsertNodeAtPoint(editor, node2, at, options = {}) {
       applySplitNode(editor, at.path, at.offset, properties);
     }
     const path2 = pathRef2.unref(), insertPath = isAtEnd ? Path.next(path2) : path2;
-    if (editor.apply({
+    editor.apply({
       type: "insert_node",
       path: insertPath,
       node: node2
-    }), options.select) {
-      const point2 = Editor.end(editor, insertPath);
-      point2 && applySelect(editor, point2);
-    }
+    });
+    const point2 = Editor.end(editor, insertPath);
+    point2 && applySelect(editor, point2);
   });
 }
 function withNormalizeNode(editor, fn) {
@@ -10730,9 +10120,7 @@ function createNormalizationPlugin(editorActor) {
       const [node2, path2] = nodeEntry;
       if (Editor.isEditor(node2) && node2.children.length === 0 && withoutPatching(editor, () => {
         withNormalizeNode(editor, () => {
-          applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0], {
-            select: !0
-          });
+          applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0]);
         });
       }), editor.isTextBlock(node2)) {
         const children = Node$1.children(editor, path2, editor.schema);
@@ -10740,11 +10128,8 @@ function createNormalizationPlugin(editorActor) {
           const nextNode = node2.children[childPath[1] + 1];
           if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
             debug$1.normalization("merging spans with same marks"), withNormalizeNode(editor, () => {
-              const mergePath = [childPath[0], childPath[1] + 1], {
-                text: _text,
-                ...properties
-              } = nextNode;
-              applyMergeNode(editor, mergePath, child.text.length, properties);
+              const mergePath = [childPath[0], childPath[1] + 1];
+              applyMergeNode(editor, mergePath, child.text.length);
             });
             return;
           }
@@ -15358,13 +14743,7 @@ function deleteSameBlockRange(editor, start2, end2) {
     });
   }
   const startNodeAfter = Node$1.get(editor, start2.path, editor.schema), endNodeAfter = Node$1.get(editor, newEndPath, editor.schema);
-  if (Text$1.isText(startNodeAfter, editor.schema) && Text$1.isText(endNodeAfter, editor.schema)) {
-    const {
-      text: _,
-      ...properties
-    } = endNodeAfter;
-    applyMergeNode(editor, newEndPath, startNodeAfter.text.length, properties);
-  }
+  Text$1.isText(startNodeAfter, editor.schema) && Text$1.isText(endNodeAfter, editor.schema) && applyMergeNode(editor, newEndPath, startNodeAfter.text.length);
 }
 function deleteCrossBlockRange(editor, start2, end2) {
   const startBlockPath = [start2.path[0]];
@@ -15408,11 +14787,7 @@ function deleteCrossBlockRange(editor, start2, end2) {
         markDefs: newMarkDefs
       }, startBlockPath);
     }
-    const {
-      children: _,
-      ...properties
-    } = endBlock;
-    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length, properties);
+    applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length);
   });
 }
 function deleteExpandedRange(editor, range2) {
@@ -15472,11 +14847,7 @@ const insertChildOperationImplementation = ({
     const [focusSpan] = getFocusSpan({
       editor: operation.editor
     });
-    focusSpan ? applyInsertNodeAtPoint(operation.editor, span, focus, {
-      select: !0
-    }) : applyInsertNodeAtPath(operation.editor, span, [focusBlockIndex, focusChildIndex + 1], {
-      select: !0
-    }), operation.editor.pendingSelection = operation.editor.selection;
+    focusSpan ? applyInsertNodeAtPoint(operation.editor, span, focus) : applyInsertNodeAtPath(operation.editor, span, [focusBlockIndex, focusChildIndex + 1]), operation.editor.pendingSelection = operation.editor.selection;
     return;
   }
   const inlineObject = parseInlineObject({
@@ -15498,11 +14869,7 @@ const insertChildOperationImplementation = ({
     }, [focusSpan] = getFocusSpan({
       editor: operation.editor
     });
-    focusSpan ? applyInsertNodeAtPoint(operation.editor, inlineNode, focus, {
-      select: !0
-    }) : applyInsertNodeAtPath(operation.editor, inlineNode, [focusBlockIndex, focusChildIndex + 1], {
-      select: !0
-    });
+    focusSpan ? applyInsertNodeAtPoint(operation.editor, inlineNode, focus) : applyInsertNodeAtPath(operation.editor, inlineNode, [focusBlockIndex, focusChildIndex + 1]);
     return;
   }
   throw new Error("Unable to parse child");
@@ -15596,7 +14963,34 @@ const moveBackwardOperationImplementation = ({
   const destinationBlockIndex = operation.editor.blockIndexMap.get(destinationKey);
   if (destinationBlockIndex === void 0)
     throw new Error("Failed to get block index from block key");
-  applyMoveNode(operation.editor, [originBlockIndex], [destinationBlockIndex]);
+  const editor = operation.editor, node2 = Node$1.get(editor, [originBlockIndex], editor.schema), savedSelection = editor.selection ? {
+    anchor: {
+      ...editor.selection.anchor
+    },
+    focus: {
+      ...editor.selection.focus
+    }
+  } : null;
+  if (Editor.withoutNormalizing(editor, () => {
+    editor.apply({
+      type: "remove_node",
+      path: [originBlockIndex],
+      node: node2
+    }), editor.apply({
+      type: "insert_node",
+      path: [destinationBlockIndex],
+      node: node2
+    });
+  }), savedSelection) {
+    const fixPoint = (point2) => point2.path[0] === originBlockIndex ? {
+      ...point2,
+      path: [destinationBlockIndex, ...point2.path.slice(1)]
+    } : point2;
+    editor.selection = {
+      anchor: fixPoint(savedSelection.anchor),
+      focus: fixPoint(savedSelection.focus)
+    };
+  }
 }, moveForwardOperationImplementation = ({
   operation
 }) => {