@portabletext/editor 1.44.12 → 1.44.14

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

@@ -4,120 +4,6 @@ function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
 var React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$g), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase);
-function createEditorSchema(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;
-}
-function compileSchemaDefinition(definition) {
-  const blockObjects = definition?.blockObjects?.map((blockObject) => types.defineType({
-    type: "object",
-    // Very naive way to work around `SanitySchema.compile` adding default
-    // fields to objects with the name `image`
-    name: blockObject.name === "image" ? "tmp-image" : blockObject.name,
-    title: blockObject.name === "image" && blockObject.title === void 0 ? "Image" : blockObject.title,
-    fields: []
-  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => types.defineType({
-    type: "object",
-    name: inlineObject.name,
-    title: inlineObject.title,
-    fields: []
-  })) ?? [], portableTextSchema = types.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__default.default(decorator.name),
-          value: decorator.name
-        })) ?? [],
-        annotations: definition?.annotations?.map((annotation) => ({
-          name: annotation.name,
-          type: "object",
-          title: annotation.title
-        })) ?? []
-      },
-      lists: definition?.lists?.map((list) => ({
-        value: list.name,
-        title: list.title ?? startCase__default.default(list.name)
-      })) ?? [],
-      styles: definition?.styles?.map((style) => ({
-        value: style.name,
-        title: style.title ?? startCase__default.default(style.name)
-      })) ?? []
-    }]
-  }), schema$1 = schema.Schema.compile({
-    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
-  }).get("portable-text"), pteSchema = createEditorSchema(schema$1);
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) => blockObject.name === "tmp-image" ? {
-      ...blockObject,
-      name: "image",
-      type: {
-        ...blockObject.type,
-        name: "image"
-      }
-    } : blockObject)
-  };
-}
 const rootName = "sanity-pte:";
 debug__default.default(rootName);
 function debugWithName(name) {
@@ -231,319 +117,86 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
 function isEqualToEmptyEditor(children, schemaTypes) {
   return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && slate.Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && slate.Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
 }
-function getFocusBlock({
-  editor
-}) {
-  if (!editor.selection)
-    return [void 0, void 0];
-  try {
-    return slate.Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getPointBlock({
-  editor,
-  point
-}) {
-  try {
-    const [block] = slate.Editor.node(editor, point.path.slice(0, 1)) ?? [void 0, void 0];
-    return block ? [block, point.path] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getFocusChild({
-  editor
-}) {
-  const [focusBlock, focusBlockPath] = getFocusBlock({
-    editor
-  }), childIndex = editor.selection?.focus.path.at(1);
-  if (!focusBlock || !focusBlockPath || childIndex === void 0)
-    return [void 0, void 0];
-  try {
-    const focusChild = slate.Node.child(focusBlock, childIndex);
-    return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getPointChild({
-  editor,
-  point
-}) {
-  const [block, blockPath] = getPointBlock({
-    editor,
-    point
-  }), childIndex = point.path.at(1);
-  if (!block || !blockPath || childIndex === void 0)
-    return [void 0, void 0];
-  try {
-    const pointChild = slate.Node.child(block, childIndex);
-    return pointChild ? [pointChild, [...blockPath, childIndex]] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getFirstBlock({
-  editor
-}) {
-  const firstBlockPath = slate.Editor.start(editor, []).path.at(0);
-  try {
-    return firstBlockPath !== void 0 ? slate.Editor.node(editor, [firstBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getLastBlock({
-  editor
-}) {
-  const lastBlockPath = slate.Editor.end(editor, []).path.at(0);
-  try {
-    return lastBlockPath !== void 0 ? slate.Editor.node(editor, [lastBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
-  } catch {
-    return [void 0, void 0];
-  }
-}
-function getNodeBlock({
-  editor,
-  schema: schema2,
-  node
-}) {
-  if (slate.Editor.isEditor(node))
-    return;
-  if (isBlockElement({
-    editor,
-    schema: schema2
-  }, node))
-    return elementToBlock({
-      schema: schema2,
-      element: node
-    });
-  const parent = Array.from(slate.Editor.nodes(editor, {
-    mode: "highest",
-    at: [],
-    match: (n) => isBlockElement({
-      editor,
-      schema: schema2
-    }, n) && n.children.some((child) => child._key === node._key)
-  })).at(0)?.at(0);
-  return slate.Element.isElement(parent) ? elementToBlock({
-    schema: schema2,
-    element: parent
-  }) : void 0;
-}
-function elementToBlock({
-  schema: schema2,
-  element
-}) {
-  return fromSlateValue([element], schema2.block.name)?.at(0);
-}
-function isBlockElement({
-  editor,
-  schema: schema2
-}, node) {
-  return slate.Element.isElement(node) && !editor.isInline(node) && (schema2.block.name === node._type || schema2.blockObjects.some((blockObject) => blockObject.name === node._type));
-}
-function isListItemActive({
-  editor,
-  listItem
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedBlocks = [...slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node)
-  })];
-  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
-}
-function isStyleActive({
-  editor,
-  style
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedBlocks = [...slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node)
-  })];
-  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
-}
-function slateRangeToSelection({
-  schema: schema2,
-  editor,
-  range
-}) {
-  const [anchorBlock] = getPointBlock({
-    editor,
-    point: range.anchor
-  }), [focusBlock] = getPointBlock({
-    editor,
-    point: range.focus
-  });
-  if (!anchorBlock || !focusBlock)
-    return null;
-  const [anchorChild] = anchorBlock._type === schema2.block.name ? getPointChild({
-    editor,
-    point: range.anchor
-  }) : [void 0, void 0], [focusChild] = focusBlock._type === schema2.block.name ? getPointChild({
-    editor,
-    point: range.focus
-  }) : [void 0, void 0], selection = {
-    anchor: {
-      path: [{
-        _key: anchorBlock._key
-      }],
-      offset: range.anchor.offset
-    },
-    focus: {
-      path: [{
-        _key: focusBlock._key
-      }],
-      offset: range.focus.offset
-    },
-    backward: slate.Range.isBackward(range)
-  };
-  return anchorChild && (selection.anchor.path.push("children"), selection.anchor.path.push({
-    _key: anchorChild._key
-  })), focusChild && (selection.focus.path.push("children"), selection.focus.path.push({
-    _key: focusChild._key
-  })), selection;
-}
-function toSlatePath(path, editor) {
-  if (!editor)
-    return [];
-  const [block, blockPath] = Array.from(slate.Editor.nodes(editor, {
-    at: [],
-    match: (n) => types.isKeySegment(path[0]) && n._key === path[0]._key
-  }))[0] || [void 0, void 0];
-  if (!block || !slate.Element.isElement(block))
-    return [];
-  if (editor.isVoid(block))
-    return [blockPath[0], 0];
-  const childPath = [path[2]], childIndex = block.children.findIndex((child) => isEqual__default.default([{
-    _key: child._key
-  }], childPath));
-  if (childIndex >= 0 && block.children[childIndex]) {
-    const child = block.children[childIndex];
-    return slate.Element.isElement(child) && editor.isVoid(child) ? blockPath.concat(childIndex).concat(0) : blockPath.concat(childIndex);
-  }
-  return [blockPath[0], 0];
-}
-function toSlateRange(selection, editor) {
-  if (!selection || !editor)
-    return null;
-  const anchor = {
-    path: toSlatePath(selection.anchor.path, editor),
-    offset: selection.anchor.offset
-  }, focus = {
-    path: toSlatePath(selection.focus.path, editor),
-    offset: selection.focus.offset
-  };
-  return focus.path.length === 0 || anchor.path.length === 0 ? null : anchor && focus ? {
-    anchor,
-    focus
-  } : null;
-}
-function moveRangeByOperation(range, operation) {
-  const anchor = slate.Point.transform(range.anchor, operation), focus = slate.Point.transform(range.focus, operation);
-  return anchor === null || focus === null ? null : slate.Point.equals(anchor, range.anchor) && slate.Point.equals(focus, range.focus) ? range : {
-    anchor,
-    focus
-  };
-}
-const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), EditorActorContext = React.createContext({}), PortableTextEditorContext = React.createContext(null), usePortableTextEditor = () => {
-  const editor = React.useContext(PortableTextEditorContext);
-  if (!editor)
-    throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
-  return editor;
-};
-function compileType(rawType) {
-  return schema.Schema.compile({
-    name: "blockTypeSchema",
-    types: [rawType]
-  }).get(rawType.name);
-}
-const mutationMachine = xstate.setup({
-  types: {
-    context: {},
-    events: {},
-    input: {},
-    emitted: {}
-  },
-  actions: {
-    "emit has pending patches": xstate.emit({
-      type: "has pending patches"
-    }),
-    "emit mutations": xstate.enqueueActions(({
-      context,
-      enqueue
-    }) => {
-      for (const bulk of context.pendingMutations)
-        enqueue.emit({
-          type: "mutation",
-          patches: bulk.patches,
-          snapshot: bulk.value
-        });
-    }),
-    "clear pending mutations": xstate.assign({
-      pendingMutations: []
-    }),
-    "defer patch": xstate.assign({
-      pendingMutations: ({
-        context,
-        event
-      }) => {
-        if (xstate.assertEvent(event, "patch"), context.pendingMutations.length === 0)
-          return [{
-            actionId: event.actionId,
-            value: event.value,
-            patches: [event.patch]
-          }];
-        const lastBulk = context.pendingMutations.at(-1);
-        return lastBulk && lastBulk.actionId === event.actionId ? context.pendingMutations.slice(0, -1).concat({
-          value: event.value,
-          actionId: lastBulk.actionId,
-          patches: [...lastBulk.patches, event.patch]
-        }) : context.pendingMutations.concat({
-          value: event.value,
-          actionId: event.actionId,
-          patches: [event.patch]
-        });
-      }
-    })
-  },
-  actors: {
-    "type listener": xstate.fromCallback(({
-      input,
-      sendBack
-    }) => {
-      const originalApply = input.slateEditor.apply;
-      return input.slateEditor.apply = (op) => {
-        op.type === "insert_text" || op.type === "remove_text" ? sendBack({
-          type: "typing"
-        }) : sendBack({
-          type: "not typing"
-        }), originalApply(op);
-      }, () => {
-        input.slateEditor.apply = originalApply;
-      };
-    })
-  },
-  guards: {
-    "is typing": xstate.stateIn({
-      typing: "typing"
-    }),
-    "no pending mutations": ({
-      context
-    }) => context.pendingMutations.length === 0,
-    "slate is normalizing": ({
-      context
-    }) => slate.Editor.isNormalizing(context.slateEditor)
-  },
-  delays: {
-    "mutation debounce": process.env.NODE_ENV === "test" ? 250 : 0,
-    "type debounce": process.env.NODE_ENV === "test" ? 0 : 250
+const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), mutationMachine = xstate.setup({
+  types: {
+    context: {},
+    events: {},
+    input: {},
+    emitted: {}
+  },
+  actions: {
+    "emit has pending patches": xstate.emit({
+      type: "has pending patches"
+    }),
+    "emit mutations": xstate.enqueueActions(({
+      context,
+      enqueue
+    }) => {
+      for (const bulk of context.pendingMutations)
+        enqueue.emit({
+          type: "mutation",
+          patches: bulk.patches,
+          snapshot: bulk.value
+        });
+    }),
+    "clear pending mutations": xstate.assign({
+      pendingMutations: []
+    }),
+    "defer patch": xstate.assign({
+      pendingMutations: ({
+        context,
+        event
+      }) => {
+        if (xstate.assertEvent(event, "patch"), context.pendingMutations.length === 0)
+          return [{
+            actionId: event.actionId,
+            value: event.value,
+            patches: [event.patch]
+          }];
+        const lastBulk = context.pendingMutations.at(-1);
+        return lastBulk && lastBulk.actionId === event.actionId ? context.pendingMutations.slice(0, -1).concat({
+          value: event.value,
+          actionId: lastBulk.actionId,
+          patches: [...lastBulk.patches, event.patch]
+        }) : context.pendingMutations.concat({
+          value: event.value,
+          actionId: event.actionId,
+          patches: [event.patch]
+        });
+      }
+    })
+  },
+  actors: {
+    "type listener": xstate.fromCallback(({
+      input,
+      sendBack
+    }) => {
+      const originalApply = input.slateEditor.apply;
+      return input.slateEditor.apply = (op) => {
+        op.type === "insert_text" || op.type === "remove_text" ? sendBack({
+          type: "typing"
+        }) : sendBack({
+          type: "not typing"
+        }), originalApply(op);
+      }, () => {
+        input.slateEditor.apply = originalApply;
+      };
+    })
+  },
+  guards: {
+    "is typing": xstate.stateIn({
+      typing: "typing"
+    }),
+    "no pending mutations": ({
+      context
+    }) => context.pendingMutations.length === 0,
+    "slate is normalizing": ({
+      context
+    }) => slate.Editor.isNormalizing(context.slateEditor)
+  },
+  delays: {
+    "mutation debounce": process.env.NODE_ENV === "test" ? 250 : 0,
+    "type debounce": process.env.NODE_ENV === "test" ? 0 : 250
   }
 }).createMachine({
   id: "mutation",
@@ -2650,17 +2303,26 @@ const converterJson = {
     snapshot,
     event
   }) => {
-    const blocks = blockTools.htmlToBlocks(event.data, snapshot.context.schema.portableText, {
+    const parsedBlocks = blockTools.htmlToBlocks(event.data, snapshot.context.schema.portableText, {
       keyGenerator: snapshot.context.keyGenerator,
       unstable_whitespaceOnPasteMode: snapshot.context.schema.block.options.unstable_whitespaceOnPasteMode
+    }).flatMap((block) => {
+      const parsedBlock = parseBlocks.parseBlock({
+        context: snapshot.context,
+        block,
+        options: {
+          refreshKeys: !1
+        }
+      });
+      return parsedBlock ? [parsedBlock] : [];
     });
-    return blocks.length === 0 ? {
+    return parsedBlocks.length === 0 ? {
       type: "deserialization.failure",
       mimeType: "text/html",
       reason: "No blocks deserialized"
     } : {
       type: "deserialization.success",
-      data: blocks,
+      data: parsedBlocks,
       mimeType: "text/html"
     };
   }
@@ -2692,16 +2354,25 @@ const converterJson = {
     snapshot,
     event
   }) => {
-    const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, blocks = blockTools.htmlToBlocks(textToHtml, snapshot.context.schema.portableText, {
+    const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, parsedBlocks = blockTools.htmlToBlocks(textToHtml, snapshot.context.schema.portableText, {
       keyGenerator: snapshot.context.keyGenerator
+    }).flatMap((block) => {
+      const parsedBlock = parseBlocks.parseBlock({
+        context: snapshot.context,
+        block,
+        options: {
+          refreshKeys: !1
+        }
+      });
+      return parsedBlock ? [parsedBlock] : [];
     });
-    return blocks.length === 0 ? {
+    return parsedBlocks.length === 0 ? {
       type: "deserialization.failure",
       mimeType: "text/plain",
       reason: "No blocks deserialized"
     } : {
       type: "deserialization.success",
-      data: blocks,
+      data: parsedBlocks,
       mimeType: "text/plain"
     };
   }
@@ -2718,7 +2389,66 @@ const converterJson = {
 function escapeHtml(str) {
   return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
 }
-const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain], debug$c = debugWithName("operationToPatches");
+const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain];
+function compileType(rawType) {
+  return schema.Schema.compile({
+    name: "blockTypeSchema",
+    types: [rawType]
+  }).get(rawType.name);
+}
+function createEditorSchema(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;
+}
+const debug$c = debugWithName("operationToPatches");
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
@@ -3481,494 +3211,169 @@ function isDecoratorActive({
     ...slate.Editor.marks(editor) || {}
   }.marks || []).includes(decorator);
 }
-const debug$a = debugWithName("API:editable");
-function createEditableAPI(editor, editorActor) {
-  const types2 = editorActor.getSnapshot().context.schema;
-  return {
-    focus: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "focus"
-        },
-        editor
-      });
-    },
-    blur: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          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
+const addAnnotationActionImplementation = ({
+  context,
+  action
+}) => {
+  const editor = action.editor;
+  if (!editor.selection || slate.Range.isCollapsed(editor.selection))
+    return;
+  let paths, spanPath, markDefPath;
+  const markDefPaths = [], selectedBlocks = slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => editor.isTextBlock(node),
+    reverse: slate.Range.isBackward(editor.selection)
+  });
+  for (const [block, blockPath] of selectedBlocks) {
+    if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
+      continue;
+    const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
+    markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (slate.Transforms.setNodes(editor, {
+      markDefs: [...markDefs, {
+        _type: action.annotation.name,
+        _key: annotationKey,
+        ...action.annotation.value
+      }]
+    }, {
+      at: blockPath
+    }), markDefPath = [{
+      _key: block._key
+    }, "markDefs", {
+      _key: annotationKey
+    }], slate.Range.isBackward(editor.selection) ? markDefPaths.unshift(markDefPath) : markDefPaths.push(markDefPath)), slate.Transforms.setNodes(editor, {}, {
+      match: slate.Text.isText,
+      split: !0
+    });
+    const children = slate.Node.children(editor, blockPath);
+    for (const [span, path] of children) {
+      if (!editor.isTextSpan(span) || !slate.Range.includes(editor.selection, path))
+        continue;
+      const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
+      slate.Transforms.setNodes(editor, {
+        marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
+      }, {
+        at: path
+      }), spanPath = [{
+        _key: block._key
+      }, "children", {
+        _key: span._key
+      }];
+    }
+  }
+  return markDefPath && spanPath && (paths = {
+    markDefPath,
+    markDefPaths,
+    spanPath
+  }), paths;
+}, removeAnnotationActionImplementation = ({
+  action
+}) => {
+  const editor = action.editor;
+  if (editor.selection)
+    if (slate.Range.isCollapsed(editor.selection)) {
+      const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
+        depth: 1
       });
-    },
-    toggleBlockStyle: (style) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "style.toggle",
-          style
-        },
-        editor
+      if (!editor.isTextBlock(block))
+        return;
+      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = slate.Editor.node(editor, editor.selection, {
+        depth: 2
       });
-    },
-    isMarkActive: (mark) => {
-      try {
-        return isDecoratorActive({
-          editor,
-          decorator: mark
+      if (!editor.isTextSpan(selectedChild))
+        return;
+      const annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
+      if (!annotationToRemove)
+        return;
+      const previousSpansWithSameAnnotation = [];
+      for (const [child, childPath] of slate.Node.children(editor, blockPath, {
+        reverse: !0
+      }))
+        if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, selectedChildPath))
+          if (child.marks?.includes(annotationToRemove))
+            previousSpansWithSameAnnotation.push([child, childPath]);
+          else
+            break;
+      const nextSpansWithSameAnnotation = [];
+      for (const [child, childPath] of slate.Node.children(editor, blockPath))
+        if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, selectedChildPath))
+          if (child.marks?.includes(annotationToRemove))
+            nextSpansWithSameAnnotation.push([child, childPath]);
+          else
+            break;
+      for (const [child, childPath] of [...previousSpansWithSameAnnotation, [selectedChild, selectedChildPath], ...nextSpansWithSameAnnotation])
+        slate.Transforms.setNodes(editor, {
+          marks: child.marks?.filter((mark) => mark !== annotationToRemove)
+        }, {
+          at: childPath
         });
-      } catch (err) {
-        return console.warn(err), !1;
-      }
-    },
-    marks: () => ({
-      ...slate.Editor.marks(editor) || {}
-    }).marks || [],
-    undo: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "history.undo"
-        },
-        editor
+    } else {
+      slate.Transforms.setNodes(editor, {}, {
+        match: (node) => editor.isTextSpan(node),
+        split: !0,
+        hanging: !0
       });
-    },
-    redo: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "history.redo"
-        },
-        editor
+      const blocks = slate.Editor.nodes(editor, {
+        at: editor.selection,
+        match: (node) => editor.isTextBlock(node)
       });
-    },
-    select: (selection) => {
-      const slateSelection = toSlateRange(selection, editor);
-      slateSelection ? slate.Transforms.select(editor, slateSelection) : slate.Transforms.deselect(editor), editor.onChange();
-    },
-    focusBlock: () => {
-      if (editor.selection) {
-        const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (block)
-          return fromSlateValue([block], types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
-      }
-    },
-    focusChild: () => {
-      if (editor.selection) {
-        const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (block && editor.isTextBlock(block))
-          return fromSlateValue([block], types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0].children[editor.selection.focus.path[1]];
-      }
-    },
-    insertChild: (type, value) => {
-      if (type.name !== types2.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(slate.Editor.nodes(editor, {
-        at: editor.selection.focus.path.slice(0, 1),
-        match: (n) => n._type === types2.block.name
-      }))[0] || [void 0];
-      if (!focusBlock)
-        throw new Error("No focused text block");
-      if (type.name !== types2.span.name && !types2.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: types2.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 === types2.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types2.span.name && (debug$a("Inserting span child next to inline object child, moving selection + 1"), editor.move({
-        distance: 1,
-        unit: "character"
-      })), slate.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;
-      }
-    },
-    hasListStyle: (listItem) => {
-      try {
-        return isListItemActive({
-          editor,
-          listItem
-        });
-      } catch {
-        return !1;
-      }
-    },
-    isVoid: (element) => ![types2.block.name, types2.span.name].includes(element._type),
-    findByPath: (path) => {
-      const slatePath = toSlateRange({
-        focus: {
-          path,
-          offset: 0
-        },
-        anchor: {
-          path,
-          offset: 0
-        }
-      }, editor);
-      if (slatePath) {
-        const [block, blockPath] = slate.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], types2.block.name)[0], [{
-              _key: block._key
-            }]];
-          const ptBlock = fromSlateValue([block], types2.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];
-    },
-    findDOMNode: (element) => {
-      let node;
-      try {
-        const [item] = Array.from(slate.Editor.nodes(editor, {
-          at: [],
-          match: (n) => n._key === element._key
-        }) || [])[0] || [void 0];
-        node = slateReact.ReactEditor.toDOMNode(editor, item);
-      } catch {
-      }
-      return node;
-    },
-    activeAnnotations: () => {
-      if (!editor.selection || editor.selection.focus.path.length < 2)
-        return [];
-      try {
-        const activeAnnotations = [], spans = slate.Editor.nodes(editor, {
-          at: editor.selection,
-          match: (node) => slate.Text.isText(node) && node.marks !== void 0 && Array.isArray(node.marks) && node.marks.length > 0
-        });
-        for (const [span, path] of spans) {
-          const [block] = slate.Editor.node(editor, path, {
-            depth: 1
-          });
-          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
-            slate.Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
-          });
-        }
-        return activeAnnotations;
-      } catch {
-        return [];
-      }
-    },
-    isAnnotationActive: (annotationType) => isAnnotationActive({
-      editor,
-      annotation: {
-        name: annotationType
-      }
-    }),
-    addAnnotation: (type, value) => {
-      let paths;
-      return slate.Editor.withoutNormalizing(editor, () => {
-        paths = addAnnotationActionImplementation({
-          context: {
-            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
-            schema: types2
-          },
-          action: {
-            annotation: {
-              name: type.name,
-              value: value ?? {}
-            },
-            editor
-          }
-        });
-      }), 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$a("Deleting content in selection"), slate.Transforms.delete(editor, {
-              at: range,
-              hanging: !0,
-              voids: !0
-            }), editor.onChange();
-            return;
-          }
-          options?.mode === "blocks" && (debug$a("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
-            at: range,
-            voids: !0,
-            match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && slate.Element.isElement(node)
-          })), options?.mode === "children" && (debug$a("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
-            at: range,
-            voids: !0,
-            match: (node) => node._type === types2.span.name || // Text children
-            !editor.isTextBlock(node) && slate.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
-          }
-        },
-        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, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
-    isCollapsedSelection: () => !!editor.selection && slate.Range.isCollapsed(editor.selection),
-    isExpandedSelection: () => !!editor.selection && slate.Range.isExpanded(editor.selection),
-    insertBreak: () => {
-      editor.insertBreak(), editor.onChange();
-    },
-    getFragment: () => fromSlateValue(editor.getFragment(), types2.block.name),
-    isSelectionsOverlapping: (selectionA, selectionB) => {
-      const rangeA = toSlateRange(selectionA, editor), rangeB = toSlateRange(selectionB, editor);
-      return slate.Range.isRange(rangeA) && slate.Range.isRange(rangeB) && slate.Range.includes(rangeA, rangeB);
-    }
-  };
-}
-function isAnnotationActive({
-  editor,
-  annotation
-}) {
-  if (!editor.selection || editor.selection.focus.path.length < 2)
-    return !1;
-  try {
-    const spans = [...slate.Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => slate.Text.isText(node)
-    })];
-    if (spans.length === 0 || spans.some(([span]) => !types.isPortableTextSpan(span) || !span.marks || span.marks?.length === 0)) return !1;
-    const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
-      const [block] = slate.Editor.node(editor, path, {
-        depth: 1
-      });
-      return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
-    }, []);
-    return spans.every(([span]) => types.isPortableTextSpan(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
-  } catch {
-    return !1;
-  }
-}
-const addAnnotationActionImplementation = ({
-  context,
-  action
-}) => {
-  const editor = action.editor;
-  if (!editor.selection || slate.Range.isCollapsed(editor.selection))
-    return;
-  let paths, spanPath, markDefPath;
-  const markDefPaths = [], selectedBlocks = slate.Editor.nodes(editor, {
-    at: editor.selection,
-    match: (node) => editor.isTextBlock(node),
-    reverse: slate.Range.isBackward(editor.selection)
-  });
-  for (const [block, blockPath] of selectedBlocks) {
-    if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
-      continue;
-    const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
-    markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (slate.Transforms.setNodes(editor, {
-      markDefs: [...markDefs, {
-        _type: action.annotation.name,
-        _key: annotationKey,
-        ...action.annotation.value
-      }]
-    }, {
-      at: blockPath
-    }), markDefPath = [{
-      _key: block._key
-    }, "markDefs", {
-      _key: annotationKey
-    }], slate.Range.isBackward(editor.selection) ? markDefPaths.unshift(markDefPath) : markDefPaths.push(markDefPath)), slate.Transforms.setNodes(editor, {}, {
-      match: slate.Text.isText,
-      split: !0
-    });
-    const children = slate.Node.children(editor, blockPath);
-    for (const [span, path] of children) {
-      if (!editor.isTextSpan(span) || !slate.Range.includes(editor.selection, path))
-        continue;
-      const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
-      slate.Transforms.setNodes(editor, {
-        marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
-      }, {
-        at: path
-      }), spanPath = [{
-        _key: block._key
-      }, "children", {
-        _key: span._key
-      }];
-    }
-  }
-  return markDefPath && spanPath && (paths = {
-    markDefPath,
-    markDefPaths,
-    spanPath
-  }), paths;
-}, removeAnnotationActionImplementation = ({
-  action
-}) => {
-  const editor = action.editor;
-  if (debug$a("Removing annotation", action.annotation.name), !!editor.selection)
-    if (slate.Range.isCollapsed(editor.selection)) {
-      const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
-        depth: 1
-      });
-      if (!editor.isTextBlock(block))
-        return;
-      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = slate.Editor.node(editor, editor.selection, {
-        depth: 2
-      });
-      if (!editor.isTextSpan(selectedChild))
-        return;
-      const annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
-      if (!annotationToRemove)
-        return;
-      const previousSpansWithSameAnnotation = [];
-      for (const [child, childPath] of slate.Node.children(editor, blockPath, {
-        reverse: !0
-      }))
-        if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, selectedChildPath))
-          if (child.marks?.includes(annotationToRemove))
-            previousSpansWithSameAnnotation.push([child, childPath]);
-          else
-            break;
-      const nextSpansWithSameAnnotation = [];
-      for (const [child, childPath] of slate.Node.children(editor, blockPath))
-        if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, selectedChildPath))
-          if (child.marks?.includes(annotationToRemove))
-            nextSpansWithSameAnnotation.push([child, childPath]);
-          else
-            break;
-      for (const [child, childPath] of [...previousSpansWithSameAnnotation, [selectedChild, selectedChildPath], ...nextSpansWithSameAnnotation])
-        slate.Transforms.setNodes(editor, {
-          marks: child.marks?.filter((mark) => mark !== annotationToRemove)
-        }, {
-          at: childPath
-        });
-    } else {
-      slate.Transforms.setNodes(editor, {}, {
-        match: (node) => editor.isTextSpan(node),
-        split: !0,
-        hanging: !0
-      });
-      const blocks = slate.Editor.nodes(editor, {
-        at: editor.selection,
-        match: (node) => editor.isTextBlock(node)
-      });
-      for (const [block, blockPath] of blocks) {
-        const children = slate.Node.children(editor, blockPath);
-        for (const [child, childPath] of children) {
-          if (!editor.isTextSpan(child) || !slate.Range.includes(editor.selection, childPath))
-            continue;
-          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== action.annotation.name);
-          marksWithoutAnnotation.length !== marks.length && slate.Transforms.setNodes(editor, {
-            marks: marksWithoutAnnotation
-          }, {
-            at: childPath
-          });
-        }
+      for (const [block, blockPath] of blocks) {
+        const children = slate.Node.children(editor, blockPath);
+        for (const [child, childPath] of children) {
+          if (!editor.isTextSpan(child) || !slate.Range.includes(editor.selection, childPath))
+            continue;
+          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== action.annotation.name);
+          marksWithoutAnnotation.length !== marks.length && slate.Transforms.setNodes(editor, {
+            marks: marksWithoutAnnotation
+          }, {
+            at: childPath
+          });
+        }
       }
     }
