@portabletext/editor 1.31.2 → 1.33.0

package/lib/_chunks-cjs/plugin.event-listener.cjs

@@ -1,9 +1,9 @@
 "use strict";
-var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), jsxRuntime = require("react/jsx-runtime"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$e = require("debug"), slate = require("slate"), xstate = require("xstate"), isEqual = require("lodash/isEqual.js"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), parseBlocks = require("./parse-blocks.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), startCase = require("lodash.startcase"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), util_reverseSelection = require("./util.reverse-selection.cjs"), behavior_core = require("./behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), rxjs = require("rxjs");
+var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), jsxRuntime = require("react/jsx-runtime"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$e = require("debug"), slate = require("slate"), xstate = require("xstate"), isEqual = require("lodash/isEqual.js"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), getRandomValues = require("get-random-values-esm"), util_blockOffsetsToSelection = require("./util.block-offsets-to-selection.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), util_reverseSelection = require("./util.reverse-selection.cjs"), selector_getTrimmedSelection = require("./selector.get-trimmed-selection.cjs"), startCase = require("lodash.startcase"), behavior_core = require("./behavior.core.cjs"), rxjs = require("rxjs");
 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$e), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
+var React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$e), 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), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase);
 function createEditorSchema(portableTextType) {
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
@@ -1391,6 +1391,43 @@ function isRedoing(editor) {
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
+const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
+  let table;
+  return () => {
+    if (table)
+      return table;
+    table = [];
+    for (let i = 0; i < 256; ++i)
+      table[i] = (i + 256).toString(16).slice(1);
+    return table;
+  };
+})();
+function whatwgRNG(length = 16) {
+  const rnds8 = new Uint8Array(length);
+  return getRandomValues__default.default(rnds8), rnds8;
+}
+function randomKey(length) {
+  const table = getByteHexTable();
+  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+}
+const IS_APPLYING_BEHAVIOR_ACTIONS = /* @__PURE__ */ new WeakMap();
+function withApplyingBehaviorActions(editor, fn) {
+  const prev = IS_APPLYING_BEHAVIOR_ACTIONS.get(editor);
+  IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, !0), slate.Editor.withoutNormalizing(editor, fn), IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, prev);
+}
+function isApplyingBehaviorActions(editor) {
+  return IS_APPLYING_BEHAVIOR_ACTIONS.get(editor) ?? !1;
+}
+const CURRENT_BEHAVIOR_ACTION_INTEND_SET = /* @__PURE__ */ new WeakMap();
+function withApplyingBehaviorActionIntendSet(editor, fn) {
+  const current = CURRENT_BEHAVIOR_ACTION_INTEND_SET.get(editor);
+  CURRENT_BEHAVIOR_ACTION_INTEND_SET.set(editor, {
+    actionSetId: defaultKeyGenerator()
+  }), withApplyingBehaviorActions(editor, fn), CURRENT_BEHAVIOR_ACTION_INTEND_SET.set(editor, current);
+}
+function getCurrentBehaviorActionSetId(editor) {
+  return CURRENT_BEHAVIOR_ACTION_INTEND_SET.get(editor)?.actionSetId;
+}
 const debug$d = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
   return state === void 0 ? !0 : state;
@@ -1403,6 +1440,7 @@ function createWithUndoRedo(options) {
   return (editor) => {
     let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
     const remotePatches = getRemotePatches(editor);
+    let previousBehaviorActionIntendSetId = getCurrentBehaviorActionSetId(editor);
     options.subscriptions.push(() => {
       debug$d("Subscribing to patches");
       const sub = editorActor.on("patches", ({
@@ -1458,10 +1496,10 @@ function createWithUndoRedo(options) {
         history
       } = editor, {
         undos
-      } = history, step = undos[undos.length - 1], lastOp = step && step.operations && step.operations[step.operations.length - 1], overwrite = shouldOverwrite(op, lastOp), save = isSaving(editor);
-      let merge = !0;
+      } = history, step = undos[undos.length - 1], lastOp = step && step.operations && step.operations[step.operations.length - 1], overwrite = shouldOverwrite(op, lastOp), save = isSaving(editor), currentBehaviorActionIntendSetId = getCurrentBehaviorActionSetId(editor);
+      let merge = currentBehaviorActionIntendSetId !== void 0 && previousBehaviorActionIntendSetId === void 0 ? !1 : currentBehaviorActionIntendSetId !== void 0 && previousBehaviorActionIntendSetId !== void 0 ? currentBehaviorActionIntendSetId === previousBehaviorActionIntendSetId : !0;
       if (save) {
-        if (step ? operations.length === 0 && (merge = shouldMerge(op, lastOp) || overwrite) : merge = !1, step && merge)
+        if (step ? operations.length === 0 && (merge = currentBehaviorActionIntendSetId === void 0 && previousBehaviorActionIntendSetId === void 0 ? shouldMerge(op, lastOp) || overwrite : merge) : merge = !1, step && merge)
           step.operations.push(op);
         else {
           const newStep = {
@@ -1474,83 +1512,80 @@ function createWithUndoRedo(options) {
           undos.shift();
         shouldClear(op) && (history.redos = []);
       }
-      apply2(op);
-    }, editor.undo = () => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      }))
-        return;
-      const {
-        undos
-      } = editor.history;
-      if (undos.length > 0) {
-        const step = undos[undos.length - 1];
-        if (debug$d("Undoing", step), step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
-          let transformedOperations = step.operations;
-          otherPatches.forEach((item) => {
-            transformedOperations = flatten__default.default(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
-          });
-          const reversedOperations = transformedOperations.map(slate.Operation.inverse).reverse();
-          try {
-            slate.Editor.withoutNormalizing(editor, () => {
-              withUndoing(editor, () => {
-                withoutSaving(editor, () => {
-                  reversedOperations.forEach((op) => {
-                    editor.apply(op);
-                  });
-                });
+      previousBehaviorActionIntendSetId = currentBehaviorActionIntendSetId, apply2(op);
+    }, editor;
+  };
+}
+const historyUndoActionImplementation = ({
+  action
+}) => {
+  const editor = action.editor, {
+    undos
+  } = editor.history, remotePatches = getRemotePatches(editor);
+  if (undos.length > 0) {
+    const step = undos[undos.length - 1];
+    if (debug$d("Undoing", step), step.operations.length > 0) {
+      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+      let transformedOperations = step.operations;
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten__default.default(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
+      });
+      const reversedOperations = transformedOperations.map(slate.Operation.inverse).reverse();
+      try {
+        slate.Editor.withoutNormalizing(editor, () => {
+          withUndoing(editor, () => {
+            withoutSaving(editor, () => {
+              reversedOperations.forEach((op) => {
+                editor.apply(op);
               });
-            }), editor.normalize(), editor.onChange();
-          } catch (err) {
-            debug$d("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
-              undos: [],
-              redos: []
-            }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
-            return;
-          }
-          editor.history.redos.push(step), editor.history.undos.pop();
-        }
-      }
-    }, editor.redo = () => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      }))
-        return;
-      const {
-        redos
-      } = editor.history;
-      if (redos.length > 0) {
-        const step = redos[redos.length - 1];
-        if (debug$d("Redoing", step), step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
-          let transformedOperations = step.operations;
-          otherPatches.forEach((item) => {
-            transformedOperations = flatten__default.default(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
+            });
           });
-          try {
-            slate.Editor.withoutNormalizing(editor, () => {
-              withRedoing(editor, () => {
-                withoutSaving(editor, () => {
-                  transformedOperations.forEach((op) => {
-                    editor.apply(op);
-                  });
-                });
+        });
+      } catch (err) {
+        debug$d("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+          undos: [],
+          redos: []
+        }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
+        return;
+      }
+      editor.history.redos.push(step), editor.history.undos.pop();
+    }
+  }
+}, historyRedoActionImplementation = ({
+  action
+}) => {
+  const editor = action.editor, {
+    redos
+  } = editor.history, remotePatches = getRemotePatches(editor);
+  if (redos.length > 0) {
+    const step = redos[redos.length - 1];
+    if (debug$d("Redoing", step), step.operations.length > 0) {
+      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+      let transformedOperations = step.operations;
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten__default.default(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
+      });
+      try {
+        slate.Editor.withoutNormalizing(editor, () => {
+          withRedoing(editor, () => {
+            withoutSaving(editor, () => {
+              transformedOperations.forEach((op) => {
+                editor.apply(op);
               });
-            }), editor.normalize(), editor.onChange();
-          } catch (err) {
-            debug$d("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
-              undos: [],
-              redos: []
-            }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
-            return;
-          }
-          editor.history.undos.push(step), editor.history.redos.pop();
-        }
+            });
+          });
+        });
+      } catch (err) {
+        debug$d("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+          undos: [],
+          redos: []
+        }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
+        return;
       }
-    }, editor;
-  };
-}
+      editor.history.undos.push(step), editor.history.redos.pop();
+    }
+  }
+};
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
   const transformedOperation = {
     ...operation
@@ -2291,7 +2326,7 @@ const converterJson = {
         reason: "Data is not an array"
       };
     const parsedBlocks = blocks.flatMap((block) => {
-      const parsedBlock = parseBlocks.parseBlock({
+      const parsedBlock = util_blockOffsetsToSelection.parseBlock({
         context,
         block,
         options: {
@@ -2693,265 +2728,393 @@ const insertBreakActionImplementation = ({
 }) => {
   slate.insertText(action.editor, `
 `);
-}, IS_APPLYING_BEHAVIOR_ACTIONS = /* @__PURE__ */ new WeakMap();
-function withApplyingBehaviorActions(editor, fn) {
-  const prev = isApplyingBehaviorActions(editor);
-  IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, !0), fn(), IS_APPLYING_BEHAVIOR_ACTIONS.set(editor, prev);
-}
-function isApplyingBehaviorActions(editor) {
-  return IS_APPLYING_BEHAVIOR_ACTIONS.get(editor) ?? !1;
+}, toggleListItemActionImplementation = ({
+  context,
+  action
+}) => {
+  isListItemActive({
+    editor: action.editor,
+    listItem: action.listItem
+  }) ? removeListItemActionImplementation({
+    context,
+    action: {
+      ...action,
+      type: "list item.remove"
+    }
+  }) : addListItemActionImplementation({
+    context,
+    action: {
+      ...action,
+      type: "list item.add"
+    }
+  });
+}, removeListItemActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection)
+    return;
+  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
+    at: action.editor.selection,
+    match: (node) => guards.isListBlock(node)
+  })];
+  for (const [, at] of selectedBlocks)
+    slate.Transforms.unsetNodes(action.editor, ["listItem", "level"], {
+      at
+    });
+}, addListItemActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection)
+    return;
+  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
+    at: action.editor.selection,
+    match: (node) => guards.isTextBlock(node)
+  })];
+  for (const [, at] of selectedBlocks)
+    slate.Transforms.setNodes(action.editor, {
+      level: 1,
+      listItem: action.listItem
+    }, {
+      at
+    });
+};
+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 createWithEventListeners(editorActor, subscriptions) {
-  return function(editor) {
-    if (editorActor.getSnapshot().context.maxBlocks !== void 0)
-      return editor;
-    subscriptions.push(() => {
-      const subscription = editorActor.on("*", (event) => {
-        switch (event.type) {
-          // These events are not relevant for Behaviors
-          case "blurred":
-          case "done loading":
-          case "editable":
-          case "error":
-          case "focused":
-          case "invalid value":
-          case "loading":
-          case "mutation":
-          case "patch":
-          case "patches":
-          case "read only":
-          case "ready":
-          case "selection":
-          case "value changed":
-          case "unset":
-            break;
-          case "custom.*":
-            editorActor.send({
-              type: "custom behavior event",
-              behaviorEvent: event.event,
-              editor
-            });
-            break;
-          default:
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: event,
-              editor
-            });
-            break;
-        }
-      });
-      return () => {
-        subscription.unsubscribe();
-      };
+const toggleStyleActionImplementation = ({
+  context,
+  action
+}) => {
+  isStyleActive({
+    editor: action.editor,
+    style: action.style
+  }) ? removeStyleActionImplementation({
+    context,
+    action: {
+      ...action,
+      type: "style.remove"
+    }
+  }) : addStyleActionImplementation({
+    context,
+    action: {
+      ...action,
+      type: "style.add"
+    }
+  });
+}, removeStyleActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection)
+    return;
+  const defaultStyle = context.schema.styles[0].value, guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
+    at: action.editor.selection,
+    match: (node) => guards.isTextBlock(node)
+  })];
+  for (const [, at] of selectedBlocks)
+    slate.Transforms.setNodes(action.editor, {
+      style: defaultStyle
+    }, {
+      at
     });
