@portabletext/editor 1.47.6 → 1.47.8

package/lib/_chunks-es/editor-provider.js

@@ -1,8 +1,8 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
-import { c } from "react-compiler-runtime";
-import React, { useEffect, useMemo, createContext, useContext, useState, startTransition, Component } from "react";
-import { withReact, ReactEditor, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
+import React, { useEffect, createContext, useContext, useState, startTransition, Component, useMemo } from "react";
+import { withReact, ReactEditor, Slate } from "slate-react";
+import { c } from "react-compiler-runtime";
 import debug$g from "debug";
 import isEqual from "lodash/isEqual.js";
 import { Element, Text, Editor, Path, Operation, Transforms, Node, Range, Point, createEditor } from "slate";
@@ -14,7 +14,7 @@ import isPlainObject from "lodash/isPlainObject.js";
 import uniq from "lodash/uniq.js";
 import getRandomValues from "get-random-values-esm";
 import { parseBlock, parseAnnotation, isTextBlock, parseInlineObject } from "./parse-blocks.js";
-import { sliceBlocks, blockOffsetToSpanSelectionPoint, getBlockEndPoint, getBlockStartPoint, getTextBlockText } from "./util.slice-blocks.js";
+import { sliceBlocks, blockOffsetToSpanSelectionPoint, isEmptyTextBlock, getBlockEndPoint, getBlockStartPoint, getTextBlockText } from "./util.slice-blocks.js";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
@@ -25,9 +25,9 @@ import omit from "lodash/omit.js";
 import { selectionPointToBlockOffset, blockOffsetsToSelection } from "./util.selection-point-to-block-offset.js";
 import { getTrimmedSelection, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, isSelectingEntireBlocks, getActiveAnnotations } from "./selector.is-selecting-entire-blocks.js";
 import { DOMEditor } from "slate-dom";
+import startCase from "lodash.startcase";
 import { defineBehavior, raise, coreBehaviors } from "./behavior.core.js";
 import { getFocusTextBlock, getPreviousBlock, getNextBlock, getFocusSpan, isSelectionCollapsed, isOverlappingSelection, getSelectedBlocks, isSelectionExpanded } from "./selector.is-overlapping-selection.js";
-import startCase from "lodash.startcase";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
 const rootName = "sanity-pte:";
@@ -5070,2173 +5070,2178 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const abstractAnnotationBehaviors = [defineBehavior({
-  on: "annotation.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => isActiveAnnotation(event.annotation.name)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "annotation.remove",
-    annotation: event.annotation
-  })]]
-}), defineBehavior({
-  on: "annotation.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => !isActiveAnnotation(event.annotation.name)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "annotation.add",
-    annotation: event.annotation
-  })]]
-})], abstractDecoratorBehaviors = [defineBehavior({
-  on: "decorator.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => isActiveDecorator(event.decorator)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "decorator.remove",
-    decorator: event.decorator
-  })]]
-}), defineBehavior({
-  on: "decorator.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const manualSelection = event.at ? blockOffsetsToSelection({
-      value: snapshot.context.value,
-      offsets: event.at
-    }) : null;
-    return manualSelection ? !isActiveDecorator(event.decorator)({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: manualSelection
+function createLegacySchema(portableTextType) {
+  if (!portableTextType)
+    throw new Error("Parameter 'portabletextType' missing (required)");
+  const blockType = portableTextType.of?.find(findBlockType);
+  if (!blockType)
+    throw new Error("Block type is not defined in this schema (required)");
+  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  if (!childrenField)
+    throw new Error("Children field for block type found in schema (required)");
+  const ofType = childrenField.type.of;
+  if (!ofType)
+    throw new Error("Valid types for block children not found in schema (required)");
+  const spanType = ofType.find((memberType) => memberType.name === "span");
+  if (!spanType)
+    throw new Error("Span type not found in schema (required)");
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
+  return {
+    styles: resolveEnabledStyles(blockType),
+    decorators: resolveEnabledDecorators(spanType),
+    lists: resolveEnabledListItems(blockType),
+    block: blockType,
+    span: spanType,
+    portableText: portableTextType,
+    inlineObjects: inlineObjectTypes,
+    blockObjects: blockObjectTypes,
+    annotations: spanType.annotations
+  };
+}
+function resolveEnabledStyles(blockType) {
+  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  if (!styleField)
+    throw new Error("A field with name 'style' is not defined in the block type (required).");
+  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
+  if (!textStyles || textStyles.length === 0)
+    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
+  return textStyles;
+}
+function resolveEnabledDecorators(spanType) {
+  return spanType.decorators;
+}
+function resolveEnabledListItems(blockType) {
+  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  if (!listField)
+    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
+  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
+  if (!listItems)
+    throw new Error("The list field need at least to be an empty array");
+  return listItems;
+}
+function findBlockType(type) {
+  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
+}
+function defineSchema(definition) {
+  return definition;
+}
+const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
+  image: temporaryImageName,
+  url: temporaryUrlName
+}, objectNames = {
+  [temporaryImageName]: "image",
+  [temporaryUrlName]: "url"
+}, defaultObjectTitles = {
+  image: "Image",
+  url: "URL"
+};
+function legacySchemaToEditorSchema(schema) {
+  return {
+    annotations: schema.annotations.map((annotation) => ({
+      name: annotation.name,
+      fields: annotation.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: annotation.title
+    })),
+    block: {
+      name: schema.block.name
+    },
+    blockObjects: schema.blockObjects.map((blockObject) => ({
+      name: blockObject.name,
+      fields: blockObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: blockObject.title
+    })),
+    decorators: schema.decorators.map((decorator) => ({
+      name: decorator.value,
+      title: decorator.title,
+      value: decorator.value
+    })),
+    inlineObjects: schema.inlineObjects.map((inlineObject) => ({
+      name: inlineObject.name,
+      fields: inlineObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType
+      })),
+      title: inlineObject.title
+    })),
+    span: {
+      name: schema.span.name
+    },
+    styles: schema.styles.map((style) => ({
+      name: style.value,
+      title: style.title,
+      value: style.value
+    })),
+    lists: schema.lists.map((list) => ({
+      name: list.value,
+      title: list.title,
+      value: list.value
+    }))
+  };
+}
+function compileSchemaDefinitionToLegacySchema(definition) {
+  const blockObjects = definition?.blockObjects?.map((blockObject) => defineType({
+    type: "object",
+    // Very naive way to work around `SanitySchema.compile` adding default
+    // fields to objects with certain names.
+    name: temporaryObjectNames[blockObject.name] ?? blockObject.name,
+    title: blockObject.title === void 0 ? (
+      // This avoids the default title which is a title case of the object name
+      defaultObjectTitles[blockObject.name]
+    ) : blockObject.title,
+    fields: blockObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
+  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => defineType({
+    type: "object",
+    // Very naive way to work around `SanitySchema.compile` adding default
+    // fields to objects with certain names.
+    name: temporaryObjectNames[inlineObject.name] ?? inlineObject.name,
+    title: inlineObject.title === void 0 ? (
+      // This avoids the default title which is a title case of the object name
+      defaultObjectTitles[inlineObject.name]
+    ) : inlineObject.title,
+    fields: inlineObject.fields?.map((field) => ({
+      name: field.name,
+      type: field.type
+    })) ?? []
+  })) ?? [], portableTextSchema = defineField({
+    type: "array",
+    name: "portable-text",
+    of: [...blockObjects.map((blockObject) => ({
+      type: blockObject.name
+    })), {
+      type: "block",
+      name: "block",
+      of: inlineObjects.map((inlineObject) => ({
+        type: inlineObject.name
+      })),
+      marks: {
+        decorators: definition?.decorators?.map((decorator) => ({
+          title: decorator.title ?? startCase(decorator.name),
+          value: decorator.name
+        })) ?? [],
+        annotations: definition?.annotations?.map((annotation) => ({
+          name: annotation.name,
+          type: "object",
+          title: annotation.title,
+          fields: annotation.fields?.map((field) => ({
+            name: field.name,
+            type: field.type
+          })) ?? []
+        })) ?? []
+      },
+      lists: definition?.lists?.map((list) => ({
+        value: list.name,
+        title: list.title ?? startCase(list.name)
+      })) ?? [],
+      styles: definition?.styles?.map((style) => ({
+        value: style.name,
+        title: style.title ?? startCase(style.name)
+      })) ?? []
+    }]
+  }), schema = Schema.compile({
+    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
+  }).get("portable-text"), pteSchema = createLegacySchema(schema);
+  return {
+    ...pteSchema,
+    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
+      ...blockObject,
+      name: objectNames[blockObject.name],
+      type: {
+        ...blockObject.type,
+        name: objectNames[blockObject.name]
       }
-    }) : !isActiveDecorator(event.decorator)(snapshot);
-  },
-  actions: [({
-    event
-  }) => [raise({
-    ...event,
-    type: "decorator.add"
-  })]]
-})], abstractDeleteBehaviors = [defineBehavior({
-  on: "delete.text",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const selection = blockOffsetsToSelection({
-      value: snapshot.context.value,
-      offsets: event.at
-    });
-    if (!selection)
-      return !1;
-    const trimmedSelection = getTrimmedSelection({
-      context: {
-        converters: [],
-        schema: snapshot.context.schema,
-        keyGenerator: snapshot.context.keyGenerator,
-        activeDecorators: [],
-        readOnly: !1,
-        value: snapshot.context.value,
-        selection
-      }
-    });
-    return trimmedSelection ? {
-      selection: trimmedSelection
-    } : !1;
-  },
-  actions: [(_, {
-    selection
-  }) => [raise({
-    type: "delete",
-    at: selection
-  })]]
-})], abstractInsertBehaviors = [defineBehavior({
-  on: "insert.blocks",
-  guard: ({
-    event
-  }) => event.placement === "before",
-  actions: [({
-    event
-  }) => event.blocks.map((block, index) => raise({
-    type: "insert.block",
-    block,
-    placement: index === 0 ? "before" : "after",
-    select: "end"
-  }))]
-}), defineBehavior({
-  on: "insert.blocks",
-  guard: ({
-    event
-  }) => event.placement === "after",
-  actions: [({
-    event
-  }) => event.blocks.map((block) => raise({
-    type: "insert.block",
-    block,
-    placement: "after",
-    select: "end"
-  }))]
-}), defineBehavior({
-  on: "insert.blocks",
-  guard: ({
-    snapshot,
-    event
-  }) => !(event.placement !== "auto" || !getFocusTextBlock(snapshot)),
-  actions: [({
-    event
-  }) => event.blocks.length === 1 ? [raise({
-    type: "insert.block",
-    block: event.blocks[0],
-    placement: "auto",
-    select: "end"
-  })] : event.blocks.flatMap((block, index) => index === 0 ? [raise({
-    type: "split.block"
-  }), raise({
-    type: "select.previous block",
-    select: "end"
-  }), raise({
-    type: "insert.block",
-    block,
-    placement: "auto",
-    select: "end"
-  })] : index === event.blocks.length - 1 ? [raise({
-    type: "select.next block",
-    select: "start"
-  }), raise({
-    type: "insert.block",
-    block,
-    placement: "auto",
-    select: "end"
-  })] : [raise({
-    type: "insert.block",
-    block,
-    placement: "after",
-    select: "end"
-  })])]
-}), defineBehavior({
-  on: "insert.blocks",
-  guard: ({
-    event
-  }) => event.placement === "auto",
-  actions: [({
-    event
-  }) => event.blocks.map((block, index) => raise({
-    type: "insert.block",
-    block,
-    placement: index === 0 ? "auto" : "after",
-    select: "end"
-  }))]
-}), defineBehavior({
-  on: "insert.break",
-  actions: [() => [raise({
-    type: "split.block"
-  })]]
-}), defineBehavior({
-  on: "insert.soft break",
-  actions: [() => [raise({
-    type: "insert.text",
-    text: `
-`
-  })]]
-})], abstractListItemBehaviors = [defineBehavior({
-  on: "list item.add",
-  guard: ({
-    snapshot
-  }) => ({
-    selectedTextBlocks: getSelectedTextBlocks(snapshot)
-  }),
-  actions: [({
-    event
-  }, {
-    selectedTextBlocks
-  }) => selectedTextBlocks.map((block) => raise({
-    type: "block.set",
-    at: block.path,
-    props: {
-      level: 1,
-      listItem: event.listItem
-    }
-  }))]
-}), defineBehavior({
-  on: "list item.remove",
-  guard: ({
-    snapshot
-  }) => ({
-    selectedTextBlocks: getSelectedTextBlocks(snapshot)
-  }),
-  actions: [(_, {
-    selectedTextBlocks
-  }) => selectedTextBlocks.map((block) => raise({
-    type: "block.unset",
-    at: block.path,
-    props: ["level", "listItem"]
-  }))]
-}), defineBehavior({
-  on: "list item.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => isActiveListItem(event.listItem)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "list item.remove",
-    listItem: event.listItem
-  })]]
-}), defineBehavior({
-  on: "list item.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => !isActiveListItem(event.listItem)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "list item.add",
-    listItem: event.listItem
-  })]]
-})], abstractMoveBehaviors = [defineBehavior({
-  on: "move.block up",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const previousBlock = getPreviousBlock({
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: {
-            path: event.at,
-            offset: 0
-          },
-          focus: {
-            path: event.at,
-            offset: 0
-          }
-        }
-      }
-    });
-    return previousBlock ? {
-      previousBlock
-    } : !1;
-  },
-  actions: [({
-    event
-  }, {
-    previousBlock
-  }) => [raise({
-    type: "move.block",
-    at: event.at,
-    to: previousBlock.path
-  })]]
-}), defineBehavior({
-  on: "move.block down",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const nextBlock = getNextBlock({
-      context: {
-        ...snapshot.context,
-        selection: {
-          anchor: {
-            path: event.at,
-            offset: 0
-          },
-          focus: {
-            path: event.at,
-            offset: 0
-          }
-        }
-      }
-    });
-    return nextBlock ? {
-      nextBlock
-    } : !1;
-  },
-  actions: [({
-    event
-  }, {
-    nextBlock
-  }) => [raise({
-    type: "move.block",
-    at: event.at,
-    to: nextBlock.path
-  })]]
-})], abstractSelectBehaviors = [defineBehavior({
-  on: "select.previous block",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const previousBlock = getPreviousBlock(snapshot);
-    if (!previousBlock)
-      return !1;
-    const point = event.select === "end" ? getBlockEndPoint(previousBlock) : getBlockStartPoint(previousBlock);
-    return {
-      selection: {
-        anchor: point,
-        focus: point
-      }
-    };
-  },
-  actions: [(_, {
-    selection
-  }) => [raise({
-    type: "select",
-    at: selection
-  })]]
-}), defineBehavior({
-  on: "select.next block",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    const nextBlock = getNextBlock(snapshot);
-    if (!nextBlock)
-      return !1;
-    const point = event.select === "end" ? getBlockEndPoint(nextBlock) : getBlockStartPoint(nextBlock);
-    return {
-      selection: {
-        anchor: point,
-        focus: point
-      }
-    };
-  },
-  actions: [(_, {
-    selection
-  }) => [raise({
-    type: "select",
-    at: selection
-  })]]
-})], abstractStyleBehaviors = [defineBehavior({
-  on: "style.add",
-  guard: ({
-    snapshot
-  }) => ({
-    selectedTextBlocks: getSelectedTextBlocks(snapshot)
-  }),
-  actions: [({
-    event
-  }, {
-    selectedTextBlocks
-  }) => selectedTextBlocks.map((block) => raise({
-    type: "block.set",
-    at: block.path,
-    props: {
-      style: event.style
+    } : blockObject),
+    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
+      ...inlineObject,
+      name: objectNames[inlineObject.name]
+    } : inlineObject)
+  };
+}
+function slateChildrenToBlocks(schema, value) {
+  const blocks = new Array(value.length);
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex];
+    if (descendant._type !== schema.block.name) {
+      blocks[blockIndex] = {
+        _key: descendant._key,
+        _type: descendant._type,
+        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
+      };
+      continue;
     }
-  }))]
-}), defineBehavior({
-  on: "style.remove",
-  guard: ({
-    snapshot
-  }) => ({
-    selectedTextBlocks: getSelectedTextBlocks(snapshot)
-  }),
-  actions: [(_, {
-    selectedTextBlocks
-  }) => selectedTextBlocks.map((block) => raise({
-    type: "block.unset",
-    at: block.path,
-    props: ["style"]
-  }))]
-}), defineBehavior({
-  on: "style.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => isActiveStyle(event.style)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "style.remove",
-    style: event.style
-  })]]
-}), defineBehavior({
-  on: "style.toggle",
-  guard: ({
-    snapshot,
-    event
-  }) => !isActiveStyle(event.style)(snapshot),
-  actions: [({
-    event
-  }) => [raise({
-    type: "style.add",
-    style: event.style
-  })]]
-})], keyIs = {
-  lineBreak: (event) => event.key === "Enter" && event.shiftKey
-}, raiseInsertSoftBreak = defineBehavior({
-  on: "keyboard.keydown",
-  guard: ({
-    event
-  }) => keyIs.lineBreak(event.originEvent),
-  actions: [() => [raise({
-    type: "insert.soft break"
-  })]]
-}), raiseDeserializationSuccessOrFailure = defineBehavior({
-  on: "deserialize",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    let success;
-    const failures = [];
-    for (const converter of snapshot.context.converters) {
-      const data = event.originEvent.originEvent.dataTransfer.getData(converter.mimeType);
-      if (!data)
-        continue;
-      const deserializeEvent = converter.deserialize({
-        snapshot,
-        event: {
-          type: "deserialize",
-          data
-        }
-      });
-      if (deserializeEvent.type === "deserialization.success") {
-        success = deserializeEvent;
-        break;
-      } else
-        failures.push(deserializeEvent);
+    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+      const child = children[childIndex];
+      processedChildren[childIndex] = child._type === schema.span.name ? child : {
+        _key: child._key,
+        _type: child._type,
+        ..."value" in child && typeof child.value == "object" ? child.value : {}
+      };
     }
-    return success || {
-      type: "deserialization.failure",
-      mimeType: "*/*",
-      reason: failures.map((failure) => failure.reason).join(", ")
+    blocks[blockIndex] = {
+      ...descendant,
+      children: processedChildren
     };
-  },
-  actions: [({
-    event
-  }, deserializeEvent) => [raise({
-    ...deserializeEvent,
-    originEvent: event.originEvent
-  })]]
-}), raiseSerializationSuccessOrFailure = defineBehavior({
-  on: "serialize",
-  guard: ({
-    snapshot,
-    event
-  }) => {
-    if (snapshot.context.converters.length === 0)
-      return !1;
-    const serializeEvents = snapshot.context.converters.map((converter) => converter.serialize({
-      snapshot,
-      event: {
-        ...event,
-        originEvent: event.originEvent.type
-      }
-    }));
-    return serializeEvents.length === 0 ? !1 : serializeEvents;
-  },
-  actions: [({
-    event
-  }, serializeEvents) => serializeEvents.map((serializeEvent) => raise({
-    ...serializeEvent,
-    originEvent: event.originEvent
-  }))]
-}), defaultBehaviors = [
-  defineBehavior({
-    on: "clipboard.copy",
-    guard: ({
-      snapshot
-    }) => {
-      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
-      return focusSpan && selectionCollapsed;
+  }
+  return blocks;
+}
+function getActiveDecorators({
+  schema,
+  slateEditorInstance
+}) {
+  const decorators = schema.decorators.map((decorator) => decorator.name);
+  return ({
+    ...Editor.marks(slateEditorInstance) ?? {}
+  }.marks ?? []).filter((mark) => decorators.includes(mark));
+}
+function defaultCompare(a, b) {
+  return a === b;
+}
+function useEditorSelector(editor, selector, t0) {
+  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
+  let t1;
+  return $[0] !== editor || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
+    const snapshot = getEditorSnapshot({
+      editorActorSnapshot,
+      slateEditorInstance: editor._internal.slateEditor.instance
+    });
+    return selector(snapshot);
+  }, $[0] = editor, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
+}
+function getEditorSnapshot({
+  editorActorSnapshot,
+  slateEditorInstance
+}) {
+  return {
+    context: {
+      converters: [...editorActorSnapshot.context.converters],
+      activeDecorators: getActiveDecorators({
+        schema: editorActorSnapshot.context.schema,
+        slateEditorInstance
+      }),
+      keyGenerator: editorActorSnapshot.context.keyGenerator,
+      readOnly: editorActorSnapshot.matches({
+        "edit mode": "read only"
+      }),
+      schema: editorActorSnapshot.context.schema,
+      selection: editorActorSnapshot.context.selection,
+      value: slateChildrenToBlocks(editorActorSnapshot.context.schema, slateEditorInstance.children)
+    },
+    beta: {
+      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
+      internalDrag: editorActorSnapshot.context.internalDrag
+    }
+  };
+}
+const debug$3 = debugWithName("API:editable");
+function createEditableAPI(editor, editorActor) {
+  const types = editorActor.getSnapshot().context.schema;
+  return {
+    focus: () => {
+      editorActor.send({
+        type: "focus",
+        editor
+      });
+    },
+    blur: () => {
+      editorActor.send({
+        type: "blur",
+        editor
+      });
+    },
+    toggleMark: (mark) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "decorator.toggle",
+          decorator: mark
+        },
+        editor
+      });
+    },
+    toggleList: (listItem) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "list item.toggle",
+          listItem
+        },
+        editor
+      });
+    },
+    toggleBlockStyle: (style) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "style.toggle",
+          style
+        },
+        editor
+      });
+    },
+    isMarkActive: (mark) => {
+      try {
+        return isDecoratorActive({
+          editor,
+          decorator: mark
+        });
+      } catch (err) {
+        return console.warn(err), !1;
+      }
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
-  }),
-  defineBehavior({
-    on: "clipboard.copy",
-    actions: [({
-      event
-    }) => [raise({
-      type: "serialize",
-      originEvent: event
-    })]]
-  }),
-  defineBehavior({
-    on: "clipboard.cut",
-    guard: ({
-      snapshot
-    }) => {
-      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
-      return focusSpan && selectionCollapsed;
+    marks: () => ({
+      ...Editor.marks(editor) || {}
+    }).marks || [],
+    undo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.undo"
+        },
+        editor
+      });
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
-  }),
-  defineBehavior({
-    on: "clipboard.cut",
-    guard: ({
-      snapshot
-    }) => snapshot.context.selection ? {
-      selection: snapshot.context.selection
-    } : !1,
-    actions: [({
-      event
-    }, {
-      selection
-    }) => [raise({
-      type: "serialize",
-      originEvent: event
-    }), raise({
-      type: "delete",
-      at: selection
-    })]]
-  }),
-  defineBehavior({
-    on: "drag.dragstart",
-    actions: [({
-      event
-    }) => [raise({
-      type: "serialize",
-      originEvent: event
-    })]]
-  }),
-  defineBehavior({
-    on: "serialization.success",
-    actions: [({
-      event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        event.originEvent.originEvent.dataTransfer.setData(event.mimeType, event.data);
+    redo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.redo"
+        },
+        editor
+      });
+    },
+    select: (selection) => {
+      const slateSelection = toSlateRange(selection, editor);
+      slateSelection ? Transforms.select(editor, slateSelection) : Transforms.deselect(editor), editor.onChange();
+    },
+    focusBlock: () => {
+      if (editor.selection) {
+        const block = Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+        if (block)
+          return fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
       }
-    }]]
-  }),
-  defineBehavior({
-    on: "serialization.failure",
-    actions: [({
-      event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        console.warn(`Serialization of ${event.mimeType} failed with reason "${event.reason}"`);
+    },
+    focusChild: () => {
+      if (editor.selection) {
+        const block = Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+        if (block && editor.isTextBlock(block))
+          return fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0].children[editor.selection.focus.path[1]];
       }
-    }]]
-  }),
-  defineBehavior({
-    on: "drag.drop",
-    guard: ({
-      snapshot,
-      event
-    }) => {
-      const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
-      return dragOrigin ? isOverlappingSelection(dropPosition)({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
-        }
-      }) : !1;
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
-  }),
-  defineBehavior({
-    on: "drag.drop",
-    actions: [({
-      event
-    }) => [raise({
-      type: "select",
-      at: event.position.selection
-    }), raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  defineBehavior({
-    on: "deserialization.success",
-    guard: ({
-      snapshot,
-      event
-    }) => {
-      if (event.originEvent.type !== "drag.drop" || snapshot.beta.internalDrag === void 0)
+    insertChild: (type, value) => {
+      if (type.name !== types.span.name)
+        return editorActor.send({
+          type: "behavior event",
+          behaviorEvent: {
+            type: "insert.inline object",
+            inlineObject: {
+              name: type.name,
+              value
+            }
+          },
+          editor
+        }), editor.selection ? slateRangeToSelection({
+          schema: editorActor.getSnapshot().context.schema,
+          editor,
+          range: editor.selection
+        })?.focus.path ?? [] : [];
+      if (!editor.selection)
+        throw new Error("The editor has no selection");
+      const [focusBlock] = Array.from(Editor.nodes(editor, {
+        at: editor.selection.focus.path.slice(0, 1),
+        match: (n) => n._type === types.block.name
+      }))[0] || [void 0];
+      if (!focusBlock)
+        throw new Error("No focused text block");
+      if (type.name !== types.span.name && !types.inlineObjects.some((t) => t.name === type.name))
+        throw new Error("This type cannot be inserted as a child to a text block");
+      const child = toSlateValue([{
+        _key: editorActor.getSnapshot().context.keyGenerator(),
+        _type: types.block.name,
+        children: [{
+          _key: editorActor.getSnapshot().context.keyGenerator(),
+          _type: type.name,
+          ...value || {}
+        }]
+      }], {
+        schemaTypes: editorActor.getSnapshot().context.schema
+      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
+      return isSpanNode && focusNode._type !== types.span.name && (debug$3("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+        distance: 1,
+        unit: "character"
+      })), Transforms.insertNodes(editor, child, {
+        select: !0,
+        at: editor.selection
+      }), editor.onChange(), editor.selection ? slateRangeToSelection({
+        schema: editorActor.getSnapshot().context.schema,
+        editor,
+        range: editor.selection
+      })?.focus.path ?? [] : [];
+    },
+    insertBlock: (type, value) => (editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "insert.block",
+        block: {
+          _type: type.name,
+          ...value || {}
+        },
+        placement: "auto"
+      },
+      editor
+    }), editor.selection ? slateRangeToSelection({
+      schema: editorActor.getSnapshot().context.schema,
+      editor,
+      range: editor.selection
+    })?.focus.path ?? [] : []),
+    hasBlockStyle: (style) => {
+      try {
+        return isStyleActive({
+          editor,
+          style
+        });
+      } catch {
         return !1;
-      const dragOrigin = snapshot.beta.internalDrag.origin, dropPosition = event.originEvent.position.selection, droppingOnDragOrigin = dragOrigin ? isOverlappingSelection(dropPosition)({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
+      }
+    },
+    hasListStyle: (listItem) => {
+      try {
+        return isListItemActive({
+          editor,
+          listItem
+        });
+      } catch {
+        return !1;
+      }
+    },
+    isVoid: (element) => ![types.block.name, types.span.name].includes(element._type),
+    findByPath: (path) => {
+      const slatePath = toSlateRange({
+        focus: {
+          path,
+          offset: 0
+        },
+        anchor: {
+          path,
+          offset: 0
         }
-      }) : !1, draggingEntireBlocks = isSelectingEntireBlocks({
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
+      }, editor);
+      if (slatePath) {
+        const [block, blockPath] = Editor.node(editor, slatePath.focus.path.slice(0, 1));
+        if (block && blockPath && typeof block._key == "string") {
+          if (path.length === 1 && slatePath.focus.path.length === 1)
+            return [fromSlateValue([block], types.block.name)[0], [{
+              _key: block._key
+            }]];
+          const ptBlock = fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
+          if (editor.isTextBlock(ptBlock)) {
+            const ptChild = ptBlock.children[slatePath.focus.path[1]];
+            if (ptChild)
+              return [ptChild, [{
+                _key: block._key
+              }, "children", {
+                _key: ptChild._key
+              }]];
+          }
         }
-      }), draggedBlocks = getSelectedBlocks({
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
+      }
+      return [void 0, void 0];
+    },
+    findDOMNode: (element) => {
+      let node;
+      try {
+        const [item] = Array.from(Editor.nodes(editor, {
+          at: [],
+          match: (n) => n._key === element._key
+        }) || [])[0] || [void 0];
+        node = ReactEditor.toDOMNode(editor, item);
+      } catch {
+      }
+      return node;
+    },
+    activeAnnotations: () => {
+      if (!editor.selection || editor.selection.focus.path.length < 2)
+        return [];
+      try {
+        const activeAnnotations = [], spans = Editor.nodes(editor, {
+          at: editor.selection,
+          match: (node) => Text.isText(node) && node.marks !== void 0 && Array.isArray(node.marks) && node.marks.length > 0
+        });
+        for (const [span, path] of spans) {
+          const [block] = Editor.node(editor, path, {
+            depth: 1
+          });
+          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
+            Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
+          });
         }
-      });
-      return droppingOnDragOrigin ? !1 : {
-        draggingEntireBlocks,
-        draggedBlocks,
-        dragOrigin,
-        originEvent: event.originEvent
-      };
+        return activeAnnotations;
+      } catch {
+        return [];
+      }
     },
-    actions: [({
-      event
-    }, {
-      draggingEntireBlocks,
-      draggedBlocks,
-      dragOrigin,
-      originEvent
-    }) => [...draggingEntireBlocks ? draggedBlocks.map((block) => raise({
-      type: "delete.block",
-      at: block.path
-    })) : [raise({
-      type: "delete",
-      at: dragOrigin.selection
-    })], raise({
-      type: "insert.blocks",
-      blocks: event.data,
-      placement: draggingEntireBlocks ? originEvent.position.block === "start" ? "before" : originEvent.position.block === "end" ? "after" : "auto" : "auto"
-    })]]
-  }),
-  /**
-   * If we are pasting text/plain into a text block then we can probably
-   * assume that the intended behavior is that the pasted text inherits
-   * formatting from the text it's pasted into.
-   */
-  defineBehavior({
-    on: "deserialization.success",
-    guard: ({
-      snapshot,
-      event
-    }) => {
-      if (getFocusTextBlock(snapshot) && event.mimeType === "text/plain" && event.originEvent.type === "clipboard.paste") {
-        const activeDecorators = snapshot.context.activeDecorators;
-        return {
-          activeAnnotations: getActiveAnnotations(snapshot),
-          activeDecorators,
-          textRuns: event.data.flatMap((block) => isTextBlock(snapshot.context.schema, block) ? [getTextBlockText(block)] : [])
-        };
+    isAnnotationActive: (annotationType) => isAnnotationActive({
+      editor,
+      annotation: {
+        name: annotationType
       }
-      return !1;
+    }),
+    addAnnotation: (type, value) => {
+      let paths;
+      return Editor.withoutNormalizing(editor, () => {
+        paths = addAnnotationActionImplementation({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: types
+          },
+          action: {
+            annotation: {
+              name: type.name,
+              value: value ?? {}
+            },
+            editor
+          }
+        });
+      }), editor.onChange(), paths;
     },
-    actions: [(_, {
-      activeAnnotations,
-      activeDecorators,
-      textRuns
-    }) => textRuns.flatMap((textRun, index) => index !== textRuns.length - 1 ? [raise({
-      type: "insert.span",
-      text: textRun,
-      decorators: activeDecorators,
-      annotations: activeAnnotations.map(({
-        _key,
-        _type,
-        ...value
-      }) => ({
-        name: _type,
-        value
-      }))
-    }), raise({
-      type: "insert.break"
-    })] : [raise({
-      type: "insert.span",
-      text: textRun,
-      decorators: activeDecorators,
-      annotations: activeAnnotations.map(({
-        _key,
-        _type,
-        ...value
-      }) => ({
-        name: _type,
-        value
-      }))
-    })])]
-  }),
-  defineBehavior({
-    on: "deserialization.success",
-    actions: [({
-      event
-    }) => [raise({
-      type: "insert.blocks",
-      blocks: event.data,
-      placement: "auto"
-    })]]
-  }),
-  defineBehavior({
-    on: "deserialization.failure",
-    actions: [({
-      event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        console.warn(`Deserialization of ${event.mimeType} failed with reason "${event.reason}"`);
+    delete: (selection, options) => {
+      if (selection) {
+        const range = toSlateRange(selection, editor);
+        if (!(range && range.anchor.path.length > 0 && range.focus.path.length > 0))
+          throw new Error("Invalid range");
+        if (range) {
+          if (!options?.mode || options?.mode === "selected") {
+            debug$3("Deleting content in selection"), Transforms.delete(editor, {
+              at: range,
+              hanging: !0,
+              voids: !0
+            }), editor.onChange();
+            return;
+          }
+          options?.mode === "blocks" && (debug$3("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
+            at: range,
+            voids: !0,
+            match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element.isElement(node)
+          })), options?.mode === "children" && (debug$3("Deleting children touched by selection"), Transforms.removeNodes(editor, {
+            at: range,
+            voids: !0,
+            match: (node) => node._type === types.span.name || // Text children
+            !editor.isTextBlock(node) && Element.isElement(node)
+          })), editor.children.length === 0 && (editor.children = [editor.pteCreateTextBlock({
+            decorators: []
+          })]), editor.onChange();
+        }
       }
-    }]]
-  }),
-  defineBehavior({
-    on: "clipboard.paste",
-    guard: ({
-      snapshot
-    }) => snapshot.context.selection && isSelectionExpanded(snapshot) ? {
-      selection: snapshot.context.selection
-    } : !1,
-    actions: [({
-      event
-    }, {
-      selection
-    }) => [raise({
-      type: "delete",
-      at: selection
-    }), raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  defineBehavior({
-    on: "clipboard.paste",
-    actions: [({
-      event
-    }) => [raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  defineBehavior({
-    on: "input.*",
-    actions: [({
-      event
-    }) => [raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  ...abstractAnnotationBehaviors,
-  ...abstractDecoratorBehaviors,
-  ...abstractDeleteBehaviors,
-  ...abstractInsertBehaviors,
-  ...abstractListItemBehaviors,
-  ...abstractMoveBehaviors,
-  ...abstractStyleBehaviors,
-  ...abstractSelectBehaviors,
-  raiseDeserializationSuccessOrFailure,
-  raiseSerializationSuccessOrFailure,
-  raiseInsertSoftBreak
-], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "delete.text", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "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);
+    },
+    removeAnnotation: (type) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "annotation.remove",
+          annotation: {
+            name: type.name
+          }
+        },
+        editor
+      });
+    },
+    getSelection: () => {
+      let ptRange = null;
+      if (editor.selection) {
+        const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
+        if (existing)
+          return existing;
+        ptRange = slateRangeToSelection({
+          schema: editorActor.getSnapshot().context.schema,
+          editor,
+          range: editor.selection
+        }), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+      }
+      return ptRange;
+    },
+    getValue: () => fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+    isCollapsedSelection: () => !!editor.selection && Range.isCollapsed(editor.selection),
+    isExpandedSelection: () => !!editor.selection && Range.isExpanded(editor.selection),
+    insertBreak: () => {
+      editor.insertBreak(), editor.onChange();
+    },
+    getFragment: () => fromSlateValue(editor.getFragment(), types.block.name),
+    isSelectionsOverlapping: (selectionA, selectionB) => {
+      const rangeA = toSlateRange(selectionA, editor), rangeB = toSlateRange(selectionB, editor);
+      return Range.isRange(rangeA) && Range.isRange(rangeB) && Range.includes(rangeA, rangeB);
+    }
+  };
 }
-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 nativeBehaviorEventTypes.includes(event.type);
+function isAnnotationActive({
+  editor,
+  annotation
+}) {
+  if (!editor.selection || editor.selection.focus.path.length < 2)
+    return !1;
+  try {
+    const spans = [...Editor.nodes(editor, {
+      at: editor.selection,
+      match: (node) => Text.isText(node)
+    })];
+    if (spans.length === 0 || spans.some(([span]) => !isPortableTextSpan$1(span) || !span.marks || span.marks?.length === 0)) return !1;
+    const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
+      const [block] = Editor.node(editor, path, {
+        depth: 1
+      });
+      return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
+    }, []);
+    return spans.every(([span]) => isPortableTextSpan$1(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
+  } catch {
+    return !1;
+  }
 }
-function isCustomBehaviorEvent(event) {
-  return event.type.startsWith("custom.");
+function compileSchemasFromEditorConfig(config) {
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), schema = legacySchemaToEditorSchema(legacySchema);
+  return {
+    legacySchema,
+    schema
+  };
 }
-const debug$3 = debugWithName("behaviors:event");
-function eventCategory(event) {
-  return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "abstract" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
+function editorConfigToMachineInput(config) {
+  const {
+    legacySchema,
+    schema
+  } = compileSchemasFromEditorConfig(config);
+  return {
+    behaviors: config.behaviors,
+    converters: createCoreConverters(legacySchema),
+    getLegacySchema: () => legacySchema,
+    keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
+    maxBlocks: config.maxBlocks,
+    readOnly: config.readOnly,
+    schema,
+    initialValue: config.initialValue
+  };
 }
-function performEvent({
-  mode,
-  behaviors,
-  event,
-  editor,
-  keyGenerator,
-  schema,
-  getSnapshot,
-  nativeEvent
-}) {
-  debug$3(`(${eventCategory(event)})`, JSON.stringify(event, null, 2));
-  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
+function createInternalEditor(editorActor) {
+  const slateEditor = createSlateEditor({
+    editorActor
+  }), editable = createEditableAPI(slateEditor.instance, editorActor);
+  return {
+    getSnapshot: () => getEditorSnapshot({
+      editorActorSnapshot: editorActor.getSnapshot(),
+      slateEditorInstance: slateEditor.instance
+    }),
+    registerBehavior: (config) => (editorActor.send({
+      type: "add behavior",
+      behavior: config.behavior
+    }), () => {
+      editorActor.send({
+        type: "remove behavior",
+        behavior: config.behavior
+      });
+    }),
+    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 "blur":
+          editorActor.send({
+            type: "blur",
+            editor: slateEditor.instance
+          });
+          break;
+        case "focus":
+          editorActor.send({
+            type: "focus",
+            editor: slateEditor.instance
+          });
+          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) {
+        case "blurred":
+        case "done loading":
+        case "editable":
+        case "error":
+        case "focused":
+        case "invalid value":
+        case "loading":
+        case "mutation":
+        case "patch":
+        case "read only":
+        case "ready":
+        case "selection":
+        case "value changed":
+          listener(event2);
+          break;
+      }
+    }),
+    _internal: {
+      editable,
+      editorActor,
+      slateEditor
+    }
+  };
+}
+const EditorActorContext = createContext({}), abstractAnnotationBehaviors = [defineBehavior({
+  on: "annotation.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => isActiveAnnotation(event.annotation.name)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "annotation.remove",
+    annotation: event.annotation
+  })]]
+}), defineBehavior({
+  on: "annotation.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => !isActiveAnnotation(event.annotation.name)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "annotation.add",
+    annotation: event.annotation
+  })]]
+})], abstractDecoratorBehaviors = [defineBehavior({
+  on: "decorator.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => isActiveDecorator(event.decorator)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "decorator.remove",
+    decorator: event.decorator
+  })]]
+}), defineBehavior({
+  on: "decorator.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const manualSelection = event.at ? blockOffsetsToSelection({
+      value: snapshot.context.value,
+      offsets: event.at
+    }) : null;
+    return manualSelection ? !isActiveDecorator(event.decorator)({
+      ...snapshot,
+      context: {
+        ...snapshot.context,
+        selection: manualSelection
+      }
+    }) : !isActiveDecorator(event.decorator)(snapshot);
+  },
+  actions: [({
+    event
+  }) => [raise({
     ...event,
-    editor
-  }, eventBehaviors = (mode === "raise" ? [...behaviors, ...defaultBehaviors] : behaviors).filter((behavior) => {
-    if (behavior.on === "*")
-      return !0;
-    const [listenedNamespace] = behavior.on.includes("*") && behavior.on.includes(".") ? behavior.on.split(".") : [void 0], [eventNamespace] = event.type.includes(".") ? event.type.split(".") : [void 0];
-    return listenedNamespace !== void 0 && eventNamespace !== void 0 && listenedNamespace === eventNamespace || listenedNamespace !== void 0 && eventNamespace === void 0 && listenedNamespace === event.type ? !0 : behavior.on === event.type;
-  });
-  if (eventBehaviors.length === 0) {
-    if (!defaultAction)
-      return;
-    withApplyingBehaviorActions(editor, () => {
-      try {
-        performAction({
-          context: {
-            keyGenerator,
-            schema
-          },
-          action: defaultAction
-        });
-      } catch (error) {
-        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+    type: "decorator.add"
+  })]]
+})], abstractDeleteBehaviors = [defineBehavior({
+  on: "delete.text",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const selection = blockOffsetsToSelection({
+      value: snapshot.context.value,
+      offsets: event.at
+    });
+    if (!selection)
+      return !1;
+    const trimmedSelection = getTrimmedSelection({
+      context: {
+        converters: [],
+        schema: snapshot.context.schema,
+        keyGenerator: snapshot.context.keyGenerator,
+        activeDecorators: [],
+        readOnly: !1,
+        value: snapshot.context.value,
+        selection
       }
-    }), editor.onChange();
-    return;
-  }
-  const guardSnapshot = getSnapshot();
-  let behaviorOverwritten = !1;
-  for (const eventBehavior of eventBehaviors) {
-    const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
-      snapshot: guardSnapshot,
-      event
     });
-    if (shouldRun) {
-      for (const actionSet of eventBehavior.actions) {
-        const actionsSnapshot = getSnapshot(), actions = actionSet({
-          snapshot: actionsSnapshot,
-          event
-        }, shouldRun);
-        actions.length !== 0 && (behaviorOverwritten = behaviorOverwritten || actions.some((action) => action.type !== "effect"), withApplyingBehaviorActionSet(editor, () => {
-          for (const action of actions) {
-            if (action.type === "raise") {
-              performEvent({
-                mode,
-                behaviors: mode === "execute" ? isCustomBehaviorEvent(action.event) ? [...behaviors, ...defaultBehaviors] : defaultBehaviors : [...behaviors, ...defaultBehaviors],
-                event: action.event,
-                editor,
-                keyGenerator,
-                schema,
-                getSnapshot,
-                nativeEvent: void 0
-              });
-              continue;
-            }
-            if (action.type === "execute") {
-              if (isAbstractBehaviorEvent(action.event) || isCustomBehaviorEvent(action.event))
-                performEvent({
-                  mode: "execute",
-                  behaviors: isCustomBehaviorEvent(action.event) ? [...behaviors, ...defaultBehaviors] : defaultBehaviors,
-                  event: action.event,
-                  editor,
-                  keyGenerator,
-                  schema,
-                  getSnapshot,
-                  nativeEvent: void 0
-                });
-              else {
-                const internalAction2 = {
-                  ...action.event,
-                  editor
-                };
-                let actionFailed2 = !1;
-                if (withApplyingBehaviorActions(editor, () => {
-                  try {
-                    performAction({
-                      context: {
-                        keyGenerator,
-                        schema
-                      },
-                      action: internalAction2
-                    });
-                  } catch (error) {
-                    console.error(new Error(`Performing action "${action.event.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed2 = !0;
-                  }
-                }), actionFailed2)
-                  break;
-                editor.onChange();
-              }
-              continue;
-            }
-            const internalAction = {
-              ...action,
-              editor
-            };
-            let actionFailed = !1;
-            if (withApplyingBehaviorActions(editor, () => {
-              try {
-                performAction({
-                  context: {
-                    keyGenerator,
-                    schema
-                  },
-                  action: internalAction
-                });
-              } catch (error) {
-                console.error(new Error(`Performing action "${internalAction.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed = !0;
-              }
-            }), actionFailed)
-              break;
-            editor.onChange();
+    return trimmedSelection ? {
+      selection: trimmedSelection
+    } : !1;
+  },
+  actions: [(_, {
+    selection
+  }) => [raise({
+    type: "delete",
+    at: selection
+  })]]
+})], abstractInsertBehaviors = [defineBehavior({
+  on: "insert.blocks",
+  guard: ({
+    event
+  }) => event.placement === "before",
+  actions: [({
+    event
+  }) => event.blocks.map((block, index) => raise({
+    type: "insert.block",
+    block,
+    placement: index === 0 ? "before" : "after",
+    select: "end"
+  }))]
+}), defineBehavior({
+  on: "insert.blocks",
+  guard: ({
+    event
+  }) => event.placement === "after",
+  actions: [({
+    event
+  }) => event.blocks.map((block) => raise({
+    type: "insert.block",
+    block,
+    placement: "after",
+    select: "end"
+  }))]
+}), defineBehavior({
+  on: "insert.blocks",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (event.placement !== "auto")
+      return !1;
+    const focusTextBlock = getFocusTextBlock(snapshot);
+    return focusTextBlock ? {
+      focusTextBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    focusTextBlock
+  }) => event.blocks.length === 1 ? [raise({
+    type: "insert.block",
+    block: event.blocks[0],
+    placement: "auto",
+    select: "end"
+  })] : isEmptyTextBlock(focusTextBlock.node) ? event.blocks.map((block, index) => raise({
+    type: "insert.block",
+    block,
+    placement: index === 0 ? "auto" : "after",
+    select: "end"
+  })) : event.blocks.flatMap((block, index) => index === 0 ? [raise({
+    type: "split.block"
+  }), raise({
+    type: "select.previous block",
+    select: "end"
+  }), raise({
+    type: "insert.block",
+    block,
+    placement: "auto",
+    select: "end"
+  })] : index === event.blocks.length - 1 ? [raise({
+    type: "select.next block",
+    select: "start"
+  }), raise({
+    type: "insert.block",
+    block,
+    placement: "auto",
+    select: "end"
+  })] : [raise({
+    type: "insert.block",
+    block,
+    placement: "after",
+    select: "end"
+  })])]
+}), defineBehavior({
+  on: "insert.blocks",
+  guard: ({
+    event
+  }) => event.placement === "auto",
+  actions: [({
+    event
+  }) => event.blocks.map((block, index) => raise({
+    type: "insert.block",
+    block,
+    placement: index === 0 ? "auto" : "after",
+    select: "end"
+  }))]
+}), defineBehavior({
+  on: "insert.break",
+  actions: [() => [raise({
+    type: "split.block"
+  })]]
+}), defineBehavior({
+  on: "insert.soft break",
+  actions: [() => [raise({
+    type: "insert.text",
+    text: `
+`
+  })]]
+})], abstractListItemBehaviors = [defineBehavior({
+  on: "list item.add",
+  guard: ({
+    snapshot
+  }) => ({
+    selectedTextBlocks: getSelectedTextBlocks(snapshot)
+  }),
+  actions: [({
+    event
+  }, {
+    selectedTextBlocks
+  }) => selectedTextBlocks.map((block) => raise({
+    type: "block.set",
+    at: block.path,
+    props: {
+      level: 1,
+      listItem: event.listItem
+    }
+  }))]
+}), defineBehavior({
+  on: "list item.remove",
+  guard: ({
+    snapshot
+  }) => ({
+    selectedTextBlocks: getSelectedTextBlocks(snapshot)
+  }),
+  actions: [(_, {
+    selectedTextBlocks
+  }) => selectedTextBlocks.map((block) => raise({
+    type: "block.unset",
+    at: block.path,
+    props: ["level", "listItem"]
+  }))]
+}), defineBehavior({
+  on: "list item.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => isActiveListItem(event.listItem)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "list item.remove",
+    listItem: event.listItem
+  })]]
+}), defineBehavior({
+  on: "list item.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => !isActiveListItem(event.listItem)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "list item.add",
+    listItem: event.listItem
+  })]]
+})], abstractMoveBehaviors = [defineBehavior({
+  on: "move.block up",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const previousBlock = getPreviousBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
+          },
+          focus: {
+            path: event.at,
+            offset: 0
           }
-        }));
-      }
-      if (behaviorOverwritten) {
-        nativeEvent?.preventDefault();
-        break;
+        }
       }
