@portabletext/editor 1.49.3 → 1.49.5

package/lib/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), useEditor = require("./_chunks-cjs/use-editor.cjs"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), noop = require("lodash/noop.js"), slate = require("slate"), slateReact = require("slate-react"), debug$h = require("debug"), util_isEqualSelectionPoints = require("./_chunks-cjs/util.is-equal-selection-points.cjs"), util_sliceBlocks = require("./_chunks-cjs/util.slice-blocks.cjs"), selector_isSelectionExpanded = require("./_chunks-cjs/selector.is-selection-expanded.cjs"), selector_isSelectingEntireBlocks = require("./_chunks-cjs/selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), util_selectionPointToBlockOffset = require("./_chunks-cjs/util.selection-point-to-block-offset.cjs"), isEqual = require("lodash/isEqual.js"), types = require("@sanity/types"), getRandomValues = require("get-random-values-esm"), behaviors_index = require("./behaviors/index.cjs"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), omit = require("lodash/omit.js"), util_childSelectionPointToBlockOffset = require("./_chunks-cjs/util.child-selection-point-to-block-offset.cjs"), startCase = require("lodash.startcase");
+var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), useEditor = require("./_chunks-cjs/use-editor.cjs"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), noop = require("lodash/noop.js"), slate = require("slate"), slateReact = require("slate-react"), debug$i = require("debug"), util_isEqualSelectionPoints = require("./_chunks-cjs/util.is-equal-selection-points.cjs"), util_sliceBlocks = require("./_chunks-cjs/util.slice-blocks.cjs"), selector_isSelectionExpanded = require("./_chunks-cjs/selector.is-selection-expanded.cjs"), selector_isSelectingEntireBlocks = require("./_chunks-cjs/selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), util_selectionPointToBlockOffset = require("./_chunks-cjs/util.selection-point-to-block-offset.cjs"), isEqual = require("lodash/isEqual.js"), types = require("@sanity/types"), getRandomValues = require("get-random-values-esm"), behaviors_index = require("./behaviors/index.cjs"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), omit = require("lodash/omit.js"), util_childSelectionPointToBlockOffset = require("./_chunks-cjs/util.child-selection-point-to-block-offset.cjs"), startCase = require("lodash.startcase");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$h), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase);
+var noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$i), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase);
 function EditorEventListener(props) {
   const $ = reactCompilerRuntime.c(5), editor = useEditor.useEditor(), on = useEffectEvent.useEffectEvent(props.on);
   let t0;
@@ -2505,7 +2505,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) || []);
@@ -2518,7 +2518,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: patches2,
         snapshot