-    const {
-      deleteBackward,
-      deleteForward,
-      insertBreak,
-      insertData,
-      insertText,
-      select,
-      setFragmentData
-    } = editor;
-    return editor.deleteBackward = (unit) => {
-      if (isApplyingBehaviorActions(editor)) {
-        deleteBackward(unit);
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "delete.backward",
-          unit
-        },
-        editor
-      });
-    }, editor.deleteForward = (unit) => {
-      if (isApplyingBehaviorActions(editor)) {
-        deleteForward(unit);
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "delete.forward",
-          unit
-        },
-        editor
-      });
-    }, editor.insertBreak = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertBreak();
-        return;
+}, addStyleActionImplementation = ({
+  context,
+  action
+}) => {
+  if (!action.editor.selection)
+    return;
+  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
+    at: action.editor.selection,
+    match: (node) => guards.isTextBlock(node)
+  })];
+  for (const [, at] of selectedBlocks)
+    slate.Transforms.setNodes(action.editor, {
+      style: action.style
+    }, {
+      at
+    });
+};
+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 isPortableTextSpan(node) {
+  return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
+}
+function isPortableTextBlock(node) {
+  return (
+    // A block doesn't _have_ to be named 'block' - to differentiate between
+    // allowed child types and marks, one might name them differently
+    typeof node._type == "string" && // Toolkit-types like nested spans are @-prefixed
+    node._type[0] !== "@" && // `markDefs` isn't _required_ per say, but if it's there, it needs to be an array
+    (!("markDefs" in node) || !node.markDefs || Array.isArray(node.markDefs) && // Every mark definition needs to have an `_key` to be mappable in child spans
+    node.markDefs.every((def) => typeof def._key == "string")) && // `children` is required and needs to be an array
+    "children" in node && Array.isArray(node.children) && // All children are objects with `_type` (usually spans, but can contain other stuff)
+    node.children.every((child) => typeof child == "object" && "_type" in child)
+  );
+}
+const decoratorAddActionImplementation = ({
+  context,
+  action
+}) => {
+  const editor = action.editor, mark = action.decorator, selection = action.selection ? toSlateRange(action.selection, action.editor) ?? editor.selection : editor.selection;
+  if (!selection)
+    return;
+  const value = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editorSelection = toPortableTextRange(value, selection, context.schema), anchorOffset = editorSelection ? util_reverseSelection.spanSelectionPointToBlockOffset({
+    value,
+    selectionPoint: editorSelection.anchor
+  }) : void 0, focusOffset = editorSelection ? util_reverseSelection.spanSelectionPointToBlockOffset({
+    value,
+    selectionPoint: editorSelection.focus
+  }) : void 0;
+  if (!anchorOffset || !focusOffset)
+    throw new Error("Unable to find anchor or focus offset");
+  if (slate.Range.isExpanded(selection)) {
+    slate.Transforms.setNodes(editor, {}, {
+      at: selection,
+      match: slate.Text.isText,
+      split: !0,
+      hanging: !0
+    });
+    const newValue = fromSlateValue(editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), newSelection = util_blockOffsetsToSelection.blockOffsetsToSelection({
+      value: newValue,
+      offsets: {
+        anchor: anchorOffset,
+        focus: focusOffset
+      },
+      backward: editorSelection?.backward
+    }), trimmedSelection = selector_getTrimmedSelection.getTrimmedSelection({
+      context: {
+        activeDecorators: [],
+        converters: [],
+        keyGenerator: context.keyGenerator,
+        schema: context.schema,
+        selection: newSelection,
+        value: newValue
       }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "insert.break"
-        },
-        editor
+    });
+    if (!trimmedSelection)
+      throw new Error("Unable to find trimmed selection");
+    const newRange = toSlateRange(trimmedSelection, editor);
+    if (!newRange)
+      throw new Error("Unable to find new selection");
+    const splitTextNodes = slate.Range.isRange(newRange) ? [...slate.Editor.nodes(editor, {
+      at: newRange,
+      match: (node) => slate.Text.isText(node)
+    })] : [];
+    for (const [node, path] of splitTextNodes) {
+      const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
+      slate.Transforms.setNodes(editor, {
+        marks
+      }, {
+        at: path,
+        match: slate.Text.isText,
+        split: !0,
+        hanging: !0
       });
-    }, editor.insertData = (dataTransfer) => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertData(dataTransfer);
-        return;
-      }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "deserialize",
-          dataTransfer
-        },
-        editor
+    }
+  } else {
+    const [block, blockPath] = slate.Editor.node(editor, selection, {
+      depth: 1
+    }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+    if (lonelyEmptySpan) {
+      const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
+      slate.Transforms.setNodes(editor, {
+        marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
+      }, {
+        at: blockPath,
+        match: (node) => editor.isTextSpan(node)
       });
-    }, editor.insertSoftBreak = () => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertSoftBreakActionImplementation({
-          context: {
-            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
-            schema: editorActor.getSnapshot().context.schema
-          },
-          action: {
-            type: "insert.soft break",
-            editor
+    } else {
+      const existingMarks = {
+        ...slate.Editor.marks(editor) || {}
+      }.marks || [], marks = {
+        ...slate.Editor.marks(editor) || {},
+        marks: [...existingMarks, mark]
+      };
+      editor.marks = marks;
+    }
+  }
+  if (editor.selection) {
+    const selection2 = editor.selection;
+    editor.selection = {
+      ...selection2
+    };
+  }
+};
+function getPreviousSpan({
+  editor,
+  blockPath,
+  spanPath
+}) {
+  let previousSpan;
+  for (const [child, childPath] of slate.Node.children(editor, blockPath, {
+    reverse: !0
+  }))
+    if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, spanPath)) {
+      previousSpan = child;
+      break;
+    }
+  return previousSpan;
+}
+function getNextSpan({
+  editor,
+  blockPath,
+  spanPath
+}) {
+  let nextSpan;
+  for (const [child, childPath] of slate.Node.children(editor, blockPath))
+    if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, spanPath)) {
+      nextSpan = child;
+      break;
+    }
+  return nextSpan;
+}
+const debug$9 = debugWithName("plugin:withPortableTextMarkModel");
+function createWithPortableTextMarkModel(editorActor, types2) {
+  return function(editor) {
+    const {
+      apply: apply2,
+      normalizeNode
+    } = editor, decorators = types2.decorators.map((t) => t.value);
+    return editor.normalizeNode = (nodeEntry) => {
+      const [node, path] = nodeEntry;
+      if (editor.isTextBlock(node)) {
+        const children = slate.Node.children(editor, path);
+        for (const [child, childPath] of children) {
+          const nextNode = node.children[childPath[1] + 1];
+          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
+            debug$9("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+              type: "normalizing"
+            }), slate.Transforms.mergeNodes(editor, {
+              at: [childPath[0], childPath[1] + 1],
+              voids: !0
+            }), editorActor.send({
+              type: "done normalizing"
+            });
+            return;
           }
-        });
-        return;
+        }
       }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "insert.soft break"
-        },
-        editor
-      });
-    }, editor.insertText = (text, options) => {
-      if (isApplyingBehaviorActions(editor)) {
-        insertText(text, options);
+      if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
+        debug$9("Adding .markDefs to block node"), editorActor.send({
+          type: "normalizing"
+        }), slate.Transforms.setNodes(editor, {
+          markDefs: []
+        }, {
+          at: path
+        }), editorActor.send({
+          type: "done normalizing"
+        });
         return;
       }
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "insert.text",
-          text,
-          options
-        },
-        editor,
-        defaultActionCallback: () => {
-          insertText(text, options);
-        }
-      });
-    }, editor.select = (location) => {
-      if (isApplyingBehaviorActions(editor)) {
-        select(location);
+      if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
+        debug$9("Adding .marks to span node"), editorActor.send({
+          type: "normalizing"
+        }), slate.Transforms.setNodes(editor, {
+          marks: []
+        }, {
+          at: path
+        }), editorActor.send({
+          type: "done normalizing"
+        });
         return;
       }
-      const range = slate.Editor.range(editor, location);
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "select",
-          selection: toPortableTextRange(fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), range, editorActor.getSnapshot().context.schema)
-        },
-        editor,
-        defaultActionCallback: () => {
-          select(location);
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
+        if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
+          debug$9("Removing annotations from empty span node"), editorActor.send({
+            type: "normalizing"
+          }), slate.Transforms.setNodes(editor, {
+            marks: node.marks?.filter((mark) => decorators2.includes(mark))
+          }, {
+            at: path
+          }), editorActor.send({
+            type: "done normalizing"
+          });
+          return;
         }