-    }
-  }
-  if (!behaviorOverwritten) {
-    if (!defaultAction)
-      return;
-    withApplyingBehaviorActions(editor, () => {
-      try {
-        performAction({
-          context: {
-            keyGenerator,
-            schema
+    });
+    return previousBlock ? {
+      previousBlock
+    } : !1;
+  },
+  actions: [({
+    event
+  }, {
+    previousBlock
+  }) => [raise({
+    type: "move.block",
+    at: event.at,
+    to: previousBlock.path
+  })]]
+}), defineBehavior({
+  on: "move.block down",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const nextBlock = getNextBlock({
+      context: {
+        ...snapshot.context,
+        selection: {
+          anchor: {
+            path: event.at,
+            offset: 0
           },
-          action: defaultAction
-        });
-      } catch (error) {
-        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+          focus: {
+            path: event.at,
+            offset: 0
+          }
+        }
       }
-    }), editor.onChange();
-  }
-}
-function slateChildrenToBlocks(schema, value) {
-  const blocks = new Array(value.length);
-  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
-    const descendant = value[blockIndex];
-    if (descendant._type !== schema.block.name) {
-      blocks[blockIndex] = {
-        _key: descendant._key,
-        _type: descendant._type,
-        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
-      };
-      continue;
-    }
-    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-      const child = children[childIndex];
-      processedChildren[childIndex] = child._type === schema.span.name ? child : {
-        _key: child._key,
-        _type: child._type,
-        ..."value" in child && typeof child.value == "object" ? child.value : {}
-      };
-    }
-    blocks[blockIndex] = {
-      ...descendant,
-      children: processedChildren
-    };
-  }
-  return blocks;
-}
-function getActiveDecorators({
-  schema,
-  slateEditorInstance
-}) {
-  const decorators = schema.decorators.map((decorator) => decorator.name);
-  return ({
-    ...Editor.marks(slateEditorInstance) ?? {}
-  }.marks ?? []).filter((mark) => decorators.includes(mark));
-}
-function createEditorSnapshot({
-  converters,
-  editor,
-  keyGenerator,
-  readOnly,
-  schema,
-  hasTag,
-  internalDrag
-}) {
-  const value = slateChildrenToBlocks(schema, editor.children), selection = editor.selection ? slateRangeToSelection({
-    schema,
-    editor,
-    range: editor.selection
-  }) : null;
-  return {
-    context: {
-      activeDecorators: getActiveDecorators({
-        schema,
-        slateEditorInstance: editor
-      }),
-      converters,
-      keyGenerator,
-      readOnly,
-      schema,
-      selection,
-      value
-    },
-    beta: {
-      hasTag,
-      internalDrag
-    }
-  };
-}
-const editorMachine = setup({
-  types: {
-    context: {},
-    events: {},
-    emitted: {},
-    input: {},
-    tags: {}
+    });
+    return nextBlock ? {
+      nextBlock
+    } : !1;
   },
