@portabletext/editor 1.44.1 → 1.44.3

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$g from "debug";
 import isEqual from "lodash/isEqual.js";
-import { Editor, Element, Point, Range, Text, Node, Path, Operation, Transforms, insertText, createEditor } from "slate";
+import { Element, Text, Range, Editor, Node, Point, Path, Operation, Transforms, insertText, createEditor } from "slate";
 import { setup, stateIn, fromCallback, assign, enqueueActions, emit, assertEvent, 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";
@@ -14,7 +14,7 @@ import isPlainObject from "lodash/isPlainObject.js";
 import uniq from "lodash/uniq.js";
 import getRandomValues from "get-random-values-esm";
 import { parseBlock, isTextBlock } from "./parse-blocks.js";
-import { sliceBlocks, blockOffsetToSpanSelectionPoint, isKeyedSegment as isKeyedSegment$1, getBlockEndPoint, getBlockStartPoint, getTextBlockText } from "./util.slice-blocks.js";
+import { sliceBlocks, blockOffsetToSpanSelectionPoint, getBlockEndPoint, getBlockStartPoint, getTextBlockText } from "./util.slice-blocks.js";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
@@ -150,87 +150,6 @@ function debugWithName(name) {
   const namespace = `${rootName}${name}`;
   return debug$g && debug$g.enabled(namespace) ? debug$g(namespace) : debug$g(rootName);
 }
-function createKeyedPath(point, value, types) {
-  const blockPath = [point.path[0]];
-  if (!value)
-    return null;
-  const block = value[blockPath[0]];
-  if (!block)
-    return null;
-  const keyedBlockPath = [{
-    _key: block._key
-  }];
-  if (block._type !== types.block.name)
-    return keyedBlockPath;
-  let keyedChildPath;
-  const childPath = point.path.slice(0, 2), child = Array.isArray(block.children) && block.children[childPath[1]];
-  return child && (keyedChildPath = ["children", {
-    _key: child._key
-  }]), keyedChildPath ? [...keyedBlockPath, ...keyedChildPath] : keyedBlockPath;
-}
-function toSlatePath(path, editor) {
-  if (!editor)
-    return [];
-  const [block, blockPath] = Array.from(Editor.nodes(editor, {
-    at: [],
-    match: (n) => isKeySegment(path[0]) && n._key === path[0]._key
-  }))[0] || [void 0, void 0];
-  if (!block || !Element.isElement(block))
-    return [];
-  if (editor.isVoid(block))
-    return [blockPath[0], 0];
-  const childPath = [path[2]], childIndex = block.children.findIndex((child) => isEqual([{
-    _key: child._key
-  }], childPath));
-  if (childIndex >= 0 && block.children[childIndex]) {
-    const child = block.children[childIndex];
-    return Element.isElement(child) && editor.isVoid(child) ? blockPath.concat(childIndex).concat(0) : blockPath.concat(childIndex);
-  }
-  return [blockPath[0], 0];
-}
-function toPortableTextRange(value, range, types) {
-  if (!range)
-    return null;
-  let anchor = null, focus = null;
-  const anchorPath = range.anchor && createKeyedPath(range.anchor, value, types);
-  anchorPath && range.anchor && (anchor = {
-    path: anchorPath,
-    offset: range.anchor.offset
-  });
-  const focusPath = range.focus && createKeyedPath(range.focus, value, types);
-  focusPath && range.focus && (focus = {
-    path: focusPath,
-    offset: range.focus.offset
-  });
-  const backward = !!(Range.isRange(range) && Range.isBackward(range));
-  return anchor && focus ? {
-    anchor,
-    focus,
-    backward
-  } : null;
-}
-function toSlateRange(selection, editor) {
-  if (!selection || !editor)
-    return null;
-  const anchor = {
-    path: toSlatePath(selection.anchor.path, editor),
-    offset: selection.anchor.offset
-  }, focus = {
-    path: toSlatePath(selection.focus.path, editor),
-    offset: selection.focus.offset
-  };
-  return focus.path.length === 0 || anchor.path.length === 0 ? null : anchor && focus ? {
-    anchor,
-    focus
-  } : null;
-}
-function moveRangeByOperation(range, operation) {
-  const anchor = Point.transform(range.anchor, operation), focus = Point.transform(range.focus, operation);
-  return anchor === null || focus === null ? null : Point.equals(anchor, range.anchor) && Point.equals(focus, range.focus) ? range : {
-    anchor,
-    focus
-  };
-}
 const VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
   const value = keyMap[object._key];
@@ -341,10 +260,14 @@ function isEqualToEmptyEditor(children, schemaTypes) {
 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];
+  return editor.selection ? Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0] : [void 0, void 0];
+}
+function getPointBlock({
+  editor,
+  point
+}) {
+  const [block] = Editor.node(editor, point.path.slice(0, 1)) ?? [void 0, void 0];
+  return block ? [block, point.path] : [void 0, void 0];
 }
 function getFocusChild({
   editor
@@ -357,6 +280,23 @@ function getFocusChild({
   const focusChild = Node.child(focusBlock, childIndex);
   return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
 }
+function getPointChild({
+  editor,
+  point
+}) {
+  const [block, blockPath] = getPointBlock({
+    editor,
+    point
+  }), childIndex = point.path.at(1);
+  if (!block || !blockPath || childIndex === void 0)
+    return [void 0, void 0];
+  try {
+    const pointChild = Node.child(block, childIndex);
+    return pointChild ? [pointChild, [...blockPath, childIndex]] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
 function getFirstBlock({
   editor
 }) {
@@ -433,6 +373,89 @@ function isStyleActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
 }
+function slateRangeToSelection({
+  schema,
+  editor,
+  range
+}) {
+  const [anchorBlock] = getPointBlock({
+    editor,
+    point: range.anchor
+  }), [focusBlock] = getPointBlock({
+    editor,
+    point: range.focus
+  });
+  if (!anchorBlock || !focusBlock)
+    return null;
+  const [anchorChild] = anchorBlock._type === schema.block.name ? getPointChild({
+    editor,
+    point: range.anchor
+  }) : [void 0, void 0], [focusChild] = focusBlock._type === schema.block.name ? getPointChild({
+    editor,
+    point: range.focus
+  }) : [void 0, void 0], selection = {
+    anchor: {
+      path: [{
+        _key: anchorBlock._key
+      }],
+      offset: range.anchor.offset
+    },
+    focus: {
+      path: [{
+        _key: focusBlock._key
+      }],
+      offset: range.focus.offset
+    },
+    backward: Range.isBackward(range)
+  };
+  return anchorChild && (selection.anchor.path.push("children"), selection.anchor.path.push({
+    _key: anchorChild._key
+  })), focusChild && (selection.focus.path.push("children"), selection.focus.path.push({
+    _key: focusChild._key
+  })), selection;
+}
+function toSlatePath(path, editor) {
+  if (!editor)
+    return [];
+  const [block, blockPath] = Array.from(Editor.nodes(editor, {
+    at: [],
+    match: (n) => isKeySegment(path[0]) && n._key === path[0]._key
+  }))[0] || [void 0, void 0];
+  if (!block || !Element.isElement(block))
+    return [];
+  if (editor.isVoid(block))
+    return [blockPath[0], 0];
+  const childPath = [path[2]], childIndex = block.children.findIndex((child) => isEqual([{
+    _key: child._key
+  }], childPath));
+  if (childIndex >= 0 && block.children[childIndex]) {
+    const child = block.children[childIndex];
+    return Element.isElement(child) && editor.isVoid(child) ? blockPath.concat(childIndex).concat(0) : blockPath.concat(childIndex);
+  }
+  return [blockPath[0], 0];
+}
+function toSlateRange(selection, editor) {
+  if (!selection || !editor)
+    return null;
+  const anchor = {
+    path: toSlatePath(selection.anchor.path, editor),
+    offset: selection.anchor.offset
+  }, focus = {
+    path: toSlatePath(selection.focus.path, editor),
+    offset: selection.focus.offset
+  };
+  return focus.path.length === 0 || anchor.path.length === 0 ? null : anchor && focus ? {
+    anchor,
+    focus
+  } : null;
+}
+function moveRangeByOperation(range, operation) {
+  const anchor = Point.transform(range.anchor, operation), focus = Point.transform(range.focus, operation);
+  return anchor === null || focus === null ? null : Point.equals(anchor, range.anchor) && Point.equals(focus, range.focus) ? range : {
+    anchor,
+    focus
+  };
+}
 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({}), PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
   const editor = useContext(PortableTextEditorContext);
   if (!editor)
@@ -3575,7 +3598,11 @@ function createEditableAPI(editor, editorActor) {
             }
           },
           editor
-        }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? [];
+        }), editor.selection ? slateRangeToSelection({
+          schema: editorActor.getSnapshot().context.schema,
+          editor,
+          range: editor.selection
+        })?.focus.path ?? [] : [];
       if (!editor.selection)
         throw new Error("The editor has no selection");
       const [focusBlock] = Array.from(Editor.nodes(editor, {
@@ -3603,7 +3630,11 @@ function createEditableAPI(editor, editorActor) {
       })), Transforms.insertNodes(editor, child, {
         select: !0,
         at: editor.selection
-      }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path || [];
+      }), editor.onChange(), editor.selection ? slateRangeToSelection({
+        schema: editorActor.getSnapshot().context.schema,
+        editor,
+        range: editor.selection
+      })?.focus.path ?? [] : [];
     },
     insertBlock: (type, value) => (editorActor.send({
       type: "behavior event",
@@ -3616,7 +3647,11 @@ function createEditableAPI(editor, editorActor) {
         placement: "auto"
       },
       editor
-    }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? []),
+    }), editor.selection ? slateRangeToSelection({
+      schema: editorActor.getSnapshot().context.schema,
+      editor,
+      range: editor.selection
+    })?.focus.path ?? [] : []),
     hasBlockStyle: (style) => {
       try {
         return isStyleActive({
@@ -3774,7 +3809,11 @@ function createEditableAPI(editor, editorActor) {
         const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
         if (existing)
           return existing;
-        ptRange = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+        ptRange = slateRangeToSelection({
+          schema: editorActor.getSnapshot().context.schema,
+          editor,
+          range: editor.selection
+        }), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
       }
       return ptRange;
     },
@@ -4065,7 +4104,11 @@ const addAnnotationActionImplementation = ({
   } : void 0, selection = manualSelection ? toSlateRange(manualSelection, action.editor) ?? editor.selection : editor.selection;
   if (!selection)
     return;
-  const editorSelection = toPortableTextRange(value, selection, context.schema), anchorOffset = editorSelection ? selectionPointToBlockOffset({
+  const editorSelection = slateRangeToSelection({
+    schema: context.schema,
+    editor,
+    range: selection
+  }), anchorOffset = editorSelection ? selectionPointToBlockOffset({
     value,
     selectionPoint: editorSelection.anchor
   }) : void 0, focusOffset = editorSelection ? selectionPointToBlockOffset({
@@ -4452,63 +4495,6 @@ const insertTextActionImplementation = ({
     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({
-    action: {
-      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({
-    action: {
-      at: action.at,
-      to: [{
-        _key: destinationBlockKey
-      }],
-      editor: action.editor
-    }
-  });
 }, noopActionImplementation = () => {
 }, selectActionImplementation = ({
   action
@@ -4539,8 +4525,6 @@ const insertTextActionImplementation = ({
   "insert.text": insertTextActionImplementation,
   effect: effectActionImplementation,
   "move.block": moveBlockActionImplementation,
-  "move.block down": moveBlockDownActionImplementation,
-  "move.block up": moveBlockUpActionImplementation,
   noop: noopActionImplementation,
   select: selectActionImplementation
 };
@@ -4710,20 +4694,6 @@ function performAction({
       });
       break;
     }
-    case "move.block down": {
-      behaviorActionImplementations["move.block down"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "move.block up": {
-      behaviorActionImplementations["move.block up"]({
-        context,
-        action
-      });
-      break;
-    }
     case "noop":
       break;
     default: {
@@ -4735,65 +4705,10 @@ function performAction({
     }
   }
 }
-function createWithEventListeners(editorActor, subscriptions) {
+function createWithEventListeners(editorActor) {
   return function(editor) {
     if (editorActor.getSnapshot().context.maxBlocks !== void 0)
       return editor;
-    subscriptions.push(() => {
-      const subscription = editorActor.on("*", (event) => {
-        switch (event.type) {
-          // These events are not relevant for Behaviors
-          case "blurred":
-          case "done loading":
-          case "editable":
-          case "error":
-          case "focused":
-          case "invalid value":
-          case "loading":
-          case "mutation":
-          case "patch":
-          case "internal.patch":
-          case "patches":
-          case "read only":
-          case "ready":
-          case "selection":
-          case "value changed":
-          case "unset":
-            break;
-          case "custom.*":
-            editorActor.send({
-              type: "custom behavior event",
-              behaviorEvent: event.event,
-              editor
-            });
-            break;
-          case "insert.block object":
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "insert.block",
-                block: {
-                  _type: event.blockObject.name,
-                  ...event.blockObject.value ?? {}
-                },
-                placement: event.placement
-              },
-              editor
-            });
-            break;
-          default:
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: event,
-              editor
-            });
-            break;
-        }
-      });
-      return () => {
-        subscription.unsubscribe();
-      };
-    });
     const {
       deleteBackward,
       deleteForward,
@@ -4919,7 +4834,11 @@ function createWithEventListeners(editorActor, subscriptions) {
         type: "behavior event",
         behaviorEvent: {
           type: "select",
-          selection: toPortableTextRange(fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), range, editorActor.getSnapshot().context.schema)
+          selection: slateRangeToSelection({
+            schema: editorActor.getSnapshot().context.schema,
+            editor,
+            range
+          })
         },
         editor,
         defaultActionCallback: () => {
@@ -5476,7 +5395,7 @@ function createWithPortableTextBlockStyle(editorActor, types) {
   };
 }
 debugWithName("plugin:withPortableTextSelections");
-function createWithPortableTextSelections(editorActor, types) {
+function createWithPortableTextSelections(editorActor) {
   let prevSelection = null;
   return function(editor) {
     const emitPortableTextSelection = () => {
@@ -5484,12 +5403,11 @@ function createWithPortableTextSelections(editorActor, types) {
         let ptRange = null;
         if (editor.selection) {
           const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
-          if (existing)
-            ptRange = existing;
-          else {
-            const value = editor.children;
-            ptRange = toPortableTextRange(value, editor.selection, types), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
-          }
+          existing ? ptRange = existing : (ptRange = slateRangeToSelection({
+            schema: editorActor.getSnapshot().context.schema,
+            editor,
+            range: editor.selection
+          }), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange));
         }
         ptRange ? editorActor.send({
           type: "notify.selection",
@@ -5603,8 +5521,8 @@ const withPlugins = (editor, options) => {
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
     editorActor,
     schemaTypes
-  }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
-  return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
+  }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
+  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
 }, debug$3 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
 function createSlateEditor(config) {
   const existingSlateEditor = slateEditors.get(config.editorActor);
@@ -5626,17 +5544,7 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const keyIs = {
-  lineBreak: (event) => event.key === "Enter" && event.shiftKey
-}, raiseInsertSoftBreak = defineBehavior({
-  on: "keyboard.keydown",
-  guard: ({
-    event
-  }) => keyIs.lineBreak(event.originEvent),
-  actions: [() => [raise({
-    type: "insert.soft break"
-  })]]
-}), internalAnnotationBehaviors = [defineBehavior({
+const abstractAnnotationBehaviors = [defineBehavior({
   on: "annotation.toggle",
   guard: ({
     snapshot,
@@ -5660,7 +5568,7 @@ const keyIs = {
     type: "annotation.add",
     annotation: event.annotation
   })]]
-})], internalDecoratorBehaviors = [defineBehavior({
+})], abstractDecoratorBehaviors = [defineBehavior({
   on: "decorator.toggle",
   guard: ({
     snapshot,
@@ -5696,7 +5604,7 @@ const keyIs = {
     ...event,
     type: "decorator.add"
   })]]
-})], internalInsertBehaviors = [defineBehavior({
+})], abstractInsertBehaviors = [defineBehavior({
   on: "insert.blocks",
   guard: ({
     event
@@ -5772,7 +5680,7 @@ const keyIs = {
     placement: index === 0 ? "auto" : "after",
     select: "end"
   }))]
-})], internalListItemBehaviors = [defineBehavior({
+})], abstractListItemBehaviors = [defineBehavior({
   on: "list item.add",
   guard: ({
     snapshot
@@ -5829,7 +5737,75 @@ const keyIs = {
     type: "list item.add",
     listItem: event.listItem
   })]]
-})], internalSelectBehaviors = [defineBehavior({
+})], abstractMoveBehaviors = [defineBehavior({
+  on: "move.block up",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const previousBlock = getPreviousBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
+          },
+          focus: {
+            path: event.at,
+            offset: 0
+          }
+        }
+      }
+    });
+    return previousBlock ? {
+      previousBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    previousBlock
+  }) => [raise({
+    type: "move.block",
+    at: event.at,
+    to: previousBlock.path
+  })]]
+}), defineBehavior({
+  on: "move.block down",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const nextBlock = getNextBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
+          },
+          focus: {
+            path: event.at,
+            offset: 0
+          }
+        }
+      }
+    });
+    return nextBlock ? {
+      nextBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    nextBlock
+  }) => [raise({
+    type: "move.block",
+    at: event.at,
+    to: nextBlock.path
+  })]]
+})], abstractSelectBehaviors = [defineBehavior({
   on: "select.previous block",
   guard: ({
     snapshot,
@@ -5875,7 +5851,7 @@ const keyIs = {
     type: "select",
     selection
   })]]
-})], internalStyleBehaviors = [defineBehavior({
+})], abstractStyleBehaviors = [defineBehavior({
   on: "style.add",
   guard: ({
     snapshot
@@ -5931,7 +5907,17 @@ const keyIs = {
     type: "style.add",
     style: event.style
   })]]
-})], raiseDeserializationSuccessOrFailure = defineBehavior({
+})], keyIs = {
+  lineBreak: (event) => event.key === "Enter" && event.shiftKey
+}, raiseInsertSoftBreak = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    event
+  }) => keyIs.lineBreak(event.originEvent),
+  actions: [() => [raise({
+    type: "insert.soft break"
+  })]]
+}), raiseDeserializationSuccessOrFailure = defineBehavior({
   on: "deserialize",
   guard: ({
     snapshot,
@@ -6259,43 +6245,30 @@ const keyIs = {
       originEvent: event
     })]]
   }),