-      });
-    }, editor.setFragmentData = (dataTransfer, originEvent) => {
-      if (originEvent === "drag") {
-        setFragmentData(dataTransfer);
-        return;
       }
-      if (isApplyingBehaviorActions(editor)) {
-        setFragmentData(dataTransfer);
-        return;
+      if (editor.isTextBlock(node)) {
+        const decorators2 = types2.decorators.map((decorator) => decorator.value);
+        for (const [child, childPath] of slate.Node.children(editor, path))
+          if (editor.isTextSpan(child)) {
+            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
+            if (orphanedAnnotations.length > 0) {
+              debug$9("Removing orphaned annotations from span node"), editorActor.send({
+                type: "normalizing"
+              }), slate.Transforms.setNodes(editor, {
+                marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
+              }, {
+                at: childPath
+              }), editorActor.send({
+                type: "done normalizing"
+              });
+              return;
+            }
+          }
       }
-      dataTransfer.clearData(), editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "serialize",
-          dataTransfer,
-          originEvent: originEvent ?? "unknown"
-        },
-        editor
-      });
-    }, editor;
-  };
-}
-function createWithMaxBlocks(editorActor) {
-  return function(editor) {
-    const {
-      apply: apply2
-    } = editor;
-    return editor.apply = (operation) => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      })) {
-        apply2(operation);
-        return;
-      }
-      if (isChangingRemotely(editor)) {
-        apply2(operation);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(operation);
-        return;
-      }
-      const rows = editorActor.getSnapshot().context.maxBlocks ?? -1;
-      rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
-    }, editor;
-  };
-}
-function createWithObjectKeys(editorActor, schemaTypes) {
-  return function(editor) {
-    const {
-      apply: apply2,
-      normalizeNode
-    } = editor;
-    return editor.apply = (operation) => {
-      if (isChangingRemotely(editor)) {
-        apply2(operation);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(operation);
-        return;
-      }
-      if (operation.type === "split_node") {
-        const existingKeys = [...slate.Node.descendants(editor)].map(([node]) => node._key);
-        apply2({
-          ...operation,
-          properties: {
-            ...operation.properties,
-            _key: operation.properties._key === void 0 || existingKeys.includes(operation.properties._key) ? editorActor.getSnapshot().context.keyGenerator() : operation.properties._key
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath);
+        if (editor.isTextBlock(block)) {
+          const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          if (orphanedAnnotations.length > 0) {
+            debug$9("Removing orphaned annotations from span node"), editorActor.send({
+              type: "normalizing"
+            }), slate.Transforms.setNodes(editor, {
+              marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
+            }, {
+              at: path
+            }), editorActor.send({
+              type: "done normalizing"
+            });
+            return;
           }
-        });
-        return;
+        }
       }
-      if (operation.type === "insert_node" && !slate.Editor.isEditor(operation.node)) {
-        const existingKeys = [...slate.Node.descendants(editor)].map(([node]) => node._key);
-        apply2({
-          ...operation,
-          node: {
-            ...operation.node,
-            _key: operation.node._key === void 0 || existingKeys.includes(operation.node._key) ? editorActor.getSnapshot().context.keyGenerator() : operation.node._key
-          }
-        });
-        return;
+      if (editor.isTextBlock(node)) {
+        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
+        for (const markDef of markDefs)
+          markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
+        if (markDefs.length !== newMarkDefs.length) {
+          debug$9("Removing duplicate markDefs"), editorActor.send({
+            type: "normalizing"
+          }), slate.Transforms.setNodes(editor, {
+            markDefs: newMarkDefs
+          }, {
+            at: path
+          }), editorActor.send({
+            type: "done normalizing"
+          });
+          return;
+        }
       }
-      apply2(operation);
-    }, editor.normalizeNode = (entry) => {
-      const [node, path] = entry;
-      if (slate.Element.isElement(node) && node._type === schemaTypes.block.name) {
-        if (!node._key) {
-          editorActor.send({
+      if (editor.isTextBlock(node) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
+        const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
+        if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
+          debug$9("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
-            _key: editorActor.getSnapshot().context.keyGenerator()
+            markDefs: newMarkDefs
           }, {
             at: path
           }), editorActor.send({
@@ -2959,1279 +3122,325 @@ function createWithObjectKeys(editorActor, schemaTypes) {
           });
           return;
         }
-        for (const [child, childPath] of slate.Node.children(editor, path))
-          if (!child._key) {
-            editorActor.send({
-              type: "normalizing"
-            }), slate.Transforms.setNodes(editor, {
-              _key: editorActor.getSnapshot().context.keyGenerator()
-            }, {
-              at: childPath
-            }), editorActor.send({
-              type: "done normalizing"
+      }
+      normalizeNode(nodeEntry);
+    }, editor.apply = (op) => {
+      if (isChangingRemotely(editor)) {
+        apply2(op);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(op);
+        return;
+      }
+      if (op.type === "set_selection" && slate.Editor.marks(editor) && op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+        const previousSelectionIsCollapsed = slate.Range.isCollapsed({
+          anchor: op.properties.anchor,
+          focus: op.properties.focus
+        }), newSelectionIsCollapsed = slate.Range.isCollapsed({
+          anchor: op.newProperties.anchor,
+          focus: op.newProperties.focus
+        });
+        if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
+          const focusSpan = Array.from(slate.Editor.nodes(editor, {
+            mode: "lowest",
+            at: op.properties.focus,
+            match: (n) => editor.isTextSpan(n),
+            voids: !1
+          }))[0]?.[0], newFocusSpan = Array.from(slate.Editor.nodes(editor, {
+            mode: "lowest",
+            at: op.newProperties.focus,
+            match: (n) => editor.isTextSpan(n),
+            voids: !1
+          }))[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+          if (movedToNextSpan || movedToPreviousSpan)
+            return;
+        }
+      }
+      if (op.type === "insert_node") {
+        const {
+          selection
+        } = editor;
+        if (selection) {
+          const [_block, blockPath] = slate.Editor.node(editor, selection, {
+            depth: 1
+          }), previousSpan = getPreviousSpan({
+            editor,
+            blockPath,
+            spanPath: op.path
+          }), previousSpanAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
+            editor,
+            blockPath,
+            spanPath: [op.path[0], op.path[1] - 1]
+          }), nextSpanAnnotations = nextSpan ? nextSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = previousSpanAnnotations?.filter((annotation) => !nextSpanAnnotations?.includes(annotation)) ?? [], atTheEndOfAnnotation = annotationsEnding.length > 0;
+          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsEnding.includes(mark))) {
+            slate.Transforms.insertNodes(editor, {
+              ...op.node,
+              _key: editorActor.getSnapshot().context.keyGenerator(),
+              marks: op.node.marks?.filter((mark) => !annotationsEnding.includes(mark)) ?? []
             });
             return;
           }
+          const annotationsStarting = nextSpanAnnotations?.filter((annotation) => !previousSpanAnnotations?.includes(annotation)) ?? [], atTheStartOfAnnotation = annotationsStarting.length > 0;
+          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsStarting.includes(mark))) {
+            slate.Transforms.insertNodes(editor, {
+              ...op.node,
+              _key: editorActor.getSnapshot().context.keyGenerator(),
+              marks: op.node.marks?.filter((mark) => !annotationsStarting.includes(mark)) ?? []
+            });
+            return;
+          }
+          const nextSpanDecorators = nextSpan?.marks?.filter((mark) => decorators.includes(mark)) ?? [];
+          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.length === 0) {
+            slate.Transforms.insertNodes(editor, {
+              ...op.node,
+              _key: editorActor.getSnapshot().context.keyGenerator(),
+              marks: nextSpanDecorators
+            });
+            return;
+          }
+        }
       }
-      normalizeNode(entry);
-    }, editor;
-  };
-}
-const debug$9 = debugWithName("applyPatches"), debugVerbose = debug$9.enabled && !0;
-function createApplyPatch(schemaTypes) {
-  return (editor, patch) => {
-    let changed = !1;
-    debugVerbose && (debug$9(`
-
-NEW PATCH =============================================================`), debug$9(JSON.stringify(patch, null, 2)));
-    try {
-      switch (patch.type) {
-        case "insert":
-          changed = insertPatch(editor, patch, schemaTypes);
-          break;
-        case "unset":
-          changed = unsetPatch(editor, patch);
-          break;
-        case "set":
-          changed = setPatch(editor, patch);
-          break;
-        case "diffMatchPatch":
-          changed = diffMatchPatch(editor, patch);
-          break;
-        default:
-          debug$9("Unhandled patch", patch.type);
-      }
-    } catch (err) {
-      console.error(err);
-    }
-    return changed;
-  };
-}
-function diffMatchPatch(editor, patch) {
-  const {
-    block,
-    child,
-    childPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (!block)
-    return debug$9("Block not found"), !1;
-  if (!child || !childPath)
-    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, {
-    allowExceedingIndices: !0
-  }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
-  debugState(editor, "before");
-  let offset = 0;
-  for (const [op, text] of diff$1)
-    op === DIFF_INSERT ? (editor.apply({
-      type: "insert_text",
-      path: childPath,
-      offset,
-      text
-    }), offset += text.length) : op === DIFF_DELETE ? editor.apply({
-      type: "remove_text",
-      path: childPath,
-      offset,
-      text
-    }) : op === DIFF_EQUAL && (offset += text.length);
-  return debugState(editor, "after"), !0;
-}
-function insertPatch(editor, patch, schemaTypes) {
-  const {
-    block: targetBlock,
-    child: targetChild,
-    blockPath: targetBlockPath,
-    childPath: targetChildPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (!targetBlock || !targetBlockPath)
-    return debug$9("Block not found"), !1;
-  if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$9("Ignoring patch targeting void value"), !1;
-  if (patch.path.length === 1) {
-    const {
-      items: items2,
-      position: position2
-    } = patch, blocksToInsert = toSlateValue(items2, {
-      schemaTypes
-    }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$9(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
-      at: [normalizedIdx2]
-    }), debugState(editor, "after"), !0;
-  }
-  const {
-    items,
-    position
-  } = patch;
-  if (!targetChild || !targetChildPath)
-    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$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;
-}
-function setPatch(editor, patch) {
-  let value = patch.value;
-  typeof patch.path[3] == "string" && (value = {}, value[patch.path[3]] = patch.value);
-  const {
-    block,
-    blockPath,
-    child,
-    childPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (!block)
-    return debug$9("Block not found"), !1;
-  const isTextBlock = editor.isTextBlock(block);
-  if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    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$9("Setting text property"), editor.apply({
-        type: "remove_text",
-        path: childPath,
-        offset: 0,
-        text: newText
-      }), editor.apply({
-        type: "insert_text",
-        path: childPath,
-        offset: 0,
-        text: value.text
-      }), editor.onChange());
-    } else
-      debug$9("Setting non-text property"), editor.apply({
-        type: "set_node",
-        path: childPath,
-        properties: {},
-        newProperties: value
-      });
-    return !0;
-  } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$9("Setting block property");
-    const {
-      children,
-      ...nextRest
-    } = value, {
-      children: prevChildren,
-      ...prevRest
-    } = block || {
-      children: void 0
-    };
-    editor.apply({
-      type: "set_node",
-      path: blockPath,
-      properties: {
-        ...prevRest
-      },
-      newProperties: nextRest
-    }), debug$9("Setting children"), block.children.forEach((c, cIndex) => {
-      editor.apply({
-        type: "remove_node",
-        path: blockPath.concat(block.children.length - 1 - cIndex),
-        node: c
-      });
-    }), Array.isArray(children) && children.forEach((c, cIndex) => {
-      editor.apply({
-        type: "insert_node",
-        path: blockPath.concat(cIndex),
-        node: c
-      });
-    });
-  } else if (block && "value" in block)
-    if (patch.path.length > 1 && patch.path[1] !== "children") {
-      const newVal = patches.applyAll(block.value, [{
-        ...patch,
-        path: patch.path.slice(1)
-      }]);
-      slate.Transforms.setNodes(editor, {
-        ...block,
-        value: newVal
-      }, {
-        at: blockPath
-      });
-    } else
-      return !1;
-  return debugState(editor, "after"), !0;
-}
-function unsetPatch(editor, patch) {
-  if (patch.path.length === 0) {
-    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, {
-        at: [i]
-      });
-    }), slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({
-      decorators: []
-    })), previousSelection && slate.Transforms.select(editor, {
-      anchor: {
-        path: [0, 0],
-        offset: 0
-      },
-      focus: {
-        path: [0, 0],
-        offset: 0
-      }
-    }), editor.onChange(), debugState(editor, "after"), !0;
-  }
-  const {
-    block,
-    blockPath,
-    child,
-    childPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (patch.path.length === 1) {
-    if (!block || !blockPath)
-      return debug$9("Block not found"), !1;
-    const blockIndex = blockPath[0];
-    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$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;
-}
-function isKeyedSegment(segment) {
-  return typeof segment == "object" && "_key" in segment;
-}
-function debugState(editor, stateName) {
-  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;
-  const block = editor.children.find((node, index) => {
-    const isMatch = isKeyedSegment(path[0]) ? node._key === path[0]._key : index === path[0];
-    return isMatch && (blockIndex = index), isMatch;
-  });
-  return block ? {
-    block,
-    path: [blockIndex]
-  } : {};
-}
-function findBlockAndChildFromPath(editor, path) {
-  const {
-    block,
-    path: blockPath
-  } = findBlockFromPath(editor, path);
-  if (!(slate.Element.isElement(block) && path[1] === "children"))
-    return {
-      block,
-      blockPath,
-      child: void 0,
-      childPath: void 0
-    };
-  let childIndex = -1;
-  const child = block.children.find((node, index) => {
-    const isMatch = isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2];
-    return isMatch && (childIndex = index), isMatch;
-  });
-  return child ? {
-    block,
-    child,
-    blockPath,
-    childPath: blockPath?.concat(childIndex)
-  } : {
-    block,
-    blockPath,
-    child: void 0,
-    childPath: void 0
-  };
-}
-const debug$8 = debugWithName("plugin:withPatches");
-function createWithPatches({
-  editorActor,
-  patchFunctions,
-  schemaTypes,
-  subscriptions
-}) {
-  let previousChildren;
-  const applyPatch = createApplyPatch(schemaTypes);
-  return function(editor) {
-    IS_PROCESSING_REMOTE_CHANGES.set(editor, !1), PATCHING.set(editor, !0), previousChildren = [...editor.children];
-    const {
-      apply: apply2
-    } = editor;
-    let bufferedPatches = [];
-    const handleBufferedRemotePatches = () => {
-      if (bufferedPatches.length === 0)
-        return;
-      const patches2 = bufferedPatches;
-      bufferedPatches = [];
-      let changed = !1;
-      withRemoteChanges(editor, () => {
-        slate.Editor.withoutNormalizing(editor, () => {
-          withoutPatching(editor, () => {
-            withoutSaving(editor, () => {
-              patches2.forEach((patch) => {
-                debug$8.enabled && debug$8(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
-              });
-            });
-          });
-        }), changed && (editor.normalize(), editor.onChange());
-      });
-    }, handlePatches = ({
-      patches: patches2
-    }) => {
-      const remotePatches = patches2.filter((p) => p.origin !== "local");
-      remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
-    };
-    return subscriptions.push(() => {
-      debug$8("Subscribing to remote patches");
-      const sub = editorActor.on("patches", handlePatches);
-      return () => {
-        debug$8("Unsubscribing to remote patches"), sub.unsubscribe();
-      };
-    }), editor.apply = (operation) => {
-      let patches$1 = [];
-      previousChildren = editor.children;
-      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes);
-      apply2(operation);
-      const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes);
-      if (!isPatching(editor))
-        return editor;
-      switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches$1.push(patches.insert(previousChildren, "before", [0])), operation.type) {
-        case "insert_text":
-          patches$1 = [...patches$1, ...patchFunctions.insertTextPatch(editor, operation, previousChildren)];
-          break;
-        case "remove_text":
-          patches$1 = [...patches$1, ...patchFunctions.removeTextPatch(editor, operation, previousChildren)];
-          break;
-        case "remove_node":
-          patches$1 = [...patches$1, ...patchFunctions.removeNodePatch(editor, operation, previousChildren)];
-          break;
-        case "split_node":
-          patches$1 = [...patches$1, ...patchFunctions.splitNodePatch(editor, operation, previousChildren)];
-          break;
-        case "insert_node":
-          patches$1 = [...patches$1, ...patchFunctions.insertNodePatch(editor, operation, previousChildren)];
-          break;
-        case "set_node":
-          patches$1 = [...patches$1, ...patchFunctions.setNodePatch(editor, operation, previousChildren)];
-          break;
-        case "merge_node":
-          patches$1 = [...patches$1, ...patchFunctions.mergeNodePatch(editor, operation, previousChildren)];
-          break;
-        case "move_node":
-          patches$1 = [...patches$1, ...patchFunctions.moveNodePatch(editor, operation, previousChildren)];
-          break;
-      }
-      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches$1 = [...patches$1, patches.unset([])], editorActor.send({
-        type: "notify.unset",
-        previousValue: fromSlateValue(previousChildren, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
-      })), editorWasEmpty && patches$1.length > 0 && (patches$1 = [patches.setIfMissing([], []), ...patches$1]), patches$1.length > 0 && patches$1.forEach((patch) => {
-        editorActor.send({
-          type: "patch",
-          patch: {
-            ...patch,
-            origin: "local"
-          }
-        });
-      }), editor;
-    }, editor;
-  };
-}
-const debug$7 = debugWithName("plugin:withPlaceholderBlock");
-function createWithPlaceholderBlock(editorActor) {
-  return function(editor) {
-    const {
-      apply: apply2
-    } = editor;
-    return editor.apply = (op) => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      })) {
-        apply2(op);
-        return;
-      }
-      if (isChangingRemotely(editor)) {
-        apply2(op);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(op);
-        return;
-      }
-      if (op.type === "remove_node") {
-        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$7("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
-            decorators: []
-          })));
-        }
-      }
-      apply2(op);
-    }, editor;
-  };
-}
-const debug$6 = debugWithName("plugin:withPortableTextBlockStyle");
-function createWithPortableTextBlockStyle(editorActor, types2) {
-  const defaultStyle = types2.styles[0].value;
-  return function(editor) {
-    const {
-      normalizeNode
-    } = editor;
-    return editor.normalizeNode = (nodeEntry) => {
-      const [, path] = nodeEntry;
-      for (const op of editor.operations)
-        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$6(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
-              type: "normalizing"
-            }), slate.Transforms.setNodes(editor, {
-              style: defaultStyle
-            }, {
-              at: [op.path[0] + 1],
-              voids: !1
-            }), editorActor.send({
-              type: "done normalizing"
-            });
-            return;
-          }
-        }
-      normalizeNode(nodeEntry);
-    }, editor;
-  };
-}
-function isPortableTextSpan(node) {
-  return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
-}
-function isPortableTextBlock(node) {
-  return (
-    // A block doesn't _have_ to be named 'block' - to differentiate between
-    // allowed child types and marks, one might name them differently
-    typeof node._type == "string" && // Toolkit-types like nested spans are @-prefixed
-    node._type[0] !== "@" && // `markDefs` isn't _required_ per say, but if it's there, it needs to be an array
-    (!("markDefs" in node) || !node.markDefs || Array.isArray(node.markDefs) && // Every mark definition needs to have an `_key` to be mappable in child spans
-    node.markDefs.every((def) => typeof def._key == "string")) && // `children` is required and needs to be an array
-    "children" in node && Array.isArray(node.children) && // All children are objects with `_type` (usually spans, but can contain other stuff)
-    node.children.every((child) => typeof child == "object" && "_type" in child)
-  );
-}
-function getPreviousSpan({
-  editor,
-  blockPath,
-  spanPath
-}) {
-  let previousSpan;
-  for (const [child, childPath] of slate.Node.children(editor, blockPath, {
-    reverse: !0
-  }))
-    if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, spanPath)) {
-      previousSpan = child;
-      break;
-    }
-  return previousSpan;
-}
-function getNextSpan({
-  editor,
-  blockPath,
-  spanPath
-}) {
-  let nextSpan;
-  for (const [child, childPath] of slate.Node.children(editor, blockPath))
-    if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, spanPath)) {
-      nextSpan = child;
-      break;
-    }
-  return nextSpan;
-}
-const debug$5 = debugWithName("plugin:withPortableTextMarkModel");
-function createWithPortableTextMarkModel(editorActor, types2) {
-  return function(editor) {
-    const {
-      apply: apply2,
-      normalizeNode
-    } = editor, decorators = types2.decorators.map((t) => t.value);
-    return editor.normalizeNode = (nodeEntry) => {
-      const [node, path] = nodeEntry;
-      if (editor.isTextBlock(node)) {
-        const children = slate.Node.children(editor, path);
-        for (const [child, childPath] of children) {
-          const nextNode = node.children[childPath[1] + 1];
-          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
-            debug$5("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
-              type: "normalizing"
-            }), slate.Transforms.mergeNodes(editor, {
-              at: [childPath[0], childPath[1] + 1],
-              voids: !0
-            }), editorActor.send({
-              type: "done normalizing"
-            });
-            return;
-          }
-        }
-      }
-      if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$5("Adding .markDefs to block node"), editorActor.send({
-          type: "normalizing"
-        }), slate.Transforms.setNodes(editor, {
-          markDefs: []
-        }, {
-          at: path
-        }), editorActor.send({
-          type: "done normalizing"
-        });
-        return;
-      }
-      if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$5("Adding .marks to span node"), editorActor.send({
-          type: "normalizing"
-        }), slate.Transforms.setNodes(editor, {
-          marks: []
-        }, {
-          at: path
-        }), editorActor.send({
-          type: "done normalizing"
-        });
-        return;
-      }
-      if (editor.isTextSpan(node)) {
-        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
-        if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$5("Removing annotations from empty span node"), editorActor.send({
-            type: "normalizing"
-          }), slate.Transforms.setNodes(editor, {
-            marks: node.marks?.filter((mark) => decorators2.includes(mark))
-          }, {
-            at: path
-          }), editorActor.send({
-            type: "done normalizing"
-          });
-          return;
-        }
-      }
-      if (editor.isTextBlock(node)) {
-        const decorators2 = types2.decorators.map((decorator) => decorator.value);
-        for (const [child, childPath] of slate.Node.children(editor, path))
-          if (editor.isTextSpan(child)) {
-            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
-            if (orphanedAnnotations.length > 0) {
-              debug$5("Removing orphaned annotations from span node"), editorActor.send({
-                type: "normalizing"
-              }), slate.Transforms.setNodes(editor, {
-                marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
-              }, {
-                at: childPath
-              }), editorActor.send({
-                type: "done normalizing"
-              });
-              return;
-            }
-          }
-      }
-      if (editor.isTextSpan(node)) {
-        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath);
-        if (editor.isTextBlock(block)) {
-          const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
-          if (orphanedAnnotations.length > 0) {
-            debug$5("Removing orphaned annotations from span node"), editorActor.send({
-              type: "normalizing"
-            }), slate.Transforms.setNodes(editor, {
-              marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
-            }, {
-              at: path
-            }), editorActor.send({
-              type: "done normalizing"
-            });
-            return;
-          }
-        }
-      }
-      if (editor.isTextBlock(node)) {
-        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
-        for (const markDef of markDefs)
-          markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
-        if (markDefs.length !== newMarkDefs.length) {
-          debug$5("Removing duplicate markDefs"), editorActor.send({
-            type: "normalizing"
-          }), slate.Transforms.setNodes(editor, {
-            markDefs: newMarkDefs
-          }, {
-            at: path
-          }), editorActor.send({
-            type: "done normalizing"
-          });
-          return;
-        }
-      }
-      if (editor.isTextBlock(node) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
-        const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
-        if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
-          debug$5("Removing markDef not in use"), editorActor.send({
-            type: "normalizing"
-          }), slate.Transforms.setNodes(editor, {
-            markDefs: newMarkDefs
-          }, {
-            at: path
-          }), editorActor.send({
-            type: "done normalizing"
-          });
-          return;
-        }
-      }
-      normalizeNode(nodeEntry);
-    }, editor.apply = (op) => {
-      if (isChangingRemotely(editor)) {
-        apply2(op);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(op);
-        return;
-      }
-      if (op.type === "set_selection" && slate.Editor.marks(editor) && op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
-        const previousSelectionIsCollapsed = slate.Range.isCollapsed({
-          anchor: op.properties.anchor,
-          focus: op.properties.focus
-        }), newSelectionIsCollapsed = slate.Range.isCollapsed({
-          anchor: op.newProperties.anchor,
-          focus: op.newProperties.focus
-        });
-        if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-          const focusSpan = Array.from(slate.Editor.nodes(editor, {
-            mode: "lowest",
-            at: op.properties.focus,
-            match: (n) => editor.isTextSpan(n),
-            voids: !1
-          }))[0]?.[0], newFocusSpan = Array.from(slate.Editor.nodes(editor, {
-            mode: "lowest",
-            at: op.newProperties.focus,
-            match: (n) => editor.isTextSpan(n),
-            voids: !1
-          }))[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
-          if (movedToNextSpan || movedToPreviousSpan)
-            return;
-        }
-      }
-      if (op.type === "insert_node") {
-        const {
-          selection
-        } = editor;
-        if (selection) {
-          const [_block, blockPath] = slate.Editor.node(editor, selection, {
-            depth: 1
-          }), previousSpan = getPreviousSpan({
-            editor,
-            blockPath,
-            spanPath: op.path
-          }), previousSpanAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
-            editor,
-            blockPath,
-            spanPath: [op.path[0], op.path[1] - 1]
-          }), nextSpanAnnotations = nextSpan ? nextSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = previousSpanAnnotations?.filter((annotation) => !nextSpanAnnotations?.includes(annotation)) ?? [], atTheEndOfAnnotation = annotationsEnding.length > 0;
-          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsEnding.includes(mark))) {
-            slate.Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks: op.node.marks?.filter((mark) => !annotationsEnding.includes(mark)) ?? []
-            });
-            return;
-          }
-          const annotationsStarting = nextSpanAnnotations?.filter((annotation) => !previousSpanAnnotations?.includes(annotation)) ?? [], atTheStartOfAnnotation = annotationsStarting.length > 0;
-          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsStarting.includes(mark))) {
-            slate.Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks: op.node.marks?.filter((mark) => !annotationsStarting.includes(mark)) ?? []
-            });
-            return;
-          }
-          const nextSpanDecorators = nextSpan?.marks?.filter((mark) => decorators.includes(mark)) ?? [];
-          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.length === 0) {
-            slate.Transforms.insertNodes(editor, {
-              ...op.node,
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              marks: nextSpanDecorators
-            });
-            return;
-          }
-        }
-      }
-      if (op.type === "insert_text") {
-        const {
-          selection
-        } = editor, collapsedSelection = selection ? slate.Range.isCollapsed(selection) : !1;
-        if (selection && collapsedSelection) {
-          const [_block, blockPath] = slate.Editor.node(editor, selection, {
-            depth: 1
-          }), [span, spanPath] = Array.from(slate.Editor.nodes(editor, {
-            mode: "lowest",
-            at: selection.focus,
-            match: (n) => editor.isTextSpan(n),
-            voids: !1
-          }))[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
-            editor,
-            blockPath,
-            spanPath
-          }), nextSpan = getNextSpan({
-            editor,
-            blockPath,
-            spanPath
-          }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
-          if (spanHasAnnotations && !spanIsEmpty) {
-            if (atTheBeginningOfSpan) {
-              if (previousSpanHasSameMarks) {
-                slate.Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: previousSpan?.marks ?? []
-                });
-                return;
-              } else if (previousSpanHasSameAnnotations) {
-                slate.Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: previousSpan?.marks ?? []
-                });
-                return;
-              } else if (previousSpanHasSameAnnotation) {
-                apply2(op);
-                return;
-              } else if (!previousSpan) {
-                slate.Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: []
-                });
-                return;
-              }
-            }
-            if (atTheEndOfSpan) {
-              if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) {
-                slate.Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: nextSpan?.marks ?? []
-                });
-                return;
-              }
-              if (!nextSpan) {
-                slate.Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: []
-                });
-                return;
-              }
-            }
-          }
-          if (atTheBeginningOfSpan && !spanIsEmpty && previousSpan) {
-            slate.Transforms.insertNodes(editor, {
-              _type: "span",
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              text: op.text,
-              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter((mark) => decorators.includes(mark))
-            });
-            return;
-          }
-        }
-      }
-      if (op.type === "remove_text") {
-        const {
-          selection
-        } = editor;
-        if (selection && slate.Range.isExpanded(selection)) {
-          const [block, blockPath] = slate.Editor.node(editor, selection, {
-            depth: 1
-          }), [span, spanPath] = Array.from(slate.Editor.nodes(editor, {
-            mode: "lowest",
-            at: {
-              path: op.path,
-              offset: op.offset
-            },
-            match: (n) => editor.isTextSpan(n),
-            voids: !1
-          }))[0] ?? [void 0, void 0];
-          if (span && block && isPortableTextBlock(block)) {
-            const markDefs = block.markDefs ?? [], marks = span.marks ?? [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
-              editor,
-              blockPath,
-              spanPath
-            }), nextSpan = getNextSpan({
-              editor,
-              blockPath,
-              spanPath
-            }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
-            if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
-              const marksWithoutAnnotationMarks = ({
-                ...slate.Editor.marks(editor) || {}
-              }.marks || []).filter((mark) => decorators.includes(mark));
-              slate.Editor.withoutNormalizing(editor, () => {
-                apply2(op), slate.Transforms.setNodes(editor, {
-                  marks: marksWithoutAnnotationMarks
-                }, {
-                  at: op.path
-                });
-              }), editor.onChange();
-              return;
-            }
-          }
-        }
-      }
-      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
-        const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
-        if (editor.isTextBlock(targetBlock)) {
-          const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-          debug$5("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
-            markDefs: newMarkDefs
-          }, {
-            at: targetPath,
-            voids: !1
-          }), apply2(op);
-          return;
-        }
-      }
-      apply2(op);
-    }, editor;
-  };
-}
-const addDecoratorActionImplementation = ({
-  action
-}) => {
-  const editor = action.editor, mark = action.decorator;
-  if (editor.selection) {
-    if (slate.Range.isExpanded(editor.selection)) {
-      slate.Transforms.setNodes(editor, {}, {
-        match: slate.Text.isText,
-        split: !0,
-        hanging: !0
-      });
-      const splitTextNodes = slate.Range.isRange(editor.selection) ? [...slate.Editor.nodes(editor, {
-        at: editor.selection,
-        match: slate.Text.isText
-      })] : [];
-      splitTextNodes.length > 1 && splitTextNodes.every((node) => node[0].marks?.includes(mark)) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
-        const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
-        slate.Transforms.setNodes(editor, {
-          marks
-        }, {
-          at: path,
-          match: slate.Text.isText,
-          split: !0,
-          hanging: !0
-        });
-      });
-    } else {
-      const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
-        depth: 1
-      }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
-      if (lonelyEmptySpan) {
-        const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
-        slate.Transforms.setNodes(editor, {
-          marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
-        }, {
-          at: blockPath,
-          match: (node) => editor.isTextSpan(node)
-        });
-      } else {
-        const existingMarks = {
-          ...slate.Editor.marks(editor) || {}
-        }.marks || [], marks = {
-          ...slate.Editor.marks(editor) || {},
-          marks: [...existingMarks, mark]
-        };
-        editor.marks = marks;
-      }
-    }
-    if (editor.selection) {
-      const selection = editor.selection;
-      editor.selection = {
-        ...selection
-      };
-    }
-  }
-}, removeDecoratorActionImplementation = ({
-  action
-}) => {
-  const editor = action.editor, mark = action.decorator, {
-    selection
-  } = editor;
-  if (selection) {
-    if (slate.Range.isExpanded(selection))
-      slate.Transforms.setNodes(editor, {}, {
-        match: slate.Text.isText,
-        split: !0,
-        hanging: !0
-      }), editor.selection && [...slate.Editor.nodes(editor, {
-        at: editor.selection,
-        match: slate.Text.isText
-      })].forEach(([node, path]) => {
-        const block = editor.children[path[0]];
-        slate.Element.isElement(block) && block.children.includes(node) && slate.Transforms.setNodes(editor, {
-          marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
-          _type: "span"
-        }, {
-          at: path
-        });
-      });
-    else {
-      const [block, blockPath] = slate.Editor.node(editor, selection, {
-        depth: 1
-      }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
-      if (lonelyEmptySpan) {
-        const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
-        slate.Transforms.setNodes(editor, {
-          marks: existingMarksWithoutDecorator
-        }, {
-          at: blockPath,
-          match: (node) => editor.isTextSpan(node)
-        });
-      } else {
-        const existingMarks = {
-          ...slate.Editor.marks(editor) || {}
-        }.marks || [], marks = {
-          ...slate.Editor.marks(editor) || {},
-          marks: existingMarks.filter((eMark) => eMark !== mark)
-        };
-        editor.marks = {
-          marks: marks.marks,
-          _type: "span"
-        };
-      }
-    }
-    if (editor.selection) {
-      const selection2 = editor.selection;
-      editor.selection = {
-        ...selection2
-      };
-    }
-  }
-};
-function isDecoratorActive({
-  editor,
-  decorator
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedTextNodes = Array.from(slate.Editor.nodes(editor, {
-    match: slate.Text.isText,
-    at: editor.selection
-  }));
-  return selectedTextNodes.length === 0 ? !1 : slate.Range.isExpanded(editor.selection) ? selectedTextNodes.every((n) => {
-    const [node] = n;
-    return node.marks?.includes(decorator);
-  }) : ({
-    ...slate.Editor.marks(editor) || {}
-  }.marks || []).includes(decorator);
-}
-const toggleDecoratorActionImplementation = ({
-  context,
-  action
-}) => {
-  isDecoratorActive({
-    editor: action.editor,
-    decorator: action.decorator
-  }) ? removeDecoratorActionImplementation({
-    context,
-    action: {
-      type: "decorator.remove",
-      editor: action.editor,
-      decorator: action.decorator
-    }
-  }) : addDecoratorActionImplementation({
-    context,
-    action: {
-      type: "decorator.add",
-      editor: action.editor,
-      decorator: action.decorator
-    }
-  });
-};
-debugWithName("plugin:withPortableTextSelections");
-function createWithPortableTextSelections(editorActor, types2) {
-  let prevSelection = null;
-  return function(editor) {
-    const emitPortableTextSelection = () => {
-      if (prevSelection !== editor.selection) {
-        let ptRange = null;
-        if (editor.selection) {
-          const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
-          if (existing)
-            ptRange = existing;
-          else {
-            const value = editor.children;
-            ptRange = toPortableTextRange(value, editor.selection, types2), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+      if (op.type === "insert_text") {
+        const {
+          selection
+        } = editor, collapsedSelection = selection ? slate.Range.isCollapsed(selection) : !1;
+        if (selection && collapsedSelection) {
+          const [_block, blockPath] = slate.Editor.node(editor, selection, {
+            depth: 1
+          }), [span, spanPath] = Array.from(slate.Editor.nodes(editor, {
+            mode: "lowest",
+            at: selection.focus,
+            match: (n) => editor.isTextSpan(n),
+            voids: !1
+          }))[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
+            editor,
+            blockPath,
+            spanPath
+          }), nextSpan = getNextSpan({
+            editor,
+            blockPath,
+            spanPath
+          }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
+          if (spanHasAnnotations && !spanIsEmpty) {
+            if (atTheBeginningOfSpan) {
+              if (previousSpanHasSameMarks) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: previousSpan?.marks ?? []
+                });
+                return;
+              } else if (previousSpanHasSameAnnotations) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: previousSpan?.marks ?? []
+                });
+                return;
+              } else if (previousSpanHasSameAnnotation) {
+                apply2(op);
+                return;
+              } else if (!previousSpan) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: []
+                });
+                return;
+              }
+            }
+            if (atTheEndOfSpan) {
+              if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: nextSpan?.marks ?? []
+                });
+                return;
+              }
+              if (!nextSpan) {
+                slate.Transforms.insertNodes(editor, {
+                  _type: "span",
+                  _key: editorActor.getSnapshot().context.keyGenerator(),
+                  text: op.text,
+                  marks: []
+                });
+                return;
+              }
+            }
+          }
+          if (atTheBeginningOfSpan && !spanIsEmpty && previousSpan) {
+            slate.Transforms.insertNodes(editor, {
+              _type: "span",
+              _key: editorActor.getSnapshot().context.keyGenerator(),
+              text: op.text,
+              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter((mark) => decorators.includes(mark))
+            });
+            return;
           }
         }
