@portabletext/editor 1.1.9 → 1.1.11

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), types = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), schema = require("@sanity/schema"), isHotkeyEsm = require("is-hotkey-esm"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), flatten = require("lodash/flatten.js"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), debounce = require("lodash/debounce.js"), content = require("@sanity/util/content");
+var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), types = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), flatten = require("lodash/flatten.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), debounce = require("lodash/debounce.js"), content = require("@sanity/util/content");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -799,20 +799,15 @@ function getFocusBlockObject(context) {
   const focusBlock = getFocusBlock(context);
   return focusBlock && !types.isPortableTextTextBlock(focusBlock.node) ? { node: focusBlock.node, path: focusBlock.path } : void 0;
 }
-const overwriteSoftReturn = {
-  on: "key down",
-  guard: ({ event }) => isHotkeyEsm.isHotkey("shift+enter", event.nativeEvent),
-  actions: [
-    ({ event }) => (event.nativeEvent.preventDefault(), { type: "insert text", text: `
-` })
-  ]
-}, enterOnVoidBlock = {
-  on: "key down",
-  guard: ({ context, event }) => isHotkeyEsm.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(types2) {
   const textBlockName = types2.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
@@ -1087,6 +1082,46 @@ function createOperationToPatches(types2) {
     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$1) {
   return function(editor) {
@@ -1573,127 +1608,6 @@ function createWithEditableAPI(editorActor, portableTextEditor, types$1) {
     }), editor;
   };
 }
-function createWithInsertBreak(editorActor, types2) {
-  return function(editor) {
-    const { insertBreak } = editor;
-    return editor.insertBreak = () => {
-      if (!editor.selection) {
-        insertBreak();
-        return;
-      }
-      const [focusSpan] = Array.from(
-        slate.Editor.nodes(editor, {
-          mode: "lowest",
-          at: editor.selection.focus,
-          match: (n) => editor.isTextSpan(n),
-          voids: !1
-        })
-      )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
-        (mark) => types2.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusAnnotations = focusSpan.marks?.filter(
-        (mark) => !types2.decorators.some((decorator) => decorator.value === mark)
-      ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-      if (editor.isTextBlock(focusBlock)) {
-        const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
-          path: [...focusBlockPath, 0],
-          offset: 0
-        });
-        if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
-          slate.Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: focusAnnotations.length === 0 ? focusDecorators : []
-            })
-          );
-          const [nextBlockPath] = slate.Path.next(focusBlockPath);
-          slate.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__default.default(start, {
-          path: [...focusBlockPath, focusBlock.children.length - 1],
-          offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
-        });
-        if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
-          slate.Editor.insertNode(
-            editor,
-            editor.pteCreateTextBlock({
-              decorators: []
-            })
-          );
-          const [nextBlockPath] = slate.Path.next(focusBlockPath);
-          slate.Transforms.setSelection(editor, {
-            anchor: { path: [nextBlockPath, 0], offset: 0 },
-            focus: { path: [nextBlockPath, 0], offset: 0 }
-          });
-          return;
-        }
-        if (!atTheStartOfBlock && !atTheEndOfBlock) {
-          slate.Editor.withoutNormalizing(editor, () => {
-            if (!editor.selection)
-              return;
-            slate.Transforms.splitNodes(editor, {
-              at: editor.selection
-            });
-            const [nextNode, nextNodePath] = slate.Editor.node(
-              editor,
-              slate.Path.next(focusBlockPath),
-              { depth: 1 }
-            );
-            if (slate.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(
-                slate.Node.children(editor, focusBlockPath)
-              ).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextNodePath);
-              for (const [child, childPath] of children) {
-                if (!editor.isTextSpan(child))
-                  continue;
-                const marks = child.marks ?? [];
-                for (const mark of marks)
-                  types2.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__default.default(marks, newMarks) || slate.Transforms.setNodes(
-                  editor,
-                  { marks: newMarks },
-                  {
-                    at: childPath
-                  }
-                );
-              }
-              const newMarkDefs = nextNode.markDefs.map((markDef) => ({
-                ...markDef,
-                _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-              }));
-              isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.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);
@@ -3778,6 +3692,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: [
             {
@@ -4397,14 +4313,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)
@@ -4418,9 +4334,7 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
             withUtils(
               withPlaceholderBlock(
                 withPortableTextLists(
-                  withPortableTextSelections(
-                    withEditableAPI(withInsertBreak(e))
-                  )
+                  withPortableTextSelections(withEditableAPI(e))
                 )
               )
             )
@@ -4430,18 +4344,18 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     ),
     subscribe: () => noop__default.default
   } : {
-    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))
                         )
                       )
                     )