-}, blockSetBehaviorActionImplementation = ({
+};
+function toSlatePath(path, editor) {
+  if (!editor)
+    return [];
+  const [block, blockPath] = Array.from(slate.Editor.nodes(editor, {
+    at: [],
+    match: (n) => types.isKeySegment(path[0]) && n._key === path[0]._key
+  }))[0] || [void 0, void 0];
+  if (!block || !slate.Element.isElement(block))
+    return [];
+  if (editor.isVoid(block))
+    return [blockPath[0], 0];
+  const childPath = [path[2]], childIndex = block.children.findIndex((child) => isEqual__default.default([{
+    _key: child._key
+  }], childPath));
+  if (childIndex >= 0 && block.children[childIndex]) {
+    const child = block.children[childIndex];
+    return slate.Element.isElement(child) && editor.isVoid(child) ? blockPath.concat(childIndex).concat(0) : blockPath.concat(childIndex);
+  }
+  return [blockPath[0], 0];
+}
+function toSlateRange(selection, editor) {
+  if (!selection || !editor)
+    return null;
+  const anchor = {
+    path: toSlatePath(selection.anchor.path, editor),
+    offset: selection.anchor.offset
+  }, focus = {
+    path: toSlatePath(selection.focus.path, editor),
+    offset: selection.focus.offset
+  };
+  return focus.path.length === 0 || anchor.path.length === 0 ? null : anchor && focus ? {
+    anchor,
+    focus
+  } : null;
+}
+function moveRangeByOperation(range, operation) {
+  const anchor = slate.Point.transform(range.anchor, operation), focus = slate.Point.transform(range.focus, operation);
+  return anchor === null || focus === null ? null : slate.Point.equals(anchor, range.anchor) && slate.Point.equals(focus, range.focus) ? range : {
+    anchor,
+    focus
+  };
+}
+const blockSetBehaviorActionImplementation = ({
   context,
   action
 }) => {
@@ -4082,7 +3487,187 @@ const addAnnotationActionImplementation = ({
   action
 }) => {
   slateReact.ReactEditor.blur(action.editor);
-}, decoratorAddActionImplementation = ({
+};
+function getFocusBlock({
+  editor
+}) {
+  if (!editor.selection)
+    return [void 0, void 0];
+  try {
+    return slate.Editor.node(editor, editor.selection.focus.path.slice(0, 1)) ?? [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getPointBlock({
+  editor,
+  point
+}) {
+  try {
+    const [block] = slate.Editor.node(editor, point.path.slice(0, 1)) ?? [void 0, void 0];
+    return block ? [block, point.path] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getFocusChild({
+  editor
+}) {
+  const [focusBlock, focusBlockPath] = getFocusBlock({
+    editor
+  }), childIndex = editor.selection?.focus.path.at(1);
+  if (!focusBlock || !focusBlockPath || childIndex === void 0)
+    return [void 0, void 0];
+  try {
+    const focusChild = slate.Node.child(focusBlock, childIndex);
+    return focusChild ? [focusChild, [...focusBlockPath, childIndex]] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getPointChild({
+  editor,
+  point
+}) {
+  const [block, blockPath] = getPointBlock({
+    editor,
+    point
+  }), childIndex = point.path.at(1);
+  if (!block || !blockPath || childIndex === void 0)
+    return [void 0, void 0];
+  try {
+    const pointChild = slate.Node.child(block, childIndex);
+    return pointChild ? [pointChild, [...blockPath, childIndex]] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getFirstBlock({
+  editor
+}) {
+  const firstBlockPath = slate.Editor.start(editor, []).path.at(0);
+  try {
+    return firstBlockPath !== void 0 ? slate.Editor.node(editor, [firstBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getLastBlock({
+  editor
+}) {
+  const lastBlockPath = slate.Editor.end(editor, []).path.at(0);
+  try {
+    return lastBlockPath !== void 0 ? slate.Editor.node(editor, [lastBlockPath]) ?? [void 0, void 0] : [void 0, void 0];
+  } catch {
+    return [void 0, void 0];
+  }
+}
+function getNodeBlock({
+  editor,
+  schema: schema2,
+  node
+}) {
+  if (slate.Editor.isEditor(node))
+    return;
+  if (isBlockElement({
+    editor,
+    schema: schema2
+  }, node))
+    return elementToBlock({
+      schema: schema2,
+      element: node
+    });
+  const parent = Array.from(slate.Editor.nodes(editor, {
+    mode: "highest",
+    at: [],
+    match: (n) => isBlockElement({
+      editor,
+      schema: schema2
+    }, n) && n.children.some((child) => child._key === node._key)
+  })).at(0)?.at(0);
+  return slate.Element.isElement(parent) ? elementToBlock({
+    schema: schema2,
+    element: parent
+  }) : void 0;
+}
+function elementToBlock({
+  schema: schema2,
+  element
+}) {
+  return fromSlateValue([element], schema2.block.name)?.at(0);
+}
+function isBlockElement({
+  editor,
+  schema: schema2
+}, node) {
+  return slate.Element.isElement(node) && !editor.isInline(node) && (schema2.block.name === node._type || schema2.blockObjects.some((blockObject) => blockObject.name === node._type));
+}
+function isListItemActive({
+  editor,
+  listItem
+}) {
+  if (!editor.selection)
+    return !1;
+  const selectedBlocks = [...slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => editor.isTextBlock(node)
+  })];
+  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
+}
+function isStyleActive({
+  editor,
+  style
+}) {
+  if (!editor.selection)
+    return !1;
+  const selectedBlocks = [...slate.Editor.nodes(editor, {
+    at: editor.selection,
+    match: (node) => editor.isTextBlock(node)
+  })];
+  return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
+}
+function slateRangeToSelection({
+  schema: schema2,
+  editor,
+  range
+}) {
+  const [anchorBlock] = getPointBlock({
+    editor,
+    point: range.anchor
+  }), [focusBlock] = getPointBlock({
+    editor,
+    point: range.focus
+  });
+  if (!anchorBlock || !focusBlock)
+    return null;
+  const [anchorChild] = anchorBlock._type === schema2.block.name ? getPointChild({
+    editor,
+    point: range.anchor
+  }) : [void 0, void 0], [focusChild] = focusBlock._type === schema2.block.name ? getPointChild({
+    editor,
+    point: range.focus
+  }) : [void 0, void 0], selection = {
+    anchor: {
+      path: [{
+        _key: anchorBlock._key
+      }],
+      offset: range.anchor.offset
+    },
+    focus: {
+      path: [{
+        _key: focusBlock._key
+      }],
+      offset: range.focus.offset
+    },
+    backward: slate.Range.isBackward(range)
+  };
+  return anchorChild && (selection.anchor.path.push("children"), selection.anchor.path.push({
+    _key: anchorChild._key
+  })), focusChild && (selection.focus.path.push("children"), selection.focus.path.push({
+    _key: focusChild._key
+  })), selection;
+}
+const decoratorAddActionImplementation = ({
   context,
   action
 }) => {
@@ -4497,7 +4082,7 @@ const insertTextActionImplementation = ({
 }) => {
   const newSelection = toSlateRange(action.selection, action.editor);
   newSelection ? slate.Transforms.select(action.editor, newSelection) : slate.Transforms.deselect(action.editor);
-}, debug$9 = debugWithName("behaviors:action"), behaviorActionImplementations = {
+}, debug$a = debugWithName("behaviors:action"), behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
   "block.set": blockSetBehaviorActionImplementation,
@@ -4528,7 +4113,7 @@ function performAction({
   context,
   action
 }) {
-  switch (debug$9(JSON.stringify(omit__default.default(action, ["editor"]), null, 2)), action.type) {
+  switch (debug$a(JSON.stringify(omit__default.default(action, ["editor"]), null, 2)), action.type) {
     case "annotation.add": {
       behaviorActionImplementations["annotation.add"]({
         context,
@@ -4963,13 +4548,13 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-const debug$8 = debugWithName("applyPatches"), debugVerbose = debug$8.enabled && !0;
+const debug$9 = debugWithName("applyPatches"), debugVerbose = debug$9.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose && (debug$8(`
+    debugVerbose && (debug$9(`
 
-NEW PATCH =============================================================`), debug$8(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$9(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -4985,7 +4570,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$8("Unhandled patch", patch.type);
+          debug$9("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -5000,9 +4585,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$8("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   if (!child || !childPath)
-    return debug$8("Child not found"), !1;
+    return debug$9("Child not found"), !1;
   if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child))
     return !1;
   const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, {
@@ -5032,9 +4617,9 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$8("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$8("Ignoring patch targeting void value"), !1;
+    return debug$9("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -5042,7 +4627,7 @@ function insertPatch(editor, patch, schemaTypes) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$8(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$9(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -5051,14 +4636,14 @@ function insertPatch(editor, patch, schemaTypes) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$8("Child not found"), !1;
+    return debug$9("Child not found"), !1;
   const childrenToInsert = targetBlock && toSlateValue([{
     ...targetBlock,
     children: items
   }], {
     schemaTypes
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$8(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$9(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -5072,14 +4657,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$8("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$8("Ignoring setting void value"), !1;
+    return debug$9("Ignoring setting void value"), !1;
   if (debugState(editor, "before"), isTextBlock && child && childPath) {
     if (slate.Text.isText(value) && slate.Text.isText(child)) {
       const newText = child.text;
-      value.text !== newText && (debug$8("Setting text property"), editor.apply({
+      value.text !== newText && (debug$9("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -5091,7 +4676,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$8("Setting non-text property"), editor.apply({
+      debug$9("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -5099,7 +4684,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$8("Setting block property");
+    debug$9("Setting block property");
     const {
       children,
       ...nextRest
@@ -5116,7 +4701,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$8("Setting children"), block.children.forEach((c, cIndex) => {
+    }), debug$9("Setting children"), block.children.forEach((c, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -5147,7 +4732,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$8("Removing everything"), debugState(editor, "before");
+    debug$9("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       slate.Transforms.removeNodes(editor, {
@@ -5174,13 +4759,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$8("Block not found"), !1;
+      return debug$9("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$8(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
+    return debug$9(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
       at: [blockIndex]
     }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$8("Child not found"), !1) : (debug$8(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$8(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$9("Child not found"), !1) : (debug$9(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$9(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -5188,7 +4773,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose && (debug$8(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$8(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose && (debug$9(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$9(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -5230,7 +4815,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$7 = debugWithName("plugin:withPatches");
+const debug$8 = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -5256,7 +4841,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               patches2.forEach((patch) => {
-                debug$7.enabled && debug$7(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                debug$8.enabled && debug$8(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -5269,10 +4854,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$7("Subscribing to remote patches");
+      debug$8("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$7("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$8("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       let patches$1 = [];
@@ -5326,7 +4911,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$6 = debugWithName("plugin:withPlaceholderBlock");
+const debug$7 = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -5351,7 +4936,7 @@ function createWithPlaceholderBlock(editorActor) {
         const node = op.node;
         if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
           const nextPath = slate.Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$6("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$7("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -5360,7 +4945,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$5 = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$6 = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor, types2) {
   const defaultStyle = types2.styles[0].value;
   return function(editor) {
@@ -5373,7 +4958,7 @@ function createWithPortableTextBlockStyle(editorActor, types2) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$5(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$6(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               style: defaultStyle
@@ -5424,7 +5009,7 @@ function createWithPortableTextSelections(editorActor) {
     }, editor;
   };
 }
-const debug$4 = debugWithName("plugin:withSchemaTypes");
+const debug$5 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
   schemaTypes
@@ -5437,7 +5022,7 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$4("Setting span type on text node without a type");
+        debug$5("Setting span type on text node without a type");
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -5453,7 +5038,7 @@ function createWithSchemaTypes({
         return;
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$4("Setting missing key on child node without a key");
+        debug$5("Setting missing key on child node without a key");
         const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -5519,12 +5104,12 @@ const withPlugins = (editor, options) => {
     schemaTypes
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
   return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
-}, debug$3 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
+}, debug$4 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
 function createSlateEditor(config) {
   const existingSlateEditor = slateEditors.get(config.editorActor);
   if (existingSlateEditor)
-    return debug$3("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
-  debug$3("Creating new Slate editor instance", config.editorActor.id);
+    return debug$4("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
+  debug$4("Creating new Slate editor instance", config.editorActor.id);
   const unsubscriptions = [], subscriptions = [], instance = withPlugins(slateReact.withReact(slate.createEditor()), {
     editorActor: config.editorActor,
     subscriptions
@@ -5538,7 +5123,91 @@ function createSlateEditor(config) {
     instance,
     initialValue
   };
-  return slateEditors.set(config.editorActor, slateEditor), slateEditor;
+  return slateEditors.set(config.editorActor, slateEditor), slateEditor;
+}
+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 compileSchemaDefinition(definition) {
+  const blockObjects = definition?.blockObjects?.map((blockObject) => types.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: []
+  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => types.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: []
+  })) ?? [], portableTextSchema = types.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__default.default(decorator.name),
+          value: decorator.name
+        })) ?? [],
+        annotations: definition?.annotations?.map((annotation) => ({
+          name: annotation.name,
+          type: "object",
+          title: annotation.title
+        })) ?? []
+      },
+      lists: definition?.lists?.map((list) => ({
+        value: list.name,
+        title: list.title ?? startCase__default.default(list.name)
+      })) ?? [],
+      styles: definition?.styles?.map((style) => ({
+        value: style.name,
+        title: style.title ?? startCase__default.default(style.name)
+      })) ?? []
+    }]
+  }), schema$1 = schema.Schema.compile({
+    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
+  }).get("portable-text"), pteSchema = createEditorSchema(schema$1);
+  return {
+    ...pteSchema,
+    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
+      ...blockObject,
+      name: objectNames[blockObject.name],
+      type: {
+        ...blockObject.type,
+        name: objectNames[blockObject.name]
+      }
+    } : blockObject),
+    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
+      ...inlineObject,
+      name: objectNames[inlineObject.name]
+    } : inlineObject)
+  };
 }
 const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
   on: "annotation.toggle",
@@ -5987,22 +5656,228 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     })]]
   }),
   behavior_core.defineBehavior({
-    on: "clipboard.cut",
-    guard: ({
-      snapshot
-    }) => {
-      const focusSpan = selector_isOverlappingSelection.getFocusSpan(snapshot), selectionCollapsed = selector_isOverlappingSelection.isSelectionCollapsed(snapshot);
-      return focusSpan && selectionCollapsed;
-    },
-    actions: [() => [{
-      type: "noop"
+    on: "clipboard.cut",
+    guard: ({
+      snapshot
+    }) => {
+      const focusSpan = selector_isOverlappingSelection.getFocusSpan(snapshot), selectionCollapsed = selector_isOverlappingSelection.isSelectionCollapsed(snapshot);
+      return focusSpan && selectionCollapsed;
+    },
+    actions: [() => [{
+      type: "noop"
+    }]]
+  }),
+  behavior_core.defineBehavior({
+    on: "clipboard.cut",
+    guard: ({
+      snapshot
+    }) => snapshot.context.selection ? {
+      selection: snapshot.context.selection
+    } : !1,
+    actions: [({
+      event
+    }, {
+      selection
+    }) => [behavior_core.raise({
+      type: "serialize",
+      originEvent: event
+    }), behavior_core.raise({
+      type: "delete",
+      selection
+    })]]
+  }),
+  behavior_core.defineBehavior({
+    on: "drag.dragstart",
+    actions: [({
+      event
+    }) => [behavior_core.raise({
+      type: "serialize",
+      originEvent: event
+    })]]
+  }),
+  behavior_core.defineBehavior({
+    on: "serialization.success",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        event.originEvent.originEvent.dataTransfer.setData(event.mimeType, event.data);
+      }
+    }]]
+  }),
+  behavior_core.defineBehavior({
+    on: "serialization.failure",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        console.warn(`Serialization of ${event.mimeType} failed with reason "${event.reason}"`);
+      }
+    }]]
+  }),
+  behavior_core.defineBehavior({
+    on: "drag.drop",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
+      return dragOrigin ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }) : !1;
+    },
+    actions: [() => [{
+      type: "noop"
+    }]]
+  }),
+  behavior_core.defineBehavior({
+    on: "drag.drop",
+    actions: [({
+      event
+    }) => [behavior_core.raise({
+      type: "select",
+      selection: event.position.selection
+    }), behavior_core.raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
+  }),
+  behavior_core.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 ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }) : !1, draggingEntireBlocks = selector_isSelectingEntireBlocks.isSelectingEntireBlocks({
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }), draggedBlocks = selector_isOverlappingSelection.getSelectedBlocks({
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      });
+      return droppingOnDragOrigin ? !1 : {
+        draggingEntireBlocks,
+        draggedBlocks,
+        dragOrigin,
+        originEvent: event.originEvent
+      };
+    },
+    actions: [({
+      event
+    }, {
+      draggingEntireBlocks,
+      draggedBlocks,
+      dragOrigin,
+      originEvent
+    }) => [...draggingEntireBlocks ? draggedBlocks.map((block) => behavior_core.raise({
+      type: "delete.block",
+      at: block.path
+    })) : [behavior_core.raise({
+      type: "delete",
+      selection: dragOrigin.selection
+    })], behavior_core.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.
+   */
+  behavior_core.defineBehavior({
+    on: "deserialization.success",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      if (selector_isOverlappingSelection.getFocusTextBlock(snapshot) && event.mimeType === "text/plain" && event.originEvent.type === "clipboard.paste") {
+        const activeDecorators = snapshot.context.activeDecorators;
+        return {
+          activeAnnotations: selector_isSelectingEntireBlocks.getActiveAnnotations(snapshot),
+          activeDecorators,
+          textRuns: event.data.flatMap((block) => parseBlocks.isTextBlock(snapshot.context.schema, block) ? [util_sliceBlocks.getTextBlockText(block)] : [])
+        };
+      }
+      return !1;
+    },
+    actions: [(_, {
+      activeAnnotations,
+      activeDecorators,
+      textRuns
+    }) => textRuns.flatMap((textRun, index) => index !== textRuns.length - 1 ? [behavior_core.raise({
+      type: "insert.span",
+      text: textRun,
+      decorators: activeDecorators,
+      annotations: activeAnnotations.map(({
+        _key,
+        _type,
+        ...value
+      }) => ({
+        name: _type,
+        value
+      }))
+    }), behavior_core.raise({
+      type: "insert.break"
+    })] : [behavior_core.raise({
+      type: "insert.span",
+      text: textRun,
+      decorators: activeDecorators,
+      annotations: activeAnnotations.map(({
+        _key,
+        _type,
+        ...value
+      }) => ({
+        name: _type,
+        value
+      }))
+    })])]
+  }),
+  behavior_core.defineBehavior({
+    on: "deserialization.success",
+    actions: [({
+      event
+    }) => [behavior_core.raise({
+      type: "insert.blocks",
+      blocks: event.data,
+      placement: "auto"
+    })]]
+  }),
+  behavior_core.defineBehavior({
+    on: "deserialization.failure",
+    actions: [({
+      event
+    }) => [{
+      type: "effect",
+      effect: () => {
+        console.warn(`Deserialization of ${event.mimeType} failed with reason "${event.reason}"`);
+      }
     }]]
   }),
   behavior_core.defineBehavior({
-    on: "clipboard.cut",
+    on: "clipboard.paste",
     guard: ({
       snapshot
-    }) => snapshot.context.selection ? {
+    }) => snapshot.context.selection && selector_isOverlappingSelection.isSelectionExpanded(snapshot) ? {
       selection: snapshot.context.selection
     } : !1,
     actions: [({
@@ -6010,887 +5885,1049 @@ const abstractAnnotationBehaviors = [behavior_core.defineBehavior({
     }, {
       selection
     }) => [behavior_core.raise({
-      type: "serialize",
-      originEvent: event
-    }), behavior_core.raise({
       type: "delete",
       selection
+    }), behavior_core.raise({
+      type: "deserialize",
+      originEvent: event
     })]]
   }),
   behavior_core.defineBehavior({
-    on: "drag.dragstart",
+    on: "clipboard.paste",
     actions: [({
       event
     }) => [behavior_core.raise({
-      type: "serialize",
+      type: "deserialize",
       originEvent: event
     })]]
   }),
   behavior_core.defineBehavior({
-    on: "serialization.success",
+    on: "input.*",
     actions: [({
       event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        event.originEvent.originEvent.dataTransfer.setData(event.mimeType, event.data);
-      }
-    }]]
+    }) => [behavior_core.raise({
+      type: "deserialize",
+      originEvent: event
+    })]]
   }),
-  behavior_core.defineBehavior({
-    on: "serialization.failure",
-    actions: [({
-      event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        console.warn(`Serialization of ${event.mimeType} failed with reason "${event.reason}"`);
+  ...abstractAnnotationBehaviors,
+  ...abstractDecoratorBehaviors,
+  ...abstractInsertBehaviors,
+  ...abstractListItemBehaviors,
+  ...abstractMoveBehaviors,
+  ...abstractStyleBehaviors,
+  ...abstractSelectBehaviors,
+  raiseDeserializationSuccessOrFailure,
+  raiseSerializationSuccessOrFailure,
+  raiseInsertSoftBreak
+], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
+function isAbstractBehaviorEvent(event) {
+  return abstractBehaviorEventTypes.includes(event.type);
+}
+const nativeBehaviorEventTypes = ["clipboard.copy", "clipboard.cut", "clipboard.paste", "drag.dragstart", "drag.drag", "drag.dragend", "drag.dragenter", "drag.dragover", "drag.dragleave", "drag.drop", "input.*", "keyboard.keydown", "keyboard.keyup", "mouse.click"];
+function isNativeBehaviorEvent(event) {
+  return nativeBehaviorEventTypes.includes(event.type);
+}
+function isCustomBehaviorEvent(event) {
+  return event.type.startsWith("custom.");
+}
+const debug$3 = debugWithName("behaviors:event");
+function eventCategory(event) {
+  return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "abstract" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
+}
+function performEvent({
+  behaviors,
+  event,
+  editor,
+  keyGenerator,
+  schema: schema2,
+  getSnapshot,
+  nativeEvent,
+  defaultActionCallback
+}) {
+  debug$3(`(${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
+    ...event,
+    editor
+  }, eventBehaviors = 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 (defaultActionCallback) {
+      withApplyingBehaviorActions(editor, () => {
+        try {
+          defaultActionCallback();
+        } catch (error) {
+          console.error(new Error(`Performing action "${event.type}" failed due to: ${error.message}`));
+        }
+      });
+      return;
+    }
+    if (!defaultAction)
+      return;
+    withApplyingBehaviorActions(editor, () => {
+      try {
+        performAction({
+          context: {
+            keyGenerator,
+            schema: schema2
+          },
+          action: defaultAction
+        });
+      } catch (error) {
+        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
       }
-    }]]
-  }),
-  behavior_core.defineBehavior({
-    on: "drag.drop",
-    guard: ({
-      snapshot,
+    }), editor.onChange();
+    return;
+  }
+  const editorSnapshot = getSnapshot();
+  let behaviorOverwritten = !1;
+  for (const eventBehavior of eventBehaviors) {
+    const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
+      context: editorSnapshot.context,
+      snapshot: editorSnapshot,
       event
-    }) => {
-      const dragOrigin = snapshot.beta.internalDrag?.origin, dropPosition = event.position.selection;
-      return dragOrigin ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
+    });
+    if (!shouldRun)
+      continue;
+    const actionSets = eventBehavior.actions.map((actionSet) => actionSet({
+      context: editorSnapshot.context,
+      snapshot: editorSnapshot,
+      event
+    }, shouldRun));
+    for (const actionSet of actionSets)
+      actionSet.length !== 0 && (behaviorOverwritten = behaviorOverwritten || actionSet.some((action) => action.type !== "effect"), withApplyingBehaviorActionSet(editor, () => {
+        for (const action of actionSet) {
+          if (action.type === "raise") {
+            performEvent({
+              behaviors,
+              event: action.event,
+              editor,
+              keyGenerator,
+              schema: schema2,
+              getSnapshot,
+              defaultActionCallback: void 0,
+              nativeEvent: void 0
+            });
+            continue;
+          }
+          const internalAction = {
+            ...action,
+            editor
+          };
+          try {
+            performAction({
+              context: {
+                keyGenerator,
+                schema: schema2
+              },
+              action: internalAction
+            });
+          } catch (error) {
+            console.error(new Error(`Performing action "${internalAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+            break;
+          }
         }
-      }) : !1;
+      }), editor.onChange());
+    if (behaviorOverwritten) {
+      nativeEvent?.preventDefault();
+      break;
+    }
+  }
+  if (!behaviorOverwritten) {
+    if (defaultActionCallback) {
+      withApplyingBehaviorActions(editor, () => {
+        try {
+          defaultActionCallback();
+        } catch (error) {
+          console.error(new Error(`Performing "${event.type}" failed due to: ${error.message}`));
+        }
+      });
+      return;
+    }
+    if (!defaultAction)
+      return;
+    withApplyingBehaviorActions(editor, () => {
+      try {
+        performAction({
+          context: {
+            keyGenerator,
+            schema: schema2
+          },
+          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 slateChildrenToBlocks(schema2, value) {
+  const blocks = new Array(value.length);
+  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
+    const descendant = value[blockIndex];
+    if (descendant._type !== schema2.block.name) {
+      blocks[blockIndex] = {
+        _key: descendant._key,
+        _type: descendant._type,
+        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
+      };
+      continue;
+    }
+    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
+    for (let childIndex = 0; childIndex < children.length; childIndex++) {
+      const child = children[childIndex];
+      processedChildren[childIndex] = child._type === schema2.span.name ? child : {
+        _key: child._key,
+        _type: child._type,
+        ..."value" in child && typeof child.value == "object" ? child.value : {}
+      };
+    }
+    blocks[blockIndex] = {
+      ...descendant,
+      children: processedChildren
+    };
+  }
+  return blocks;
+}
+function getActiveDecorators({
+  schema: schema2,
+  slateEditorInstance
+}) {
+  const decorators = schema2.decorators.map((decorator) => decorator.value);
+  return ({
+    ...slate.Editor.marks(slateEditorInstance) ?? {}
+  }.marks ?? []).filter((mark) => decorators.includes(mark));
+}
+function createEditorSnapshot({
+  converters,
+  editor,
+  keyGenerator,
+  readOnly,
+  schema: schema2,
+  hasTag,
+  internalDrag
+}) {
+  const value = slateChildrenToBlocks(schema2, editor.children), selection = editor.selection ? slateRangeToSelection({
+    schema: schema2,
+    editor,
+    range: editor.selection
+  }) : null;
+  return {
+    context: {
+      activeDecorators: getActiveDecorators({
+        schema: schema2,
+        slateEditorInstance: editor
+      }),
+      converters,
+      keyGenerator,
+      readOnly,
+      schema: schema2,
+      selection,
+      value
     },
-    actions: [() => [{
-      type: "noop"
-    }]]
-  }),
-  behavior_core.defineBehavior({
-    on: "drag.drop",
-    actions: [({
-      event
-    }) => [behavior_core.raise({
-      type: "select",
-      selection: event.position.selection
-    }), behavior_core.raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  behavior_core.defineBehavior({
-    on: "deserialization.success",
-    guard: ({
-      snapshot,
-      event
+    beta: {
+      hasTag,
+      internalDrag
+    }
+  };
+}
+const editorMachine = xstate.setup({
+  types: {
+    context: {},
+    events: {},
+    emitted: {},
+    input: {},
+    tags: {}
+  },
+  actions: {
+    "add behavior to context": xstate.assign({
+      behaviors: ({
+        context,
+        event
+      }) => (xstate.assertEvent(event, "add behavior"), /* @__PURE__ */ new Set([...context.behaviors, event.behavior]))
+    }),
+    "remove behavior from context": xstate.assign({
+      behaviors: ({
+        context,
+        event
+      }) => (xstate.assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
+    }),
+    "assign behaviors": xstate.assign({
+      behaviors: ({
+        event
+      }) => (xstate.assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...event.behaviors]))
+    }),
+    "assign schema": xstate.assign({
+      schema: ({
+        event
+      }) => (xstate.assertEvent(event, "update schema"), event.schema)
+    }),
+    "emit patch event": xstate.enqueueActions(({
+      event,
+      enqueue
     }) => {
-      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 ? selector_isOverlappingSelection.isOverlappingSelection(dropPosition)({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
-        }
-      }) : !1, draggingEntireBlocks = selector_isSelectingEntireBlocks.isSelectingEntireBlocks({
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
-        }
-      }), draggedBlocks = selector_isOverlappingSelection.getSelectedBlocks({
-        context: {
-          ...snapshot.context,
-          selection: dragOrigin.selection
-        }
+      xstate.assertEvent(event, "internal.patch"), enqueue.emit(event), enqueue.emit({
+        type: "patch",
+        patch: event.patch
       });
-      return droppingOnDragOrigin ? !1 : {
-        draggingEntireBlocks,
-        draggedBlocks,
-        dragOrigin,
-        originEvent: event.originEvent
-      };
-    },
-    actions: [({
-      event
-    }, {
-      draggingEntireBlocks,
-      draggedBlocks,
-      dragOrigin,
-      originEvent
-    }) => [...draggingEntireBlocks ? draggedBlocks.map((block) => behavior_core.raise({
-      type: "delete.block",
-      at: block.path
-    })) : [behavior_core.raise({
-      type: "delete",
-      selection: dragOrigin.selection
-    })], behavior_core.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.
-   */
-  behavior_core.defineBehavior({
-    on: "deserialization.success",
-    guard: ({
-      snapshot,
+    }),
+    "emit mutation event": xstate.emit(({
       event
+    }) => (xstate.assertEvent(event, "mutation"), event)),
+    "emit read only": xstate.emit({
+      type: "read only"
+    }),
+    "emit editable": xstate.emit({
+      type: "editable"
+    }),
+    "defer event": xstate.assign({
+      pendingEvents: ({
+        context,
+        event
+      }) => (xstate.assertEvent(event, ["internal.patch", "mutation"]), [...context.pendingEvents, event])
+    }),
+    "emit pending events": xstate.enqueueActions(({
+      context,
+      enqueue
     }) => {
-      if (selector_isOverlappingSelection.getFocusTextBlock(snapshot) && event.mimeType === "text/plain" && event.originEvent.type === "clipboard.paste") {
-        const activeDecorators = snapshot.context.activeDecorators;
-        return {
-          activeAnnotations: selector_isSelectingEntireBlocks.getActiveAnnotations(snapshot),
-          activeDecorators,
-          textRuns: event.data.flatMap((block) => parseBlocks.isTextBlock(snapshot.context.schema, block) ? [util_sliceBlocks.getTextBlockText(block)] : [])
-        };
-      }
-      return !1;
+      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": xstate.emit({
+      type: "ready"
+    }),
+    "clear pending events": xstate.assign({
+      pendingEvents: []
+    }),
+    "handle behavior event": ({
+      context,
+      event,
+      self
+    }) => {
+      xstate.assertEvent(event, ["behavior event"]), performEvent({
+        behaviors: [...context.behaviors.values(), ...defaultBehaviors],
+        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,
+        defaultActionCallback: event.type === "behavior event" ? event.defaultActionCallback : void 0
+      });
+    }
+  }
+}).createMachine({
+  id: "editor",
+  context: ({
+    input
+  }) => ({
+    behaviors: /* @__PURE__ */ new Set([...input.behaviors ?? behavior_core.coreBehaviors]),
+    converters: new Set(input.converters ?? []),
+    keyGenerator: input.keyGenerator,
+    pendingEvents: [],
+    schema: input.schema,
+    selection: null,
+    initialReadOnly: input.readOnly ?? !1,
+    maxBlocks: input.maxBlocks,
+    value: input.value
+  }),
+  on: {
+    "notify.blurred": {
+      actions: xstate.emit(({
+        event
+      }) => ({
+        ...event,
+        type: "blurred"
+      }))
+    },
+    "notify.done loading": {
+      actions: xstate.emit({
+        type: "done loading"
+      })
+    },
+    "notify.error": {
+      actions: xstate.emit(({
+        event
+      }) => ({
+        ...event,
+        type: "error"
+      }))
+    },
+    "notify.invalid value": {
+      actions: xstate.emit(({
+        event
+      }) => ({
+        ...event,
+        type: "invalid value"
+      }))
+    },
+    "notify.focused": {
+      actions: xstate.emit(({
+        event
+      }) => ({
+        ...event,
+        type: "focused"
+      }))
     },
-    actions: [(_, {
-      activeAnnotations,
-      activeDecorators,
-      textRuns
-    }) => textRuns.flatMap((textRun, index) => index !== textRuns.length - 1 ? [behavior_core.raise({
-      type: "insert.span",
-      text: textRun,
-      decorators: activeDecorators,
-      annotations: activeAnnotations.map(({
-        _key,
-        _type,
-        ...value
+    "notify.selection": {
+      actions: [xstate.assign({
+        selection: ({
+          event
+        }) => event.selection
+      }), xstate.emit(({
+        event
       }) => ({
-        name: _type,
-        value
+        ...event,
+        type: "selection"
+      }))]
+    },
+    "notify.unset": {
+      actions: xstate.emit(({
+        event
+      }) => ({
+        ...event,
+        type: "unset"
       }))
-    }), behavior_core.raise({
-      type: "insert.break"
-    })] : [behavior_core.raise({
-      type: "insert.span",
-      text: textRun,
-      decorators: activeDecorators,
-      annotations: activeAnnotations.map(({
-        _key,
-        _type,
-        ...value
+    },
+    "notify.loading": {
+      actions: xstate.emit({
+        type: "loading"
+      })
+    },
+    "notify.value changed": {
+      actions: xstate.emit(({
+        event
       }) => ({
-        name: _type,
-        value
+        ...event,
+        type: "value changed"
       }))
-    })])]
-  }),
-  behavior_core.defineBehavior({
-    on: "deserialization.success",
-    actions: [({
-      event
-    }) => [behavior_core.raise({
-      type: "insert.blocks",
-      blocks: event.data,
-      placement: "auto"
-    })]]
-  }),
-  behavior_core.defineBehavior({
-    on: "deserialization.failure",
-    actions: [({
-      event
-    }) => [{
-      type: "effect",
-      effect: () => {
-        console.warn(`Deserialization of ${event.mimeType} failed with reason "${event.reason}"`);
-      }
-    }]]
-  }),
-  behavior_core.defineBehavior({
-    on: "clipboard.paste",
-    guard: ({
-      snapshot
-    }) => snapshot.context.selection && selector_isOverlappingSelection.isSelectionExpanded(snapshot) ? {
-      selection: snapshot.context.selection
-    } : !1,
-    actions: [({
-      event
-    }, {
-      selection
-    }) => [behavior_core.raise({
-      type: "delete",
-      selection
-    }), behavior_core.raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  behavior_core.defineBehavior({
-    on: "clipboard.paste",
-    actions: [({
-      event
-    }) => [behavior_core.raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  behavior_core.defineBehavior({
-    on: "input.*",
-    actions: [({
-      event
-    }) => [behavior_core.raise({
-      type: "deserialize",
-      originEvent: event
-    })]]
-  }),
-  ...abstractAnnotationBehaviors,
-  ...abstractDecoratorBehaviors,
-  ...abstractInsertBehaviors,
-  ...abstractListItemBehaviors,
-  ...abstractMoveBehaviors,
-  ...abstractStyleBehaviors,
-  ...abstractSelectBehaviors,
-  raiseDeserializationSuccessOrFailure,
-  raiseSerializationSuccessOrFailure,
-  raiseInsertSoftBreak
-], abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "style.add", "style.remove", "style.toggle"];
-function isAbstractBehaviorEvent(event) {
-  return abstractBehaviorEventTypes.includes(event.type);
-}
-const nativeBehaviorEventTypes = ["clipboard.copy", "clipboard.cut", "clipboard.paste", "drag.dragstart", "drag.drag", "drag.dragend", "drag.dragenter", "drag.dragover", "drag.dragleave", "drag.drop", "input.*", "keyboard.keydown", "keyboard.keyup", "mouse.click"];
-function isNativeBehaviorEvent(event) {
-  return nativeBehaviorEventTypes.includes(event.type);
-}
-function isCustomBehaviorEvent(event) {
-  return event.type.startsWith("custom.");
-}
-const debug$2 = debugWithName("behaviors:event");
-function eventCategory(event) {
-  return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "abstract" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
-}
-function performEvent({
-  behaviors,
-  event,
-  editor,
-  keyGenerator,
-  schema: schema2,
-  getSnapshot,
-  nativeEvent,
-  defaultActionCallback
-}) {
-  debug$2(`(${eventCategory(event)})`, JSON.stringify(event, null, 2));
-  const defaultAction = isCustomBehaviorEvent(event) || isNativeBehaviorEvent(event) || isAbstractBehaviorEvent(event) ? void 0 : {
-    ...event,
-    editor
-  }, eventBehaviors = 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 (defaultActionCallback) {
-      withApplyingBehaviorActions(editor, () => {
-        try {
-          defaultActionCallback();
-        } catch (error) {
-          console.error(new Error(`Performing action "${event.type}" failed due to: ${error.message}`));
-        }
-      });
-      return;
+    },
+    "add behavior": {
+      actions: "add behavior to context"
+    },
+    "remove behavior": {
+      actions: "remove behavior from context"
+    },
+    patches: {
+      actions: xstate.emit(({
+        event
+      }) => event)
+    },
+    "update behaviors": {
+      actions: "assign behaviors"
+    },
+    "update key generator": {
+      actions: xstate.assign({
+        keyGenerator: ({
+          event
+        }) => event.keyGenerator
+      })
+    },
+    "update schema": {
+      actions: "assign schema"
+    },
+    "update value": {
+      actions: xstate.assign({
+        value: ({
+          event
+        }) => event.value
+      })
+    },
+    "update maxBlocks": {
+      actions: xstate.assign({
+        maxBlocks: ({
+          event
+        }) => event.maxBlocks
+      })
     }
-    if (!defaultAction)
-      return;
-    withApplyingBehaviorActions(editor, () => {
-      try {
-        performAction({
-          context: {
-            keyGenerator,
-            schema: schema2
+  },
+  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"
+            }
           },
-          action: defaultAction
-        });
-      } catch (error) {
-        console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
+          initial: "idle",
+          states: {
+            idle: {
+              on: {
+                dragstart: {
+                  actions: [xstate.assign({
+                    internalDrag: ({
+                      event
+                    }) => ({
+                      ghost: event.ghost,
+                      origin: event.origin
+                    })
+                  })],
+                  target: "dragging internally"
+                }
+              }
+            },
+            "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}`));
+                  }
+              }, xstate.assign({
+                internalDrag: void 0
+              })],
+              tags: ["dragging internally"],
+              on: {
+                dragend: {
+                  target: "idle"
+                },
+                drop: {
+                  target: "idle"
+                }
+              }
+            }
+          }
+        }
       }
-    }), editor.onChange();
-    return;
-  }
-  const editorSnapshot = getSnapshot();
-  let behaviorOverwritten = !1;
-  for (const eventBehavior of eventBehaviors) {
-    const shouldRun = eventBehavior.guard === void 0 || eventBehavior.guard({
-      context: editorSnapshot.context,
-      snapshot: editorSnapshot,
-      event
-    });
-    if (!shouldRun)
-      continue;
-    const actionSets = eventBehavior.actions.map((actionSet) => actionSet({
-      context: editorSnapshot.context,
-      snapshot: editorSnapshot,
-      event
-    }, shouldRun));
-    for (const actionSet of actionSets)
-      actionSet.length !== 0 && (behaviorOverwritten = behaviorOverwritten || actionSet.some((action) => action.type !== "effect"), withApplyingBehaviorActionSet(editor, () => {
-        for (const action of actionSet) {
-          if (action.type === "raise") {
-            performEvent({
-              behaviors,
-              event: action.event,
-              editor,
-              keyGenerator,
-              schema: schema2,
-              getSnapshot,
-              defaultActionCallback: void 0,
-              nativeEvent: void 0
-            });
-            continue;
+    },
+    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"
+            }
           }
-          const internalAction = {
-            ...action,
-            editor
-          };
-          try {
-            performAction({
-              context: {
-                keyGenerator,
-                schema: schema2
-              },
-              action: internalAction
-            });
-          } catch (error) {
-            console.error(new Error(`Performing action "${internalAction.type}" as a result of "${event.type}" failed due to: ${error.message}`));
-            break;
+        },
+        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"
+            }
           }
         }
-      }), editor.onChange());
-    if (behaviorOverwritten) {
-      nativeEvent?.preventDefault();
-      break;
-    }
-  }
-  if (!behaviorOverwritten) {
-    if (defaultActionCallback) {
-      withApplyingBehaviorActions(editor, () => {
-        try {
-          defaultActionCallback();
-        } catch (error) {
-          console.error(new Error(`Performing "${event.type}" failed due to: ${error.message}`));
-        }
-      });
-      return;
-    }
-    if (!defaultAction)
-      return;
-    withApplyingBehaviorActions(editor, () => {
-      try {
-        performAction({
-          context: {
-            keyGenerator,
-            schema: schema2
-          },
-          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 slateChildrenToBlocks(schema2, value) {
-  const blocks = new Array(value.length);
-  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
-    const descendant = value[blockIndex];
-    if (descendant._type !== schema2.block.name) {
-      blocks[blockIndex] = {
-        _key: descendant._key,
-        _type: descendant._type,
-        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
-      };
-      continue;
-    }
-    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-      const child = children[childIndex];
-      processedChildren[childIndex] = child._type === schema2.span.name ? child : {
-        _key: child._key,
-        _type: child._type,
-        ..."value" in child && typeof child.value == "object" ? child.value : {}
-      };
     }
-    blocks[blockIndex] = {
-      ...descendant,
-      children: processedChildren
-    };
   }
-  return blocks;
-}
-function getActiveDecorators({
-  schema: schema2,
-  slateEditorInstance
-}) {
-  const decorators = schema2.decorators.map((decorator) => decorator.value);
-  return ({
-    ...slate.Editor.marks(slateEditorInstance) ?? {}
-  }.marks ?? []).filter((mark) => decorators.includes(mark));
+});
+function defaultCompare(a, b) {
+  return a === b;
 }
-function createEditorSnapshot({
-  converters,
-  editor,
-  keyGenerator,
-  readOnly,
-  schema: schema2,
-  hasTag,
-  internalDrag
+function useEditorSelector(editor, selector, t0) {
+  const $ = reactCompilerRuntime.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], react.useSelector(editor._internal.editorActor, t1, compare);
+}
+function getEditorSnapshot({
+  editorActorSnapshot,
+  slateEditorInstance
 }) {
-  const value = slateChildrenToBlocks(schema2, editor.children), selection = editor.selection ? slateRangeToSelection({
-    schema: schema2,
-    editor,
-    range: editor.selection
-  }) : null;
   return {
     context: {
+      converters: [...editorActorSnapshot.context.converters],
       activeDecorators: getActiveDecorators({
-        schema: schema2,
-        slateEditorInstance: editor
+        schema: editorActorSnapshot.context.schema,
+        slateEditorInstance
       }),
-      converters,
-      keyGenerator,
-      readOnly,
-      schema: schema2,
-      selection,
-      value
+      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,
-      internalDrag
+      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
+      internalDrag: editorActorSnapshot.context.internalDrag
     }
   };
 }
-const editorMachine = xstate.setup({
-  types: {
-    context: {},
-    events: {},
-    emitted: {},
-    input: {},
-    tags: {}
-  },
-  actions: {
-    "add behavior to context": xstate.assign({
-      behaviors: ({
-        context,
-        event
-      }) => (xstate.assertEvent(event, "add behavior"), /* @__PURE__ */ new Set([...context.behaviors, event.behavior]))
-    }),
-    "remove behavior from context": xstate.assign({
-      behaviors: ({
-        context,
-        event
-      }) => (xstate.assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
-    }),
-    "assign behaviors": xstate.assign({
-      behaviors: ({
-        event
-      }) => (xstate.assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...event.behaviors]))
-    }),
-    "assign schema": xstate.assign({
-      schema: ({
-        event
-      }) => (xstate.assertEvent(event, "update schema"), event.schema)
-    }),
-    "emit patch event": xstate.enqueueActions(({
-      event,
-      enqueue
-    }) => {
-      xstate.assertEvent(event, "internal.patch"), enqueue.emit(event), enqueue.emit({
-        type: "patch",
-        patch: event.patch
-      });
-    }),
-    "emit mutation event": xstate.emit(({
-      event
-    }) => (xstate.assertEvent(event, "mutation"), event)),
-    "emit read only": xstate.emit({
-      type: "read only"
-    }),
-    "emit editable": xstate.emit({
-      type: "editable"
-    }),
-    "defer event": xstate.assign({
-      pendingEvents: ({
-        context,
-        event
-      }) => (xstate.assertEvent(event, ["internal.patch", "mutation"]), [...context.pendingEvents, event])
-    }),
-    "emit pending events": xstate.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": xstate.emit({
-      type: "ready"
-    }),
-    "clear pending events": xstate.assign({
-      pendingEvents: []
-    }),
-    "handle behavior event": ({
-      context,
-      event,
-      self
-    }) => {
-      xstate.assertEvent(event, ["behavior event"]), performEvent({
-        behaviors: [...context.behaviors.values(), ...defaultBehaviors],
-        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,
-        defaultActionCallback: event.type === "behavior event" ? event.defaultActionCallback : void 0
+const debug$2 = debugWithName("API:editable");
+function createEditableAPI(editor, editorActor) {
+  const types2 = editorActor.getSnapshot().context.schema;
+  return {
+    focus: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "focus"
+        },
+        editor
       });
-    }
-  }
-}).createMachine({
-  id: "editor",
-  context: ({
-    input
-  }) => ({
-    behaviors: /* @__PURE__ */ new Set([...input.behaviors ?? behavior_core.coreBehaviors]),
-    converters: new Set(input.converters ?? []),
-    keyGenerator: input.keyGenerator,
-    pendingEvents: [],
-    schema: input.schema,
-    selection: null,
-    initialReadOnly: input.readOnly ?? !1,
-    maxBlocks: input.maxBlocks,
-    value: input.value
-  }),
-  on: {
-    "notify.blurred": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "blurred"
-      }))
-    },
-    "notify.done loading": {
-      actions: xstate.emit({
-        type: "done loading"
-      })
-    },
-    "notify.error": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "error"
-      }))
-    },
-    "notify.invalid value": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "invalid value"
-      }))
-    },
-    "notify.focused": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "focused"
-      }))
-    },
-    "notify.selection": {
-      actions: [xstate.assign({
-        selection: ({
-          event
-        }) => event.selection
-      }), xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "selection"
-      }))]
     },