-        ptRange ? editorActor.send({
-          type: "notify.selection",
-          selection: ptRange
-        }) : editorActor.send({
-          type: "notify.selection",
-          selection: null
-        });
-      }
-      prevSelection = editor.selection;
-    }, {
-      onChange
-    } = editor;
-    return editor.onChange = () => {
-      onChange(), editorActor.getSnapshot().matches({
-        setup: "setting up"
-      }) || emitPortableTextSelection();
-    }, editor;
-  };
-}
-const debug$4 = debugWithName("plugin:withSchemaTypes");
-function createWithSchemaTypes({
-  editorActor,
-  schemaTypes
-}) {
-  return function(editor) {
-    editor.isTextBlock = (value) => types.isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => types.isPortableTextSpan(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => types.isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
-    const {
-      normalizeNode
-    } = editor;
-    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");
-        const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
-        editorActor.send({
-          type: "normalizing"
-        }), slate.Transforms.setNodes(editor, {
-          ...span,
-          _type: schemaTypes.span.name,
-          _key: key
-        }, {
-          at: path
-        }), editorActor.send({
-          type: "done normalizing"
-        });
-        return;
-      }
-      if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$4("Setting missing key on child node without a key");
-        const key = editorActor.getSnapshot().context.keyGenerator();
-        editorActor.send({
-          type: "normalizing"
-        }), slate.Transforms.setNodes(editor, {
-          _key: key
-        }, {
-          at: path
-        }), editorActor.send({
-          type: "done normalizing"
-        });
-        return;
       }
-      normalizeNode(entry);
-    }, editor;
-  };
-}
-function createWithUtils({
-  editorActor,
-  schemaTypes
-}) {
-  return function(editor) {
-    return editor.pteCreateTextBlock = (options) => toSlateValue([{
-      _type: schemaTypes.block.name,
-      _key: editorActor.getSnapshot().context.keyGenerator(),
-      style: schemaTypes.styles[0].value || "normal",
-      ...options.listItem ? {
-        listItem: options.listItem
-      } : {},
-      ...options.level ? {
-        level: options.level
-      } : {},
-      markDefs: [],
-      children: [{
-        _type: "span",
-        _key: editorActor.getSnapshot().context.keyGenerator(),
-        text: "",
-        marks: options.decorators.filter((decorator) => schemaTypes.decorators.find(({
-          value
-        }) => value === decorator))
-      }]
-    }], {
-      schemaTypes
-    })[0], editor;
-  };
-}
-const withPlugins = (editor, options) => {
-  const e = editor, {
-    editorActor
-  } = options, schemaTypes = editorActor.getSnapshot().context.schema, operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
-    editorActor,
-    schemaTypes
-  }), withPatches = createWithPatches({
-    editorActor,
-    patchFunctions: operationToPatches,
-    schemaTypes,
-    subscriptions: options.subscriptions
-  }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
-    editorActor,
-    blockSchemaType: schemaTypes.block,
-    subscriptions: options.subscriptions
-  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
-    editorActor,
-    schemaTypes
-  }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
-  return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
-}, debug$3 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
-function createSlateEditor(config) {
-  const existingSlateEditor = slateEditors.get(config.editorActor);
-  if (existingSlateEditor)
-    return debug$3("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
-  debug$3("Creating new Slate editor instance", config.editorActor.id);
-  const unsubscriptions = [], subscriptions = [], instance = withPlugins(slateReact.withReact(slate.createEditor()), {
-    editorActor: config.editorActor,
-    subscriptions
-  });
-  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {});
-  for (const subscription of subscriptions)
-    unsubscriptions.push(subscription());
-  const initialValue = [instance.pteCreateTextBlock({
-    decorators: []
-  })], slateEditor = {
-    instance,
-    initialValue
+      if (op.type === "remove_text") {
+        const {
+          selection
+        } = editor;
+        if (selection && slate.Range.isExpanded(selection)) {
+          const [block, blockPath] = slate.Editor.node(editor, selection, {
+            depth: 1
+          }), [span, spanPath] = Array.from(slate.Editor.nodes(editor, {
+            mode: "lowest",
+            at: {
+              path: op.path,
+              offset: op.offset
+            },
+            match: (n) => editor.isTextSpan(n),
+            voids: !1
+          }))[0] ?? [void 0, void 0];
+          if (span && block && isPortableTextBlock(block)) {
+            const markDefs = block.markDefs ?? [], marks = span.marks ?? [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
+              editor,
+              blockPath,
+              spanPath
+            }), nextSpan = getNextSpan({
+              editor,
+              blockPath,
+              spanPath
+            }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
+            if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
+              const marksWithoutAnnotationMarks = ({
+                ...slate.Editor.marks(editor) || {}
+              }.marks || []).filter((mark) => decorators.includes(mark));
+              slate.Editor.withoutNormalizing(editor, () => {
+                apply2(op), slate.Transforms.setNodes(editor, {
+                  marks: marksWithoutAnnotationMarks
+                }, {
+                  at: op.path
+                });
+              }), editor.onChange();
+              return;
+            }
+          }
+        }
+      }
+      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
+        const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
+        if (editor.isTextBlock(targetBlock)) {
+          const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
+          debug$9("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
+            markDefs: newMarkDefs
+          }, {
+            at: targetPath,
+            voids: !1
+          }), apply2(op);
+          return;
+        }
+      }
+      apply2(op);
+    }, editor;
   };