-  actions: {
-    "add behavior to context": assign({
-      behaviors: ({
-        context,
-        event
-      }) => (assertEvent(event, "add behavior"), /* @__PURE__ */ new Set([...context.behaviors, event.behavior]))
-    }),
-    "remove behavior from context": assign({
-      behaviors: ({
-        context,
-        event
-      }) => (assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
-    }),
-    "assign behaviors": assign({
-      behaviors: ({
-        event
-      }) => (assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...event.behaviors]))
-    }),
-    "assign schema": assign({
-      schema: ({
-        event
-      }) => (assertEvent(event, "update schema"), event.schema)
-    }),
-    "emit patch event": enqueueActions(({
-      event,
-      enqueue
-    }) => {
-      assertEvent(event, "internal.patch"), enqueue.emit(event), enqueue.emit({
-        type: "patch",
-        patch: event.patch
-      });
-    }),
-    "emit mutation event": emit(({
-      event
-    }) => (assertEvent(event, "mutation"), event)),
-    "emit read only": emit({
-      type: "read only"
-    }),
-    "emit editable": emit({
-      type: "editable"
-    }),
-    "defer event": assign({
-      pendingEvents: ({
-        context,
-        event
-      }) => (assertEvent(event, ["internal.patch", "mutation"]), [...context.pendingEvents, event])
-    }),
-    "emit pending events": enqueueActions(({
-      context,
-      enqueue
-    }) => {
-      for (const event of context.pendingEvents)
-        event.type === "internal.patch" ? (enqueue.emit(event), enqueue.emit({
-          type: "patch",
-          patch: event.patch
-        })) : enqueue.emit(event);
-    }),
-    "emit ready": emit({
-      type: "ready"
-    }),
-    "clear pending events": assign({
-      pendingEvents: []
-    }),
-    "handle blur": ({
-      event
-    }) => {
-      assertEvent(event, "blur");
-      try {
-        ReactEditor.blur(event.editor);
-      } catch (error) {
-        console.error(new Error(`Failed to blur editor: ${error.message}`));
-      }
-    },
-    "handle focus": ({
-      context
-    }) => {
-      if (!context.slateEditor) {
-        console.error("No Slate editor found to focus");
-        return;
+  actions: [({
+    event
+  }, {
+    nextBlock
+  }) => [raise({
+    type: "move.block",
+    at: event.at,
+    to: nextBlock.path
+  })]]
+})], abstractSelectBehaviors = [defineBehavior({
+  on: "select.previous block",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const previousBlock = getPreviousBlock(snapshot);
+    if (!previousBlock)
+      return !1;
+    const point = event.select === "end" ? getBlockEndPoint(previousBlock) : getBlockStartPoint(previousBlock);
+    return {
+      selection: {
+        anchor: point,
+        focus: point
       }
-      try {
-        const currentSelection = context.slateEditor.selection;
-        ReactEditor.focus(context.slateEditor), currentSelection && Transforms.select(context.slateEditor, currentSelection);
-      } catch (error) {
-        console.error(new Error(`Failed to focus editor: ${error.message}`));
+    };
+  },
+  actions: [(_, {
+    selection
+  }) => [raise({
+    type: "select",
+    at: selection
+  })]]
+}), defineBehavior({
+  on: "select.next block",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const nextBlock = getNextBlock(snapshot);
+    if (!nextBlock)
+      return !1;
+    const point = event.select === "end" ? getBlockEndPoint(nextBlock) : getBlockStartPoint(nextBlock);
+    return {
+      selection: {
+        anchor: point,
+        focus: point
       }
-    },
-    "handle behavior event": ({
-      context,
-      event,
-      self
-    }) => {
-      assertEvent(event, ["behavior event"]), performEvent({
-        mode: "raise",
-        behaviors: [...context.behaviors.values()],
-        event: event.behaviorEvent,
-        editor: event.editor,
-        keyGenerator: context.keyGenerator,
-        schema: context.schema,
-        getSnapshot: () => createEditorSnapshot({
-          converters: [...context.converters],
-          editor: event.editor,
-          keyGenerator: context.keyGenerator,
-          readOnly: self.getSnapshot().matches({
-            "edit mode": "read only"
-          }),
-          schema: context.schema,
-          hasTag: (tag) => self.getSnapshot().hasTag(tag),
-          internalDrag: context.internalDrag
-        }),
-        nativeEvent: event.nativeEvent
-      });
-    }
+    };
   },
-  guards: {
-    "slate is busy": ({
-      context
-    }) => context.slateEditor ? context.slateEditor.operations.length > 0 : !1
-  }
-}).createMachine({
-  id: "editor",
-  context: ({
-    input
+  actions: [(_, {
+    selection
+  }) => [raise({
+    type: "select",
+    at: selection
+  })]]
+})], abstractStyleBehaviors = [defineBehavior({
+  on: "style.add",
+  guard: ({
+    snapshot
   }) => ({
-    behaviors: /* @__PURE__ */ new Set([...input.behaviors ?? coreBehaviors]),
-    converters: new Set(input.converters ?? []),
-    keyGenerator: input.keyGenerator,
-    pendingEvents: [],
-    schema: input.schema,
-    selection: null,
-    initialReadOnly: input.readOnly ?? !1,
-    maxBlocks: input.maxBlocks,
-    incomingValue: input.initialValue
+    selectedTextBlocks: getSelectedTextBlocks(snapshot)
   }),
-  on: {
-    "notify.blurred": {
-      actions: emit(({
-        event
-      }) => ({
-        ...event,
-        type: "blurred"
-      }))
-    },
-    "notify.done loading": {
-      actions: emit({
-        type: "done loading"
-      })
-    },
-    "notify.error": {
-      actions: emit(({
-        event
-      }) => ({
-        ...event,
-        type: "error"
-      }))
-    },
-    "notify.invalid value": {
-      actions: emit(({
-        event
-      }) => ({
-        ...event,
-        type: "invalid value"
-      }))
-    },
-    "notify.focused": {
-      actions: emit(({
-        event
-      }) => ({
-        ...event,
-        type: "focused"
-      }))
-    },
-    "notify.selection": {
-      actions: [assign({
-        selection: ({
-          event
-        }) => event.selection
-      }), emit(({
-        event
-      }) => ({
-        ...event,
-        type: "selection"
-      }))]
-    },
-    "notify.unset": {
-      actions: emit(({
-        event
-      }) => ({
-        ...event,
-        type: "unset"
-      }))
-    },
-    "notify.loading": {
-      actions: emit({
-        type: "loading"
-      })
-    },
-    "notify.value changed": {
-      actions: emit(({
-        event
-      }) => ({
+  actions: [({
+    event
+  }, {
+    selectedTextBlocks
+  }) => selectedTextBlocks.map((block) => raise({
+    type: "block.set",
+    at: block.path,
+    props: {
+      style: event.style
+    }
+  }))]
+}), defineBehavior({
+  on: "style.remove",
+  guard: ({
+    snapshot
+  }) => ({
+    selectedTextBlocks: getSelectedTextBlocks(snapshot)
+  }),
+  actions: [(_, {
+    selectedTextBlocks
+  }) => selectedTextBlocks.map((block) => raise({
+    type: "block.unset",
+    at: block.path,
+    props: ["style"]
+  }))]
+}), defineBehavior({
+  on: "style.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => isActiveStyle(event.style)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "style.remove",
+    style: event.style
+  })]]
+}), defineBehavior({
+  on: "style.toggle",
+  guard: ({
+    snapshot,
+    event
+  }) => !isActiveStyle(event.style)(snapshot),
+  actions: [({
+    event
+  }) => [raise({
+    type: "style.add",
+    style: event.style
+  })]]
+})], keyIs = {
+  lineBreak: (event) => event.key === "Enter" && event.shiftKey
+}, raiseInsertSoftBreak = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    event
+  }) => keyIs.lineBreak(event.originEvent),
+  actions: [() => [raise({
+    type: "insert.soft break"
+  })]]
+}), raiseDeserializationSuccessOrFailure = defineBehavior({
+  on: "deserialize",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    let success;
+    const failures = [];
+    for (const converter of snapshot.context.converters) {
+      const data = event.originEvent.originEvent.dataTransfer.getData(converter.mimeType);
+      if (!data)
+        continue;
+      const deserializeEvent = converter.deserialize({
+        snapshot,
+        event: {
+          type: "deserialize",
+          data
+        }
+      });
+      if (deserializeEvent.type === "deserialization.success") {
+        success = deserializeEvent;
+        break;
+      } else
+        failures.push(deserializeEvent);
+    }
+    return success || {
+      type: "deserialization.failure",
+      mimeType: "*/*",
+      reason: failures.map((failure) => failure.reason).join(", ")
+    };
+  },
+  actions: [({
+    event
+  }, deserializeEvent) => [raise({
+    ...deserializeEvent,
+    originEvent: event.originEvent
+  })]]
+}), raiseSerializationSuccessOrFailure = defineBehavior({
+  on: "serialize",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (snapshot.context.converters.length === 0)
+      return !1;
+    const serializeEvents = snapshot.context.converters.map((converter) => converter.serialize({
+      snapshot,
+      event: {
         ...event,
-        type: "value changed"
-      }))
-    },
-    "add behavior": {
-      actions: "add behavior to context"
-    },
-    "remove behavior": {
-      actions: "remove behavior from context"
-    },
-    patches: {
-      actions: emit(({
-        event
-      }) => event)
-    },
-    "update behaviors": {
-      actions: "assign behaviors"
-    },
-    "update key generator": {
-      actions: assign({
-        keyGenerator: ({
-          event
-        }) => event.keyGenerator
-      })
-    },
-    "update schema": {
-      actions: "assign schema"
+        originEvent: event.originEvent.type
+      }
+    }));
+    return serializeEvents.length === 0 ? !1 : serializeEvents;
+  },
+  actions: [({
+    event
+  }, serializeEvents) => serializeEvents.map((serializeEvent) => raise({
+    ...serializeEvent,
+    originEvent: event.originEvent
+  }))]
+}), defaultBehaviors = [
+  defineBehavior({
+    on: "clipboard.copy",
+    guard: ({
+      snapshot
+    }) => {
+      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+      return focusSpan && selectionCollapsed;
     },
-    "update value": {
-      actions: assign({
-        incomingValue: ({
-          event
-        }) => event.value
-      })
+    actions: [() => [{
+      type: "noop"
+    }]]
+  }),
+  defineBehavior({
+    on: "clipboard.copy",
+    actions: [({
+      event
+    }) => [raise({
+      type: "serialize",
+      originEvent: event
+    })]]
+  }),
+  defineBehavior({
+    on: "clipboard.cut",
+    guard: ({
+      snapshot
+    }) => {
+      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+      return focusSpan && selectionCollapsed;
     },
-    "update maxBlocks": {
-      actions: assign({
-        maxBlocks: ({
-          event
-        }) => event.maxBlocks
-      })
-    }
-  },
-  type: "parallel",
-  states: {
-    "edit mode": {
-      initial: "read only",
-      states: {
-        "read only": {
-          initial: "determine initial edit mode",
-          on: {
-            "behavior event": {
-              actions: "handle behavior event",
-              guard: ({
-                event
-              }) => event.behaviorEvent.type === "clipboard.copy" || event.behaviorEvent.type === "mouse.click" || event.behaviorEvent.type === "serialize" || event.behaviorEvent.type === "serialization.failure" || event.behaviorEvent.type === "serialization.success" || event.behaviorEvent.type === "select"
-            }
-          },
-          states: {
-            "determine initial edit mode": {
-              on: {
-                "done syncing initial value": [{
-                  target: "#editor.edit mode.read only.read only",
-                  guard: ({
-                    context
-                  }) => context.initialReadOnly
-                }, {
-                  target: "#editor.edit mode.editable"
-                }]
-              }
-            },
-            "read only": {
-              on: {
-                "update readOnly": {
-                  guard: ({
-                    event
-                  }) => !event.readOnly,
-                  target: "#editor.edit mode.editable",
-                  actions: ["emit editable"]
-                }
-              }
-            }
-          }
-        },
-        editable: {
-          on: {
-            "update readOnly": {
-              guard: ({
-                event
-              }) => event.readOnly,
-              target: "#editor.edit mode.read only.read only",
-              actions: ["emit read only"]
-            },
-            "behavior event": {
-              actions: "handle behavior event"
-            },
-            blur: {
-              actions: "handle blur"
-            },
-            focus: {
-              target: ".focusing",
-              actions: [assign({
-                slateEditor: ({
-                  event
-                }) => event.editor
-              })]
-            }
-          },
-          initial: "idle",
-          states: {
-            idle: {
-              on: {
-                dragstart: {
-                  actions: [assign({
-                    internalDrag: ({
-                      event
-                    }) => ({
-                      ghost: event.ghost,
-                      origin: event.origin
-                    })
-                  })],
-                  target: "dragging internally"
-                }
-              }
-            },
-            focusing: {
-              initial: "checking if busy",
-              states: {
-                "checking if busy": {
-                  always: [{
-                    guard: "slate is busy",
-                    target: "busy"
-                  }, {
-                    target: "#editor.edit mode.editable.idle",
-                    actions: ["handle focus"]
-                  }]
-                },
-                busy: {
-                  after: {
-                    10: {
-                      target: "checking if busy"
-                    }
-                  }
-                }
-              }
-            },
-            "dragging internally": {
-              exit: [({
-                context
-              }) => {
-                if (context.internalDrag?.ghost)
-                  try {
-                    context.internalDrag.ghost.parentNode?.removeChild(context.internalDrag.ghost);
-                  } catch (error) {
-                    console.error(new Error(`Removing the internal drag ghost failed due to: ${error.message}`));
-                  }
-              }, assign({
-                internalDrag: void 0
-              })],
-              tags: ["dragging internally"],
-              on: {
-                dragend: {
-                  target: "idle"
-                },
-                drop: {
-                  target: "idle"
-                }
-              }
-            }
-          }
-        }
+    actions: [() => [{
+      type: "noop"
+    }]]
+  }),
+  defineBehavior({
+    on: "clipboard.cut",
+    guard: ({
+      snapshot
+    }) => snapshot.context.selection ? {
+      selection: snapshot.context.selection
+    } : !1,
+    actions: [({
+      event
+    }, {
+      selection
+    }) => [raise({
+      type: "serialize",
+      originEvent: event
+    }), raise({
+      type: "delete",
+      at: selection
+    })]]
+  }),
+  defineBehavior({
+    on: "drag.dragstart",
+    actions: [({
+      event
+    }) => [raise({
+      type: "serialize",
+      originEvent: event
+    })]]
+  }),
+  defineBehavior({
+    on: "serialization.success",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        event.originEvent.originEvent.dataTransfer.setData(event.mimeType, event.data);
+      }
+    }]]
+  }),
+  defineBehavior({
+    on: "serialization.failure",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        console.warn(`Serialization of ${event.mimeType} failed with reason "${event.reason}"`);
       }
+    }]]
+  }),
+  defineBehavior({
+    on: "drag.drop",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
+      return dragOrigin ? isOverlappingSelection(dropPosition)({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }) : !1;
     },
-    setup: {
-      initial: "setting up",
-      states: {
-        "setting up": {
-          exit: ["emit ready"],
-          on: {
-            "internal.patch": {
-              actions: "defer event"
-            },
-            mutation: {
-              actions: "defer event"
-            },
-            "done syncing initial value": {
-              target: "pristine"
-            }
-          }
-        },
-        pristine: {
-          initial: "idle",
-          states: {
-            idle: {
-              on: {
-                normalizing: {
-                  target: "normalizing"
-                },
-                "internal.patch": {
-                  actions: "defer event",
-                  target: "#editor.setup.dirty"
-                },
-                mutation: {
-                  actions: "defer event",
-                  target: "#editor.setup.dirty"
-                }
-              }
-            },
-            normalizing: {
-              on: {
-                "done normalizing": {
-                  target: "idle"
-                },
-                "internal.patch": {
-                  actions: "defer event"
-                },
-                mutation: {
-                  actions: "defer event"
-                }
-              }
-            }
-          }
-        },
-        dirty: {
-          entry: ["emit pending events", "clear pending events"],
-          on: {
-            "internal.patch": {
-              actions: "emit patch event"
-            },
-            mutation: {
-              actions: "emit mutation event"
-            }
-          }
+    actions: [() => [{
+      type: "noop"
+    }]]
+  }),
+  defineBehavior({
+    on: "drag.drop",
+    actions: [({
+      event
+    }) => [raise({
+      type: "select",
+      at: event.position.selection
+    }), raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
+  }),
+  defineBehavior({
+    on: "deserialization.success",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      if (event.originEvent.type !== "drag.drop" || snapshot.beta.internalDrag === void 0)
+        return !1;
+      const dragOrigin = snapshot.beta.internalDrag.origin, dropPosition = event.originEvent.position.selection, droppingOnDragOrigin = dragOrigin ? isOverlappingSelection(dropPosition)({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
         }
-      }
-    }
-  }
-});
-function createLegacySchema(portableTextType) {
-  if (!portableTextType)
-    throw new Error("Parameter 'portabletextType' missing (required)");
-  const blockType = portableTextType.of?.find(findBlockType);
-  if (!blockType)
-    throw new Error("Block type is not defined in this schema (required)");
-  const childrenField = blockType.fields?.find((field) => field.name === "children");
-  if (!childrenField)
-    throw new Error("Children field for block type found in schema (required)");
-  const ofType = childrenField.type.of;
-  if (!ofType)
-    throw new Error("Valid types for block children not found in schema (required)");
-  const spanType = ofType.find((memberType) => memberType.name === "span");
-  if (!spanType)
-    throw new Error("Span type not found in schema (required)");
-  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
-  return {
-    styles: resolveEnabledStyles(blockType),
-    decorators: resolveEnabledDecorators(spanType),
-    lists: resolveEnabledListItems(blockType),
-    block: blockType,
-    span: spanType,
-    portableText: portableTextType,
-    inlineObjects: inlineObjectTypes,
-    blockObjects: blockObjectTypes,
-    annotations: spanType.annotations
-  };
-}
-function resolveEnabledStyles(blockType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === "style");
-  if (!styleField)
-    throw new Error("A field with name 'style' is not defined in the block type (required).");
-  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
-  if (!textStyles || textStyles.length === 0)
-    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
-  return textStyles;
-}
-function resolveEnabledDecorators(spanType) {
-  return spanType.decorators;
-}
-function resolveEnabledListItems(blockType) {
-  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
-  if (!listField)
-    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
-  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
-  if (!listItems)
-    throw new Error("The list field need at least to be an empty array");
-  return listItems;
-}
-function findBlockType(type) {
-  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
-}
-function defineSchema(definition) {
-  return definition;
-}
-const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
-  image: temporaryImageName,
-  url: temporaryUrlName
-}, objectNames = {
-  [temporaryImageName]: "image",
-  [temporaryUrlName]: "url"
-}, defaultObjectTitles = {
-  image: "Image",
-  url: "URL"
-};
-function legacySchemaToEditorSchema(schema) {
-  return {
-    annotations: schema.annotations.map((annotation) => ({
-      name: annotation.name,
-      fields: annotation.fields.map((field) => ({
-        name: field.name,
-        type: field.type.jsonType
-      })),
-      title: annotation.title
-    })),
-    block: {
-      name: schema.block.name
+      }) : !1, draggingEntireBlocks = isSelectingEntireBlocks({
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }), draggedBlocks = getSelectedBlocks({
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      });
+      return droppingOnDragOrigin ? !1 : {
+        draggingEntireBlocks,
+        draggedBlocks,
+        dragOrigin,
+        originEvent: event.originEvent
+      };
     },
