@portabletext/editor 1.37.0 → 1.38.1

package/lib/_chunks-es/editor-provider.js

@@ -5,7 +5,7 @@ import { ReactEditor, withReact, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
 import debug$e from "debug";
 import isEqual from "lodash/isEqual.js";
-import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, deleteForward, createEditor as createEditor$1 } from "slate";
+import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, createEditor as createEditor$1 } from "slate";
 import { setup, emit, enqueueActions, assign, assertEvent, fromCallback, stateIn, and, not, createActor } from "xstate";
 import { unset, set, setIfMissing, insert, diffMatchPatch as diffMatchPatch$1, applyAll } from "@portabletext/patches";
 import { defineType, defineField, isKeySegment, isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, isPortableTextListBlock } from "@sanity/types";
@@ -13,19 +13,20 @@ import flatten from "lodash/flatten.js";
 import isPlainObject from "lodash/isPlainObject.js";
 import uniq from "lodash/uniq.js";
 import getRandomValues from "get-random-values-esm";
-import { parseBlock, blockOffsetsToSelection, isTextBlock } from "./util.block-offsets-to-selection.js";
-import { sliceBlocks, blockOffsetToSpanSelectionPoint, spanSelectionPointToBlockOffset } from "./util.slice-blocks.js";
+import { parseBlock, blockOffsetsToSelection, isTextBlock, parseBlocks } from "./parse-blocks.js";
+import { sliceBlocks, blockOffsetToSpanSelectionPoint, spanSelectionPointToBlockOffset, isKeyedSegment as isKeyedSegment$1 } from "./util.slice-blocks.js";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
 import get from "lodash/get.js";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
-import { createGuards } from "./selector.is-at-the-start-of-block.js";
-import { getTrimmedSelection, isActiveAnnotation, isActiveDecorator, isActiveListItem, isActiveStyle } from "./selector.is-active-style.js";
+import { createGuards, getFocusSpan, isSelectionCollapsed, getSelectedBlocks, isSelectionExpanded } from "./selector.is-at-the-start-of-block.js";
+import { getTrimmedSelection, isOverlappingSelection, isSelectingEntireBlocks, isActiveAnnotation, isActiveDecorator, isActiveListItem, isActiveStyle } from "./selector.is-overlapping-selection.js";
 import omit from "lodash/omit.js";
+import { DOMEditor } from "slate-dom";
 import startCase from "lodash.startcase";
-import { defineBehavior, raise, coreBehaviors, isCustomBehaviorEvent } from "./behavior.core.js";
+import { defineBehavior, raise, isDragBehaviorEvent, isMouseBehaviorEvent, coreBehaviors, isCustomBehaviorEvent } from "./behavior.core.js";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
 function createEditorSchema(portableTextType) {
@@ -331,7 +332,65 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
 function isEqualToEmptyEditor(children, schemaTypes) {
   return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
 }
-const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), IS_DRAGGING = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_ELEMENT = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_ELEMENT_TARGET = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_TARGET_POSITION = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
+const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), EditorActorContext = createContext({});
+function getActiveDecorators({
+  schema,
+  slateEditorInstance
+}) {
+  const decorators = schema.decorators.map((decorator) => decorator.value);
+  return ({
+    ...Editor.marks(slateEditorInstance) ?? {}
+  }.marks ?? []).filter((mark) => decorators.includes(mark));
+}
+function getValue({
+  editorActorSnapshot,
+  slateEditorInstance
+}) {
+  return fromSlateValue(slateEditorInstance.children, editorActorSnapshot.context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(slateEditorInstance));
+}
+function defaultCompare(a, b) {
+  return a === b;
+}
+function useEditorSelector(editor, selector, t0) {
+  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
+  let t1;
+  return $[0] !== editor._internal.slateEditor.instance || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
+    const snapshot = getEditorSnapshot({
+      editorActorSnapshot,
+      slateEditorInstance: editor._internal.slateEditor.instance
+    });
+    return selector(snapshot);
+  }, $[0] = editor._internal.slateEditor.instance, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
+}
+function getEditorSnapshot({
+  editorActorSnapshot,
+  slateEditorInstance
+}) {
+  return {
+    context: {
+      converters: [...editorActorSnapshot.context.converters],
+      activeDecorators: getActiveDecorators({
+        schema: editorActorSnapshot.context.schema,
+        slateEditorInstance
+      }),
+      keyGenerator: editorActorSnapshot.context.keyGenerator,
+      readOnly: editorActorSnapshot.matches({
+        "edit mode": "read only"
+      }),
+      schema: editorActorSnapshot.context.schema,
+      selection: editorActorSnapshot.context.selection,
+      value: getValue({
+        editorActorSnapshot,
+        slateEditorInstance
+      })
+    },
+    beta: {
+      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
+      internalDrag: editorActorSnapshot.context.internalDrag
+    }
+  };
+}
+const PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
   const editor = useContext(PortableTextEditorContext);
   if (!editor)
     throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
