@portabletext/editor 1.36.6 → 1.38.0

package/lib/_chunks-cjs/editor-provider.cjs

@@ -1,5 +1,5 @@
 "use strict";
-var jsxRuntime = require("react/jsx-runtime"), reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$e = require("debug"), isEqual = require("lodash/isEqual.js"), slate = require("slate"), xstate = require("xstate"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), getRandomValues = require("get-random-values-esm"), util_blockOffsetsToSelection = require("./util.block-offsets-to-selection.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), selector_isActiveStyle = require("./selector.is-active-style.cjs"), omit = require("lodash/omit.js"), startCase = require("lodash.startcase"), behavior_core = require("./behavior.core.cjs"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event");
+var jsxRuntime = require("react/jsx-runtime"), reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$e = require("debug"), isEqual = require("lodash/isEqual.js"), slate = require("slate"), xstate = require("xstate"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), getRandomValues = require("get-random-values-esm"), parseBlocks = require("./parse-blocks.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), selector_isOverlappingSelection = require("./selector.is-overlapping-selection.cjs"), omit = require("lodash/omit.js"), slateDom = require("slate-dom"), startCase = require("lodash.startcase"), behavior_core = require("./behavior.core.cjs"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -307,7 +307,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 && slate.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 && slate.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 = React.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 = React.createContext({});
+function getActiveDecorators({
+  schema: schema2,
+  slateEditorInstance
+}) {
+  const decorators = schema2.decorators.map((decorator) => decorator.value);
+  return ({
+    ...slate.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 $ = reactCompilerRuntime.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], react.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 = React.createContext(null), usePortableTextEditor = () => {
   const editor = React.useContext(PortableTextEditorContext);
   if (!editor)
     throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
@@ -2401,7 +2459,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",
@@ -2410,7 +2469,7 @@ const converterJson = {
       };
     const blocks = util_sliceBlocks.sliceBlocks({
       blocks: snapshot.context.value,
-      selection: snapshot.context.selection
+      selection
     });
     return {
       type: "serialization.success",
@@ -2431,7 +2490,7 @@ const converterJson = {
         reason: "Data is not an array"
       };
     const parsedBlocks = blocks.flatMap((block) => {
-      const parsedBlock = util_blockOffsetsToSelection.parseBlock({
+      const parsedBlock = parseBlocks.parseBlock({
         context: snapshot.context,
         block,
         options: {
@@ -2460,7 +2519,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",
@@ -2469,7 +2529,7 @@ const converterJson = {
       };
     const blocks = util_sliceBlocks.sliceBlocks({
       blocks: snapshot.context.value,
-      selection: snapshot.context.selection
+      selection
     }), html = toHtml.toHTML(blocks, {
       onMissingComponent: !1,
       components: {
@@ -2513,21 +2573,24 @@ const converterJson = {
   serialize: ({
     snapshot,
     event
-  }) => snapshot.context.selection ? {
-    type: "serialization.success",
-    data: util_sliceBlocks.sliceBlocks({
-      blocks: snapshot.context.value,
-      selection: snapshot.context.selection
-    }).map((block) => types.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: util_sliceBlocks.sliceBlocks({
+        blocks: snapshot.context.value,
+        selection
+      }).map((block) => types.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,
@@ -2791,7 +2854,8 @@ const insertBreakActionImplementation = ({
   const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
     slate.Transforms.splitNodes(editor, {
-      at: editor.selection
+      at: editor.selection,
+      always: !0
     });
     const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
       depth: 1
@@ -3026,21 +3090,23 @@ const decoratorAddActionImplementation = ({
       split: !0,
       hanging: !0
     });
-    const newValue = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), newSelection = util_blockOffsetsToSelection.blockOffsetsToSelection({
+    const newValue = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), newSelection = parseBlocks.blockOffsetsToSelection({
       value: newValue,
       offsets: {
         anchor: anchorOffset,
         focus: focusOffset
       },
       backward: editorSelection?.backward
-    }), trimmedSelection = selector_isActiveStyle.getTrimmedSelection({
+    }), trimmedSelection = selector_isOverlappingSelection.getTrimmedSelection({
       beta: {
-        hasTag: () => !1
+        hasTag: () => !1,
+        internalDrag: void 0
       },
       context: {
         activeDecorators: [],
         converters: [],
         keyGenerator: context.keyGenerator,
+        readOnly: !1,
         schema: context.schema,
         selection: newSelection,
         value: newValue
@@ -4073,49 +4139,7 @@ const addAnnotationActionImplementation = ({
         editor: action.editor
       }
     });
-};
-function insertBlock({
-  block,
-  placement,
-  editor,
-  schema: schema2
-}) {
-  if (editor.selection) {
-    const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(editor, {
-      at: editor.selection.focus.path.slice(0, 1),
-      match: (n) => !slate.Editor.isEditor(n)
-    }))[0] ?? [void 0, void 0];
-    if (placement === "after") {
-      const nextPath = [focusBlockPath[0] + 1];
-      slate.Transforms.insertNodes(editor, block, {
-        at: nextPath
-      }), slate.Transforms.select(editor, {
-        anchor: {
-          path: [nextPath[0], 0],
-          offset: 0
-        },
-        focus: {
-          path: [nextPath[0], 0],
-          offset: 0
-        }
-      });
-    } else placement === "before" ? slate.Transforms.insertNodes(editor, block, {
-      at: focusBlockPath
-    }) : (slate.Editor.insertNode(editor, block), focusBlock && isEqualToEmptyEditor([focusBlock], schema2) && slate.Transforms.removeNodes(editor, {
-      at: focusBlockPath
-    }));
-  } else {
-    const lastBlock = Array.from(slate.Editor.nodes(editor, {
-      match: (n) => !slate.Editor.isEditor(n),
-      at: [],
-      reverse: !0
-    }))[0];
-    slate.Editor.insertNode(editor, block), lastBlock && isEqualToEmptyEditor([lastBlock[0]], schema2) && slate.Transforms.removeNodes(editor, {
-      at: lastBlock[1]
-    });
-  }
-}
-const blockSetBehaviorActionImplementation = ({
+}, blockSetBehaviorActionImplementation = ({
   context,
   action
 }) => {
@@ -4142,7 +4166,7 @@ const blockSetBehaviorActionImplementation = ({
   const {
     _type,
     ...filteredProps
-  } = action.props, updatedBlock = util_blockOffsetsToSelection.parseBlock({
+  } = action.props, updatedBlock = parseBlocks.parseBlock({
     context,
     block: {
       ...parsedBlock,
@@ -4186,8 +4210,8 @@ const blockSetBehaviorActionImplementation = ({
   const parsedBlock = fromSlateValue([block], context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)).at(0);
   if (!parsedBlock)
     throw new Error(`Unable to parse block at ${JSON.stringify(action.at)}`);
-  if (util_blockOffsetsToSelection.isTextBlock(context.schema, parsedBlock)) {
-    const propsToRemove = action.props.filter((prop) => prop !== "_type"), updatedTextBlock = util_blockOffsetsToSelection.parseBlock({
+  if (parseBlocks.isTextBlock(context.schema, parsedBlock)) {
+    const propsToRemove = action.props.filter((prop) => prop !== "_type"), updatedTextBlock = parseBlocks.parseBlock({
       context,
       block: omit__default.default(parsedBlock, propsToRemove),
       options: {
@@ -4204,7 +4228,7 @@ const blockSetBehaviorActionImplementation = ({
     });
     return;
   }
-  const updatedBlockObject = util_blockOffsetsToSelection.parseBlock({
+  const updatedBlockObject = parseBlocks.parseBlock({
     context,
     block: omit__default.default(parsedBlock, action.props.filter((prop) => prop !== "_type")),
     options: {
@@ -4225,6 +4249,10 @@ const blockSetBehaviorActionImplementation = ({
   }, {
     at: location
   });
+}, blurActionImplementation = ({
+  action
+}) => {
+  slateReact.ReactEditor.blur(action.editor);
 }, dataTransferSetActionImplementation = ({
   action
 }) => {
@@ -4235,12 +4263,42 @@ const blockSetBehaviorActionImplementation = ({
   const range = toSlateRange(action.selection, action.editor);
   if (!range)
     throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`);
-  slate.select(action.editor, range), slate.deleteFragment(action.editor);
+  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;
+  }
+  slate.Transforms.removeNodes(action.editor, {
+    at: range
+  });
+}, deleteForwardActionImplementation = ({
+  action
+}) => {
+  action.editor.deleteForward(action.unit);
 }, deleteTextActionImplementation = ({
   context,
   action
 }) => {
-  const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), selection = util_blockOffsetsToSelection.blockOffsetsToSelection({
+  const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), selection = parseBlocks.blockOffsetsToSelection({
     value,
     offsets: {
       anchor: action.anchor,
@@ -4249,15 +4307,17 @@ const blockSetBehaviorActionImplementation = ({
   });
   if (!selection)
     throw new Error("Unable to find selection from block offsets");
-  const trimmedSelection = selector_isActiveStyle.getTrimmedSelection({
+  const trimmedSelection = selector_isOverlappingSelection.getTrimmedSelection({
     beta: {
-      hasTag: () => !1
+      hasTag: () => !1,
+      internalDrag: void 0
     },
     context: {
       converters: [],
       schema: context.schema,
       keyGenerator: context.keyGenerator,
       activeDecorators: [],
+      readOnly: !1,
       value,
       selection
     }
@@ -4270,176 +4330,563 @@ const blockSetBehaviorActionImplementation = ({
   slate.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(slate.Editor.nodes(editor, {
+    at: editor.selection.focus.path.slice(0, 1),
+    match: (n) => !slate.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 = slate.Node.child(focusBlock, childIndex);
+  return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
+}
+function getLastBlock({
+  editor
+}) {
+  return Array.from(slate.Editor.nodes(editor, {
+    match: (n) => !slate.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 = parseBlocks.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: slate.Editor.start(action.editor, [])
-      });
-      return;
-    }
-    if (action.placement === "after") {
-      action.editor.insertFragment(fragment, {
-        at: slate.Editor.end(action.editor, [])
-      });
-      return;
-    }
-    action.editor.insertFragment(fragment);
-    return;
-  }
-  const [focusBlock, focusPath] = slate.Editor.node(action.editor, action.editor.selection, {
-    depth: 1
+};
+function insertBlock({
+  block,
+  placement,
+  select,
+  editor,
+  schema: schema2
+}) {
+  const [focusBlock, focusBlockPath] = getFocusBlock({
+    editor
   });
-  if (action.placement === "before" && focusPath) {
-    slate.Transforms.insertNodes(action.editor, fragment, {
-      at: focusPath
+  if (!editor.selection || !focusBlock || !focusBlockPath) {
+    select !== "none" && slateDom.DOMEditor.focus(editor);
+    const [lastBlock, lastBlockPath] = getLastBlock({
+      editor
     });
-    return;
-  }
-  if (action.placement === "after" && focusPath) {
-    const nextPath = [focusPath[0] + 1];
-    slate.Transforms.insertNodes(action.editor, fragment, {
-      at: nextPath
-    }), slate.Transforms.select(action.editor, {
-      anchor: {
-        path: [nextPath[0], 0],
-        offset: 0
-      },
-      focus: {
-        path: [nextPath[0], 0],
-        offset: 0
+    if (placement === "before")
+      slate.Transforms.insertNodes(editor, [block], {
+        at: [0]
+      }), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, [0])) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, [0]));
+    else if (placement === "after") {
+      const nextPath = lastBlockPath ? [lastBlockPath[0] + 1] : [0];
+      slate.Transforms.insertNodes(editor, [block], {
+        at: nextPath,
+        select: !1
+      }), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, nextPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, nextPath));
+    } else {
+      if (lastBlock && isEqualToEmptyEditor([lastBlock], schema2)) {
+        slate.Transforms.removeNodes(editor, {
+          at: lastBlockPath
+        }), slate.Transforms.insertNodes(editor, [block], {
+          at: lastBlockPath,
+          select: !1
+        }), slate.Transforms.deselect(editor), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, lastBlockPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, lastBlockPath));
+        return;
+      }
+      if (editor.isTextBlock(block) && lastBlock && editor.isTextBlock(lastBlock)) {
+        const selectionBefore = slate.Editor.end(editor, lastBlockPath);
+        slate.Transforms.insertFragment(editor, [block], {
+          at: slate.Editor.end(editor, lastBlockPath)
+        }), select === "start" ? slate.Transforms.select(editor, selectionBefore) : select === "none" && slate.Transforms.deselect(editor);
+        return;
       }
+      const nextPath = lastBlockPath ? [lastBlockPath[0] + 1] : [0];
+      slate.Transforms.insertNodes(editor, [block], {
+        at: nextPath,
+        select: !1
+      }), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, nextPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, nextPath));
+    }
+  } else if (placement === "before") {
+    const currentSelection = editor.selection;
+    slate.Transforms.insertNodes(editor, [block], {
+      at: focusBlockPath,
+      select: !1
     });
-    return;
-  }
-  if (action.editor.isTextBlock(focusBlock) && action.editor.isTextBlock(fragment[0])) {
-    const {
-      markDefs
-    } = focusBlock;
-    isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(action.editor, {
-      markDefs: uniq__default.default([...fragment[0].markDefs || [], ...markDefs || []])
-    }, {
-      at: focusPath,
-      mode: "lowest",
-      voids: !1
+    const adjustedSelection = slate.Range.transform(currentSelection, {
+      type: "move_node",
+      path: focusBlockPath,
+      newPath: [focusBlockPath[0] + 1]
     });
+    adjustedSelection ? slate.Transforms.select(editor, adjustedSelection) : slate.Transforms.select(editor, currentSelection), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, focusBlockPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, focusBlockPath));
+  } else if (placement === "after") {
+    const nextPath = [focusBlockPath[0] + 1], currentSelection = editor.selection;
+    slate.Transforms.insertNodes(editor, [block], {
+      at: nextPath,
+      select: !1
+    }), slate.Transforms.select(editor, currentSelection), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, nextPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, nextPath));
+  } else {
+    const currentSelection = editor.selection, focusBlockStartPoint = slate.Editor.start(editor, focusBlockPath);
+    if (editor.isTextBlock(focusBlock) && editor.isTextBlock(block)) {
+      if (select === "end") {
+        slate.Transforms.insertFragment(editor, [block], {
+          voids: !0
+        });
+        return;
+      }
+      slate.Transforms.insertFragment(editor, [block], {
+        at: currentSelection,
+        voids: !0
+      }), select === "start" ? slate.Point.equals(currentSelection.anchor, focusBlockStartPoint) ? slate.Transforms.select(editor, slate.Editor.start(editor, focusBlockPath)) : slate.Transforms.select(editor, currentSelection) : slate.Point.equals(currentSelection.anchor, focusBlockStartPoint) || slate.Transforms.select(editor, currentSelection);
+    } else if (editor.isTextBlock(focusBlock)) {
+      const focusBlockStartPoint2 = slate.Editor.start(editor, focusBlockPath), focusBlockEndPoint = slate.Editor.end(editor, focusBlockPath);
+      if (slate.Point.equals(currentSelection.anchor, focusBlockStartPoint2))
+        slate.Transforms.insertNodes(editor, [block], {
+          at: focusBlockPath,
+          select: !1
+        }), (select === "start" || select === "end") && slate.Transforms.select(editor, slate.Editor.start(editor, focusBlockPath)), isEqualToEmptyEditor([focusBlock], schema2) && slate.Transforms.removeNodes(editor, {
+          at: slate.Path.next(focusBlockPath)
+        });
+      else if (slate.Point.equals(currentSelection.focus, focusBlockEndPoint)) {
+        const nextPath = [focusBlockPath[0] + 1];
+        slate.Transforms.insertNodes(editor, [block], {
+          at: nextPath,
+          select: !1
+        }), (select === "start" || select === "end") && slate.Transforms.select(editor, slate.Editor.start(editor, nextPath));
+      } else {
+        const currentSelection2 = editor.selection, [focusChild] = getFocusChild({
+          editor
+        });
+        if (focusChild && editor.isTextSpan(focusChild))
+          slate.Transforms.insertFragment(editor, [block], {
+            at: currentSelection2
+          }), select === "start" || select === "end" ? slate.Transforms.select(editor, [focusBlockPath[0] + 1]) : slate.Transforms.select(editor, currentSelection2);
+        else {
+          const nextPath = [focusBlockPath[0] + 1];
+          slate.Transforms.insertNodes(editor, [block], {
+            at: nextPath,
+            select: !1
+          }), slate.Transforms.select(editor, currentSelection2), select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, nextPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, nextPath));
+        }
+      }
+    } else {
+      slate.Transforms.insertNodes(editor, [block], {
+        select: !1
+      });
+      const nextPath = [focusBlockPath[0] + 1];
+      select === "start" ? slate.Transforms.select(editor, slate.Editor.start(editor, nextPath)) : select === "end" && slate.Transforms.select(editor, slate.Editor.end(editor, nextPath));
+    }
   }
-  isEqualToEmptyEditor(action.editor.children, context.schema) ? (slate.Transforms.splitNodes(action.editor, {
-    at: [0, 0]
-  }), action.editor.insertFragment(fragment), slate.Transforms.removeNodes(action.editor, {
-    at: [0]
-  })) : action.editor.insertFragment(fragment);
-}, insertInlineObjectActionImplementation = ({
+}
+const selectActionImplementation = ({
+  action
+}) => {
+  const newSelection = toSlateRange(action.selection, action.editor);
+  newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
+}, selectNextBlockActionImplementation = ({
   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(slate.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");
+    console.error("Unable to select previous block without a selection");
     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");
+  const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1], position = action.select === "end" ? slate.Editor.end(action.editor, nextBlockPath) : slate.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;
   }
-  slate.Transforms.insertNodes(action.editor, child);
-}, insertSpanActionImplementation = ({
+  selectActionImplementation({
+    context,
+    action: {
+      type: "select",
+      selection: newSelection,
+      editor: action.editor
+    }
+  });
+}, selectPreviousBlockActionImplementation = ({
   context,
   action
 }) => {
   if (!action.editor.selection) {
-    console.error("Unable to perform action without selection", action);
+    console.error("Unable to select previous block without a selection");
     return;
   }
-  const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(action.editor, {
-    at: action.editor.selection.focus.path,
-    match: (node) => action.editor.isTextBlock(node)
-  }))[0] ?? [void 0, void 0];
-  if (!focusBlock || !focusBlockPath) {
-    console.error("Unable to perform action without focus block", action);
+  const blockPath = action.editor.selection.focus.path.slice(0, 1);
+  if (!slate.Path.hasPrevious(blockPath)) {
+    console.error("There's no previous block to select");
     return;
   }
-  const markDefs = focusBlock.markDefs ?? [], annotations = action.annotations ? action.annotations.map((annotation) => ({
-    _type: annotation.name,
-    _key: context.keyGenerator(),
-    ...annotation.value
-  })) : void 0;
-  annotations && annotations.length > 0 && slate.Transforms.setNodes(action.editor, {
-    markDefs: [...markDefs, ...annotations]
-  }), slate.Transforms.insertNodes(action.editor, {
-    _type: "span",
-    _key: context.keyGenerator(),
-    text: action.text,
-    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
-  });
-}, insertBlockActionImplementation = ({
-  context,
-  action
-}) => {
-  const parsedBlock = util_blockOffsetsToSelection.parseBlock({
-    block: action.block,
+  const position = action.select === "end" ? slate.Editor.end(action.editor, slate.Path.previous(blockPath)) : slate.Editor.start(action.editor, slate.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;
+  }
+  selectActionImplementation({
     context,
+    action: {
+      type: "select",
+      selection: newSelection,
+      editor: action.editor
+    }
+  });
+}, insertBlocksActionImplementation = ({
+  context,
+  action
+}) => {
+  const parsedBlocks = parseBlocks.parseBlocks({
+    context,
+    blocks: action.blocks,
     options: {
       refreshKeys: !1
     }
   });
-  if (!parsedBlock)
-    throw new Error(`Failed to parse block ${JSON.stringify(action.block)}`);
-  const fragment = toSlateValue([parsedBlock], {
+  if (parsedBlocks.length === 0)
+    throw new Error(`Failed to parse blocks ${JSON.stringify(action.blocks)}`);
+  const fragment = toSlateValue(parsedBlocks, {
     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
+  });
+  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
+}) => {
+  slateReact.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(slate.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;
+  }
+  slate.Transforms.insertNodes(action.editor, child);
+}, insertSpanActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection) {
+    console.error("Unable to perform action without selection", action);
+    return;
+  }
+  const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(action.editor, {
+    at: action.editor.selection.focus.path,
+    match: (node) => action.editor.isTextBlock(node)
+  }))[0] ?? [void 0, void 0];
+  if (!focusBlock || !focusBlockPath) {
+    console.error("Unable to perform action without focus block", action);
+    return;
+  }
+  const markDefs = focusBlock.markDefs ?? [], annotations = action.annotations ? action.annotations.map((annotation) => ({
+    _type: annotation.name,
+    _key: context.keyGenerator(),
+    ...annotation.value
+  })) : void 0;
+  annotations && annotations.length > 0 && slate.Transforms.setNodes(action.editor, {
+    markDefs: [...markDefs, ...annotations]
+  }), slate.Transforms.insertNodes(action.editor, {
+    _type: "span",
+    _key: context.keyGenerator(),
+    text: action.text,
+    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
+  });
+}, insertBlockObjectActionImplementation = ({
+  context,
+  action
+}) => {
+  insertBlockActionImplementation({
+    context,
+    action: {
+      type: "insert.block",
+      block: {
+        _key: context.keyGenerator(),
+        _type: action.blockObject.name,
+        ...action.blockObject.value ? action.blockObject.value : {}
+      },
+      editor: action.editor,
+      placement: action.placement
+    }
+  });
+}, 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]];
+  slate.Transforms.moveNodes(action.editor, {
+    at,
+    to,
+    mode: "highest"
+  });
+}, moveBlockDownActionImplementation = ({
+  context,
+  action
+}) => {
+  const at = [toSlatePath(action.at, action.editor)[0]], to = [slate.Path.next(at)[0]], selection = toPortableTextRange(action.editor.children, {
+    anchor: {
+      path: to,
+      offset: 0
+    },
+    focus: {
+      path: to,
+      offset: 0
+    }
+  }, context.schema), destinationBlockKey = selection && util_sliceBlocks.isKeyedSegment(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 (!slate.Path.hasPrevious(at))
+    return;
+  const to = [slate.Path.previous(at)[0]], selection = toPortableTextRange(action.editor.children, {
+    anchor: {
+      path: to,
+      offset: 0
+    },
+    focus: {
+      path: to,
+      offset: 0
+    }
+  }, context.schema), destinationBlockKey = selection && util_sliceBlocks.isKeyedSegment(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,
@@ -4447,72 +4894,19 @@ const blockSetBehaviorActionImplementation = ({
   "annotation.toggle": toggleAnnotationActionImplementation,
   "block.set": blockSetBehaviorActionImplementation,
   "block.unset": blockUnsetBehaviorActionImplementation,
-  blur: ({
-    action
-  }) => {
-    slateReact.ReactEditor.blur(action.editor);
-  },
+  blur: blurActionImplementation,
   "data transfer.set": dataTransferSetActionImplementation,
   "decorator.add": decoratorAddActionImplementation,
   "decorator.remove": removeDecoratorActionImplementation,
   "decorator.toggle": toggleDecoratorActionImplementation,
-  focus: ({
-    action
-  }) => {
-    slateReact.ReactEditor.focus(action.editor);
-  },
+  focus: focusActionImplementation,
   delete: deleteActionImplementation,
-  "delete.backward": ({
-    action
-  }) => {
-    action.editor.deleteBackward(action.unit);
-  },
-  "delete.forward": ({
-    action
-  }) => {
-    slate.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;
-    }
-    slate.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,
@@ -4522,129 +4916,21 @@ const blockSetBehaviorActionImplementation = ({
   "insert.inline object": insertInlineObjectActionImplementation,
   "insert.soft break": insertSoftBreakActionImplementation,
   "insert.span": insertSpanActionImplementation,
-  "insert.text": ({
-    action
-  }) => {
-    slate.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]];
-    slate.Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  "move.block down": ({
-    action
-  }) => {
-    const at = [toSlatePath(action.at, action.editor)[0]], to = [slate.Path.next(at)[0]];
-    slate.Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  "move.block up": ({
-    action
-  }) => {
-    const at = [toSlatePath(action.at, action.editor)[0]];
-    if (!slate.Path.hasPrevious(at))
-      return;
-    const to = [slate.Path.previous(at)[0]];
-    slate.Transforms.moveNodes(action.editor, {
-      at,
-      to,
-      mode: "highest"
-    });
-  },
-  noop: () => {
-  },
-  select: ({
-    action
-  }) => {
-    const newSelection = toSlateRange(action.selection, action.editor);
-    newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.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 (!slate.Path.hasPrevious(blockPath)) {
-      console.error("There's no previous block to select");
-      return;
-    }
-    const previousBlockPath = slate.Path.previous(blockPath);
-    slate.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];
-    slate.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
@@ -4652,27 +4938,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": {
@@ -4794,6 +5059,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "effect": {
+      behaviorActionImplementations.effect({
+        context,
+        action
+      });
+      break;
+    }
     case "focus": {
       behaviorActionImplementations.focus({
         context,
@@ -4920,6 +5192,8 @@ function performDefaultAction({
       });
       break;
     }
+    case "noop":
+      break;
     case "select": {
       behaviorActionImplementations.select({
         context,
@@ -5027,10 +5301,8 @@ function createWithEventListeners(editorActor, subscriptions) {
       deleteBackward,
       deleteForward,
       insertBreak,
-      insertData,
       insertText,
-      select,
-      setFragmentData
+      select
     } = editor;
     return editor.deleteBackward = (unit) => {
       if (isApplyingBehaviorActions(editor)) {
@@ -5070,19 +5342,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({
@@ -5159,20 +5420,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({
@@ -5886,7 +6135,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => selector_isActiveStyle.isActiveAnnotation(event.annotation.name)(snapshot),
+  }) => selector_isOverlappingSelection.isActiveAnnotation(event.annotation.name)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5898,7 +6147,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => !selector_isActiveStyle.isActiveAnnotation(event.annotation.name)(snapshot),
+  }) => !selector_isOverlappingSelection.isActiveAnnotation(event.annotation.name)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5910,7 +6159,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => selector_isActiveStyle.isActiveDecorator(event.decorator)(snapshot),
+  }) => selector_isOverlappingSelection.isActiveDecorator(event.decorator)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5922,7 +6171,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => !selector_isActiveStyle.isActiveDecorator(event.decorator)(snapshot),
+  }) => !selector_isOverlappingSelection.isActiveDecorator(event.decorator)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5934,7 +6183,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => selector_isActiveStyle.isActiveListItem(event.listItem)(snapshot),
+  }) => selector_isOverlappingSelection.isActiveListItem(event.listItem)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5946,7 +6195,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => !selector_isActiveStyle.isActiveListItem(event.listItem)(snapshot),
+  }) => !selector_isOverlappingSelection.isActiveListItem(event.listItem)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5958,7 +6207,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => selector_isActiveStyle.isActiveStyle(event.style)(snapshot),
+  }) => selector_isOverlappingSelection.isActiveStyle(event.style)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -5970,7 +6219,7 @@ const keyIs = {
   guard: ({
     snapshot,
     event
-  }) => !selector_isActiveStyle.isActiveStyle(event.style)(snapshot),
+  }) => !selector_isOverlappingSelection.isActiveStyle(event.style)(snapshot),
   actions: [({
     event
   }) => [behavior_core.raise({
@@ -6003,16 +6252,8 @@ const keyIs = {
     event
   }, deserializeEvent) => [behavior_core.raise({
     ...deserializeEvent,
-    dataTransfer: event.dataTransfer
-  })]]
-}), raiseInsertBlocks = behavior_core.defineBehavior({
-  on: "deserialization.success",
-  actions: [({
-    event
-  }) => [behavior_core.raise({
-    type: "insert.blocks",
-    blocks: event.data,
-    placement: "auto"
+    dataTransfer: event.dataTransfer,
+    originEvent: event.originEvent
   })]]
 }), raiseSerializationSuccessOrFailure = behavior_core.defineBehavior({
   on: "serialize",
@@ -6024,7 +6265,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;
   },
@@ -6032,9 +6276,69 @@ const keyIs = {
     event
   }, serializeEvents) => serializeEvents.map((serializeEvent) => behavior_core.raise({
     ...serializeEvent,
+    originEvent: event.originEvent,
     dataTransfer: event.dataTransfer
   }))]
-}), raiseDataTransferSet = behavior_core.defineBehavior({
+}), defaultBehaviors = [behavior_core.defineBehavior({
+  on: "copy",
+  guard: ({
+    snapshot
+  }) => {
+    const focusSpan = selector_isAtTheStartOfBlock.getFocusSpan(snapshot), selectionCollapsed = selector_isAtTheStartOfBlock.isSelectionCollapsed(snapshot);
+    return focusSpan && selectionCollapsed;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), behavior_core.defineBehavior({
+  on: "copy",
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "serialize",
+    dataTransfer: event.data,
+    originEvent: event
+  })]]
+}), behavior_core.defineBehavior({
+  on: "cut",
+  guard: ({
+    snapshot
+  }) => {
+    const focusSpan = selector_isAtTheStartOfBlock.getFocusSpan(snapshot), selectionCollapsed = selector_isAtTheStartOfBlock.isSelectionCollapsed(snapshot);
+    return focusSpan && selectionCollapsed;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), behavior_core.defineBehavior({
+  on: "cut",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [behavior_core.raise({
+    type: "serialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  }), behavior_core.raise({
+    type: "delete",
+    selection
+  })]]
+}), behavior_core.defineBehavior({
+  on: "drag.dragstart",
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "serialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  })]]
+}), behavior_core.defineBehavior({
   on: "serialization.success",
   actions: [({
     event
@@ -6044,22 +6348,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: schema2,
-  slateEditorInstance
-}) {
-  const decorators = schema2.decorators.map((decorator) => decorator.value);
-  return ({
-    ...slate.Editor.marks(slateEditorInstance) ?? {}
-  }.marks ?? []).filter((mark) => decorators.includes(mark));
-}
+}), behavior_core.defineBehavior({
+  on: "drag.drop",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
+    return dragOrigin ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }) : !1;
+  },
+  actions: [() => [{
+    type: "noop"
+  }]]
+}), behavior_core.defineBehavior({
+  on: "drag.drop",
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "deserialize",
+    dataTransfer: event.dataTransfer,
+    originEvent: event
+  })]]
+}), behavior_core.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 ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }) : !1, draggingEntireBlocks = selector_isOverlappingSelection.isSelectingEntireBlocks({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    }), draggedBlocks = selector_isAtTheStartOfBlock.getSelectedBlocks({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: dragOrigin.selection
+      }
+    });
+    return droppingOnDragOrigin ? !1 : {
+      draggingEntireBlocks,
+      draggedBlocks,
+      dragOrigin
+    };
+  },
+  actions: [({
+    event
+  }, {
+    draggingEntireBlocks,
+    draggedBlocks,
+    dragOrigin
+  }) => [behavior_core.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) => behavior_core.raise({
+    type: "delete.block",
+    blockPath: block.path
+  })) : [behavior_core.raise({
+    type: "delete",
+    selection: dragOrigin.selection
+  })]]]
+}), behavior_core.defineBehavior({
+  on: "deserialization.success",
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "insert.blocks",
+    blocks: event.data,
+    placement: "auto"
+  })]]
+}), behavior_core.defineBehavior({
+  on: "paste",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection && selector_isAtTheStartOfBlock.isSelectionExpanded(snapshot) ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [behavior_core.raise({
+    type: "delete",
+    selection
+  }), behavior_core.raise({
+    type: "deserialize",
+    dataTransfer: event.data,
+    originEvent: event
+  })]]
+}), behavior_core.defineBehavior({
+  on: "paste",
+  actions: [({
+    event
+  }) => [behavior_core.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: schema2,
-  hasTag
+  hasTag,
+  internalDrag
 }) {
   const value = fromSlateValue(editor.children, schema2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), selection = toPortableTextRange(value, editor.selection, schema2);
   return {
@@ -6070,12 +6481,14 @@ function createEditorSnapshot({
       }),
       converters,
       keyGenerator,
+      readOnly,
       schema: schema2,
       selection,
       value
     },
     beta: {
-      hasTag
+      hasTag,
+      internalDrag
     }
   };
 }
@@ -6157,10 +6570,10 @@ const editorMachine = xstate.setup({
       self
     }) => {
       xstate.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" || behavior_core.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" || behavior_core.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 : behavior_core.isDragBehaviorEvent(event.behaviorEvent) && behavior.on === "drag.*" || behavior.on === event.behaviorEvent.type);
       if (eventBehaviors.length === 0) {
         if (defaultActionCallback) {
           withApplyingBehaviorActions(event.editor, () => {
@@ -6177,7 +6590,10 @@ const editorMachine = xstate.setup({
         withApplyingBehaviorActions(event.editor, () => {
           try {
             performAction({
-              context,
+              context: {
+                keyGenerator: context.keyGenerator,
+                schema: context.schema
+              },
               action: defaultAction
             });
           } catch (error) {
@@ -6190,8 +6606,12 @@ const editorMachine = xstate.setup({
         converters: [...context.converters],
         editor: event.editor,
         keyGenerator: context.keyGenerator,
+        readOnly: self.getSnapshot().matches({
+          "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) {
@@ -6228,7 +6648,10 @@ const editorMachine = xstate.setup({
               };
               try {
                 performAction({
-                  context,
+                  context: {
+                    keyGenerator: context.keyGenerator,
+                    schema: context.schema
+                  },
                   action: internalAction
                 });
               } catch (error) {
@@ -6258,7 +6681,10 @@ const editorMachine = xstate.setup({
         withApplyingBehaviorActions(event.editor, () => {
           try {
             performAction({
-              context,
+              context: {
+                keyGenerator: context.keyGenerator,
+                schema: context.schema
+              },
               action: defaultAction
             });
           } catch (error) {
@@ -6533,11 +6959,26 @@ const editorMachine = xstate.setup({
             idle: {
               on: {
                 dragstart: {
+                  actions: [xstate.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);
+              }, xstate.assign({
+                internalDrag: void 0
+              })],
               tags: ["dragging internally"],
               on: {
                 dragend: {
@@ -6617,50 +7058,6 @@ const editorMachine = xstate.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 $ = reactCompilerRuntime.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], react.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,
-      schema: editorActorSnapshot.context.schema,
-      selection: editorActorSnapshot.context.selection,
-      value: getValue({
-        editorActorSnapshot,
-        slateEditorInstance
-      })
-    },
-    beta: {
-      hasTag: (tag) => editorActorSnapshot.hasTag(tag)
-    }
-  };
-}
 function createEditor(config) {
   const editorActor = xstate.createActor(editorMachine, {
     input: editorConfigToMachineInput(config)
@@ -6737,7 +7134,7 @@ function createEditorFromActor(editorActor) {
     }
   };
 }
-const EditorActorContext = React.createContext({}), PortableTextEditorSelectionContext = React.createContext(null), usePortableTextEditorSelection = () => {
+const PortableTextEditorSelectionContext = React.createContext(null), usePortableTextEditorSelection = () => {
   const selection = React.useContext(PortableTextEditorSelectionContext);
   if (selection === void 0)
     throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
@@ -7306,21 +7703,17 @@ function useEditor() {
 }
 exports.EditorActorContext = EditorActorContext;
 exports.EditorProvider = EditorProvider;
-exports.IS_DRAGGING = IS_DRAGGING;
-exports.IS_DRAGGING_BLOCK_ELEMENT = IS_DRAGGING_BLOCK_ELEMENT;
-exports.IS_DRAGGING_BLOCK_TARGET_POSITION = IS_DRAGGING_BLOCK_TARGET_POSITION;
-exports.IS_DRAGGING_ELEMENT_TARGET = IS_DRAGGING_ELEMENT_TARGET;
 exports.KEY_TO_VALUE_ELEMENT = KEY_TO_VALUE_ELEMENT;
 exports.PortableTextEditor = PortableTextEditor;
 exports.debugWithName = debugWithName;
 exports.defaultKeyGenerator = defaultKeyGenerator;
 exports.defineSchema = defineSchema;
 exports.fromSlateValue = fromSlateValue;
+exports.getEditorSnapshot = getEditorSnapshot;
 exports.isEqualToEmptyEditor = isEqualToEmptyEditor;
 exports.moveRangeByOperation = moveRangeByOperation;
 exports.toPortableTextRange = toPortableTextRange;
 exports.toSlateRange = toSlateRange;
-exports.toSlateValue = toSlateValue;
 exports.useEditor = useEditor;
 exports.useEditorSelector = useEditorSelector;
 exports.usePortableTextEditor = usePortableTextEditor;