-    blockObjects: schema.blockObjects.map((blockObject) => ({
-      name: blockObject.name,
-      fields: blockObject.fields.map((field) => ({
-        name: field.name,
-        type: field.type.jsonType
-      })),
-      title: blockObject.title
-    })),
-    decorators: schema.decorators.map((decorator) => ({
-      name: decorator.value,
-      title: decorator.title,
-      value: decorator.value
-    })),
-    inlineObjects: schema.inlineObjects.map((inlineObject) => ({
-      name: inlineObject.name,
-      fields: inlineObject.fields.map((field) => ({
-        name: field.name,
-        type: field.type.jsonType
-      })),
-      title: inlineObject.title
-    })),
-    span: {
-      name: schema.span.name
+    actions: [({
+      event
+    }, {
+      draggingEntireBlocks,
+      draggedBlocks,
+      dragOrigin,
+      originEvent
+    }) => [...draggingEntireBlocks ? draggedBlocks.map((block) => raise({
+      type: "delete.block",
+      at: block.path
+    })) : [raise({
+      type: "delete",
+      at: dragOrigin.selection
+    })], raise({
+      type: "insert.blocks",
+      blocks: event.data,
+      placement: draggingEntireBlocks ? originEvent.position.block === "start" ? "before" : originEvent.position.block === "end" ? "after" : "auto" : "auto"
+    })]]
+  }),
+  /**
+   * If we are pasting text/plain into a text block then we can probably
+   * assume that the intended behavior is that the pasted text inherits
+   * formatting from the text it's pasted into.
+   */
+  defineBehavior({
+    on: "deserialization.success",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      if (getFocusTextBlock(snapshot) && event.mimeType === "text/plain" && event.originEvent.type === "clipboard.paste") {
+        const activeDecorators = snapshot.context.activeDecorators;
+        return {
+          activeAnnotations: getActiveAnnotations(snapshot),
+          activeDecorators,
+          textRuns: event.data.flatMap((block) => isTextBlock(snapshot.context.schema, block) ? [getTextBlockText(block)] : [])
+        };
+      }
+      return !1;
     },
-    styles: schema.styles.map((style) => ({
-      name: style.value,
-      title: style.title,
-      value: style.value
-    })),
-    lists: schema.lists.map((list) => ({
-      name: list.value,
-      title: list.title,
-      value: list.value
-    }))
-  };
-}
-function compileSchemaDefinitionToLegacySchema(definition) {
-  const blockObjects = definition?.blockObjects?.map((blockObject) => defineType({
-    type: "object",
-    // Very naive way to work around `SanitySchema.compile` adding default
-    // fields to objects with certain names.
-    name: temporaryObjectNames[blockObject.name] ?? blockObject.name,
-    title: blockObject.title === void 0 ? (
-      // This avoids the default title which is a title case of the object name
-      defaultObjectTitles[blockObject.name]
-    ) : blockObject.title,
-    fields: blockObject.fields?.map((field) => ({
-      name: field.name,
-      type: field.type
-    })) ?? []
-  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => defineType({
-    type: "object",
-    // Very naive way to work around `SanitySchema.compile` adding default
-    // fields to objects with certain names.
-    name: temporaryObjectNames[inlineObject.name] ?? inlineObject.name,
-    title: inlineObject.title === void 0 ? (
-      // This avoids the default title which is a title case of the object name
-      defaultObjectTitles[inlineObject.name]
-    ) : inlineObject.title,
-    fields: inlineObject.fields?.map((field) => ({
-      name: field.name,
-      type: field.type
-    })) ?? []
-  })) ?? [], portableTextSchema = defineField({
-    type: "array",
-    name: "portable-text",
-    of: [...blockObjects.map((blockObject) => ({
-      type: blockObject.name
-    })), {
-      type: "block",
-      name: "block",
-      of: inlineObjects.map((inlineObject) => ({
-        type: inlineObject.name
-      })),
-      marks: {
-        decorators: definition?.decorators?.map((decorator) => ({
-          title: decorator.title ?? startCase(decorator.name),
-          value: decorator.name
-        })) ?? [],
-        annotations: definition?.annotations?.map((annotation) => ({
-          name: annotation.name,
-          type: "object",
-          title: annotation.title,
-          fields: annotation.fields?.map((field) => ({
-            name: field.name,
-            type: field.type
-          })) ?? []
-        })) ?? []
-      },
-      lists: definition?.lists?.map((list) => ({
-        value: list.name,
-        title: list.title ?? startCase(list.name)
-      })) ?? [],
-      styles: definition?.styles?.map((style) => ({
-        value: style.name,
-        title: style.title ?? startCase(style.name)
-      })) ?? []
-    }]
-  }), schema = Schema.compile({
-    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
-  }).get("portable-text"), pteSchema = createLegacySchema(schema);
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
-      ...blockObject,
-      name: objectNames[blockObject.name],
-      type: {
-        ...blockObject.type,
-        name: objectNames[blockObject.name]
+    actions: [(_, {
+      activeAnnotations,
+      activeDecorators,
+      textRuns
+    }) => textRuns.flatMap((textRun, index) => index !== textRuns.length - 1 ? [raise({
+      type: "insert.span",
+      text: textRun,
+      decorators: activeDecorators,
+      annotations: activeAnnotations.map(({
+        _key,
+        _type,
+        ...value
+      }) => ({
+        name: _type,
+        value
+      }))
+    }), raise({
+      type: "insert.break"
+    })] : [raise({
+      type: "insert.span",
+      text: textRun,
+      decorators: activeDecorators,
+      annotations: activeAnnotations.map(({
+        _key,
+        _type,
+        ...value
+      }) => ({
+        name: _type,
+        value
+      }))
+    })])]
+  }),
+  defineBehavior({
+    on: "deserialization.success",
+    actions: [({
+      event
+    }) => [raise({
+      type: "insert.blocks",
+      blocks: event.data,
+      placement: "auto"
+    })]]
+  }),
+  defineBehavior({
+    on: "deserialization.failure",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        console.warn(`Deserialization of ${event.mimeType} failed with reason "${event.reason}"`);
       }
-    } : blockObject),
-    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
-      ...inlineObject,
-      name: objectNames[inlineObject.name]
-    } : inlineObject)
-  };
+    }]]
+  }),
+  defineBehavior({
+    on: "clipboard.paste",
+    guard: ({
+      snapshot
+    }) => snapshot.context.selection && isSelectionExpanded(snapshot) ? {
+      selection: snapshot.context.selection
+    } : !1,
+    actions: [({
+      event
+    }, {
+      selection
+    }) => [raise({
+      type: "delete",
+      at: selection
+    }), raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
+  }),
+  defineBehavior({
+    on: "clipboard.paste",
+    actions: [({
+      event
+    }) => [raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
+  }),
+  defineBehavior({
+    on: "input.*",
+    actions: [({
+      event
+    }) => [raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
+  }),
+  ...abstractAnnotationBehaviors,
+  ...abstractDecoratorBehaviors,
+  ...abstractDeleteBehaviors,
+  ...abstractInsertBehaviors,
+  ...abstractListItemBehaviors,
+  ...abstractMoveBehaviors,
+  ...abstractStyleBehaviors,
+  ...abstractSelectBehaviors,
+  raiseDeserializationSuccessOrFailure,
+  raiseSerializationSuccessOrFailure,
+  raiseInsertSoftBreak
+], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "delete.text", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "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);
 }
-function defaultCompare(a, b) {
-  return a === b;
+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 nativeBehaviorEventTypes.includes(event.type);
 }
-function useEditorSelector(editor, selector, t0) {
-  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
-  let t1;
-  return $[0] !== editor || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
-    const snapshot = getEditorSnapshot({
-      editorActorSnapshot,
-      slateEditorInstance: editor._internal.slateEditor.instance
+function isCustomBehaviorEvent(event) {
+  return event.type.startsWith("custom.");
+}
+const debug$2 = debugWithName("behaviors:event");
+function eventCategory(event) {
+  return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "abstract" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
+}
+function performEvent({
+  mode,
+  behaviors,
+  event,
+  editor,
+  keyGenerator,
+  schema,
+  getSnapshot,
+  nativeEvent
+}) {
+  debug$2(`(${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
+    ...event,
+    editor
+  }, eventBehaviors = (mode === "raise" ? [...behaviors, ...defaultBehaviors] : behaviors).filter((behavior) => {
+    if (behavior.on === "*")
+      return !0;
+    const [listenedNamespace] = behavior.on.includes("*") && behavior.on.includes(".") ? behavior.on.split(".") : [void 0], [eventNamespace] = event.type.includes(".") ? event.type.split(".") : [void 0];
+    return listenedNamespace !== void 0 && eventNamespace !== void 0 && listenedNamespace === eventNamespace || listenedNamespace !== void 0 && eventNamespace === void 0 && listenedNamespace === event.type ? !0 : behavior.on === event.type;
+  });
+  if (eventBehaviors.length === 0) {
+    if (!defaultAction)
+      return;
+    withApplyingBehaviorActions(editor, () => {
+      try {
+        performAction({
+          context: {
+            keyGenerator,
+            schema
+          },
+          action: defaultAction
+        });
+      } catch (error) {
+        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+      }
+    }), editor.onChange();
+    return;
+  }
+  const guardSnapshot = getSnapshot();
+  let behaviorOverwritten = !1;
+  for (const eventBehavior of eventBehaviors) {
+    const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
+      snapshot: guardSnapshot,
+      event
     });
-    return selector(snapshot);
-  }, $[0] = editor, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
+    if (shouldRun) {
+      for (const actionSet of eventBehavior.actions) {
+        const actionsSnapshot = getSnapshot(), actions = actionSet({
+          snapshot: actionsSnapshot,
+          event
+        }, shouldRun);
+        actions.length !== 0 && (behaviorOverwritten = behaviorOverwritten || actions.some((action) => action.type !== "effect"), withApplyingBehaviorActionSet(editor, () => {
+          for (const action of actions) {
+            if (action.type === "raise") {
+              performEvent({
+                mode,
+                behaviors: mode === "execute" ? isCustomBehaviorEvent(action.event) ? [...behaviors, ...defaultBehaviors] : defaultBehaviors : [...behaviors, ...defaultBehaviors],
+                event: action.event,
+                editor,
+                keyGenerator,
+                schema,
+                getSnapshot,
+                nativeEvent: void 0
+              });
+              continue;
+            }
+            if (action.type === "execute") {
+              if (isAbstractBehaviorEvent(action.event) || isCustomBehaviorEvent(action.event))
+                performEvent({
+                  mode: "execute",
+                  behaviors: isCustomBehaviorEvent(action.event) ? [...behaviors, ...defaultBehaviors] : defaultBehaviors,
+                  event: action.event,
+                  editor,
+                  keyGenerator,
+                  schema,
+                  getSnapshot,
+                  nativeEvent: void 0
+                });
+              else {
+                const internalAction2 = {
+                  ...action.event,
+                  editor
+                };
+                let actionFailed2 = !1;
+                if (withApplyingBehaviorActions(editor, () => {
+                  try {
+                    performAction({
+                      context: {
+                        keyGenerator,
+                        schema
+                      },
+                      action: internalAction2
+                    });
+                  } catch (error) {
+                    console.error(new Error(`Performing action "${action.event.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed2 = !0;
+                  }
+                }), actionFailed2)
+                  break;
+                editor.onChange();
+              }
+              continue;
+            }
+            const internalAction = {
+              ...action,
+              editor
+            };
+            let actionFailed = !1;
+            if (withApplyingBehaviorActions(editor, () => {
+              try {
+                performAction({
+                  context: {
+                    keyGenerator,
+                    schema
+                  },
+                  action: internalAction
+                });
+              } catch (error) {
+                console.error(new Error(`Performing action "${internalAction.type}" as a result of "${event.type}" failed due to: ${error.message}`)), actionFailed = !0;
+              }
+            }), actionFailed)
+              break;
+            editor.onChange();
+          }
+        }));
+      }
+      if (behaviorOverwritten) {
+        nativeEvent?.preventDefault();
+        break;
+      }
+    }
+  }
+  if (!behaviorOverwritten) {
+    if (!defaultAction)
+      return;
+    withApplyingBehaviorActions(editor, () => {
+      try {
+        performAction({
+          context: {
+            keyGenerator,
+            schema
+          },
+          action: defaultAction
+        });
+      } catch (error) {
+        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+      }
+    }), editor.onChange();
+  }
 }