-    "notify.unset": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "unset"
-      }))
+    blur: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "blur"
+        },
+        editor
+      });
     },
-    "notify.loading": {
-      actions: xstate.emit({
-        type: "loading"
-      })
+    toggleMark: (mark) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "decorator.toggle",
+          decorator: mark
+        },
+        editor
+      });
     },
-    "notify.value changed": {
-      actions: xstate.emit(({
-        event
-      }) => ({
-        ...event,
-        type: "value changed"
-      }))
+    toggleList: (listItem) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "list item.toggle",
+          listItem
+        },
+        editor
+      });
     },
-    "add behavior": {
-      actions: "add behavior to context"
+    toggleBlockStyle: (style) => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "style.toggle",
+          style
+        },
+        editor
+      });
     },
-    "remove behavior": {
-      actions: "remove behavior from context"
+    isMarkActive: (mark) => {
+      try {
+        return isDecoratorActive({
+          editor,
+          decorator: mark
+        });
+      } catch (err) {
+        return console.warn(err), !1;
+      }
     },
-    patches: {
-      actions: xstate.emit(({
-        event
-      }) => event)
+    marks: () => ({
+      ...slate.Editor.marks(editor) || {}
+    }).marks || [],
+    undo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.undo"
+        },
+        editor
+      });
     },
