@portabletext/editor 4.2.1 → 4.2.2

package/lib/index.js

@@ -3491,7 +3491,7 @@ function createBehaviorApiPlugin(editorActor) {
       delete: editorDelete,
       insertNodes,
       select,
-      setSelection
+      setSelection: setSelection2
     } = editor;
     return editor.delete = (options) => {
       if (editor.isNormalizingNode || editor.isPerformingBehaviorOperation) {
@@ -3645,7 +3645,7 @@ function createBehaviorApiPlugin(editorActor) {
       });
     }, editor.setSelection = (partialRange) => {
       if (editor.isNormalizingNode || editor.isPerformingBehaviorOperation) {
-        setSelection(partialRange);
+        setSelection2(partialRange);
         return;
       }
       const anchor = partialRange.anchor ? slatePointToSelectionPoint({
@@ -3666,12 +3666,12 @@ function createBehaviorApiPlugin(editorActor) {
       if (editor.selection) {
         const newAnchor = partialRange.anchor ?? editor.selection.anchor, newFocus = partialRange.focus ?? editor.selection.focus;
         if (Point.equals(newAnchor, editor.selection.anchor) && Point.equals(newFocus, editor.selection.focus)) {
-          setSelection(partialRange);
+          setSelection2(partialRange);
           return;
         }
       }
       if (!anchor || !focus) {
-        setSelection(partialRange);
+        setSelection2(partialRange);
         return;
       }
       editorActor.send({
@@ -6271,25 +6271,44 @@ const abstractAnnotationBehaviors = [defineBehavior({
   guard: ({
     snapshot,
     event
-  }) => isActiveDecorator(event.decorator)(snapshot),
+  }) => {
+    const at = event.at ?? snapshot.context.selection;
+    if (!at)
+      return !1;
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: at
+      }
+    };
+    return isActiveDecorator(event.decorator)(adjustedSnapshot);
+  },
   actions: [({
     event
   }) => [raise({
     type: "decorator.remove",
-    decorator: event.decorator
+    decorator: event.decorator,
+    at: event.at
   })]]
 }), defineBehavior({
   on: "decorator.toggle",
   guard: ({
     snapshot,
     event
-  }) => event.at ? !isActiveDecorator(event.decorator)({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: event.at
-    }
-  }) : !isActiveDecorator(event.decorator)(snapshot),
+  }) => {
+    const at = event.at ?? snapshot.context.selection;
+    if (!at)
+      return !1;
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: at
+      }
+    };
+    return !isActiveDecorator(event.decorator)(adjustedSnapshot);
+  },
   actions: [({
     event
   }) => [raise({
@@ -6316,8 +6335,17 @@ const abstractAnnotationBehaviors = [defineBehavior({
   }) => {
     if (event.direction !== "backward")
       return !1;
-    const previousBlock = getPreviousBlock(snapshot), focusTextBlock = getFocusTextBlock(snapshot);
-    if (!previousBlock || !focusTextBlock || !isAtTheStartOfBlock(focusTextBlock)(snapshot))
+    const at = event.at ?? snapshot.context.selection;
+    if (!at)
+      return !1;
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: at
+      }
+    }, previousBlock = getPreviousBlock(adjustedSnapshot), focusTextBlock = getFocusTextBlock(adjustedSnapshot);
+    if (!previousBlock || !focusTextBlock || !isAtTheStartOfBlock(focusTextBlock)(adjustedSnapshot))
       return !1;
     const previousBlockEndPoint = getBlockEndPoint({
       context: snapshot.context,
@@ -6414,8 +6442,17 @@ const abstractAnnotationBehaviors = [defineBehavior({
   }) => {
     if (event.direction !== "forward")
       return !1;
-    const nextBlock = getNextBlock(snapshot), focusTextBlock = getFocusTextBlock(snapshot);
-    return !nextBlock || !focusTextBlock || !isAtTheEndOfBlock(focusTextBlock)(snapshot) || !isTextBlock(snapshot.context, nextBlock.node) ? !1 : {
+    const at = event.at ?? snapshot.context.selection;
+    if (!at)
+      return !1;
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: at
+      }
+    }, nextBlock = getNextBlock(adjustedSnapshot), focusTextBlock = getFocusTextBlock(adjustedSnapshot);
+    return !nextBlock || !focusTextBlock || !isAtTheEndOfBlock(focusTextBlock)(adjustedSnapshot) || !isTextBlock(snapshot.context, nextBlock.node) ? !1 : {
       nextBlock
     };
   },
@@ -9104,7 +9141,13 @@ const MAX_LIST_LEVEL = 10, clearListOnBackspace = defineBehavior({
     snapshot,
     event
   }) => {
-    const focusListBlock = getFocusListBlock(snapshot);
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: event.at ?? snapshot.context.selection
+      }
+    }, focusListBlock = getFocusListBlock(adjustedSnapshot);
     if (!focusListBlock)
       return !1;
     const firstInsertedBlock = event.blocks.at(0), secondInsertedBlock = event.blocks.at(1), insertedListBlock = isListBlock(snapshot.context, firstInsertedBlock) ? firstInsertedBlock : isListBlock(snapshot.context, secondInsertedBlock) ? secondInsertedBlock : void 0;
@@ -9138,7 +9181,13 @@ const MAX_LIST_LEVEL = 10, clearListOnBackspace = defineBehavior({
     snapshot,
     event
   }) => {
-    const focusListBlock = getFocusListBlock(snapshot);
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: event.at ?? snapshot.context.selection
+      }
+    }, focusListBlock = getFocusListBlock(adjustedSnapshot);
     if (!focusListBlock || isEmptyTextBlock(snapshot.context, focusListBlock.node))
       return !1;
     const firstInsertedBlock = event.blocks.at(0), secondInsertedBlock = event.blocks.at(1), insertedListBlock = isListBlock(snapshot.context, firstInsertedBlock) ? firstInsertedBlock : isListBlock(snapshot.context, secondInsertedBlock) ? secondInsertedBlock : void 0;
@@ -9171,7 +9220,13 @@ const MAX_LIST_LEVEL = 10, clearListOnBackspace = defineBehavior({
   }) => {
     if (event.placement !== "auto" || event.block._type !== snapshot.context.schema.block.name || event.block.listItem !== void 0)
       return !1;
-    const focusListBlock = getFocusListBlock(snapshot);
+    const adjustedSnapshot = {
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: event.at ?? snapshot.context.selection
+      }
+    }, focusListBlock = getFocusListBlock(adjustedSnapshot);
     return !focusListBlock || !isEmptyTextBlock(snapshot.context, focusListBlock.node) ? !1 : {
       level: focusListBlock.node.level,
       listItem: focusListBlock.node.listItem
@@ -9237,6 +9292,31 @@ function getEventBehaviors(behaviorIndex, type) {
   const global = behaviorIndex.global, namespace = type.includes(".") ? type.split(".").at(0) : type, namespaced = namespace ? behaviorIndex.namespaced.get(namespace) ?? [] : [], exact = behaviorIndex.exact.get(type) ?? [];
   return [...global, ...namespaced, ...exact].sort((a, b) => a.sortOrder - b.sortOrder).map((sortedBehavior) => sortedBehavior.behavior);
 }
+function createEditorSnapshot({
+  converters,
+  editor,
+  keyGenerator,
+  readOnly,
+  schema
+}) {
+  const selection = editor.selection ? slateRangeToSelection({
+    schema,
+    editor,
+    range: editor.selection
+  }) : null, context = {
+    converters,
+    keyGenerator,
+    readOnly,
+    schema,
+    selection,
+    value: editor.value
+  };
+  return {
+    blockIndexMap: editor.blockIndexMap,
+    context,
+    decoratorState: editor.decoratorState
+  };
+}
 const addAnnotationOperationImplementation = ({
   context,
   operation
@@ -9652,19 +9732,31 @@ const addAnnotationOperationImplementation = ({
     };
   }
 }, decoratorRemoveOperationImplementation = ({
+  context,
   operation
 }) => {
-  const editor = operation.editor, mark = operation.decorator, {
-    selection
-  } = editor;
-  if (selection) {
-    if (Range.isExpanded(selection))
+  const editor = operation.editor, mark = operation.decorator, at = operation.at ? toSlateRange({
+    context: {
+      schema: context.schema,
+      value: operation.editor.value,
+      selection: operation.at
+    },
+    blockIndexMap: operation.editor.blockIndexMap
+  }) : editor.selection;
+  if (at) {
+    if (Range.isExpanded(at)) {
+      const rangeRef = Editor.rangeRef(editor, at, {
+        affinity: "inward"
+      });
       Transforms.setNodes(editor, {}, {
+        at,
         match: Text.isText,
         split: !0,
         hanging: !0
-      }), editor.selection && [...Editor.nodes(editor, {
-        at: editor.selection,
+      });
+      const updatedAt = rangeRef.unref();
+      updatedAt && [...Editor.nodes(editor, {
+        at: updatedAt,
         match: Text.isText
       })].forEach(([node, path]) => {
         const block = editor.children[path[0]];
@@ -9675,8 +9767,8 @@ const addAnnotationOperationImplementation = ({
           at: path
         });
       });
-    else {
-      const [block, blockPath] = Editor.node(editor, selection, {
+    } else {
+      const [block, blockPath] = Editor.node(editor, at, {
         depth: 1
       }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
       if (lonelyEmptySpan) {
@@ -9691,9 +9783,9 @@ const addAnnotationOperationImplementation = ({
         editor.decoratorState[mark] = !1;
     }
     if (editor.selection) {
-      const selection2 = editor.selection;
+      const selection = editor.selection;
       editor.selection = {
-        ...selection2
+        ...selection
       };
     }
   }
@@ -10058,200 +10150,579 @@ function insertBlock(options) {
     },
     blockIndexMap: editor.blockIndexMap
   }) : editor.selection;
-  editor.children.length === 0 && Transforms.insertNodes(editor, createPlaceholderBlock(context), {
-    at: [0]
-  });
+  if (editor.children.length === 0) {
+    insertNodeAt(editor, [0], block, select);
+    return;
+  }
   const start = at ? Range.start(at) : Editor.start(editor, []), end = at ? Range.end(at) : Editor.end(editor, []), [startBlock, startBlockPath] = Array.from(Editor.nodes(editor, {
     at: start,
     mode: "lowest",
     match: (node, path) => Element$1.isElement(node) && path.length <= start.path.length
-  })).at(0) ?? [void 0, void 0], [endBlock, endBlockPath] = Array.from(Editor.nodes(editor, {
+  })).at(0) ?? [void 0, void 0];
+  let [endBlock, endBlockPath] = Array.from(Editor.nodes(editor, {
     at: end,
     mode: "lowest",
     match: (node, path) => Element$1.isElement(node) && path.length <= end.path.length
   })).at(0) ?? [void 0, void 0];
   if (!startBlock || !startBlockPath || !endBlock || !endBlockPath)
     throw new Error("Unable to insert block without a start and end block");
+  if (placement === "before") {
+    insertNodeAt(editor, startBlockPath, block, select);
+    return;
+  }
+  if (placement === "after") {
+    insertNodeAt(editor, Path.next(endBlockPath), block, select);
+    return;
+  }
   if (!at) {
-    if (placement === "before")
-      Transforms.insertNodes(editor, [block], {
-        at: [0]
-      }), select === "start" ? Transforms.select(editor, Editor.start(editor, [0])) : select === "end" && Transforms.select(editor, Editor.end(editor, [0]));
-    else if (placement === "after") {
-      const nextPath = Path.next(endBlockPath);
-      Transforms.insertNodes(editor, [block], {
-        at: nextPath
-      }), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
-    } else {
-      if (isEmptyTextBlock(context, endBlock)) {
-        Transforms.insertNodes(editor, [block], {
-          at: endBlockPath,
-          select: !1
-        }), Transforms.removeNodes(editor, {
-          at: Path.next(endBlockPath)
-        }), Transforms.deselect(editor), select === "start" ? Transforms.select(editor, Editor.start(editor, endBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, endBlockPath));
-        return;
+    if (isEmptyTextBlock(context, endBlock)) {
+      replaceEmptyTextBlock(editor, endBlockPath, block, select);
+      return;
+    }
+    if (editor.isTextBlock(block) && editor.isTextBlock(endBlock)) {
+      const selectionBefore = Editor.end(editor, endBlockPath);
+      insertTextBlockFragment(editor, block, selectionBefore), select === "start" ? setSelectionToPoint(editor, selectionBefore) : select === "none" && clearSelection(editor);
+      return;
+    }
+    insertNodeAt(editor, Path.next(endBlockPath), block, select);
+    return;
+  }
+  if (Range.isExpanded(at) && !editor.isTextBlock(block)) {
+    const atBeforeDelete = Editor.rangeRef(editor, at, {
+      affinity: "inward"
+    }), start2 = Range.start(at), startBlock2 = Node.get(editor, [start2.path[0]]), startOfBlock = Editor.start(editor, [start2.path[0]]), isAtStartOfBlock = Element$1.isElement(startBlock2) && Point.equals(start2, startOfBlock);
+    deleteExpandedRange(editor, at);
+    const atAfterDelete = atBeforeDelete.unref() ?? editor.selection, atBeforeInsert = atAfterDelete ? Editor.rangeRef(editor, atAfterDelete, {
+      affinity: "inward"
+    }) : void 0;
+    if (atAfterDelete) {
+      const insertPath = isAtStartOfBlock ? [atAfterDelete.anchor.path[0]] : [atAfterDelete.anchor.path[0] + 1];
+      if (editor.apply({
+        type: "insert_node",
+        path: insertPath,
+        node: block
+      }), select !== "none") {
+        const point = Editor.start(editor, insertPath);
+        editor.apply({
+          type: "set_selection",
+          properties: editor.selection,
+          newProperties: {
+            anchor: point,
+            focus: point
+          }
+        });
       }
-      if (editor.isTextBlock(block) && endBlock && editor.isTextBlock(endBlock)) {
-        const selectionBefore = Editor.end(editor, endBlockPath);
-        Transforms.insertFragment(editor, [block], {
-          at: Editor.end(editor, endBlockPath)
-        }), select === "start" ? Transforms.select(editor, selectionBefore) : select === "none" && Transforms.deselect(editor);
-        return;
+    }
+    const atAfterInsert = atBeforeInsert?.unref() ?? editor.selection;
+    if (select === "none" && atAfterInsert && editor.apply({
+      type: "set_selection",
+      properties: editor.selection,
+      newProperties: atAfterInsert
+    }), !editor.isTextBlock(block) && atAfterDelete) {
+      const emptyBlockPath = isAtStartOfBlock ? [atAfterDelete.anchor.path[0] + 1] : [atAfterDelete.anchor.path[0]];
+      try {
+        const potentiallyEmptyBlock = Node.get(editor, emptyBlockPath);
+        Element$1.isElement(potentiallyEmptyBlock) && isEmptyTextBlock(context, potentiallyEmptyBlock) && editor.apply({
+          type: "remove_node",
+          path: emptyBlockPath,
+          node: potentiallyEmptyBlock
+        });
+      } catch {
       }
-      const nextPath = Path.next(endBlockPath);
-      Transforms.insertNodes(editor, [block], {
-        at: nextPath,
-        select: !1
-      }), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
     }
     return;
   }
-  if (!at)
-    throw new Error("Unable to insert block without a selection");
-  if (placement === "before")
-    Transforms.insertNodes(editor, [block], {
-      at: startBlockPath,
-      select: !1
-    }), select === "start" ? Transforms.select(editor, Editor.start(editor, startBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, startBlockPath));
-  else if (placement === "after") {
-    const nextPath = Path.next(endBlockPath);
-    Transforms.insertNodes(editor, [block], {
-      at: nextPath,
-      select: !1
-    }), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
-  } else {
-    const endBlockEndPoint = Editor.start(editor, endBlockPath);
-    if (Range.isExpanded(at) && !editor.isTextBlock(block)) {
-      const atBeforeDelete = Editor.rangeRef(editor, at, {
-        affinity: "inward"
-      });
-      Transforms.delete(editor, {
-        at
-      });
-      const [focusBlock, focusBlockPath] = getFocusBlock({
-        editor
-      }), atAfterDelete = atBeforeDelete.unref() ?? editor.selection, atBeforeInsert = atAfterDelete ? Editor.rangeRef(editor, atAfterDelete, {
-        affinity: "inward"
-      }) : void 0;
-      Transforms.insertNodes(editor, [block], {
-        voids: !0,
-        at: atAfterDelete ?? void 0,
-        select: select !== "none"
-      });
-      const atAfterInsert = atBeforeInsert?.unref() ?? editor.selection;
-      select === "none" && atAfterInsert && Transforms.select(editor, atAfterInsert), isEmptyTextBlock(context, focusBlock) && Transforms.removeNodes(editor, {
-        at: focusBlockPath
+  if (!editor.isTextBlock(block) && editor.isTextBlock(endBlock) && !Range.isExpanded(at)) {
+    const selectionPoint = Range.start(at), blockPath = [selectionPoint.path[0]], blockStartPoint = Editor.start(editor, blockPath), blockEndPoint = Editor.end(editor, blockPath), isAtBlockStart = Point.equals(selectionPoint, blockStartPoint), isAtBlockEnd = Point.equals(selectionPoint, blockEndPoint);
+    if (!isAtBlockStart && !isAtBlockEnd) {
+      const currentBlock = Node.get(editor, blockPath), childIndex = selectionPoint.path[1], childOffset = selectionPoint.offset;
+      if (childOffset > 0) {
+        const textNode = Node.get(editor, selectionPoint.path);
+        if (childOffset < textNode.text.length) {
+          const {
+            text: _2,
+            ...properties
+          } = textNode;
+          editor.apply({
+            type: "split_node",
+            path: selectionPoint.path,
+            position: childOffset,
+            properties
+          });
+        }
+      }
+      const splitAtIndex = childOffset > 0 ? childIndex + 1 : childIndex, {
+        children: _,
+        ...blockProperties
+      } = currentBlock;
+      editor.apply({
+        type: "split_node",
+        path: blockPath,
+        position: splitAtIndex,
+        properties: blockProperties
       });
+      const insertPath = [blockPath[0] + 1];
+      if (editor.apply({
+        type: "insert_node",
+        path: insertPath,
+        node: block
+      }), select === "none") {
+        const firstBlockEndPoint = Editor.end(editor, blockPath);
+        editor.apply({
+          type: "set_selection",
+          properties: editor.selection,
+          newProperties: {
+            anchor: firstBlockEndPoint,
+            focus: firstBlockEndPoint
+          }
+        });
+      } else if (select === "start") {
+        const point = Editor.start(editor, insertPath);
+        editor.apply({
+          type: "set_selection",
+          properties: editor.selection,
+          newProperties: {
+            anchor: point,
+            focus: point
+          }
+        });
+      } else if (select === "end") {
+        const point = Editor.end(editor, insertPath);
+        editor.apply({
+          type: "set_selection",
+          properties: editor.selection,
+          newProperties: {
+            anchor: point,
+            focus: point
+          }
+        });
+      }
       return;
     }
-    if (editor.isTextBlock(endBlock) && editor.isTextBlock(block)) {
-      const selectionStartPoint = Range.start(at);
-      if (isEmptyTextBlock(context, endBlock)) {
-        Transforms.insertNodes(editor, [block], {
-          at: endBlockPath,
-          select: !1
-        }), Transforms.removeNodes(editor, {
-          at: Path.next(endBlockPath)
-        }), select === "start" ? Transforms.select(editor, selectionStartPoint) : select === "end" ? Transforms.select(editor, Editor.end(editor, endBlockPath)) : Transforms.select(editor, at);
-        return;
-      }
-      const endBlockChildKeys = endBlock.children.map((child) => child._key), endBlockMarkDefsKeys = endBlock.markDefs?.map((markDef) => markDef._key) ?? [], markDefKeyMap = /* @__PURE__ */ new Map(), adjustedMarkDefs = block.markDefs?.map((markDef) => {
-        if (endBlockMarkDefsKeys.includes(markDef._key)) {
-          const newKey = context.keyGenerator();
-          return markDefKeyMap.set(markDef._key, newKey), {
-            ...markDef,
-            _key: newKey
+  }
+  if (editor.isTextBlock(endBlock) && editor.isTextBlock(block)) {
+    let selectionStartPoint = Range.start(at), wasCrossBlockDeletion = !1;
+    if (Range.isExpanded(at)) {
+      const [start2, end2] = Range.edges(at), isCrossBlock = start2.path[0] !== end2.path[0];
+      if (deleteExpandedRange(editor, at), isCrossBlock) {
+        wasCrossBlockDeletion = !0;
+        const startBlockPath2 = [start2.path[0]], mergedBlock = Node.get(editor, startBlockPath2);
+        if (editor.isTextBlock(mergedBlock)) {
+          const mergePoint = {
+            path: [...startBlockPath2, start2.path[1]],
+            offset: start2.offset
           };
+          setSelectionToPoint(editor, mergePoint), selectionStartPoint = mergePoint;
         }
-        return markDef;
-      }), adjustedChildren = block.children.map((child) => {
-        if (isSpan(context, child)) {
-          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
-            };
-        }
-        return endBlockChildKeys.includes(child._key) ? {
-          ...child,
-          _key: context.keyGenerator()
-        } : child;
-      });
-      Transforms.setNodes(editor, {
+      }
+      const [newEndBlock, newEndBlockPath] = Array.from(Editor.nodes(editor, {
+        at: Editor.end(editor, []),
+        mode: "lowest",
+        match: (node, path) => Element$1.isElement(node) && path.length === 1
+      })).at(-1) ?? [void 0, void 0];
+      newEndBlock && newEndBlockPath && Element$1.isElement(newEndBlock) && (endBlock = newEndBlock, endBlockPath = newEndBlockPath);
+    }
+    if (!editor.isTextBlock(endBlock))
+      return;
+    if (isEmptyTextBlock(context, endBlock)) {
+      replaceEmptyTextBlock(editor, endBlockPath, block, select);
+      return;
+    }
+    const endBlockChildKeys = endBlock.children.map((child) => child._key), endBlockMarkDefsKeys = endBlock.markDefs?.map((markDef) => markDef._key) ?? [], markDefKeyMap = /* @__PURE__ */ new Map(), adjustedMarkDefs = block.markDefs?.map((markDef) => {
+      if (endBlockMarkDefsKeys.includes(markDef._key)) {
+        const newKey = context.keyGenerator();
+        return markDefKeyMap.set(markDef._key, newKey), {
+          ...markDef,
+          _key: newKey
+        };
+      }
+      return markDef;
+    }), adjustedChildren = block.children.map((child) => {
+      if (isSpan(context, child)) {
+        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
+          };
+      }
+      return endBlockChildKeys.includes(child._key) ? {
+        ...child,
+        _key: context.keyGenerator()
+      } : child;
+    }), endBlockNode = Node.get(editor, endBlockPath);
+    if (Element$1.isElement(endBlockNode) && editor.isTextBlock(endBlockNode)) {
+      const properties = {
+        markDefs: endBlockNode.markDefs
+      }, newProperties = {
         markDefs: [...endBlock.markDefs ?? [], ...adjustedMarkDefs ?? []]
-      }, {
-        at: endBlockPath
-      });
-      const adjustedBlock = isEqualChildren(block.children, adjustedChildren) ? block : {
-        ...block,
-        children: adjustedChildren
       };
-      if (select === "end") {
-        Transforms.insertFragment(editor, [adjustedBlock], {
-          voids: !0
-        });
-        return;
-      }
-      Transforms.insertFragment(editor, [adjustedBlock], {
-        at,
-        voids: !0
-      }), select === "start" ? Transforms.select(editor, selectionStartPoint) : Point.equals(selectionStartPoint, endBlockEndPoint) || Transforms.select(editor, selectionStartPoint);
-    } else if (editor.isTextBlock(endBlock)) {
-      const endBlockStartPoint = Editor.start(editor, endBlockPath), endBlockEndPoint2 = Editor.end(editor, endBlockPath), selectionStartPoint = Range.start(at), selectionEndPoint = Range.end(at);
-      if (Range.isCollapsed(at) && Point.equals(selectionStartPoint, endBlockStartPoint))
-        Transforms.insertNodes(editor, [block], {
-          at: endBlockPath,
-          select: !1
-        }), (select === "start" || select === "end") && Transforms.select(editor, Editor.start(editor, endBlockPath)), isEmptyTextBlock(context, endBlock) && Transforms.removeNodes(editor, {
-          at: Path.next(endBlockPath)
-        });
-      else if (Range.isCollapsed(at) && Point.equals(selectionEndPoint, endBlockEndPoint2)) {
-        const nextPath = [endBlockPath[0] + 1];
-        Transforms.insertNodes(editor, [block], {
-          at: nextPath,
-          select: !1
-        }), (select === "start" || select === "end") && Transforms.select(editor, Editor.start(editor, nextPath));
-      } else if (Range.isExpanded(at) && Point.equals(selectionStartPoint, endBlockStartPoint) && Point.equals(selectionEndPoint, endBlockEndPoint2))
-        Transforms.insertFragment(editor, [block], {
-          at
-        }), select === "start" ? Transforms.select(editor, Editor.start(editor, endBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, endBlockPath));
-      else if (Range.isExpanded(at) && Point.equals(selectionStartPoint, endBlockStartPoint))
-        Transforms.insertFragment(editor, [block], {
-          at
-        }), select === "start" ? Transforms.select(editor, Editor.start(editor, endBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, endBlockPath));
-      else if (Range.isExpanded(at) && Point.equals(selectionEndPoint, endBlockEndPoint2))
-        Transforms.insertFragment(editor, [block], {
-          at
-        }), select === "start" ? Transforms.select(editor, Editor.start(editor, Path.next(endBlockPath))) : select === "end" && Transforms.select(editor, Editor.end(editor, Path.next(endBlockPath)));
+      editor.apply({
+        type: "set_node",
+        path: endBlockPath,
+        properties,
+        newProperties
+      });
+    }
+    const adjustedBlock = isEqualChildren(block.children, adjustedChildren) ? block : {
+      ...block,
+      children: adjustedChildren
+    };
+    if (select === "end") {
+      const insertAt = editor.selection ? Range.end(editor.selection) : Editor.end(editor, endBlockPath);
+      insertTextBlockFragment(editor, adjustedBlock, insertAt);
+      return;
+    }
+    if (insertTextBlockFragment(editor, adjustedBlock, selectionStartPoint), select === "start")
+      setSelectionToPoint(editor, selectionStartPoint);
+    else if (select === "none")
+      if (wasCrossBlockDeletion)
+        setSelectionToPoint(editor, selectionStartPoint);
       else {
-        const [focusChild] = getFocusChild({
-          editor
-        });
-        if (focusChild && editor.isTextSpan(focusChild))
-          Transforms.splitNodes(editor, {
-            at
-          }), Transforms.insertFragment(editor, [block], {
-            at
-          }), select === "start" || select === "end" ? Transforms.select(editor, [endBlockPath[0] + 1]) : Transforms.select(editor, at);
-        else {
-          const nextPath = [endBlockPath[0] + 1];
-          Transforms.insertNodes(editor, [block], {
-            at: nextPath,
-            select: !1
-          }), Transforms.select(editor, at), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
+        const endBlockStartPoint = Editor.start(editor, endBlockPath);
+        Point.equals(selectionStartPoint, endBlockStartPoint) || setSelectionToPoint(editor, selectionStartPoint);
+      }
+  } else {
+    if (!editor.isTextBlock(endBlock)) {
+      insertNodeAt(editor, [endBlockPath[0] + 1], block, select);
+      return;
+    }
+    const endBlockStartPoint = Editor.start(editor, endBlockPath), endBlockEndPoint = Editor.end(editor, endBlockPath), selectionStartPoint = Range.start(at), selectionEndPoint = Range.end(at);
+    if (Range.isCollapsed(at) && Point.equals(selectionStartPoint, endBlockStartPoint)) {
+      editor.apply({
+        type: "insert_node",
+        path: endBlockPath,
+        node: block
+      }), select !== "none" && setSelection(editor, endBlockPath, "start"), isEmptyTextBlock(context, endBlock) && removeNodeAt(editor, Path.next(endBlockPath));
+      return;
+    }
+    if (Range.isCollapsed(at) && Point.equals(selectionEndPoint, endBlockEndPoint)) {
+      const nextPath = [endBlockPath[0] + 1];
+      editor.apply({
+        type: "insert_node",
+        path: nextPath,
+        node: block
+      }), select !== "none" && setSelection(editor, nextPath, "start");
+      return;
+    }
+    if (Range.isExpanded(at) && Point.equals(selectionStartPoint, endBlockStartPoint) && Point.equals(selectionEndPoint, endBlockEndPoint)) {
+      editor.apply({
+        type: "insert_node",
+        path: endBlockPath,
+        node: block
+      }), removeNodeAt(editor, Path.next(endBlockPath)), select !== "none" && setSelection(editor, endBlockPath, select);
+      return;
+    }
+    if (Range.isExpanded(at) && Point.equals(selectionStartPoint, endBlockStartPoint)) {
+      const [, end2] = Range.edges(at), endNode = Node.get(editor, end2.path);
+      end2.offset > 0 && editor.apply({
+        type: "remove_text",
+        path: end2.path,
+        offset: 0,
+        text: endNode.text.slice(0, end2.offset)
+      });
+      for (let i = end2.path[1] - 1; i >= 0; i--)
+        removeNodeAt(editor, [...endBlockPath, i]);
+      insertTextBlockFragment(editor, block, Editor.start(editor, endBlockPath)), select !== "none" && setSelection(editor, endBlockPath, select);
+      return;
+    }
+    if (Range.isExpanded(at) && Point.equals(selectionEndPoint, endBlockEndPoint)) {
+      const [start2] = Range.edges(at), blockNode = Node.get(editor, endBlockPath);
+      for (let i = blockNode.children.length - 1; i > start2.path[1]; i--)
+        removeNodeAt(editor, [...endBlockPath, i]);
+      const startNode = Node.get(editor, start2.path);
+      start2.offset < startNode.text.length && editor.apply({
+        type: "remove_text",
+        path: start2.path,
+        offset: start2.offset,
+        text: startNode.text.slice(start2.offset)
+      }), insertTextBlockFragment(editor, block, start2), select !== "none" && setSelection(editor, Path.next(endBlockPath), select);
+      return;
+    }
+    const [focusChild] = getFocusChild({
+      editor
+    });
+    if (focusChild && editor.isTextSpan(focusChild)) {
+      const startPoint = Range.start(at);
+      if (editor.isTextBlock(block)) {
+        const nodeToSplit = Node.get(editor, startPoint.path);
+        if (Text.isText(nodeToSplit)) {
+          const {
+            text: _,
+            ...properties
+          } = nodeToSplit;
+          editor.apply({
+            type: "split_node",
+            path: startPoint.path,
+            position: startPoint.offset,
+            properties
+          });
+        }
+        insertTextBlockFragment(editor, block, startPoint), select === "none" ? setSelectionToRange(editor, at) : setSelection(editor, [endBlockPath[0] + 1], "start");
+      } else {
+        let currentPath = startPoint.path, currentOffset = startPoint.offset;
+        const cursorPositionRef = Editor.pointRef(editor, startPoint, {
+          affinity: "backward"
+        }), blockPath = [currentPath[0]], firstBlockPathRef = Editor.pathRef(editor, blockPath), textNode = Node.get(editor, currentPath);
+        if (Text.isText(textNode) && currentOffset > 0 && currentOffset < textNode.text.length) {
+          const {
+            text: _,
+            ...properties
+          } = textNode;
+          editor.apply({
+            type: "split_node",
+            path: currentPath,
+            position: currentOffset,
+            properties
+          }), currentPath = Path.next(currentPath), currentOffset = 0;
+        }
+        const splitAtIndex = currentOffset > 0 ? currentPath[1] + 1 : currentPath[1], blockToSplit = Node.get(editor, blockPath);
+        if (splitAtIndex < blockToSplit.children.length && Element$1.isElement(blockToSplit)) {
+          const {
+            children: _,
+            ...blockProperties
+          } = blockToSplit;
+          editor.apply({
+            type: "split_node",
+            path: blockPath,
+            position: splitAtIndex,
+            properties: blockProperties
+          });
+        }
+        const currentFirstBlockPath = firstBlockPathRef.unref(), insertPath = currentFirstBlockPath ? [currentFirstBlockPath[0] + 1] : [blockPath[0] + 1];
+        if (editor.apply({
+          type: "insert_node",
+          path: insertPath,
+          node: block
+        }), select === "start" || select === "end") {
+          const point = Editor.start(editor, insertPath);
+          editor.apply({
+            type: "set_selection",
+            properties: editor.selection,
+            newProperties: {
+              anchor: point,
+              focus: point
+            }
+          });
+        } else {
+          const point = cursorPositionRef.unref();
+          point && editor.apply({
+            type: "set_selection",
+            properties: editor.selection,
+            newProperties: {
+              anchor: point,
+              focus: point
+            }
+          });
         }
       }
     } else {
       const nextPath = [endBlockPath[0] + 1];
-      Transforms.insertNodes(editor, [block], {
-        select: !1,
-        at: nextPath
-      }), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
+      editor.apply({
+        type: "insert_node",
+        path: nextPath,
+        node: block
+      }), select === "none" ? setSelectionToRange(editor, at) : setSelection(editor, nextPath, select);
+    }
+  }
+}
+function setSelection(editor, path, position) {
+  const point = position === "start" ? Editor.start(editor, path) : Editor.end(editor, path);
+  editor.apply({
+    type: "set_selection",
+    properties: editor.selection,
+    newProperties: {
+      anchor: point,
+      focus: point
+    }
+  });
+}
+function clearSelection(editor) {
+  editor.selection && editor.apply({
+    type: "set_selection",
+    properties: editor.selection,
+    newProperties: null
+  });
+}
+function setSelectionToPoint(editor, point) {
+  editor.apply({
+    type: "set_selection",
+    properties: editor.selection,
+    newProperties: {
+      anchor: point,
+      focus: point
+    }
+  });
+}
+function setSelectionToRange(editor, range) {
+  editor.apply({
+    type: "set_selection",
+    properties: editor.selection,
+    newProperties: range
+  });
+}
+function insertNodeAt(editor, path, node, select) {
+  editor.apply({
+    type: "insert_node",
+    path,
+    node
+  }), select !== "none" && setSelection(editor, path, select);
+}
+function removeNodeAt(editor, path) {
+  const node = Node.get(editor, path);
+  editor.apply({
+    type: "remove_node",
+    path,
+    node
+  });
+}
+function replaceEmptyTextBlock(editor, blockPath, newBlock, select) {
+  const hadSelection = editor.selection !== null;
+  if (editor.apply({
+    type: "insert_node",
+    path: blockPath,
+    node: newBlock
+  }), removeNodeAt(editor, Path.next(blockPath)), select === "none" && !hadSelection)
+    return;
+  const point = select === "end" ? Editor.end(editor, blockPath) : Editor.start(editor, blockPath);
+  clearSelection(editor), editor.apply({
+    type: "set_selection",
+    properties: null,
+    newProperties: {
+      anchor: point,
+      focus: point
+    }
+  });
+}
+function deleteSameBlockRange(editor, start, end) {
+  const blockPath = [start.path[0]];
+  if (Path.equals(start.path, end.path)) {
+    const textToRemove = Node.get(editor, start.path).text.slice(start.offset, end.offset);
+    editor.apply({
+      type: "remove_text",
+      path: start.path,
+      offset: start.offset,
+      text: textToRemove
+    });
+    return;
+  }
+  const startNode = Node.get(editor, start.path);
+  if (start.offset < startNode.text.length) {
+    const textToRemove = startNode.text.slice(start.offset);
+    editor.apply({
+      type: "remove_text",
+      path: start.path,
+      offset: start.offset,
+      text: textToRemove
+    });
+  }
+  for (let i = end.path[1] - 1; i > start.path[1]; i--)
+    removeNodeAt(editor, [...blockPath, i]);
+  const newEndPath = [...blockPath, start.path[1] + 1], endNode = Node.get(editor, newEndPath);
+  if (end.offset > 0) {
+    const textToRemove = endNode.text.slice(0, end.offset);
+    editor.apply({
+      type: "remove_text",
+      path: newEndPath,
+      offset: 0,
+      text: textToRemove
+    });
+  }
+  const startNodeAfter = Node.get(editor, start.path), endNodeAfter = Node.get(editor, newEndPath);
+  if (Text.isText(startNodeAfter) && Text.isText(endNodeAfter)) {
+    const {
+      text: _,
+      ...properties
+    } = endNodeAfter;
+    editor.apply({
+      type: "merge_node",
+      path: newEndPath,
+      position: startNodeAfter.text.length,
+      properties
+    });
+  }
+}
+function deleteCrossBlockRange(editor, start, end) {
+  const startBlockPath = [start.path[0]];
+  if (start.path.length > 1) {
+    const startNode = Node.get(editor, start.path);
+    if (start.offset < startNode.text.length) {
+      const textToRemove = startNode.text.slice(start.offset);
+      editor.apply({
+        type: "remove_text",
+        path: start.path,
+        offset: start.offset,
+        text: textToRemove
+      });
+    }
+    const startBlock2 = Node.get(editor, startBlockPath);
+    for (let i = startBlock2.children.length - 1; i > start.path[1]; i--)
+      removeNodeAt(editor, [...startBlockPath, i]);
+  }
+  for (let i = end.path[0] - 1; i > start.path[0]; i--)
+    removeNodeAt(editor, [i]);
+  const adjustedEndBlockPath = [start.path[0] + 1];
+  if (end.path.length > 1) {
+    for (let i = 0; i < end.path[1]; i++)
+      removeNodeAt(editor, [...adjustedEndBlockPath, 0]);
+    const endNodePath = [...adjustedEndBlockPath, 0], endNode = Node.get(editor, endNodePath);
+    if (end.offset > 0) {
+      const textToRemove = endNode.text.slice(0, end.offset);
+      editor.apply({
+        type: "remove_text",
+        path: endNodePath,
+        offset: 0,
+        text: textToRemove
+      });
+    }
+  }
+  const startBlock = Node.get(editor, startBlockPath), endBlock = Node.get(editor, adjustedEndBlockPath);
+  if (editor.isTextBlock(startBlock) && editor.isTextBlock(endBlock)) {
+    const {
+      children: _,
+      ...properties
+    } = endBlock;
+    editor.apply({
+      type: "merge_node",
+      path: adjustedEndBlockPath,
+      position: startBlock.children.length,
+      properties
+    });
+  }
+}
+function deleteExpandedRange(editor, range) {
+  const [start, end] = Range.edges(range);
+  start.path[0] === end.path[0] ? deleteSameBlockRange(editor, start, end) : deleteCrossBlockRange(editor, start, end);
+}
+function insertTextBlockFragment(editor, block, at) {
+  if (!Element$1.isElement(block) || !editor.isTextBlock(block))
+    return;
+  if (at.offset > 0) {
+    const textNode = Node.get(editor, at.path);
+    if (Text.isText(textNode)) {
+      const {
+        text: _,
+        ...properties
+      } = textNode;
+      editor.apply({
+        type: "split_node",
+        path: at.path,
+        position: at.offset,
+        properties
+      });
     }
   }
+  const parentPath = Path.parent(at.path);
+  let insertIndex = at.path[at.path.length - 1] + (at.offset > 0 ? 1 : 0);
+  for (const child of block.children) {
+    const childPath = [...parentPath, insertIndex];
+    editor.apply({
+      type: "insert_node",
+      path: childPath,
+      node: child
+    }), insertIndex++;
+  }
 }
 const insertChildOperationImplementation = ({
   context,
@@ -10585,9 +11056,10 @@ function performEvent({
   forwardFromBehaviors,
   event,
   editor,
+  converters,
   keyGenerator,
+  readOnly,
   schema,
-  getSnapshot,
   nativeEvent,
   sendBack
 }) {
@@ -10605,10 +11077,16 @@ function performEvent({
           editor
         }
       });
-    }), editor.onChange();
+    }), mode === "send" && editor.onChange();
     return;
   }
-  const guardSnapshot = getSnapshot();
+  const guardSnapshot = createEditorSnapshot({
+    converters,
+    editor,
+    keyGenerator,
+    readOnly,
+    schema
+  });
   let nativeEventPrevented = !1, defaultBehaviorOverwritten = !1, eventBehaviorIndex = -1;
   for (const eventBehavior of eventBehaviors) {
     eventBehaviorIndex++;
@@ -10628,7 +11106,13 @@ function performEvent({
     let actionSetIndex = -1;
     for (const actionSet of eventBehavior.actions) {
       actionSetIndex++;
-      const actionsSnapshot = getSnapshot();
+      const actionsSnapshot = createEditorSnapshot({
+        converters,
+        editor,
+        keyGenerator,
+        readOnly,
+        schema
+      });
       let actions = [];
       try {
         actions = actionSet({
@@ -10666,9 +11150,10 @@ function performEvent({
               forwardFromBehaviors: remainingBehaviors,
               event: action.event,
               editor,
+              converters,
               keyGenerator,
+              readOnly,
               schema,
-              getSnapshot,
               nativeEvent,
               sendBack
             });
@@ -10681,9 +11166,10 @@ function performEvent({
               abstractBehaviorIndex,
               event: action.event,
               editor,
+              converters,
               keyGenerator,
+              readOnly,
               schema,
-              getSnapshot,
               nativeEvent,
               sendBack
             });
@@ -10695,9 +11181,10 @@ function performEvent({
             abstractBehaviorIndex,
             event: action.event,
             editor,
+            converters,
             keyGenerator,
+            readOnly,
             schema,
-            getSnapshot,
             nativeEvent: void 0,
             sendBack
           });
@@ -10717,7 +11204,7 @@ function performEvent({
         editor
       }
     });
-  }), editor.onChange()) : nativeEventPrevented && nativeEvent?.preventDefault();
+  }), mode === "send" && editor.onChange()) : nativeEventPrevented && (nativeEvent?.preventDefault(), mode === "send" && editor.onChange());
 }
 function sortByPriority(items) {
   if (items.length === 0)
@@ -10762,31 +11249,6 @@ function sortByPriority(items) {
     result.includes(item) || result.push(item);
   return [...result, ...itemsWithoutPriority];
 }
-function createEditorSnapshot({
-  converters,
-  editor,
-  keyGenerator,
-  readOnly,
-  schema
-}) {
-  const selection = editor.selection ? slateRangeToSelection({
-    schema,
-    editor,
-    range: editor.selection
-  }) : null, context = {
-    converters,
-    keyGenerator,
-    readOnly,
-    schema,
-    selection,
-    value: editor.value
-  };
-  return {
-    blockIndexMap: editor.blockIndexMap,
-    context,
-    decoratorState: editor.decoratorState
-  };
-}
 function rerouteExternalBehaviorEvent({
   event,
   slateEditor
@@ -10937,16 +11399,11 @@ const editorMachine = setup({
           abstractBehaviorIndex: context.abstractBehaviorIndex,
           event: event.behaviorEvent,
           editor: event.editor,
+          converters: [...context.converters],
           keyGenerator: context.keyGenerator,
           schema: context.schema,
-          getSnapshot: () => createEditorSnapshot({
-            converters: [...context.converters],
-            editor: event.editor,
-            keyGenerator: context.keyGenerator,
-            readOnly: self.getSnapshot().matches({
-              "edit mode": "read only"
-            }),
-            schema: context.schema
+          readOnly: self.getSnapshot().matches({
+            "edit mode": "read only"
           }),
           nativeEvent: event.nativeEvent,
           sendBack: (eventSentBack) => {
@@ -13260,12 +13717,12 @@ const usePortableTextEditorSelection = () => {
   const $ = c(5), editorActor = useContext(EditorActorContext);
   let t0;
   $[0] !== editorActor ? (t0 = editorActor.getSnapshot(), $[0] = editorActor, $[1] = t0) : t0 = $[1];
-  const [selection, setSelection] = useState(t0.context.selection);
+  const [selection, setSelection2] = useState(t0.context.selection);
   let t1, t2;
   return $[2] !== editorActor ? (t1 = () => {
     const subscription = editorActor.on("selection", (event) => {
       startTransition(() => {
-        setSelection(event.selection);
+        setSelection2(event.selection);
       });
     });
     return () => {