-function getEditorSnapshot({
-  editorActorSnapshot,
-  slateEditorInstance
+function createEditorSnapshot({
+  converters,
+  editor,
+  keyGenerator,
+  readOnly,
+  schema,
+  hasTag,
+  internalDrag
 }) {
+  const value = slateChildrenToBlocks(schema, editor.children), selection = editor.selection ? slateRangeToSelection({
+    schema,
+    editor,
+    range: editor.selection
+  }) : null;
   return {
     context: {
-      converters: [...editorActorSnapshot.context.converters],
       activeDecorators: getActiveDecorators({
-        schema: editorActorSnapshot.context.schema,
-        slateEditorInstance
-      }),
-      keyGenerator: editorActorSnapshot.context.keyGenerator,
-      readOnly: editorActorSnapshot.matches({
-        "edit mode": "read only"
+        schema,
+        slateEditorInstance: editor
       }),
-      schema: editorActorSnapshot.context.schema,
-      selection: editorActorSnapshot.context.selection,
-      value: slateChildrenToBlocks(editorActorSnapshot.context.schema, slateEditorInstance.children)
+      converters,
+      keyGenerator,
+      readOnly,
+      schema,
+      selection,
+      value
     },
     beta: {
-      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
-      internalDrag: editorActorSnapshot.context.internalDrag
+      hasTag,
+      internalDrag
     }
   };
 }
-const debug$2 = debugWithName("API:editable");
-function createEditableAPI(editor, editorActor) {
-  const types = editorActor.getSnapshot().context.schema;
-  return {
-    focus: () => {
-      editorActor.send({
-        type: "focus",
-        editor
-      });
-    },
-    blur: () => {
-      editorActor.send({
-        type: "blur",
-        editor
-      });
-    },
-    toggleMark: (mark) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "decorator.toggle",
-          decorator: mark
-        },
-        editor
-      });
-    },
-    toggleList: (listItem) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "list item.toggle",
-          listItem
-        },
-        editor
-      });
-    },
-    toggleBlockStyle: (style) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "style.toggle",
-          style
-        },
-        editor
+const editorMachine = setup({
+  types: {
+    context: {},
+    events: {},
+    emitted: {},
+    input: {},
+    tags: {}
+  },
+  actions: {
+    "add behavior to context": assign({
+      behaviors: ({
+        context,
+        event
+      }) => (assertEvent(event, "add behavior"), /* @__PURE__ */ new Set([...context.behaviors, event.behavior]))
+    }),
+    "remove behavior from context": assign({
+      behaviors: ({
+        context,
+        event
+      }) => (assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
+    }),
+    "assign behaviors": assign({
+      behaviors: ({
+        event
+      }) => (assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...event.behaviors]))
+    }),
+    "assign schema": assign({
+      schema: ({
+        event
+      }) => (assertEvent(event, "update schema"), event.schema)
+    }),
+    "emit patch event": enqueueActions(({
+      event,
+      enqueue
+    }) => {
+      assertEvent(event, "internal.patch"), enqueue.emit(event), enqueue.emit({
+        type: "patch",
+        patch: event.patch
       });
+    }),
+    "emit mutation event": emit(({
+      event
+    }) => (assertEvent(event, "mutation"), event)),
+    "emit read only": emit({
+      type: "read only"
+    }),
+    "emit editable": emit({
+      type: "editable"
+    }),
+    "defer event": assign({
+      pendingEvents: ({
+        context,
+        event
+      }) => (assertEvent(event, ["internal.patch", "mutation"]), [...context.pendingEvents, event])
+    }),
+    "emit pending events": enqueueActions(({
+      context,
+      enqueue
+    }) => {
+      for (const event of context.pendingEvents)
+        event.type === "internal.patch" ? (enqueue.emit(event), enqueue.emit({
+          type: "patch",
+          patch: event.patch
+        })) : enqueue.emit(event);
+    }),
+    "emit ready": emit({
+      type: "ready"
+    }),
+    "clear pending events": assign({
+      pendingEvents: []
+    }),
+    "handle blur": ({
+      event
+    }) => {
+      assertEvent(event, "blur");
+      try {
+        ReactEditor.blur(event.editor);
+      } catch (error) {
+        console.error(new Error(`Failed to blur editor: ${error.message}`));
+      }
     },
-    isMarkActive: (mark) => {
+    "handle focus": ({
+      context
+    }) => {
+      if (!context.slateEditor) {
+        console.error("No Slate editor found to focus");
+        return;
+      }
       try {
-        return isDecoratorActive({
-          editor,
-          decorator: mark
-        });
-      } catch (err) {
-        return console.warn(err), !1;
+        const currentSelection = context.slateEditor.selection;
+        ReactEditor.focus(context.slateEditor), currentSelection && Transforms.select(context.slateEditor, currentSelection);
+      } catch (error) {
+        console.error(new Error(`Failed to focus editor: ${error.message}`));
       }
     },
-    marks: () => ({
-      ...Editor.marks(editor) || {}
-    }).marks || [],
-    undo: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "history.undo"
-        },
-        editor
+    "handle behavior event": ({
+      context,
+      event,
+      self
+    }) => {
+      assertEvent(event, ["behavior event"]), performEvent({
+        mode: "raise",
+        behaviors: [...context.behaviors.values()],
+        event: event.behaviorEvent,
+        editor: event.editor,
+        keyGenerator: context.keyGenerator,
+        schema: context.schema,
+        getSnapshot: () => createEditorSnapshot({
+          converters: [...context.converters],
+          editor: event.editor,
+          keyGenerator: context.keyGenerator,
+          readOnly: self.getSnapshot().matches({
+            "edit mode": "read only"
+          }),
+          schema: context.schema,
+          hasTag: (tag) => self.getSnapshot().hasTag(tag),
+          internalDrag: context.internalDrag
+        }),
+        nativeEvent: event.nativeEvent
       });
+    }
+  },
+  guards: {
+    "slate is busy": ({
+      context
+    }) => context.slateEditor ? context.slateEditor.operations.length > 0 : !1
+  }
+}).createMachine({
+  id: "editor",
+  context: ({
+    input
+  }) => ({
+    behaviors: /* @__PURE__ */ new Set([...input.behaviors ?? coreBehaviors]),
+    converters: new Set(input.converters ?? []),
+    getLegacySchema: input.getLegacySchema,
+    keyGenerator: input.keyGenerator,
+    pendingEvents: [],
+    schema: input.schema,
+    selection: null,
+    initialReadOnly: input.readOnly ?? !1,
+    maxBlocks: input.maxBlocks,
+    incomingValue: input.initialValue
+  }),
+  on: {
+    "notify.blurred": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "blurred"
+      }))
     },
