@portabletext/editor 1.1.9 → 1.1.11

package/lib/index.esm.js

@@ -2,7 +2,7 @@ import { jsx, Fragment, jsxs } from "react/jsx-runtime";
 import isEqual from "lodash/isEqual.js";
 import noop from "lodash/noop.js";
 import { useRef, useState, useMemo, useEffect, useCallback, createContext, useContext, startTransition, Component, forwardRef, useImperativeHandle } from "react";
-import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Node, Operation, createEditor } from "slate";
+import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Node, Operation, createEditor, deleteBackward, insertText } from "slate";
 import { useSlateStatic, ReactEditor, useSelected, withReact, Slate, useSlate, Editable } from "slate-react";
 import debug$m from "debug";
 import { isKeySegment, isPortableTextTextBlock, isPortableTextSpan, isPortableTextListBlock } from "@sanity/types";
@@ -11,12 +11,12 @@ import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
 import { fromCallback, setup, assign, assertEvent, emit, enqueueActions, createActor } from "xstate";
 import { Schema } from "@sanity/schema";
-import { isHotkey } from "is-hotkey-esm";
 import { diffMatchPatch as diffMatchPatch$1, set, insert, setIfMissing, unset, applyAll } from "@portabletext/patches";
 import get from "lodash/get.js";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import flatten from "lodash/flatten.js";
+import { isHotkey } from "is-hotkey-esm";
 import { htmlToBlocks, normalizeBlock } from "@sanity/block-tools";
 import isPlainObject from "lodash/isPlainObject.js";
 import throttle from "lodash/throttle.js";
@@ -816,20 +816,15 @@ function getFocusBlockObject(context) {
   const focusBlock = getFocusBlock(context);
   return focusBlock && !isPortableTextTextBlock(focusBlock.node) ? { node: focusBlock.node, path: focusBlock.path } : void 0;
 }
-const overwriteSoftReturn = {
-  on: "key down",
-  guard: ({ event }) => isHotkey("shift+enter", event.nativeEvent),
-  actions: [
-    ({ event }) => (event.nativeEvent.preventDefault(), { type: "insert text", text: `
-` })
-  ]
-}, enterOnVoidBlock = {
-  on: "key down",
-  guard: ({ context, event }) => isHotkey("enter", event.nativeEvent) ? !!getFocusBlockObject(context) : !1,
-  actions: [
-    ({ event }) => (event.nativeEvent.preventDefault(), { type: "insert text block", decorators: [] })
-  ]
-}, coreBehaviors = [overwriteSoftReturn, enterOnVoidBlock], debug$k = debugWithName("operationToPatches");
+const softReturn = {
+  on: "insert soft break",
+  actions: [() => [{ type: "insert text", text: `
+` }]]
+}, breakingVoidBlock = {
+  on: "insert break",
+  guard: ({ context }) => !!getFocusBlockObject(context),
+  actions: [() => [{ type: "insert text block", decorators: [] }]]
+}, coreBehaviors = [softReturn, breakingVoidBlock], debug$k = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
@@ -1104,6 +1099,46 @@ function createOperationToPatches(types) {
     splitNodePatch
   };
 }
+function createWithEventListeners(editorActor) {
+  return function(editor) {
+    return editor.deleteBackward = (unit) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "delete backward",
+          unit
+        },
+        editor
+      });
+    }, editor.insertBreak = () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert break"
+        },
+        editor
+      });
+    }, editor.insertSoftBreak = () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert soft break"
+        },
+        editor
+      });
+    }, editor.insertText = (text, options) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert text",
+          text,
+          options
+        },
+        editor
+      });
+    }, editor;
+  };
+}
 const debug$j = debugWithName("API:editable");
 function createWithEditableAPI(editorActor, portableTextEditor, types) {
   return function(editor) {
@@ -1590,127 +1625,6 @@ function createWithEditableAPI(editorActor, portableTextEditor, types) {
     }), editor;
   };
 }