@@ -2425,7 +2484,8 @@ const converterJson = {
     snapshot,
     event
   }) => {
-    if (!snapshot.context.selection)
+    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+    if (!selection)
       return {
         type: "serialization.failure",
         mimeType: "application/x-portable-text",
@@ -2434,7 +2494,7 @@ const converterJson = {
       };
     const blocks = sliceBlocks({
       blocks: snapshot.context.value,
-      selection: snapshot.context.selection
+      selection
     });
     return {
       type: "serialization.success",
@@ -2484,7 +2544,8 @@ const converterJson = {
     snapshot,
     event
   }) => {
-    if (!snapshot.context.selection)
+    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+    if (!selection)
       return {
         type: "serialization.failure",
         mimeType: "text/html",
@@ -2493,7 +2554,7 @@ const converterJson = {
       };
     const blocks = sliceBlocks({
       blocks: snapshot.context.value,
-      selection: snapshot.context.selection
+      selection
     }), html = toHTML(blocks, {
       onMissingComponent: !1,
       components: {
@@ -2537,21 +2598,24 @@ const converterJson = {
   serialize: ({
     snapshot,
     event
-  }) => snapshot.context.selection ? {
-    type: "serialization.success",
-    data: sliceBlocks({
-      blocks: snapshot.context.value,
-      selection: snapshot.context.selection
-    }).map((block) => isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]`).join("") : `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]`).join(`
+  }) => {
+    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+    return selection ? {
+      type: "serialization.success",
+      data: sliceBlocks({
+        blocks: snapshot.context.value,
+        selection
+      }).map((block) => isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]`).join("") : `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]`).join(`
 
 `),
-    mimeType: "text/plain",
-    originEvent: event.originEvent
-  } : {
-    type: "serialization.failure",
-    mimeType: "text/plain",
-    originEvent: event.originEvent,
-    reason: "No selection"
+      mimeType: "text/plain",
+      originEvent: event.originEvent
+    } : {
+      type: "serialization.failure",
+      mimeType: "text/plain",
+      originEvent: event.originEvent,
+      reason: "No selection"
+    };
   },
   deserialize: ({
     snapshot,
@@ -2815,7 +2879,8 @@ const insertBreakActionImplementation = ({
   const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
     Transforms.splitNodes(editor, {
-      at: editor.selection
+      at: editor.selection,
+      always: !0
     });
     const [nextBlock, nextBlockPath] = Editor.node(editor, Path.next(focusBlockPath), {
       depth: 1
@@ -3059,7 +3124,8 @@ const decoratorAddActionImplementation = ({
       backward: editorSelection?.backward
     }), trimmedSelection = getTrimmedSelection({
       beta: {
-        hasTag: () => !1
+        hasTag: () => !1,
+        internalDrag: void 0
       },
       context: {
         activeDecorators: [],
@@ -4098,49 +4164,7 @@ const addAnnotationActionImplementation = ({
         editor: action.editor
       }
     });
-};
-function insertBlock({
-  block,
-  placement,
-  editor,
-  schema
-}) {
-  if (editor.selection) {
-    const [focusBlock, focusBlockPath] = Array.from(Editor.nodes(editor, {
-      at: editor.selection.focus.path.slice(0, 1),
-      match: (n) => !Editor.isEditor(n)
-    }))[0] ?? [void 0, void 0];
-    if (placement === "after") {
-      const nextPath = [focusBlockPath[0] + 1];
-      Transforms.insertNodes(editor, block, {
-        at: nextPath
-      }), Transforms.select(editor, {
-        anchor: {
-          path: [nextPath[0], 0],
-          offset: 0
-        },
-        focus: {
-          path: [nextPath[0], 0],
-          offset: 0
-        }
-      });
-    } else placement === "before" ? Transforms.insertNodes(editor, block, {
-      at: focusBlockPath
-    }) : (Editor.insertNode(editor, block), focusBlock && isEqualToEmptyEditor([focusBlock], schema) && Transforms.removeNodes(editor, {
-      at: focusBlockPath
-    }));
-  } else {
-    const lastBlock = Array.from(Editor.nodes(editor, {
-      match: (n) => !Editor.isEditor(n),
-      at: [],
-      reverse: !0
-    }))[0];
-    Editor.insertNode(editor, block), lastBlock && isEqualToEmptyEditor([lastBlock[0]], schema) && Transforms.removeNodes(editor, {
-      at: lastBlock[1]
-    });
-  }
-}
-const blockSetBehaviorActionImplementation = ({
+}, blockSetBehaviorActionImplementation = ({
   context,
   action
 }) => {
@@ -4250,6 +4274,10 @@ const blockSetBehaviorActionImplementation = ({
   }, {
     at: location
   });
+}, blurActionImplementation = ({
+  action
+}) => {
+  ReactEditor.blur(action.editor);
 }, dataTransferSetActionImplementation = ({
   action
 }) => {
@@ -4263,6 +4291,34 @@ const blockSetBehaviorActionImplementation = ({
   action.editor.delete({
     at: range
   });
+}, deleteBackwardActionImplementation = ({
+  action
+}) => {
+  action.editor.deleteBackward(action.unit);
+}, deleteBlockActionImplementation = ({
+  action
+}) => {
+  const range = toSlateRange({
+    anchor: {
+      path: action.blockPath,
+      offset: 0
+    },
+    focus: {
+      path: action.blockPath,
+      offset: 0
+    }
+  }, action.editor);
+  if (!range) {
+    console.error("Unable to find Slate range from selection points");
+    return;
+  }
+  Transforms.removeNodes(action.editor, {
+    at: range
+  });
+}, deleteForwardActionImplementation = ({
+  action
+}) => {
+  action.editor.deleteForward(action.unit);
 }, deleteTextActionImplementation = ({
   context,
   action
@@ -4278,7 +4334,8 @@ const blockSetBehaviorActionImplementation = ({
     throw new Error("Unable to find selection from block offsets");
   const trimmedSelection = getTrimmedSelection({
     beta: {
-      hasTag: () => !1
+      hasTag: () => !1,
+      internalDrag: void 0
     },
     context: {
       converters: [],
@@ -4298,157 +4355,395 @@ const blockSetBehaviorActionImplementation = ({
   Transforms.delete(action.editor, {
     at: range
   });
-}, insertBlockObjectActionImplementation = ({
+}, deserializationFailureActionImplementation = ({
+  action
+}) => {
+  console.warn(`Deserialization of ${action.mimeType} failed with reason "${action.reason}"`);
+};
+function getFocusBlock({
+  editor
+}) {
+  return editor.selection ? Array.from(Editor.nodes(editor, {
+    at: editor.selection.focus.path.slice(0, 1),
+    match: (n) => !Editor.isEditor(n)
+  })).at(0) ?? [void 0, void 0] : [void 0, void 0];
+}
+function getFocusChild({
+  editor
+}) {
+  const [focusBlock, focusBlockPath] = getFocusBlock({
+    editor
+  }), childIndex = editor.selection?.focus.path.at(1);
+  if (!focusBlock || !focusBlockPath || childIndex === void 0)
+    return [void 0, void 0];
+  const focusChild = Node.child(focusBlock, childIndex);
+  return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
+}
+function getLastBlock({
+  editor
+}) {
+  return Array.from(Editor.nodes(editor, {
+    match: (n) => !Editor.isEditor(n),
+    at: [],
+    reverse: !0
+  })).at(0) ?? [void 0, void 0];
+}
+const insertBlockActionImplementation = ({
   context,
   action
 }) => {
-  const block = toSlateValue([{
-    _key: context.keyGenerator(),
-    _type: action.blockObject.name,
-    ...action.blockObject.value ? action.blockObject.value : {}
-  }], {
+  const parsedBlock = parseBlock({
+    block: action.block,
+    context,
+    options: {
+      refreshKeys: !1
+    }
+  });
+  if (!parsedBlock)
+    throw new Error(`Failed to parse block ${JSON.stringify(action.block)}`);
+  const fragment = toSlateValue([parsedBlock], {
     schemaTypes: context.schema
   })[0];
+  if (!fragment)
+    throw new Error(`Failed to convert block to Slate fragment ${JSON.stringify(parsedBlock)}`);
   insertBlock({
-    block,
+    block: fragment,
     placement: action.placement,
+    select: action.select ?? "start",
     editor: action.editor,
     schema: context.schema
   });
-}, insertBlocksActionImplementation = ({
-  context,
-  action
-}) => {
-  const fragment = toSlateValue(action.blocks, {
-    schemaTypes: context.schema
-  });
-  if (!action.editor.selection) {
-    if (action.placement === "before") {
-      action.editor.insertFragment(fragment, {
-        at: Editor.start(action.editor, [])
-      });
-      return;
-    }
-    if (action.placement === "after") {
-      action.editor.insertFragment(fragment, {
-        at: Editor.end(action.editor, [])
-      });
-      return;
-    }
-    action.editor.insertFragment(fragment);
-    return;
-  }
-  const [focusBlock, focusPath] = Editor.node(action.editor, action.editor.selection, {
-    depth: 1
+};
+function insertBlock({
+  block,
+  placement,
+  select,
+  editor,
+  schema
+}) {
+  const [focusBlock, focusBlockPath] = getFocusBlock({
+    editor
   });
-  if (action.placement === "before" && focusPath) {
-    Transforms.insertNodes(action.editor, fragment, {
-      at: focusPath
-    });
-    return;
-  }
-  if (action.placement === "after" && focusPath) {
-    const nextPath = [focusPath[0] + 1];
-    Transforms.insertNodes(action.editor, fragment, {
-      at: nextPath
+  if (!editor.selection || !focusBlock || !focusBlockPath) {
+    select !== "none" && DOMEditor.focus(editor);
+    const [lastBlock, lastBlockPath] = getLastBlock({
+      editor
     });
-    const [nextBlock, nextBlockPath] = Editor.node(action.editor, Path.next(focusPath), {
-      depth: 1
-    }), nextChild = Node.child(nextBlock, 0);
-    !action.editor.isTextSpan(nextChild) && Transforms.insertNodes(action.editor, {
-      _key: context.keyGenerator(),
-      _type: "span",
-      text: "",
-      marks: []
-    }, {
-      at: [nextBlockPath[0], 0]
-    }), Transforms.select(action.editor, {
-      anchor: {
-        path: [nextPath[0], 0],
-        offset: 0
-      },
-      focus: {
-        path: [nextPath[0], 0],
-        offset: 0
+    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 = lastBlockPath ? [lastBlockPath[0] + 1] : [0];
+      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 {
+      if (lastBlock && isEqualToEmptyEditor([lastBlock], schema)) {
+        Transforms.removeNodes(editor, {
+          at: lastBlockPath
+        }), Transforms.insertNodes(editor, [block], {
+          at: lastBlockPath,
+          select: !1
+        }), Transforms.deselect(editor), select === "start" ? Transforms.select(editor, Editor.start(editor, lastBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, lastBlockPath));
+        return;
       }
+      if (editor.isTextBlock(block) && lastBlock && editor.isTextBlock(lastBlock)) {
+        const selectionBefore = Editor.end(editor, lastBlockPath);
+        Transforms.insertFragment(editor, [block], {
+          at: Editor.end(editor, lastBlockPath)
+        }), select === "start" ? Transforms.select(editor, selectionBefore) : select === "none" && Transforms.deselect(editor);
+        return;
+      }
+      const nextPath = lastBlockPath ? [lastBlockPath[0] + 1] : [0];
+      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 if (placement === "before") {
+    const currentSelection = editor.selection;
+    Transforms.insertNodes(editor, [block], {
+      at: focusBlockPath,
+      select: !1
     });
-    return;
-  }
-  if (!action.editor.isTextBlock(focusBlock)) {
-    const nextPath = [focusPath[0] + 1];
-    Transforms.insertNodes(action.editor, fragment, {
-      at: nextPath
+    const adjustedSelection = Range.transform(currentSelection, {
+      type: "move_node",
+      path: focusBlockPath,
+      newPath: [focusBlockPath[0] + 1]
     });
-    const [nextBlock, nextBlockPath] = Editor.node(action.editor, Path.next(focusPath), {
-      depth: 1
-    }), nextChild = Node.child(nextBlock, 0);
-    !action.editor.isTextSpan(nextChild) && Transforms.insertNodes(action.editor, {
-      _key: context.keyGenerator(),
-      _type: "span",
-      text: "",
-      marks: []
-    }, {
-      at: [nextBlockPath[0], 0]
-    }), Transforms.select(action.editor, {
-      anchor: {
-        path: [nextPath[0], 0],
-        offset: 0
-      },
-      focus: {
-        path: [nextPath[0], 0],
-        offset: 0
+    adjustedSelection ? Transforms.select(editor, adjustedSelection) : Transforms.select(editor, currentSelection), select === "start" ? Transforms.select(editor, Editor.start(editor, focusBlockPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, focusBlockPath));
+  } else if (placement === "after") {
+    const nextPath = [focusBlockPath[0] + 1], currentSelection = editor.selection;
+    Transforms.insertNodes(editor, [block], {
+      at: nextPath,
+      select: !1
+    }), Transforms.select(editor, currentSelection), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
+  } else {
+    const currentSelection = editor.selection, focusBlockStartPoint = Editor.start(editor, focusBlockPath);
+    if (editor.isTextBlock(focusBlock) && editor.isTextBlock(block)) {
+      if (select === "end") {
+        Transforms.insertFragment(editor, [block], {
+          voids: !0
+        });
+        return;
       }
-    });
+      Transforms.insertFragment(editor, [block], {
+        at: currentSelection,
+        voids: !0
+      }), select === "start" ? Point.equals(currentSelection.anchor, focusBlockStartPoint) ? Transforms.select(editor, Editor.start(editor, focusBlockPath)) : Transforms.select(editor, currentSelection) : Point.equals(currentSelection.anchor, focusBlockStartPoint) || Transforms.select(editor, currentSelection);
+    } else if (editor.isTextBlock(focusBlock)) {
+      const focusBlockStartPoint2 = Editor.start(editor, focusBlockPath), focusBlockEndPoint = Editor.end(editor, focusBlockPath);
+      if (Point.equals(currentSelection.anchor, focusBlockStartPoint2))
+        Transforms.insertNodes(editor, [block], {
+          at: focusBlockPath,
+          select: !1
+        }), (select === "start" || select === "end") && Transforms.select(editor, Editor.start(editor, focusBlockPath)), isEqualToEmptyEditor([focusBlock], schema) && Transforms.removeNodes(editor, {
+          at: Path.next(focusBlockPath)
+        });
+      else if (Point.equals(currentSelection.focus, focusBlockEndPoint)) {
+        const nextPath = [focusBlockPath[0] + 1];
+        Transforms.insertNodes(editor, [block], {
+          at: nextPath,
+          select: !1
+        }), (select === "start" || select === "end") && Transforms.select(editor, Editor.start(editor, nextPath));
+      } else {
+        const currentSelection2 = editor.selection, [focusChild] = getFocusChild({
+          editor
+        });
+        if (focusChild && editor.isTextSpan(focusChild))
+          Transforms.insertFragment(editor, [block], {
+            at: currentSelection2
+          }), select === "start" || select === "end" ? Transforms.select(editor, [focusBlockPath[0] + 1]) : Transforms.select(editor, currentSelection2);
+        else {
+          const nextPath = [focusBlockPath[0] + 1];
+          Transforms.insertNodes(editor, [block], {
+            at: nextPath,
+            select: !1
+          }), Transforms.select(editor, currentSelection2), select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
+        }
+      }
+    } else {
+      Transforms.insertNodes(editor, [block], {
+        select: !1
+      });
+      const nextPath = [focusBlockPath[0] + 1];
+      select === "start" ? Transforms.select(editor, Editor.start(editor, nextPath)) : select === "end" && Transforms.select(editor, Editor.end(editor, nextPath));
+    }
+  }
+}
+const selectActionImplementation = ({
+  action
+}) => {
+  const newSelection = toSlateRange(action.selection, action.editor);
+  newSelection ? Transforms.select(action.editor, newSelection) : Transforms.deselect(action.editor);
+}, selectNextBlockActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection) {
+    console.error("Unable to select previous block without a selection");
     return;
   }
-  if (action.editor.isTextBlock(focusBlock) && action.editor.isTextBlock(fragment[0])) {
-    const {
-      markDefs
-    } = focusBlock;
-    isEqual(markDefs, fragment[0].markDefs) || Transforms.setNodes(action.editor, {
-      markDefs: uniq([...fragment[0].markDefs || [], ...markDefs || []])
-    }, {
-      at: focusPath,
-      mode: "lowest",
-      voids: !1
-    });
+  const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1], position = action.select === "end" ? Editor.end(action.editor, nextBlockPath) : Editor.start(action.editor, nextBlockPath), newSelection = toPortableTextRange(action.editor.children, {
+    anchor: position,
+    focus: position
+  }, context.schema);
+  if (!newSelection) {
+    console.error("Could not find selection for next block");
+    return;
   }
-  isEqualToEmptyEditor(action.editor.children, context.schema) ? (Transforms.splitNodes(action.editor, {
-    at: [0, 0]
-  }), action.editor.insertFragment(fragment), Transforms.removeNodes(action.editor, {
-    at: [0]
-  })) : action.editor.insertFragment(fragment);
-}, insertInlineObjectActionImplementation = ({
+  selectActionImplementation({
+    context,
+    action: {
+      type: "select",
+      selection: newSelection,
+      editor: action.editor
+    }
+  });
+}, selectPreviousBlockActionImplementation = ({
   context,
   action
 }) => {
-  if (!context.schema.inlineObjects.some((inlineObject) => inlineObject.name === action.inlineObject.name)) {
-    console.error("Unable to insert unknown inline object");
+  if (!action.editor.selection) {
+    console.error("Unable to select previous block without a selection");
     return;
   }
-  if (!action.editor.selection) {
-    console.error("Unable to insert inline object without selection");
+  const blockPath = action.editor.selection.focus.path.slice(0, 1);
+  if (!Path.hasPrevious(blockPath)) {
+    console.error("There's no previous block to select");
     return;
   }
-  const [focusTextBlock] = Array.from(Editor.nodes(action.editor, {
-    at: action.editor.selection.focus.path,
-    match: (node) => action.editor.isTextBlock(node)
-  })).at(0) ?? [void 0, void 0];
-  if (!focusTextBlock) {
-    console.error("Unable to perform action without focus text block");
+  const position = action.select === "end" ? Editor.end(action.editor, Path.previous(blockPath)) : Editor.start(action.editor, Path.previous(blockPath)), newSelection = toPortableTextRange(action.editor.children, {
+    anchor: position,
+    focus: position
+  }, context.schema);
+  if (!newSelection) {
+    console.error("Could not find selection for previous block");
     return;
   }
-  const child = toSlateValue([{
-    _type: context.schema.block.name,
-    _key: context.keyGenerator(),
-    children: [{
-      _type: action.inlineObject.name,
-      _key: context.keyGenerator(),
-      ...action.inlineObject.value ?? {}
-    }]
-  }], {
-    schemaTypes: context.schema
-  }).at(0)?.children.at(0);
+  selectActionImplementation({
+    context,
+    action: {
+      type: "select",
+      selection: newSelection,
+      editor: action.editor
+    }
+  });
+}, insertBlocksActionImplementation = ({
+  context,
+  action
+}) => {
+  const parsedBlocks = parseBlocks({
+    context,
+    blocks: action.blocks,
+    options: {
+      refreshKeys: !1
+    }
+  });
+  if (parsedBlocks.length === 0)
+    throw new Error(`Failed to parse blocks ${JSON.stringify(action.blocks)}`);
+  const fragment = toSlateValue(parsedBlocks, {
+    schemaTypes: context.schema
+  });
+  if (fragment.length === 0)
+    throw new Error(`Failed to convert blocks to Slate fragment ${JSON.stringify(parsedBlocks)}`);
+  const [focusBlock] = getFocusBlock({
+    editor: action.editor
+  });
+  if (action.placement === "before") {
+    let index = 0;
+    for (const block of fragment)
+      insertBlock({
+        block,
+        placement: index === 0 ? "before" : "after",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      }), index++;
+  } else if (action.placement === "after")
+    for (const block of fragment)
+      insertBlock({
+        block,
+        placement: "after",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      });
+  else if (focusBlock && action.editor.isTextBlock(focusBlock)) {
+    if (fragment.length === 1) {
+      insertBlock({
+        block: fragment[0],
+        placement: "auto",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      });
+      return;
+    }
+    let index = 0;
+    for (const block of fragment)
+      index === 0 ? (insertBreakActionImplementation({
+        context,
+        action: {
+          type: "insert.break",
+          editor: action.editor
+        }
+      }), selectPreviousBlockActionImplementation({
+        context,
+        action: {
+          type: "select.previous block",
+          editor: action.editor,
+          select: "end"
+        }
+      }), insertBlock({
+        block,
+        placement: "auto",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      })) : index === fragment.length - 1 ? (selectNextBlockActionImplementation({
+        context,
+        action: {
+          type: "select.next block",
+          editor: action.editor,
+          select: "start"
+        }
+      }), insertBlock({
+        block,
+        placement: "auto",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      })) : insertBlock({
+        block,
+        placement: "after",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      }), index++;
+  } else
+    for (const block of fragment)
+      insertBlock({
+        block,
+        placement: "auto",
+        select: "end",
+        editor: action.editor,
+        schema: context.schema
+      });
+}, deserializationSuccessActionImplementation = ({
+  context,
+  action
+}) => {
+  insertBlocksActionImplementation({
+    context,
+    action: {
+      type: "insert.blocks",
+      blocks: action.data,
+      editor: action.editor,
+      placement: "auto"
+    }
+  });
+}, effectActionImplementation = ({
+  action
+}) => {
+  action.effect();
+}, focusActionImplementation = ({
+  action
+}) => {
+  ReactEditor.focus(action.editor);
+}, insertInlineObjectActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!context.schema.inlineObjects.some((inlineObject) => inlineObject.name === action.inlineObject.name)) {
+    console.error("Unable to insert unknown inline object");
+    return;
+  }
+  if (!action.editor.selection) {
+    console.error("Unable to insert inline object without selection");
+    return;
+  }
+  const [focusTextBlock] = Array.from(Editor.nodes(action.editor, {
+    at: action.editor.selection.focus.path,
+    match: (node) => action.editor.isTextBlock(node)
+  })).at(0) ?? [void 0, void 0];
+  if (!focusTextBlock) {
+    console.error("Unable to perform action without focus text block");
+    return;
+  }
+  const child = toSlateValue([{
+    _type: context.schema.block.name,
+    _key: context.keyGenerator(),
+    children: [{
+      _type: action.inlineObject.name,
+      _key: context.keyGenerator(),
+      ...action.inlineObject.value ?? {}
+    }]
+  }], {
+    schemaTypes: context.schema
+  }).at(0)?.children.at(0);
   if (!child) {
     console.error("Unable to insert inline object");
     return;
@@ -4483,29 +4778,140 @@ const blockSetBehaviorActionImplementation = ({
     text: action.text,
     marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
   });
-}, insertBlockActionImplementation = ({
+}, insertBlockObjectActionImplementation = ({
   context,
   action
 }) => {
-  const parsedBlock = parseBlock({
-    block: action.block,
+  insertBlockActionImplementation({
     context,
-    options: {
-      refreshKeys: !1
+    action: {
+      type: "insert.block",
+      block: {
+        _key: context.keyGenerator(),
+        _type: action.blockObject.name,
+        ...action.blockObject.value ? action.blockObject.value : {}
+      },
+      editor: action.editor,
+      placement: action.placement
     }
   });
-  if (!parsedBlock)
-    throw new Error(`Failed to parse block ${JSON.stringify(action.block)}`);
-  const fragment = toSlateValue([parsedBlock], {
-    schemaTypes: context.schema
-  })[0];
-  if (!fragment)
-    throw new Error(`Failed to convert block to Slate fragment ${JSON.stringify(parsedBlock)}`);
-  insertBlock({
-    block: fragment,
-    placement: action.placement,
-    editor: action.editor,
-    schema: context.schema
+}, insertTextActionImplementation = ({
+  action
+}) => {
+  action.editor.insertText(action.text);
+}, insertTextBlockActionImplementation = ({
+  context,
+  action
+}) => {
+  insertBlockActionImplementation({
+    context,
+    action: {
+      type: "insert.block",
+      block: {
+        _key: context.keyGenerator(),
+        _type: context.schema.block.name,
+        children: action.textBlock?.children?.map((child) => ({
+          ...child,
+          _key: context.keyGenerator()
+        })) ?? [{
+          _type: context.schema.span.name,
+          _key: context.keyGenerator(),
+          text: "",
+          marks: []
+        }],
+        markDefs: [],
+        style: context.schema.styles[0].value ?? "normal"
+      },
+      editor: action.editor,
+      placement: action.placement,
+      select: "start"
+    }
+  });
+}, moveBlockActionImplementation = ({
+  action
+}) => {
+  const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
+  Transforms.moveNodes(action.editor, {
+    at,
+    to,
+    mode: "highest"
+  });
+}, moveBlockDownActionImplementation = ({
+  context,
+  action
+}) => {
+  const at = [toSlatePath(action.at, action.editor)[0]], to = [Path.next(at)[0]], selection = toPortableTextRange(action.editor.children, {
+    anchor: {
+      path: to,
+      offset: 0
+    },
+    focus: {
+      path: to,
+      offset: 0
+    }
+  }, context.schema), destinationBlockKey = selection && isKeyedSegment$1(selection.focus.path[0]) ? selection.focus.path[0]._key : void 0;
+  if (destinationBlockKey === void 0) {
+    console.error("Could not find destination block key");
+    return;
+  }
+  moveBlockActionImplementation({
+    context,
+    action: {
+      type: "move.block",
+      at: action.at,
+      to: [{
+        _key: destinationBlockKey
+      }],
+      editor: action.editor
+    }
+  });
+}, moveBlockUpActionImplementation = ({
+  context,
+  action
+}) => {
+  const at = [toSlatePath(action.at, action.editor)[0]];
+  if (!Path.hasPrevious(at))
+    return;
+  const to = [Path.previous(at)[0]], selection = toPortableTextRange(action.editor.children, {
+    anchor: {
+      path: to,
+      offset: 0
+    },
+    focus: {
+      path: to,
+      offset: 0
+    }
+  }, context.schema), destinationBlockKey = selection && isKeyedSegment$1(selection.focus.path[0]) ? selection.focus.path[0]._key : void 0;
+  if (destinationBlockKey === void 0) {
+    console.error("Could not find destination block key");
+    return;
+  }
+  moveBlockActionImplementation({
+    context,
+    action: {
+      type: "move.block",
+      at: action.at,
+      to: [{
+        _key: destinationBlockKey
+      }],
+      editor: action.editor
+    }
+  });
+}, noopActionImplementation = () => {
+}, serializationFailureActionImplementation = ({
+  action
+}) => {
+  console.warn(`Serialization of ${action.mimeType} failed with reason "${action.reason}"`);
+}, serializationSuccessActionImplementation = ({
+  context,
+  action
+}) => {
+  dataTransferSetActionImplementation({
+    context,
+    action: {
+      ...action,
+      type: "data transfer.set"
+    }
   });
 }, behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
@@ -4513,72 +4919,19 @@ const blockSetBehaviorActionImplementation = ({
   "annotation.toggle": toggleAnnotationActionImplementation,
   "block.set": blockSetBehaviorActionImplementation,
   "block.unset": blockUnsetBehaviorActionImplementation,
-  blur: ({
-    action
-  }) => {
-    ReactEditor.blur(action.editor);
-  },
+  blur: blurActionImplementation,
   "data transfer.set": dataTransferSetActionImplementation,
   "decorator.add": decoratorAddActionImplementation,
   "decorator.remove": removeDecoratorActionImplementation,
   "decorator.toggle": toggleDecoratorActionImplementation,
-  focus: ({
-    action
-  }) => {
-    ReactEditor.focus(action.editor);
-  },
+  focus: focusActionImplementation,
   delete: deleteActionImplementation,
-  "delete.backward": ({
-    action
-  }) => {
-    action.editor.deleteBackward(action.unit);
-  },
-  "delete.forward": ({
-    action
-  }) => {
-    deleteForward(action.editor, action.unit);
-  },
-  "delete.block": ({
-    action
-  }) => {
-    const range = toSlateRange({
-      anchor: {
-        path: action.blockPath,
-        offset: 0
-      },
-      focus: {
-        path: action.blockPath,
-        offset: 0
-      }
-    }, action.editor);
-    if (!range) {
-      console.error("Unable to find Slate range from selection points");
-      return;
-    }
-    Transforms.removeNodes(action.editor, {
-      at: range
-    });
-  },
+  "delete.backward": deleteBackwardActionImplementation,
+  "delete.forward": deleteForwardActionImplementation,
+  "delete.block": deleteBlockActionImplementation,
   "delete.text": deleteTextActionImplementation,
-  "deserialization.failure": ({
-    action
-  }) => {
-    console.warn(`Deserialization of ${action.mimeType} failed with reason "${action.reason}"`);
-  },
-  "deserialization.success": ({
-    context,
-    action
-  }) => {
-    insertBlocksActionImplementation({
-      context,
-      action: {
-        type: "insert.blocks",
-        blocks: action.data,
-        editor: action.editor,
-        placement: "auto"
-      }
-    });
-  },
+  "deserialization.failure": deserializationFailureActionImplementation,
+  "deserialization.success": deserializationSuccessActionImplementation,
   "history.redo": historyRedoActionImplementation,
   "history.undo": historyUndoActionImplementation,
   "insert.block": insertBlockActionImplementation,
@@ -4588,129 +4941,21 @@ const blockSetBehaviorActionImplementation = ({
   "insert.inline object": insertInlineObjectActionImplementation,
   "insert.soft break": insertSoftBreakActionImplementation,
   "insert.span": insertSpanActionImplementation,
-  "insert.text": ({
-    action
-  }) => {
-    insertText(action.editor, action.text);
-  },
-  "insert.text block": ({
-    context,
-    action
-  }) => {
-    const block = toSlateValue([{
-      _key: context.keyGenerator(),
-      _type: context.schema.block.name,
-      style: context.schema.styles[0].value ?? "normal",
-      markDefs: [],
-      children: action.textBlock?.children?.map((child) => ({
-        ...child,
-        _key: context.keyGenerator()
-      })) ?? [{
-        _type: context.schema.span.name,
-        _key: context.keyGenerator(),
-        text: ""
-      }]
-    }], {
-      schemaTypes: context.schema
-    })[0];
-    insertBlock({
-      block,
-      editor: action.editor,
-      schema: context.schema,
-      placement: action.placement
-    });
-  },
-  effect: ({
-    action
-  }) => {
-    action.effect();
-  },
+  "insert.text": insertTextActionImplementation,
+  "insert.text block": insertTextBlockActionImplementation,
+  effect: effectActionImplementation,
   "list item.add": addListItemActionImplementation,
   "list item.remove": removeListItemActionImplementation,
   "list item.toggle": toggleListItemActionImplementation,
-  "move.block": ({
-    action
-  }) => {
-    const at = [toSlatePath(action.at, action.editor)[0]], to = [toSlatePath(action.to, action.editor)[0]];
-    Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  "move.block down": ({
-    action
-  }) => {
-    const at = [toSlatePath(action.at, action.editor)[0]], to = [Path.next(at)[0]];
-    Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  "move.block up": ({
-    action
-  }) => {
-    const at = [toSlatePath(action.at, action.editor)[0]];
-    if (!Path.hasPrevious(at))
-      return;
-    const to = [Path.previous(at)[0]];
-    Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  noop: () => {
-  },
-  select: ({
-    action
-  }) => {
-    const newSelection = toSlateRange(action.selection, action.editor);
-    newSelection ? Transforms.select(action.editor, newSelection) : Transforms.deselect(action.editor);
-  },
-  "select.previous block": ({
-    action
-  }) => {
-    if (!action.editor.selection) {
-      console.error("Unable to select previous block without a selection");
-      return;
-    }
-    const blockPath = action.editor.selection.focus.path.slice(0, 1);
-    if (!Path.hasPrevious(blockPath)) {
-      console.error("There's no previous block to select");
-      return;
-    }
-    const previousBlockPath = Path.previous(blockPath);
-    Transforms.select(action.editor, previousBlockPath);
-  },
-  "select.next block": ({
-    action
-  }) => {
-    if (!action.editor.selection) {
-      console.error("Unable to select next block without a selection");
-      return;
-    }
-    const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1];
-    Transforms.select(action.editor, nextBlockPath);
-  },
-  "serialization.failure": ({
-    action
-  }) => {
-    console.warn(`Serialization of ${action.mimeType} failed with reason "${action.reason}"`);
-  },
-  "serialization.success": ({
-    context,
-    action
-  }) => {
-    dataTransferSetActionImplementation({
-      context,
-      action: {
-        ...action,
-        type: "data transfer.set"
-      }
-    });
-  },
+  "move.block": moveBlockActionImplementation,
+  "move.block down": moveBlockDownActionImplementation,
+  "move.block up": moveBlockUpActionImplementation,
+  noop: noopActionImplementation,
+  select: selectActionImplementation,
+  "select.previous block": selectPreviousBlockActionImplementation,
+  "select.next block": selectNextBlockActionImplementation,
+  "serialization.failure": serializationFailureActionImplementation,
+  "serialization.success": serializationSuccessActionImplementation,
   "style.toggle": toggleStyleActionImplementation,
   "style.add": addStyleActionImplementation,
   "style.remove": removeStyleActionImplementation
@@ -4718,27 +4963,6 @@ const blockSetBehaviorActionImplementation = ({
 function performAction({
   context,
   action
-}) {
-  switch (action.type) {
-    case "noop":
-      break;
-    case "effect": {
-      behaviorActionImplementations.effect({
-        context,
-        action
-      });
-      break;
-    }
-    default:
-      performDefaultAction({
-        context,
-        action
-      });
-  }
-}
-function performDefaultAction({
-  context,
-  action
 }) {
   switch (action.type) {
     case "annotation.add": {
@@ -4860,6 +5084,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "effect": {
+      behaviorActionImplementations.effect({
+        context,
+        action
+      });
+      break;
+    }
     case "focus": {
       behaviorActionImplementations.focus({
         context,
@@ -4986,6 +5217,8 @@ function performDefaultAction({
       });
       break;
     }
+    case "noop":
+      break;
     case "select": {
       behaviorActionImplementations.select({
         context,
@@ -5091,12 +5324,10 @@ function createWithEventListeners(editorActor, subscriptions) {
     });
     const {
       deleteBackward,
-      deleteForward: deleteForward2,
+      deleteForward,
       insertBreak,
-      insertData,
       insertText: insertText2,
-      select,
-      setFragmentData
+      select
     } = editor;
     return editor.deleteBackward = (unit) => {
       if (isApplyingBehaviorActions(editor)) {
@@ -5113,7 +5344,7 @@ function createWithEventListeners(editorActor, subscriptions) {
       });
     }, editor.deleteForward = (unit) => {
       if (isApplyingBehaviorActions(editor)) {
-        deleteForward2(unit);
+        deleteForward(unit);
         return;
       }
       editorActor.send({
@@ -5136,19 +5367,8 @@ function createWithEventListeners(editorActor, subscriptions) {
         },
         editor
       });
-    }, editor.insertData = (dataTransfer) => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertData(dataTransfer);
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "deserialize",
-          dataTransfer
-        },
-        editor
-      });
+    }, editor.insertData = () => {
+      console.warn("Unexpected call to .insertData(...)");
     }, editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
         insertSoftBreakActionImplementation({
@@ -5225,20 +5445,8 @@ function createWithEventListeners(editorActor, subscriptions) {
           select(location);
         }
       });
-    }, editor.setFragmentData = (dataTransfer, originEvent) => {
-      if (isApplyingBehaviorActions(editor)) {
-        setFragmentData(dataTransfer);
-        return;
-      }
-      dataTransfer.clearData(), editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "serialize",
-          dataTransfer,
-          originEvent: originEvent ?? "unknown"
-        },
-        editor
-      });
+    }, editor.setFragmentData = () => {
+      console.warn("Unexpected call to .setFragmentData(...)");
     }, editor.undo = () => {
       if (isApplyingBehaviorActions(editor)) {
         performAction({
@@ -6069,16 +6277,8 @@ const keyIs = {
     event
   }, deserializeEvent) => [raise({
     ...deserializeEvent,
-    dataTransfer: event.dataTransfer
-  })]]
-}), raiseInsertBlocks = defineBehavior({
-  on: "deserialization.success",
-  actions: [({
-    event
-  }) => [raise({
-    type: "insert.blocks",
-    blocks: event.data,
-    placement: "auto"
+    dataTransfer: event.dataTransfer,
+    originEvent: event.originEvent
   })]]
 }), raiseSerializationSuccessOrFailure = defineBehavior({
   on: "serialize",
@@ -6090,7 +6290,10 @@ const keyIs = {
       return !1;
     const serializeEvents = snapshot.context.converters.map((converter) => converter.serialize({
       snapshot,
-      event
+      event: {
+        ...event,
+        originEvent: event.originEvent.type
+      }
     }));
     return serializeEvents.length === 0 ? !1 : serializeEvents;
   },
@@ -6098,9 +6301,69 @@ const keyIs = {
     event
   }, serializeEvents) => serializeEvents.map((serializeEvent) => raise({
     ...serializeEvent,
+    originEvent: event.originEvent,
     dataTransfer: event.dataTransfer
   }))]
-}), raiseDataTransferSet = defineBehavior({
+}), defaultBehaviors = [defineBehavior({
+  on: "copy",
+  guard: ({
+    snapshot
+  }) => {
+    const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+    return focusSpan && selectionCollapsed;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), defineBehavior({
+  on: "copy",
+  actions: [({
+    event
+  }) => [raise({
+    type: "serialize",
+    dataTransfer: event.data,
+    originEvent: event
+  })]]
+}), defineBehavior({
+  on: "cut",
+  guard: ({
+    snapshot
+  }) => {
+    const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+    return focusSpan && selectionCollapsed;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), defineBehavior({
+  on: "cut",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [raise({
+    type: "serialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  }), raise({
+    type: "delete",
+    selection
+  })]]
+}), defineBehavior({
+  on: "drag.dragstart",
+  actions: [({
+    event
+  }) => [raise({
+    type: "serialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  })]]
+}), defineBehavior({
   on: "serialization.success",
   actions: [({
     event
@@ -6110,23 +6373,129 @@ const keyIs = {
     dataTransfer: event.dataTransfer,
     mimeType: event.mimeType
   })]]
-}), defaultBehaviors = [toggleAnnotationOff, toggleAnnotationOn, toggleDecoratorOff, toggleDecoratorOn, toggleListItemOff, toggleListItemOn, toggleStyleOff, toggleStyleOn, raiseDeserializationSuccessOrFailure, raiseInsertBlocks, raiseSerializationSuccessOrFailure, raiseDataTransferSet, raiseInsertSoftBreak];
-function getActiveDecorators({
-  schema,
-  slateEditorInstance
-}) {
-  const decorators = schema.decorators.map((decorator) => decorator.value);
-  return ({
-    ...Editor.marks(slateEditorInstance) ?? {}
-  }.marks ?? []).filter((mark) => decorators.includes(mark));
-}
+}), defineBehavior({
+  on: "drag.drop",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
+    return dragOrigin ? isOverlappingSelection(dropPosition)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }) : !1;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), defineBehavior({
+  on: "drag.drop",
+  actions: [({
+    event
+  }) => [raise({
+    type: "deserialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  })]]
+}), defineBehavior({
+  on: "deserialization.success",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (event.originEvent.type !== "drag.drop" || snapshot.beta.internalDrag === void 0)
+      return !1;
+    const dragOrigin = snapshot.beta.internalDrag.origin, dropPosition = event.originEvent.position.selection, droppingOnDragOrigin = dragOrigin ? isOverlappingSelection(dropPosition)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }) : !1, draggingEntireBlocks = isSelectingEntireBlocks({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }), draggedBlocks = getSelectedBlocks({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    });
+    return droppingOnDragOrigin ? !1 : {
+      draggingEntireBlocks,
+      draggedBlocks,
+      dragOrigin
+    };
+  },
+  actions: [({
+    event
+  }, {
+    draggingEntireBlocks,
+    draggedBlocks,
+    dragOrigin
+  }) => [raise({
+    type: "insert.blocks",
+    blocks: event.data,
+    placement: draggingEntireBlocks ? event.originEvent.position.block === "start" ? "before" : event.originEvent.position.block === "end" ? "after" : "auto" : "auto"
+  }), ...draggingEntireBlocks ? draggedBlocks.map((block) => raise({
+    type: "delete.block",
+    blockPath: block.path
+  })) : [raise({
+    type: "delete",
+    selection: dragOrigin.selection
+  })]]]
+}), defineBehavior({
+  on: "deserialization.success",
+  actions: [({
+    event
+  }) => [raise({
+    type: "insert.blocks",
+    blocks: event.data,
+    placement: "auto"
+  })]]
+}), defineBehavior({
+  on: "paste",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection && isSelectionExpanded(snapshot) ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [raise({
+    type: "delete",
+    selection
+  }), raise({
+    type: "deserialize",
+    dataTransfer: event.data,
+    originEvent: event
+  })]]
+}), defineBehavior({
+  on: "paste",
+  actions: [({
+    event
+  }) => [raise({
+    type: "deserialize",
+    dataTransfer: event.data,
+    originEvent: event
+  })]]
+}), toggleAnnotationOff, toggleAnnotationOn, toggleDecoratorOff, toggleDecoratorOn, toggleListItemOff, toggleListItemOn, toggleStyleOff, toggleStyleOn, raiseDeserializationSuccessOrFailure, raiseSerializationSuccessOrFailure, raiseInsertSoftBreak];
 function createEditorSnapshot({
   converters,
   editor,
   keyGenerator,
   readOnly,
   schema,
-  hasTag
+  hasTag,
+  internalDrag
 }) {
   const value = fromSlateValue(editor.children, schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), selection = toPortableTextRange(value, editor.selection, schema);
   return {
@@ -6143,7 +6512,8 @@ function createEditorSnapshot({
       value
     },
     beta: {
-      hasTag
+      hasTag,
+      internalDrag
     }
   };
 }
@@ -6225,10 +6595,10 @@ const editorMachine = setup({
       self
     }) => {
       assertEvent(event, ["behavior event", "custom behavior event"]);
-      const defaultAction = event.type === "custom behavior event" || event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "deserialize" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" || event.behaviorEvent.type === "serialize" ? void 0 : {
+      const defaultAction = event.type === "custom behavior event" || isDragBehaviorEvent(event.behaviorEvent) || event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "cut" || event.behaviorEvent.type === "deserialize" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || isMouseBehaviorEvent(event.behaviorEvent) || event.behaviorEvent.type === "paste" || event.behaviorEvent.type === "serialize" ? void 0 : {
         ...event.behaviorEvent,
         editor: event.editor
-      }, defaultActionCallback = event.type === "behavior event" ? event.defaultActionCallback : void 0, eventBehaviors = [...context.behaviors.values(), ...defaultBehaviors].filter((behavior) => behavior.on === "*" || behavior.on === event.behaviorEvent.type);
+      }, defaultActionCallback = event.type === "behavior event" ? event.defaultActionCallback : void 0, eventBehaviors = [...context.behaviors.values(), ...defaultBehaviors].filter((behavior) => behavior.on === "*" ? !0 : isDragBehaviorEvent(event.behaviorEvent) && behavior.on === "drag.*" || behavior.on === event.behaviorEvent.type);
       if (eventBehaviors.length === 0) {
         if (defaultActionCallback) {
           withApplyingBehaviorActions(event.editor, () => {
@@ -6265,7 +6635,8 @@ const editorMachine = setup({
           "edit mode": "read only"
         }),
         schema: context.schema,
-        hasTag: (tag) => self.getSnapshot().hasTag(tag)
+        hasTag: (tag) => self.getSnapshot().hasTag(tag),
+        internalDrag: context.internalDrag
       });
       let behaviorOverwritten = !1;
       for (const eventBehavior of eventBehaviors) {
@@ -6613,11 +6984,26 @@ const editorMachine = setup({
             idle: {
               on: {
                 dragstart: {
+                  actions: [assign({
+                    internalDrag: ({
+                      event
+                    }) => ({
+                      ghost: event.ghost,
+                      origin: event.origin
+                    })
+                  })],
                   target: "dragging internally"
                 }
               }
             },
             "dragging internally": {
+              exit: [({
+                context
+              }) => {
+                context.internalDrag?.ghost && document.body.removeChild(context.internalDrag.ghost);
+              }, assign({
+                internalDrag: void 0
+              })],
               tags: ["dragging internally"],
               on: {
                 dragend: {
@@ -6697,53 +7083,6 @@ const editorMachine = setup({
     }
   }
 });
-function getValue({
-  editorActorSnapshot,
-  slateEditorInstance
-}) {
-  return fromSlateValue(slateEditorInstance.children, editorActorSnapshot.context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(slateEditorInstance));
-}
-function defaultCompare(a, b) {
-  return a === b;
-}
-function useEditorSelector(editor, selector, t0) {
-  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
-  let t1;
-  return $[0] !== editor._internal.slateEditor.instance || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
-    const snapshot = getEditorSnapshot({
-      editorActorSnapshot,
-      slateEditorInstance: editor._internal.slateEditor.instance
-    });
-    return selector(snapshot);
-  }, $[0] = editor._internal.slateEditor.instance, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
-}
-function getEditorSnapshot({
-  editorActorSnapshot,
-  slateEditorInstance
-}) {
-  return {
-    context: {
-      converters: [...editorActorSnapshot.context.converters],
-      activeDecorators: getActiveDecorators({
-        schema: editorActorSnapshot.context.schema,
-        slateEditorInstance
-      }),
-      keyGenerator: editorActorSnapshot.context.keyGenerator,
-      readOnly: editorActorSnapshot.matches({
-        "edit mode": "read only"
-      }),
-      schema: editorActorSnapshot.context.schema,
-      selection: editorActorSnapshot.context.selection,
-      value: getValue({
-        editorActorSnapshot,
-        slateEditorInstance
-      })
-    },
-    beta: {
-      hasTag: (tag) => editorActorSnapshot.hasTag(tag)
-    }
-  };
-}
 function createEditor(config) {
   const editorActor = createActor(editorMachine, {
     input: editorConfigToMachineInput(config)
@@ -6820,7 +7159,7 @@ function createEditorFromActor(editorActor) {
     }
   };
 }
-const EditorActorContext = createContext({}), PortableTextEditorSelectionContext = createContext(null), usePortableTextEditorSelection = () => {
+const PortableTextEditorSelectionContext = createContext(null), usePortableTextEditorSelection = () => {
   const selection = useContext(PortableTextEditorSelectionContext);
   if (selection === void 0)
     throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
@@ -7390,21 +7729,17 @@ function useEditor() {
 export {
   EditorActorContext,
   EditorProvider,
-  IS_DRAGGING,
-  IS_DRAGGING_BLOCK_ELEMENT,
-  IS_DRAGGING_BLOCK_TARGET_POSITION,
-  IS_DRAGGING_ELEMENT_TARGET,
   KEY_TO_VALUE_ELEMENT,
   PortableTextEditor,
   debugWithName,
   defaultKeyGenerator,
   defineSchema,
   fromSlateValue,
+  getEditorSnapshot,
   isEqualToEmptyEditor,
   moveRangeByOperation,
   toPortableTextRange,
   toSlateRange,
-  toSlateValue,
   useEditor,
   useEditorSelector,
   usePortableTextEditor,