@portabletext/editor 1.30.6 → 1.31.0

package/lib/_chunks-es/plugin.event-listener.js

@@ -4,7 +4,7 @@ import { useEffectEvent } from "use-effect-event";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { withReact, ReactEditor, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
-import debug$f from "debug";
+import debug$e from "debug";
 import { Editor, Element, Range, Point, Text, Operation, Transforms, Path, Node, insertText, createEditor as createEditor$1, select, deleteFragment, deleteBackward, deleteForward } from "slate";
 import { setup, emit, assign, fromCallback, assertEvent, enqueueActions, createActor } from "xstate";
 import isEqual from "lodash/isEqual.js";
@@ -23,7 +23,7 @@ import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import startCase from "lodash.startcase";
 import { createGuards } from "./selector.is-at-the-start-of-block.js";
-import { blockOffsetToSpanSelectionPoint } from "./util.is-empty-text-block.js";
+import { blockOffsetToSpanSelectionPoint } from "./util.reverse-selection.js";
 import { defineBehavior, raise, coreBehaviors, isCustomBehaviorEvent } from "./behavior.core.js";
 import getRandomValues from "get-random-values-esm";
 import { Subject } from "rxjs";
@@ -142,10 +142,10 @@ function compileSchemaDefinition(definition) {
   };
 }
 const rootName = "sanity-pte:";
-debug$f(rootName);
+debug$e(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$f && debug$f.enabled(namespace) ? debug$f(namespace) : debug$f(rootName);
+  return debug$e && debug$e.enabled(namespace) ? debug$e(namespace) : debug$e(rootName);
 }
 function createKeyedPath(point, value, types) {
   const blockPath = [point.path[0]];
@@ -1414,7 +1414,7 @@ function isRedoing(editor) {
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
-const debug$e = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$d = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
   return state === void 0 ? !0 : state;
 }, getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) || []);