@@ -2527,7 +2527,7 @@ function createWithUndoRedo(options) {
         patches2.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;
@@ -2543,7 +2543,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$g("Unsubscribing to patches"), sub.unsubscribe();
+        debug$h("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -2582,7 +2582,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();
@@ -2600,7 +2600,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) => {
@@ -2618,7 +2618,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+        debug$h("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
           undos: [],
           redos: []
         }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
@@ -2635,7 +2635,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) => {
@@ -2652,7 +2652,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+        debug$h("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
           undos: [],
           redos: []
         }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
@@ -2670,16 +2670,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual__default.default({
       _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__default.default({
       _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__default.default({
@@ -2766,7 +2766,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
 }) => {
@@ -2821,13 +2821,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
@@ -2868,139 +2872,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: xstate.and(["is busy", "is new value"]),
+          target: "busy",
+          actions: ["assign pending value"]
+        }, {
+          guard: "is new value",
+          target: "syncing",
+          actions: ["assign pending value"]
+        }, {
+          guard: xstate.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: [xstate.emit(({
-                event
-              }) => event)]
-            },
-            "invalid value": {
-              actions: [xstate.emit(({
-                event
-              }) => event)]
-            },
-            "value changed": {
-              actions: [xstate.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: [xstate.emit(({
+            event
+          }) => event)]
+        },
+        "invalid value": {
+          actions: [xstate.emit(({
+            event
+          }) => event)]
+        },
+        "value changed": {
+          actions: [xstate.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"]
+        }]
       }
     }
   }
@@ -3014,7 +2994,7 @@ async function updateValue({
 }) {
   let isChanged = !1, isValid = !0;
   const hadSelection = !!slateEditor.selection;
-  if ((!value || value.length === 0) && (debug$f("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
+  if ((!value || value.length === 0) && (debug$g("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
       withoutPatching(slateEditor, () => {
         hadSelection && slate.Transforms.deselect(slateEditor);
@@ -3034,21 +3014,16 @@ async function updateValue({
     const slateValueFromProps = toSlateValue(value, {
       schemaTypes: context.schema
     });
-    await new Promise((resolve) => {
+    streamBlocks ? await new Promise((resolve) => {
       slate.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--)
-                slate.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,
@@ -3067,17 +3042,41 @@ async function updateValue({
           });
         });
       });
+    }) : slate.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) {
@@ -3105,19 +3104,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--)
+      slate.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,
@@ -3139,7 +3152,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
@@ -3147,9 +3160,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 ? slate.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 ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
-          }) : (debug$f("Invalid", validation), sendBack({
+          }) : (debug$g("Invalid", validation), sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -3177,14 +3190,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"), slate.Transforms.removeNodes(slateEditor, {
+      childIndex > 0 && (debug$g("Removing child"), slate.Transforms.removeNodes(slateEditor, {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual__default.default(currentBlockChild, oldBlockChild), isTextChanged = !isEqual__default.default(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key) {
-          debug$f("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$g("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
           const isSpanNode = slate.Text.isText(currentBlockChild) && currentBlockChild._type === "span" && slate.Text.isText(oldBlockChild) && oldBlockChild._type === "span";
@@ -3201,23 +3214,23 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), slate.Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$f("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode || (debug$g("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
             voids: !0
           }));
-        } else oldBlockChild ? (debug$f("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$g("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$f("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$g("Inserting new child", currentBlockChild), slate.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 $ = reactCompilerRuntime.c(41), {
     editorActor,
@@ -3313,14 +3326,14 @@ function Synchronizer(props) {
   }, t12 = [syncActorRef, readOnly], $[26] = readOnly, $[27] = syncActorRef, $[28] = t11, $[29] = t12) : (t11 = $[28], t12 = $[29]), React.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]), React.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,
@@ -3328,7 +3341,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;
@@ -3343,11 +3356,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");
@@ -3440,7 +3453,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$1 = [], splitBlock = editor.children[operation.path[0]];
@@ -3498,9 +3511,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$1 = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -3526,7 +3539,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$1;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -3616,7 +3629,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$c = debugWithName("plugin:withPortableTextMarkModel");
+const debug$d = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
@@ -3630,7 +3643,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"
             }), slate.Transforms.mergeNodes(editor, {
               at: [childPath[0], childPath[1] + 1],
@@ -3643,7 +3656,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"
         }), slate.Transforms.setNodes(editor, {
           markDefs: []
@@ -3655,7 +3668,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"
         }), slate.Transforms.setNodes(editor, {
           marks: []
@@ -3669,7 +3682,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextSpan(node)) {
         const blockPath = slate.Path.parent(path), [block] = slate.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"
           }), slate.Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -3687,7 +3700,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"
               }), slate.Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3705,7 +3718,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"
             }), slate.Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3723,7 +3736,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"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3738,7 +3751,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) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
-          debug$c("Removing markDef not in use"), editorActor.send({
+          debug$d("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3958,7 +3971,7 @@ function createWithPortableTextMarkModel(editorActor) {
         const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-          debug$c("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
+          debug$d("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -5182,13 +5195,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(schema2) {
   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":
@@ -5204,7 +5217,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);
@@ -5219,9 +5232,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") || !slate.Text.isText(child))
     return !1;
   const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, {
@@ -5251,9 +5264,9 @@ function insertPatch(editor, patch, schema2) {
     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,
@@ -5261,7 +5274,7 @@ function insertPatch(editor, patch, schema2) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes: schema2
     }, 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"), slate.Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$c(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -5270,14 +5283,14 @@ function insertPatch(editor, patch, schema2) {
     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: schema2
   }, 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 && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$c(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -5291,14 +5304,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 isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && 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"), isTextBlock && child && childPath) {
     if (slate.Text.isText(value) && slate.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,
@@ -5310,7 +5323,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: {},
@@ -5318,7 +5331,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$b("Setting block property");
+    debug$c("Setting block property");
     const {
       children,
       ...nextRest
@@ -5335,7 +5348,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$b("Setting children"), block.children.forEach((c, cIndex) => {
+    }), debug$c("Setting children"), block.children.forEach((c, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -5366,7 +5379,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 slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       slate.Transforms.removeNodes(editor, {
@@ -5393,13 +5406,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"), slate.Transforms.removeNodes(editor, {
+    return debug$c(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
       at: [blockIndex]
     }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$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)}`), slate.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)}`), slate.Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -5407,7 +5420,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;
@@ -5449,7 +5462,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$a = debugWithName("plugin:withPatches");
+const debug$b = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -5474,7 +5487,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               for (const patch of patches2) {
-                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) {
@@ -5492,10 +5505,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$1 = [];
@@ -5549,7 +5562,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withPlaceholderBlock");
+const debug$a = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -5574,7 +5587,7 @@ function createWithPlaceholderBlock(editorActor) {
         const node = op.node;
         if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
           const nextPath = slate.Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$9("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$a("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -5583,7 +5596,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) {
@@ -5596,7 +5609,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] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$8(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$9(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               style: defaultStyle
@@ -5647,7 +5660,7 @@ function createWithPortableTextSelections(editorActor) {
     }, editor;
   };
 }
-const debug$7 = debugWithName("plugin:withSchemaTypes");
+const debug$8 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor
 }) {
@@ -5659,7 +5672,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"
@@ -5675,7 +5688,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"
@@ -5736,12 +5749,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(slateReact.withReact(slate.createEditor()), {
     editorActor: config.editorActor,
     subscriptions
@@ -6028,7 +6041,7 @@ function getEditorSnapshot({
     }
   };
 }
-const debug$5 = debugWithName("API:editable");
+const debug$6 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -6161,7 +6174,7 @@ function createEditableAPI(editor, editorActor) {
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types2.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types2.span.name && (debug$5("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      return isSpanNode && focusNode._type !== types2.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), slate.Transforms.insertNodes(editor, child, {
@@ -6306,18 +6319,18 @@ function createEditableAPI(editor, editorActor) {
           throw new Error("Invalid range");
         if (range) {
           if (!options?.mode || options?.mode === "selected") {
-            debug$5("Deleting content in selection"), slate.Transforms.delete(editor, {
+            debug$6("Deleting content in selection"), slate.Transforms.delete(editor, {
               at: range,
               hanging: !0,
               voids: !0
             }), editor.onChange();
             return;
           }
-          options?.mode === "blocks" && (debug$5("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
+          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && slate.Element.isElement(node)
-          })), options?.mode === "children" && (debug$5("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
+          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types2.span.name || // Text children
@@ -8076,7 +8089,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";
 }
@@ -8091,7 +8104,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;
@@ -8100,7 +8113,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: schema2
@@ -8243,7 +8256,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: schema2
@@ -8331,7 +8344,7 @@ function createEditorSnapshot({
     }
   };
 }
-const editorMachine = xstate.setup({
+const debug$4 = debugWithName("editor machine"), editorMachine = xstate.setup({
   types: {
     context: {},
     events: {},
@@ -8612,6 +8625,12 @@ const editorMachine = xstate.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",
@@ -8624,6 +8643,12 @@ const editorMachine = xstate.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: ({
@@ -8663,6 +8688,12 @@ const editorMachine = xstate.setup({
           initial: "idle",
           states: {
             idle: {
+              entry: [() => {
+                debug$4("entry: edit mode->editable->idle");
+              }],
+              exit: [() => {
+                debug$4("exit: edit mode->editable-idle");
+              }],
               on: {
                 dragstart: {
                   actions: [xstate.assign({
@@ -8681,6 +8712,12 @@ const editorMachine = xstate.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"
@@ -8690,6 +8727,12 @@ const editorMachine = xstate.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"
@@ -8699,7 +8742,12 @@ const editorMachine = xstate.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)
@@ -8729,7 +8777,12 @@ const editorMachine = xstate.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"
@@ -8752,6 +8805,12 @@ const editorMachine = xstate.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: [xstate.emit(({
@@ -8764,7 +8823,12 @@ const editorMachine = xstate.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"]
@@ -8783,6 +8847,12 @@ const editorMachine = xstate.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"
@@ -8798,6 +8868,12 @@ const editorMachine = xstate.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"
@@ -8813,7 +8889,12 @@ const editorMachine = xstate.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"
@@ -9878,12 +9959,7 @@ const debug = debugWithName("component:Editable"), PortableTextEditable = React.
       type: "range decorations updated",
       rangeDecorations: rangeDecorations ?? []
     });
-  }, [rangeDecorationsActor, rangeDecorations]), React.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]), React.useMemo(() => readOnly ? slateEditor : createWithHotkeys(editorActor, portableTextEditor, hotkeys)(slateEditor), [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
   const renderElement = React.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(RenderElement, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, spellCheck }), [spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = React.useCallback((leafProps) => /* @__PURE__ */ jsxRuntime.jsx(RenderLeaf, { ...leafProps, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder }), [readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder]), renderText = React.useCallback((props_0) => /* @__PURE__ */ jsxRuntime.jsx(RenderText, { ...props_0 }), []), restoreSelectionFromProps = React.useCallback(() => {
     if (propsSelection) {
       debug(`Selection from props ${JSON.stringify(propsSelection)}`);