@portabletext/editor 1.50.6 → 1.50.7

package/lib/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), useEditor = require("./_chunks-cjs/use-editor.cjs"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), noop = require("lodash/noop.js"), slate = require("slate"), slateReact = require("slate-react"), debug$i = require("debug"), util_isEqualSelectionPoints = require("./_chunks-cjs/util.is-equal-selection-points.cjs"), util_sliceBlocks = require("./_chunks-cjs/util.slice-blocks.cjs"), selector_isSelectionExpanded = require("./_chunks-cjs/selector.is-selection-expanded.cjs"), selector_isSelectingEntireBlocks = require("./_chunks-cjs/selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), util_selectionPointToBlockOffset = require("./_chunks-cjs/util.selection-point-to-block-offset.cjs"), isEqual = require("lodash/isEqual.js"), types = require("@sanity/types"), getRandomValues = require("get-random-values-esm"), behaviors_index = require("./behaviors/index.cjs"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), flatten = require("lodash/flatten.js"), omit = require("lodash/omit.js"), util_childSelectionPointToBlockOffset = require("./_chunks-cjs/util.child-selection-point-to-block-offset.cjs"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), immer = require("immer"), startCase = require("lodash.startcase"), isPlainObject = require("lodash/isPlainObject.js");
+var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), useEditor = require("./_chunks-cjs/use-editor.cjs"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), noop = require("lodash/noop.js"), slate = require("slate"), slateReact = require("slate-react"), debug$h = require("debug"), util_isEqualSelectionPoints = require("./_chunks-cjs/util.is-equal-selection-points.cjs"), util_sliceBlocks = require("./_chunks-cjs/util.slice-blocks.cjs"), selector_isSelectionExpanded = require("./_chunks-cjs/selector.is-selection-expanded.cjs"), selector_isSelectingEntireBlocks = require("./_chunks-cjs/selector.is-selecting-entire-blocks.cjs"), slateDom = require("slate-dom"), util_selectionPointToBlockOffset = require("./_chunks-cjs/util.selection-point-to-block-offset.cjs"), isEqual = require("lodash/isEqual.js"), types = require("@sanity/types"), getRandomValues = require("get-random-values-esm"), behaviors_index = require("./behaviors/index.cjs"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), flatten = require("lodash/flatten.js"), omit = require("lodash/omit.js"), util_childSelectionPointToBlockOffset = require("./_chunks-cjs/util.child-selection-point-to-block-offset.cjs"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), immer = require("immer"), startCase = require("lodash.startcase"), isPlainObject = require("lodash/isPlainObject.js");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var React__default = /* @__PURE__ */ _interopDefaultCompat(React), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$i), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject);
+var React__default = /* @__PURE__ */ _interopDefaultCompat(React), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$h), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject);
 function EditorEventListener(props) {
   const $ = reactCompilerRuntime.c(5), editor = useEditor.useEditor(), on = useEffectEvent.useEffectEvent(props.on);
   let t0;
@@ -209,6 +209,17 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
 function isEqualToEmptyEditor(children, schemaTypes) {
   return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && slate.Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].name && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && slate.Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
 }
+function getBlockPath({
+  editor,
+  _key
+}) {
+  const [, blockPath] = Array.from(slate.Editor.nodes(editor, {
+    at: [],
+    match: (n) => n._key === _key
+  })).at(0) ?? [void 0, void 0], blockIndex = blockPath?.at(0);
+  if (blockIndex !== void 0)
+    return [blockIndex];
+}
 function getFocusBlock({
   editor
 }) {
@@ -1558,7 +1569,7 @@ function getEditorSnapshot({
     }
   };
 }
