@portabletext/editor 1.0.8 → 1.0.10

package/lib/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$l = require("debug"), types = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), flatten = require("lodash/flatten.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), content = require("@sanity/util/content"), debounce = require("lodash/debounce.js");
+var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), types = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), flatten = require("lodash/flatten.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), content = require("@sanity/util/content"), debounce = require("lodash/debounce.js");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$l), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce);
+var isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$m), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce);
 const rootName = "sanity-pte:";
 debug__default.default(rootName);
 function debugWithName(name) {
@@ -332,7 +332,7 @@ function getCounterContentForListLevel(level) {
       return "counter(listItemNumberNextNextNext) '. '";
   }
 }
-const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({ children, element, readOnly, blockRef }) => {
+const debug$l = debugWithName("components:DraggableBlock"), DraggableBlock = ({ children, element, readOnly, blockRef }) => {
   const editor = slateReact.useSlateStatic(), dragGhostRef = react.useRef(), [isDragOver, setIsDragOver] = react.useState(!1), isVoid = react.useMemo(() => slate.Editor.isVoid(editor, element), [editor, element]), isInline = react.useMemo(() => slate.Editor.isInline(editor, element), [editor, element]), [blockElement, setBlockElement] = react.useState(null);
   react.useEffect(
     () => setBlockElement(blockRef ? blockRef.current : slateReact.ReactEditor.toDOMNode(editor, element)),
@@ -359,18 +359,18 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({
     (event) => {
       const targetBlock = IS_DRAGGING_ELEMENT_TARGET.get(editor);
       if (targetBlock) {
-        IS_DRAGGING.set(editor, !1), event.preventDefault(), event.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$k("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
+        IS_DRAGGING.set(editor, !1), event.preventDefault(), event.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$l("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
         const dragPosition2 = IS_DRAGGING_BLOCK_TARGET_POSITION.get(editor);
         IS_DRAGGING_BLOCK_TARGET_POSITION.delete(editor);
         let targetPath = slateReact.ReactEditor.findPath(editor, targetBlock);
         const myPath = slateReact.ReactEditor.findPath(editor, element), isBefore = slate.Path.isBefore(myPath, targetPath);
         if (dragPosition2 === "bottom" && !isBefore) {
           if (targetPath[0] >= editor.children.length - 1) {
-            debug$k("target is already at the bottom, not moving");
+            debug$l("target is already at the bottom, not moving");
             return;
           }
           const originalPath = targetPath;
-          targetPath = slate.Path.next(targetPath), debug$k(
+          targetPath = slate.Path.next(targetPath), debug$l(
             `Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(
               targetPath
             )}`
@@ -378,29 +378,29 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({
         }
         if (dragPosition2 === "top" && isBefore && targetPath[0] !== editor.children.length - 1) {
           const originalPath = targetPath;
-          targetPath = slate.Path.previous(targetPath), debug$k(
+          targetPath = slate.Path.previous(targetPath), debug$l(
             `Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(
               targetPath
             )}`
           );
         }
         if (slate.Path.equals(targetPath, myPath)) {
-          event.preventDefault(), debug$k("targetPath and myPath is the same, not moving");
+          event.preventDefault(), debug$l("targetPath and myPath is the same, not moving");
           return;
         }
-        debug$k(
+        debug$l(
           `Moving element ${element._key} from path ${JSON.stringify(myPath)} to ${JSON.stringify(
             targetPath
           )} (${dragPosition2})`
         ), slate.Transforms.moveNodes(editor, { at: myPath, to: targetPath }), editor.onChange();
         return;
       }
-      debug$k("No target element, not doing anything");
+      debug$l("No target element, not doing anything");
     },
     [editor, element]
   ), handleDrop = react.useCallback(
     (event) => {
-      IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$k("On drop (prevented)", element), event.preventDefault(), event.stopPropagation(), setIsDragOver(!1));
+      IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$l("On drop (prevented)", element), event.preventDefault(), event.stopPropagation(), setIsDragOver(!1));
     },
     [editor, element]
   ), handleDrag = react.useCallback(
@@ -417,10 +417,10 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({
   ), handleDragStart = react.useCallback(
     (event) => {
       if (!isVoid || isInline) {
-        debug$k("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
+        debug$l("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
         return;
       }
-      if (debug$k("Drag start"), IS_DRAGGING.set(editor, !0), event.dataTransfer && (event.dataTransfer.setData("application/portable-text", "something"), event.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
+      if (debug$l("Drag start"), IS_DRAGGING.set(editor, !0), event.dataTransfer && (event.dataTransfer.setData("application/portable-text", "something"), event.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
         let dragGhost = blockElement.cloneNode(!0);
         const customGhost = dragGhost.querySelector("[data-pt-drag-ghost-element]");
         if (customGhost && (dragGhost = customGhost), dragGhost.setAttribute("data-dragged", ""), document.body) {
@@ -701,12 +701,12 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
-const debug$j = debugWithName("operationToPatches");
-debug$j.enabled = !1;
+const debug$k = debugWithName("operationToPatches");
+debug$k.enabled = !1;
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$j.enabled && debug$j("Operation", JSON.stringify(operation, null, 2));
+    debug$k.enabled && debug$k("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");
@@ -797,7 +797,7 @@ function createOperationToPatches(types2) {
         ])
       ];
     }
-    return debug$j("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$k("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]];
@@ -860,9 +860,9 @@ function createOperationToPatches(types2) {
       throw new Error("Block not found");
     } else if (editor.isTextBlock(block) && operation.path.length === 2) {
       const spanToRemove = editor.isTextBlock(block) && block.children && block.children[operation.path[1]];
-      return spanToRemove ? [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$j("Span not found in editor trying to remove node"), []);
+      return spanToRemove ? [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$k("Span not found in editor trying to remove node"), []);
     } else
-      return debug$j("Not creating patch inside object block"), [];
+      return debug$k("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], block = beforeValue[operation.path[0]], targetBlock = editor.children[operation.path[0]];
@@ -878,7 +878,7 @@ function createOperationToPatches(types2) {
         patches.set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
       ), mergedSpan && patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: mergedSpan._key }])));
     } else
-      debug$j("Void nodes can't be merged, not creating any patches");
+      debug$k("Void nodes can't be merged, not creating any patches");
     return patches$1;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -911,7 +911,7 @@ function createOperationToPatches(types2) {
     splitNodePatch
   };
 }
-const debug$i = debugWithName("API:editable");
+const debug$j = debugWithName("API:editable");
 function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
   return function(editor) {
     return portableTextEditor.setEditable({
@@ -994,7 +994,7 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           ],
           portableTextEditor
         )[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types$1.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-        return isSpanNode && focusNode._type !== types$1.span.name && (debug$i("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
+        return isSpanNode && focusNode._type !== types$1.span.name && (debug$j("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
           select: !0,
           at: editor.selection
         }), editor.onChange(), ((_a = toPortableTextRange(
@@ -1193,18 +1193,18 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
             throw new Error("Invalid range");
           if (range) {
             if (!(options != null && options.mode) || (options == null ? void 0 : options.mode) === "selected") {
-              debug$i("Deleting content in selection"), slate.Transforms.delete(editor, {
+              debug$j("Deleting content in selection"), slate.Transforms.delete(editor, {
                 at: range,
                 hanging: !0,
                 voids: !0
               }), editor.onChange();
               return;
             }
-            (options == null ? void 0 : options.mode) === "blocks" && (debug$i("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
+            (options == null ? void 0 : options.mode) === "blocks" && (debug$j("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 == null ? void 0 : options.mode) === "children" && (debug$i("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
+            })), (options == null ? void 0 : options.mode) === "children" && (debug$j("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
               at: range,
               voids: !0,
               match: (node) => node._type === types$1.span.name || // Text children
@@ -1215,7 +1215,7 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
       },
       removeAnnotation: (type) => {
         let { selection } = editor;
-        if (debug$i("Removing annotation", type), selection) {
+        if (debug$j("Removing annotation", type), selection) {
           if (slate.Range.isCollapsed(selection)) {
             const [node, nodePath] = slate.Editor.node(editor, selection, { depth: 2 });
             slate.Text.isText(node) && node.marks && typeof node.text == "string" && (slate.Transforms.select(editor, nodePath), selection = editor.selection);
@@ -2035,14 +2035,14 @@ function parse(textline) {
 function toInt(num) {
   return parseInt(num, 10);
 }
-const debug$h = debugWithName("applyPatches"), debugVerbose$3 = debug$h.enabled && !0;
+const debug$i = debugWithName("applyPatches"), debugVerbose$4 = debug$i.enabled && !0;
 function createApplyPatch(schemaTypes) {
   let previousPatch;
   return function(editor, patch) {
     let changed = !1;
-    debugVerbose$3 && (debug$h(`
+    debugVerbose$4 && (debug$i(`
 
-NEW PATCH =============================================================`), debug$h(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$i(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -2058,7 +2058,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$h("Unhandled patch", patch.type);
+          debug$i("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -2069,9 +2069,9 @@ NEW PATCH =============================================================`), debug
 function diffMatchPatch(editor, patch) {
   const { block, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$h("Block not found"), !1;
+    return debug$i("Block not found"), !1;
   if (!child || !childPath)
-    return debug$h("Child not found"), !1;
+    return debug$i("Child not found"), !1;
   if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child))
     return !1;
   const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
@@ -2089,40 +2089,40 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$h("Block not found"), !1;
+    return debug$i("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$h("Ignoring patch targeting void value"), !1;
+    return debug$i("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const { items: items2, position: position2 } = patch, blocksToInsert = toSlateValue(
       items2,
       { schemaTypes },
       KEY_TO_SLATE_ELEMENT.get(editor)
     ), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$h(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, { at: [normalizedIdx2] }), debugState(editor, "after"), !0;
+    return debug$i(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, { at: [normalizedIdx2] }), debugState(editor, "after"), !0;
   }
   const { items, position } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$h("Child not found"), !1;
+    return debug$i("Child not found"), !1;
   const childrenToInsert = targetBlock && toSlateValue(
     [{ ...targetBlock, children: items }],
     { schemaTypes },
     KEY_TO_SLATE_ELEMENT.get(editor)
   ), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$h(`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;
+  return debug$i(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, { at: childInsertPath }), debugState(editor, "after"), !0;
 }
 function setPatch(editor, patch) {
   let value = patch.value;
   typeof patch.path[3] == "string" && (value = {}, value[patch.path[3]] = patch.value);
   const { block, blockPath, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$h("Block not found"), !1;
+    return debug$i("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$h("Ignoring setting void value"), !1;
+    return debug$i("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$h("Setting text property"), editor.apply({
+      value.text !== newText && (debug$i("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -2134,7 +2134,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$h("Setting non-text property"), editor.apply({
+      debug$i("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -2142,14 +2142,14 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$h("Setting block property");
+    debug$i("Setting block property");
     const { children, ...nextRest } = value, { children: prevChildren, ...prevRest } = block || { children: void 0 };
     editor.apply({
       type: "set_node",
       path: blockPath,
       properties: { ...prevRest },
       newProperties: nextRest
-    }), debug$h("Setting children"), block.children.forEach((c, cIndex) => {
+    }), debug$i("Setting children"), block.children.forEach((c, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -2170,7 +2170,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch, previousPatch) {
   if (patch.path.length === 0) {
-    debug$h("Removing everything"), debugState(editor, "before");
+    debug$i("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return slate.Transforms.deselect(editor), editor.children.forEach((c, i) => {
       slate.Transforms.removeNodes(editor, { at: [i] });
@@ -2182,17 +2182,17 @@ function unsetPatch(editor, patch, previousPatch) {
   const { block, blockPath, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$h("Block not found"), !1;
+      return debug$i("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$h(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, { at: [blockIndex] }), debugState(editor, "after"), !0;
+    return debug$i(`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$h("Child not found"), !1) : (debug$h(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose$3 && debug$h(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, { at: childPath }), debugState(editor, "after"), !0) : !1;
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$i("Child not found"), !1) : (debug$i(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose$4 && debug$i(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, { at: childPath }), debugState(editor, "after"), !0) : !1;
 }
 function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose$3 && (debug$h(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$h(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose$4 && (debug$i(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$i(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -2231,7 +2231,7 @@ function withoutPatching(editor, fn) {
 function isPatching(editor) {
   return PATCHING.get(editor);
 }
-const debug$g = debugWithName("plugin:withUndoRedo"), debugVerbose$2 = debug$g.enabled && !1, SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$h = debugWithName("plugin:withUndoRedo"), debugVerbose$3 = debug$h.enabled && !1, 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) || []);
@@ -2244,13 +2244,13 @@ function createWithUndoRedo(options) {
     );
     const remotePatches = getRemotePatches(editor);
     patches$ && editor.subscriptions.push(() => {
-      debug$g("Subscribing to patches");
+      debug$h("Subscribing to patches");
       const sub = patches$.subscribe(({ patches: patches2, snapshot }) => {
         let reset = !1;
         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 = { undos: [], redos: [] }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
+              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;
               return;
             }
             remotePatches.push({ patch, time: /* @__PURE__ */ new Date(), snapshot, previousSnapshot });
@@ -2258,7 +2258,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$g("Unsubscribing to patches"), sub.unsubscribe();
+        debug$h("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = { undos: [], redos: [] };
     const { apply: apply2 } = editor;
@@ -2277,7 +2277,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();
@@ -2290,7 +2290,7 @@ function createWithUndoRedo(options) {
       const { undos } = editor.history;
       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) => {
@@ -2311,7 +2311,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$g("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
+            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), editor.onChange();
             return;
           }
           editor.history.redos.push(step), editor.history.undos.pop();
@@ -2323,7 +2323,7 @@ function createWithUndoRedo(options) {
       const { redos } = editor.history;
       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) => {
@@ -2344,7 +2344,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$g("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
+            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), editor.onChange();
             return;
           }
           editor.history.undos.push(step), editor.history.redos.pop();
@@ -2354,13 +2354,13 @@ function createWithUndoRedo(options) {
   };
 }
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
-  debugVerbose$2 && (debug$g(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$g(`Operation ${JSON.stringify(operation)}`), debug$g(`Patch ${JSON.stringify(patch)}`));
+  debugVerbose$3 && (debug$h(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$h(`Operation ${JSON.stringify(operation)}`), debug$h(`Patch ${JSON.stringify(patch)}`));
   const transformedOperation = { ...operation };
   if (patch.type === "insert" && patch.path.length === 1) {
     const insertBlockIndex = (snapshot || []).findIndex(
       (blk) => isEqual__default.default({ _key: blk._key }, patch.path[0])
     );
-    return debug$g(
+    return debug$h(
       `Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`
     ), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
   }
@@ -2368,12 +2368,12 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     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"), []) : (debugVerbose$2 && (debug$g(`Selection ${JSON.stringify(editor.selection)}`), debug$g(
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$h("Skipping transformation that targeted removed block"), []) : (debugVerbose$3 && (debug$h(`Selection ${JSON.stringify(editor.selection)}`), debug$h(
       `Adjusting block path (-1) for '${transformedOperation.type}' operation and patch '${patch.type}'`
     )), [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({ _key: operationTargetBlock._key }, patch.path[0]) ? [transformedOperation] : (parse(patch.value).forEach((diffPatch) => {
@@ -2436,7 +2436,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("plugin:withPatches");
+const debug$g = debugWithName("plugin:withPatches");
 function createWithPatches({
   change$,
   patches$,
@@ -2462,7 +2462,7 @@ function createWithPatches({
             withoutSaving(editor, () => {
               withPreserveKeys(editor, () => {
                 patches2.forEach((patch) => {
-                  debug$f.enabled && debug$f(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                  debug$g.enabled && debug$g(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
                 });
               });
             });
@@ -2474,10 +2474,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return patches$ && editor.subscriptions.push(() => {
-      debug$f("Subscribing to patches$");
+      debug$g("Subscribing to patches$");
       const sub = patches$.subscribe(handlePatches);
       return () => {
-        debug$f("Unsubscribing to patches$"), sub.unsubscribe();
+        debug$g("Unsubscribing to patches$"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       if (readOnly)
@@ -2555,7 +2555,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$e = debugWithName("plugin:withPlaceholderBlock");
+const debug$f = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock() {
   return function(editor) {
     const { apply: apply2 } = editor;
@@ -2564,14 +2564,14 @@ function createWithPlaceholderBlock() {
         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$e("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()));
+          editor.children[nextPath[0]] || (debug$f("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()));
         }
       }
       apply2(op);
     }, editor;
   };
 }
-const debug$d = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$e = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(types2) {
   const defaultStyle = types2.styles[0].value;
   return function(editor) {
@@ -2583,7 +2583,7 @@ function createWithPortableTextBlockStyle(types2) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$d(`Normalizing split node to ${defaultStyle} style`, op), slate.Transforms.setNodes(editor, { style: defaultStyle }, { at: [op.path[0] + 1], voids: !1 });
+            debug$e(`Normalizing split node to ${defaultStyle} style`, op), slate.Transforms.setNodes(editor, { style: defaultStyle }, { at: [op.path[0] + 1], voids: !1 });
             break;
           }
         }
@@ -2599,9 +2599,9 @@ function createWithPortableTextBlockStyle(types2) {
           match: (node) => editor.isTextBlock(node)
         })
       ].forEach(([node, path]) => {
-        editor.isTextBlock(node) && node.style === blockStyle ? (debug$d(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(editor, { ...node, style: defaultStyle }, {
+        editor.isTextBlock(node) && node.style === blockStyle ? (debug$e(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(editor, { ...node, style: defaultStyle }, {
           at: path
-        })) : (blockStyle ? debug$d(`Setting style '${blockStyle}'`) : debug$d("Setting default style", defaultStyle), slate.Transforms.setNodes(
+        })) : (blockStyle ? debug$e(`Setting style '${blockStyle}'`) : debug$e("Setting default style", defaultStyle), slate.Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2613,11 +2613,11 @@ function createWithPortableTextBlockStyle(types2) {
     }, editor;
   };
 }
-const debug$c = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
+const debug$d = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
 function createWithPortableTextLists(types2) {
   return function(editor) {
     return editor.pteToggleListItem = (listItemStyle) => {
-      editor.pteHasListStyle(listItemStyle) ? (debug$c(`Remove list item '${listItemStyle}'`), editor.pteUnsetListItem(listItemStyle)) : (debug$c(`Add list item '${listItemStyle}'`), editor.pteSetListItem(listItemStyle));
+      editor.pteHasListStyle(listItemStyle) ? (debug$d(`Remove list item '${listItemStyle}'`), editor.pteUnsetListItem(listItemStyle)) : (debug$d(`Add list item '${listItemStyle}'`), editor.pteSetListItem(listItemStyle));
     }, editor.pteUnsetListItem = (listItemStyle) => {
       editor.selection && [
         ...slate.Editor.nodes(editor, {
@@ -2631,7 +2631,7 @@ function createWithPortableTextLists(types2) {
             listItem: void 0,
             level: void 0
           };
-          debug$c(`Unsetting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, newNode, { at: path });
+          debug$d(`Unsetting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, newNode, { at: path });
         }
       });
     }, editor.pteSetListItem = (listItemStyle) => {
@@ -2641,7 +2641,7 @@ function createWithPortableTextLists(types2) {
           match: (node) => editor.isTextBlock(node)
         })
       ].forEach(([node, path]) => {
-        debug$c(`Setting list '${listItemStyle}'`), slate.Transforms.setNodes(
+        debug$d(`Setting list '${listItemStyle}'`), slate.Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2661,7 +2661,7 @@ function createWithPortableTextLists(types2) {
         })
       ];
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
-        slate.Element.isElement(node) && (debug$c("Unset list"), slate.Transforms.setNodes(
+        slate.Element.isElement(node) && (debug$d("Unset list"), slate.Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2683,7 +2683,7 @@ function createWithPortableTextLists(types2) {
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
         if (editor.isListBlock(node)) {
           let level = node.level || 1;
-          reverse ? (level--, debug$c("Decrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))) : (level++, debug$c("Incrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))), slate.Transforms.setNodes(
+          reverse ? (level--, debug$d("Decrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))) : (level++, debug$d("Incrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))), slate.Transforms.setNodes(
             editor,
             { level: Math.min(MAX_LIST_LEVEL, Math.max(1, level)) },
             { at: path }
@@ -2705,7 +2705,7 @@ function createWithPortableTextLists(types2) {
     }, editor;
   };
 }
-const debug$b = debugWithName("plugin:withPortableTextMarkModel");
+const debug$c = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(types2, change$) {
   return function(editor) {
     const { apply: apply2, normalizeNode } = editor, decorators = types2.decorators.map((t) => t.value), forceNewSelection = () => {
@@ -2726,7 +2726,7 @@ function createWithPortableTextMarkModel(types2, change$) {
       ) && mergeSpans(editor);
       const [node, path] = nodeEntry, isSpan = slate.Text.isText(node) && node._type === types2.span.name, isTextBlock = editor.isTextBlock(node);
       if (isSpan || isTextBlock) {
-        if (isSpan && !Array.isArray(node.marks) && (debug$b("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path }), editor.onChange()), isSpan && (node.marks || []).length > 0) {
+        if (isSpan && !Array.isArray(node.marks) && (debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path }), editor.onChange()), isSpan && (node.marks || []).length > 0) {
           const spanMarks = node.marks || EMPTY_MARKS$1, annotationMarks = spanMarks.filter(
             (mark) => !types2.decorators.map((dec) => dec.value).includes(mark)
           );
@@ -2737,7 +2737,7 @@ function createWithPortableTextMarkModel(types2, change$) {
                 return !((_a = block.markDefs) != null && _a.find((def) => def._key === mark));
               }
             ) || [];
-            orphanedMarks.length > 0 && (debug$b("Removing orphaned .marks from span node"), slate.Transforms.setNodes(
+            orphanedMarks.length > 0 && (debug$c("Removing orphaned .marks from span node"), slate.Transforms.setNodes(
               editor,
               { marks: spanMarks.filter((mark) => !orphanedMarks.includes(mark)) },
               { at: path }
@@ -2747,14 +2747,14 @@ function createWithPortableTextMarkModel(types2, change$) {
         for (const op of editor.operations) {
           if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
             const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
-            if (debug$b("Copying markDefs over to merged block", op), editor.isTextBlock(targetBlock)) {
+            if (debug$c("Copying markDefs over to merged block", op), editor.isTextBlock(targetBlock)) {
               const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
               isEqual__default.default(newMarkDefs, targetBlock.markDefs) || (slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 }), editor.onChange());
             }
           }
           if (op.type === "split_node" && op.path.length === 1 && slate.Element.isElementProps(op.properties) && op.properties._type === types2.block.name && "markDefs" in op.properties && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] + 1 < editor.children.length) {
             const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] + 1]);
-            if (debug$b("Copying markDefs over to split block", op), editor.isTextBlock(targetBlock)) {
+            if (debug$c("Copying markDefs over to split block", op), editor.isTextBlock(targetBlock)) {
               const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [];
               slate.Transforms.setNodes(
                 editor,
@@ -2778,7 +2778,7 @@ function createWithPortableTextMarkModel(types2, change$) {
         (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)));
-        node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs) && (debug$b("Removing markDef not in use"), slate.Transforms.setNodes(
+        node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs) && (debug$c("Removing markDef not in use"), slate.Transforms.setNodes(
           editor,
           {
             markDefs: newMarkDefs
@@ -2811,7 +2811,7 @@ function createWithPortableTextMarkModel(types2, change$) {
               editor,
               { marks: marksWithoutAnnotationMarks },
               { at: slate.Path.next(selection.focus.path) }
-            ), debug$b("Inserting text at end of annotation");
+            ), debug$c("Inserting text at end of annotation");
             return;
           }
         }
@@ -2903,7 +2903,7 @@ function createWithPortableTextMarkModel(types2, change$) {
         ...slate.Editor.marks(editor) || {}
       }.marks || []).includes(mark);
     }, editor.pteToggleMark = (mark) => {
-      editor.pteIsMarkActive(mark) ? (debug$b(`Remove mark '${mark}'`), slate.Editor.removeMark(editor, mark)) : (debug$b(`Add mark '${mark}'`), slate.Editor.addMark(editor, mark, !0));
+      editor.pteIsMarkActive(mark) ? (debug$c(`Remove mark '${mark}'`), slate.Editor.removeMark(editor, mark)) : (debug$c(`Add mark '${mark}'`), slate.Editor.addMark(editor, mark, !0));
     }, editor;
   };
   function mergeSpans(editor) {
@@ -2917,12 +2917,12 @@ function createWithPortableTextMarkModel(types2, change$) {
         const [parent] = path.length > 1 ? slate.Editor.node(editor, slate.Path.parent(path)) : [void 0], nextPath = [path[0], path[1] + 1];
         if (editor.isTextBlock(parent)) {
           const nextNode = parent.children[nextPath[1]];
-          slate.Text.isText(node) && slate.Text.isText(nextNode) && isEqual__default.default(nextNode.marks, node.marks) && (debug$b("Merging spans"), slate.Transforms.mergeNodes(editor, { at: nextPath, voids: !0 }), editor.onChange());
+          slate.Text.isText(node) && slate.Text.isText(nextNode) && isEqual__default.default(nextNode.marks, node.marks) && (debug$c("Merging spans"), slate.Transforms.mergeNodes(editor, { at: nextPath, voids: !0 }), editor.onChange());
         }
       }
   }
 }
-const debug$a = debugWithName("plugin:withPortableTextSelections"), debugVerbose$1 = debug$a.enabled && !1;
+const debug$b = debugWithName("plugin:withPortableTextSelections"), debugVerbose$2 = debug$b.enabled && !1;
 function createWithPortableTextSelections(change$, types2) {
   let prevSelection = null;
   return function(editor) {
@@ -2938,7 +2938,7 @@ function createWithPortableTextSelections(change$, types2) {
             ptRange = toPortableTextRange(value, editor.selection, types2), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
           }
         }
-        debugVerbose$1 && debug$a(
+        debugVerbose$2 && debug$b(
           `Emitting selection ${JSON.stringify(ptRange || null)} (${JSON.stringify(
             editor.selection
           )})`
@@ -2952,7 +2952,7 @@ function createWithPortableTextSelections(change$, types2) {
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withSchemaTypes");
+const debug$a = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   schemaTypes,
   keyGenerator
@@ -2963,12 +2963,12 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$9("Setting span type on text node without a type");
+        debug$a("Setting span type on text node without a type");
         const span = node, key = span._key || keyGenerator();
         slate.Transforms.setNodes(editor, { ...span, _type: schemaTypes.span.name, _key: key }, { at: path });
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$9("Setting missing key on child node without a key");
+        debug$a("Setting missing key on child node without a key");
         const key = keyGenerator();
         slate.Transforms.setNodes(editor, { _key: key }, { at: path });
       }
@@ -2976,7 +2976,7 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
-const debug$8 = debugWithName("plugin:withUtils");
+const debug$9 = debugWithName("plugin:withUtils");
 function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
   return function(editor) {
     return editor.pteExpandToWord = () => {
@@ -2984,18 +2984,18 @@ function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
       if (selection && !slate.Range.isExpanded(selection)) {
         const [textNode] = slate.Editor.node(editor, selection.focus, { depth: 2 });
         if (!textNode || !slate.Text.isText(textNode) || textNode.text.length === 0) {
-          debug$8("pteExpandToWord: Can't expand to word here");
+          debug$9("pteExpandToWord: Can't expand to word here");
           return;
         }
         const { focus } = selection, focusOffset = focus.offset, charsBefore = textNode.text.slice(0, focusOffset), charsAfter = textNode.text.slice(focusOffset, -1), isEmpty = (str) => str.match(/\s/g), whiteSpaceBeforeIndex = charsBefore.split("").reverse().findIndex((str) => isEmpty(str)), newStartOffset = whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0, whiteSpaceAfterIndex = charsAfter.split("").findIndex((obj) => isEmpty(obj)), newEndOffset = charsBefore.length + (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1);
         if (!(newStartOffset === newEndOffset || isNaN(newStartOffset) || isNaN(newEndOffset))) {
-          debug$8("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
+          debug$9("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
             anchor: { ...selection.anchor, offset: newStartOffset },
             focus: { ...selection.focus, offset: newEndOffset }
           });
           return;
         }
-        debug$8("pteExpandToWord: Can't expand to word here");
+        debug$9("pteExpandToWord: Can't expand to word here");
       }
     }, editor.pteCreateEmptyBlock = () => toSlateValue(
       [
@@ -3018,7 +3018,7 @@ function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
     )[0], editor;
   };
 }
-const debug$7 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
+const debug$8 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
   marks: {
     "mod+b": "strong",
     "mod+i": "em",
@@ -3031,7 +3031,7 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions || DEFAULT_HOTKEYS;
   return function(editor) {
     return editor.pteWithHotKeys = (event) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c, _d, _e, _f;
       Object.keys(activeHotkeys).forEach((cat) => {
         if (cat === "marks")
           for (const hotkey in activeHotkeys[cat]) {
@@ -3042,7 +3042,7 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
               const possibleMark = activeHotkeys[cat];
               if (possibleMark) {
                 const mark = possibleMark[hotkey];
-                debug$7(`HotKey ${hotkey} to toggle ${mark}`), editor.pteToggleMark(mark);
+                debug$8(`HotKey ${hotkey} to toggle ${mark}`), editor.pteToggleMark(mark);
               }
             }
           }
@@ -3087,7 +3087,7 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
       if (isBackspace && editor.selection && editor.selection.focus.path[0] > 0 && slate.Range.isCollapsed(editor.selection)) {
         const prevPath = slate.Path.previous(editor.selection.focus.path.slice(0, 1)), prevBlock = slate.Node.descendant(editor, prevPath), focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
         if (prevBlock && focusBlock && slate.Editor.isVoid(editor, prevBlock) && editor.selection.focus.offset === 0) {
-          debug$7("Preventing deleting void block above"), event.preventDefault(), event.stopPropagation();
+          debug$8("Preventing deleting void block above"), event.preventDefault(), event.stopPropagation();
           const isTextBlock = types.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && ((_d = (_c = focusBlock.children) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) === "";
           if (!isTextBlock || isEmptyFocusBlock) {
             slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, prevPath), editor.onChange();
@@ -3104,9 +3104,9 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
         const nextBlock = slate.Node.descendant(
           editor,
           slate.Path.next(editor.selection.focus.path.slice(0, 1))
-        ), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-        if (nextBlock && focusBlock && !slate.Editor.isVoid(editor, focusBlock) && slate.Editor.isVoid(editor, nextBlock)) {
-          debug$7("Preventing deleting void block below"), event.preventDefault(), event.stopPropagation(), slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, focusBlockPath), editor.onChange();
+        ), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath), isEmptyFocusBlock = types.isPortableTextTextBlock(focusBlock) && focusBlock.children.length === 1 && ((_f = (_e = focusBlock.children) == null ? void 0 : _e[0]) == null ? void 0 : _f.text) === "";
+        if (nextBlock && focusBlock && !slate.Editor.isVoid(editor, focusBlock) && slate.Editor.isVoid(editor, nextBlock) && isEmptyFocusBlock) {
+          debug$8("Preventing deleting void block below"), event.preventDefault(), event.stopPropagation(), slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, focusBlockPath), editor.onChange();
           return;
         }
       }
@@ -3406,7 +3406,7 @@ function validateValue(value, types$1, keyGenerator) {
     return !1;
   }) && (valid = !1), { valid, resolution, value });
 }
-const debug$6 = debugWithName("plugin:withInsertData");
+const debug$7 = debugWithName("plugin:withInsertData");
 function createWithInsertData(change$, schemaTypes, keyGenerator) {
   return function(editor) {
     const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => {
@@ -3445,13 +3445,13 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
       const asHTML = div.innerHTML;
       contents.ownerDocument.body.removeChild(div);
       const fragment = editor.getFragment(), portableText = fromSlateValue(fragment, blockTypeName), asJSON = JSON.stringify(portableText), asPlainText = toPlainText(portableText);
-      data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$6("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$6("Set fragment data", asJSON, asHTML);
+      data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$7("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$7("Set fragment data", asJSON, asHTML);
     }, editor.insertPortableTextData = (data) => {
       var _a, _b;
       if (!editor.selection)
         return !1;
       const pText = data.getData("application/x-portable-text"), origin = data.getData("application/x-portable-text-event-origin");
-      if (debug$6(`Inserting portable text from ${origin} event`, pText), pText) {
+      if (debug$7(`Inserting portable text from ${origin} event`, pText), pText) {
         const parsed = JSON.parse(pText);
         if (Array.isArray(parsed) && parsed.length > 0) {
           const slateValue = _regenerateKeys(
@@ -3469,7 +3469,7 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
               name: "pasteError",
               description: errorDescription,
               data: validation
-            }), debug$6("Invalid insert result", validation), !1;
+            }), debug$7("Invalid insert result", validation), !1;
           }
           return _insertFragment(editor, slateValue, schemaTypes), !0;
         }
@@ -3478,11 +3478,11 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
     }, editor.insertTextOrHTMLData = (data) => {
       var _a;
       if (!editor.selection)
-        return debug$6("No selection, not inserting"), !1;
+        return debug$7("No selection, not inserting"), !1;
       change$.next({ type: "loading", isLoading: !0 });
       const html = data.getData("text/html"), text = data.getData("text/plain");
       if (html || text) {
-        debug$6("Inserting data", data);
+        debug$7("Inserting data", data);
         let portableText, fragment, insertedType;
         if (html) {
           if (portableText = blockTools.htmlToBlocks(html, schemaTypes.portableText, {
@@ -3510,9 +3510,9 @@ Try to insert as plain text (shift-paste) instead.`;
             name: "pasteError",
             description: errorDescription,
             data: validation
-          }), debug$6("Invalid insert result", validation), !1;
+          }), debug$7("Invalid insert result", validation), !1;
         }
-        return debug$6(`Inserting ${insertedType} fragment at ${JSON.stringify(editor.selection)}`), _insertFragment(editor, fragment, schemaTypes), change$.next({ type: "loading", isLoading: !1 }), !0;
+        return debug$7(`Inserting ${insertedType} fragment at ${JSON.stringify(editor.selection)}`), _insertFragment(editor, fragment, schemaTypes), change$.next({ type: "loading", isLoading: !1 }), !0;
       }
       return change$.next({ type: "loading", isLoading: !1 }), !1;
     }, editor.insertData = (data) => {
@@ -3580,7 +3580,7 @@ function _insertFragment(editor, fragment, schemaTypes) {
     const [focusBlock, focusPath] = slate.Editor.node(editor, editor.selection, { depth: 1 });
     if (editor.isTextBlock(focusBlock) && editor.isTextBlock(fragment[0])) {
       const { markDefs } = focusBlock;
-      debug$6("Mixing markDefs of focusBlock and fragments[0] block", markDefs, fragment[0].markDefs), isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(
+      debug$7("Mixing markDefs of focusBlock and fragments[0] block", markDefs, fragment[0].markDefs), isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(
         editor,
         {
           markDefs: uniq__default.default([...fragment[0].markDefs || [], ...markDefs || []])
@@ -3663,10 +3663,10 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
       };
     }
   };
-}, debug$5 = debugWithName("component:PortableTextEditor:SlateContainer");
+}, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer");
 function SlateContainer(props) {
   const { patches$, portableTextEditor, readOnly, maxBlocks, keyGenerator } = props, [[slateEditor, subscribe]] = react.useState(() => {
-    debug$5("Creating new Slate editor instance");
+    debug$6("Creating new Slate editor instance");
     const { editor, subscribe: _sub } = withPlugins(slateReact.withReact(slate.createEditor()), {
       keyGenerator,
       maxBlocks,
@@ -3682,7 +3682,7 @@ function SlateContainer(props) {
       unsubscribe();
     };
   }, [subscribe]), react.useEffect(() => {
-    debug$5("Re-initializing plugin chain"), withPlugins(slateEditor, {
+    debug$6("Re-initializing plugin chain"), withPlugins(slateEditor, {
       keyGenerator,
       maxBlocks,
       patches$,
@@ -3692,7 +3692,7 @@ function SlateContainer(props) {
   }, [keyGenerator, portableTextEditor, maxBlocks, readOnly, patches$, slateEditor]);
   const initialValue = react.useMemo(() => [slateEditor.pteCreateEmptyBlock()], [slateEditor]);
   return react.useEffect(() => () => {
-    debug$5("Destroying Slate editor"), slateEditor.destroy();
+    debug$6("Destroying Slate editor"), slateEditor.destroy();
   }, [slateEditor]), /* @__PURE__ */ jsxRuntime.jsx(slateReact.Slate, { editor: slateEditor, initialValue, children: props.children });
 }
 const defaultKeyGenerator = () => content.randomKey(12), PortableTextEditorKeyGeneratorContext = react.createContext(defaultKeyGenerator), usePortableTextEditorKeyGenerator = () => {
@@ -3702,31 +3702,22 @@ const defaultKeyGenerator = () => content.randomKey(12), PortableTextEditorKeyGe
       "The `usePortableTextEditorKeyGenerator` hook must be used inside the <PortableTextEditor> component's context."
     );
   return keyGenerator;
-}, PortableTextEditorSelectionContext = react.createContext(null), usePortableTextEditorSelection = () => {
-  const selection = react.useContext(PortableTextEditorSelectionContext);
-  if (selection === void 0)
-    throw new Error(
-      "The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context."
-    );
-  return selection;
-}, PortableTextEditorValueContext = react.createContext(
-  void 0
-), PortableTextEditorReadOnlyContext = react.createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
+}, PortableTextEditorReadOnlyContext = react.createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
   const readOnly = react.useContext(PortableTextEditorReadOnlyContext);
   if (readOnly === void 0)
     throw new Error(
       "The `usePortableTextEditorReadOnly` hook must be used inside the <PortableTextEditor> component's context."
     );
   return readOnly;
-}, debug$4 = debugWithName("hook:useSyncValue"), CURRENT_VALUE = /* @__PURE__ */ new WeakMap();
+}, debug$5 = debugWithName("hook:useSyncValue"), CURRENT_VALUE = /* @__PURE__ */ new WeakMap();
 function useSyncValue(props) {
   const { portableTextEditor, readOnly, keyGenerator } = props, { change$, schemaTypes } = portableTextEditor, previousValue = react.useRef(), slateEditor = slateReact.useSlate(), updateValueFunctionRef = react.useRef(), updateFromCurrentValue = react.useCallback(() => {
     const currentValue = CURRENT_VALUE.get(portableTextEditor);
     if (previousValue.current === currentValue) {
-      debug$4("Value is the same object as previous, not need to sync");
+      debug$5("Value is the same object as previous, not need to sync");
       return;
     }
-    updateValueFunctionRef.current && currentValue && (debug$4("Updating the value debounced"), updateValueFunctionRef.current(currentValue));
+    updateValueFunctionRef.current && currentValue && (debug$5("Updating the value debounced"), updateValueFunctionRef.current(currentValue));
   }, [portableTextEditor]), updateValueDebounced = react.useMemo(
     () => debounce__default.default(updateFromCurrentValue, 1e3, { trailing: !0, leading: !1 }),
     [updateFromCurrentValue]
@@ -3737,17 +3728,17 @@ function useSyncValue(props) {
       const isProcessingLocalChanges = isChangingLocally(slateEditor), isProcessingRemoteChanges = isChangingRemotely(slateEditor);
       if (!readOnly) {
         if (isProcessingLocalChanges) {
-          debug$4("Has local changes, not syncing value right now"), updateValueDebounced();
+          debug$5("Has local changes, not syncing value right now"), updateValueDebounced();
           return;
         }
         if (isProcessingRemoteChanges) {
-          debug$4("Has remote changes, not syncing value right now"), updateValueDebounced();
+          debug$5("Has remote changes, not syncing value right now"), updateValueDebounced();
           return;
         }
       }
       let isChanged = !1, isValid = !0;
       const hadSelection = !!slateEditor.selection;
-      if ((!value || value.length === 0) && (debug$4("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
+      if ((!value || value.length === 0) && (debug$5("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
         withoutSaving(slateEditor, () => {
           withoutPatching(slateEditor, () => {
             hadSelection && slate.Transforms.deselect(slateEditor);
@@ -3784,7 +3775,7 @@ function useSyncValue(props) {
                       `${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${(_c = validation.resolution) == null ? void 0 : _c.description}`
                     ), validation.resolution.patches.forEach((patch) => {
                       change$.next({ type: "patch", patch });
-                    })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$4.enabled && debug$4("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$4.enabled && debug$4("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), isChanged = !0) : (change$.next({
+                    })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$5.enabled && debug$5("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$5.enabled && debug$5("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), isChanged = !0) : (change$.next({
                       type: "invalidValue",
                       resolution: validation.resolution,
                       value
@@ -3792,14 +3783,14 @@ function useSyncValue(props) {
                   }
                   if (!oldBlock && isValid) {
                     const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, schemaTypes, keyGenerator);
-                    debug$4.enabled && debug$4(
+                    debug$5.enabled && debug$5(
                       "Validating and inserting new block in the end of the value",
                       currentBlock
                     ), validation.valid || (_e = validation.resolution) != null && _e.autoResolve ? withPreserveKeys(slateEditor, () => {
                       slate.Transforms.insertNodes(slateEditor, currentBlock, {
                         at: [currentBlockIndex]
                       });
-                    }) : (debug$4("Invalid", validation), change$.next({
+                    }) : (debug$5("Invalid", validation), change$.next({
                       type: "invalidValue",
                       resolution: validation.resolution,
                       value
@@ -3812,11 +3803,11 @@ function useSyncValue(props) {
         });
       }
       if (!isValid) {
-        debug$4("Invalid value, returning");
+        debug$5("Invalid value, returning");
         return;
       }
       if (isChanged) {
-        debug$4("Server value changed, syncing editor");
+        debug$5("Server value changed, syncing editor");
         try {
           slateEditor.onChange();
         } catch (err) {
@@ -3832,7 +3823,7 @@ function useSyncValue(props) {
           focus: { path: [0, 0], offset: 0 }
         }), slateEditor.onChange()), change$.next({ type: "value", value });
       } else
-        debug$4("Server value and editor value is equal, no need to sync.");
+        debug$5("Server value and editor value is equal, no need to sync.");
       previousValue.current = value;
     };
     return updateValueFunctionRef.current = updateFunction, updateFunction;
@@ -3860,7 +3851,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     currentBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - currentBlock.children.length)).forEach(
       (_, index) => {
         const childIndex = oldBlockChildrenLength - 1 - index;
-        childIndex > 0 && (debug$4("Removing child"), slate.Transforms.removeNodes(slateEditor, {
+        childIndex > 0 && (debug$5("Removing child"), slate.Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, childIndex]
         }));
       }
@@ -3868,7 +3859,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual__default.default(currentBlockChild, oldBlockChild), isTextChanged = !isEqual__default.default(currentBlockChild.text, oldBlockChild == null ? void 0 : oldBlockChild.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === (oldBlockChild == null ? void 0 : oldBlockChild._key)) {
-          debug$4("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$5("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";
@@ -3876,7 +3867,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             at: { focus: { path, offset: 0 }, anchor: { path, offset: oldBlockChild.text.length } }
           }), slate.Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$4("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(
+          }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(
             slateEditor,
             { _key: VOID_CHILD_KEY },
             {
@@ -3884,13 +3875,13 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
               voids: !0
             }
           ));
-        } else oldBlockChild ? (debug$4("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), withPreserveKeys(slateEditor, () => {
           slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
             at: [currentBlockIndex, currentBlockChildIndex]
           });
-        }), slateEditor.onChange()) : oldBlockChild || (debug$4("Inserting new child", currentBlockChild), withPreserveKeys(slateEditor, () => {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), withPreserveKeys(slateEditor, () => {
           slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
             at: [currentBlockIndex, currentBlockChildIndex]
           }), slateEditor.onChange();
@@ -3898,9 +3889,9 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     });
   }
 }
-const debug$3 = debugWithName("component:PortableTextEditor:Synchronizer"), debugVerbose = debug$3.enabled && !1, FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3;
+const debug$4 = debugWithName("component:PortableTextEditor:Synchronizer"), debugVerbose$1 = debug$4.enabled && !1, FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3;
 function Synchronizer(props) {
-  const { change$, portableTextEditor, onChange, keyGenerator, readOnly, value } = props, [selection, setSelection] = react.useState(null), pendingPatches = react.useRef([]), syncValue = useSyncValue({
+  const portableTextEditor = usePortableTextEditor(), keyGenerator = usePortableTextEditorKeyGenerator(), readOnly = usePortableTextEditorReadOnlyStatus(), { change$, getValue, onChange, value } = props, pendingPatches = react.useRef([]), syncValue = useSyncValue({
     keyGenerator,
     onChange,
     portableTextEditor,
@@ -3911,13 +3902,13 @@ function Synchronizer(props) {
   }, [slateEditor]);
   const onFlushPendingPatches = react.useCallback(() => {
     if (pendingPatches.current.length > 0) {
-      debug$3("Flushing pending patches"), debugVerbose && debug$3(`Patches:
+      debug$4("Flushing pending patches"), debugVerbose$1 && debug$4(`Patches:
 ${JSON.stringify(pendingPatches.current, null, 2)}`);
-      const snapshot = PortableTextEditor.getValue(portableTextEditor);
+      const snapshot = getValue();
       change$.next({ type: "mutation", patches: pendingPatches.current, snapshot }), pendingPatches.current = [];
     }
     IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !1);
-  }, [slateEditor, portableTextEditor, change$]), onFlushPendingPatchesThrottled = react.useMemo(() => throttle__default.default(
+  }, [slateEditor, getValue, change$]), onFlushPendingPatchesThrottled = react.useMemo(() => throttle__default.default(
     () => {
       if (slate.Editor.isNormalizing(slateEditor)) {
         onFlushPendingPatches();
@@ -3934,37 +3925,54 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
   react.useEffect(() => () => {
     onFlushPendingPatches();
   }, [onFlushPendingPatches]), react.useEffect(() => {
-    debug$3("Subscribing to editor changes$");
+    debug$4("Subscribing to editor changes$");
     const sub = change$.subscribe((next) => {
       switch (next.type) {
         case "patch":
           IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !0), pendingPatches.current.push(next.patch), onFlushPendingPatchesThrottled(), onChange(next);
           break;
-        case "selection":
-          react.startTransition(() => {
-            debugVerbose && debug$3("Setting selection"), setSelection(next.selection);
-          }), onChange(next);
-          break;
         default:
           onChange(next);
       }
     });
     return () => {
-      debug$3("Unsubscribing to changes$"), sub.unsubscribe();
+      debug$4("Unsubscribing to changes$"), sub.unsubscribe();
     };
   }, [change$, onChange, onFlushPendingPatchesThrottled, slateEditor]);
   const handleOnline = react.useCallback(() => {
-    debug$3("Editor is online, syncing from props.value"), change$.next({ type: "connection", value: "online" }), syncValue(value);
+    debug$4("Editor is online, syncing from props.value"), change$.next({ type: "connection", value: "online" }), syncValue(value);
   }, [change$, syncValue, value]), handleOffline = react.useCallback(() => {
-    debug$3("Editor is offline"), change$.next({ type: "connection", value: "offline" });
+    debug$4("Editor is offline"), change$.next({ type: "connection", value: "offline" });
   }, [change$]);
   react.useEffect(() => (portableTextEditor.props.patches$ && (window.addEventListener("online", handleOnline), window.addEventListener("offline", handleOffline)), () => {
     portableTextEditor.props.patches$ && (window.removeEventListener("online", handleOnline), window.removeEventListener("offline", handleOffline));
   }));
   const isInitialValueFromProps = react.useRef(!0);
   return react.useEffect(() => {
-    debug$3("Value from props changed, syncing new value"), syncValue(value), isInitialValueFromProps.current && (change$.next({ type: "loading", isLoading: !1 }), change$.next({ type: "ready" }), isInitialValueFromProps.current = !1);
-  }, [change$, syncValue, value]), /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorKeyGeneratorContext.Provider, { value: keyGenerator, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: portableTextEditor, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorValueContext.Provider, { value, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }) }) }) }) });
+    debug$4("Value from props changed, syncing new value"), syncValue(value), isInitialValueFromProps.current && (change$.next({ type: "loading", isLoading: !1 }), change$.next({ type: "ready" }), isInitialValueFromProps.current = !1);
+  }, [change$, syncValue, value]), null;
+}
+const PortableTextEditorSelectionContext = react.createContext(null), usePortableTextEditorSelection = () => {
+  const selection = react.useContext(PortableTextEditorSelectionContext);
+  if (selection === void 0)
+    throw new Error(
+      "The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context."
+    );
+  return selection;
+}, debug$3 = debugWithName("component:PortableTextEditor:SelectionProvider"), debugVerbose = debug$3.enabled && !1;
+function PortableTextEditorSelectionProvider(props) {
+  const { change$ } = props, [selection, setSelection] = react.useState(null);
+  return react.useEffect(() => {
+    debug$3("Subscribing to selection changes$");
+    const subscription = change$.subscribe((next) => {
+      next.type === "selection" && react.startTransition(() => {
+        debugVerbose && debug$3("Setting selection"), setSelection(next.selection);
+      });
+    });
+    return () => {
+      debug$3("Unsubscribing to selection changes$"), subscription.unsubscribe();
+    };
+  }, [change$]), /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children });
 }
 var __defProp = Object.defineProperty, __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
 const debug$2 = debugWithName("component:PortableTextEditor");
@@ -3972,8 +3980,11 @@ class PortableTextEditor extends react.Component {
   constructor(props) {
     if (super(props), __publicField(this, "change$", new rxjs.Subject()), __publicField(this, "schemaTypes"), __publicField(this, "editable"), __publicField(this, "setEditable", (editable) => {
       this.editable = { ...this.editable, ...editable };
+    }), __publicField(this, "getValue", () => {
+      if (this.editable)
+        return this.editable.getValue();
     }), !props.schemaType)
-      throw new Error('PortableTextEditor: missing "type" property');
+      throw new Error('PortableTextEditor: missing "schemaType" property');
     props.incomingPatches$ && console.warn("The prop 'incomingPatches$' is deprecated and renamed to 'patches$'"), this.change$.next({ type: "loading", isLoading: !0 }), this.schemaTypes = getPortableTextMemberSchemaTypes(
       props.schemaType.hasOwnProperty("jsonType") ? props.schemaType : compileType(props.schemaType)
     );
@@ -3993,18 +4004,18 @@ class PortableTextEditor extends react.Component {
         patches$: _patches$,
         portableTextEditor: this,
         readOnly,
-        children: /* @__PURE__ */ jsxRuntime.jsx(
-          Synchronizer,
-          {
-            change$,
-            keyGenerator,
-            onChange,
-            portableTextEditor: this,
-            readOnly,
-            value,
-            children
-          }
-        )
+        children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorKeyGeneratorContext.Provider, { value: keyGenerator, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxRuntime.jsxs(PortableTextEditorSelectionProvider, { change$, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            Synchronizer,
+            {
+              change$,
+              getValue: this.getValue,
+              onChange,
+              value
+            }
+          ),
+          children
+        ] }) }) }) })
       }
     );
   }
@@ -4264,7 +4275,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   pointerEvents: "none",
   left: 0,
   right: 0
-}, EMPTY_DECORATIONS_STATE = [], PortableTextEditable = react.forwardRef(function(props, forwardedRef) {
+}, PortableTextEditable = react.forwardRef(function(props, forwardedRef) {
   const {
     hotkeys,
     onBlur,
@@ -4285,7 +4296,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     scrollSelectionIntoView,
     spellCheck,
     ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = react.useRef(null), [editableElement, setEditableElement] = react.useState(null), [hasInvalidValue, setHasInvalidValue] = react.useState(!1), [rangeDecorationState, setRangeDecorationsState] = react.useState(EMPTY_DECORATIONS_STATE);
+  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = react.useRef(null), [editableElement, setEditableElement] = react.useState(null), [hasInvalidValue, setHasInvalidValue] = react.useState(!1), [rangeDecorationState, setRangeDecorationsState] = react.useState([]);
   react.useImperativeHandle(forwardedRef, () => ref.current);
   const rangeDecorationsRef = react.useRef(rangeDecorations), { change$, schemaTypes } = portableTextEditor, slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = react.useMemo(
     () => createWithInsertData(change$, schemaTypes, keyGenerator),
@@ -4377,7 +4388,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           return;
         }
       }
-      setRangeDecorationsState(EMPTY_DECORATIONS_STATE);
+      setRangeDecorationsState([]);
     },
     [portableTextEditor, rangeDecorations, schemaTypes, slateEditor]
   );
@@ -4526,9 +4537,9 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           }
         ];
       if (path.length === 0)
-        return EMPTY_DECORATIONS_STATE;
+        return [];
       const result = rangeDecorationState.filter((item) => slate.Range.isCollapsed(item) ? path.length !== 2 ? !1 : slate.Path.equals(item.focus.path, path) && slate.Path.equals(item.anchor.path, path) : slate.Range.intersection(item, { anchor: { path, offset: 0 }, focus: { path, offset: 0 } }) || slate.Range.includes(item, path));
-      return result.length > 0 ? result : EMPTY_DECORATIONS_STATE;
+      return result.length > 0 ? result : [];
     },
     [slateEditor, schemaTypes, rangeDecorationState]
   );