@portabletext/editor 1.44.0 → 1.44.2

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

@@ -315,10 +315,7 @@ function isEqualToEmptyEditor(children, schemaTypes) {
 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];
+  return editor.selection ? slate.Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0] : [void 0, void 0];
 }
 function getFocusChild({
   editor
@@ -2979,112 +2976,6 @@ function isPortableTextBlock(node) {
     node.children.every((child) => typeof child == "object" && "_type" in child)
   );
 }
-const decoratorAddActionImplementation = ({
-  context,
-  action
-}) => {
-  const editor = action.editor, mark = action.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = action.offsets?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
-    value,
-    blockOffset: action.offsets.anchor,
-    direction: "backward"
-  }) : void 0, manualFocus = action.offsets?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
-    value,
-    blockOffset: action.offsets.focus,
-    direction: "forward"
-  }) : void 0, manualSelection = manualAnchor && manualFocus ? {
-    anchor: manualAnchor,
-    focus: manualFocus
-  } : void 0, selection = manualSelection ? toSlateRange(manualSelection, action.editor) ?? editor.selection : editor.selection;
-  if (!selection)
-    return;
-  const editorSelection = toPortableTextRange(value, selection, context.schema), anchorOffset = editorSelection ? util_selectionPointToBlockOffset.selectionPointToBlockOffset({
-    value,
-    selectionPoint: editorSelection.anchor
-  }) : void 0, focusOffset = editorSelection ? util_selectionPointToBlockOffset.selectionPointToBlockOffset({
-    value,
-    selectionPoint: editorSelection.focus
-  }) : void 0;
-  if (!anchorOffset || !focusOffset)
-    throw new Error("Unable to find anchor or focus offset");
-  if (slate.Range.isExpanded(selection)) {
-    slate.Transforms.setNodes(editor, {}, {
-      at: selection,
-      match: slate.Text.isText,
-      split: !0,
-      hanging: !0
-    });
-    const newValue = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), newSelection = util_selectionPointToBlockOffset.blockOffsetsToSelection({
-      value: newValue,
-      offsets: {
-        anchor: anchorOffset,
-        focus: focusOffset
-      },
-      backward: editorSelection?.backward
-    }), trimmedSelection = selector_isSelectingEntireBlocks.getTrimmedSelection({
-      context: {
-        activeDecorators: [],
-        converters: [],
-        keyGenerator: context.keyGenerator,
-        readOnly: !1,
-        schema: context.schema,
-        selection: newSelection,
-        value: newValue
-      }
-    });
-    if (!trimmedSelection)
-      throw new Error("Unable to find trimmed selection");
-    const newRange = toSlateRange(trimmedSelection, editor);
-    if (!newRange)
-      throw new Error("Unable to find new selection");
-    const splitTextNodes = slate.Range.isRange(newRange) ? [...slate.Editor.nodes(editor, {
-      at: newRange,
-      match: (node) => slate.Text.isText(node)
-    })] : [];
-    for (const [node, path] of splitTextNodes) {
-      const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
-      slate.Transforms.setNodes(editor, {
-        marks
-      }, {
-        at: path,
-        match: slate.Text.isText,
-        split: !0,
-        hanging: !0
-      });
-    }
-  } else {
-    if (!Array.from(slate.Editor.nodes(editor, {
-      at: selection,
-      match: (node) => editor.isTextSpan(node)
-    }))?.at(0))
-      return;
-    const [block, blockPath] = slate.Editor.node(editor, selection, {
-      depth: 1
-    }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
-    if (lonelyEmptySpan) {
-      const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
-      slate.Transforms.setNodes(editor, {
-        marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
-      }, {
-        at: blockPath,
-        match: (node) => editor.isTextSpan(node)
-      });
-    } else {
-      const existingMarks = {
-        ...slate.Editor.marks(editor) || {}
-      }.marks || [], marks = {
-        ...slate.Editor.marks(editor) || {},
-        marks: [...existingMarks, mark]
-      };
-      editor.marks = marks;
-    }
-  }
-  if (editor.selection) {
-    const selection2 = editor.selection;
-    editor.selection = {
-      ...selection2
-    };
-  }
-};
 function getPreviousSpan({
   editor,
   blockPath,
@@ -3542,25 +3433,7 @@ function isDecoratorActive({
     ...slate.Editor.marks(editor) || {}
   }.marks || []).includes(decorator);
 }
-const toggleDecoratorActionImplementation = ({
-  context,
-  action
-}) => {
-  isDecoratorActive({
-    editor: action.editor,
-    decorator: action.decorator
-  }) ? removeDecoratorActionImplementation({
-    action: {
-      editor: action.editor,
-      decorator: action.decorator
-    }
-  }) : decoratorAddActionImplementation({
-    context,
-    action: {
-      ...action
-    }
-  });
-}, debug$a = debugWithName("API:editable");
+const debug$a = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -4031,30 +3904,6 @@ const addAnnotationActionImplementation = ({
         }
       }
     }