-const debug$h = debugWithName("plugin:withPortableTextMarkModel");
+const debug$g = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
@@ -1572,7 +1583,7 @@ function createWithPortableTextMarkModel(editorActor) {
         for (const [child, childPath] of children) {
           const nextNode = node.children[childPath[1] + 1];
           if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
-            debug$h("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$g("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.mergeNodes(editor, {
               at: [childPath[0], childPath[1] + 1],
@@ -1585,7 +1596,7 @@ function createWithPortableTextMarkModel(editorActor) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$h("Adding .markDefs to block node"), editorActor.send({
+        debug$g("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           markDefs: []
@@ -1597,7 +1608,7 @@ function createWithPortableTextMarkModel(editorActor) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$h("Adding .marks to span node"), editorActor.send({
+        debug$g("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           marks: []
@@ -1611,7 +1622,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextSpan(node)) {
         const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$h("Removing annotations from empty span node"), editorActor.send({
+          debug$g("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -1629,7 +1640,7 @@ function createWithPortableTextMarkModel(editorActor) {
           if (editor.isTextSpan(child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
-              debug$h("Removing orphaned annotations from span node"), editorActor.send({
+              debug$g("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), slate.Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -1647,7 +1658,7 @@ function createWithPortableTextMarkModel(editorActor) {
         if (editor.isTextBlock(block)) {
           const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$h("Removing orphaned annotations from span node"), editorActor.send({
+            debug$g("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -1665,7 +1676,7 @@ function createWithPortableTextMarkModel(editorActor) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$h("Removing duplicate markDefs"), editorActor.send({
+          debug$g("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -1680,7 +1691,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextBlock(node) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
         const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
-          debug$h("Removing markDef not in use"), editorActor.send({
+          debug$g("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -1833,7 +1844,7 @@ function createWithPortableTextMarkModel(editorActor) {
         const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-          debug$h("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
+          debug$g("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -2543,7 +2554,7 @@ function withUndoStep(editor, fn) {
 function getCurrentUndoStepId(editor) {
   return CURRENT_UNDO_STEP.get(editor)?.undoStepId;
 }
-const debug$g = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$f = 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) || []);
@@ -2556,7 +2567,7 @@ function createWithUndoRedo(options) {
     const remotePatches = getRemotePatches(editor);
     let previousUndoStepId = getCurrentUndoStepId(editor);
     options.subscriptions.push(() => {
-      debug$g("Subscribing to patches");
+      debug$f("Subscribing to patches");
       const sub = editorActor.on("patches", ({
         patches: patches2,
         snapshot
@@ -2565,7 +2576,7 @@ function createWithUndoRedo(options) {
         patches2.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$g("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+              debug$f("Someone else cleared the content, resetting undo/redo history"), editor.history = {
                 undos: [],
                 redos: []
               }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -2581,7 +2592,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$g("Unsubscribing to patches"), sub.unsubscribe();
+        debug$f("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -2620,7 +2631,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$f("Created new undo step", step);
         }
         for (; undos.length > UNDO_STEP_LIMIT; )
           undos.shift();
@@ -2638,7 +2649,7 @@ const historyUndoOperationImplementation = ({
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (undos.length > 0) {
     const step = undos[undos.length - 1];
-    if (debug$g("Undoing", step), step.operations.length > 0) {
+    if (debug$f("Undoing", step), step.operations.length > 0) {
       const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
       let transformedOperations = step.operations;
       otherPatches.forEach((item) => {
@@ -2656,7 +2667,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+        debug$f("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
           undos: [],
           redos: []
         }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
@@ -2673,7 +2684,7 @@ const historyUndoOperationImplementation = ({
   } = editor.history, remotePatches = getRemotePatches(editor);
   if (redos.length > 0) {
     const step = redos[redos.length - 1];
-    if (debug$g("Redoing", step), step.operations.length > 0) {
+    if (debug$f("Redoing", step), step.operations.length > 0) {
       const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
       let transformedOperations = step.operations;
       otherPatches.forEach((item) => {
@@ -2690,7 +2701,7 @@ const historyUndoOperationImplementation = ({
           });
         });
       } catch (err) {
-        debug$g("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+        debug$f("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
           undos: [],
           redos: []
         }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
@@ -2708,16 +2719,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual__default.default({
       _key: blk._key
     }, patch.path[0]));
-    return debug$g(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$f(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 1) {
     const unsetBlockIndex = (previousSnapshot || []).findIndex((blk) => isEqual__default.default({
       _key: blk._key
     }, patch.path[0]));
-    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$g("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$f("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$g(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$f(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual__default.default({
@@ -3167,58 +3178,29 @@ const addAnnotationOperationImplementation = ({
     };
   }
 }, deleteOperationImplementation = ({
-  context,
   operation
 }) => {
+  const anchorBlockPath = util_sliceBlocks.isKeyedSegment(operation.at.anchor.path[0]) ? getBlockPath({
+    editor: operation.editor,
+    _key: operation.at.anchor.path[0]._key
+  }) : void 0, focusBlockPath = util_sliceBlocks.isKeyedSegment(operation.at.focus.path[0]) ? getBlockPath({
+    editor: operation.editor,
+    _key: operation.at.focus.path[0]._key
+  }) : void 0;
+  if (operation.at.anchor.path.length === 1 && operation.at.focus.path.length === 1 && anchorBlockPath && focusBlockPath && anchorBlockPath[0] === focusBlockPath[0]) {
+    slate.Transforms.removeNodes(operation.editor, {
+      at: [anchorBlockPath[0]]
+    });
+    return;
+  }
   const range = toSlateRange(operation.at, operation.editor);
   if (!range)
     throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(operation.at)}`);
-  if (slate.Range.isCollapsed(range)) {
-    const [focusBlock] = getFocusBlock({
-      editor: {
-        ...operation.editor,
-        selection: range
-      }
-    }), [focusChild] = getFocusChild({
-      editor: {
-        ...operation.editor,
-        selection: range
-      }
-    });
-    if (focusBlock && focusBlock._type === context.schema.block.name && focusChild && focusChild._type === context.schema.span.name)
-      return;
-  }
   operation.editor.delete({
-    at: range
-  });
-}, deleteBackwardOperationImplementation = ({
-  operation
-}) => {
-  slate.deleteBackward(operation.editor, operation.unit);
-}, deleteBlockOperationImplementation = ({
-  operation
-}) => {
-  const range = toSlateRange({
-    anchor: {
-      path: operation.at,
-      offset: 0
-    },
-    focus: {
-      path: operation.at,
-      offset: 0
-    }
-  }, operation.editor);
-  if (!range) {
-    console.error("Unable to find Slate range from selection points");
-    return;
-  }
-  slate.Transforms.removeNodes(operation.editor, {
-    at: range
+    at: range,
+    reverse: operation.direction === "backward",
+    unit: operation.unit
   });
-}, deleteForwardOperationImplementation = ({
-  operation
-}) => {
-  slate.deleteForward(operation.editor, operation.unit);
 }, insertInlineObjectOperationImplementation = ({
   context,
   operation
@@ -3511,9 +3493,6 @@ const moveBackwardOperationImplementation = ({
   "decorator.add": decoratorAddOperationImplementation,
   "decorator.remove": removeDecoratorOperationImplementation,
   delete: deleteOperationImplementation,
-  "delete.backward": deleteBackwardOperationImplementation,
-  "delete.forward": deleteForwardOperationImplementation,
-  "delete.block": deleteBlockOperationImplementation,
   "history.redo": historyRedoOperationImplementation,
   "history.undo": historyUndoOperationImplementation,
   "insert.block": insertBlockOperationImplementation,
@@ -3580,27 +3559,6 @@ function performOperation({
         });
         break;
       }
-      case "delete.backward": {
-        behaviorOperationImplementations["delete.backward"]({
-          context,
-          operation
-        });
-        break;
-      }
-      case "delete.block": {
-        behaviorOperationImplementations["delete.block"]({
-          context,
-          operation
-        });
-        break;
-      }
-      case "delete.forward": {
-        behaviorOperationImplementations["delete.forward"]({
-          context,
-          operation
-        });
-        break;
-      }
       case "history.redo": {
         behaviorOperationImplementations["history.redo"]({
           context,
@@ -3691,9 +3649,39 @@ function createWithEventListeners(editorActor) {
     if (editorActor.getSnapshot().context.maxBlocks !== void 0)
       return editor;
     const {
+      delete: editorDelete,
       select
     } = editor;
-    return editor.deleteBackward = (unit) => {
+    return editor.delete = (options) => {
+      if (isApplyingBehaviorOperations(editor)) {
+        editorDelete(options);
+        return;
+      }
+      const at = options?.at ?? editor.selection;
+      if (!at) {
+        console.error("Unexpected call to .delete(...) without `at` option");
+        return;
+      }
+      const range = slate.Editor.range(editor, at), selection = slateRangeToSelection({
+        schema: editorActor.getSnapshot().context.schema,
+        editor,
+        range
+      });
+      if (!selection) {
+        console.error("Unexpected call to .delete(...) with invalid `at` option");
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "delete",
+          at: selection,
+          direction: options?.reverse ? "backward" : "forward",
+          unit: options?.unit
+        },
+        editor
+      });
+    }, editor.deleteBackward = (unit) => {
       if (isApplyingBehaviorOperations(editor)) {
         console.error("Unexpected call to .deleteBackward(...)");
         return;
@@ -3951,13 +3939,9 @@ function createWithObjectKeys(editorActor) {
     }, editor;
   };
 }
-const debug$f = debugWithName("applyPatches"), debugVerbose = debug$f.enabled && !0;
 function createApplyPatch(schema2) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose && (debug$f(`
-
-NEW PATCH =============================================================`), debug$f(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -3972,8 +3956,6 @@ NEW PATCH =============================================================`), debug
         case "diffMatchPatch":
           changed = diffMatchPatch(editor, patch);
           break;
-        default:
-          debug$f("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -3982,164 +3964,166 @@ NEW PATCH =============================================================`), debug
   };
 }
 function diffMatchPatch(editor, patch) {
-  const {
-    block,
-    child,
-    childPath
-  } = findBlockAndChildFromPath(editor, patch.path);
+  const block = findBlock(editor.children, patch.path);
   if (!block)
-    return debug$f("Block not found"), !1;
-  if (!child || !childPath)
-    return debug$f("Child not found"), !1;
-  if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child))
     return !1;
-  const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, {
+  const child = findBlockChild(block, patch.path);
+  if (!child || !(block && editor.isTextBlock(block.node) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child.node))
+    return !1;
+  const patches2 = parse(patch.value), [newValue] = apply(patches2, child.node.text, {
     allowExceedingIndices: !0
-  }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
-  debugState(editor, "before");
+  }), diff$1 = cleanupEfficiency(diff(child.node.text, newValue), 5);
   let offset = 0;
   for (const [op, text] of diff$1)
     op === DIFF_INSERT ? (editor.apply({
       type: "insert_text",
-      path: childPath,
+      path: [block.index, child.index],
       offset,
       text
     }), offset += text.length) : op === DIFF_DELETE ? editor.apply({
       type: "remove_text",
-      path: childPath,
+      path: [block.index, child.index],
       offset,
       text
     }) : op === DIFF_EQUAL && (offset += text.length);
-  return debugState(editor, "after"), !0;
+  return !0;
 }
 function insertPatch(editor, patch, schema2) {
-  const {
-    block: targetBlock,
-    child: targetChild,
-    blockPath: targetBlockPath,
-    childPath: targetChildPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (!targetBlock || !targetBlockPath)
-    return debug$f("Block not found"), !1;
-  if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$f("Ignoring patch targeting void value"), !1;
+  const block = findBlock(editor.children, patch.path);
+  if (!block || patch.path.length > 1 && patch.path[1] !== "children")
+    return !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
       position: position2
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes: schema2
-    }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    debug$f(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before");
-    const editorWasEmptyBefore = isEqualToEmptyEditor(editor.children, schema2);
+    }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = block.index, normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex, editorWasEmptyBefore = isEqualToEmptyEditor(editor.children, schema2);
     return slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), editorWasEmptyBefore && typeof patch.path[0] == "number" && patch.path[0] === 0 && slate.Transforms.removeNodes(editor, {
       at: [position2 === "before" ? targetBlockIndex + 1 : targetBlockIndex]
-    }), debugState(editor, "after"), !0;
+    }), !0;
   }
   const {
     items,
     position
-  } = patch;
-  if (!targetChild || !targetChildPath)
-    return debug$f("Child not found"), !1;
-  const childrenToInsert = targetBlock && toSlateValue([{
-    ...targetBlock,
+  } = patch, targetChild = findBlockChild(block, patch.path);
+  if (!targetChild)
+    return !1;
+  const childrenToInsert = toSlateValue([{
+    ...block.node,
     children: items
   }], {
     schemaTypes: schema2
-  }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$f(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  }, KEY_TO_SLATE_ELEMENT.get(editor)), normalizedIdx = position === "after" ? targetChild.index + 1 : targetChild.index, childInsertPath = [block.index, normalizedIdx];
+  return childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
-  }), debugState(editor, "after"), !0;
+  }), !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);
+  const block = findBlock(editor.children, patch.path);
   if (!block)
-    return debug$f("Block not found"), !1;
-  const isTextBlock = editor.isTextBlock(block);
+    return !1;
+  const isTextBlock = editor.isTextBlock(block.node);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$f("Ignoring setting void value"), !1;
-  if (debugState(editor, "before"), isTextBlock && child && childPath) {
-    if (slate.Text.isText(value) && slate.Text.isText(child)) {
-      const newText = child.text;
-      value.text !== newText && (debug$f("Setting text property"), editor.apply({
-        type: "remove_text",
-        path: childPath,
-        offset: 0,
-        text: newText
-      }), editor.apply({
-        type: "insert_text",
-        path: childPath,
-        offset: 0,
-        text: value.text
-      }), editor.onChange());
-    } else
-      debug$f("Setting non-text property"), editor.apply({
-        type: "set_node",
-        path: childPath,
-        properties: {},
-        newProperties: value
+    return !1;
+  const child = findBlockChild(block, patch.path);
+  if (isTextBlock && child) {
+    if (slate.Text.isText(child.node))
+      if (slate.Text.isText(value)) {
+        const oldText = child.node.text, newText = value.text;
+        oldText !== newText && (editor.apply({
+          type: "remove_text",
+          path: [block.index, child.index],
+          offset: 0,
+          text: oldText
+        }), editor.apply({
+          type: "insert_text",
+          path: [block.index, child.index],
+          offset: 0,
+          text: newText
+        }), editor.onChange());
+      } else {
+        const propPath = patch.path.slice(3), propEntry = propPath.at(0);
+        if (propEntry === void 0 || typeof propEntry == "string" && ["_key", "_type", "text"].includes(propEntry))
+          return !1;
+        const newNode = patches.applyAll(child.node, [{
+          ...patch,
+          path: propPath
+        }]);
+        slate.Transforms.setNodes(editor, newNode, {
+          at: [block.index, child.index]
+        });
+      }
+    else {
+      const propPath = patch.path.slice(3), reservedProps = ["_key", "_type", "children", "__inline"], propEntry = propPath.at(0);
+      if (propEntry === void 0 || typeof propEntry == "string" && reservedProps.includes(propEntry))
+        return !1;
+      const value2 = "value" in child.node && typeof child.node.value == "object" ? child.node.value : {}, newValue = patches.applyAll(value2, [{
+        ...patch,
+        path: patch.path.slice(3)
+      }]);
+      slate.Transforms.setNodes(editor, {
+        ...child.node,
+        value: newValue
+      }, {
+        at: [block.index, child.index]
       });
+    }
     return !0;
-  } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$f("Setting block property");
+  } else if (slate.Element.isElement(block.node) && patch.path.length === 1) {
     const {
       children,
       ...nextRest
     } = value, {
       children: prevChildren,
       ...prevRest
-    } = block || {
+    } = block.node || {
       children: void 0
     };
     editor.apply({
       type: "set_node",
-      path: blockPath,
+      path: [block.index],
       properties: {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$f("Setting children"), block.children.forEach((c, cIndex) => {
+    });
+    const blockNode = block.node;
+    blockNode.children.forEach((child2, childIndex) => {
       editor.apply({
         type: "remove_node",
-        path: blockPath.concat(block.children.length - 1 - cIndex),
-        node: c
+        path: [block.index, blockNode.children.length - 1 - childIndex],
+        node: child2
       });
-    }), Array.isArray(children) && children.forEach((c, cIndex) => {
+    }), Array.isArray(children) && children.forEach((child2, childIndex) => {
       editor.apply({
         type: "insert_node",
-        path: blockPath.concat(cIndex),
-        node: c
+        path: [block.index, childIndex],
+        node: child2
       });
     });
-  } else if (block && "value" in block)
+  } else if (block && "value" in block.node)
     if (patch.path.length > 1 && patch.path[1] !== "children") {
-      const newVal = patches.applyAll(block.value, [{
+      const newVal = patches.applyAll(block.node.value, [{
         ...patch,
         path: patch.path.slice(1)
       }]);
       slate.Transforms.setNodes(editor, {
-        ...block,
+        ...block.node,
         value: newVal
       }, {
-        at: blockPath
+        at: [block.index]
       });
     } else
       return !1;
-  return debugState(editor, "after"), !0;
+  return !0;
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$f("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     slate.Transforms.deselect(editor);
     const children = slate.Node.children(editor, [], {
@@ -4160,71 +4144,97 @@ function unsetPatch(editor, patch) {
         path: [0, 0],
         offset: 0
       }
-    }), editor.onChange(), debugState(editor, "after"), !0;
+    }), editor.onChange(), !0;
   }
-  const {
-    block,
-    blockPath,
-    child,
-    childPath
-  } = findBlockAndChildFromPath(editor, patch.path);
-  if (patch.path.length === 1) {
-    if (!block || !blockPath)
-      return debug$f("Block not found"), !1;
-    const blockIndex = blockPath[0];
-    return debug$f(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
-      at: [blockIndex]
-    }), debugState(editor, "after"), !0;
+  const block = findBlock(editor.children, patch.path);
+  if (!block)
+    return !1;
+  if (patch.path.length === 1)
+    return slate.Transforms.removeNodes(editor, {
+      at: [block.index]
+    }), !0;
+  const child = findBlockChild(block, patch.path);
+  if (editor.isTextBlock(block.node) && child && patch.path[1] === "children" && patch.path.length === 3)
+    return slate.Transforms.removeNodes(editor, {
+      at: [block.index, child.index]
+    }), !0;
+  if (child && !slate.Text.isText(child.node)) {
+    const propEntry = patch.path.slice(3).at(0);
+    if (propEntry === void 0 || typeof propEntry == "string" && ["_key", "_type", "children", "__inline"].includes(propEntry))
+      return !1;
+    const value = "value" in child.node && typeof child.node.value == "object" ? child.node.value : {}, newValue = patches.applyAll(value, [{
+      ...patch,
+      path: patch.path.slice(3)
+    }]);
+    return slate.Transforms.setNodes(editor, {
+      ...child.node,
+      value: newValue
+    }, {
+      at: [block.index, child.index]
+    }), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$f("Child not found"), !1) : (debug$f(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$f(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
-    at: childPath
-  }), debugState(editor, "after"), !0) : !1;
-}
-function isKeyedSegment(segment) {
-  return typeof segment == "object" && "_key" in segment;
-}
-function debugState(editor, stateName) {
-  debugVerbose && (debug$f(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$f(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  if (child && slate.Text.isText(child.node)) {
+    const propPath = patch.path.slice(3), propEntry = propPath.at(0);
+    if (propEntry === void 0 || typeof propEntry == "string" && ["_key", "_type"].includes(propEntry))
+      return !1;
+    if (typeof propEntry == "string" && propEntry === "text")
+      return editor.apply({
+        type: "remove_text",
+        path: [block.index, child.index],
+        offset: 0,
+        text: child.node.text
+      }), !0;
+    const newNode = patches.applyAll(child.node, [{
+      ...patch,
+      path: propPath
+    }]), removedProperties = Object.keys(child.node).filter((property) => newNode[property] === void 0);
+    return slate.Transforms.unsetNodes(editor, removedProperties, {
+      at: [block.index, child.index]
+    }), !0;
+  }
+  if (!child) {
+    if ("value" in block.node) {
+      const newVal = patches.applyAll(block.node.value, [{
+        ...patch,
+        path: patch.path.slice(1)
+      }]);
+      return slate.Transforms.setNodes(editor, {
+        ...block.node,
+        value: newVal
+      }, {
+        at: [block.index]
+      }), !0;
+    }
+    return !1;
+  }
+  return !1;
 }
-function findBlockFromPath(editor, path) {
+function findBlock(children, path) {
   let blockIndex = -1;
-  const block = editor.children.find((node, index) => {
-    const isMatch = isKeyedSegment(path[0]) ? node._key === path[0]._key : index === path[0];
+  const block = children.find((node, index) => {
+    const isMatch = util_sliceBlocks.isKeyedSegment(path[0]) ? node._key === path[0]._key : index === path[0];
     return isMatch && (blockIndex = index), isMatch;
   });
-  return block ? {
-    block,
-    path: [blockIndex]
-  } : {};
-}
-function findBlockAndChildFromPath(editor, path) {
-  const {
-    block,
-    path: blockPath
-  } = findBlockFromPath(editor, path);
-  if (!(slate.Element.isElement(block) && path[1] === "children"))
+  if (block)
     return {
-      block,
-      blockPath,
-      child: void 0,
-      childPath: void 0
+      node: block,
+      index: blockIndex
     };
+}
+function findBlockChild(block, path) {
+  const blockNode = block.node;
+  if (!slate.Element.isElement(blockNode) || path[1] !== "children")
+    return;
   let childIndex = -1;
-  const child = block.children.find((node, index) => {
-    const isMatch = isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2];
+  const child = blockNode.children.find((node, index) => {
+    const isMatch = util_sliceBlocks.isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2];
     return isMatch && (childIndex = index), isMatch;
   });
-  return child ? {
-    block,
-    child,
-    blockPath,
-    childPath: blockPath?.concat(childIndex)
-  } : {
-    block,
-    blockPath,
-    child: void 0,
-    childPath: void 0
-  };
+  if (child)
+    return {
+      node: child,
+      index: childIndex
+    };
 }
 function insertTextPatch(schema2, children, operation, beforeValue) {
   const block = util_sliceBlocks.isTextBlock({
@@ -5885,6 +5895,57 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
     type: "decorator.add"
   })]]
 })], abstractDeleteBehaviors = [behaviors_index.defineBehavior({
+  on: "delete.backward",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [behaviors_index.raise({
+    type: "delete",
+    direction: "backward",
+    unit: event.unit,
+    at: selection
+  })]]
+}), behaviors_index.defineBehavior({
+  on: "delete.forward",
+  guard: ({
+    snapshot
+  }) => snapshot.context.selection ? {
+    selection: snapshot.context.selection
+  } : !1,
+  actions: [({
+    event
+  }, {
+    selection
+  }) => [behaviors_index.raise({
+    type: "delete",
+    direction: "forward",
+    unit: event.unit,
+    at: selection
+  })]]
+}), behaviors_index.defineBehavior({
+  on: "delete.block",
+  actions: [({
+    event
+  }) => [behaviors_index.raise({
+    type: "delete",
+    at: {
+      anchor: {
+        path: event.at,
+        offset: 0
+      },
+      focus: {
+        path: event.at,
+        offset: 0
+      }
+    }
+  })]]
+}), behaviors_index.defineBehavior({
   on: "delete.text",
   guard: ({
     snapshot,
@@ -6299,7 +6360,12 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
   actions: [(_, {
     newTextBlock,
     selection
-  }) => [behaviors_index.raise({
+  }) => util_selectionPointToBlockOffset.isSelectionCollapsed(selection) ? [behaviors_index.raise({
+    type: "insert.block",
+    block: newTextBlock,
+    placement: "after",
+    select: "start"
+  })] : [behaviors_index.raise({
     type: "delete",
     at: selection
   }), behaviors_index.raise({
@@ -6711,7 +6777,7 @@ const arrowDownOnLonelyBlockObject = behaviors_index.defineBehavior({
 function isSyntheticBehaviorEvent(event) {
   return !isCustomBehaviorEvent(event) && !isNativeBehaviorEvent(event) && !isAbstractBehaviorEvent(event);
 }
-const abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "delete.text", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "split", "style.add", "style.remove", "style.toggle"];
+const abstractBehaviorEventTypes = ["annotation.toggle", "decorator.toggle", "delete.backward", "delete.block", "delete.forward", "delete.text", "deserialize", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.soft break", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.previous block", "select.next block", "serialize", "serialization.success", "serialization.failure", "split", "style.add", "style.remove", "style.toggle"];
 function isAbstractBehaviorEvent(event) {
   return abstractBehaviorEventTypes.includes(event.type);
 }
@@ -8864,20 +8930,22 @@ async function updateValue({
   const hadSelection = !!slateEditor.selection;
   if ((!value || value.length === 0) && (debug$5("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
-      withoutPatching(slateEditor, () => {
-        if (doneSyncing)
-          return;
-        hadSelection && slate.Transforms.deselect(slateEditor);
-        const childrenLength = slateEditor.children.length;
-        slateEditor.children.forEach((_, index) => {
-          slate.Transforms.removeNodes(slateEditor, {
-            at: [childrenLength - 1 - index]
-          });
-        }), slate.Transforms.insertNodes(slateEditor, slateEditor.pteCreateTextBlock({
-          decorators: []
-        }), {
-          at: [0]
-        }), hadSelection && slate.Transforms.select(slateEditor, [0, 0]);
+      withRemoteChanges(slateEditor, () => {
+        withoutPatching(slateEditor, () => {
+          if (doneSyncing)
+            return;
+          hadSelection && slate.Transforms.deselect(slateEditor);
+          const childrenLength = slateEditor.children.length;
+          slateEditor.children.forEach((_, index) => {
+            slate.Transforms.removeNodes(slateEditor, {
+              at: [childrenLength - 1 - index]
+            });
+          }), slate.Transforms.insertNodes(slateEditor, slateEditor.pteCreateTextBlock({
+            decorators: []
+          }), {
+            at: [0]
+          }), hadSelection && slate.Transforms.select(slateEditor, [0, 0]);
+        });
       });
     });
   }), isChanged = !0), value && value.length > 0) {