-    redo: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "history.redo"
-        },
-        editor
-      });
+    "notify.done loading": {
+      actions: emit({
+        type: "done loading"
+      })
     },
-    select: (selection) => {
-      const slateSelection = toSlateRange(selection, editor);
-      slateSelection ? Transforms.select(editor, slateSelection) : Transforms.deselect(editor), editor.onChange();
+    "notify.error": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "error"
+      }))
     },
-    focusBlock: () => {
-      if (editor.selection) {
-        const block = Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (block)
-          return fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
-      }
+    "notify.invalid value": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "invalid value"
+      }))
     },
-    focusChild: () => {
-      if (editor.selection) {
-        const block = Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (block && editor.isTextBlock(block))
-          return fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0].children[editor.selection.focus.path[1]];
-      }
+    "notify.focused": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "focused"
+      }))
     },
-    insertChild: (type, value) => {
-      if (type.name !== types.span.name)
-        return editorActor.send({
-          type: "behavior event",
-          behaviorEvent: {
-            type: "insert.inline object",
-            inlineObject: {
-              name: type.name,
-              value
-            }
-          },
-          editor
-        }), editor.selection ? slateRangeToSelection({
-          schema: editorActor.getSnapshot().context.schema,
-          editor,
-          range: editor.selection
-        })?.focus.path ?? [] : [];
-      if (!editor.selection)
-        throw new Error("The editor has no selection");
-      const [focusBlock] = Array.from(Editor.nodes(editor, {
-        at: editor.selection.focus.path.slice(0, 1),
-        match: (n) => n._type === types.block.name
-      }))[0] || [void 0];
-      if (!focusBlock)
-        throw new Error("No focused text block");
-      if (type.name !== types.span.name && !types.inlineObjects.some((t) => t.name === type.name))
-        throw new Error("This type cannot be inserted as a child to a text block");
-      const child = toSlateValue([{
-        _key: editorActor.getSnapshot().context.keyGenerator(),
-        _type: types.block.name,
-        children: [{
-          _key: editorActor.getSnapshot().context.keyGenerator(),
-          _type: type.name,
-          ...value || {}
-        }]
-      }], {
-        schemaTypes: editorActor.getSnapshot().context.schema
-      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types.span.name && (debug$2("Inserting span child next to inline object child, moving selection + 1"), editor.move({
-        distance: 1,
-        unit: "character"
-      })), Transforms.insertNodes(editor, child, {
-        select: !0,
-        at: editor.selection
-      }), editor.onChange(), editor.selection ? slateRangeToSelection({
-        schema: editorActor.getSnapshot().context.schema,
-        editor,
-        range: editor.selection
-      })?.focus.path ?? [] : [];
+    "notify.selection": {
+      actions: [assign({
+        selection: ({
+          event
+        }) => event.selection
+      }), emit(({
+        event
+      }) => ({
+        ...event,
+        type: "selection"
+      }))]
     },
-    insertBlock: (type, value) => (editorActor.send({
-      type: "behavior event",
-      behaviorEvent: {
-        type: "insert.block",
-        block: {
-          _type: type.name,
-          ...value || {}
-        },
-        placement: "auto"
-      },
-      editor
-    }), editor.selection ? slateRangeToSelection({
-      schema: editorActor.getSnapshot().context.schema,
-      editor,
-      range: editor.selection
-    })?.focus.path ?? [] : []),
-    hasBlockStyle: (style) => {
-      try {
-        return isStyleActive({
-          editor,
-          style
-        });
-      } catch {
-        return !1;
-      }
+    "notify.unset": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "unset"
+      }))
+    },
+    "notify.loading": {
+      actions: emit({
+        type: "loading"
+      })
     },