-}, toggleAnnotationActionImplementation = ({
-  context,
-  action
-}) => {
-  if (isAnnotationActive({
-    editor: action.editor,
-    annotation: {
-      name: action.annotation.name
-    }
-  }))
-    removeAnnotationActionImplementation({
-      action: {
-        annotation: action.annotation,
-        editor: action.editor
-      }
-    });
-  else
-    return addAnnotationActionImplementation({
-      context,
-      action: {
-        annotation: action.annotation,
-        editor: action.editor
-      }
-    });
 }, blockSetBehaviorActionImplementation = ({
   context,
   action
@@ -4169,6 +4018,111 @@ const addAnnotationActionImplementation = ({
   action
 }) => {
   slateReact.ReactEditor.blur(action.editor);
+}, decoratorAddActionImplementation = ({
+  context,
+  action
+}) => {
+  const editor = action.editor, mark = action.decorator, value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), manualAnchor = action.offsets?.anchor ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+    value,
+    blockOffset: action.offsets.anchor,
+    direction: "backward"
+  }) : void 0, manualFocus = action.offsets?.focus ? util_sliceBlocks.blockOffsetToSpanSelectionPoint({
+    value,
+    blockOffset: action.offsets.focus,
+    direction: "forward"
+  }) : void 0, manualSelection = manualAnchor && manualFocus ? {
+    anchor: manualAnchor,
+    focus: manualFocus
+  } : void 0, selection = manualSelection ? toSlateRange(manualSelection, action.editor) ?? editor.selection : editor.selection;
+  if (!selection)
+    return;
+  const editorSelection = toPortableTextRange(value, selection, context.schema), anchorOffset = editorSelection ? util_selectionPointToBlockOffset.selectionPointToBlockOffset({
+    value,
+    selectionPoint: editorSelection.anchor
+  }) : void 0, focusOffset = editorSelection ? util_selectionPointToBlockOffset.selectionPointToBlockOffset({
+    value,
+    selectionPoint: editorSelection.focus
+  }) : void 0;
+  if (!anchorOffset || !focusOffset)
+    throw new Error("Unable to find anchor or focus offset");
+  if (slate.Range.isExpanded(selection)) {
+    slate.Transforms.setNodes(editor, {}, {
+      at: selection,
+      match: slate.Text.isText,
+      split: !0,
+      hanging: !0
+    });
+    const newValue = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), newSelection = util_selectionPointToBlockOffset.blockOffsetsToSelection({
+      value: newValue,
+      offsets: {
+        anchor: anchorOffset,
+        focus: focusOffset
+      },
+      backward: editorSelection?.backward
+    }), trimmedSelection = selector_isSelectingEntireBlocks.getTrimmedSelection({
+      context: {
+        activeDecorators: [],
+        converters: [],
+        keyGenerator: context.keyGenerator,
+        readOnly: !1,
+        schema: context.schema,
+        selection: newSelection,
+        value: newValue
+      }
+    });
+    if (!trimmedSelection)
+      throw new Error("Unable to find trimmed selection");
+    const newRange = toSlateRange(trimmedSelection, editor);
+    if (!newRange)
+      throw new Error("Unable to find new selection");
+    const splitTextNodes = slate.Range.isRange(newRange) ? [...slate.Editor.nodes(editor, {
+      at: newRange,
+      match: (node) => slate.Text.isText(node)
+    })] : [];
+    for (const [node, path] of splitTextNodes) {
+      const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
+      slate.Transforms.setNodes(editor, {
+        marks
+      }, {
+        at: path,
+        match: slate.Text.isText,
+        split: !0,
+        hanging: !0
+      });
+    }
+  } else {
+    if (!Array.from(slate.Editor.nodes(editor, {
+      at: selection,
+      match: (node) => editor.isTextSpan(node)
+    }))?.at(0))
+      return;
+    const [block, blockPath] = slate.Editor.node(editor, selection, {
+      depth: 1
+    }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+    if (lonelyEmptySpan) {
+      const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
+      slate.Transforms.setNodes(editor, {
+        marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
+      }, {
+        at: blockPath,
+        match: (node) => editor.isTextSpan(node)
+      });
+    } else {
+      const existingMarks = {
+        ...slate.Editor.marks(editor) || {}
+      }.marks || [], marks = {
+        ...slate.Editor.marks(editor) || {},
+        marks: [...existingMarks, mark]
+      };
+      editor.marks = marks;
+    }
+  }
+  if (editor.selection) {
+    const selection2 = editor.selection;
+    editor.selection = {
+      ...selection2
+    };
+  }
 }, deleteActionImplementation = ({
   action
 }) => {
@@ -4469,63 +4423,6 @@ const insertTextActionImplementation = ({
     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({
-    action: {
-      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({
-    action: {
-      at: action.at,
-      to: [{
-        _key: destinationBlockKey
-      }],
-      editor: action.editor
-    }
-  });
 }, noopActionImplementation = () => {
 }, selectActionImplementation = ({
   action
@@ -4535,13 +4432,11 @@ const insertTextActionImplementation = ({
 }, debug$9 = debugWithName("behaviors:action"), behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
-  "annotation.toggle": toggleAnnotationActionImplementation,
   "block.set": blockSetBehaviorActionImplementation,
   "block.unset": blockUnsetBehaviorActionImplementation,
   blur: blurActionImplementation,
   "decorator.add": decoratorAddActionImplementation,
   "decorator.remove": removeDecoratorActionImplementation,
-  "decorator.toggle": toggleDecoratorActionImplementation,
   focus: focusActionImplementation,
   delete: deleteActionImplementation,
   "delete.backward": deleteBackwardActionImplementation,
@@ -4558,8 +4453,6 @@ const insertTextActionImplementation = ({
   "insert.text": insertTextActionImplementation,
   effect: effectActionImplementation,
   "move.block": moveBlockActionImplementation,
-  "move.block down": moveBlockDownActionImplementation,
-  "move.block up": moveBlockUpActionImplementation,
   noop: noopActionImplementation,
   select: selectActionImplementation
 };
@@ -4582,13 +4475,6 @@ function performAction({
       });
       break;
     }
-    case "annotation.toggle": {
-      behaviorActionImplementations["annotation.toggle"]({
-        context,
-        action
-      });
-      break;
-    }
     case "block.set": {
       behaviorActionImplementations["block.set"]({
         context,
@@ -4624,13 +4510,6 @@ function performAction({
       });
       break;
     }
-    case "decorator.toggle": {
-      behaviorActionImplementations["decorator.toggle"]({
-        context,
-        action
-      });
-      break;
-    }
     case "delete": {
       behaviorActionImplementations.delete({
         context,
@@ -4743,20 +4622,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: {
@@ -4768,65 +4633,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,
@@ -5637,7 +5447,7 @@ const withPlugins = (editor, options) => {
     editorActor,
     schemaTypes
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
-  return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
+  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);
@@ -5659,17 +5469,67 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const keyIs = {
-  lineBreak: (event) => event.key === "Enter" && event.shiftKey
-}, raiseInsertSoftBreak = behavior_core.defineBehavior({
-  on: "keyboard.keydown",
+const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
+  on: "annotation.toggle",
   guard: ({
+    snapshot,
     event
-  }) => keyIs.lineBreak(event.originEvent),
-  actions: [() => [behavior_core.raise({
-    type: "insert.soft break"
+  }) => selector_isSelectingEntireBlocks.isActiveAnnotation(event.annotation.name)(snapshot),
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "annotation.remove",
+    annotation: event.annotation
+  })]]
+}), behavior_core.defineBehavior({
+  on: "annotation.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => !selector_isSelectingEntireBlocks.isActiveAnnotation(event.annotation.name)(snapshot),
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "annotation.add",
+    annotation: event.annotation
   })]]
-}), internalInsertBehaviors = [behavior_core.defineBehavior({
+})], abstractDecoratorBehaviors = [behavior_core.defineBehavior({
+  on: "decorator.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)(snapshot),
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    type: "decorator.remove",
+    decorator: event.decorator
+  })]]
+}), behavior_core.defineBehavior({
+  on: "decorator.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const manualSelection = event.offsets ? util_selectionPointToBlockOffset.blockOffsetsToSelection({
+      value: snapshot.context.value,
+      offsets: event.offsets
+    }) : null;
+    return manualSelection ? !selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: manualSelection
+      }
+    }) : !selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)(snapshot);
+  },
+  actions: [({
+    event
+  }) => [behavior_core.raise({
+    ...event,
+    type: "decorator.add"
+  })]]
+})], abstractInsertBehaviors = [behavior_core.defineBehavior({
   on: "insert.blocks",
   guard: ({
     event
@@ -5745,7 +5605,7 @@ const keyIs = {
     placement: index === 0 ? "auto" : "after",
     select: "end"
   }))]
-})], internalListItemBehaviors = [behavior_core.defineBehavior({
+})], abstractListItemBehaviors = [behavior_core.defineBehavior({
   on: "list item.add",
   guard: ({
     snapshot
@@ -5802,7 +5662,75 @@ const keyIs = {
     type: "list item.add",
     listItem: event.listItem
   })]]
-})], internalSelectBehaviors = [behavior_core.defineBehavior({
+})], abstractMoveBehaviors = [behavior_core.defineBehavior({
+  on: "move.block up",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const previousBlock = selector_isOverlappingSelection.getPreviousBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
+          },
+          focus: {
+            path: event.at,
+            offset: 0
+          }
+        }
+      }
+    });
+    return previousBlock ? {
+      previousBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    previousBlock
+  }) => [behavior_core.raise({
+    type: "move.block",
+    at: event.at,
+    to: previousBlock.path
+  })]]
+}), behavior_core.defineBehavior({
+  on: "move.block down",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const nextBlock = selector_isOverlappingSelection.getNextBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
+          },
+          focus: {
+            path: event.at,
+            offset: 0
+          }
+        }
+      }
+    });
+    return nextBlock ? {
+      nextBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    nextBlock
+  }) => [behavior_core.raise({
+    type: "move.block",
+    at: event.at,
+    to: nextBlock.path
+  })]]
+})], abstractSelectBehaviors = [behavior_core.defineBehavior({
   on: "select.previous block",
   guard: ({
     snapshot,
@@ -5848,7 +5776,7 @@ const keyIs = {
     type: "select",
     selection
   })]]
-})], internalStyleBehaviors = [behavior_core.defineBehavior({
+})], abstractStyleBehaviors = [behavior_core.defineBehavior({
   on: "style.add",
   guard: ({
     snapshot
@@ -5904,65 +5832,15 @@ const keyIs = {
     type: "style.add",
     style: event.style
   })]]
-})], toggleAnnotationOff = behavior_core.defineBehavior({
-  on: "annotation.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => selector_isSelectingEntireBlocks.isActiveAnnotation(event.annotation.name)(snapshot),
-  actions: [({
-    event
-  }) => [behavior_core.raise({
-    type: "annotation.remove",
-    annotation: event.annotation
-  })]]
-}), toggleAnnotationOn = behavior_core.defineBehavior({
-  on: "annotation.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => !selector_isSelectingEntireBlocks.isActiveAnnotation(event.annotation.name)(snapshot),
-  actions: [({
-    event
-  }) => [behavior_core.raise({
-    type: "annotation.add",
-    annotation: event.annotation
-  })]]
-}), toggleDecoratorOff = behavior_core.defineBehavior({
-  on: "decorator.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)(snapshot),
-  actions: [({
-    event
-  }) => [behavior_core.raise({
-    type: "decorator.remove",
-    decorator: event.decorator
-  })]]
-}), toggleDecoratorOn = behavior_core.defineBehavior({
-  on: "decorator.toggle",
+})], keyIs = {
+  lineBreak: (event) => event.key === "Enter" && event.shiftKey
+}, raiseInsertSoftBreak = behavior_core.defineBehavior({
+  on: "keyboard.keydown",
   guard: ({
-    snapshot,
-    event
-  }) => {
-    const manualSelection = event.offsets ? util_selectionPointToBlockOffset.blockOffsetsToSelection({
-      value: snapshot.context.value,
-      offsets: event.offsets
-    }) : null;
-    return manualSelection ? !selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: manualSelection
-      }
-    }) : !selector_isSelectingEntireBlocks.isActiveDecorator(event.decorator)(snapshot);
-  },
-  actions: [({
     event
-  }) => [behavior_core.raise({
-    ...event,
-    type: "decorator.add"
+  }) => keyIs.lineBreak(event.originEvent),
+  actions: [() => [behavior_core.raise({
+    type: "insert.soft break"
   })]]
 }), raiseDeserializationSuccessOrFailure = behavior_core.defineBehavior({
   on: "deserialize",
@@ -6292,45 +6170,30 @@ const keyIs = {
       originEvent: event
     })]]
   }),