-  return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const toggleListItemActionImplementation = ({
-  context,
+const removeDecoratorActionImplementation = ({
   action
 }) => {
-  isListItemActive({
-    editor: action.editor,
-    listItem: action.listItem
-  }) ? removeListItemActionImplementation({
-    context,
-    action: {
-      ...action,
-      type: "list item.remove"
+  const editor = action.editor, mark = action.decorator, {
+    selection
+  } = editor;
+  if (selection) {
+    if (slate.Range.isExpanded(selection))
+      slate.Transforms.setNodes(editor, {}, {
+        match: slate.Text.isText,
+        split: !0,
+        hanging: !0
+      }), editor.selection && [...slate.Editor.nodes(editor, {
+        at: editor.selection,
+        match: slate.Text.isText
+      })].forEach(([node, path]) => {
+        const block = editor.children[path[0]];
+        slate.Element.isElement(block) && block.children.includes(node) && slate.Transforms.setNodes(editor, {
+          marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
+          _type: "span"
+        }, {
+          at: path
+        });
+      });
+    else {
+      const [block, blockPath] = slate.Editor.node(editor, selection, {
+        depth: 1
+      }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+      if (lonelyEmptySpan) {
+        const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
+        slate.Transforms.setNodes(editor, {
+          marks: existingMarksWithoutDecorator
+        }, {
+          at: blockPath,
+          match: (node) => editor.isTextSpan(node)
+        });
+      } else {
+        const existingMarks = {
+          ...slate.Editor.marks(editor) || {}
+        }.marks || [], marks = {
+          ...slate.Editor.marks(editor) || {},
+          marks: existingMarks.filter((eMark) => eMark !== mark)
+        };
+        editor.marks = {
+          marks: marks.marks,
+          _type: "span"
+        };
+      }
     }
-  }) : addListItemActionImplementation({
-    context,
-    action: {
-      ...action,
-      type: "list item.add"
+    if (editor.selection) {
+      const selection2 = editor.selection;
+      editor.selection = {
+        ...selection2
+      };
     }
-  });
-}, removeListItemActionImplementation = ({
-  context,
-  action
-}) => {
-  if (!action.editor.selection)
-    return;
-  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
-    at: action.editor.selection,
-    match: (node) => guards.isListBlock(node)
-  })];
-  for (const [, at] of selectedBlocks)
-    slate.Transforms.unsetNodes(action.editor, ["listItem", "level"], {
-      at
-    });
-}, addListItemActionImplementation = ({
-  context,
-  action
-}) => {
-  if (!action.editor.selection)
-    return;
-  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
-    at: action.editor.selection,
-    match: (node) => guards.isTextBlock(node)
-  })];
-  for (const [, at] of selectedBlocks)
-    slate.Transforms.setNodes(action.editor, {
-      level: 1,
-      listItem: action.listItem
-    }, {
-      at
-    });
+  }
 };
