@portabletext/editor 1.49.3 → 1.49.5

package/lib/index.js

@@ -7,7 +7,7 @@ import { useSelector, useActorRef } from "@xstate/react";
 import noop from "lodash/noop.js";
 import { Element as Element$1, Text, Range, Editor, Node, Point, Path, Operation, Transforms, deleteBackward, deleteForward, createEditor } from "slate";
 import { useSlateStatic, useSelected, withReact, ReactEditor, Slate, useSlate, Editable } from "slate-react";
-import debug$h from "debug";
+import debug$i from "debug";
 import { getBlockEndPoint, isEmptyTextBlock, isEqualSelectionPoints } from "./_chunks-es/util.is-equal-selection-points.js";
 import { getBlockStartPoint, isKeyedSegment as isKeyedSegment$1, parseInlineObject, parseTextBlock, parseBlockObject, parseBlock, sliceBlocks, isTextBlock, parseAnnotation, blockOffsetToSpanSelectionPoint, isSpan$1 as isSpan, isListBlock, getTextBlockText, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
 import { isSelectionCollapsed, getFocusTextBlock, getFocusSpan, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock as getSelectionStartBlock$1, getSelectionEndBlock as getSelectionEndBlock$1, getFocusBlock as getFocusBlock$1, getFocusBlockObject, getPreviousBlock, getNextBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock } from "./_chunks-es/selector.is-selection-expanded.js";
@@ -59,10 +59,10 @@ function getCompoundClientRect(nodes) {
   return new DOMRect(left, top, right - left, bottom - top);
 }
 const rootName = "sanity-pte:";
-debug$h(rootName);
+debug$i(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$h && debug$h.enabled(namespace) ? debug$h(namespace) : debug$h(rootName);
+  return debug$i && debug$i.enabled(namespace) ? debug$i(namespace) : debug$i(rootName);
 }
 function getDragSelection({
   eventSelection,
@@ -2533,7 +2533,7 @@ function withUndoStep(editor, fn) {
 function getCurrentUndoStepId(editor) {
   return CURRENT_UNDO_STEP.get(editor)?.undoStepId;
 }
-const debug$g = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$h = 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) || []);
@@ -2546,7 +2546,7 @@ function createWithUndoRedo(options) {
     const remotePatches = getRemotePatches(editor);
     let previousUndoStepId = getCurrentUndoStepId(editor);
     options.subscriptions.push(() => {
-      debug$g("Subscribing to patches");
+      debug$h("Subscribing to patches");
       const sub = editorActor.on("patches", ({
         patches,
         snapshot
@@ -2555,7 +2555,7 @@ function createWithUndoRedo(options) {
         patches.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$g("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+              debug$h("Someone else cleared the content, resetting undo/redo history"), editor.history = {
                 undos: [],
                 redos: []
               }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -2571,7 +2571,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$g("Unsubscribing to patches"), sub.unsubscribe();
+        debug$h("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -2610,7 +2610,7 @@ function createWithUndoRedo(options) {
             operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
             timestamp: /* @__PURE__ */ new Date()
           };
-          undos.push(newStep), debug$g("Created new undo step", step);
+          undos.push(newStep), debug$h("Created new undo step", step);
         }
         for (; undos.length > UNDO_STEP_LIMIT; )
           undos.shift();
@@ -2628,7 +2628,7 @@ const historyUndoOperationImplementation = ({
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (undos.length > 0) {
     const step = undos[undos.length - 1];
-    if (debug$g("Undoing", step), step.operations.length > 0) {
+    if (debug$h("Undoing", step), step.operations.length > 0) {
       const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
       let transformedOperations = step.operations;
       otherPatches.forEach((item) => {
@@ -2646,7 +2646,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+        debug$h("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();
@@ -2663,7 +2663,7 @@ const historyUndoOperationImplementation = ({
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (redos.length > 0) {
     const step = redos[redos.length - 1];
-    if (debug$g("Redoing", step), step.operations.length > 0) {
+    if (debug$h("Redoing", step), step.operations.length > 0) {
       const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
       let transformedOperations = step.operations;
       otherPatches.forEach((item) => {
@@ -2680,7 +2680,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+        debug$h("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();
@@ -2698,16 +2698,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return debug$g(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$h(`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$g("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$h("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$g(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$h(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual({
@@ -2794,7 +2794,7 @@ function findOperationTargetBlock(editor, operation) {
   let block;
   return operation.type === "set_selection" && editor.selection ? block = editor.children[editor.selection.focus.path[0]] : "path" in operation && (block = editor.children[operation.path[0]]), block;
 }
-const debug$f = debugWithName("sync machine"), syncValueCallback = ({
+const debug$g = debugWithName("sync machine"), syncValueCallback = ({
   sendBack,
   input
 }) => {
@@ -2849,13 +2849,17 @@ const debug$f = debugWithName("sync machine"), syncValueCallback = ({
       context
     }) => {
       const editable = !context.readOnly, isProcessingLocalChanges = context.isProcessingLocalChanges, isChanging = isChangingRemotely(context.slateEditor) ?? !1, isBusy = editable && (isProcessingLocalChanges || isChanging);
-      return debug$f("isBusy", {
+      return debug$g("isBusy", {
         isBusy,
         editable,
         isProcessingLocalChanges,
         isChanging
       }), isBusy;
     },
+    "is new value": ({
+      context,
+      event
+    }) => event.type === "update value" && context.previousValue !== event.value,
     "value changed while syncing": ({
       context,
       event
@@ -2896,139 +2900,115 @@ const debug$f = debugWithName("sync machine"), syncValueCallback = ({
       actions: ["assign readOnly"]
     }
   },
-  type: "parallel",
+  initial: "idle",
   states: {
-    "setting up": {
-      initial: "syncing initial value",
-      states: {
-        "syncing initial value": {
-          entry: [() => {
-            debug$f("entry: syncing initial value");
-          }],
-          exit: [() => {
-            debug$f("exit: syncing initial value");
-          }],
-          always: {
-            guard: "initial value synced",
-            target: "done syncing initial value"
-          }
-        },
-        "done syncing initial value": {
-          entry: ["emit done syncing value", () => {
-            debug$f("entry: done syncing initial value");
-          }],
-          exit: [() => {
-            debug$f("exit: done syncing initial value");
-          }],
-          type: "final"
-        }
+    idle: {
+      entry: [() => {
+        debug$g("entry: syncing->idle");
+      }],
+      exit: [() => {
+        debug$g("exit: syncing->idle");
+      }],
+      on: {
+        "update value": [{
+          guard: and(["is busy", "is new value"]),
+          target: "busy",
+          actions: ["assign pending value"]
+        }, {
+          guard: "is new value",
+          target: "syncing",
+          actions: ["assign pending value"]
+        }, {
+          guard: not("initial value synced"),
+          actions: [() => {
+            debug$g("no new value \u2013 setting initial value as synced");
+          }, "assign initial value synced", "emit done syncing value"]
+        }, {
+          actions: [() => {
+            debug$g("no new value and initial value already synced");
+          }]
+        }]
+      }
+    },
+    busy: {
+      entry: [() => {
+        debug$g("entry: syncing->busy");
+      }],
+      exit: [() => {
+        debug$g("exit: syncing->busy");
+      }],
+      after: {
+        1e3: [{
+          guard: "is busy",
+          target: ".",
+          reenter: !0,
+          actions: [() => {
+            debug$g("reenter: syncing->busy");
+          }]
+        }, {
+          target: "syncing"
+        }]
+      },
+      on: {
+        "update value": [{
+          guard: "is new value",
+          actions: ["assign pending value"]
+        }]
       }
     },
     syncing: {
-      initial: "idle",
-      states: {
-        idle: {
-          entry: [() => {
-            debug$f("entry: syncing->idle");
-          }],
-          exit: [() => {
-            debug$f("exit: syncing->idle");
-          }],
-          on: {
-            "update value": [{
-              guard: "is busy",
-              target: "busy",
-              actions: ["assign pending value"]
-            }, {
-              target: "syncing",
-              actions: ["assign pending value"]
-            }]
-          }
-        },
-        busy: {
-          entry: [() => {
-            debug$f("entry: syncing->busy");
-          }],
-          exit: [() => {
-            debug$f("exit: syncing->busy");
-          }],
-          after: {
-            1e3: [{
-              guard: "is busy",
-              target: ".",
-              reenter: !0,
-              actions: [() => {
-                debug$f("reenter: syncing->busy");
-              }]
-            }, {
-              target: "syncing"
-            }]
+      entry: [() => {
+        debug$g("entry: syncing->syncing");
+      }, "emit syncing value"],
+      exit: [() => {
+        debug$g("exit: syncing->syncing");
+      }, "emit done syncing value"],
+      invoke: {
+        src: "sync value",
+        id: "sync value",
+        input: ({
+          context
+        }) => ({
+          context: {
+            keyGenerator: context.keyGenerator,
+            previousValue: context.previousValue,
+            readOnly: context.readOnly,
+            schema: context.schema
           },
-          on: {
-            "update value": [{
-              actions: ["assign pending value"]
-            }]
-          }
+          slateEditor: context.slateEditor,
+          streamBlocks: !context.initialValueSynced,
+          value: context.pendingValue
+        })
+      },
+      on: {
+        "update value": {
+          guard: "is new value",
+          actions: ["assign pending value"]
         },
-        syncing: {
-          entry: [() => {
-            debug$f("entry: syncing->syncing");
-          }, "emit syncing value"],
-          exit: [() => {
-            debug$f("exit: syncing->syncing");
-          }, "emit done syncing value"],
-          always: {
-            guard: "pending value equals previous value",
-            target: "idle",
-            actions: ["clear pending value", "assign initial value synced"]
-          },
-          invoke: {
-            src: "sync value",
-            id: "sync value",
-            input: ({
-              context
-            }) => ({
-              context: {
-                keyGenerator: context.keyGenerator,
-                previousValue: context.previousValue,
-                readOnly: context.readOnly,
-                schema: context.schema
-              },
-              slateEditor: context.slateEditor,
-              streamBlocks: !context.initialValueSynced,
-              value: context.pendingValue
-            })
-          },
-          on: {
-            "update value": {
-              actions: ["assign pending value"]
-            },
-            patch: {
-              actions: [emit(({
-                event
-              }) => event)]
-            },
-            "invalid value": {
-              actions: [emit(({
-                event
-              }) => event)]
-            },
-            "value changed": {
-              actions: [emit(({
-                event
-              }) => event)]
-            },
-            "done syncing": [{
-              guard: "value changed while syncing",
-              actions: ["assign previous value", "assign initial value synced"],
-              target: "syncing",
-              reenter: !0
-            }, {
-              target: "idle",
-              actions: ["clear pending value", "assign previous value", "assign initial value synced"]
-            }]
-          }
-        }
+        patch: {
+          actions: [emit(({
+            event
+          }) => event)]
+        },
+        "invalid value": {
+          actions: [emit(({
+            event
+          }) => event)]
+        },
+        "value changed": {
+          actions: [emit(({
+            event
+          }) => event)]
+        },
+        "done syncing": [{
+          guard: "value changed while syncing",
+          actions: ["assign previous value", "assign initial value synced"],
+          target: "syncing",
+          reenter: !0
+        }, {
+          target: "idle",
+          actions: ["clear pending value", "assign previous value", "assign initial value synced"]
+        }]
       }
     }
   }
@@ -3042,7 +3022,7 @@ async function updateValue({
 }) {
   let isChanged = !1, isValid = !0;
   const hadSelection = !!slateEditor.selection;
-  if ((!value || value.length === 0) && (debug$f("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
+  if ((!value || value.length === 0) && (debug$g("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
       withoutPatching(slateEditor, () => {
         hadSelection && Transforms.deselect(slateEditor);
@@ -3062,21 +3042,16 @@ async function updateValue({
     const slateValueFromProps = toSlateValue(value, {
       schemaTypes: context.schema
     });
-    await new Promise((resolve) => {
+    streamBlocks ? await new Promise((resolve) => {
       Editor.withoutNormalizing(slateEditor, () => {
         withRemoteChanges(slateEditor, () => {
           withoutPatching(slateEditor, async () => {
-            const childrenLength = slateEditor.children.length;
-            if (slateValueFromProps.length < childrenLength) {
-              for (let i = childrenLength - 1; i > slateValueFromProps.length - 1; i--)
-                Transforms.removeNodes(slateEditor, {
-                  at: [i]
-                });
-              isChanged = !0;
-            }
-            for await (const [currentBlock, currentBlockIndex] of getBlocks({
-              slateValue: slateValueFromProps,
-              streamBlocks
+            isChanged = removeExtraBlocks({
+              slateEditor,
+              slateValueFromProps
+            });
+            for await (const [currentBlock, currentBlockIndex] of getStreamedBlocks({
+              slateValue: slateValueFromProps
             })) {
               const {
                 blockChanged,
@@ -3095,17 +3070,41 @@ async function updateValue({
           });
         });
       });
+    }) : Editor.withoutNormalizing(slateEditor, () => {
+      withRemoteChanges(slateEditor, () => {
+        withoutPatching(slateEditor, () => {
+          isChanged = removeExtraBlocks({
+            slateEditor,
+            slateValueFromProps
+          });
+          let index = 0;
+          for (const currentBlock of slateValueFromProps) {
+            const {
+              blockChanged,
+              blockValid
+            } = syncBlock({
+              context,
+              sendBack,
+              block: currentBlock,
+              index,
+              slateEditor,
+              value
+            });
+            isChanged = blockChanged || isChanged, isValid = isValid && blockValid, index++;
+          }
+        });
+      });
     });
   }
   if (!isValid) {
-    debug$f("Invalid value, returning"), sendBack({
+    debug$g("Invalid value, returning"), sendBack({
       type: "done syncing",
       value
     });
     return;
   }
   if (isChanged) {
-    debug$f("Server value changed, syncing editor");
+    debug$g("Server value changed, syncing editor");
     try {
       slateEditor.onChange();
     } catch (err) {
@@ -3133,19 +3132,33 @@ async function updateValue({
       value
     });
   } else
-    debug$f("Server value and editor value is equal, no need to sync.");
+    debug$g("Server value and editor value is equal, no need to sync.");
   sendBack({
     type: "done syncing",
     value
   });
 }
-async function* getBlocks({
-  slateValue,
-  streamBlocks
+function removeExtraBlocks({
+  slateEditor,
+  slateValueFromProps
+}) {
+  let isChanged = !1;
+  const childrenLength = slateEditor.children.length;
+  if (slateValueFromProps.length < childrenLength) {
+    for (let i = childrenLength - 1; i > slateValueFromProps.length - 1; i--)
+      Transforms.removeNodes(slateEditor, {
+        at: [i]
+      });
+    isChanged = !0;
+  }
+  return isChanged;
+}
+async function* getStreamedBlocks({
+  slateValue
 }) {
   let index = 0;
   for await (const block of slateValue)
-    streamBlocks && index % 10 === 0 && await new Promise((resolve) => setTimeout(resolve, 0)), yield [block, index], index++;
+    index % 10 === 0 && await new Promise((resolve) => setTimeout(resolve, 0)), yield [block, index], index++;
 }
 function syncBlock({
   context,
@@ -3167,7 +3180,7 @@ function syncBlock({
               type: "patch",
               patch
             });
-          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$f.enabled && debug$f("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$f.enabled && debug$f("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$g.enabled && debug$g("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$g.enabled && debug$g("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -3175,9 +3188,9 @@ function syncBlock({
         }
         if (!oldBlock && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          debug$f.enabled && debug$f("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+          debug$g.enabled && debug$g("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
-          }) : (debug$f("Invalid", validation), sendBack({
+          }) : (debug$g("Invalid", validation), sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -3205,14 +3218,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$f("Removing child"), Transforms.removeNodes(slateEditor, {
+      childIndex > 0 && (debug$g("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$f("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$g("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";
@@ -3229,23 +3242,23 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$f("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode || (debug$g("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
             voids: !0
           }));
-        } else oldBlockChild ? (debug$f("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$g("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$f("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$g("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slateEditor.onChange());
     });
   }
 }
-const debug$e = debugWithName("component:PortableTextEditor:Synchronizer");
+const debug$f = debugWithName("component:PortableTextEditor:Synchronizer");
 function Synchronizer(props) {
   const $ = c(41), {
     editorActor,
@@ -3341,14 +3354,14 @@ function Synchronizer(props) {
   }, t12 = [syncActorRef, readOnly], $[26] = readOnly, $[27] = syncActorRef, $[28] = t11, $[29] = t12) : (t11 = $[28], t12 = $[29]), useEffect(t11, t12);
   let t13, t14;
   $[30] !== incomingValue || $[31] !== syncActorRef ? (t13 = () => {
-    debug$e("Value from props changed, syncing new value"), syncActorRef.send({
+    debug$f("Value from props changed, syncing new value"), syncActorRef.send({
       type: "update value",
       value: incomingValue
     });
   }, t14 = [syncActorRef, incomingValue], $[30] = incomingValue, $[31] = syncActorRef, $[32] = t13, $[33] = t14) : (t13 = $[32], t14 = $[33]), useEffect(t13, t14);
   let t15;
   $[34] !== editorActor || $[35] !== mutationActorRef ? (t15 = () => {
-    debug$e("Subscribing to patch events");
+    debug$f("Subscribing to patch events");
     const sub = editorActor.on("internal.patch", (event_1) => {
       mutationActorRef.send({
         ...event_1,
@@ -3356,7 +3369,7 @@ function Synchronizer(props) {
       });
     });
     return () => {
-      debug$e("Unsubscribing to patch events"), sub.unsubscribe();
+      debug$f("Unsubscribing to patch events"), sub.unsubscribe();
     };
   }, $[34] = editorActor, $[35] = mutationActorRef, $[36] = t15) : t15 = $[36];
   let t16;
@@ -3371,11 +3384,11 @@ function _temp$1(s) {
   return s.context.incomingValue;
 }
 Synchronizer.displayName = "Synchronizer";
-const debug$d = debugWithName("operationToPatches");
+const debug$e = debugWithName("operationToPatches");
 function createOperationToPatches(editorActor) {
   const textBlockName = editorActor.getSnapshot().context.schema.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$d.enabled && debug$d("Operation", JSON.stringify(operation, null, 2));
+    debug$e.enabled && debug$e("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");
@@ -3468,7 +3481,7 @@ function createOperationToPatches(editorActor) {
         _key: block.children[operation.path[1] - 1]._key
       }])];
     }
-    return debug$d("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$e("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches = [], splitBlock = editor.children[operation.path[0]];
@@ -3526,9 +3539,9 @@ function createOperationToPatches(editorActor) {
         _key: block._key
       }, "children", {
         _key: spanToRemove._key
-      }])] : (debug$d("Span not found in editor trying to remove node"), []);
+      }])] : (debug$e("Span not found in editor trying to remove node"), []);
     } else
-      return debug$d("Not creating patch inside object block"), [];
+      return debug$e("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -3554,7 +3567,7 @@ function createOperationToPatches(editorActor) {
         _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$d("Void nodes can't be merged, not creating any patches");
+      debug$e("Void nodes can't be merged, not creating any patches");
     return patches;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -3644,7 +3657,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$c = debugWithName("plugin:withPortableTextMarkModel");
+const debug$d = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
@@ -3658,7 +3671,7 @@ function createWithPortableTextMarkModel(editorActor) {
         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$c("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$d("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],
@@ -3671,7 +3684,7 @@ function createWithPortableTextMarkModel(editorActor) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$c("Adding .markDefs to block node"), editorActor.send({
+        debug$d("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           markDefs: []
@@ -3683,7 +3696,7 @@ function createWithPortableTextMarkModel(editorActor) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$c("Adding .marks to span node"), editorActor.send({
+        debug$d("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           marks: []
@@ -3697,7 +3710,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$c("Removing annotations from empty span node"), editorActor.send({
+          debug$d("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -3715,7 +3728,7 @@ function createWithPortableTextMarkModel(editorActor) {
           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$c("Removing orphaned annotations from span node"), editorActor.send({
+              debug$d("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3733,7 +3746,7 @@ function createWithPortableTextMarkModel(editorActor) {
         if (editor.isTextBlock(block)) {
           const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$c("Removing orphaned annotations from span node"), editorActor.send({
+            debug$d("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3751,7 +3764,7 @@ function createWithPortableTextMarkModel(editorActor) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$c("Removing duplicate markDefs"), editorActor.send({
+          debug$d("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3766,7 +3779,7 @@ function createWithPortableTextMarkModel(editorActor) {
       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$c("Removing markDef not in use"), editorActor.send({
+          debug$d("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3986,7 +3999,7 @@ function createWithPortableTextMarkModel(editorActor) {
         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$c("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
+          debug$d("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -5210,13 +5223,13 @@ function createWithObjectKeys(editorActor) {
     }, editor;
   };
 }
-const debug$b = debugWithName("applyPatches"), debugVerbose = debug$b.enabled && !0;
+const debug$c = debugWithName("applyPatches"), debugVerbose = debug$c.enabled && !0;
 function createApplyPatch(schema) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose && (debug$b(`
+    debugVerbose && (debug$c(`
 
-NEW PATCH =============================================================`), debug$b(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$c(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -5232,7 +5245,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$b("Unhandled patch", patch.type);
+          debug$c("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -5247,9 +5260,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$b("Block not found"), !1;
+    return debug$c("Block not found"), !1;
   if (!child || !childPath)
-    return debug$b("Child not found"), !1;
+    return debug$c("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, {
@@ -5279,9 +5292,9 @@ function insertPatch(editor, patch, schema) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$b("Block not found"), !1;
+    return debug$c("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$b("Ignoring patch targeting void value"), !1;
+    return debug$c("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -5289,7 +5302,7 @@ function insertPatch(editor, patch, schema) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes: schema
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$b(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$c(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -5298,14 +5311,14 @@ function insertPatch(editor, patch, schema) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$b("Child not found"), !1;
+    return debug$c("Child not found"), !1;
   const childrenToInsert = targetBlock && toSlateValue([{
     ...targetBlock,
     children: items
   }], {
     schemaTypes: schema
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$b(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$c(`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;
 }
@@ -5319,14 +5332,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$b("Block not found"), !1;
+    return debug$c("Block not found"), !1;
   const isTextBlock2 = editor.isTextBlock(block);
   if (isTextBlock2 && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$b("Ignoring setting void value"), !1;
+    return debug$c("Ignoring setting void value"), !1;
   if (debugState(editor, "before"), isTextBlock2 && child && childPath) {
     if (Text.isText(value) && Text.isText(child)) {
       const newText = child.text;
-      value.text !== newText && (debug$b("Setting text property"), editor.apply({
+      value.text !== newText && (debug$c("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -5338,7 +5351,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$b("Setting non-text property"), editor.apply({
+      debug$c("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -5346,7 +5359,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (Element$1.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$b("Setting block property");
+    debug$c("Setting block property");
     const {
       children,
       ...nextRest
@@ -5363,7 +5376,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$b("Setting children"), block.children.forEach((c2, cIndex) => {
+    }), debug$c("Setting children"), block.children.forEach((c2, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -5394,7 +5407,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$b("Removing everything"), debugState(editor, "before");
+    debug$c("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       Transforms.removeNodes(editor, {
@@ -5421,13 +5434,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$b("Block not found"), !1;
+      return debug$c("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$b(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), Transforms.removeNodes(editor, {
+    return debug$c(`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$b("Child not found"), !1) : (debug$b(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$b(`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$c("Child not found"), !1) : (debug$c(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$c(`Removing child at path ${JSON.stringify(childPath)}`), Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -5435,7 +5448,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose && (debug$b(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$b(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose && (debug$c(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$c(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -5477,7 +5490,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$a = debugWithName("plugin:withPatches");
+const debug$b = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -5502,7 +5515,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               for (const patch of patches) {
-                debug$a.enabled && debug$a(`Handling remote patch ${JSON.stringify(patch)}`);
+                debug$b.enabled && debug$b(`Handling remote patch ${JSON.stringify(patch)}`);
                 try {
                   changed = applyPatch(editor, patch);
                 } catch (error) {
@@ -5520,10 +5533,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$a("Subscribing to remote patches");
+      debug$b("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$a("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$b("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       let patches = [];
@@ -5577,7 +5590,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withPlaceholderBlock");
+const debug$a = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -5602,7 +5615,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$9("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$a("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -5611,7 +5624,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$8 = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$9 = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor) {
   const defaultStyle = editorActor.getSnapshot().context.schema.styles[0].name;
   return function(editor) {
@@ -5624,7 +5637,7 @@ function createWithPortableTextBlockStyle(editorActor) {
         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$8(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$9(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               style: defaultStyle
@@ -5675,7 +5688,7 @@ function createWithPortableTextSelections(editorActor) {
     }, editor;
   };
 }
-const debug$7 = debugWithName("plugin:withSchemaTypes");
+const debug$8 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor
 }) {
@@ -5687,7 +5700,7 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$7("Setting span type on text node without a type");
+        debug$8("Setting span type on text node without a type");
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -5703,7 +5716,7 @@ function createWithSchemaTypes({
         return;
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$7("Setting missing key on child node without a key");
+        debug$8("Setting missing key on child node without a key");
         const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -5764,12 +5777,12 @@ const withPlugins = (editor, options) => {
     editorActor
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
   return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
-}, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
+}, debug$7 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
 function createSlateEditor(config) {
   const existingSlateEditor = slateEditors.get(config.editorActor);
   if (existingSlateEditor)
-    return debug$6("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
-  debug$6("Creating new Slate editor instance", config.editorActor.id);
+    return debug$7("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
+  debug$7("Creating new Slate editor instance", config.editorActor.id);
   const unsubscriptions = [], subscriptions = [], instance = withPlugins(withReact(createEditor()), {
     editorActor: config.editorActor,
     subscriptions
@@ -6056,7 +6069,7 @@ function getEditorSnapshot({
     }
   };
 }
-const debug$5 = debugWithName("API:editable");
+const debug$6 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types = editorActor.getSnapshot().context.schema;
   return {
@@ -6189,7 +6202,7 @@ function createEditableAPI(editor, editorActor) {
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types.span.name && (debug$5("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      return isSpanNode && focusNode._type !== types.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), Transforms.insertNodes(editor, child, {
@@ -6334,18 +6347,18 @@ function createEditableAPI(editor, editorActor) {
           throw new Error("Invalid range");
         if (range) {
           if (!options?.mode || options?.mode === "selected") {
-            debug$5("Deleting content in selection"), Transforms.delete(editor, {
+            debug$6("Deleting content in selection"), Transforms.delete(editor, {
               at: range,
               hanging: !0,
               voids: !0
             }), editor.onChange();
             return;
           }
-          options?.mode === "blocks" && (debug$5("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
+          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element$1.isElement(node)
-          })), options?.mode === "children" && (debug$5("Deleting children touched by selection"), Transforms.removeNodes(editor, {
+          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types.span.name || // Text children
@@ -8104,7 +8117,7 @@ function isNativeBehaviorEvent(event) {
 function isCustomBehaviorEvent(event) {
   return event.type.startsWith("custom.");
 }
-const debug$4 = debugWithName("behaviors:event");
+const debug$5 = debugWithName("behaviors:event");
 function eventCategory(event) {
   return isNativeBehaviorEvent(event) ? "native" : isAbstractBehaviorEvent(event) ? "synthetic" : isCustomBehaviorEvent(event) ? "custom" : "synthetic";
 }
@@ -8119,7 +8132,7 @@ function performEvent({
   getSnapshot,
   nativeEvent
 }) {
-  debug$4(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  debug$5(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
   const eventBehaviors = [...remainingEventBehaviors, ...abstractBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
@@ -8128,7 +8141,7 @@ function performEvent({
   });
   if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
     nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
-      debug$4(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
+      debug$5(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
         context: {
           keyGenerator,
           schema
@@ -8271,7 +8284,7 @@ function performEvent({
     }
   }
   !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), withApplyingBehaviorOperations(editor, () => {
-    debug$4(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
+    debug$5(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
       context: {
         keyGenerator,
         schema
@@ -8359,7 +8372,7 @@ function createEditorSnapshot({
     }
   };
 }
-const editorMachine = setup({
+const debug$4 = debugWithName("editor machine"), editorMachine = setup({
   types: {
     context: {},
     events: {},
@@ -8640,6 +8653,12 @@ const editorMachine = setup({
           },
           states: {
             "determine initial edit mode": {
+              entry: [() => {
+                debug$4("entry: edit mode->read only->determine initial edit mode");
+              }],
+              exit: [() => {
+                debug$4("exit: edit mode->read only->determine initial edit mode");
+              }],
               on: {
                 "done syncing value": [{
                   target: "#editor.edit mode.read only.read only",
@@ -8652,6 +8671,12 @@ const editorMachine = setup({
               }
             },
             "read only": {
+              entry: [() => {
+                debug$4("entry: edit mode->read only->read only");
+              }],
+              exit: [() => {
+                debug$4("exit: edit mode->read only->read only");
+              }],
               on: {
                 "update readOnly": {
                   guard: ({
@@ -8691,6 +8716,12 @@ const editorMachine = setup({
           initial: "idle",
           states: {
             idle: {
+              entry: [() => {
+                debug$4("entry: edit mode->editable->idle");
+              }],
+              exit: [() => {
+                debug$4("exit: edit mode->editable-idle");
+              }],
               on: {
                 dragstart: {
                   actions: [assign({
@@ -8709,6 +8740,12 @@ const editorMachine = setup({
               initial: "checking if busy",
               states: {
                 "checking if busy": {
+                  entry: [() => {
+                    debug$4("entry: edit mode->editable->focusing->checking if busy");
+                  }],
+                  exit: [() => {
+                    debug$4("exit: edit mode->editable->focusing->checking if busy");
+                  }],
                   always: [{
                     guard: "slate is busy",
                     target: "busy"
@@ -8718,6 +8755,12 @@ const editorMachine = setup({
                   }]
                 },
                 busy: {
+                  entry: [() => {
+                    debug$4("entry: edit mode->editable->focusing-busy");
+                  }],
+                  exit: [() => {
+                    debug$4("exit: edit mode->editable->focusing->busy");
+                  }],
                   after: {
                     10: {
                       target: "checking if busy"
@@ -8727,7 +8770,12 @@ const editorMachine = setup({
               }
             },
             "dragging internally": {
-              exit: [({
+              entry: [() => {
+                debug$4("entry: edit mode->editable->dragging internally");
+              }],
+              exit: [() => {
+                debug$4("exit: edit mode->editable->dragging internally");
+              }, ({
                 context
               }) => {
                 if (context.internalDrag?.ghost)
@@ -8757,7 +8805,12 @@ const editorMachine = setup({
       initial: "setting up",
       states: {
         "setting up": {
-          exit: ["emit ready", "emit pending incoming patches", "clear pending incoming patches"],
+          entry: [() => {
+            debug$4("entry: setup->setting up");
+          }],
+          exit: [() => {
+            debug$4("exit: setup->setting up");
+          }, "emit ready", "emit pending incoming patches", "clear pending incoming patches"],
           on: {
             "internal.patch": {
               actions: "defer event"
@@ -8780,6 +8833,12 @@ const editorMachine = setup({
               initial: "idle",
               states: {
                 idle: {
+                  entry: [() => {
+                    debug$4("entry: setup->set up->value sync->idle");
+                  }],
+                  exit: [() => {
+                    debug$4("exit: setup->set up->value sync->idle");
+                  }],
                   on: {
                     patches: {
                       actions: [emit(({
@@ -8792,7 +8851,12 @@ const editorMachine = setup({
                   }
                 },
                 "syncing value": {
-                  exit: ["emit pending incoming patches", "clear pending incoming patches"],
+                  entry: [() => {
+                    debug$4("entry: setup->set up->value sync->syncing value");
+                  }],
+                  exit: [() => {
+                    debug$4("exit: setup->set up->value sync->syncing value");
+                  }, "emit pending incoming patches", "clear pending incoming patches"],
                   on: {
                     patches: {
                       actions: ["defer incoming patches"]
@@ -8811,6 +8875,12 @@ const editorMachine = setup({
                   initial: "idle",
                   states: {
                     idle: {
+                      entry: [() => {
+                        debug$4("entry: setup->set up->writing->pristine->idle");
+                      }],
+                      exit: [() => {
+                        debug$4("exit: setup->set up->writing->pristine->idle");
+                      }],
                       on: {
                         normalizing: {
                           target: "normalizing"
@@ -8826,6 +8896,12 @@ const editorMachine = setup({
                       }
                     },
                     normalizing: {
+                      entry: [() => {
+                        debug$4("entry: setup->set up->writing->pristine->normalizing");
+                      }],
+                      exit: [() => {
+                        debug$4("exit: setup->set up->writing->pristine->normalizing");
+                      }],
                       on: {
                         "done normalizing": {
                           target: "idle"
@@ -8841,7 +8917,12 @@ const editorMachine = setup({
                   }
                 },
                 dirty: {
-                  entry: ["emit pending events", "clear pending events"],
+                  entry: [() => {
+                    debug$4("entry: setup->set up->writing->dirty");
+                  }, "emit pending events", "clear pending events"],
+                  exit: [() => {
+                    debug$4("exit: setup->set up->writing->dirty");
+                  }],
                   on: {
                     "internal.patch": {
                       actions: "emit patch event"
@@ -9906,12 +9987,7 @@ const debug = debugWithName("component:Editable"), PortableTextEditable = forwar
       type: "range decorations updated",
       rangeDecorations: rangeDecorations ?? []
     });
-  }, [rangeDecorationsActor, rangeDecorations]), useMemo(() => {
-    if (readOnly)
-      return debug("Editable is in read only mode"), slateEditor;
-    const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
-    return debug("Editable is in edit mode"), withHotKeys(slateEditor);
-  }, [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
+  }, [rangeDecorationsActor, rangeDecorations]), useMemo(() => readOnly ? slateEditor : createWithHotkeys(editorActor, portableTextEditor, hotkeys)(slateEditor), [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
   const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(RenderElement, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, spellCheck }), [spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((leafProps) => /* @__PURE__ */ jsx(RenderLeaf, { ...leafProps, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder }), [readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder]), renderText = useCallback((props_0) => /* @__PURE__ */ jsx(RenderText, { ...props_0 }), []), restoreSelectionFromProps = useCallback(() => {
     if (propsSelection) {
       debug(`Selection from props ${JSON.stringify(propsSelection)}`);