-function createWithInsertBreak(editorActor, types) {
-  return function(editor) {
-    const { insertBreak } = editor;
-    return editor.insertBreak = () => {
-      if (!editor.selection) {
-        insertBreak();
-        return;
-      }
-      const [focusSpan] = Array.from(
-        Editor.nodes(editor, {
-          mode: "lowest",
-          at: editor.selection.focus,
-          match: (n) => editor.isTextSpan(n),
-          voids: !1
-        })
-      )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
-        (mark) => types.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusAnnotations = focusSpan.marks?.filter(
-        (mark) => !types.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
-      if (editor.isTextBlock(focusBlock)) {
-        const [start, end] = Range.edges(editor.selection), atTheStartOfBlock = isEqual(end, {
-          path: [...focusBlockPath, 0],
-          offset: 0
-        });
-        if (atTheStartOfBlock && Range.isCollapsed(editor.selection)) {
-          Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: focusAnnotations.length === 0 ? focusDecorators : []
-            })
-          );
-          const [nextBlockPath] = Path.next(focusBlockPath);
-          Transforms.select(editor, {
-            anchor: { path: [nextBlockPath, 0], offset: 0 },
-            focus: { path: [nextBlockPath, 0], offset: 0 }
-          });
-          return;
-        }
-        const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual(start, {
-          path: [...focusBlockPath, focusBlock.children.length - 1],
-          offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
-        });
-        if (atTheEndOfBlock && Range.isCollapsed(editor.selection)) {
-          Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: []
-            })
-          );
-          const [nextBlockPath] = Path.next(focusBlockPath);
-          Transforms.setSelection(editor, {
-            anchor: { path: [nextBlockPath, 0], offset: 0 },
-            focus: { path: [nextBlockPath, 0], offset: 0 }
-          });
-          return;
-        }
-        if (!atTheStartOfBlock && !atTheEndOfBlock) {
-          Editor.withoutNormalizing(editor, () => {
-            if (!editor.selection)
-              return;
-            Transforms.splitNodes(editor, {
-              at: editor.selection
-            });
-            const [nextNode, nextNodePath] = Editor.node(
-              editor,
-              Path.next(focusBlockPath),
-              { depth: 1 }
-            );
-            if (Transforms.setSelection(editor, {
-              anchor: { path: [...nextNodePath, 0], offset: 0 },
-              focus: { path: [...nextNodePath, 0], offset: 0 }
-            }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.markDefs.length > 0) {
-              const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(
-                Node.children(editor, focusBlockPath)
-              ).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = Node.children(editor, nextNodePath);
-              for (const [child, childPath] of children) {
-                if (!editor.isTextSpan(child))
-                  continue;
-                const marks = child.marks ?? [];
-                for (const mark of marks)
-                  types.decorators.some(
-                    (decorator) => decorator.value === mark
-                  ) || prevNodeSpans.some(
-                    (prevNodeSpan) => prevNodeSpan.marks?.includes(mark)
-                  ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(
-                    mark,
-                    editorActor.getSnapshot().context.keyGenerator()
-                  );
-                const newMarks = marks.map(
-                  (mark) => newMarkDefKeys.get(mark) ?? mark
-                );
-                isEqual(marks, newMarks) || Transforms.setNodes(
-                  editor,
-                  { marks: newMarks },
-                  {
-                    at: childPath
-                  }
-                );
-              }
-              const newMarkDefs = nextNode.markDefs.map((markDef) => ({
-                ...markDef,
-                _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-              }));
-              isEqual(nextNode.markDefs, newMarkDefs) || Transforms.setNodes(
-                editor,
-                { markDefs: newMarkDefs },
-                {
-                  at: nextNodePath,
-                  match: (node) => editor.isTextBlock(node)
-                }
-              );
-            }
-          }), editor.onChange();
-          return;
-        }
-      }
-      insertBreak();
-    }, editor;
-  };
-}
 function withRemoteChanges(editor, fn) {
   const prev = isChangingRemotely(editor) || !1;
   IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
@@ -2187,8 +2101,8 @@ function deisolateChar(diffs, i, dir) {
     }
   }
   if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