-  ...internalInsertBehaviors,
-  ...internalListItemBehaviors,
-  ...internalStyleBehaviors,
-  ...internalSelectBehaviors,
-  toggleAnnotationOff,
-  toggleAnnotationOn,
-  toggleDecoratorOff,
-  toggleDecoratorOn,
+  ...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,
@@ -6343,7 +6206,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) => {
@@ -6462,6 +6325,34 @@ function performEvent({
     }), editor.onChange();
   }
 }
+function slateChildrenToBlocks(schema2, value) {
+  const blocks = new Array(value.length);
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex];
+    if (descendant._type !== schema2.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 === schema2.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: schema2,
   slateEditorInstance
@@ -6480,7 +6371,7 @@ function createEditorSnapshot({
   hasTag,
   internalDrag
 }) {
-  const value = fromSlateValue(editor.children, schema2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), selection = toPortableTextRange(value, editor.selection, schema2);
+  const value = slateChildrenToBlocks(schema2, editor.children), selection = toPortableTextRange(value, editor.selection, schema2);
   return {
     context: {
       activeDecorators: getActiveDecorators({
@@ -6576,7 +6467,7 @@ const editorMachine = xstate.setup({
       event,
       self
     }) => {
-      xstate.assertEvent(event, ["behavior event", "custom behavior event"]), performEvent({
+      xstate.assertEvent(event, ["behavior event"]), performEvent({
         behaviors: [...context.behaviors.values(), ...defaultBehaviors],
         event: event.behaviorEvent,
         editor: event.editor,
@@ -6775,87 +6666,6 @@ const editorMachine = xstate.setup({
             },
             "behavior event": {
               actions: "handle behavior event"
-            },
-            "custom behavior event": {
-              actions: "handle behavior event"
-            },
-            "annotation.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "block.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            blur: {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "custom.*": {
-              actions: xstate.emit(({
-                event
-              }) => ({
-                type: "custom.*",
-                event
-              }))
-            },
-            "decorator.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "delete.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            focus: {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "history.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "insert.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "list item.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "move.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            select: {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "select.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "style.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
-            },
-            "text block.*": {
-              actions: xstate.emit(({
-                event
-              }) => event)
             }
           },
           initial: "idle",
@@ -6967,12 +6777,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;
 }
@@ -7004,10 +6808,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),
@@ -7063,7 +6864,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) {