-function isListItemActive({
+function isDecoratorActive({
   editor,
-  listItem
+  decorator
 }) {
   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;
+  const selectedTextNodes = Array.from(slate.Editor.nodes(editor, {
+    match: slate.Text.isText,
+    at: editor.selection
+  }));
+  return selectedTextNodes.length === 0 ? !1 : slate.Range.isExpanded(editor.selection) ? selectedTextNodes.every((n) => {
+    const [node] = n;
+    return node.marks?.includes(decorator);
+  }) : ({
+    ...slate.Editor.marks(editor) || {}
+  }.marks || []).includes(decorator);
 }
-const toggleStyleActionImplementation = ({
+const toggleDecoratorActionImplementation = ({
   context,
   action
 }) => {
-  isStyleActive({
+  isDecoratorActive({
     editor: action.editor,
-    style: action.style
-  }) ? removeStyleActionImplementation({
+    decorator: action.decorator
+  }) ? removeDecoratorActionImplementation({
     context,
     action: {
-      ...action,
-      type: "style.remove"
+      type: "decorator.remove",
+      editor: action.editor,
+      decorator: action.decorator
     }
-  }) : addStyleActionImplementation({
+  }) : decoratorAddActionImplementation({
     context,
     action: {
-      ...action,
-      type: "style.add"
+      type: "decorator.add",
+      editor: action.editor,
+      decorator: action.decorator
     }
   });
-}, removeStyleActionImplementation = ({
-  context,
-  action
-}) => {
-  if (!action.editor.selection)
-    return;
-  const defaultStyle = context.schema.styles[0].value, guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
-    at: action.editor.selection,
-    match: (node) => guards.isTextBlock(node)
-  })];
-  for (const [, at] of selectedBlocks)
-    slate.Transforms.setNodes(action.editor, {
-      style: defaultStyle
-    }, {
-      at
-    });
-}, addStyleActionImplementation = ({
-  context,
-  action
-}) => {
-  if (!action.editor.selection)
-    return;
-  const guards = selector_isAtTheStartOfBlock.createGuards(context), selectedBlocks = [...slate.Editor.nodes(action.editor, {
-    at: action.editor.selection,
-    match: (node) => guards.isTextBlock(node)
-  })];
-  for (const [, at] of selectedBlocks)
-    slate.Transforms.setNodes(action.editor, {
-      style: action.style
-    }, {
-      at
-    });
-};
-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;
-}
-const debug$2 = debugWithName("API:editable");
+}, debug$8 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -4296,8 +3505,24 @@ function createEditableAPI(editor, editorActor) {
     marks: () => ({
       ...slate.Editor.marks(editor) || {}
     }).marks || [],
-    undo: () => editor.undo(),
-    redo: () => editor.redo(),
+    undo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.undo"
+        },
+        editor
+      });
+    },
+    redo: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.redo"
+        },
+        editor
+      });
+    },
     select: (selection) => {
       const slateSelection = toSlateRange(selection, editor);
       slateSelection ? slate.Transforms.select(editor, slateSelection) : slate.Transforms.deselect(editor), editor.onChange();
@@ -4350,7 +3575,7 @@ function createEditableAPI(editor, editorActor) {
       }], {
         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({
+      return isSpanNode && focusNode._type !== types2.span.name && (debug$8("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), slate.Transforms.insertNodes(editor, child, {
@@ -4488,18 +3713,18 @@ function createEditableAPI(editor, editorActor) {
           throw new Error("Invalid range");
         if (range) {
           if (!options?.mode || options?.mode === "selected") {
-            debug$2("Deleting content in selection"), slate.Transforms.delete(editor, {
+            debug$8("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, {
+          options?.mode === "blocks" && (debug$8("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, {
+          })), options?.mode === "children" && (debug$8("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types2.span.name || // Text children
@@ -4626,7 +3851,7 @@ const addAnnotationActionImplementation = ({
   action
 }) => {
   const editor = action.editor;
-  if (debug$2("Removing annotation", action.annotation.name), !!editor.selection)
+  if (debug$8("Removing annotation", action.annotation.name), !!editor.selection)
     if (slate.Range.isCollapsed(editor.selection)) {
       const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
         depth: 1
@@ -4796,17 +4021,48 @@ const blockSetBehaviorActionImplementation = ({
   location && slate.Transforms.unsetNodes(action.editor, action.props, {
     at: location
   });
-}, dataTransferSetActionImplementation = ({
-  action
-}) => {
-  action.dataTransfer.setData(action.mimeType, action.data);
-}, deleteActionImplementation = ({
-  action
-}) => {
-  const range = toSlateRange(action.selection, action.editor);
+}, dataTransferSetActionImplementation = ({
+  action
+}) => {
+  action.dataTransfer.setData(action.mimeType, action.data);
+}, deleteActionImplementation = ({
+  action
+}) => {
+  const range = toSlateRange(action.selection, action.editor);
+  if (!range)
+    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`);
+  slate.select(action.editor, range), slate.deleteFragment(action.editor);
+}, deleteTextActionImplementation = ({
+  context,
+  action
+}) => {
+  const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), selection = util_blockOffsetsToSelection.blockOffsetsToSelection({
+    value,
+    offsets: {
+      anchor: action.anchor,
+      focus: action.focus
+    }
+  });
+  if (!selection)
+    throw new Error("Unable to find selection from block offsets");
+  const trimmedSelection = selector_getTrimmedSelection.getTrimmedSelection({
+    context: {
+      converters: [],
+      schema: context.schema,
+      keyGenerator: context.keyGenerator,
+      activeDecorators: [],
+      value,
+      selection
+    }
+  });
+  if (!trimmedSelection)
+    throw new Error("Unable to find trimmed selection");
+  const range = toSlateRange(trimmedSelection, action.editor);
   if (!range)
-    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`);
-  slate.select(action.editor, range), slate.deleteFragment(action.editor);
+    throw new Error("Unable to find Slate range from trimmed selection");
+  slate.Transforms.delete(action.editor, {
+    at: range
+  });
 }, insertBlockObjectActionImplementation = ({
   context,
   action
@@ -4922,7 +4178,7 @@ const blockSetBehaviorActionImplementation = ({
   context,
   action
 }) => {
-  const parsedBlock = parseBlocks.parseBlock({
+  const parsedBlock = util_blockOffsetsToSelection.parseBlock({
     block: action.block,
     context,
     options: {
@@ -4996,7 +4252,7 @@ const blockSetBehaviorActionImplementation = ({
     slateReact.ReactEditor.blur(action.editor);
   },
   "data transfer.set": dataTransferSetActionImplementation,
-  "decorator.add": addDecoratorActionImplementation,
+  "decorator.add": decoratorAddActionImplementation,
   "decorator.remove": removeDecoratorActionImplementation,
   "decorator.toggle": toggleDecoratorActionImplementation,
   focus: ({
@@ -5036,33 +4292,7 @@ const blockSetBehaviorActionImplementation = ({
       at: range
     });
   },
-  "delete.text": ({
-    context,
-    action
-  }) => {
-    const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), anchor = util_reverseSelection.blockOffsetToSpanSelectionPoint({
-      value,
-      blockOffset: action.anchor
-    }), focus = util_reverseSelection.blockOffsetToSpanSelectionPoint({
-      value,
-      blockOffset: action.focus
-    });
-    if (!anchor || !focus) {
-      console.error("Unable to find anchor or focus selection point");
-      return;
-    }
-    const range = toSlateRange({
-      anchor,
-      focus
-    }, action.editor);
-    if (!range) {
-      console.error("Unable to find Slate range from selection points");
-      return;
-    }
-    slate.Transforms.delete(action.editor, {
-      at: range
-    });
-  },
+  "delete.text": deleteTextActionImplementation,
   "deserialization.failure": ({
     action
   }) => {
@@ -5081,6 +4311,8 @@ const blockSetBehaviorActionImplementation = ({
       }
     });
   },
+  "history.redo": historyRedoActionImplementation,
+  "history.undo": historyUndoActionImplementation,
   "insert.block": insertBlockActionImplementation,
   "insert.blocks": insertBlocksActionImplementation,
   "insert.block object": insertBlockObjectActionImplementation,
@@ -5369,6 +4601,20 @@ function performDefaultAction({
       });
       break;
     }
+    case "history.redo": {
+      behaviorActionImplementations["history.redo"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "history.undo": {
+      behaviorActionImplementations["history.undo"]({
+        context,
+        action
+      });
+      break;
+    }
     case "insert.block": {
       behaviorActionImplementations["insert.block"]({
         context,
@@ -5500,49 +4746,942 @@ function performDefaultAction({
         context,
         action
       });
-      break;
-    }
-    case "serialization.success": {
-      behaviorActionImplementations["serialization.success"]({
-        context,
-        action
+      break;
+    }
+    case "serialization.success": {
+      behaviorActionImplementations["serialization.success"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "style.add": {
+      behaviorActionImplementations["style.add"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "style.remove": {
+      behaviorActionImplementations["style.remove"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "style.toggle": {
+      behaviorActionImplementations["style.toggle"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "text block.set": {
+      behaviorActionImplementations["text block.set"]({
+        context,
+        action
+      });
+      break;
+    }
+    default:
+      behaviorActionImplementations["text block.unset"]({
+        context,
+        action
+      });
+  }
+}
+function createWithEventListeners(editorActor, subscriptions) {
+  return function(editor) {
+    if (editorActor.getSnapshot().context.maxBlocks !== void 0)
+      return editor;
+    subscriptions.push(() => {
+      const subscription = editorActor.on("*", (event) => {
+        switch (event.type) {
+          // These events are not relevant for Behaviors
+          case "blurred":
+          case "done loading":
+          case "editable":
+          case "error":
+          case "focused":
+          case "invalid value":
+          case "loading":
+          case "mutation":
+          case "patch":
+          case "patches":
+          case "read only":
+          case "ready":
+          case "selection":
+          case "value changed":
+          case "unset":
+            break;
+          case "custom.*":
+            editorActor.send({
+              type: "custom behavior event",
+              behaviorEvent: event.event,
+              editor
+            });
+            break;
+          default:
+            editorActor.send({
+              type: "behavior event",
+              behaviorEvent: event,
+              editor
+            });
+            break;
+        }
+      });
+      return () => {
+        subscription.unsubscribe();
+      };
+    });
+    const {
+      deleteBackward,
+      deleteForward,
+      insertBreak,
+      insertData,
+      insertText,
+      select,
+      setFragmentData
+    } = editor;
+    return editor.deleteBackward = (unit) => {
+      if (isApplyingBehaviorActions(editor)) {
+        deleteBackward(unit);
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "delete.backward",
+          unit
+        },
+        editor
+      });
+    }, editor.deleteForward = (unit) => {
+      if (isApplyingBehaviorActions(editor)) {
+        deleteForward(unit);
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "delete.forward",
+          unit
+        },
+        editor
+      });
+    }, editor.insertBreak = () => {
+      if (isApplyingBehaviorActions(editor)) {
+        insertBreak();
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.break"
+        },
+        editor
+      });
+    }, editor.insertData = (dataTransfer) => {
+      if (isApplyingBehaviorActions(editor)) {
+        insertData(dataTransfer);
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "deserialize",
+          dataTransfer
+        },
+        editor
+      });
+    }, editor.insertSoftBreak = () => {
+      if (isApplyingBehaviorActions(editor)) {
+        insertSoftBreakActionImplementation({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: editorActor.getSnapshot().context.schema
+          },
+          action: {
+            type: "insert.soft break",
+            editor
+          }
+        });
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.soft break"
+        },
+        editor
+      });
+    }, editor.insertText = (text, options) => {
+      if (isApplyingBehaviorActions(editor)) {
+        insertText(text, options);
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.text",
+          text,
+          options
+        },
+        editor,
+        defaultActionCallback: () => {
+          insertText(text, options);
+        }
+      });
+    }, editor.redo = () => {
+      if (isApplyingBehaviorActions(editor)) {
+        performAction({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: editorActor.getSnapshot().context.schema
+          },
+          action: {
+            type: "history.redo",
+            editor
+          }
+        });
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.redo"
+        },
+        editor
+      });
+    }, editor.select = (location) => {
+      if (isApplyingBehaviorActions(editor)) {
+        select(location);
+        return;
+      }
+      const range = slate.Editor.range(editor, location);
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "select",
+          selection: toPortableTextRange(fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), range, editorActor.getSnapshot().context.schema)
+        },
+        editor,
+        defaultActionCallback: () => {
+          select(location);
+        }
+      });
+    }, editor.setFragmentData = (dataTransfer, originEvent) => {
+      if (originEvent === "drag") {
+        setFragmentData(dataTransfer);
+        return;
+      }
+      if (isApplyingBehaviorActions(editor)) {
+        setFragmentData(dataTransfer);
+        return;
+      }
+      dataTransfer.clearData(), editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "serialize",
+          dataTransfer,
+          originEvent: originEvent ?? "unknown"
+        },
+        editor
       });
-      break;
+    }, editor.undo = () => {
+      if (isApplyingBehaviorActions(editor)) {
+        performAction({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: editorActor.getSnapshot().context.schema
+          },
+          action: {
+            type: "history.undo",
+            editor
+          }
+        });
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "history.undo"
+        },
+        editor
+      });
+    }, editor;
+  };
+}
+function createWithMaxBlocks(editorActor) {
+  return function(editor) {
+    const {
+      apply: apply2
+    } = editor;
+    return editor.apply = (operation) => {
+      if (editorActor.getSnapshot().matches({
+        "edit mode": "read only"
+      })) {
+        apply2(operation);
+        return;
+      }
+      if (isChangingRemotely(editor)) {
+        apply2(operation);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(operation);
+        return;
+      }
+      const rows = editorActor.getSnapshot().context.maxBlocks ?? -1;
+      rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
+    }, editor;
+  };
+}
+function createWithObjectKeys(editorActor, schemaTypes) {
+  return function(editor) {
+    const {
+      apply: apply2,
+      normalizeNode
+    } = editor;
+    return editor.apply = (operation) => {
+      if (isChangingRemotely(editor)) {
+        apply2(operation);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(operation);
+        return;
+      }
+      if (operation.type === "split_node") {
+        const existingKeys = [...slate.Node.descendants(editor)].map(([node]) => node._key);
+        apply2({
+          ...operation,
+          properties: {
+            ...operation.properties,
+            _key: operation.properties._key === void 0 || existingKeys.includes(operation.properties._key) ? editorActor.getSnapshot().context.keyGenerator() : operation.properties._key
+          }
+        });
+        return;
+      }
+      if (operation.type === "insert_node" && !slate.Editor.isEditor(operation.node)) {
+        const existingKeys = [...slate.Node.descendants(editor)].map(([node]) => node._key);
+        apply2({
+          ...operation,
+          node: {
+            ...operation.node,
+            _key: operation.node._key === void 0 || existingKeys.includes(operation.node._key) ? editorActor.getSnapshot().context.keyGenerator() : operation.node._key
+          }
+        });
+        return;
+      }
+      apply2(operation);
+    }, editor.normalizeNode = (entry) => {
+      const [node, path] = entry;
+      if (slate.Element.isElement(node) && node._type === schemaTypes.block.name) {
+        if (!node._key) {
+          editorActor.send({
+            type: "normalizing"
+          }), slate.Transforms.setNodes(editor, {
+            _key: editorActor.getSnapshot().context.keyGenerator()
+          }, {
+            at: path
+          }), editorActor.send({
+            type: "done normalizing"
+          });
+          return;
+        }
+        for (const [child, childPath] of slate.Node.children(editor, path))
+          if (!child._key) {
+            editorActor.send({
+              type: "normalizing"
+            }), slate.Transforms.setNodes(editor, {
+              _key: editorActor.getSnapshot().context.keyGenerator()
+            }, {
+              at: childPath
+            }), editorActor.send({
+              type: "done normalizing"
+            });
+            return;
+          }
+      }
+      normalizeNode(entry);
+    }, editor;
+  };
+}
+const debug$7 = debugWithName("applyPatches"), debugVerbose = debug$7.enabled && !0;
+function createApplyPatch(schemaTypes) {
+  return (editor, patch) => {
+    let changed = !1;
+    debugVerbose && (debug$7(`
+
+NEW PATCH =============================================================`), debug$7(JSON.stringify(patch, null, 2)));
+    try {
+      switch (patch.type) {
+        case "insert":
+          changed = insertPatch(editor, patch, schemaTypes);
+          break;
+        case "unset":
+          changed = unsetPatch(editor, patch);
+          break;
+        case "set":
+          changed = setPatch(editor, patch);
+          break;
+        case "diffMatchPatch":
+          changed = diffMatchPatch(editor, patch);
+          break;
+        default:
+          debug$7("Unhandled patch", patch.type);
+      }
+    } catch (err) {
+      console.error(err);
     }
-    case "style.add": {
-      behaviorActionImplementations["style.add"]({
-        context,
-        action
+    return changed;
+  };
+}
+function diffMatchPatch(editor, patch) {
+  const {
+    block,
+    child,
+    childPath
+  } = findBlockAndChildFromPath(editor, patch.path);
+  if (!block)
+    return debug$7("Block not found"), !1;
+  if (!child || !childPath)
+    return debug$7("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, {
+    allowExceedingIndices: !0
+  }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
+  debugState(editor, "before");
+  let offset = 0;
+  for (const [op, text] of diff$1)
+    op === DIFF_INSERT ? (editor.apply({
+      type: "insert_text",
+      path: childPath,
+      offset,
+      text
+    }), offset += text.length) : op === DIFF_DELETE ? editor.apply({
+      type: "remove_text",
+      path: childPath,
+      offset,
+      text
+    }) : op === DIFF_EQUAL && (offset += text.length);
+  return debugState(editor, "after"), !0;
+}
+function insertPatch(editor, patch, schemaTypes) {
+  const {
+    block: targetBlock,
+    child: targetChild,
+    blockPath: targetBlockPath,
+    childPath: targetChildPath
+  } = findBlockAndChildFromPath(editor, patch.path);
+  if (!targetBlock || !targetBlockPath)
+    return debug$7("Block not found"), !1;
+  if (patch.path.length > 1 && patch.path[1] !== "children")
+    return debug$7("Ignoring patch targeting void value"), !1;
+  if (patch.path.length === 1) {
+    const {
+      items: items2,
+      position: position2
+    } = patch, blocksToInsert = toSlateValue(items2, {
+      schemaTypes
+    }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
+    return debug$7(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
+      at: [normalizedIdx2]
+    }), debugState(editor, "after"), !0;
+  }
+  const {
+    items,
+    position
+  } = patch;
+  if (!targetChild || !targetChildPath)
+    return debug$7("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$7(`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;
+}
+function setPatch(editor, patch) {
+  let value = patch.value;
+  typeof patch.path[3] == "string" && (value = {}, value[patch.path[3]] = patch.value);
+  const {
+    block,
+    blockPath,
+    child,
+    childPath
+  } = findBlockAndChildFromPath(editor, patch.path);
+  if (!block)
+    return debug$7("Block not found"), !1;
+  const isTextBlock = editor.isTextBlock(block);
+  if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
+    return debug$7("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$7("Setting text property"), editor.apply({
+        type: "remove_text",
+        path: childPath,
+        offset: 0,
+        text: newText
+      }), editor.apply({
+        type: "insert_text",
+        path: childPath,
+        offset: 0,
+        text: value.text
+      }), editor.onChange());
+    } else
+      debug$7("Setting non-text property"), editor.apply({
+        type: "set_node",
+        path: childPath,
+        properties: {},
+        newProperties: value
       });
-      break;
-    }
-    case "style.remove": {
-      behaviorActionImplementations["style.remove"]({
-        context,
-        action
+    return !0;
+  } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
+    debug$7("Setting block property");
+    const {
+      children,
+      ...nextRest
+    } = value, {
+      children: prevChildren,
+      ...prevRest
+    } = block || {
+      children: void 0
+    };
+    editor.apply({
+      type: "set_node",
+      path: blockPath,
+      properties: {
+        ...prevRest
+      },
+      newProperties: nextRest
+    }), debug$7("Setting children"), block.children.forEach((c, cIndex) => {
+      editor.apply({
+        type: "remove_node",
+        path: blockPath.concat(block.children.length - 1 - cIndex),
+        node: c
       });
-      break;
-    }
-    case "style.toggle": {
-      behaviorActionImplementations["style.toggle"]({
-        context,
-        action
+    }), Array.isArray(children) && children.forEach((c, cIndex) => {
+      editor.apply({
+        type: "insert_node",
+        path: blockPath.concat(cIndex),
+        node: c
       });
-      break;
-    }
-    case "text block.set": {
-      behaviorActionImplementations["text block.set"]({
-        context,
-        action
+    });
+  } else if (block && "value" in block)
+    if (patch.path.length > 1 && patch.path[1] !== "children") {
+      const newVal = patches.applyAll(block.value, [{
+        ...patch,
+        path: patch.path.slice(1)
+      }]);
+      slate.Transforms.setNodes(editor, {
+        ...block,
+        value: newVal
+      }, {
+        at: blockPath
       });
-      break;
-    }
-    default:
-      behaviorActionImplementations["text block.unset"]({
-        context,
-        action
+    } else
+      return !1;
+  return debugState(editor, "after"), !0;
+}
+function unsetPatch(editor, patch) {
+  if (patch.path.length === 0) {
+    debug$7("Removing everything"), debugState(editor, "before");
+    const previousSelection = editor.selection;
+    return slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
+      slate.Transforms.removeNodes(editor, {
+        at: [i]
       });
+    }), slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({
+      decorators: []
+    })), previousSelection && slate.Transforms.select(editor, {
+      anchor: {
+        path: [0, 0],
+        offset: 0
+      },
+      focus: {
+        path: [0, 0],
+        offset: 0
+      }
+    }), editor.onChange(), debugState(editor, "after"), !0;
+  }
+  const {
+    block,
+    blockPath,
+    child,
+    childPath
+  } = findBlockAndChildFromPath(editor, patch.path);
+  if (patch.path.length === 1) {
+    if (!block || !blockPath)
+      return debug$7("Block not found"), !1;
+    const blockIndex = blockPath[0];
+    return debug$7(`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$7("Child not found"), !1) : (debug$7(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$7(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
+    at: childPath
+  }), debugState(editor, "after"), !0) : !1;
+}
+function isKeyedSegment(segment) {
+  return typeof segment == "object" && "_key" in segment;
+}
+function debugState(editor, stateName) {
+  debugVerbose && (debug$7(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$7(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+}
+function findBlockFromPath(editor, path) {
+  let blockIndex = -1;
+  const block = editor.children.find((node, index) => {
+    const isMatch = isKeyedSegment(path[0]) ? node._key === path[0]._key : index === path[0];
+    return isMatch && (blockIndex = index), isMatch;
+  });
+  return block ? {
+    block,
+    path: [blockIndex]
+  } : {};
+}
+function findBlockAndChildFromPath(editor, path) {
+  const {
+    block,
+    path: blockPath
+  } = findBlockFromPath(editor, path);
+  if (!(slate.Element.isElement(block) && path[1] === "children"))
+    return {
+      block,
+      blockPath,
+      child: void 0,
+      childPath: void 0
+    };
+  let childIndex = -1;
+  const child = block.children.find((node, index) => {
+    const isMatch = isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2];
+    return isMatch && (childIndex = index), isMatch;
+  });
+  return child ? {
+    block,
+    child,
+    blockPath,
+    childPath: blockPath?.concat(childIndex)
+  } : {
+    block,
+    blockPath,
+    child: void 0,
+    childPath: void 0
+  };
+}
+const debug$6 = debugWithName("plugin:withPatches");
+function createWithPatches({
+  editorActor,
+  patchFunctions,
+  schemaTypes,
+  subscriptions
+}) {
+  let previousChildren;
+  const applyPatch = createApplyPatch(schemaTypes);
+  return function(editor) {
+    IS_PROCESSING_REMOTE_CHANGES.set(editor, !1), PATCHING.set(editor, !0), previousChildren = [...editor.children];
+    const {
+      apply: apply2
+    } = editor;
+    let bufferedPatches = [];
+    const handleBufferedRemotePatches = () => {
+      if (bufferedPatches.length === 0)
+        return;
+      const patches2 = bufferedPatches;
+      bufferedPatches = [];
+      let changed = !1;
+      withRemoteChanges(editor, () => {
+        slate.Editor.withoutNormalizing(editor, () => {
+          withoutPatching(editor, () => {
+            withoutSaving(editor, () => {
+              patches2.forEach((patch) => {
+                debug$6.enabled && debug$6(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+              });
+            });
+          });
+        }), changed && (editor.normalize(), editor.onChange());
+      });
+    }, handlePatches = ({
+      patches: patches2
+    }) => {
+      const remotePatches = patches2.filter((p) => p.origin !== "local");
+      remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
+    };
+    return subscriptions.push(() => {
+      debug$6("Subscribing to remote patches");
+      const sub = editorActor.on("patches", handlePatches);
+      return () => {
+        debug$6("Unsubscribing to remote patches"), sub.unsubscribe();
+      };
+    }), editor.apply = (operation) => {
+      let patches$1 = [];
+      previousChildren = editor.children;
+      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes);
+      apply2(operation);
+      const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes);
+      if (!isPatching(editor))
+        return editor;
+      switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches$1.push(patches.insert(previousChildren, "before", [0])), operation.type) {
+        case "insert_text":
+          patches$1 = [...patches$1, ...patchFunctions.insertTextPatch(editor, operation, previousChildren)];
+          break;
+        case "remove_text":
+          patches$1 = [...patches$1, ...patchFunctions.removeTextPatch(editor, operation, previousChildren)];
+          break;
+        case "remove_node":
+          patches$1 = [...patches$1, ...patchFunctions.removeNodePatch(editor, operation, previousChildren)];
+          break;
+        case "split_node":
+          patches$1 = [...patches$1, ...patchFunctions.splitNodePatch(editor, operation, previousChildren)];
+          break;
+        case "insert_node":
+          patches$1 = [...patches$1, ...patchFunctions.insertNodePatch(editor, operation, previousChildren)];
+          break;
+        case "set_node":
+          patches$1 = [...patches$1, ...patchFunctions.setNodePatch(editor, operation, previousChildren)];
+          break;
+        case "merge_node":
+          patches$1 = [...patches$1, ...patchFunctions.mergeNodePatch(editor, operation, previousChildren)];
+          break;
+        case "move_node":
+          patches$1 = [...patches$1, ...patchFunctions.moveNodePatch(editor, operation, previousChildren)];
+          break;
+      }
+      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches$1 = [...patches$1, patches.unset([])], editorActor.send({
+        type: "notify.unset",
+        previousValue: fromSlateValue(previousChildren, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+      })), editorWasEmpty && patches$1.length > 0 && (patches$1 = [patches.setIfMissing([], []), ...patches$1]), patches$1.length > 0 && patches$1.forEach((patch) => {
+        editorActor.send({
+          type: "patch",
+          patch: {
+            ...patch,
+            origin: "local"
+          }
+        });
+      }), editor;
+    }, editor;
+  };
+}
+const debug$5 = debugWithName("plugin:withPlaceholderBlock");
+function createWithPlaceholderBlock(editorActor) {
+  return function(editor) {
+    const {
+      apply: apply2
+    } = editor;
+    return editor.apply = (op) => {
+      if (editorActor.getSnapshot().matches({
+        "edit mode": "read only"
+      })) {
+        apply2(op);
+        return;
+      }
+      if (isChangingRemotely(editor)) {
+        apply2(op);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(op);
+        return;
+      }
+      if (op.type === "remove_node") {
+        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$5("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+            decorators: []
+          })));
+        }
+      }
+      apply2(op);
+    }, editor;
+  };
+}
+const debug$4 = debugWithName("plugin:withPortableTextBlockStyle");
+function createWithPortableTextBlockStyle(editorActor, types2) {
+  const defaultStyle = types2.styles[0].value;
+  return function(editor) {
+    const {
+      normalizeNode
+    } = editor;
+    return editor.normalizeNode = (nodeEntry) => {
+      const [, path] = nodeEntry;
+      for (const op of editor.operations)
+        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$4(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+              type: "normalizing"
+            }), slate.Transforms.setNodes(editor, {
+              style: defaultStyle
+            }, {
+              at: [op.path[0] + 1],
+              voids: !1
+            }), editorActor.send({
+              type: "done normalizing"
+            });
+            return;
+          }
+        }
+      normalizeNode(nodeEntry);
+    }, editor;
+  };
+}
+debugWithName("plugin:withPortableTextSelections");
+function createWithPortableTextSelections(editorActor, types2) {
+  let prevSelection = null;
+  return function(editor) {
+    const emitPortableTextSelection = () => {
+      if (prevSelection !== editor.selection) {
+        let ptRange = null;
+        if (editor.selection) {
+          const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
+          if (existing)
+            ptRange = existing;
+          else {
+            const value = editor.children;
+            ptRange = toPortableTextRange(value, editor.selection, types2), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+          }
+        }
+        ptRange ? editorActor.send({
+          type: "notify.selection",
+          selection: ptRange
+        }) : editorActor.send({
+          type: "notify.selection",
+          selection: null
+        });
+      }
+      prevSelection = editor.selection;
+    }, {
+      onChange
+    } = editor;
+    return editor.onChange = () => {
+      onChange(), editorActor.getSnapshot().matches({
+        setup: "setting up"
+      }) || emitPortableTextSelection();
+    }, editor;
+  };
+}
+const debug$3 = debugWithName("plugin:withSchemaTypes");
+function createWithSchemaTypes({
+  editorActor,
+  schemaTypes
+}) {
+  return function(editor) {
+    editor.isTextBlock = (value) => types.isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => types.isPortableTextSpan(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => types.isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
+    const {
+      normalizeNode
+    } = editor;
+    return editor.normalizeNode = (entry) => {
+      const [node, path] = entry;
+      if (node._type === void 0 && path.length === 2) {
+        debug$3("Setting span type on text node without a type");
+        const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
+        editorActor.send({
+          type: "normalizing"
+        }), slate.Transforms.setNodes(editor, {
+          ...span,
+          _type: schemaTypes.span.name,
+          _key: key
+        }, {
+          at: path
+        }), editorActor.send({
+          type: "done normalizing"
+        });
+        return;
+      }
+      if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
+        debug$3("Setting missing key on child node without a key");
+        const key = editorActor.getSnapshot().context.keyGenerator();
+        editorActor.send({
+          type: "normalizing"
+        }), slate.Transforms.setNodes(editor, {
+          _key: key
+        }, {
+          at: path
+        }), editorActor.send({
+          type: "done normalizing"
+        });
+        return;
+      }
+      normalizeNode(entry);
+    }, editor;
+  };
+}
+function createWithUtils({
+  editorActor,
+  schemaTypes
+}) {
+  return function(editor) {
+    return editor.pteCreateTextBlock = (options) => toSlateValue([{
+      _type: schemaTypes.block.name,
+      _key: editorActor.getSnapshot().context.keyGenerator(),
+      style: schemaTypes.styles[0].value || "normal",
+      ...options.listItem ? {
+        listItem: options.listItem
+      } : {},
+      ...options.level ? {
+        level: options.level
+      } : {},
+      markDefs: [],
+      children: [{
+        _type: "span",
+        _key: editorActor.getSnapshot().context.keyGenerator(),
+        text: "",
+        marks: options.decorators.filter((decorator) => schemaTypes.decorators.find(({
+          value
+        }) => value === decorator))
+      }]
+    }], {
+      schemaTypes
+    })[0], editor;
+  };
+}
+const withPlugins = (editor, options) => {
+  const e = editor, {
+    editorActor
+  } = options, schemaTypes = editorActor.getSnapshot().context.schema, operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
+    editorActor,
+    schemaTypes
+  }), withPatches = createWithPatches({
+    editorActor,
+    patchFunctions: operationToPatches,
+    schemaTypes,
+    subscriptions: options.subscriptions
+  }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
+    editorActor,
+    blockSchemaType: schemaTypes.block,
+    subscriptions: options.subscriptions
+  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
+    editorActor,
+    schemaTypes
+  }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
+  return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
+}, debug$2 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
+function createSlateEditor(config) {
+  const existingSlateEditor = slateEditors.get(config.editorActor);
+  if (existingSlateEditor)
+    return debug$2("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
+  debug$2("Creating new Slate editor instance", config.editorActor.id);
+  const unsubscriptions = [], subscriptions = [], instance = withPlugins(slateReact.withReact(slate.createEditor()), {
+    editorActor: config.editorActor,
+    subscriptions
+  });
+  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {});
+  for (const subscription of subscriptions)
+    unsubscriptions.push(subscription());
+  const initialValue = [instance.pteCreateTextBlock({
+    decorators: []
+  })], slateEditor = {
+    instance,
+    initialValue
+  };
+  return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
 const keyIs = {
   lineBreak: (event) => event.key === "Enter" && event.shiftKey
@@ -5666,29 +5805,25 @@ const editorMachine = xstate.setup({
       if (eventBehaviors.length === 0) {
         if (defaultActionCallback) {
           withApplyingBehaviorActions(event.editor, () => {
-            slate.Editor.withoutNormalizing(event.editor, () => {
-              try {
-                defaultActionCallback();
-              } catch (error) {
-                console.error(new Error(`Performing action "${event.behaviorEvent.type}" failed due to: ${error.message}`));
-              }
-            });
+            try {
+              defaultActionCallback();
+            } catch (error) {
+              console.error(new Error(`Performing action "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+            }
           });
           return;
         }
         if (!defaultAction)
           return;
         withApplyingBehaviorActions(event.editor, () => {
-          slate.Editor.withoutNormalizing(event.editor, () => {
-            try {
-              performAction({
-                context,
-                action: defaultAction
-              });
-            } catch (error) {
-              console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
-            }
-          });
+          try {
+            performAction({
+              context,
+              action: defaultAction
+            });
+          } catch (error) {
+            console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+          }
         }), event.editor.onChange();
         return;
       }
@@ -5711,36 +5846,34 @@ const editorMachine = xstate.setup({
           event: event.behaviorEvent
         }, shouldRun));
         for (const actionIntends of actionIntendSets)
-          behaviorOverwritten = behaviorOverwritten || actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), withApplyingBehaviorActions(event.editor, () => {
-            slate.Editor.withoutNormalizing(event.editor, () => {
-              for (const actionIntend of actionIntends) {
-                if (actionIntend.type === "raise") {
-                  behavior_core.isCustomBehaviorEvent(actionIntend.event) ? enqueue.raise({
-                    type: "custom behavior event",
-                    behaviorEvent: actionIntend.event,
-                    editor: event.editor
-                  }) : enqueue.raise({
-                    type: "behavior event",
-                    behaviorEvent: actionIntend.event,
-                    editor: event.editor
-                  });
-                  continue;
-                }
-                const action = {
-                  ...actionIntend,
+          behaviorOverwritten = behaviorOverwritten || actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), withApplyingBehaviorActionIntendSet(event.editor, () => {
+            for (const actionIntend of actionIntends) {
+              if (actionIntend.type === "raise") {
+                behavior_core.isCustomBehaviorEvent(actionIntend.event) ? enqueue.raise({
+                  type: "custom behavior event",
+                  behaviorEvent: actionIntend.event,
                   editor: event.editor
-                };
-                try {
-                  performAction({
-                    context,
-                    action
-                  });
-                } catch (error) {
-                  console.error(new Error(`Performing action "${action.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
-                  break;
-                }
+                }) : enqueue.raise({
+                  type: "behavior event",
+                  behaviorEvent: actionIntend.event,
+                  editor: event.editor
+                });
+                continue;
               }
-            });
+              const action = {
+                ...actionIntend,
+                editor: event.editor
+              };
+              try {
+                performAction({
+                  context,
+                  action
+                });
+              } catch (error) {
+                console.error(new Error(`Performing action "${action.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+                break;
+              }
+            }
           }), event.editor.onChange();
         if (behaviorOverwritten) {
           event.nativeEvent?.preventDefault();
@@ -5750,29 +5883,25 @@ const editorMachine = xstate.setup({
       if (!behaviorOverwritten) {
         if (defaultActionCallback) {
           withApplyingBehaviorActions(event.editor, () => {
-            slate.Editor.withoutNormalizing(event.editor, () => {
-              try {
-                defaultActionCallback();
-              } catch (error) {
-                console.error(new Error(`Performing "${event.behaviorEvent.type}" failed due to: ${error.message}`));
-              }
-            });
+            try {
+              defaultActionCallback();
+            } catch (error) {
+              console.error(new Error(`Performing "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+            }
           });
           return;
         }
         if (!defaultAction)
           return;
         withApplyingBehaviorActions(event.editor, () => {
-          slate.Editor.withoutNormalizing(event.editor, () => {
-            try {
-              performAction({
-                context,
-                action: defaultAction
-              });
-            } catch (error) {
-              console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
-            }
-          });
+          try {
+            performAction({
+              context,
+              action: defaultAction
+            });
+          } catch (error) {
+            console.error(new Error(`Performing action "${defaultAction.type}" as a result of "${event.behaviorEvent.type}" failed due to: ${error.message}`));
+          }
         }), event.editor.onChange();
       }
     })
@@ -5996,6 +6125,11 @@ const editorMachine = xstate.setup({
                 event
               }) => event)
             },
+            "history.*": {
+              actions: xstate.emit(({
+                event
+              }) => event)
+            },
             "insert.*": {
               actions: xstate.emit(({
                 event
@@ -6141,25 +6275,6 @@ function getEditorSnapshot({
     }
   };
 }
-const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
-  let table;
-  return () => {
-    if (table)
-      return table;
-    table = [];
-    for (let i = 0; i < 256; ++i)
-      table[i] = (i + 256).toString(16).slice(1);
-    return table;
-  };
-})();
-function whatwgRNG(length = 16) {
-  const rnds8 = new Uint8Array(length);
-  return getRandomValues__default.default(rnds8), rnds8;
-}
-function randomKey(length) {
-  const table = getByteHexTable();
-  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
-}
 function createEditor(config) {
   const editorActor = xstate.createActor(editorMachine, {
     input: editorConfigToMachineInput(config)