@portabletext/editor 1.50.2 → 1.50.4

package/lib/index.js

@@ -7,9 +7,9 @@ import { useSelector, useActorRef } from "@xstate/react";
 import noop from "lodash/noop.js";
 import { Element as Element$1, Text, Range, Editor, Node, Point, Transforms, Path, Operation, deleteBackward, deleteForward, createEditor } from "slate";
 import { useSlateStatic, useSelected, withReact, ReactEditor, Slate, useSlate, Editable } from "slate-react";
-import debug$j from "debug";
+import debug$i from "debug";
 import { getBlockEndPoint, isEmptyTextBlock, isEqualSelectionPoints } from "./_chunks-es/util.is-equal-selection-points.js";
-import { getBlockStartPoint, isKeyedSegment as isKeyedSegment$1, parseInlineObject, parseTextBlock, parseBlockObject, parseBlock, sliceBlocks, isTextBlock, parseAnnotation, blockOffsetToSpanSelectionPoint, isSpan$1 as isSpan, isListBlock, getTextBlockText, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
+import { getBlockStartPoint, isKeyedSegment as isKeyedSegment$1, parseInlineObject, parseTextBlock, parseBlockObject, parseBlock, sliceBlocks, isTextBlock, parseAnnotation, blockOffsetToSpanSelectionPoint, isSpan$1 as isSpan, isListBlock, isTypedObject, getTextBlockText, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
 import { isSelectionCollapsed, getFocusTextBlock, getFocusSpan, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock as getSelectionStartBlock$1, getSelectionEndBlock as getSelectionEndBlock$1, getFocusBlock as getFocusBlock$1, getFocusBlockObject, getPreviousBlock, getNextBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock } from "./_chunks-es/selector.is-selection-expanded.js";
 import { getFocusInlineObject, isOverlappingSelection, isSelectingEntireBlocks, getTrimmedSelection, getCaretWordSelection, isAtTheEndOfBlock, isAtTheStartOfBlock, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, getActiveAnnotations } from "./_chunks-es/selector.is-selecting-entire-blocks.js";
 import { DOMEditor, isDOMNode } from "slate-dom";
@@ -24,13 +24,14 @@ import { setup, assign, enqueueActions, emit, assertEvent, stateIn, fromCallback
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
 import { Schema } from "@sanity/schema";
-import { insert, unset, set, diffMatchPatch as diffMatchPatch$1, setIfMissing, applyAll } from "@portabletext/patches";
-import get from "lodash/get.js";
-import isUndefined from "lodash/isUndefined.js";
-import omitBy from "lodash/omitBy.js";
 import flatten from "lodash/flatten.js";
 import omit from "lodash/omit.js";
 import { blockOffsetsToSelection } from "./_chunks-es/util.child-selection-point-to-block-offset.js";
+import { applyAll, unset, insert, set, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
+import get from "lodash/get.js";
+import isUndefined from "lodash/isUndefined.js";
+import omitBy from "lodash/omitBy.js";
+import { createDraft, finishDraft } from "immer";
 import startCase from "lodash.startcase";
 import isPlainObject from "lodash/isPlainObject.js";
 function EditorEventListener(props) {
@@ -59,10 +60,10 @@ function getCompoundClientRect(nodes) {
   return new DOMRect(left, top, right - left, bottom - top);
 }
 const rootName = "sanity-pte:";
-debug$j(rootName);
+debug$i(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$j && debug$j.enabled(namespace) ? debug$j(namespace) : debug$j(rootName);
+  return debug$i && debug$i.enabled(namespace) ? debug$i(namespace) : debug$i(rootName);
 }
 function getDragSelection({
   eventSelection,
@@ -1376,226 +1377,18 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
-const debug$i = debugWithName("operationToPatches");
-function createOperationToPatches(editorActor) {
-  const textBlockName = editorActor.getSnapshot().context.schema.block.name;
-  function insertTextPatch(editor, operation, beforeValue) {
-    debug$i.enabled && debug$i("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");
-    const textChild = editor.isTextBlock(block) && editor.isTextSpan(block.children[operation.path[1]]) && block.children[operation.path[1]];
-    if (!textChild)
-      throw new Error("Could not find child");
-    const path = [{
-      _key: block._key
-    }, "children", {
-      _key: textChild._key
-    }, "text"], prevBlock = beforeValue[operation.path[0]], prevChild = editor.isTextBlock(prevBlock) && prevBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevChild) ? prevChild.text : "", patch = diffMatchPatch$1(prevText, textChild.text, path);
-    return patch.value.length ? [patch] : [];
-  }
-  function removeTextPatch(editor, operation, beforeValue) {
-    const block = editor && editor.children[operation.path[0]];
-    if (!block)
-      throw new Error("Could not find block");
-    const child = editor.isTextBlock(block) && block.children[operation.path[1]] || void 0, textChild = editor.isTextSpan(child) ? child : void 0;
-    if (child && !textChild)
-      throw new Error("Expected span");
-    if (!textChild)
-      throw new Error("Could not find child");
-    const path = [{
-      _key: block._key
-    }, "children", {
-      _key: textChild._key
-    }, "text"], beforeBlock = beforeValue[operation.path[0]], prevTextChild = editor.isTextBlock(beforeBlock) && beforeBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevTextChild) && prevTextChild.text, patch = diffMatchPatch$1(prevText || "", textChild.text, path);
-    return patch.value ? [patch] : [];
-  }
-  function setNodePatch(editor, operation) {
-    if (operation.path.length === 1) {
-      const block = editor.children[operation.path[0]];
-      if (typeof block._key != "string")
-        throw new Error("Expected block to have a _key");
-      const setNode = omitBy({
-        ...editor.children[operation.path[0]],
-        ...operation.newProperties
-      }, isUndefined);
-      return [set(fromSlateValue([setNode], textBlockName)[0], [{
-        _key: block._key
-      }])];
-    } else if (operation.path.length === 2) {
-      const block = editor.children[operation.path[0]];
-      if (editor.isTextBlock(block)) {
-        const child = block.children[operation.path[1]];
-        if (child) {
-          const blockKey = block._key, childKey = child._key, patches = [], keys = Object.keys(operation.newProperties);
-          return keys.forEach((keyName) => {
-            if (keys.length === 1 && keyName === "_key") {
-              const val = get(operation.newProperties, keyName);
-              patches.push(set(val, [{
-                _key: blockKey
-              }, "children", block.children.indexOf(child), keyName]));
-            } else {
-              const val = get(operation.newProperties, keyName);
-              patches.push(set(val, [{
-                _key: blockKey
-              }, "children", {
-                _key: childKey
-              }, keyName]));
-            }
-          }), patches;
-        }
-        throw new Error("Could not find a valid child");
-      }
-      throw new Error("Could not find a valid block");
-    } else
-      throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
-  }
-  function insertNodePatch(editor, operation, beforeValue) {
-    const block = beforeValue[operation.path[0]], isTextBlock2 = editor.isTextBlock(block);
-    if (operation.path.length === 1) {
-      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block?._key : beforeBlock?._key;
-      return targetKey ? [insert([fromSlateValue([operation.node], textBlockName)[0]], position, [{
-        _key: targetKey
-      }])] : [setIfMissing(beforeValue, []), insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [operation.path[0]])];
-    } else if (isTextBlock2 && operation.path.length === 2 && editor.children[operation.path[0]]) {
-      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = {
-        ...operation.node
-      };
-      !node._type && Text.isText(node) && (node._type = "span", node.marks = []);
-      const child = fromSlateValue([{
-        _key: "bogus",
-        _type: textBlockName,
-        children: [node]
-      }], textBlockName)[0].children[0];
-      return [insert([child], position, [{
-        _key: block._key
-      }, "children", block.children.length <= 1 || !block.children[operation.path[1] - 1] ? 0 : {
-        _key: block.children[operation.path[1] - 1]._key
-      }])];
-    }
-    return debug$i("Something was inserted into a void block. Not producing editor patches."), [];
-  }
-  function splitNodePatch(editor, operation, beforeValue) {
-    const patches = [], splitBlock = editor.children[operation.path[0]];
-    if (!editor.isTextBlock(splitBlock))
-      throw new Error(`Block with path ${JSON.stringify(operation.path[0])} is not a text block and can't be split`);
-    if (operation.path.length === 1) {
-      const oldBlock = beforeValue[operation.path[0]];
-      if (editor.isTextBlock(oldBlock)) {
-        const targetValue = fromSlateValue([editor.children[operation.path[0] + 1]], textBlockName)[0];
-        targetValue && (patches.push(insert([targetValue], "after", [{
-          _key: splitBlock._key
-        }])), oldBlock.children.slice(operation.position).forEach((span) => {
-          const path = [{
-            _key: oldBlock._key
-          }, "children", {
-            _key: span._key
-          }];
-          patches.push(unset(path));
-        }));
-      }
-      return patches;
-    }
-    if (operation.path.length === 2) {
-      const splitSpan = splitBlock.children[operation.path[1]];
-      if (editor.isTextSpan(splitSpan)) {
-        const targetSpans = fromSlateValue([{
-          ...splitBlock,
-          children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
-        }], textBlockName)[0].children;
-        patches.push(insert(targetSpans, "after", [{
-          _key: splitBlock._key
-        }, "children", {
-          _key: splitSpan._key
-        }])), patches.push(set(splitSpan.text, [{
-          _key: splitBlock._key
-        }, "children", {
-          _key: splitSpan._key
-        }, "text"]));
-      }
-      return patches;
-    }
-    return patches;
-  }
-  function removeNodePatch(editor, operation, beforeValue) {
-    const block = beforeValue[operation.path[0]];
-    if (operation.path.length === 1) {
-      if (block && block._key)
-        return [unset([{
-          _key: block._key
-        }])];
-      throw new Error("Block not found");
-    } else if (editor.isTextBlock(block) && operation.path.length === 2) {
-      const spanToRemove = block.children[operation.path[1]];
-      return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(`Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)), []) : [unset([{
-        _key: block._key
-      }, "children", {
-        _key: spanToRemove._key
-      }])] : (debug$i("Span not found in editor trying to remove node"), []);
-    } else
-      return debug$i("Not creating patch inside object block"), [];
-  }
-  function mergeNodePatch(editor, operation, beforeValue) {
-    const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
-    if (operation.path.length === 1)
-      if (block?._key) {
-        const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
-        patches.push(set(newBlock, [{
-          _key: newBlock._key
-        }])), patches.push(unset([{
-          _key: block._key
-        }]));
-      } else
-        throw new Error("Target key not found!");
-    else if (editor.isTextBlock(block) && editor.isTextBlock(updatedBlock) && operation.path.length === 2) {
-      const updatedSpan = updatedBlock.children[operation.path[1] - 1] && editor.isTextSpan(updatedBlock.children[operation.path[1] - 1]) ? updatedBlock.children[operation.path[1] - 1] : void 0, removedSpan = block.children[operation.path[1]] && editor.isTextSpan(block.children[operation.path[1]]) ? block.children[operation.path[1]] : void 0;
-      updatedSpan && (block.children.filter((span) => span._key === updatedSpan._key).length === 1 ? patches.push(set(updatedSpan.text, [{
-        _key: block._key
-      }, "children", {
-        _key: updatedSpan._key
-      }, "text"])) : console.warn(`Multiple spans have \`_key\` ${updatedSpan._key}. It's ambiguous which one to update.`, JSON.stringify(block, null, 2))), removedSpan && (block.children.filter((span) => span._key === removedSpan._key).length === 1 ? patches.push(unset([{
-        _key: block._key
-      }, "children", {
-        _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$i("Void nodes can't be merged, not creating any patches");
-    return patches;
-  }
-  function moveNodePatch(editor, operation, beforeValue) {
-    const patches = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
-    if (!targetBlock)
-      return patches;
-    if (operation.path.length === 1) {
-      const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
-      patches.push(unset([{
-        _key: block._key
-      }])), patches.push(insert([fromSlateValue([block], textBlockName)[0]], position, [{
-        _key: targetBlock._key
-      }]));
-    } else if (operation.path.length === 2 && editor.isTextBlock(block) && editor.isTextBlock(targetBlock)) {
-      const child = block.children[operation.path[1]], targetChild = targetBlock.children[operation.newPath[1]], position = operation.newPath[1] === targetBlock.children.length ? "after" : "before", childToInsert = fromSlateValue([block], textBlockName)[0].children[operation.path[1]];
-      patches.push(unset([{
-        _key: block._key
-      }, "children", {
-        _key: child._key
-      }])), patches.push(insert([childToInsert], position, [{
-        _key: targetBlock._key
-      }, "children", {
-        _key: targetChild._key
-      }]));
-    }
-    return patches;
-  }
+function createPlaceholderBlock(context) {
   return {
-    insertNodePatch,
-    insertTextPatch,
-    mergeNodePatch,
-    moveNodePatch,
-    removeNodePatch,
-    removeTextPatch,
-    setNodePatch,
-    splitNodePatch
+    _type: context.schema.block.name,
+    _key: context.keyGenerator(),
+    style: context.schema.styles[0].name ?? "normal",
+    markDefs: [],
+    children: [{
+      _type: context.schema.span.name,
+      _key: context.keyGenerator(),
+      text: "",
+      marks: []
+    }]
   };
 }
 const insertTextOperationImplementation = ({
@@ -4439,6 +4232,254 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
+function insertTextPatch(schema, children, operation, beforeValue) {
+  const block = isTextBlock({
+    schema
+  }, children[operation.path[0]]) && children[operation.path[0]];
+  if (!block)
+    throw new Error("Could not find block");
+  const textChild = isTextBlock({
+    schema
+  }, block) && isSpan({
+    schema
+  }, block.children[operation.path[1]]) && block.children[operation.path[1]];
+  if (!textChild)
+    throw new Error("Could not find child");
+  const path = [{
+    _key: block._key
+  }, "children", {
+    _key: textChild._key
+  }, "text"], prevBlock = beforeValue[operation.path[0]], prevChild = isTextBlock({
+    schema
+  }, prevBlock) && prevBlock.children[operation.path[1]], prevText = isSpan({
+    schema
+  }, prevChild) ? prevChild.text : "", patch = diffMatchPatch$1(prevText, textChild.text, path);
+  return patch.value.length ? [patch] : [];
+}
+function removeTextPatch(schema, children, operation, beforeValue) {
+  const block = children[operation.path[0]];
+  if (!block)
+    throw new Error("Could not find block");
+  const child = isTextBlock({
+    schema
+  }, block) && block.children[operation.path[1]] || void 0, textChild = isSpan({
+    schema
+  }, child) ? child : void 0;
+  if (child && !textChild)
+    throw new Error("Expected span");
+  if (!textChild)
+    throw new Error("Could not find child");
+  const path = [{
+    _key: block._key
+  }, "children", {
+    _key: textChild._key
+  }, "text"], beforeBlock = beforeValue[operation.path[0]], prevTextChild = isTextBlock({
+    schema
+  }, beforeBlock) && beforeBlock.children[operation.path[1]], prevText = isSpan({
+    schema
+  }, prevTextChild) && prevTextChild.text, patch = diffMatchPatch$1(prevText || "", textChild.text, path);
+  return patch.value ? [patch] : [];
+}
+function setNodePatch(schema, children, operation) {
+  if (operation.path.length === 1) {
+    const block = children[operation.path[0]];
+    if (typeof block._key != "string")
+      throw new Error("Expected block to have a _key");
+    const setNode = omitBy({
+      ...children[operation.path[0]],
+      ...operation.newProperties
+    }, isUndefined);
+    return [set(fromSlateValue([setNode], schema.block.name)[0], [{
+      _key: block._key
+    }])];
+  } else if (operation.path.length === 2) {
+    const block = children[operation.path[0]];
+    if (isTextBlock({
+      schema
+    }, block)) {
+      const child = block.children[operation.path[1]];
+      if (child) {
+        const blockKey = block._key, childKey = child._key, patches = [], keys = Object.keys(operation.newProperties);
+        return keys.forEach((keyName) => {
+          if (keys.length === 1 && keyName === "_key") {
+            const val = get(operation.newProperties, keyName);
+            patches.push(set(val, [{
+              _key: blockKey
+            }, "children", block.children.indexOf(child), keyName]));
+          } else {
+            const val = get(operation.newProperties, keyName);
+            patches.push(set(val, [{
+              _key: blockKey
+            }, "children", {
+              _key: childKey
+            }, keyName]));
+          }
+        }), patches;
+      }
+      throw new Error("Could not find a valid child");
+    }
+    throw new Error("Could not find a valid block");
+  } else
+    throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
+}
+function insertNodePatch(schema, children, operation, beforeValue) {
+  const block = beforeValue[operation.path[0]];
+  if (operation.path.length === 1) {
+    const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block?._key : beforeBlock?._key;
+    return targetKey ? [insert([fromSlateValue([operation.node], schema.block.name)[0]], position, [{
+      _key: targetKey
+    }])] : [setIfMissing(beforeValue, []), insert([fromSlateValue([operation.node], schema.block.name)[0]], "before", [operation.path[0]])];
+  } else if (isTextBlock({
+    schema
+  }, block) && operation.path.length === 2 && children[operation.path[0]]) {
+    const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = {
+      ...operation.node
+    };
+    !node._type && Text.isText(node) && (node._type = "span", node.marks = []);
+    const child = fromSlateValue([{
+      _key: "bogus",
+      _type: schema.block.name,
+      children: [node]
+    }], schema.block.name)[0].children[0];
+    return [insert([child], position, [{
+      _key: block._key
+    }, "children", block.children.length <= 1 || !block.children[operation.path[1] - 1] ? 0 : {
+      _key: block.children[operation.path[1] - 1]._key
+    }])];
+  }
+  return [];
+}
+function splitNodePatch(schema, children, operation, beforeValue) {
+  const patches = [], splitBlock = children[operation.path[0]];
+  if (!isTextBlock({
+    schema
+  }, splitBlock))
+    throw new Error(`Block with path ${JSON.stringify(operation.path[0])} is not a text block and can't be split`);
+  if (operation.path.length === 1) {
+    const oldBlock = beforeValue[operation.path[0]];
+    if (isTextBlock({
+      schema
+    }, oldBlock)) {
+      const targetValue = fromSlateValue([children[operation.path[0] + 1]], schema.block.name)[0];
+      targetValue && (patches.push(insert([targetValue], "after", [{
+        _key: splitBlock._key
+      }])), oldBlock.children.slice(operation.position).forEach((span) => {
+        const path = [{
+          _key: oldBlock._key
+        }, "children", {
+          _key: span._key
+        }];
+        patches.push(unset(path));
+      }));
+    }
+    return patches;
+  }
+  if (operation.path.length === 2) {
+    const splitSpan = splitBlock.children[operation.path[1]];
+    if (isSpan({
+      schema
+    }, splitSpan)) {
+      const targetSpans = fromSlateValue([{
+        ...splitBlock,
+        children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
+      }], schema.block.name)[0].children;
+      patches.push(insert(targetSpans, "after", [{
+        _key: splitBlock._key
+      }, "children", {
+        _key: splitSpan._key
+      }])), patches.push(set(splitSpan.text, [{
+        _key: splitBlock._key
+      }, "children", {
+        _key: splitSpan._key
+      }, "text"]));
+    }
+    return patches;
+  }
+  return patches;
+}
+function removeNodePatch(schema, beforeValue, operation) {
+  const block = beforeValue[operation.path[0]];
+  if (operation.path.length === 1) {
+    if (block && block._key)
+      return [unset([{
+        _key: block._key
+      }])];
+    throw new Error("Block not found");
+  } else if (isTextBlock({
+    schema
+  }, block) && operation.path.length === 2) {
+    const spanToRemove = block.children[operation.path[1]];
+    return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(`Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)), []) : [unset([{
+      _key: block._key
+    }, "children", {
+      _key: spanToRemove._key
+    }])] : [];
+  } else
+    return [];
+}
+function mergeNodePatch(schema, children, operation, beforeValue) {
+  const patches = [], block = beforeValue[operation.path[0]], updatedBlock = children[operation.path[0]];
+  if (operation.path.length === 1)
+    if (block?._key) {
+      const newBlock = fromSlateValue([children[operation.path[0] - 1]], schema.block.name)[0];
+      patches.push(set(newBlock, [{
+        _key: newBlock._key
+      }])), patches.push(unset([{
+        _key: block._key
+      }]));
+    } else
+      throw new Error("Target key not found!");
+  else if (isTextBlock({
+    schema
+  }, block) && isTextBlock({
+    schema
+  }, updatedBlock) && operation.path.length === 2) {
+    const updatedSpan = updatedBlock.children[operation.path[1] - 1] && isSpan({
+      schema
+    }, updatedBlock.children[operation.path[1] - 1]) ? updatedBlock.children[operation.path[1] - 1] : void 0, removedSpan = block.children[operation.path[1]] && isSpan({
+      schema
+    }, block.children[operation.path[1]]) ? block.children[operation.path[1]] : void 0;
+    updatedSpan && (block.children.filter((span) => span._key === updatedSpan._key).length === 1 ? patches.push(set(updatedSpan.text, [{
+      _key: block._key
+    }, "children", {
+      _key: updatedSpan._key
+    }, "text"])) : console.warn(`Multiple spans have \`_key\` ${updatedSpan._key}. It's ambiguous which one to update.`, JSON.stringify(block, null, 2))), removedSpan && (block.children.filter((span) => span._key === removedSpan._key).length === 1 ? patches.push(unset([{
+      _key: block._key
+    }, "children", {
+      _key: removedSpan._key
+    }])) : console.warn(`Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)));
+  }
+  return patches;
+}
+function moveNodePatch(schema, beforeValue, operation) {
+  const patches = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
+  if (!targetBlock)
+    return patches;
+  if (operation.path.length === 1) {
+    const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
+    patches.push(unset([{
+      _key: block._key
+    }])), patches.push(insert([fromSlateValue([block], schema.block.name)[0]], position, [{
+      _key: targetBlock._key
+    }]));
+  } else if (operation.path.length === 2 && isTextBlock({
+    schema
+  }, block) && isTextBlock({
+    schema
+  }, targetBlock)) {
+    const child = block.children[operation.path[1]], targetChild = targetBlock.children[operation.newPath[1]], position = operation.newPath[1] === targetBlock.children.length ? "after" : "before", childToInsert = fromSlateValue([block], schema.block.name)[0].children[operation.path[1]];
+    patches.push(unset([{
+      _key: block._key
+    }, "children", {
+      _key: child._key
+    }])), patches.push(insert([childToInsert], position, [{
+      _key: targetBlock._key
+    }, "children", {
+      _key: targetChild._key
+    }]));
+  }
+  return patches;
+}
 const PATCHING = /* @__PURE__ */ new WeakMap();
 function withoutPatching(editor, fn) {
   const prev = isPatching(editor);
@@ -4451,7 +4492,6 @@ const debug$e = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   relayActor,
-  patchFunctions,
   subscriptions
 }) {
   let previousChildren;
@@ -4506,28 +4546,28 @@ function createWithPatches({
         return editor;
       switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches.push(insert(previousChildren, "before", [0])), operation.type) {
         case "insert_text":
-          patches = [...patches, ...patchFunctions.insertTextPatch(editor, operation, previousChildren)];
+          patches = [...patches, ...insertTextPatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousChildren)];
           break;
         case "remove_text":
-          patches = [...patches, ...patchFunctions.removeTextPatch(editor, operation, previousChildren)];
+          patches = [...patches, ...removeTextPatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousChildren)];
           break;
         case "remove_node":
-          patches = [...patches, ...patchFunctions.removeNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...removeNodePatch(editorActor.getSnapshot().context.schema, previousChildren, operation)];
           break;
         case "split_node":
-          patches = [...patches, ...patchFunctions.splitNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...splitNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousChildren)];
           break;
         case "insert_node":
-          patches = [...patches, ...patchFunctions.insertNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...insertNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousChildren)];
           break;
         case "set_node":
-          patches = [...patches, ...patchFunctions.setNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...setNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation)];
           break;
         case "merge_node":
-          patches = [...patches, ...patchFunctions.mergeNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...mergeNodePatch(editorActor.getSnapshot().context.schema, editor.children, operation, previousChildren)];
           break;
         case "move_node":
-          patches = [...patches, ...patchFunctions.moveNodePatch(editor, operation, previousChildren)];
+          patches = [...patches, ...moveNodePatch(editorActor.getSnapshot().context.schema, previousChildren, operation)];
           break;
       }
       if (!editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], relayActor.send({
@@ -4719,16 +4759,298 @@ function createWithUtils({
     })[0], editor;
   };
 }
+function isEditorNode(node) {
+  return typeof node == "object" && node !== null ? !("_type" in node) && "children" in node && Array.isArray(node.children) : !1;
+}
+function isTextBlockNode(context, node) {
+  return isTypedObject(node) && node._type === context.schema.block.name;
+}
+function isSpanNode(context, node) {
+  return typeof node != "object" || node === null || "children" in node ? !1 : "_type" in node ? node._type === context.schema.span.name : "text" in node;
+}
+function isPartialSpanNode(node) {
+  return typeof node == "object" && node !== null && "text" in node && typeof node.text == "string";
+}
+function isObjectNode(context, node) {
+  return !isEditorNode(node) && !isTextBlockNode(context, node) && !isSpanNode(context, node) && !isPartialSpanNode(node);
+}
+function getBlock(root, path) {
+  const index = path.at(0);
+  if (!(index === void 0 || path.length !== 1))
+    return root.children.at(index);
+}
+function getNode(context, root, path) {
+  if (path.length === 0)
+    return root;
+  if (path.length === 1)
+    return getBlock(root, path);
+  if (path.length === 2) {
+    const block = getBlock(root, path.slice(0, 1));
+    return !block || !isTextBlockNode(context, block) ? void 0 : block.children.at(path[1]) || void 0;
+  }
+}
+function getSpan(context, root, path) {
+  const node = getNode(context, root, path);
+  if (node && isSpanNode(context, node))
+    return node;
+}
+function getParent(context, root, path) {
+  if (path.length === 0)
+    return;
+  const parentPath = path.slice(0, -1);
+  if (parentPath.length === 0)
+    return root;
+  const blockIndex = parentPath.at(0);
+  if (blockIndex === void 0 || parentPath.length !== 1)
+    return;
+  const block = root.children.at(blockIndex);
+  if (block && isTextBlockNode(context, block))
+    return block;
+}
+function applyOperationToPortableText(context, value, operation) {
+  const draft = createDraft({
+    children: value
+  });
+  try {
+    applyOperationToPortableTextDraft(context, draft, operation);
+  } catch (e) {
+    console.error(e);
+  }
+  return finishDraft(draft).children;
+}
+function applyOperationToPortableTextDraft(context, root, operation) {
+  switch (operation.type) {
+    case "insert_node": {
+      const {
+        path,
+        node: insertedNode
+      } = operation, parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!parent || index > parent.children.length)
+        break;
+      if (path.length === 1) {
+        if (isTextBlockNode(context, insertedNode)) {
+          parent.children.splice(index, 0, {
+            ...insertedNode,
+            children: insertedNode.children.map((child) => "__inline" in child ? {
+              _key: child._key,
+              _type: child._type,
+              ..."value" in child && typeof child.value == "object" ? child.value : {}
+            } : child)
+          });
+          break;
+        }
+        if (Element$1.isElement(insertedNode) && !("__inline" in insertedNode)) {
+          parent.children.splice(index, 0, {
+            _key: insertedNode._key,
+            _type: insertedNode._type,
+            ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
+          });
+          break;
+        }
+      }
+      if (path.length === 2) {
+        if (!isTextBlockNode(context, parent))
+          break;
+        if (isPartialSpanNode(insertedNode)) {
+          parent.children.splice(index, 0, insertedNode);
+          break;
+        }
+        if ("__inline" in insertedNode) {
+          parent.children.splice(index, 0, {
+            _key: insertedNode._key,
+            _type: insertedNode._type,
+            ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
+          });
+          break;
+        }
+      }
+      break;
+    }
+    case "insert_text": {
+      const {
+        path,
+        offset,
+        text
+      } = operation;
+      if (text.length === 0) break;
+      const span = getSpan(context, root, path);
+      if (!span)
+        break;
+      const before = span.text.slice(0, offset), after = span.text.slice(offset);
+      span.text = before + text + after;
+      break;
+    }
+    case "merge_node": {
+      const {
+        path
+      } = operation, node = getNode(context, root, path), prevPath = Path.previous(path), prev = getNode(context, root, prevPath), parent = getParent(context, root, path);
+      if (!node || !prev || !parent)
+        break;
+      const index = path[path.length - 1];
+      if (isPartialSpanNode(node) && isPartialSpanNode(prev))
+        prev.text += node.text;
+      else if (isTextBlockNode(context, node) && isTextBlockNode(context, prev))
+        prev.children.push(...node.children);
+      else
+        break;
+      parent.children.splice(index, 1);
+      break;
+    }
+    case "move_node": {
+      const {
+        path,
+        newPath
+      } = operation;
+      if (Path.isAncestor(path, newPath))
+        break;
+      const node = getNode(context, root, path), parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!node || !parent)
+        break;
+      parent.children.splice(index, 1);
+      const truePath = Path.transform(path, operation), newParent = getNode(context, root, Path.parent(truePath)), newIndex = truePath[truePath.length - 1];
+      if (!newParent || !("children" in newParent) || !Array.isArray(newParent.children))
+        break;
+      newParent.children.splice(newIndex, 0, node);
+      break;
+    }
+    case "remove_node": {
+      const {
+        path
+      } = operation, index = path[path.length - 1];
+      getParent(context, root, path)?.children.splice(index, 1);
+      break;
+    }
+    case "remove_text": {
+      const {
+        path,
+        offset,
+        text
+      } = operation;
+      if (text.length === 0)
+        break;
+      const span = getSpan(context, root, path);
+      if (!span)
+        break;
+      const before = span.text.slice(0, offset), after = span.text.slice(offset + text.length);
+      span.text = before + after;
+      break;
+    }
+    case "set_node": {
+      const {
+        path,
+        properties,
+        newProperties
+      } = operation, node = getNode(context, root, path);
+      if (!node || isEditorNode(node))
+        break;
+      if (isObjectNode(context, node)) {
+        const valueBefore = "value" in properties && typeof properties.value == "object" ? properties.value : {}, valueAfter = "value" in newProperties && typeof newProperties.value == "object" ? newProperties.value : {};
+        for (const key in newProperties) {
+          if (key === "value")
+            continue;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          key !== "value" && (newProperties.hasOwnProperty(key) || delete node[key]);
+        for (const key in valueAfter) {
+          const value = valueAfter[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in valueBefore)
+          valueAfter.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      if (isTextBlockNode(context, node)) {
+        for (const key in newProperties) {
+          if (key === "children" || key === "text")
+            break;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          newProperties.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      if (isPartialSpanNode(node)) {
+        for (const key in newProperties) {
+          if (key === "text")
+            break;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          newProperties.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      break;
+    }
+    case "split_node": {
+      const {
+        path,
+        position,
+        properties
+      } = operation;
+      if (path.length === 0)
+        break;
+      const parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!parent)
+        break;
+      if (isEditorNode(parent)) {
+        const block = getBlock(root, path);
+        if (!block || !isTextBlockNode(context, block))
+          break;
+        const before = block.children.slice(0, position), after = block.children.slice(position);
+        block.children = before;
+        const newTextBlockNode = {
+          ...properties,
+          children: after,
+          _type: context.schema.block.name
+        };
+        parent.children.splice(index + 1, 0, newTextBlockNode);
+        break;
+      }
+      if (isTextBlockNode(context, parent)) {
+        const node = getNode(context, root, path);
+        if (!node || !isSpanNode(context, node))
+          break;
+        const before = node.text.slice(0, position), after = node.text.slice(position);
+        node.text = before;
+        const newSpanNode = {
+          ...properties,
+          text: after
+        };
+        parent.children.splice(index + 1, 0, newSpanNode);
+      }
+      break;
+    }
+  }
+  return root;
+}
+function pluginUpdateValue(context, editor) {
+  const {
+    apply: apply2
+  } = editor;
+  return editor.apply = (operation) => {
+    if (operation.type === "set_selection") {
+      apply2(operation);
+      return;
+    }
+    editor.value = applyOperationToPortableText({
+      keyGenerator: context.keyGenerator,
+      schema: context.schema
+    }, editor.value, operation), apply2(operation);
+  }, editor;
+}
 const withPlugins = (editor, options) => {
   const e = editor, {
     editorActor,
     relayActor
-  } = options, operationToPatches = createOperationToPatches(editorActor), withObjectKeys = createWithObjectKeys(editorActor), withSchemaTypes = createWithSchemaTypes({
+  } = options, withObjectKeys = createWithObjectKeys(editorActor), withSchemaTypes = createWithSchemaTypes({
     editorActor
   }), withPatches = createWithPatches({
     editorActor,
     relayActor,
-    patchFunctions: operationToPatches,
     subscriptions: options.subscriptions
   }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
     editorActor,
@@ -4736,7 +5058,7 @@ const withPlugins = (editor, options) => {
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
     editorActor
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
-  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
+  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(pluginUpdateValue(editorActor.getSnapshot().context, e))))))))))));
 }, debug$a = debugWithName("setup");
 function createSlateEditor(config) {
   debug$a("Creating new Slate editor instance");
@@ -4745,10 +5067,10 @@ function createSlateEditor(config) {
     relayActor: config.relayActor,
     subscriptions: config.subscriptions
   });
-  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {});
-  const initialValue = [instance.pteCreateTextBlock({
-    decorators: []
-  })];
+  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {}), instance.value = [createPlaceholderBlock(config.editorActor.getSnapshot().context)];
+  const initialValue = toSlateValue(instance.value, {
+    schemaTypes: config.editorActor.getSnapshot().context.schema
+  });
   return {
     instance,
     initialValue
@@ -6540,34 +6862,6 @@ function sortByPriority(items) {
     result.includes(item) || result.push(item);
   return [...result, ...itemsWithoutPriority];
 }
-function slateChildrenToBlocks(schema, value) {
-  const blocks = new Array(value.length);
-  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
-    const descendant = value[blockIndex];
-    if (descendant._type !== schema.block.name) {
-      blocks[blockIndex] = {
-        _key: descendant._key,
-        _type: descendant._type,
-        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
-      };
-      continue;
-    }
-    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-      const child = children[childIndex];
-      processedChildren[childIndex] = child._type === schema.span.name ? child : {
-        _key: child._key,
-        _type: child._type,
-        ..."value" in child && typeof child.value == "object" ? child.value : {}
-      };
-    }
-    blocks[blockIndex] = {
-      ...descendant,
-      children: processedChildren
-    };
-  }
-  return blocks;
-}
 function getActiveDecorators({
   schema,
   slateEditorInstance
@@ -6586,7 +6880,7 @@ function createEditorSnapshot({
   hasTag,
   internalDrag
 }) {
-  const value = slateChildrenToBlocks(schema, editor.children), selection = editor.selection ? slateRangeToSelection({
+  const selection = editor.selection ? slateRangeToSelection({
     schema,
     editor,
     range: editor.selection
@@ -6602,7 +6896,7 @@ function createEditorSnapshot({
       readOnly,
       schema,
       selection,
-      value
+      value: editor.value
     },
     beta: {
       hasTag,
@@ -7318,7 +7612,7 @@ function getEditorSnapshot({
       }),
       schema: editorActorSnapshot.context.schema,
       selection: editorActorSnapshot.context.selection,
-      value: slateChildrenToBlocks(editorActorSnapshot.context.schema, slateEditorInstance.children)
+      value: slateEditorInstance.value
     },
     beta: {
       hasTag: (tag) => editorActorSnapshot.hasTag(tag),
@@ -7705,8 +7999,8 @@ function createEditableAPI(editor, editorActor) {
         }]
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
-      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode2 = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
+      return isSpanNode2 && focusNode._type !== types.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), Transforms.insertNodes(editor, child, {
@@ -8746,8 +9040,8 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
           debug$5("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
-          const isSpanNode = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
-          isSpanNode && isTextChanged ? (oldBlockChild.text.length > 0 && Transforms.delete(slateEditor, {
+          const isSpanNode2 = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
+          isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && Transforms.delete(slateEditor, {
             at: {
               focus: {
                 path,
@@ -8760,7 +9054,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode2 || (debug$5("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
@@ -9130,6 +9424,7 @@ class PortableTextEditor extends Component {
   /*
    * The editor API (currently implemented with Slate).
    */
+  subscriptions = [];
   unsubscribers = [];
   constructor(props) {
     if (super(props), props.editor)
@@ -9146,23 +9441,20 @@ class PortableTextEditor extends Component {
         readOnly: props.readOnly,
         schema: props.schemaType
       });
-      this.unsubscribers.push((() => {
-        const subscription = actors.relayActor.on("*", (event) => {
-          const change = eventToChange(event);
-          change && (props.onChange(change), this.change$.next(change));
-        });
-        return () => {
-          subscription.unsubscribe();
-        };
-      })());
-      for (const subscription of subscriptions)
-        this.unsubscribers.push(subscription());
-      this.actors = actors, this.editor = editor, this.schemaTypes = actors.editorActor.getSnapshot().context.getLegacySchema();
+      this.subscriptions = subscriptions, this.actors = actors, this.editor = editor, this.schemaTypes = actors.editorActor.getSnapshot().context.getLegacySchema();
     }
     this.editable = this.editor._internal.editable;
   }
   componentDidMount() {
-    this.actors && (this.actors.editorActor.start(), this.actors.mutationActor.start(), this.actors.relayActor.start(), this.actors.syncActor.start());
+    if (!this.actors)
+      return;
+    for (const subscription of this.subscriptions)
+      this.unsubscribers.push(subscription());
+    const relayActorSubscription = this.actors.relayActor.on("*", (event) => {
+      const change = eventToChange(event);
+      change && (this.props.editor || this.props.onChange(change), this.change$.next(change));
+    });
+    this.unsubscribers.push(relayActorSubscription.unsubscribe), this.actors.editorActor.start(), this.actors.mutationActor.start(), this.actors.relayActor.start(), this.actors.syncActor.start();
   }
   componentDidUpdate(prevProps) {
     !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && console.warn("Updating schema type is no longer supported"), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({