-    hasListStyle: (listItem) => {
-      try {
-        return isListItemActive({
-          editor,
-          listItem
-        });
-      } catch {
-        return !1;
-      }
+    "notify.value changed": {
+      actions: emit(({
+        event
+      }) => ({
+        ...event,
+        type: "value changed"
+      }))
     },
-    isVoid: (element) => ![types.block.name, types.span.name].includes(element._type),
-    findByPath: (path) => {
-      const slatePath = toSlateRange({
-        focus: {
-          path,
-          offset: 0
-        },
-        anchor: {
-          path,
-          offset: 0
-        }
-      }, editor);
-      if (slatePath) {
-        const [block, blockPath] = Editor.node(editor, slatePath.focus.path.slice(0, 1));
-        if (block && blockPath && typeof block._key == "string") {
-          if (path.length === 1 && slatePath.focus.path.length === 1)
-            return [fromSlateValue([block], types.block.name)[0], [{
-              _key: block._key
-            }]];
-          const ptBlock = fromSlateValue([block], types.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
-          if (editor.isTextBlock(ptBlock)) {
-            const ptChild = ptBlock.children[slatePath.focus.path[1]];
-            if (ptChild)
-              return [ptChild, [{
-                _key: block._key
-              }, "children", {
-                _key: ptChild._key
-              }]];
-          }
-        }
-      }
-      return [void 0, void 0];
+    "add behavior": {
+      actions: "add behavior to context"
     },
-    findDOMNode: (element) => {
-      let node;
-      try {
-        const [item] = Array.from(Editor.nodes(editor, {
-          at: [],
-          match: (n) => n._key === element._key
-        }) || [])[0] || [void 0];
-        node = ReactEditor.toDOMNode(editor, item);
-      } catch {
-      }
-      return node;
+    "remove behavior": {
+      actions: "remove behavior from context"
     },
-    activeAnnotations: () => {
-      if (!editor.selection || editor.selection.focus.path.length < 2)
-        return [];
-      try {
-        const activeAnnotations = [], spans = Editor.nodes(editor, {
-          at: editor.selection,
-          match: (node) => Text.isText(node) && node.marks !== void 0 && Array.isArray(node.marks) && node.marks.length > 0
-        });
-        for (const [span, path] of spans) {
-          const [block] = Editor.node(editor, path, {
-            depth: 1
-          });
-          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
-            Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
-          });
-        }
-        return activeAnnotations;
-      } catch {
-        return [];
-      }
+    patches: {
+      actions: emit(({
+        event
+      }) => event)
     },
-    isAnnotationActive: (annotationType) => isAnnotationActive({
-      editor,
-      annotation: {
-        name: annotationType
-      }
-    }),
-    addAnnotation: (type, value) => {
-      let paths;
-      return Editor.withoutNormalizing(editor, () => {
-        paths = addAnnotationActionImplementation({
-          context: {
-            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
-            schema: types
+    "update behaviors": {
+      actions: "assign behaviors"
+    },
+    "update key generator": {
+      actions: assign({
+        keyGenerator: ({
+          event
+        }) => event.keyGenerator
+      })
+    },
+    "update schema": {
+      actions: "assign schema"
+    },
+    "update value": {
+      actions: assign({
+        incomingValue: ({
+          event
+        }) => event.value
+      })
+    },
+    "update maxBlocks": {
+      actions: assign({
+        maxBlocks: ({
+          event
+        }) => event.maxBlocks
+      })
+    }
+  },
+  type: "parallel",
+  states: {
+    "edit mode": {
+      initial: "read only",
+      states: {
+        "read only": {
+          initial: "determine initial edit mode",
+          on: {
+            "behavior event": {
+              actions: "handle behavior event",
+              guard: ({
+                event
+              }) => event.behaviorEvent.type === "clipboard.copy" || event.behaviorEvent.type === "mouse.click" || event.behaviorEvent.type === "serialize" || event.behaviorEvent.type === "serialization.failure" || event.behaviorEvent.type === "serialization.success" || event.behaviorEvent.type === "select"
+            }
           },
-          action: {
-            annotation: {
-              name: type.name,
-              value: value ?? {}
+          states: {
+            "determine initial edit mode": {
+              on: {
+                "done syncing initial value": [{
+                  target: "#editor.edit mode.read only.read only",
+                  guard: ({
+                    context
+                  }) => context.initialReadOnly
+                }, {
+                  target: "#editor.edit mode.editable"
+                }]
+              }
             },
-            editor
+            "read only": {
+              on: {
+                "update readOnly": {
+                  guard: ({
+                    event
+                  }) => !event.readOnly,
+                  target: "#editor.edit mode.editable",
+                  actions: ["emit editable"]
+                }
+              }
+            }
           }
-        });
-      }), editor.onChange(), paths;
-    },
-    delete: (selection, options) => {
-      if (selection) {
-        const range = toSlateRange(selection, editor);
-        if (!(range && range.anchor.path.length > 0 && range.focus.path.length > 0))
-          throw new Error("Invalid range");
-        if (range) {
-          if (!options?.mode || options?.mode === "selected") {
-            debug$2("Deleting content in selection"), Transforms.delete(editor, {
-              at: range,
-              hanging: !0,
-              voids: !0
-            }), editor.onChange();
-            return;
+        },
+        editable: {
+          on: {
+            "update readOnly": {
+              guard: ({
+                event
+              }) => event.readOnly,
+              target: "#editor.edit mode.read only.read only",
+              actions: ["emit read only"]
+            },
+            "behavior event": {
+              actions: "handle behavior event"
+            },
+            blur: {
+              actions: "handle blur"
+            },
+            focus: {
+              target: ".focusing",
+              actions: [assign({
+                slateEditor: ({
+                  event
+                }) => event.editor
+              })]
+            }
+          },
+          initial: "idle",
+          states: {
+            idle: {
+              on: {
+                dragstart: {
+                  actions: [assign({
+                    internalDrag: ({
+                      event
+                    }) => ({
+                      ghost: event.ghost,
+                      origin: event.origin
+                    })
+                  })],
+                  target: "dragging internally"
+                }
+              }
+            },
+            focusing: {
+              initial: "checking if busy",
+              states: {
+                "checking if busy": {
+                  always: [{
+                    guard: "slate is busy",
+                    target: "busy"
+                  }, {
+                    target: "#editor.edit mode.editable.idle",
+                    actions: ["handle focus"]
+                  }]
+                },
+                busy: {
+                  after: {
+                    10: {
+                      target: "checking if busy"
+                    }
+                  }
+                }
+              }
+            },
+            "dragging internally": {
+              exit: [({
+                context
+              }) => {
+                if (context.internalDrag?.ghost)
+                  try {
+                    context.internalDrag.ghost.parentNode?.removeChild(context.internalDrag.ghost);
+                  } catch (error) {
+                    console.error(new Error(`Removing the internal drag ghost failed due to: ${error.message}`));
+                  }
+              }, assign({
+                internalDrag: void 0
+              })],
+              tags: ["dragging internally"],
+              on: {
+                dragend: {
+                  target: "idle"
+                },
+                drop: {
+                  target: "idle"
+                }
+              }
+            }
           }
-          options?.mode === "blocks" && (debug$2("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
-            at: range,
-            voids: !0,
-            match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element.isElement(node)
-          })), options?.mode === "children" && (debug$2("Deleting children touched by selection"), Transforms.removeNodes(editor, {
-            at: range,
-            voids: !0,
-            match: (node) => node._type === types.span.name || // Text children
-            !editor.isTextBlock(node) && Element.isElement(node)
-          })), editor.children.length === 0 && (editor.children = [editor.pteCreateTextBlock({
-            decorators: []
-          })]), editor.onChange();
         }
       }
     },
-    removeAnnotation: (type) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "annotation.remove",
-          annotation: {
-            name: type.name
+    setup: {
+      initial: "setting up",
+      states: {
+        "setting up": {
+          exit: ["emit ready"],
+          on: {
+            "internal.patch": {
+              actions: "defer event"
+            },
+            mutation: {
+              actions: "defer event"
+            },
+            "done syncing initial value": {
+              target: "pristine"
+            }
           }
         },
-        editor
-      });
-    },
-    getSelection: () => {
-      let ptRange = null;
-      if (editor.selection) {
-        const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
-        if (existing)
-          return existing;
-        ptRange = slateRangeToSelection({
-          schema: editorActor.getSnapshot().context.schema,
-          editor,
-          range: editor.selection
-        }), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
-      }
-      return ptRange;
-    },
-    getValue: () => fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
-    isCollapsedSelection: () => !!editor.selection && Range.isCollapsed(editor.selection),
-    isExpandedSelection: () => !!editor.selection && Range.isExpanded(editor.selection),
-    insertBreak: () => {
-      editor.insertBreak(), editor.onChange();
-    },
-    getFragment: () => fromSlateValue(editor.getFragment(), types.block.name),
-    isSelectionsOverlapping: (selectionA, selectionB) => {
-      const rangeA = toSlateRange(selectionA, editor), rangeB = toSlateRange(selectionB, editor);
-      return Range.isRange(rangeA) && Range.isRange(rangeB) && Range.includes(rangeA, rangeB);
-    }
-  };
-}
-function isAnnotationActive({
-  editor,
-  annotation
-}) {
-  if (!editor.selection || editor.selection.focus.path.length < 2)
-    return !1;
-  try {
-    const spans = [...Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => Text.isText(node)
-    })];
-    if (spans.length === 0 || spans.some(([span]) => !isPortableTextSpan$1(span) || !span.marks || span.marks?.length === 0)) return !1;
-    const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
-      const [block] = Editor.node(editor, path, {
-        depth: 1
-      });
-      return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
-    }, []);
-    return spans.every(([span]) => isPortableTextSpan$1(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
-  } catch {
-    return !1;
-  }
-}
-function createInternalEditor(config) {
-  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = createActor(editorMachine, {
-    input: editorConfigToMachineInput({
-      ...config,
-      schema: editorSchema,
-      legacySchema
-    })
-  });
-  return editorActor.start(), createInternalEditorFromActor(editorActor, legacySchema);
-}
-function useCreateInternalEditor(config) {
-  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = useActorRef(editorMachine, {
-    input: editorConfigToMachineInput({
-      ...config,
-      schema: editorSchema,
-      legacySchema
-    })
-  });
-  return useMemo(() => createInternalEditorFromActor(editorActor, legacySchema), [editorActor, legacySchema]);
-}
-function editorConfigToMachineInput(config) {
-  return {
-    behaviors: config.behaviors,
-    converters: createCoreConverters(config.legacySchema),
-    keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
-    maxBlocks: config.maxBlocks,
-    readOnly: config.readOnly,
-    schema: config.schema,
-    initialValue: config.initialValue
-  };
-}
-function createInternalEditorFromActor(editorActor, legacySchema) {
-  const slateEditor = createSlateEditor({
-    editorActor
-  }), editable = createEditableAPI(slateEditor.instance, editorActor);
-  return {
-    getSnapshot: () => getEditorSnapshot({
-      editorActorSnapshot: editorActor.getSnapshot(),
-      slateEditorInstance: slateEditor.instance
-    }),
-    registerBehavior: (config) => (editorActor.send({
-      type: "add behavior",
-      behavior: config.behavior
-    }), () => {
-      editorActor.send({
-        type: "remove behavior",
-        behavior: config.behavior
-      });
-    }),
-    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 "blur":
-          editorActor.send({
-            type: "blur",
-            editor: slateEditor.instance
-          });
-          break;
-        case "focus":
-          editorActor.send({
-            type: "focus",
-            editor: slateEditor.instance
-          });
-          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
+        pristine: {
+          initial: "idle",
+          states: {
+            idle: {
+              on: {
+                normalizing: {
+                  target: "normalizing"
+                },
+                "internal.patch": {
+                  actions: "defer event",
+                  target: "#editor.setup.dirty"
+                },
+                mutation: {
+                  actions: "defer event",
+                  target: "#editor.setup.dirty"
+                }
+              }
             },
-            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) {
-        case "blurred":
-        case "done loading":
-        case "editable":
-        case "error":
-        case "focused":
-        case "invalid value":
-        case "loading":
-        case "mutation":
-        case "patch":
-        case "read only":
-        case "ready":
-        case "selection":
-        case "value changed":
-          listener(event2);
-          break;
+            normalizing: {
+              on: {
+                "done normalizing": {
+                  target: "idle"
+                },
+                "internal.patch": {
+                  actions: "defer event"
+                },
+                mutation: {
+                  actions: "defer event"
+                }
+              }
+            }
+          }
+        },
+        dirty: {
+          entry: ["emit pending events", "clear pending events"],
+          on: {
+            "internal.patch": {
+              actions: "emit patch event"
+            },
+            mutation: {
+              actions: "emit mutation event"
+            }
+          }
+        }
       }
-    }),
-    _internal: {
-      editable,
-      editorActor,
-      legacySchema,
-      slateEditor
     }
-  };
-}
-const EditorActorContext = createContext({}), PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
+  }
+}), PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
   const editor = useContext(PortableTextEditorContext);
   if (!editor)
     throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