-  ...internalAnnotationBehaviors,
-  ...internalDecoratorBehaviors,
-  ...internalInsertBehaviors,
-  ...internalListItemBehaviors,
-  ...internalStyleBehaviors,
-  ...internalSelectBehaviors,
+  ...abstractAnnotationBehaviors,
+  ...abstractDecoratorBehaviors,
+  ...abstractInsertBehaviors,
+  ...abstractListItemBehaviors,
+  ...abstractMoveBehaviors,
+  ...abstractStyleBehaviors,
+  ...abstractSelectBehaviors,
   raiseDeserializationSuccessOrFailure,
   raiseSerializationSuccessOrFailure,
   raiseInsertSoftBreak
-];
-function isKeyboardBehaviorEvent(event) {
-  return event.type.startsWith("keyboard.");
-}
-function isInternalBehaviorEvent(event) {
-  return event.type === "deserialize" || event.type.startsWith("deserialization.") || event.type === "insert.blocks" || event.type.startsWith("list item.") || event.type === "serialize" || event.type.startsWith("serialization.") || event.type === "select.next block" || event.type === "select.previous block" || event.type.startsWith("style.");
+], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
+function isAbstractBehaviorEvent(event) {
+  return abstractBehaviorEventTypes.includes(event.type);
 }
+const nativeBehaviorEventTypes = ["clipboard.copy", "clipboard.cut", "clipboard.paste", "drag.dragstart", "drag.drag", "drag.dragend", "drag.dragenter", "drag.dragover", "drag.dragleave", "drag.drop", "input.*", "keyboard.keydown", "keyboard.keyup", "mouse.click"];
 function isNativeBehaviorEvent(event) {
-  return isClipboardBehaviorEvent(event) || isDragBehaviorEvent(event) || isInputBehaviorEvent(event) || isKeyboardBehaviorEvent(event) || isMouseBehaviorEvent(event);
-}
-function isClipboardBehaviorEvent(event) {
-  return event.type.startsWith("clipboard.");
-}
-function isDragBehaviorEvent(event) {
-  return event.type.startsWith("drag.");
-}
-function isInputBehaviorEvent(event) {
-  return event.type.startsWith("input.");
-}
-function isMouseBehaviorEvent(event) {
-  return event.type.startsWith("mouse.");
+  return nativeBehaviorEventTypes.includes(event.type);
 }
 function isCustomBehaviorEvent(event) {
   return event.type.startsWith("custom.");
 }
 const debug$2 = debugWithName("behaviors:event");
 function eventCategory(event) {
-  return isNativeBehaviorEvent(event) ? "native" : isInternalBehaviorEvent(event) ? "internal" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
+  return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "abstract" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
 }
 function performEvent({
   behaviors,
@@ -6308,7 +6281,7 @@ function performEvent({
   defaultActionCallback
 }) {
   debug$2(`(${eventCategory(event)})`, JSON.stringify(event, null, 2));
-  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isInternalBehaviorEvent(event) ? void 0 : {
+  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
     ...event,
     editor
   }, eventBehaviors = behaviors.filter((behavior) => {
@@ -6427,6 +6400,34 @@ function performEvent({
     }), editor.onChange();
   }
 }
+function slateChildrenToBlocks(schema, value) {
+  const blocks = new Array(value.length);
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex];
+    if (descendant._type !== schema.block.name) {
+      blocks[blockIndex] = {
+        _key: descendant._key,
+        _type: descendant._type,
+        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
+      };
+      continue;
+    }
+    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+      const child = children[childIndex];
+      processedChildren[childIndex] = child._type === schema.span.name ? child : {
+        _key: child._key,
+        _type: child._type,
+        ..."value" in child && typeof child.value == "object" ? child.value : {}
+      };
+    }
+    blocks[blockIndex] = {
+      ...descendant,
+      children: processedChildren
+    };
+  }
+  return blocks;
+}
 function getActiveDecorators({
   schema,
   slateEditorInstance
@@ -6445,7 +6446,11 @@ function createEditorSnapshot({
   hasTag,
   internalDrag
 }) {
-  const value = fromSlateValue(editor.children, schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), selection = toPortableTextRange(value, editor.selection, schema);
+  const value = slateChildrenToBlocks(schema, editor.children), selection = editor.selection ? slateRangeToSelection({
+    schema,
+    editor,
+    range: editor.selection
+  }) : null;
   return {
     context: {
       activeDecorators: getActiveDecorators({
@@ -6541,7 +6546,7 @@ const editorMachine = setup({
       event,
       self
     }) => {
-      assertEvent(event, ["behavior event", "custom behavior event"]), performEvent({
+      assertEvent(event, ["behavior event"]), performEvent({
         behaviors: [...context.behaviors.values(), ...defaultBehaviors],
         event: event.behaviorEvent,
         editor: event.editor,
@@ -6740,87 +6745,6 @@ const editorMachine = setup({
             },
             "behavior event": {
               actions: "handle behavior event"
-            },
-            "custom behavior event": {
-              actions: "handle behavior event"
-            },
-            "annotation.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "block.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            blur: {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "custom.*": {
-              actions: emit(({
-                event
-              }) => ({
-                type: "custom.*",
-                event
-              }))
-            },
-            "decorator.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "delete.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            focus: {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "history.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "insert.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "list item.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "move.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            select: {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "select.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "style.*": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "text block.*": {
-              actions: emit(({
-                event
-              }) => event)
             }
           },
           initial: "idle",
@@ -6932,12 +6856,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;
 }
@@ -6969,10 +6887,7 @@ function getEditorSnapshot({
       }),
       schema: editorActorSnapshot.context.schema,
       selection: editorActorSnapshot.context.selection,
-      value: getValue({
-        editorActorSnapshot,
-        slateEditorInstance
-      })
+      value: slateChildrenToBlocks(editorActorSnapshot.context.schema, slateEditorInstance.children)
     },
     beta: {
       hasTag: (tag) => editorActorSnapshot.hasTag(tag),
@@ -7028,7 +6943,39 @@ function createInternalEditorFromActor(editorActor) {
       });
     }),
     send: (event) => {
-      editorActor.send(event);
+      switch (event.type) {
+        case "add behavior":
+        case "remove behavior":
+        case "update behaviors":
+        case "update key generator":
+        case "update readOnly":
+        case "patches":
+        case "update value":
+        case "update schema":
+        case "update maxBlocks":
+          editorActor.send(event);
+          break;
+        case "insert.block object":
+          editorActor.send({
+            type: "behavior event",
+            behaviorEvent: {
+              type: "insert.block",
+              block: {
+                _type: event.blockObject.name,
+                ...event.blockObject.value ?? {}
+              },
+              placement: event.placement
+            },
+            editor: slateEditor.instance
+          });
+          break;
+        default:
+          editorActor.send({
+            type: "behavior event",
+            behaviorEvent: event,
+            editor: slateEditor.instance
+          });
+      }
     },
     on: (event, listener) => editorActor.on(event, (event2) => {
       switch (event2.type) {
@@ -7638,7 +7585,7 @@ export {
   getNodeBlock,
   isEqualToEmptyEditor,
   moveRangeByOperation,
-  toPortableTextRange,
+  slateRangeToSelection,
   toSlateRange,
   useEditor,
   useEditorSelector,