-    "update behaviors": {
-      actions: "assign behaviors"
+    redo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.redo"
+        },
+        editor
+      });
     },
-    "update key generator": {
-      actions: xstate.assign({
-        keyGenerator: ({
-          event
-        }) => event.keyGenerator
-      })
+    select: (selection) => {
+      const slateSelection = toSlateRange(selection, editor);
+      slateSelection ? slate.Transforms.select(editor, slateSelection) : slate.Transforms.deselect(editor), editor.onChange();
     },
-    "update schema": {
-      actions: "assign schema"
+    focusBlock: () => {
+      if (editor.selection) {
+        const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+        if (block)
+          return fromSlateValue([block], types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
+      }
     },
-    "update value": {
-      actions: xstate.assign({
-        value: ({
-          event
-        }) => event.value
-      })
+    focusChild: () => {
+      if (editor.selection) {
+        const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+        if (block && editor.isTextBlock(block))
+          return fromSlateValue([block], types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0].children[editor.selection.focus.path[1]];
+      }
     },
-    "update maxBlocks": {
-      actions: xstate.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"
+    insertChild: (type, value) => {
+      if (type.name !== types2.span.name)
+        return editorActor.send({
+          type: "behavior event",
+          behaviorEvent: {
+            type: "insert.inline object",
+            inlineObject: {
+              name: type.name,
+              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"
-                }]
-              }
-            },
-            "read only": {
-              on: {
-                "update readOnly": {
-                  guard: ({
-                    event
-                  }) => !event.readOnly,
-                  target: "#editor.edit mode.editable",
-                  actions: ["emit editable"]
-                }
-              }
-            }
-          }
+          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(slate.Editor.nodes(editor, {
+        at: editor.selection.focus.path.slice(0, 1),
+        match: (n) => n._type === types2.block.name
+      }))[0] || [void 0];
+      if (!focusBlock)
+        throw new Error("No focused text block");
+      if (type.name !== types2.span.name && !types2.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: types2.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 === types2.span.name, focusNode = slate.Node.get(editor, focusChildPath);
+      return isSpanNode && focusNode._type !== types2.span.name && (debug$2("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+        distance: 1,
+        unit: "character"
+      })), slate.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 || {}
         },
-        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"
-            }
-          },
-          initial: "idle",
-          states: {
-            idle: {
-              on: {
-                dragstart: {
-                  actions: [xstate.assign({
-                    internalDrag: ({
-                      event
-                    }) => ({
-                      ghost: event.ghost,
-                      origin: event.origin
-                    })
-                  })],
-                  target: "dragging internally"
-                }
-              }
-            },
-            "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}`));
-                  }
-              }, xstate.assign({
-                internalDrag: void 0
-              })],
-              tags: ["dragging internally"],
-              on: {
-                dragend: {
-                  target: "idle"
-                },
-                drop: {
-                  target: "idle"
-                }
-              }
-            }
+        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;
+      }
+    },
+    hasListStyle: (listItem) => {
+      try {
+        return isListItemActive({
+          editor,
+          listItem
+        });
+      } catch {
+        return !1;
+      }
+    },
+    isVoid: (element) => ![types2.block.name, types2.span.name].includes(element._type),
+    findByPath: (path) => {
+      const slatePath = toSlateRange({
+        focus: {
+          path,
+          offset: 0
+        },
+        anchor: {
+          path,
+          offset: 0
+        }
+      }, editor);
+      if (slatePath) {
+        const [block, blockPath] = slate.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], types2.block.name)[0], [{
+              _key: block._key
+            }]];
+          const ptBlock = fromSlateValue([block], types2.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];
     },