@@ -1427,7 +1427,7 @@ function createWithUndoRedo(options) {
     let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
     const remotePatches = getRemotePatches(editor);
     options.subscriptions.push(() => {
-      debug$e("Subscribing to patches");
+      debug$d("Subscribing to patches");
       const sub = editorActor.on("patches", ({
         patches,
         snapshot
@@ -1436,7 +1436,7 @@ function createWithUndoRedo(options) {
         patches.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$e("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+              debug$d("Someone else cleared the content, resetting undo/redo history"), editor.history = {
                 undos: [],
                 redos: []
               }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -1452,7 +1452,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$e("Unsubscribing to patches"), sub.unsubscribe();
+        debug$d("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -1491,7 +1491,7 @@ function createWithUndoRedo(options) {
             operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
             timestamp: /* @__PURE__ */ new Date()
           };
-          undos.push(newStep), debug$e("Created new undo step", step);
+          undos.push(newStep), debug$d("Created new undo step", step);
         }
         for (; undos.length > UNDO_STEP_LIMIT; )
           undos.shift();
@@ -1508,7 +1508,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (undos.length > 0) {
         const step = undos[undos.length - 1];
-        if (debug$e("Undoing", step), step.operations.length > 0) {
+        if (debug$d("Undoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -1526,7 +1526,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$e("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+            debug$d("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
@@ -1545,7 +1545,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (redos.length > 0) {
         const step = redos[redos.length - 1];
-        if (debug$e("Redoing", step), step.operations.length > 0) {
+        if (debug$d("Redoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -1562,7 +1562,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$e("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+            debug$d("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
@@ -1582,16 +1582,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return debug$e(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$d(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 1) {
     const unsetBlockIndex = (previousSnapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$e("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$d("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$e(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$d(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual({
@@ -1678,7 +1678,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$d = debugWithName("sync machine"), syncValueCallback = ({
+const debug$c = debugWithName("sync machine"), syncValueCallback = ({
   sendBack,
   input
 }) => {
@@ -1730,7 +1730,7 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
       context
     }) => {
       const editable = !context.readOnly, isProcessingLocalChanges = context.isProcessingLocalChanges, isChanging = isChangingRemotely(context.slateEditor) ?? !1, isBusy = editable && (isProcessingLocalChanges || isChanging);
-      return debug$d("isBusy", {
+      return debug$c("isBusy", {
         isBusy,
         editable,
         isProcessingLocalChanges,
@@ -1784,10 +1784,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
       states: {
         "syncing initial value": {
           entry: [() => {
-            debug$d("entry: syncing initial value");
+            debug$c("entry: syncing initial value");
           }],
           exit: [() => {
-            debug$d("exit: syncing initial value");
+            debug$c("exit: syncing initial value");
           }],
           always: {
             guard: "initial value synced",
@@ -1796,10 +1796,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
         },
         "done syncing initial value": {
           entry: ["emit done syncing initial value", () => {
-            debug$d("entry: done syncing initial value");
+            debug$c("entry: done syncing initial value");
           }],
           exit: [() => {
-            debug$d("exit: done syncing initial value");
+            debug$c("exit: done syncing initial value");
           }],
           type: "final"
         }
@@ -1810,10 +1810,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
       states: {
         idle: {
           entry: [() => {
-            debug$d("entry: syncing->idle");
+            debug$c("entry: syncing->idle");
           }],
           exit: [() => {
-            debug$d("exit: syncing->idle");
+            debug$c("exit: syncing->idle");
           }],
           on: {
             "update value": [{
@@ -1828,10 +1828,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
         },
         busy: {
           entry: [() => {
-            debug$d("entry: syncing->busy");
+            debug$c("entry: syncing->busy");
           }],
           exit: [() => {
-            debug$d("exit: syncing->busy");
+            debug$c("exit: syncing->busy");
           }],
           after: {
             1e3: [{
@@ -1839,7 +1839,7 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
               target: ".",
               reenter: !0,
               actions: [() => {
-                debug$d("reenter: syncing->busy");
+                debug$c("reenter: syncing->busy");
               }]
             }, {
               target: "syncing"
@@ -1853,10 +1853,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
         },
         syncing: {
           entry: [() => {
-            debug$d("entry: syncing->syncing");
+            debug$c("entry: syncing->syncing");
           }],
           exit: [() => {
-            debug$d("exit: syncing->syncing");
+            debug$c("exit: syncing->syncing");
           }],
           always: {
             guard: "pending value equals previous value",
@@ -1922,7 +1922,7 @@ async function updateValue({
 }) {
   let isChanged = !1, isValid = !0;
   const hadSelection = !!slateEditor.selection;
-  if ((!value || value.length === 0) && (debug$d("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
+  if ((!value || value.length === 0) && (debug$c("Value is empty"), Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
       withoutPatching(slateEditor, () => {
         hadSelection && Transforms.deselect(slateEditor);
@@ -1978,14 +1978,14 @@ async function updateValue({
     });
   }
   if (!isValid) {
-    debug$d("Invalid value, returning"), sendBack({
+    debug$c("Invalid value, returning"), sendBack({
       type: "done syncing",
       value
     });
     return;
   }
   if (isChanged) {
-    debug$d("Server value changed, syncing editor");
+    debug$c("Server value changed, syncing editor");
     try {
       slateEditor.onChange();
     } catch (err) {
@@ -2013,7 +2013,7 @@ async function updateValue({
       value
     });
   } else
-    debug$d("Server value and editor value is equal, no need to sync.");
+    debug$c("Server value and editor value is equal, no need to sync.");
   sendBack({
     type: "done syncing",
     value
@@ -2047,7 +2047,7 @@ function syncBlock({
               type: "patch",
               patch
             });
-          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$d.enabled && debug$d("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$d.enabled && debug$d("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$c.enabled && debug$c("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$c.enabled && debug$c("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2055,9 +2055,9 @@ function syncBlock({
         }
         if (!oldBlock && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          debug$d.enabled && debug$d("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+          debug$c.enabled && debug$c("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
-          }) : (debug$d("Invalid", validation), sendBack({
+          }) : (debug$c("Invalid", validation), sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2085,14 +2085,14 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     const oldBlockChildrenLength = oldBlock.children.length;
     currentBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - currentBlock.children.length)).forEach((_, index) => {
       const childIndex = oldBlockChildrenLength - 1 - index;
-      childIndex > 0 && (debug$d("Removing child"), Transforms.removeNodes(slateEditor, {
+      childIndex > 0 && (debug$c("Removing child"), Transforms.removeNodes(slateEditor, {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key) {
-          debug$d("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$c("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";
@@ -2109,23 +2109,23 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$d("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode || (debug$c("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
             voids: !0
           }));
-        } else oldBlockChild ? (debug$d("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$c("Replacing child", currentBlockChild), Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$d("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$c("Inserting new child", currentBlockChild), Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slateEditor.onChange());
     });
   }
 }
-const debug$c = debugWithName("component:PortableTextEditor:Synchronizer");
+const debug$b = debugWithName("component:PortableTextEditor:Synchronizer");
 function Synchronizer(props) {
   const $ = c(40), {
     editorActor,
@@ -2213,19 +2213,19 @@ function Synchronizer(props) {
   }, t12 = [syncActorRef, readOnly], $[25] = readOnly, $[26] = syncActorRef, $[27] = t11, $[28] = t12) : (t11 = $[27], t12 = $[28]), useEffect(t11, t12);
   let t13, t14;
   $[29] !== syncActorRef || $[30] !== value ? (t13 = () => {
-    debug$c("Value from props changed, syncing new value"), syncActorRef.send({
+    debug$b("Value from props changed, syncing new value"), syncActorRef.send({
       type: "update value",
       value
     });
   }, t14 = [syncActorRef, value], $[29] = syncActorRef, $[30] = value, $[31] = t13, $[32] = t14) : (t13 = $[31], t14 = $[32]), useEffect(t13, t14);
   let t15;
   $[33] !== editorActor || $[34] !== mutationActorRef ? (t15 = () => {
-    debug$c("Subscribing to patch events");
+    debug$b("Subscribing to patch events");
     const sub = editorActor.on("patch", (event_1) => {
       mutationActorRef.send(event_1);
     });
     return () => {
-      debug$c("Unsubscribing to patch events"), sub.unsubscribe();
+      debug$b("Unsubscribing to patch events"), sub.unsubscribe();
     };
   }, $[33] = editorActor, $[34] = mutationActorRef, $[35] = t15) : t15 = $[35];
   let t16;
@@ -2427,11 +2427,11 @@ const converterJson = {
 function escapeHtml(str) {
   return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
 }
-const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain], debug$b = debugWithName("operationToPatches");
+const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain], debug$a = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$b.enabled && debug$b("Operation", JSON.stringify(operation, null, 2));
+    debug$a.enabled && debug$a("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");
@@ -2524,7 +2524,7 @@ function createOperationToPatches(types) {
         _key: block.children[operation.path[1] - 1]._key
       }])];
     }
-    return debug$b("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$a("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches = [], splitBlock = editor.children[operation.path[0]];
@@ -2582,9 +2582,9 @@ function createOperationToPatches(types) {
         _key: block._key
       }, "children", {
         _key: spanToRemove._key
-      }])] : (debug$b("Span not found in editor trying to remove node"), []);
+      }])] : (debug$a("Span not found in editor trying to remove node"), []);
     } else
-      return debug$b("Not creating patch inside object block"), [];
+      return debug$a("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -2610,7 +2610,7 @@ function createOperationToPatches(types) {
         _key: removedSpan._key
       }])) : console.warn(`Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)));
     } else
-      debug$b("Void nodes can't be merged, not creating any patches");
+      debug$a("Void nodes can't be merged, not creating any patches");
     return patches;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -3000,13 +3000,13 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-const debug$a = debugWithName("applyPatches"), debugVerbose = debug$a.enabled && !0;
+const debug$9 = debugWithName("applyPatches"), debugVerbose = debug$9.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose && (debug$a(`
+    debugVerbose && (debug$9(`
 
-NEW PATCH =============================================================`), debug$a(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$9(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -3022,7 +3022,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$a("Unhandled patch", patch.type);
+          debug$9("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -3037,9 +3037,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$a("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   if (!child || !childPath)
-    return debug$a("Child not found"), !1;
+    return debug$9("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, {
@@ -3069,9 +3069,9 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$a("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$a("Ignoring patch targeting void value"), !1;
+    return debug$9("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -3079,7 +3079,7 @@ function insertPatch(editor, patch, schemaTypes) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$a(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$9(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -3088,14 +3088,14 @@ function insertPatch(editor, patch, schemaTypes) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$a("Child not found"), !1;
+    return debug$9("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$a(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$9(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -3109,14 +3109,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$a("Block not found"), !1;
+    return debug$9("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$a("Ignoring setting void value"), !1;
+    return debug$9("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$a("Setting text property"), editor.apply({
+      value.text !== newText && (debug$9("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -3128,7 +3128,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$a("Setting non-text property"), editor.apply({
+      debug$9("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -3136,7 +3136,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$a("Setting block property");
+    debug$9("Setting block property");
     const {
       children,
       ...nextRest
@@ -3153,7 +3153,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$a("Setting children"), block.children.forEach((c2, cIndex) => {
+    }), debug$9("Setting children"), block.children.forEach((c2, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -3184,7 +3184,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$a("Removing everything"), debugState(editor, "before");
+    debug$9("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       Transforms.removeNodes(editor, {
@@ -3211,13 +3211,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$a("Block not found"), !1;
+      return debug$9("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$a(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), Transforms.removeNodes(editor, {
+    return debug$9(`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$a("Child not found"), !1) : (debug$a(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$a(`Removing child at path ${JSON.stringify(childPath)}`), Transforms.removeNodes(editor, {
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$9("Child not found"), !1) : (debug$9(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$9(`Removing child at path ${JSON.stringify(childPath)}`), Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -3225,7 +3225,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose && (debug$a(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$a(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose && (debug$9(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$9(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -3267,7 +3267,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$9 = debugWithName("plugin:withPatches");
+const debug$8 = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -3293,7 +3293,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               patches.forEach((patch) => {
-                debug$9.enabled && debug$9(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                debug$8.enabled && debug$8(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -3306,10 +3306,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$9("Subscribing to remote patches");
+      debug$8("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$9("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$8("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       let patches = [];
@@ -3360,7 +3360,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$8 = debugWithName("plugin:withPlaceholderBlock");
+const debug$7 = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -3385,7 +3385,7 @@ function createWithPlaceholderBlock(editorActor) {
         const node = op.node;
         if (op.path[0] === 0 && Editor.isVoid(editor, node)) {
           const nextPath = Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$8("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$7("Adding placeholder block"), Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -3394,7 +3394,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$7 = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$6 = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor, types) {
   const defaultStyle = types.styles[0].value;
   return function(editor) {
@@ -3407,7 +3407,7 @@ function createWithPortableTextBlockStyle(editorActor, types) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !Path.equals(path, op.path)) {
           const [child] = Editor.node(editor, [op.path[0] + 1, 0]);
           if (Text.isText(child) && child.text === "") {
-            debug$7(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$6(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               style: defaultStyle
@@ -3467,7 +3467,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$6 = debugWithName("plugin:withPortableTextMarkModel");
+const debug$5 = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types) {
   return function(editor) {
     const {
@@ -3481,7 +3481,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         for (const [child, childPath] of children) {
           const nextNode = node.children[childPath[1] + 1];
           if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
-            debug$6("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$5("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), Transforms.mergeNodes(editor, {
               at: [childPath[0], childPath[1] + 1],
@@ -3494,7 +3494,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$6("Adding .markDefs to block node"), editorActor.send({
+        debug$5("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           markDefs: []
@@ -3506,7 +3506,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$6("Adding .marks to span node"), editorActor.send({
+        debug$5("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           marks: []
@@ -3520,7 +3520,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$6("Removing annotations from empty span node"), editorActor.send({
+          debug$5("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -3538,7 +3538,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
           if (editor.isTextSpan(child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
-              debug$6("Removing orphaned annotations from span node"), editorActor.send({
+              debug$5("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3556,7 +3556,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (editor.isTextBlock(block)) {
           const decorators2 = types.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$6("Removing orphaned annotations from span node"), editorActor.send({
+            debug$5("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3574,7 +3574,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$6("Removing duplicate markDefs"), editorActor.send({
+          debug$5("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3589,7 +3589,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextBlock(node) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
         const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual(newMarkDefs, node.markDefs)) {
-          debug$6("Removing markDef not in use"), editorActor.send({
+          debug$5("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3809,7 +3809,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         const [targetBlock, targetPath] = Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq([...oldDefs, ...op.properties.markDefs]);
-          debug$6("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
+          debug$5("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -4009,7 +4009,7 @@ function createWithPortableTextSelections(editorActor, types) {
     }, editor;
   };
 }
-const debug$5 = debugWithName("plugin:withSchemaTypes");
+const debug$4 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
   schemaTypes
@@ -4022,7 +4022,7 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$5("Setting span type on text node without a type");
+        debug$4("Setting span type on text node without a type");
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4038,7 +4038,7 @@ function createWithSchemaTypes({
         return;
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$5("Setting missing key on child node without a key");
+        debug$4("Setting missing key on child node without a key");
         const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4055,43 +4055,12 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
-const debug$4 = debugWithName("plugin:withUtils");
 function createWithUtils({
   editorActor,
   schemaTypes
 }) {
   return function(editor) {
-    return editor.pteExpandToWord = () => {
-      const {
-        selection
-      } = editor;
-      if (selection && !Range.isExpanded(selection)) {
-        const [textNode] = Editor.node(editor, selection.focus, {
-          depth: 2
-        });
-        if (!textNode || !Text.isText(textNode) || textNode.text.length === 0) {
-          debug$4("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 || Number.isNaN(newStartOffset) || Number.isNaN(newEndOffset))) {
-          debug$4("pteExpandToWord: Expanding to focused word"), Transforms.setSelection(editor, {
-            anchor: {
-              ...selection.anchor,
-              offset: newStartOffset
-            },
-            focus: {
-              ...selection.focus,
-              offset: newEndOffset
-            }
-          });
-          return;
-        }
-        debug$4("pteExpandToWord: Can't expand to word here");
-      }
-    }, editor.pteCreateTextBlock = (options) => toSlateValue([{
+    return editor.pteCreateTextBlock = (options) => toSlateValue([{
       _type: schemaTypes.block.name,
       _key: editorActor.getSnapshot().context.keyGenerator(),
       style: schemaTypes.styles[0].value || "normal",
@@ -4630,57 +4599,61 @@ const addAnnotationActionImplementation = ({
     selection: originalSelection
   } = editor;
   let paths;
-  if (originalSelection && (Range.isCollapsed(originalSelection) && (editor.pteExpandToWord(), editor.onChange()), editor.selection)) {
-    let spanPath, markDefPath;
-    const markDefPaths = [];
-    if (!editor.selection)
+  if (originalSelection) {
+    if (Range.isCollapsed(originalSelection))
       return;
-    const selectedBlocks = Editor.nodes(editor, {
-      at: editor.selection,
-      match: (node) => editor.isTextBlock(node),
-      reverse: Range.isBackward(editor.selection)
-    });
-    for (const [block, blockPath] of selectedBlocks) {
-      if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
-        continue;
-      const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
-      markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (Transforms.setNodes(editor, {
-        markDefs: [...markDefs, {
-          _type: action.annotation.name,
-          _key: annotationKey,
-          ...action.annotation.value
-        }]
-      }, {
-        at: blockPath
-      }), markDefPath = [{
-        _key: block._key
-      }, "markDefs", {
-        _key: annotationKey
-      }], Range.isBackward(editor.selection) ? markDefPaths.unshift(markDefPath) : markDefPaths.push(markDefPath)), Transforms.setNodes(editor, {}, {
-        match: Text.isText,
-        split: !0
+    if (editor.selection) {
+      let spanPath, markDefPath;
+      const markDefPaths = [];
+      if (!editor.selection)
+        return;
+      const selectedBlocks = Editor.nodes(editor, {
+        at: editor.selection,
+        match: (node) => editor.isTextBlock(node),
+        reverse: Range.isBackward(editor.selection)
       });
-      const children = Node.children(editor, blockPath);
-      for (const [span, path] of children) {
-        if (!editor.isTextSpan(span) || !Range.includes(editor.selection, path))
+      for (const [block, blockPath] of selectedBlocks) {
+        if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
           continue;
-        const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
-        Transforms.setNodes(editor, {
-          marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
+        const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
+        markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (Transforms.setNodes(editor, {
+          markDefs: [...markDefs, {
+            _type: action.annotation.name,
+            _key: annotationKey,
+            ...action.annotation.value
+          }]
         }, {
-          at: path
-        }), spanPath = [{
+          at: blockPath
+        }), markDefPath = [{
           _key: block._key
-        }, "children", {
-          _key: span._key
-        }];
+        }, "markDefs", {
+          _key: annotationKey
+        }], Range.isBackward(editor.selection) ? markDefPaths.unshift(markDefPath) : markDefPaths.push(markDefPath)), Transforms.setNodes(editor, {}, {
+          match: Text.isText,
+          split: !0
+        });
+        const children = Node.children(editor, blockPath);
+        for (const [span, path] of children) {
+          if (!editor.isTextSpan(span) || !Range.includes(editor.selection, path))
+            continue;
+          const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
+          Transforms.setNodes(editor, {
+            marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
+          }, {
+            at: path
+          }), spanPath = [{
+            _key: block._key
+          }, "children", {
+            _key: span._key
+          }];
+        }
       }
+      markDefPath && spanPath && (paths = {
+        markDefPath,
+        markDefPaths,
+        spanPath
+      });
     }
-    markDefPath && spanPath && (paths = {
-      markDefPath,
-      markDefPaths,
-      spanPath
-    });
   }
   return paths;
 }, removeAnnotationActionImplementation = ({