-    const [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
-    diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
+    const [insertText2, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
+    diffs[insertIdx][1] = insertText2, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
     return;
   }
   const [text, char] = splitChar(diffs[i][1], dir);
@@ -3795,6 +3709,8 @@ function createWithUtils({
           _type: schemaTypes.block.name,
           _key: editorActor.getSnapshot().context.keyGenerator(),
           style: schemaTypes.styles[0].value || "normal",
+          ...options.listItem ? { listItem: options.listItem } : {},
+          ...options.level ? { level: options.level } : {},
           markDefs: [],
           children: [
             {
@@ -4414,14 +4330,14 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   ), withPortableTextBlockStyle = createWithPortableTextBlockStyle(
     editorActor,
     schemaTypes
-  ), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(editorActor, schemaTypes), withUtils = createWithUtils({
+  ), withPlaceholderBlock = createWithPlaceholderBlock(), withUtils = createWithUtils({
     editorActor,
     schemaTypes,
     portableTextEditor
   }), withPortableTextSelections = createWithPortableTextSelections(
     editorActor,
     schemaTypes
-  );
+  ), withEventListeners = createWithEventListeners(editorActor);
   return e.destroy = () => {
     const originalFunctions = originalFnMap.get(e);
     if (!originalFunctions)
@@ -4435,9 +4351,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
             withUtils(
               withPlaceholderBlock(
                 withPortableTextLists(
-                  withPortableTextSelections(
-                    withEditableAPI(withInsertBreak(e))
-                  )
+                  withPortableTextSelections(withEditableAPI(e))
                 )
               )
             )
@@ -4447,18 +4361,18 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     ),
     subscribe: () => noop
   } : {
-    editor: withSchemaTypes(
-      withObjectKeys(
-        withPortableTextMarkModel(
-          withPortableTextBlockStyle(
-            withPortableTextLists(
-              withPlaceholderBlock(
-                withUtils(
-                  withMaxBlocks(
-                    withUndoRedo(
-                      withPatches(
-                        withPortableTextSelections(
-                          withEditableAPI(withInsertBreak(e))
+    editor: withEventListeners(
+      withSchemaTypes(
+        withObjectKeys(
+          withPortableTextMarkModel(
+            withPortableTextBlockStyle(
+              withPortableTextLists(
+                withPlaceholderBlock(
+                  withUtils(
+                    withMaxBlocks(
+                      withUndoRedo(
+                        withPatches(
+                          withPortableTextSelections(withEditableAPI(e))
                         )
                       )
                     )
@@ -4829,26 +4743,162 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
     debug$4("Value from props changed, syncing new value"), syncValue(value), isInitialValueFromProps.current && (editorActor.send({ type: "ready" }), isInitialValueFromProps.current = !1);
   }, [editorActor, syncValue, value]), null;
 }
-const EditorActorContext = createContext({}), behaviorActionImplementations = {
-  "apply block style": ({ event }) => {
-    for (const path of event.paths) {
+const EditorActorContext = createContext({}), insertBreakActionImplementation = ({ context, action }) => {
+  const keyGenerator = context.keyGenerator, schema = context.schema, editor = action.editor;
+  if (!editor.selection)
+    return;
+  const [focusSpan] = Array.from(
+    Editor.nodes(editor, {
+      mode: "lowest",
+      at: editor.selection.focus,
+      match: (n) => editor.isTextSpan(n),
+      voids: !1
+    })
+  )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
+    (mark) => schema.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusAnnotations = focusSpan.marks?.filter(
+    (mark) => !schema.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock)) {
+    const [start, end] = Range.edges(editor.selection), atTheStartOfBlock = isEqual(end, {
+      path: [...focusBlockPath, 0],
+      offset: 0
+    });
+    if (atTheStartOfBlock && Range.isCollapsed(editor.selection)) {
+      Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: focusAnnotations.length === 0 ? focusDecorators : [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = Path.next(focusBlockPath);
+      Transforms.select(editor, {
+        anchor: { path: [nextBlockPath, 0], offset: 0 },
+        focus: { path: [nextBlockPath, 0], offset: 0 }
+      });
+      return;
+    }
+    const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual(start, {
+      path: [...focusBlockPath, focusBlock.children.length - 1],
+      offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
+    });
+    if (atTheEndOfBlock && Range.isCollapsed(editor.selection)) {
+      Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = Path.next(focusBlockPath);
+      Transforms.setSelection(editor, {
+        anchor: { path: [nextBlockPath, 0], offset: 0 },
+        focus: { path: [nextBlockPath, 0], offset: 0 }
+      });
+      return;
+    }
+    if (!atTheStartOfBlock && !atTheEndOfBlock) {
+      Editor.withoutNormalizing(editor, () => {
+        if (!editor.selection)
+          return;
+        Transforms.splitNodes(editor, {
+          at: editor.selection
+        });
+        const [nextNode, nextNodePath] = Editor.node(
+          editor,
+          Path.next(focusBlockPath),
+          { depth: 1 }
+        );
+        if (Transforms.setSelection(editor, {
+          anchor: { path: [...nextNodePath, 0], offset: 0 },
+          focus: { path: [...nextNodePath, 0], offset: 0 }
+        }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.markDefs.length > 0) {
+          const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(
+            Node.children(editor, focusBlockPath)
+          ).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = Node.children(editor, nextNodePath);
+          for (const [child, childPath] of children) {
+            if (!editor.isTextSpan(child))
+              continue;
+            const marks = child.marks ?? [];
+            for (const mark of marks)
+              schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some(
+                (prevNodeSpan) => prevNodeSpan.marks?.includes(mark)
+              ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+            const newMarks = marks.map(
+              (mark) => newMarkDefKeys.get(mark) ?? mark
+            );
+            isEqual(marks, newMarks) || Transforms.setNodes(
+              editor,
+              { marks: newMarks },
+              {
+                at: childPath
+              }
+            );
+          }
+          const newMarkDefs = nextNode.markDefs.map((markDef) => ({
+            ...markDef,
+            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+          }));
+          isEqual(nextNode.markDefs, newMarkDefs) || Transforms.setNodes(
+            editor,
+            { markDefs: newMarkDefs },
+            {
+              at: nextNodePath,
+              match: (node) => editor.isTextBlock(node)
+            }
+          );
+        }
+      }), editor.onChange();
+      return;
+    }
+  }
+}, behaviorActionImplementations = {
+  "set block": ({ action }) => {
+    for (const path of action.paths) {
+      const at = toSlateRange(
+        { anchor: { path, offset: 0 }, focus: { path, offset: 0 } },
+        action.editor
+      );
+      Transforms.setNodes(
+        action.editor,
+        {
+          ...action.style ? { style: action.style } : {},
+          ...action.listItem ? { listItem: action.listItem } : {},
+          ...action.level ? { level: action.level } : {}
+        },
+        { at }
+      );
+    }
+  },
+  "unset block": ({ action }) => {
+    for (const path of action.paths) {
       const at = toSlateRange(
         { anchor: { path, offset: 0 }, focus: { path, offset: 0 } },
-        event.editor
+        action.editor
       );
-      Transforms.setNodes(event.editor, { style: event.style }, { at });
+      Transforms.unsetNodes(action.editor, action.props, { at });
     }
   },
-  "delete text": ({ event }) => {
-    Transforms.delete(event.editor, {
-      at: toSlateRange(event.selection, event.editor)
+  "delete backward": ({ action }) => {
+    deleteBackward(action.editor, action.unit);
+  },
+  "delete text": ({ action }) => {
+    Transforms.delete(action.editor, {
+      at: toSlateRange(action.selection, action.editor)
     });
   },
-  "insert text": ({ event }) => {
-    Editor.insertText(event.editor, event.text);
+  "insert break": insertBreakActionImplementation,
+  // This mimics Slate's internal which also just does a regular insert break
+  // when on soft break
+  "insert soft break": insertBreakActionImplementation,
+  "insert text": ({ action }) => {
+    insertText(action.editor, action.text);
   },
-  "insert text block": ({ context, event }) => {
-    Editor.insertNode(event.editor, {
+  "insert text block": ({ context, action }) => {
+    Editor.insertNode(action.editor, {
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
       style: context.schema.styles[0].value ?? "normal",
@@ -4861,8 +4911,47 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
         }
       ]
     });
+  },
+  effect: ({ action }) => {
+    action.effect();
   }
-}, networkLogic = fromCallback(({ sendBack }) => {
+};
+function performDefaultAction({
+  context,
+  action
+}) {
+  switch (action.type) {
+    case "delete backward": {
+      behaviorActionImplementations["delete backward"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert break": {
+      behaviorActionImplementations["insert break"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert soft break": {
+      behaviorActionImplementations["insert soft break"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "insert text": {
+      behaviorActionImplementations["insert text"]({
+        context,
+        action
+      });
+      break;
+    }
+  }
+}
+const networkLogic = fromCallback(({ sendBack }) => {
   const onlineHandler = () => {
     sendBack({ type: "online" });
   }, offlineHandler = () => {
@@ -4895,12 +4984,17 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
       pendingEvents: []
     }),
     "handle behavior event": enqueueActions(({ context, event, enqueue }) => {
-      assertEvent(event, ["key down", "before insert text"]);
-      const eventBehaviors = context.behaviors.filter(
-        (behavior) => behavior.on === event.type
+      assertEvent(event, ["behavior event"]);
+      const defaultAction = {
+        ...event.behaviorEvent,
+        editor: event.editor
+      }, eventBehaviors = context.behaviors.filter(
+        (behavior) => behavior.on === event.behaviorEvent.type
       );
-      if (eventBehaviors.length === 0)
+      if (eventBehaviors.length === 0) {
+        performDefaultAction({ context, action: defaultAction });
         return;
+      }
       const value = fromSlateValue(
         event.editor.children,
         context.schema.block.name,
@@ -4913,7 +5007,7 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
       if (!selection) {
         console.warn(
           `Unable to handle event ${event.type} due to missing selection`
-        );
+        ), performDefaultAction({ context, action: defaultAction });
         return;
       }
       const behaviorContext = {
@@ -4921,22 +5015,28 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
         value,
         selection
       };
+      let behaviorOverwritten = !1;
       for (const eventBehavior of eventBehaviors) {
         const shouldRun = eventBehavior.guard?.({
           context: behaviorContext,
-          event
+          event: event.behaviorEvent
         }) ?? !0;
         if (!shouldRun)
           continue;
-        const actions = eventBehavior.actions.map(
-          (action) => action({ context: behaviorContext, event }, shouldRun)
+        const actionIntendSets = eventBehavior.actions.map(
+          (actionSet) => actionSet(
+            { context: behaviorContext, event: event.behaviorEvent },
+            shouldRun
+          )
         );
-        for (const action of actions)
-          typeof action == "object" && enqueue.raise({
-            ...action,
-            editor: event.editor
+        for (const actionIntends of actionIntendSets)
+          behaviorOverwritten = actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), enqueue.raise({
+            type: "behavior action intends",
+            editor: event.editor,
+            actionIntends
           });
       }
+      behaviorOverwritten || performDefaultAction({ context, action: defaultAction });
     })
   },
   actors: {
@@ -4968,23 +5068,83 @@ const EditorActorContext = createContext({}), behaviorActionImplementations = {
     loading: { actions: emit({ type: "loading" }) },
     "done loading": { actions: emit({ type: "done loading" }) },
     "update schema": { actions: "assign schema" },
-    "key down": {
-      actions: ["handle behavior event"]
-    },
-    "before insert text": {
-      actions: ["handle behavior event"]
-    },
-    "apply block style": {
-      actions: [behaviorActionImplementations["apply block style"]]
-    },
-    "delete text": {
-      actions: [behaviorActionImplementations["delete text"]]
-    },
-    "insert text": {
-      actions: [behaviorActionImplementations["insert text"]]
-    },
-    "insert text block": {
-      actions: [behaviorActionImplementations["insert text block"]]
+    "behavior event": { actions: "handle behavior event" },
+    "behavior action intends": {
+      actions: [
+        ({ context, event }) => {
+          Editor.withoutNormalizing(event.editor, () => {
+            for (const actionIntend of event.actionIntends) {
+              const action = {
+                ...actionIntend,
+                editor: event.editor
+              };
+              switch (action.type) {
+                case "delete backward": {
+                  behaviorActionImplementations["delete backward"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "delete text": {
+                  behaviorActionImplementations["delete text"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert break": {
+                  behaviorActionImplementations["insert break"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert soft break": {
+                  behaviorActionImplementations["insert soft break"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert text": {
+                  behaviorActionImplementations["insert text"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "insert text block": {
+                  behaviorActionImplementations["insert text block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "set block": {
+                  behaviorActionImplementations["set block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                case "unset block": {
+                  behaviorActionImplementations["unset block"]({
+                    context,
+                    action
+                  });
+                  break;
+                }
+                default:
+                  behaviorActionImplementations.effect({
+                    context,
+                    action
+                  });
+              }
+            }
+          }), event.editor.onChange();
+        }
+      ]
     }
   },
   initial: "pristine",
@@ -5616,11 +5776,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [editorActor, onBlur]
   ), handleOnBeforeInput = useCallback(
     (event) => {
-      onBeforeInput && onBeforeInput(event), !event.defaultPrevented && event.inputType === "insertText" && editorActor.send({
-        type: "before insert text",
-        nativeEvent: event,
-        editor: slateEditor
-      });
+      onBeforeInput && onBeforeInput(event);
     },
     [onBeforeInput]
   ), validateSelection = useCallback(() => {
@@ -5659,11 +5815,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   }, [validateSelection, editableElement]);
   const handleKeyDown = useCallback(
     (event) => {
-      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || (editorActor.send({
-        type: "key down",
-        nativeEvent: event.nativeEvent,
-        editor: slateEditor
-      }), slateEditor.pteWithHotKeys(event));
+      props.onKeyDown && props.onKeyDown(event), event.isDefaultPrevented() || slateEditor.pteWithHotKeys(event);
     },
     [props, slateEditor]
   ), scrollSelectionIntoViewToSlate = useMemo(() => {