-    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"
-                }
-              }
+    findDOMNode: (element) => {
+      let node;
+      try {
+        const [item] = Array.from(slate.Editor.nodes(editor, {
+          at: [],
+          match: (n) => n._key === element._key
+        }) || [])[0] || [void 0];
+        node = slateReact.ReactEditor.toDOMNode(editor, item);
+      } catch {
+      }
+      return node;
+    },
+    activeAnnotations: () => {
+      if (!editor.selection || editor.selection.focus.path.length < 2)
+        return [];
+      try {
+        const activeAnnotations = [], spans = slate.Editor.nodes(editor, {
+          at: editor.selection,
+          match: (node) => slate.Text.isText(node) && node.marks !== void 0 && Array.isArray(node.marks) && node.marks.length > 0
+        });
+        for (const [span, path] of spans) {
+          const [block] = slate.Editor.node(editor, path, {
+            depth: 1
+          });
+          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
+            slate.Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
+          });
+        }
+        return activeAnnotations;
+      } catch {
+        return [];
+      }
+    },
+    isAnnotationActive: (annotationType) => isAnnotationActive({
+      editor,
+      annotation: {
+        name: annotationType
+      }
+    }),
+    addAnnotation: (type, value) => {
+      let paths;
+      return slate.Editor.withoutNormalizing(editor, () => {
+        paths = addAnnotationActionImplementation({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: types2
+          },
+          action: {
+            annotation: {
+              name: type.name,
+              value: value ?? {}
             },
-            normalizing: {
-              on: {
-                "done normalizing": {
-                  target: "idle"
-                },
-                "internal.patch": {
-                  actions: "defer event"
-                },
-                mutation: {
-                  actions: "defer event"
-                }
-              }
-            }
+            editor
           }
-        },
-        dirty: {
-          entry: ["emit pending events", "clear pending events"],
-          on: {
-            "internal.patch": {
-              actions: "emit patch event"
-            },
-            mutation: {
-              actions: "emit mutation event"
-            }
+        });
+      }), 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"), slate.Transforms.delete(editor, {
+              at: range,
+              hanging: !0,
+              voids: !0
+            }), editor.onChange();
+            return;
           }