@@ -7281,13 +7286,23 @@ class PortableTextEditor extends Component {
    * The editor API (currently implemented with Slate).
    */
   constructor(props) {
-    super(props), props.editor ? this.editor = props.editor : this.editor = createInternalEditor({
-      keyGenerator: props.keyGenerator ?? defaultKeyGenerator,
-      schema: props.schemaType,
-      initialValue: props.value,
-      maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
-      readOnly: props.readOnly
-    }), this.schemaTypes = this.editor._internal.legacySchema, this.editable = this.editor._internal.editable;
+    if (super(props), props.editor)
+      this.editor = props.editor, this.schemaTypes = this.editor._internal.editorActor.getSnapshot().context.getLegacySchema();
+    else {
+      const legacySchema = createLegacySchema(props.schemaType.hasOwnProperty("jsonType") ? props.schemaType : compileType(props.schemaType)), schema = legacySchemaToEditorSchema(legacySchema), editorActor = createActor(editorMachine, {
+        input: {
+          converters: createCoreConverters(legacySchema),
+          getLegacySchema: () => legacySchema,
+          initialValue: props.value,
+          keyGenerator: props.keyGenerator ?? defaultKeyGenerator,
+          maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
+          readOnly: props.readOnly,
+          schema
+        }
+      });
+      editorActor.start(), this.editor = createInternalEditor(editorActor), this.schemaTypes = legacySchema;
+    }
+    this.editable = this.editor._internal.editable;
   }
   componentDidUpdate(prevProps) {
     !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = createLegacySchema(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
@@ -7773,34 +7788,18 @@ function RouteEventsToChanges(props) {
 }
 const EditorContext = React.createContext(void 0);
 function EditorProvider(props) {
-  const $ = c(28), internalEditor = useCreateInternalEditor(props.initialConfig), editorActor = internalEditor._internal.editorActor, slateEditor = internalEditor._internal.slateEditor;
-  let t0, t1;
-  $[0] !== internalEditor ? (t1 = new PortableTextEditor({
+  const editorActor = useActorRef(editorMachine, {
+    input: editorConfigToMachineInput(props.initialConfig)
+  }), internalEditor = useMemo(() => createInternalEditor(editorActor), [editorActor]), portableTextEditor = useMemo(() => new PortableTextEditor({
     editor: internalEditor
-  }), $[0] = internalEditor, $[1] = t1) : t1 = $[1], t0 = t1;
-  const portableTextEditor = t0;
-  let t2;
-  $[2] !== portableTextEditor.change$ ? (t2 = (change) => {
-    portableTextEditor.change$.next(change);
-  }, $[2] = portableTextEditor.change$, $[3] = t2) : t2 = $[3];
-  let t3;
-  $[4] !== editorActor || $[5] !== t2 ? (t3 = /* @__PURE__ */ jsx(RouteEventsToChanges, { editorActor, onChange: t2 }), $[4] = editorActor, $[5] = t2, $[6] = t3) : t3 = $[6];
-  let t4;
-  $[7] !== editorActor || $[8] !== slateEditor.instance ? (t4 = /* @__PURE__ */ jsx(Synchronizer, { editorActor, slateEditor: slateEditor.instance }), $[7] = editorActor, $[8] = slateEditor.instance, $[9] = t4) : t4 = $[9];
-  let t5;
-  $[10] !== editorActor || $[11] !== props.children ? (t5 = /* @__PURE__ */ jsx(PortableTextEditorSelectionProvider, { editorActor, children: props.children }), $[10] = editorActor, $[11] = props.children, $[12] = t5) : t5 = $[12];
-  let t6;
-  $[13] !== portableTextEditor || $[14] !== t5 ? (t6 = /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: portableTextEditor, children: t5 }), $[13] = portableTextEditor, $[14] = t5, $[15] = t6) : t6 = $[15];
-  let t7;
-  $[16] !== slateEditor.initialValue || $[17] !== slateEditor.instance || $[18] !== t6 ? (t7 = /* @__PURE__ */ jsx(Slate, { editor: slateEditor.instance, initialValue: slateEditor.initialValue, children: t6 }), $[16] = slateEditor.initialValue, $[17] = slateEditor.instance, $[18] = t6, $[19] = t7) : t7 = $[19];
-  let t8;
-  $[20] !== editorActor || $[21] !== t7 ? (t8 = /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: editorActor, children: t7 }), $[20] = editorActor, $[21] = t7, $[22] = t8) : t8 = $[22];
-  let t9;
-  return $[23] !== internalEditor || $[24] !== t3 || $[25] !== t4 || $[26] !== t8 ? (t9 = /* @__PURE__ */ jsxs(EditorContext.Provider, { value: internalEditor, children: [
-    t3,
-    t4,
-    t8
-  ] }), $[23] = internalEditor, $[24] = t3, $[25] = t4, $[26] = t8, $[27] = t9) : t9 = $[27], t9;
+  }), [internalEditor]);
+  return /* @__PURE__ */ jsxs(EditorContext.Provider, { value: internalEditor, children: [
+    /* @__PURE__ */ jsx(RouteEventsToChanges, { editorActor, onChange: (change) => {
+      portableTextEditor.change$.next(change);
+    } }),
+    /* @__PURE__ */ jsx(Synchronizer, { editorActor, slateEditor: internalEditor._internal.slateEditor.instance }),
+    /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: editorActor, children: /* @__PURE__ */ jsx(Slate, { editor: internalEditor._internal.slateEditor.instance, initialValue: internalEditor._internal.slateEditor.initialValue, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: portableTextEditor, children: /* @__PURE__ */ jsx(PortableTextEditorSelectionProvider, { editorActor, children: props.children }) }) }) })
+  ] });
 }
 function useEditor() {
   const editor = React.useContext(EditorContext);