@portabletext/editor 1.0.8 → 1.0.10

package/lib/index.mjs

@@ -4,7 +4,7 @@ import noop from "lodash/noop.js";
 import { useRef, useState, useMemo, useEffect, useCallback, createContext, useContext, startTransition, Component, forwardRef, useImperativeHandle } from "react";
 import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Node, Operation, createEditor } from "slate";
 import { useSlateStatic, ReactEditor, useSelected, withReact, Slate, useSlate, Editable } from "slate-react";
-import debug$l from "debug";
+import debug$m from "debug";
 import { isKeySegment, isPortableTextSpan, isPortableTextTextBlock, isPortableTextListBlock } from "@sanity/types";
 import { styled } from "styled-components";
 import uniq from "lodash/uniq.js";
@@ -22,10 +22,10 @@ import throttle from "lodash/throttle.js";
 import { randomKey } from "@sanity/util/content";
 import debounce from "lodash/debounce.js";
 const rootName = "sanity-pte:";
-debug$l(rootName);
+debug$m(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$l && debug$l.enabled(namespace) ? debug$l(namespace) : debug$l(rootName);
+  return debug$m && debug$m.enabled(namespace) ? debug$m(namespace) : debug$m(rootName);
 }
 function createKeyedPath(point, value, types) {
   const blockPath = [point.path[0]];
@@ -348,7 +348,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 = useSlateStatic(), dragGhostRef = useRef(), [isDragOver, setIsDragOver] = useState(!1), isVoid = useMemo(() => Editor.isVoid(editor, element), [editor, element]), isInline = useMemo(() => Editor.isInline(editor, element), [editor, element]), [blockElement, setBlockElement] = useState(null);
   useEffect(
     () => setBlockElement(blockRef ? blockRef.current : ReactEditor.toDOMNode(editor, element)),
@@ -375,18 +375,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 = ReactEditor.findPath(editor, targetBlock);
         const myPath = ReactEditor.findPath(editor, element), isBefore = 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 = Path.next(targetPath), debug$k(
+          targetPath = Path.next(targetPath), debug$l(
             `Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(
               targetPath
             )}`
@@ -394,29 +394,29 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({
         }
         if (dragPosition2 === "top" && isBefore && targetPath[0] !== editor.children.length - 1) {
           const originalPath = targetPath;
-          targetPath = Path.previous(targetPath), debug$k(
+          targetPath = Path.previous(targetPath), debug$l(
             `Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(
               targetPath
             )}`
           );
         }
         if (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})`
         ), 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 = 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 = useCallback(
@@ -433,10 +433,10 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = ({
   ), handleDragStart = 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) {
@@ -717,12 +717,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(types) {
   const textBlockName = types.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");
@@ -813,7 +813,7 @@ function createOperationToPatches(types) {
         ])
       ];
     }
-    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 = [], splitBlock = editor.children[operation.path[0]];
@@ -876,9 +876,9 @@ function createOperationToPatches(types) {
       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 ? [unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$j("Span not found in editor trying to remove node"), []);
+      return spanToRemove ? [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 = [], block = beforeValue[operation.path[0]], targetBlock = editor.children[operation.path[0]];
@@ -894,7 +894,7 @@ function createOperationToPatches(types) {
         set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
       ), mergedSpan && patches.push(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;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -927,7 +927,7 @@ function createOperationToPatches(types) {
     splitNodePatch
   };
 }
-const debug$i = debugWithName("API:editable");
+const debug$j = debugWithName("API:editable");
 function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
   return function(editor) {
     return portableTextEditor.setEditable({
@@ -1010,7 +1010,7 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
           ],
           portableTextEditor
         )[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
-        return isSpanNode && focusNode._type !== types.span.name && (debug$i("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), Transforms.insertNodes(editor, child, {
+        return isSpanNode && focusNode._type !== types.span.name && (debug$j("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), Transforms.insertNodes(editor, child, {
           select: !0,
           at: editor.selection
         }), editor.onChange(), ((_a = toPortableTextRange(
@@ -1209,18 +1209,18 @@ function createWithEditableAPI(portableTextEditor, types, 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"), Transforms.delete(editor, {
+              debug$j("Deleting content in selection"), 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"), Transforms.removeNodes(editor, {
+            (options == null ? void 0 : options.mode) === "blocks" && (debug$j("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
               at: range,
               voids: !0,
               match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element$1.isElement(node)
-            })), (options == null ? void 0 : options.mode) === "children" && (debug$i("Deleting children touched by selection"), Transforms.removeNodes(editor, {
+            })), (options == null ? void 0 : options.mode) === "children" && (debug$j("Deleting children touched by selection"), Transforms.removeNodes(editor, {
               at: range,
               voids: !0,
               match: (node) => node._type === types.span.name || // Text children
@@ -1231,7 +1231,7 @@ function createWithEditableAPI(portableTextEditor, types, keyGenerator) {
       },
       removeAnnotation: (type) => {
         let { selection } = editor;
-        if (debug$i("Removing annotation", type), selection) {
+        if (debug$j("Removing annotation", type), selection) {
           if (Range.isCollapsed(selection)) {
             const [node, nodePath] = Editor.node(editor, selection, { depth: 2 });
             Text.isText(node) && node.marks && typeof node.text == "string" && (Transforms.select(editor, nodePath), selection = editor.selection);
@@ -2051,14 +2051,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":
@@ -2074,7 +2074,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);
@@ -2085,9 +2085,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") || !Text.isText(child))
     return !1;
   const patches = parse(patch.value), [newValue] = apply(patches, child.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
@@ -2105,40 +2105,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"), Transforms.insertNodes(editor, blocksToInsert, { at: [normalizedIdx2] }), debugState(editor, "after"), !0;
+    return debug$i(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), 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 && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, { at: childInsertPath }), debugState(editor, "after"), !0;
+  return debug$i(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, { at: childInsertPath }), debugState(editor, "after"), !0;
 }
 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 (Text.isText(value) && 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,
@@ -2150,7 +2150,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: {},
@@ -2158,14 +2158,14 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (Element$1.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),
@@ -2186,7 +2186,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 Transforms.deselect(editor), editor.children.forEach((c, i) => {
       Transforms.removeNodes(editor, { at: [i] });
@@ -2198,17 +2198,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"), Transforms.removeNodes(editor, { at: [blockIndex] }), debugState(editor, "after"), !0;
+    return debug$i(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), Transforms.removeNodes(editor, { at: [blockIndex] }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$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)}`), 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)}`), 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;
@@ -2247,7 +2247,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) || []);
@@ -2260,13 +2260,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, snapshot }) => {
         let reset = !1;
         patches.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$g("Someone else cleared the content, resetting undo/redo history"), editor.history = { 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 });
@@ -2274,7 +2274,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;
@@ -2293,7 +2293,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();
@@ -2306,7 +2306,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) => {
@@ -2327,7 +2327,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$g("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), 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), Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
             return;
           }
           editor.history.redos.push(step), editor.history.undos.pop();
@@ -2339,7 +2339,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) => {
@@ -2360,7 +2360,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$g("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), 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), Transforms.deselect(editor), editor.history = { undos: [], redos: [] }, SAVING.set(editor, !0), editor.onChange();
             return;
           }
           editor.history.undos.push(step), editor.history.redos.pop();
@@ -2370,13 +2370,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({ _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)];
   }
@@ -2384,12 +2384,12 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const unsetBlockIndex = (previousSnapshot || []).findIndex(
       (blk) => isEqual({ _key: blk._key }, patch.path[0])
     );
-    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$g("Skipping transformation that targeted removed block"), []) : (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({ _key: operationTargetBlock._key }, patch.path[0]) ? [transformedOperation] : (parse(patch.value).forEach((diffPatch) => {
@@ -2452,7 +2452,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$,
@@ -2478,7 +2478,7 @@ function createWithPatches({
             withoutSaving(editor, () => {
               withPreserveKeys(editor, () => {
                 patches.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);
                 });
               });
             });
@@ -2490,10 +2490,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)
@@ -2571,7 +2571,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;
@@ -2580,14 +2580,14 @@ function createWithPlaceholderBlock() {
         const node = op.node;
         if (op.path[0] === 0 && Editor.isVoid(editor, node)) {
           const nextPath = Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$e("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateEmptyBlock()));
+          editor.children[nextPath[0]] || (debug$f("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateEmptyBlock()));
         }
       }
       apply2(op);
     }, editor;
   };
 }
-const debug$d = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$e = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(types) {
   const defaultStyle = types.styles[0].value;
   return function(editor) {
@@ -2599,7 +2599,7 @@ function createWithPortableTextBlockStyle(types) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !Path.equals(path, op.path)) {
           const [child] = Editor.node(editor, [op.path[0] + 1, 0]);
           if (Text.isText(child) && child.text === "") {
-            debug$d(`Normalizing split node to ${defaultStyle} style`, op), Transforms.setNodes(editor, { style: defaultStyle }, { at: [op.path[0] + 1], voids: !1 });
+            debug$e(`Normalizing split node to ${defaultStyle} style`, op), Transforms.setNodes(editor, { style: defaultStyle }, { at: [op.path[0] + 1], voids: !1 });
             break;
           }
         }
@@ -2615,9 +2615,9 @@ function createWithPortableTextBlockStyle(types) {
           match: (node) => editor.isTextBlock(node)
         })
       ].forEach(([node, path]) => {
-        editor.isTextBlock(node) && node.style === blockStyle ? (debug$d(`Unsetting block style '${blockStyle}'`), Transforms.setNodes(editor, { ...node, style: defaultStyle }, {
+        editor.isTextBlock(node) && node.style === blockStyle ? (debug$e(`Unsetting block style '${blockStyle}'`), Transforms.setNodes(editor, { ...node, style: defaultStyle }, {
           at: path
-        })) : (blockStyle ? debug$d(`Setting style '${blockStyle}'`) : debug$d("Setting default style", defaultStyle), Transforms.setNodes(
+        })) : (blockStyle ? debug$e(`Setting style '${blockStyle}'`) : debug$e("Setting default style", defaultStyle), Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2629,11 +2629,11 @@ function createWithPortableTextBlockStyle(types) {
     }, editor;
   };
 }
-const debug$c = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
+const debug$d = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
 function createWithPortableTextLists(types) {
   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 && [
         ...Editor.nodes(editor, {
@@ -2647,7 +2647,7 @@ function createWithPortableTextLists(types) {
             listItem: void 0,
             level: void 0
           };
-          debug$c(`Unsetting list '${listItemStyle}'`), Transforms.setNodes(editor, newNode, { at: path });
+          debug$d(`Unsetting list '${listItemStyle}'`), Transforms.setNodes(editor, newNode, { at: path });
         }
       });
     }, editor.pteSetListItem = (listItemStyle) => {
@@ -2657,7 +2657,7 @@ function createWithPortableTextLists(types) {
           match: (node) => editor.isTextBlock(node)
         })
       ].forEach(([node, path]) => {
-        debug$c(`Setting list '${listItemStyle}'`), Transforms.setNodes(
+        debug$d(`Setting list '${listItemStyle}'`), Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2677,7 +2677,7 @@ function createWithPortableTextLists(types) {
         })
       ];
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
-        Element$1.isElement(node) && (debug$c("Unset list"), Transforms.setNodes(
+        Element$1.isElement(node) && (debug$d("Unset list"), Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2699,7 +2699,7 @@ function createWithPortableTextLists(types) {
       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)))), 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)))), Transforms.setNodes(
             editor,
             { level: Math.min(MAX_LIST_LEVEL, Math.max(1, level)) },
             { at: path }
@@ -2721,7 +2721,7 @@ function createWithPortableTextLists(types) {
     }, editor;
   };
 }
-const debug$b = debugWithName("plugin:withPortableTextMarkModel");
+const debug$c = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(types, change$) {
   return function(editor) {
     const { apply: apply2, normalizeNode } = editor, decorators = types.decorators.map((t) => t.value), forceNewSelection = () => {
@@ -2742,7 +2742,7 @@ function createWithPortableTextMarkModel(types, change$) {
       ) && mergeSpans(editor);
       const [node, path] = nodeEntry, isSpan = Text.isText(node) && node._type === types.span.name, isTextBlock = editor.isTextBlock(node);
       if (isSpan || isTextBlock) {
-        if (isSpan && !Array.isArray(node.marks) && (debug$b("Adding .marks to span node"), 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"), Transforms.setNodes(editor, { marks: [] }, { at: path }), editor.onChange()), isSpan && (node.marks || []).length > 0) {
           const spanMarks = node.marks || EMPTY_MARKS$1, annotationMarks = spanMarks.filter(
             (mark) => !types.decorators.map((dec) => dec.value).includes(mark)
           );
@@ -2753,7 +2753,7 @@ function createWithPortableTextMarkModel(types, change$) {
                 return !((_a = block.markDefs) != null && _a.find((def) => def._key === mark));
               }
             ) || [];
-            orphanedMarks.length > 0 && (debug$b("Removing orphaned .marks from span node"), Transforms.setNodes(
+            orphanedMarks.length > 0 && (debug$c("Removing orphaned .marks from span node"), Transforms.setNodes(
               editor,
               { marks: spanMarks.filter((mark) => !orphanedMarks.includes(mark)) },
               { at: path }
@@ -2763,14 +2763,14 @@ function createWithPortableTextMarkModel(types, change$) {
         for (const op of editor.operations) {
           if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
             const [targetBlock, targetPath] = 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([...oldDefs, ...op.properties.markDefs]);
               isEqual(newMarkDefs, targetBlock.markDefs) || (Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 }), editor.onChange());
             }
           }
           if (op.type === "split_node" && op.path.length === 1 && Element$1.isElementProps(op.properties) && op.properties._type === types.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] = 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 || [];
               Transforms.setNodes(
                 editor,
@@ -2794,7 +2794,7 @@ function createWithPortableTextMarkModel(types, change$) {
         (op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1
       )) {
         const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
-        node.markDefs && !isEqual(newMarkDefs, node.markDefs) && (debug$b("Removing markDef not in use"), Transforms.setNodes(
+        node.markDefs && !isEqual(newMarkDefs, node.markDefs) && (debug$c("Removing markDef not in use"), Transforms.setNodes(
           editor,
           {
             markDefs: newMarkDefs
@@ -2827,7 +2827,7 @@ function createWithPortableTextMarkModel(types, change$) {
               editor,
               { marks: marksWithoutAnnotationMarks },
               { at: Path.next(selection.focus.path) }
-            ), debug$b("Inserting text at end of annotation");
+            ), debug$c("Inserting text at end of annotation");
             return;
           }
         }
@@ -2919,7 +2919,7 @@ function createWithPortableTextMarkModel(types, change$) {
         ...Editor.marks(editor) || {}
       }.marks || []).includes(mark);
     }, editor.pteToggleMark = (mark) => {
-      editor.pteIsMarkActive(mark) ? (debug$b(`Remove mark '${mark}'`), Editor.removeMark(editor, mark)) : (debug$b(`Add mark '${mark}'`), Editor.addMark(editor, mark, !0));
+      editor.pteIsMarkActive(mark) ? (debug$c(`Remove mark '${mark}'`), Editor.removeMark(editor, mark)) : (debug$c(`Add mark '${mark}'`), Editor.addMark(editor, mark, !0));
     }, editor;
   };
   function mergeSpans(editor) {
@@ -2933,12 +2933,12 @@ function createWithPortableTextMarkModel(types, change$) {
         const [parent] = path.length > 1 ? Editor.node(editor, Path.parent(path)) : [void 0], nextPath = [path[0], path[1] + 1];
         if (editor.isTextBlock(parent)) {
           const nextNode = parent.children[nextPath[1]];
-          Text.isText(node) && Text.isText(nextNode) && isEqual(nextNode.marks, node.marks) && (debug$b("Merging spans"), Transforms.mergeNodes(editor, { at: nextPath, voids: !0 }), editor.onChange());
+          Text.isText(node) && Text.isText(nextNode) && isEqual(nextNode.marks, node.marks) && (debug$c("Merging spans"), 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$, types) {
   let prevSelection = null;
   return function(editor) {
@@ -2954,7 +2954,7 @@ function createWithPortableTextSelections(change$, types) {
             ptRange = toPortableTextRange(value, editor.selection, types), 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
           )})`
@@ -2968,7 +2968,7 @@ function createWithPortableTextSelections(change$, types) {
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withSchemaTypes");
+const debug$a = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   schemaTypes,
   keyGenerator
@@ -2979,12 +2979,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();
         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();
         Transforms.setNodes(editor, { _key: key }, { at: path });
       }
@@ -2992,7 +2992,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 = () => {
@@ -3000,18 +3000,18 @@ function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
       if (selection && !Range.isExpanded(selection)) {
         const [textNode] = Editor.node(editor, selection.focus, { depth: 2 });
         if (!textNode || !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"), Transforms.setSelection(editor, {
+          debug$9("pteExpandToWord: Expanding to focused word"), 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(
       [
@@ -3034,7 +3034,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",
@@ -3047,7 +3047,7 @@ function createWithHotkeys(types, 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]) {
@@ -3058,7 +3058,7 @@ function createWithHotkeys(types, 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);
               }
             }
           }
@@ -3103,7 +3103,7 @@ function createWithHotkeys(types, portableTextEditor, hotkeysFromOptions) {
       if (isBackspace && editor.selection && editor.selection.focus.path[0] > 0 && Range.isCollapsed(editor.selection)) {
         const prevPath = Path.previous(editor.selection.focus.path.slice(0, 1)), prevBlock = Node.descendant(editor, prevPath), focusBlock = Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
         if (prevBlock && focusBlock && 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 = 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) {
             Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), Transforms.select(editor, prevPath), editor.onChange();
@@ -3120,9 +3120,9 @@ function createWithHotkeys(types, portableTextEditor, hotkeysFromOptions) {
         const nextBlock = Node.descendant(
           editor,
           Path.next(editor.selection.focus.path.slice(0, 1))
-        ), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
-        if (nextBlock && focusBlock && !Editor.isVoid(editor, focusBlock) && Editor.isVoid(editor, nextBlock)) {
-          debug$7("Preventing deleting void block below"), event.preventDefault(), event.stopPropagation(), Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), Transforms.select(editor, focusBlockPath), editor.onChange();
+        ), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath), isEmptyFocusBlock = isPortableTextTextBlock(focusBlock) && focusBlock.children.length === 1 && ((_f = (_e = focusBlock.children) == null ? void 0 : _e[0]) == null ? void 0 : _f.text) === "";
+        if (nextBlock && focusBlock && !Editor.isVoid(editor, focusBlock) && Editor.isVoid(editor, nextBlock) && isEmptyFocusBlock) {
+          debug$8("Preventing deleting void block below"), event.preventDefault(), event.stopPropagation(), Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), Transforms.select(editor, focusBlockPath), editor.onChange();
           return;
         }
       }
@@ -3422,7 +3422,7 @@ function validateValue(value, types, 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) => {
@@ -3461,13 +3461,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(
@@ -3485,7 +3485,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;
         }
@@ -3494,11 +3494,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 = htmlToBlocks(html, schemaTypes.portableText, {
@@ -3526,9 +3526,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) => {
@@ -3596,7 +3596,7 @@ function _insertFragment(editor, fragment, schemaTypes) {
     const [focusBlock, focusPath] = 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(markDefs, fragment[0].markDefs) || Transforms.setNodes(
+      debug$7("Mixing markDefs of focusBlock and fragments[0] block", markDefs, fragment[0].markDefs), isEqual(markDefs, fragment[0].markDefs) || Transforms.setNodes(
         editor,
         {
           markDefs: uniq([...fragment[0].markDefs || [], ...markDefs || []])
@@ -3679,10 +3679,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]] = useState(() => {
-    debug$5("Creating new Slate editor instance");
+    debug$6("Creating new Slate editor instance");
     const { editor, subscribe: _sub } = withPlugins(withReact(createEditor()), {
       keyGenerator,
       maxBlocks,
@@ -3698,7 +3698,7 @@ function SlateContainer(props) {
       unsubscribe();
     };
   }, [subscribe]), useEffect(() => {
-    debug$5("Re-initializing plugin chain"), withPlugins(slateEditor, {
+    debug$6("Re-initializing plugin chain"), withPlugins(slateEditor, {
       keyGenerator,
       maxBlocks,
       patches$,
@@ -3708,7 +3708,7 @@ function SlateContainer(props) {
   }, [keyGenerator, portableTextEditor, maxBlocks, readOnly, patches$, slateEditor]);
   const initialValue = useMemo(() => [slateEditor.pteCreateEmptyBlock()], [slateEditor]);
   return useEffect(() => () => {
-    debug$5("Destroying Slate editor"), slateEditor.destroy();
+    debug$6("Destroying Slate editor"), slateEditor.destroy();
   }, [slateEditor]), /* @__PURE__ */ jsx(Slate, { editor: slateEditor, initialValue, children: props.children });
 }
 const defaultKeyGenerator = () => randomKey(12), PortableTextEditorKeyGeneratorContext = createContext(defaultKeyGenerator), usePortableTextEditorKeyGenerator = () => {
@@ -3718,31 +3718,22 @@ const defaultKeyGenerator = () => randomKey(12), PortableTextEditorKeyGeneratorC
       "The `usePortableTextEditorKeyGenerator` hook must be used inside the <PortableTextEditor> component's context."
     );
   return keyGenerator;
-}, PortableTextEditorSelectionContext = createContext(null), usePortableTextEditorSelection = () => {
-  const selection = useContext(PortableTextEditorSelectionContext);
-  if (selection === void 0)
-    throw new Error(
-      "The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context."
-    );
-  return selection;
-}, PortableTextEditorValueContext = createContext(
-  void 0
-), PortableTextEditorReadOnlyContext = createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
+}, PortableTextEditorReadOnlyContext = createContext(!1), usePortableTextEditorReadOnlyStatus = () => {
   const readOnly = 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 = useRef(), slateEditor = useSlate(), updateValueFunctionRef = useRef(), updateFromCurrentValue = 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 = useMemo(
     () => debounce(updateFromCurrentValue, 1e3, { trailing: !0, leading: !1 }),
     [updateFromCurrentValue]
@@ -3753,17 +3744,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"), Editor.withoutNormalizing(slateEditor, () => {
+      if ((!value || value.length === 0) && (debug$5("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
         withoutSaving(slateEditor, () => {
           withoutPatching(slateEditor, () => {
             hadSelection && Transforms.deselect(slateEditor);
@@ -3800,7 +3791,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
@@ -3808,14 +3799,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, () => {
                       Transforms.insertNodes(slateEditor, currentBlock, {
                         at: [currentBlockIndex]
                       });
-                    }) : (debug$4("Invalid", validation), change$.next({
+                    }) : (debug$5("Invalid", validation), change$.next({
                       type: "invalidValue",
                       resolution: validation.resolution,
                       value
@@ -3828,11 +3819,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) {
@@ -3848,7 +3839,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;
@@ -3876,7 +3867,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"), Transforms.removeNodes(slateEditor, {
+        childIndex > 0 && (debug$5("Removing child"), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, childIndex]
         }));
       }
@@ -3884,7 +3875,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(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), Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$5("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
           const isSpanNode = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
@@ -3892,7 +3883,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             at: { focus: { path, offset: 0 }, anchor: { path, offset: oldBlockChild.text.length } }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$4("Updating changed inline object child", currentBlockChild), Transforms.setNodes(
+          }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), Transforms.setNodes(
             slateEditor,
             { _key: VOID_CHILD_KEY },
             {
@@ -3900,13 +3891,13 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
               voids: !0
             }
           ));
-        } else oldBlockChild ? (debug$4("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), withPreserveKeys(slateEditor, () => {
           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, () => {
           Transforms.insertNodes(slateEditor, currentBlockChild, {
             at: [currentBlockIndex, currentBlockChildIndex]
           }), slateEditor.onChange();
@@ -3914,9 +3905,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] = useState(null), pendingPatches = useRef([]), syncValue = useSyncValue({
+  const portableTextEditor = usePortableTextEditor(), keyGenerator = usePortableTextEditorKeyGenerator(), readOnly = usePortableTextEditorReadOnlyStatus(), { change$, getValue, onChange, value } = props, pendingPatches = useRef([]), syncValue = useSyncValue({
     keyGenerator,
     onChange,
     portableTextEditor,
@@ -3927,13 +3918,13 @@ function Synchronizer(props) {
   }, [slateEditor]);
   const onFlushPendingPatches = 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 = useMemo(() => throttle(
+  }, [slateEditor, getValue, change$]), onFlushPendingPatchesThrottled = useMemo(() => throttle(
     () => {
       if (Editor.isNormalizing(slateEditor)) {
         onFlushPendingPatches();
@@ -3950,37 +3941,54 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
   useEffect(() => () => {
     onFlushPendingPatches();
   }, [onFlushPendingPatches]), 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":
-          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 = 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 = useCallback(() => {
-    debug$3("Editor is offline"), change$.next({ type: "connection", value: "offline" });
+    debug$4("Editor is offline"), change$.next({ type: "connection", value: "offline" });
   }, [change$]);
   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 = useRef(!0);
   return 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__ */ jsx(PortableTextEditorKeyGeneratorContext.Provider, { value: keyGenerator, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: portableTextEditor, children: /* @__PURE__ */ jsx(PortableTextEditorValueContext.Provider, { value, children: /* @__PURE__ */ jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ 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 = createContext(null), usePortableTextEditorSelection = () => {
+  const selection = 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] = useState(null);
+  return useEffect(() => {
+    debug$3("Subscribing to selection changes$");
+    const subscription = change$.subscribe((next) => {
+      next.type === "selection" && startTransition(() => {
+        debugVerbose && debug$3("Setting selection"), setSelection(next.selection);
+      });
+    });
+    return () => {
+      debug$3("Unsubscribing to selection changes$"), subscription.unsubscribe();
+    };
+  }, [change$]), /* @__PURE__ */ 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");
@@ -3988,8 +3996,11 @@ class PortableTextEditor extends Component {
   constructor(props) {
     if (super(props), __publicField(this, "change$", new 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)
     );
@@ -4009,18 +4020,18 @@ class PortableTextEditor extends Component {
         patches$: _patches$,
         portableTextEditor: this,
         readOnly,
-        children: /* @__PURE__ */ jsx(
-          Synchronizer,
-          {
-            change$,
-            keyGenerator,
-            onChange,
-            portableTextEditor: this,
-            readOnly,
-            value,
-            children
-          }
-        )
+        children: /* @__PURE__ */ jsx(PortableTextEditorKeyGeneratorContext.Provider, { value: keyGenerator, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsx(PortableTextEditorReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsxs(PortableTextEditorSelectionProvider, { change$, children: [
+          /* @__PURE__ */ jsx(
+            Synchronizer,
+            {
+              change$,
+              getValue: this.getValue,
+              onChange,
+              value
+            }
+          ),
+          children
+        ] }) }) }) })
       }
     );
   }
@@ -4280,7 +4291,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   pointerEvents: "none",
   left: 0,
   right: 0
-}, EMPTY_DECORATIONS_STATE = [], PortableTextEditable = forwardRef(function(props, forwardedRef) {
+}, PortableTextEditable = forwardRef(function(props, forwardedRef) {
   const {
     hotkeys,
     onBlur,
@@ -4301,7 +4312,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     scrollSelectionIntoView,
     spellCheck,
     ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState(EMPTY_DECORATIONS_STATE);
+  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
   useImperativeHandle(forwardedRef, () => ref.current);
   const rangeDecorationsRef = useRef(rangeDecorations), { change$, schemaTypes } = portableTextEditor, slateEditor = useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = useMemo(
     () => createWithInsertData(change$, schemaTypes, keyGenerator),
@@ -4393,7 +4404,7 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           return;
         }
       }
-      setRangeDecorationsState(EMPTY_DECORATIONS_STATE);
+      setRangeDecorationsState([]);
     },
     [portableTextEditor, rangeDecorations, schemaTypes, slateEditor]
   );
@@ -4542,9 +4553,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) => Range.isCollapsed(item) ? path.length !== 2 ? !1 : Path.equals(item.focus.path, path) && Path.equals(item.anchor.path, path) : Range.intersection(item, { anchor: { path, offset: 0 }, focus: { path, offset: 0 } }) || Range.includes(item, path));
-      return result.length > 0 ? result : EMPTY_DECORATIONS_STATE;
+      return result.length > 0 ? result : [];
     },
     [slateEditor, schemaTypes, rangeDecorationState]
   );