+          options?.mode === "blocks" && (debug$2("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
+            at: range,
+            voids: !0,
+            match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && slate.Element.isElement(node)
+          })), options?.mode === "children" && (debug$2("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
+            at: range,
+            voids: !0,
+            match: (node) => node._type === types2.span.name || // Text children
+            !editor.isTextBlock(node) && slate.Element.isElement(node)
+          })), editor.children.length === 0 && (editor.children = [editor.pteCreateTextBlock({
+            decorators: []
+          })]), editor.onChange();
         }
       }
-    }
-  }
-});
-function defaultCompare(a, b) {
-  return a === b;
-}
-function useEditorSelector(editor, selector, t0) {
-  const $ = reactCompilerRuntime.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], react.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
+    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, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+    isCollapsedSelection: () => !!editor.selection && slate.Range.isCollapsed(editor.selection),
+    isExpandedSelection: () => !!editor.selection && slate.Range.isExpanded(editor.selection),
+    insertBreak: () => {
+      editor.insertBreak(), editor.onChange();
+    },
+    getFragment: () => fromSlateValue(editor.getFragment(), types2.block.name),
+    isSelectionsOverlapping: (selectionA, selectionB) => {
+      const rangeA = toSlateRange(selectionA, editor), rangeB = toSlateRange(selectionB, editor);
+      return slate.Range.isRange(rangeA) && slate.Range.isRange(rangeB) && slate.Range.includes(rangeA, rangeB);
     }
   };
 }