@@ -4812,26 +4726,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 = react.createContext({}), behaviorActionImplementations = {
-  "apply block style": ({ event }) => {
-    for (const path of event.paths) {
+const EditorActorContext = react.createContext({}), insertBreakActionImplementation = ({ context, action }) => {
+  const keyGenerator = context.keyGenerator, schema2 = context.schema, editor = action.editor;
+  if (!editor.selection)
+    return;
+  const [focusSpan] = Array.from(
+    slate.Editor.nodes(editor, {
+      mode: "lowest",
+      at: editor.selection.focus,
+      match: (n) => editor.isTextSpan(n),
+      voids: !1
+    })
+  )[0] ?? [void 0], focusDecorators = focusSpan.marks?.filter(
+    (mark) => schema2.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusAnnotations = focusSpan.marks?.filter(
+    (mark) => !schema2.decorators.some((decorator) => decorator.value === mark)
+  ) ?? [], focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+  if (editor.isTextBlock(focusBlock)) {
+    const [start, end] = slate.Range.edges(editor.selection), atTheStartOfBlock = isEqual__default.default(end, {
+      path: [...focusBlockPath, 0],
+      offset: 0
+    });
+    if (atTheStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
+      slate.Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: focusAnnotations.length === 0 ? focusDecorators : [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = slate.Path.next(focusBlockPath);
+      slate.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__default.default(start, {
+      path: [...focusBlockPath, focusBlock.children.length - 1],
+      offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
+    });
+    if (atTheEndOfBlock && slate.Range.isCollapsed(editor.selection)) {
+      slate.Editor.insertNode(
+        editor,
+        editor.pteCreateTextBlock({
+          decorators: [],
+          listItem: focusBlock.listItem,
+          level: focusBlock.level
+        })
+      );
+      const [nextBlockPath] = slate.Path.next(focusBlockPath);
+      slate.Transforms.setSelection(editor, {
+        anchor: { path: [nextBlockPath, 0], offset: 0 },
+        focus: { path: [nextBlockPath, 0], offset: 0 }
+      });
+      return;
+    }
+    if (!atTheStartOfBlock && !atTheEndOfBlock) {
+      slate.Editor.withoutNormalizing(editor, () => {
+        if (!editor.selection)
+          return;
+        slate.Transforms.splitNodes(editor, {
+          at: editor.selection
+        });
+        const [nextNode, nextNodePath] = slate.Editor.node(
+          editor,
+          slate.Path.next(focusBlockPath),
+          { depth: 1 }
+        );
+        if (slate.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(
+            slate.Node.children(editor, focusBlockPath)
+          ).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextNodePath);
+          for (const [child, childPath] of children) {
+            if (!editor.isTextSpan(child))
+              continue;
+            const marks = child.marks ?? [];
+            for (const mark of marks)
+              schema2.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__default.default(marks, newMarks) || slate.Transforms.setNodes(
+              editor,
+              { marks: newMarks },
+              {
+                at: childPath
+              }
+            );
+          }
+          const newMarkDefs = nextNode.markDefs.map((markDef) => ({
+            ...markDef,
+            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+          }));
+          isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.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
+      );
+      slate.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
       );
-      slate.Transforms.setNodes(event.editor, { style: event.style }, { at });
+      slate.Transforms.unsetNodes(action.editor, action.props, { at });
     }
   },
-  "delete text": ({ event }) => {
-    slate.Transforms.delete(event.editor, {
-      at: toSlateRange(event.selection, event.editor)
+  "delete backward": ({ action }) => {
+    slate.deleteBackward(action.editor, action.unit);
+  },
+  "delete text": ({ action }) => {
+    slate.Transforms.delete(action.editor, {
+      at: toSlateRange(action.selection, action.editor)
     });
   },
-  "insert text": ({ event }) => {
-    slate.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 }) => {
+    slate.insertText(action.editor, action.text);
   },
-  "insert text block": ({ context, event }) => {
-    slate.Editor.insertNode(event.editor, {
+  "insert text block": ({ context, action }) => {
+    slate.Editor.insertNode(action.editor, {
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
       style: context.schema.styles[0].value ?? "normal",
@@ -4844,8 +4894,47 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
         }
       ]
     });
+  },
+  effect: ({ action }) => {
+    action.effect();
+  }
+};
+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;
+    }
   }
-}, networkLogic = xstate.fromCallback(({ sendBack }) => {
+}
+const networkLogic = xstate.fromCallback(({ sendBack }) => {
   const onlineHandler = () => {
     sendBack({ type: "online" });
   }, offlineHandler = () => {
@@ -4878,12 +4967,17 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
       pendingEvents: []
     }),
     "handle behavior event": xstate.enqueueActions(({ context, event, enqueue }) => {
-      xstate.assertEvent(event, ["key down", "before insert text"]);
-      const eventBehaviors = context.behaviors.filter(
-        (behavior) => behavior.on === event.type
+      xstate.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,
@@ -4896,7 +4990,7 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
       if (!selection) {
         console.warn(
           `Unable to handle event ${event.type} due to missing selection`
-        );
+        ), performDefaultAction({ context, action: defaultAction });
         return;
       }
       const behaviorContext = {
@@ -4904,22 +4998,28 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
         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: {
@@ -4951,23 +5051,83 @@ const EditorActorContext = react.createContext({}), behaviorActionImplementation
     loading: { actions: xstate.emit({ type: "loading" }) },
     "done loading": { actions: xstate.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 }) => {
+          slate.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",
@@ -5599,11 +5759,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     [editorActor, onBlur]
   ), handleOnBeforeInput = react.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 = react.useCallback(() => {
@@ -5642,11 +5798,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   }, [validateSelection, editableElement]);
   const handleKeyDown = react.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 = react.useMemo(() => {