@portabletext/editor 1.18.7 → 1.20.0

package/lib/index.js

@@ -1,16 +1,15 @@
 import { Schema } from "@sanity/schema";
 import { defineType, defineField, isKeySegment, isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, isPortableTextListBlock } from "@sanity/types";
 import startCase from "lodash.startcase";
-import { jsx, Fragment, jsxs } from "react/jsx-runtime";
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import isEqual from "lodash/isEqual.js";
 import noop from "lodash/noop.js";
 import React, { useRef, useState, useEffect, useMemo, createContext, useContext, startTransition, Component, useCallback, forwardRef, useImperativeHandle } from "react";
 import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Operation, Node, createEditor as createEditor$1, deleteBackward, deleteForward, insertText } from "slate";
 import { useSlateStatic, ReactEditor, useSelected, withReact, Slate, useSlate, Editable } from "slate-react";
-import debug$l from "debug";
+import debug$k from "debug";
 import { c } from "react-compiler-runtime";
-import { styled } from "styled-components";
 import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
@@ -140,10 +139,10 @@ function compileSchemaDefinition(definition) {
   };
 }
 const rootName = "sanity-pte:";
-debug$l(rootName);
+debug$k(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$l && debug$l.enabled(namespace) ? debug$l(namespace) : debug$l(rootName);
+  return debug$k && debug$k.enabled(namespace) ? debug$k(namespace) : debug$k(rootName);
 }
 function createKeyedPath(point, value, types) {
   const blockPath = [point.path[0]];
@@ -214,7 +213,7 @@ function toSlateRange(selection, editor) {
     path: toSlatePath(selection.focus.path, editor),
     offset: selection.focus.offset
   };
-  return focus.path.length === 0 || anchor.path.length === 0 ? null : anchor && focus ? {
+  return focus.path.length === 0 || anchor.path.length === 0 ? null : focus ? {
     anchor,
     focus
   } : null;
@@ -377,172 +376,20 @@ function isEqualToEmptyEditor(children, schemaTypes) {
 const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), IS_DRAGGING = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_ELEMENT = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_ELEMENT_TARGET = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_TARGET_POSITION = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), DefaultObject = (props) => {
   const $ = c(4);
   let t0;
-  $[0] !== props.value ? (t0 = JSON.stringify(props.value, null, 2), $[0] = props.value, $[1] = t0) : t0 = $[1];
+  $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = {
+    userSelect: "none"
+  }, $[0] = t0) : t0 = $[0];
   let t1;
-  return $[2] !== t0 ? (t1 = /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsx("pre", { children: t0 }) }), $[2] = t0, $[3] = t1) : t1 = $[3], t1;
+  return $[1] !== props.value._key || $[2] !== props.value._type ? (t1 = /* @__PURE__ */ jsxs("div", { style: t0, children: [
+    "[",
+    props.value._type,
+    ": ",
+    props.value._key,
+    "]"
+  ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
 };
 DefaultObject.displayName = "DefaultObject";
-const DefaultBlockObject = styled.div`
-  user-select: none;
-  border: ${(props) => props.selected ? "1px solid blue" : "1px solid transparent"};
-`;
-styled.span`
-  background: #999;
-  border: ${(props) => props.selected ? "1px solid blue" : "1px solid transparent"};
-`;
-const DefaultListItem = styled.div`
-  &.pt-list-item {
-    width: fit-content;
-    position: relative;
-    display: block;
-
-    /* Important 'transform' in order to force refresh the ::before and ::after rules
-      in Webkit: https://stackoverflow.com/a/21947628/831480
-    */
-    transform: translateZ(0);
-    margin-left: ${(props) => getLeftPositionForListLevel(props.listLevel)};
-  }
-  &.pt-list-item > .pt-list-item-inner {
-    display: flex;
-    margin: 0;
-    padding: 0;
-    &:before {
-      justify-content: flex-start;
-      vertical-align: top;
-    }
-  }
-  &.pt-list-item-bullet > .pt-list-item-inner:before {
-      content: '${(props) => getContentForListLevelAndStyle(props.listLevel, props.listStyle)}';
-      font-size: 0.4375rem; /* 7px */
-      line-height: 1.5rem; /* Same as body text */
-      /* Optical alignment */
-      position: relative;
-    }
-  }
-  &.pt-list-item-bullet > .pt-list-item-inner {
-    &:before {
-      min-width: 1.5rem; /* Make sure space between bullet and text never shrinks */
-    }
-  }
-  &.pt-list-item-number {
-    counter-increment: ${(props) => getCounterIncrementForListLevel(props.listLevel)};
-    counter-reset: ${(props) => getCounterResetForListLevel(props.listLevel)};
-  }
-  & + :not(.pt-list-item-number) {
-    counter-reset: listItemNumber;
-  }
-  &.pt-list-item-number > .pt-list-item-inner:before {
-    content: ${(props) => getCounterContentForListLevel(props.listLevel)};
-    min-width: 1.5rem; /* Make sure space between number and text never shrinks */
-    /* Optical alignment */
-    position: relative;
-    top: 1px;
-  }
-`, DefaultListItemInner = styled.div``;
-function getLeftPositionForListLevel(level) {
-  switch (Number(level)) {
-    case 1:
-      return "1.5em";
-    case 2:
-      return "3em";
-    case 3:
-      return "4.5em";
-    case 4:
-      return "6em";
-    case 5:
-      return "7.5em";
-    case 6:
-      return "9em";
-    case 7:
-      return "10.5em";
-    case 8:
-      return "12em";
-    case 9:
-      return "13.5em";
-    case 10:
-      return "15em";
-    default:
-      return "0em";
-  }
-}
-const bullets = ["\u25CF", "\u25CB", "\u25A0"];
-function getContentForListLevelAndStyle(level, style) {
-  const normalizedLevel = (level - 1) % 3;
-  return style === "bullet" ? bullets[normalizedLevel] : "*";
-}
-function getCounterIncrementForListLevel(level) {
-  switch (level) {
-    case 1:
-      return "listItemNumber";
-    case 2:
-      return "listItemAlpha";
-    case 3:
-      return "listItemRoman";
-    case 4:
-      return "listItemNumberNext";
-    case 5:
-      return "listItemLetterNext";
-    case 6:
-      return "listItemRomanNext";
-    case 7:
-      return "listItemNumberNextNext";
-    case 8:
-      return "listItemAlphaNextNext";
-    case 9:
-      return "listItemRomanNextNext";
-    default:
-      return "listItemNumberNextNextNext";
-  }
-}
-function getCounterResetForListLevel(level) {
-  switch (level) {
-    case 1:
-      return "listItemAlpha";
-    case 2:
-      return "listItemRoman";
-    case 3:
-      return "listItemNumberNext";
-    case 4:
-      return "listItemLetterNext";
-    case 5:
-      return "listItemRomanNext";
-    case 6:
-      return "listItemNumberNextNext";
-    case 7:
-      return "listItemAlphaNextNext";
-    case 8:
-      return "listItemRomanNextNext";
-    case 9:
-      return "listItemNumberNextNextNext";
-    default:
-      return "listItemNumberNextNextNext";
-  }
-}
-function getCounterContentForListLevel(level) {
-  switch (level) {
-    case 1:
-      return "counter(listItemNumber) '. '";
-    case 2:
-      return "counter(listItemAlpha, lower-alpha) '. '";
-    case 3:
-      return "counter(listItemRoman, lower-roman) '. '";
-    case 4:
-      return "counter(listItemNumberNext) '. '";
-    case 5:
-      return "counter(listItemLetterNext, lower-alpha) '. '";
-    case 6:
-      return "counter(listItemRomanNext, lower-roman) '. '";
-    case 7:
-      return "counter(listItemNumberNextNext) '. '";
-    case 8:
-      return "counter(listItemAlphaNextNext, lower-alpha) '. '";
-    case 9:
-      return "counter(listItemRomanNextNext, lower-roman) '. '";
-    default:
-      return "counter(listItemNumberNextNextNext) '. '";
-  }
-}
-const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = (t0) => {
+const debug$j = debugWithName("components:DraggableBlock"), DraggableBlock = (t0) => {
   const $ = c(51), {
     children,
     element,
@@ -580,39 +427,39 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   $[16] !== editor || $[17] !== element ? (t9 = (event_0) => {
     const targetBlock = IS_DRAGGING_ELEMENT_TARGET.get(editor);
     if (targetBlock) {
-      IS_DRAGGING.set(editor, !1), event_0.preventDefault(), event_0.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$k("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
+      IS_DRAGGING.set(editor, !1), event_0.preventDefault(), event_0.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$j("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
       const dragPosition = IS_DRAGGING_BLOCK_TARGET_POSITION.get(editor);
       IS_DRAGGING_BLOCK_TARGET_POSITION.delete(editor);
       let targetPath = ReactEditor.findPath(editor, targetBlock);
       const myPath = ReactEditor.findPath(editor, element), isBefore = Path.isBefore(myPath, targetPath);
       if (dragPosition === "bottom" && !isBefore) {
         if (targetPath[0] >= editor.children.length - 1) {
-          debug$k("target is already at the bottom, not moving");
+          debug$j("target is already at the bottom, not moving");
           return;
         }
         const originalPath = targetPath;
-        targetPath = Path.next(targetPath), debug$k(`Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(targetPath)}`);
+        targetPath = Path.next(targetPath), debug$j(`Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(targetPath)}`);
       }
       if (dragPosition === "top" && isBefore && targetPath[0] !== editor.children.length - 1) {
         const originalPath_0 = targetPath;
-        targetPath = Path.previous(targetPath), debug$k(`Adjusting targetPath from ${JSON.stringify(originalPath_0)} to ${JSON.stringify(targetPath)}`);
+        targetPath = Path.previous(targetPath), debug$j(`Adjusting targetPath from ${JSON.stringify(originalPath_0)} to ${JSON.stringify(targetPath)}`);
       }
       if (Path.equals(targetPath, myPath)) {
-        event_0.preventDefault(), debug$k("targetPath and myPath is the same, not moving");
+        event_0.preventDefault(), debug$j("targetPath and myPath is the same, not moving");
         return;
       }
-      debug$k(`Moving element ${element._key} from path ${JSON.stringify(myPath)} to ${JSON.stringify(targetPath)} (${dragPosition})`), Transforms.moveNodes(editor, {
+      debug$j(`Moving element ${element._key} from path ${JSON.stringify(myPath)} to ${JSON.stringify(targetPath)} (${dragPosition})`), Transforms.moveNodes(editor, {
         at: myPath,
         to: targetPath
       }), editor.onChange();
       return;
     }
-    debug$k("No target element, not doing anything");
+    debug$j("No target element, not doing anything");
   }, $[16] = editor, $[17] = element, $[18] = t9) : t9 = $[18];
   const handleDragEnd = t9;
   let t10;
   $[19] !== editor || $[20] !== element ? (t10 = (event_1) => {
-    IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$k("On drop (prevented)", element), event_1.preventDefault(), event_1.stopPropagation(), setIsDragOver(!1));
+    IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$j("On drop (prevented)", element), event_1.preventDefault(), event_1.stopPropagation(), setIsDragOver(!1));
   }, $[19] = editor, $[20] = element, $[21] = t10) : t10 = $[21];
   const handleDrop = t10;
   let t11;
@@ -629,10 +476,10 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   let t12;
   $[26] !== blockElement || $[27] !== editor || $[28] !== handleDrag || $[29] !== isInline || $[30] !== isVoid ? (t12 = (event_3) => {
     if (!isVoid || isInline) {
-      debug$k("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
+      debug$j("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
       return;
     }
-    if (debug$k("Drag start"), IS_DRAGGING.set(editor, !0), event_3.dataTransfer && (event_3.dataTransfer.setData("application/portable-text", "something"), event_3.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
+    if (debug$j("Drag start"), IS_DRAGGING.set(editor, !0), event_3.dataTransfer && (event_3.dataTransfer.setData("application/portable-text", "something"), event_3.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
       let dragGhost = blockElement.cloneNode(!0);
       const customGhost = dragGhost.querySelector("[data-pt-drag-ghost-element]");
       if (customGhost && (dragGhost = customGhost), dragGhost.setAttribute("data-dragged", ""), document.body) {
@@ -747,7 +594,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
     let level;
     if (isListItem && (typeof element.level == "number" && (level = element.level), className += ` pt-list-item pt-list-item-${element.listItem} pt-list-item-level-${level || 1}`), editor.isListBlock(value) && isListItem && element.listItem) {
       const listType = schemaTypes.lists.find((item_0) => item_0.value === element.listItem);
-      renderListItem && listType ? renderedBlock = renderListItem({
+      renderListItem && listType && (renderedBlock = renderListItem({
         block: value,
         children: renderedBlock,
         focused,
@@ -757,7 +604,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
         schemaType: listType,
         level: value.level || 1,
         editorElementRef: blockRef
-      }) : renderedBlock = /* @__PURE__ */ jsx(DefaultListItem, { listStyle: value.listItem || schemaTypes.lists[0].value, listLevel: value.level || 1, children: /* @__PURE__ */ jsx(DefaultListItemInner, { children: renderedBlock }) });
+      }));
     }
     const renderProps = Object.defineProperty({
       children: renderedBlock,
@@ -803,10 +650,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
   }
   return /* @__PURE__ */ jsxs("div", { ...attributes, className, children: [
     children,
-    /* @__PURE__ */ jsxs(DraggableBlock, { element, readOnly, blockRef, children: [
-      renderedBlockFromProps && /* @__PURE__ */ jsx("div", { ref: blockRef, contentEditable: !1, children: renderedBlockFromProps }),
-      !renderedBlockFromProps && /* @__PURE__ */ jsx(DefaultBlockObject, { selected, children: /* @__PURE__ */ jsx(DefaultObject, { value }) })
-    ] })
+    /* @__PURE__ */ jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsx("div", { ref: blockRef, contentEditable: !1, children: renderedBlockFromProps || /* @__PURE__ */ jsx(DefaultObject, { value }) }) })
   ] }, element._key);
 };
 Element.displayName = "Element";
@@ -1907,7 +1751,7 @@ function isRedoing(editor) {
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
-const debug$j = debugWithName("plugin:withUndoRedo"), debugVerbose$3 = debug$j.enabled && !1, SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$i = 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;
 }, getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) || []);
@@ -1920,7 +1764,7 @@ function createWithUndoRedo(options) {
     let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
     const remotePatches = getRemotePatches(editor);
     options.subscriptions.push(() => {
-      debug$j("Subscribing to patches");
+      debug$i("Subscribing to patches");
       const sub = editorActor.on("patches", ({
         patches,
         snapshot
@@ -1929,7 +1773,7 @@ function createWithUndoRedo(options) {
         patches.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$j("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+              debug$i("Someone else cleared the content, resetting undo/redo history"), editor.history = {
                 undos: [],
                 redos: []
               }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -1945,7 +1789,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$j("Unsubscribing to patches"), sub.unsubscribe();
+        debug$i("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -1984,7 +1828,7 @@ function createWithUndoRedo(options) {
             operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
             timestamp: /* @__PURE__ */ new Date()
           };
-          undos.push(newStep), debug$j("Created new undo step", step);
+          undos.push(newStep), debug$i("Created new undo step", step);
         }
         for (; undos.length > UNDO_STEP_LIMIT; )
           undos.shift();
@@ -2001,7 +1845,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (undos.length > 0) {
         const step = undos[undos.length - 1];
-        if (debug$j("Undoing", step), step.operations.length > 0) {
+        if (debug$i("Undoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -2019,7 +1863,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$j("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+            debug$i("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
@@ -2038,7 +1882,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (redos.length > 0) {
         const step = redos[redos.length - 1];
-        if (debug$j("Redoing", step), step.operations.length > 0) {
+        if (debug$i("Redoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -2055,7 +1899,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$j("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+            debug$i("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
@@ -2068,7 +1912,6 @@ function createWithUndoRedo(options) {
   };
 }
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
-  debugVerbose$3 && (debug$j(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$j(`Operation ${JSON.stringify(operation)}`), debug$j(`Patch ${JSON.stringify(patch)}`));
   const transformedOperation = {
     ...operation
   };
@@ -2076,16 +1919,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return debug$j(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$i(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 1) {
     const unsetBlockIndex = (previousSnapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$j("Skipping transformation that targeted removed block"), []) : (debugVerbose$3 && (debug$j(`Selection ${JSON.stringify(editor.selection)}`), debug$j(`Adjusting block path (-1) for '${transformedOperation.type}' operation and patch '${patch.type}'`)), [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)]);
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$i("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$j(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$i(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual({
@@ -2365,7 +2208,7 @@ const syncValueCallback = ({
       }
     }
   }
-}), debug$i = debugWithName("hook:useSyncValue");
+}), debug$h = debugWithName("hook:useSyncValue");
 async function updateValue({
   context,
   sendBack,
@@ -2375,7 +2218,7 @@ async function updateValue({
 }) {
   let isChanged = !1, isValid = !0;
   const hadSelection = !!slateEditor.selection;
-  if ((!value || value.length === 0) && (debug$i("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
+  if ((!value || value.length === 0) && (debug$h("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
       withoutPatching(slateEditor, () => {
         hadSelection && Transforms.deselect(slateEditor);
@@ -2431,14 +2274,14 @@ async function updateValue({
     });
   }
   if (!isValid) {
-    debug$i("Invalid value, returning"), sendBack({
+    debug$h("Invalid value, returning"), sendBack({
       type: "done syncing",
       value
     });
     return;
   }
   if (isChanged) {
-    debug$i("Server value changed, syncing editor");
+    debug$h("Server value changed, syncing editor");
     try {
       slateEditor.onChange();
     } catch (err) {
@@ -2466,7 +2309,7 @@ async function updateValue({
       value
     });
   } else
-    debug$i("Server value and editor value is equal, no need to sync.");
+    debug$h("Server value and editor value is equal, no need to sync.");
   sendBack({
     type: "done syncing",
     value
@@ -2500,7 +2343,7 @@ function syncBlock({
               type: "patch",
               patch
             });
-          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$h.enabled && debug$h("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$h.enabled && debug$h("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2508,9 +2351,9 @@ function syncBlock({
         }
         if (!oldBlock && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+          debug$h.enabled && debug$h("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
-          }) : (debug$i("Invalid", validation), sendBack({
+          }) : (debug$h("Invalid", validation), sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2538,14 +2381,14 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     const oldBlockChildrenLength = oldBlock.children.length;
     currentBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - currentBlock.children.length)).forEach((_, index) => {
       const childIndex = oldBlockChildrenLength - 1 - index;
-      childIndex > 0 && (debug$i("Removing child"), Transforms.removeNodes(slateEditor, {
+      childIndex > 0 && (debug$h("Removing child"), Transforms.removeNodes(slateEditor, {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key) {
-          debug$i("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$h("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
           const isSpanNode = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
@@ -2562,23 +2405,23 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$i("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode || (debug$h("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
             voids: !0
           }));
-        } else oldBlockChild ? (debug$i("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$h("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$i("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$h("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slateEditor.onChange());
     });
   }
 }
-const debug$h = debugWithName("component:PortableTextEditor:Synchronizer");
+const debug$g = debugWithName("component:PortableTextEditor:Synchronizer");
 function Synchronizer(props) {
   const $ = c(40), {
     editorActor,
@@ -2649,19 +2492,19 @@ function Synchronizer(props) {
   }, t12 = [syncActorRef, readOnly], $[25] = readOnly, $[26] = syncActorRef, $[27] = t11, $[28] = t12) : (t11 = $[27], t12 = $[28]), useEffect(t11, t12);
   let t13, t14;
   $[29] !== syncActorRef || $[30] !== value ? (t13 = () => {
-    debug$h("Value from props changed, syncing new value"), syncActorRef.send({
+    debug$g("Value from props changed, syncing new value"), syncActorRef.send({
       type: "update value",
       value
     });
   }, t14 = [syncActorRef, value], $[29] = syncActorRef, $[30] = value, $[31] = t13, $[32] = t14) : (t13 = $[31], t14 = $[32]), useEffect(t13, t14);
   let t15;
   $[33] !== editorActor || $[34] !== mutationActorRef ? (t15 = () => {
-    debug$h("Subscribing to patch events");
+    debug$g("Subscribing to patch events");
     const sub = editorActor.on("patch", (event_1) => {
       mutationActorRef.send(event_1);
     });
     return () => {
-      debug$h("Unsubscribing to patch events"), sub.unsubscribe();
+      debug$g("Unsubscribing to patch events"), sub.unsubscribe();
     };
   }, $[33] = editorActor, $[34] = mutationActorRef, $[35] = t15) : t15 = $[35];
   let t16;
@@ -2676,11 +2519,11 @@ function _temp(s) {
   return s.context.value;
 }
 Synchronizer.displayName = "Synchronizer";
-const debug$g = debugWithName("operationToPatches");
+const debug$f = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$g.enabled && debug$g("Operation", JSON.stringify(operation, null, 2));
+    debug$f.enabled && debug$f("Operation", JSON.stringify(operation, null, 2));
     const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
     if (!block)
       throw new Error("Could not find block");
@@ -2773,7 +2616,7 @@ function createOperationToPatches(types) {
         _key: block.children[operation.path[1] - 1]._key
       }])];
     }
-    return debug$g("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$f("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches = [], splitBlock = editor.children[operation.path[0]];
@@ -2831,9 +2674,9 @@ function createOperationToPatches(types) {
         _key: block._key
       }, "children", {
         _key: spanToRemove._key
-      }])] : (debug$g("Span not found in editor trying to remove node"), []);
+      }])] : (debug$f("Span not found in editor trying to remove node"), []);
     } else
-      return debug$g("Not creating patch inside object block"), [];
+      return debug$f("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -2859,7 +2702,7 @@ function createOperationToPatches(types) {
         _key: removedSpan._key
       }])) : console.warn(`Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)));
     } else
-      debug$g("Void nodes can't be merged, not creating any patches");
+      debug$f("Void nodes can't be merged, not creating any patches");
     return patches;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -2898,9 +2741,19 @@ function createOperationToPatches(types) {
     splitNodePatch
   };
 }
+const 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;
+}
 function createWithEventListeners(editorActor, subscriptions) {
   return function(editor) {
-    return editorActor.getSnapshot().context.maxBlocks !== void 0 || (subscriptions.push(() => {
+    if (editorActor.getSnapshot().context.maxBlocks !== void 0)
+      return editor;
+    subscriptions.push(() => {
       const subscription = editorActor.on("*", (event) => {
         switch (event.type) {
           case "annotation.add": {
@@ -2925,17 +2778,6 @@ function createWithEventListeners(editorActor, subscriptions) {
             });
             break;
           }
-          case "annotation.toggle": {
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "annotation.toggle",
-                annotation: event.annotation
-              },
-              editor
-            });
-            break;
-          }
           case "blur": {
             editorActor.send({
               type: "behavior event",
@@ -2946,28 +2788,6 @@ function createWithEventListeners(editorActor, subscriptions) {
             });
             break;
           }
-          case "decorator.add": {
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "decorator.add",
-                decorator: event.decorator
-              },
-              editor
-            });
-            break;
-          }
-          case "decorator.remove": {
-            editorActor.send({
-              type: "behavior event",
-              behaviorEvent: {
-                type: "decorator.remove",
-                decorator: event.decorator
-              },
-              editor
-            });
-            break;
-          }
           case "decorator.toggle": {
             editorActor.send({
               type: "behavior event",
@@ -3023,6 +2843,17 @@ function createWithEventListeners(editorActor, subscriptions) {
             });
             break;
           }
+          case "select": {
+            editorActor.send({
+              type: "behavior event",
+              behaviorEvent: {
+                type: "select",
+                selection: event.selection
+              },
+              editor
+            });
+            break;
+          }
           case "style.toggle": {
             editorActor.send({
               type: "behavior event",
@@ -3039,25 +2870,11 @@ function createWithEventListeners(editorActor, subscriptions) {
       return () => {
         subscription.unsubscribe();
       };
-    }), editor.addMark = (mark) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "decorator.add",
-          decorator: mark
-        },
-        editor
-      });
-    }, editor.removeMark = (mark) => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "decorator.remove",
-          decorator: mark
-        },
-        editor
-      });
-    }, editor.deleteBackward = (unit) => {
+    });
+    const {
+      select
+    } = editor;
+    return editor.deleteBackward = (unit) => {
       editorActor.send({
         type: "behavior event",
         behaviorEvent: {
@@ -3101,7 +2918,21 @@ function createWithEventListeners(editorActor, subscriptions) {
         },
         editor
       });
-    }), editor;
+    }, editor.select = (location) => {
+      if (isApplyingBehaviorActions(editor)) {
+        select(location);
+        return;
+      }
+      const range = 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
+      });
+    }, editor;
   };
 }
 function createWithMaxBlocks(editorActor) {
@@ -3198,13 +3029,13 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-const debug$f = debugWithName("applyPatches"), debugVerbose$2 = debug$f.enabled && !0;
+const debug$e = debugWithName("applyPatches"), debugVerbose = debug$e.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose$2 && (debug$f(`
+    debugVerbose && (debug$e(`
 
-NEW PATCH =============================================================`), debug$f(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$e(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -3220,7 +3051,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$f("Unhandled patch", patch.type);
+          debug$e("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -3235,9 +3066,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$f("Block not found"), !1;
+    return debug$e("Block not found"), !1;
   if (!child || !childPath)
-    return debug$f("Child not found"), !1;
+    return debug$e("Child not found"), !1;
   if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !Text.isText(child))
     return !1;
   const patches = parse(patch.value), [newValue] = apply(patches, child.text, {
@@ -3267,9 +3098,9 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$f("Block not found"), !1;
+    return debug$e("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$f("Ignoring patch targeting void value"), !1;
+    return debug$e("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -3277,7 +3108,7 @@ function insertPatch(editor, patch, schemaTypes) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$f(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$e(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -3286,14 +3117,14 @@ function insertPatch(editor, patch, schemaTypes) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$f("Child not found"), !1;
+    return debug$e("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$f(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$e(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -3307,14 +3138,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$f("Block not found"), !1;
+    return debug$e("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$f("Ignoring setting void value"), !1;
+    return debug$e("Ignoring setting void value"), !1;
   if (debugState(editor, "before"), isTextBlock && child && childPath) {
     if (Text.isText(value) && Text.isText(child)) {
       const newText = child.text;
-      value.text !== newText && (debug$f("Setting text property"), editor.apply({
+      value.text !== newText && (debug$e("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -3326,7 +3157,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$f("Setting non-text property"), editor.apply({
+      debug$e("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -3334,7 +3165,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (Element$1.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$f("Setting block property");
+    debug$e("Setting block property");
     const {
       children,
       ...nextRest
@@ -3351,7 +3182,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$f("Setting children"), block.children.forEach((c2, cIndex) => {
+    }), debug$e("Setting children"), block.children.forEach((c2, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -3377,7 +3208,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$f("Removing everything"), debugState(editor, "before");
+    debug$e("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       Transforms.removeNodes(editor, {
@@ -3404,13 +3235,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$f("Block not found"), !1;
+      return debug$e("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$f(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), Transforms.removeNodes(editor, {
+    return debug$e(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), Transforms.removeNodes(editor, {
       at: [blockIndex]
     }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$f("Child not found"), !1) : (debug$f(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose$2 && debug$f(`Removing child at path ${JSON.stringify(childPath)}`), Transforms.removeNodes(editor, {
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$e("Child not found"), !1) : (debug$e(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$e(`Removing child at path ${JSON.stringify(childPath)}`), Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -3418,7 +3249,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose$2 && (debug$f(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$f(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose && (debug$e(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$e(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -3460,7 +3291,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$e = debugWithName("plugin:withPatches");
+const debug$d = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -3486,7 +3317,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               patches.forEach((patch) => {
-                debug$e.enabled && debug$e(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                debug$d.enabled && debug$d(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -3499,10 +3330,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$e("Subscribing to remote patches");
+      debug$d("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$e("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$d("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       let patches = [];
@@ -3553,7 +3384,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$d = debugWithName("plugin:withPlaceholderBlock");
+const debug$c = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -3578,7 +3409,7 @@ function createWithPlaceholderBlock(editorActor) {
         const node = op.node;
         if (op.path[0] === 0 && Editor.isVoid(editor, node)) {
           const nextPath = Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$d("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$c("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -3587,7 +3418,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$c = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$b = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor, types) {
   const defaultStyle = types.styles[0].value;
   return function(editor) {
@@ -3600,7 +3431,7 @@ function createWithPortableTextBlockStyle(editorActor, types) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !Path.equals(path, op.path)) {
           const [child] = Editor.node(editor, [op.path[0] + 1, 0]);
           if (Text.isText(child) && child.text === "") {
-            debug$c(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$b(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               style: defaultStyle
@@ -3660,7 +3491,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$b = debugWithName("plugin:withPortableTextMarkModel");
+const debug$a = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types) {
   return function(editor) {
     const {
@@ -3674,7 +3505,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         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$b("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$a("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), Transforms.mergeNodes(editor, {
               at: [childPath[0], childPath[1] + 1],
@@ -3687,7 +3518,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$b("Adding .markDefs to block node"), editorActor.send({
+        debug$a("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           markDefs: []
@@ -3699,7 +3530,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$b("Adding .marks to span node"), editorActor.send({
+        debug$a("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           marks: []
@@ -3713,7 +3544,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$b("Removing annotations from empty span node"), editorActor.send({
+          debug$a("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -3731,7 +3562,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
           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$b("Removing orphaned annotations from span node"), editorActor.send({
+              debug$a("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3749,7 +3580,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (editor.isTextBlock(block)) {
           const decorators2 = types.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$b("Removing orphaned annotations from span node"), editorActor.send({
+            debug$a("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3767,7 +3598,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$b("Removing duplicate markDefs"), editorActor.send({
+          debug$a("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3782,7 +3613,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       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) => Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual(newMarkDefs, node.markDefs)) {
-          debug$b("Removing markDef not in use"), editorActor.send({
+          debug$a("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3999,7 +3830,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         const [targetBlock, targetPath] = Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq([...oldDefs, ...op.properties.markDefs]);
-          debug$b("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
+          debug$a("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -4060,7 +3891,12 @@ const addDecoratorActionImplementation = ({
         editor.marks = marks;
       }
     }
-    editor.onChange();
+    if (editor.selection) {
+      const selection = editor.selection;
+      editor.selection = {
+        ...selection
+      };
+    }
   }
 }, removeDecoratorActionImplementation = ({
   action
@@ -4068,7 +3904,7 @@ const addDecoratorActionImplementation = ({
   const editor = action.editor, mark = action.decorator, {
     selection
   } = editor;
-  if (selection)
+  if (selection) {
     if (Range.isExpanded(selection))
       Transforms.setNodes(editor, {}, {
         match: Text.isText,
@@ -4111,6 +3947,13 @@ const addDecoratorActionImplementation = ({
         };
       }
     }
+    if (editor.selection) {
+      const selection2 = editor.selection;
+      editor.selection = {
+        ...selection2
+      };
+    }
+  }
 };
 function isDecoratorActive({
   editor,
@@ -4151,7 +3994,8 @@ const toggleDecoratorActionImplementation = ({
       decorator: action.decorator
     }
   });
-}, debug$a = debugWithName("plugin:withPortableTextSelections"), debugVerbose$1 = debug$a.enabled && !1;
+};
+debugWithName("plugin:withPortableTextSelections");
 function createWithPortableTextSelections(editorActor, types) {
   let prevSelection = null;
   return function(editor) {
@@ -4167,7 +4011,7 @@ function createWithPortableTextSelections(editorActor, types) {
             ptRange = toPortableTextRange(value, editor.selection, types), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
           }
         }
-        debugVerbose$1 && debug$a(`Emitting selection ${JSON.stringify(ptRange || null)} (${JSON.stringify(editor.selection)})`), ptRange ? editorActor.send({
+        ptRange ? editorActor.send({
           type: "selection",
           selection: ptRange
         }) : editorActor.send({
@@ -4180,10 +4024,9 @@ function createWithPortableTextSelections(editorActor, types) {
       onChange
     } = editor;
     return editor.onChange = () => {
-      const hasChanges = editor.operations.length > 0;
-      onChange(), hasChanges && !editorActor.getSnapshot().matches({
+      onChange(), editorActor.getSnapshot().matches({
         setup: "setting up"
-      }) && emitPortableTextSelection();
+      }) || emitPortableTextSelection();
     }, editor;
   };
 }
@@ -5418,16 +5261,6 @@ const insertBlockObjectActionImplementation = ({
     const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1];
     Transforms.select(action.editor, nextBlockPath);
   },
-  reselect: ({
-    action
-  }) => {
-    const selection = action.editor.selection;
-    selection && (Transforms.select(action.editor, {
-      ...selection
-    }), action.editor.selection = {
-      ...selection
-    });
-  },
   "style.toggle": toggleStyleActionImplementation,
   "style.add": addStyleActionImplementation,
   "style.remove": removeStyleActionImplementation,
@@ -5439,6 +5272,27 @@ function performAction({
   action
 }) {
   switch (action.type) {
+    case "annotation.toggle": {
+      behaviorActionImplementations["annotation.toggle"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "decorator.add": {
+      behaviorActionImplementations["decorator.add"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "decorator.remove": {
+      behaviorActionImplementations["decorator.remove"]({
+        context,
+        action
+      });
+      break;
+    }
     case "delete.block": {
       behaviorActionImplementations["delete.block"]({
         context,
@@ -5532,13 +5386,6 @@ function performAction({
       });
       break;
     }
-    case "reselect": {
-      behaviorActionImplementations.reselect({
-        context,
-        action
-      });
-      break;
-    }
     case "style.add": {
       behaviorActionImplementations["style.add"]({
         context,
@@ -5593,13 +5440,6 @@ function performDefaultAction({
       });
       break;
     }
-    case "annotation.toggle": {
-      behaviorActionImplementations["annotation.toggle"]({
-        context,
-        action
-      });
-      break;
-    }
     case "blur": {
       behaviorActionImplementations.blur({
         context,
@@ -5607,20 +5447,6 @@ function performDefaultAction({
       });
       break;
     }
-    case "decorator.add": {
-      behaviorActionImplementations["decorator.add"]({
-        context,
-        action
-      });
-      break;
-    }
-    case "decorator.remove": {
-      behaviorActionImplementations["decorator.remove"]({
-        context,
-        action
-      });
-      break;
-    }
     case "decorator.toggle": {
       behaviorActionImplementations["decorator.toggle"]({
         context,
@@ -5691,6 +5517,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "select": {
+      behaviorActionImplementations.select({
+        context,
+        action
+      });
+      break;
+    }
     default:
       behaviorActionImplementations["style.toggle"]({
         context,
@@ -5715,10 +5548,22 @@ const editorMachine = setup({
     input: {}
   },
   actions: {
+    "add behavior to context": assign({
+      behaviors: ({
+        context,
+        event
+      }) => (assertEvent(event, "add behavior"), /* @__PURE__ */ new Set([...context.behaviors, event.behavior]))
+    }),
+    "remove behavior from context": assign({
+      behaviors: ({
+        context,
+        event
+      }) => (assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
+    }),
     "assign behaviors": assign({
       behaviors: ({
         event
-      }) => (assertEvent(event, "update behaviors"), event.behaviors)
+      }) => (assertEvent(event, "update behaviors"), new Set(event.behaviors))
     }),
     "assign schema": assign({
       schema: ({
@@ -5765,14 +5610,16 @@ const editorMachine = setup({
       const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : {
         ...event.behaviorEvent,
         editor: event.editor
-      }, eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
+      }, eventBehaviors = [...context.behaviors.values()].filter((behavior) => behavior.on === event.behaviorEvent.type);
       if (eventBehaviors.length === 0) {
         if (!defaultAction)
           return;
-        Editor.withoutNormalizing(event.editor, () => {
-          performAction({
-            context,
-            action: defaultAction
+        withApplyingBehaviorActions(event.editor, () => {
+          Editor.withoutNormalizing(event.editor, () => {
+            performAction({
+              context,
+              action: defaultAction
+            });
           });
         }), event.editor.onChange();
         return;
@@ -5800,21 +5647,28 @@ const editorMachine = setup({
           event: event.behaviorEvent
         }, shouldRun));
         for (const actionIntends of actionIntendSets)
-          behaviorOverwritten = behaviorOverwritten || actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), Editor.withoutNormalizing(event.editor, () => {
-            for (const actionIntend of actionIntends) {
-              const action = {
-                ...actionIntend,
-                editor: event.editor
-              };
-              performAction({
-                context,
-                action
-              });
-            }
-          }), event.editor.onChange(), actionIntends.some((actionIntend) => actionIntend.type === "reselect") && enqueue.raise({
-            type: "selection",
-            selection: toPortableTextRange(event.editor.children, event.editor.selection, context.schema)
-          });
+          behaviorOverwritten = behaviorOverwritten || actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), withApplyingBehaviorActions(event.editor, () => {
+            Editor.withoutNormalizing(event.editor, () => {
+              for (const actionIntend of actionIntends) {
+                if (actionIntend.type === "raise") {
+                  enqueue.raise({
+                    type: "behavior event",
+                    behaviorEvent: actionIntend.event,
+                    editor: event.editor
+                  });
+                  continue;
+                }
+                const action = {
+                  ...actionIntend,
+                  editor: event.editor
+                };
+                performAction({
+                  context,
+                  action
+                });
+              }
+            });
+          }), event.editor.onChange();
         if (behaviorOverwritten) {
           event.nativeEvent?.preventDefault();
           break;
@@ -5823,10 +5677,12 @@ const editorMachine = setup({
       if (!behaviorOverwritten) {
         if (!defaultAction)
           return;
-        Editor.withoutNormalizing(event.editor, () => {
-          performAction({
-            context,
-            action: defaultAction
+        withApplyingBehaviorActions(event.editor, () => {
+          Editor.withoutNormalizing(event.editor, () => {
+            performAction({
+              context,
+              action: defaultAction
+            });
           });
         }), event.editor.onChange();
       }
@@ -5837,7 +5693,7 @@ const editorMachine = setup({
   context: ({
     input
   }) => ({
-    behaviors: input.behaviors ?? coreBehaviors,
+    behaviors: new Set(input.behaviors ?? coreBehaviors),
     keyGenerator: input.keyGenerator,
     pendingEvents: [],
     schema: input.schema,
@@ -5847,6 +5703,12 @@ const editorMachine = setup({
     value: input.value
   }),
   on: {
+    "add behavior": {
+      actions: "add behavior to context"
+    },
+    "remove behavior": {
+      actions: "remove behavior from context"
+    },
     unset: {
       actions: emit(({
         event
@@ -5967,17 +5829,7 @@ const editorMachine = setup({
             "behavior event": {
               actions: "handle behavior event"
             },
-            "annotation.add": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "annotation.remove": {
-              actions: emit(({
-                event
-              }) => event)
-            },
-            "annotation.toggle": {
+            "annotation.*": {
               actions: emit(({
                 event
               }) => event)
@@ -6007,6 +5859,11 @@ const editorMachine = setup({
                 event
               }) => event)
             },
+            select: {
+              actions: emit(({
+                event
+              }) => event)
+            },
             "style.*": {
               actions: emit(({
                 event
@@ -6177,6 +6034,15 @@ function createEditorFromActor(editorActor) {
       editorActorSnapshot: editorActor.getSnapshot(),
       slateEditorInstance: slateEditor.instance
     }),
+    registerBehavior: (config) => (editorActor.send({
+      type: "add behavior",
+      behavior: config.behavior
+    }), () => {
+      editorActor.send({
+        type: "remove behavior",
+        behavior: config.behavior
+      });
+    }),
     send: (event) => {
       editorActor.send(event);
     },
@@ -6197,7 +6063,7 @@ const EditorActorContext = createContext({}), PortableTextEditorSelectionContext
   if (selection === void 0)
     throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
   return selection;
-}, debug$5 = debugWithName("component:PortableTextEditor:SelectionProvider"), debugVerbose = debug$5.enabled && !1;
+}, debug$5 = debugWithName("component:PortableTextEditor:SelectionProvider");
 function PortableTextEditorSelectionProvider(props) {
   const $ = c(6), [selection, setSelection] = useState(null);
   let t0, t1;
@@ -6205,7 +6071,7 @@ function PortableTextEditorSelectionProvider(props) {
     debug$5("Subscribing to selection changes");
     const subscription = props.editorActor.on("selection", (event) => {
       startTransition(() => {
-        debugVerbose && debug$5("Setting selection"), setSelection(event.selection);
+        setSelection(event.selection);
       });
     });
     return () => {
@@ -6401,23 +6267,19 @@ function RouteEventsToChanges(props) {
           });
           break bb5;
         }
-        case "annotation.add":
-        case "annotation.remove":
-        case "annotation.toggle":
-        case "blur":
-        case "decorator.add":
-        case "decorator.remove":
-        case "decorator.toggle":
-        case "focus":
-        case "insert.block object":
-        case "insert.inline object":
-        case "list item.toggle":
-        case "style.toggle":
-        case "patches":
-        case "editable":
-        case "read only":
+        case "mutation": {
+          handleChange(event);
           break bb5;
-        default:
+        }
+        case "ready": {
+          handleChange(event);
+          break bb5;
+        }
+        case "selection": {
+          handleChange(event);
+          break bb5;
+        }
+        case "unset":
           handleChange(event);
       }
     });
@@ -6550,17 +6412,9 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   return useMemo(() => /* @__PURE__ */ jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
-const debug$2 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
-  marks: {
-    "mod+b": "strong",
-    "mod+i": "em",
-    "mod+u": "underline",
-    "mod+'": "code"
-  },
-  custom: {}
-};
+const debug$2 = debugWithName("plugin:withHotKeys");
 function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions) {
-  const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions || DEFAULT_HOTKEYS;
+  const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions ?? {};
   return function(editor) {
     return editor.pteWithHotKeys = (event) => {
       Object.keys(activeHotkeys).forEach((cat) => {