+function isAnnotationActive({
+  editor,
+  annotation
+}) {
+  if (!editor.selection || editor.selection.focus.path.length < 2)
+    return !1;
+  try {
+    const spans = [...slate.Editor.nodes(editor, {
+      at: editor.selection,
+      match: (node) => slate.Text.isText(node)
+    })];
+    if (spans.length === 0 || spans.some(([span]) => !types.isPortableTextSpan(span) || !span.marks || span.marks?.length === 0)) return !1;
+    const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
+      const [block] = slate.Editor.node(editor, path, {
+        depth: 1
+      });
+      return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
+    }, []);
+    return spans.every(([span]) => types.isPortableTextSpan(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
+  } catch {
+    return !1;
+  }
+}
 function createInternalEditor(config) {
   const editorActor = xstate.createActor(editorMachine, {
     input: editorConfigToMachineInput(config)
@@ -6999,7 +7036,12 @@ function createInternalEditorFromActor(editorActor) {
     }
   };
 }
-const PortableTextEditorSelectionContext = React.createContext(null), usePortableTextEditorSelection = () => {
+const EditorActorContext = React.createContext({}), PortableTextEditorContext = React.createContext(null), usePortableTextEditor = () => {
+  const editor = React.useContext(PortableTextEditorContext);
+  if (!editor)
+    throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
+  return editor;
+}, PortableTextEditorSelectionContext = React.createContext(null), usePortableTextEditorSelection = () => {
   const selection = React.useContext(PortableTextEditorSelectionContext);
   if (selection === void 0)
     throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");