@portabletext/editor 1.22.0 → 1.24.0

package/lib/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var schema = require("@sanity/schema"), types = require("@sanity/types"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$k = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), xstate = require("xstate"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isSelectionCollapsed = require("./_chunks-cjs/selector.is-selection-collapsed.cjs"), util_isEmptyTextBlock = require("./_chunks-cjs/util.is-empty-text-block.cjs"), behavior_core = require("./_chunks-cjs/behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), blockTools = require("@portabletext/block-tools");
+var schema = require("@sanity/schema"), types = require("@sanity/types"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$j = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), xstate = require("xstate"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), util_sliceBlocks = require("./_chunks-cjs/util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isSelectionCollapsed = require("./_chunks-cjs/selector.is-selection-collapsed.cjs"), util_isEmptyTextBlock = require("./_chunks-cjs/util.is-empty-text-block.cjs"), behavior_core = require("./_chunks-cjs/behavior.core.cjs"), getRandomValues = require("get-random-values-esm");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$k), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
+var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$j), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
 function createEditorSchema(portableTextType) {
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
@@ -370,7 +370,7 @@ const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), IS_DRAGGING
   ] }), $[1] = props.value._key, $[2] = props.value._type, $[3] = t1) : t1 = $[3], t1;
 };
 DefaultObject.displayName = "DefaultObject";
-const debug$j = debugWithName("components:DraggableBlock"), DraggableBlock = (t0) => {
+const debug$i = debugWithName("components:DraggableBlock"), DraggableBlock = (t0) => {
   const $ = reactCompilerRuntime.c(51), {
     children,
     element,
@@ -408,39 +408,39 @@ const debug$j = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   $[16] !== editor || $[17] !== element ? (t9 = (event_0) => {
     const targetBlock = IS_DRAGGING_ELEMENT_TARGET.get(editor);
     if (targetBlock) {
-      IS_DRAGGING.set(editor, !1), event_0.preventDefault(), event_0.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$j("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
+      IS_DRAGGING.set(editor, !1), event_0.preventDefault(), event_0.stopPropagation(), IS_DRAGGING_ELEMENT_TARGET.delete(editor), dragGhostRef.current && (debug$i("Removing drag ghost"), document.body.removeChild(dragGhostRef.current));
       const dragPosition = IS_DRAGGING_BLOCK_TARGET_POSITION.get(editor);
       IS_DRAGGING_BLOCK_TARGET_POSITION.delete(editor);
       let targetPath = slateReact.ReactEditor.findPath(editor, targetBlock);
       const myPath = slateReact.ReactEditor.findPath(editor, element), isBefore = slate.Path.isBefore(myPath, targetPath);
       if (dragPosition === "bottom" && !isBefore) {
         if (targetPath[0] >= editor.children.length - 1) {
-          debug$j("target is already at the bottom, not moving");
+          debug$i("target is already at the bottom, not moving");
           return;
         }
         const originalPath = targetPath;
-        targetPath = slate.Path.next(targetPath), debug$j(`Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(targetPath)}`);
+        targetPath = slate.Path.next(targetPath), debug$i(`Adjusting targetPath from ${JSON.stringify(originalPath)} to ${JSON.stringify(targetPath)}`);
       }
       if (dragPosition === "top" && isBefore && targetPath[0] !== editor.children.length - 1) {
         const originalPath_0 = targetPath;
-        targetPath = slate.Path.previous(targetPath), debug$j(`Adjusting targetPath from ${JSON.stringify(originalPath_0)} to ${JSON.stringify(targetPath)}`);
+        targetPath = slate.Path.previous(targetPath), debug$i(`Adjusting targetPath from ${JSON.stringify(originalPath_0)} to ${JSON.stringify(targetPath)}`);
       }
       if (slate.Path.equals(targetPath, myPath)) {
-        event_0.preventDefault(), debug$j("targetPath and myPath is the same, not moving");
+        event_0.preventDefault(), debug$i("targetPath and myPath is the same, not moving");
         return;
       }
-      debug$j(`Moving element ${element._key} from path ${JSON.stringify(myPath)} to ${JSON.stringify(targetPath)} (${dragPosition})`), slate.Transforms.moveNodes(editor, {
+      debug$i(`Moving element ${element._key} from path ${JSON.stringify(myPath)} to ${JSON.stringify(targetPath)} (${dragPosition})`), slate.Transforms.moveNodes(editor, {
         at: myPath,
         to: targetPath
       }), editor.onChange();
       return;
     }
-    debug$j("No target element, not doing anything");
+    debug$i("No target element, not doing anything");
   }, $[16] = editor, $[17] = element, $[18] = t9) : t9 = $[18];
   const handleDragEnd = t9;
   let t10;
   $[19] !== editor || $[20] !== element ? (t10 = (event_1) => {
-    IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$j("On drop (prevented)", element), event_1.preventDefault(), event_1.stopPropagation(), setIsDragOver(!1));
+    IS_DRAGGING_BLOCK_ELEMENT.get(editor) && (debug$i("On drop (prevented)", element), event_1.preventDefault(), event_1.stopPropagation(), setIsDragOver(!1));
   }, $[19] = editor, $[20] = element, $[21] = t10) : t10 = $[21];
   const handleDrop = t10;
   let t11;
@@ -457,10 +457,10 @@ const debug$j = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   let t12;
   $[26] !== blockElement || $[27] !== editor || $[28] !== handleDrag || $[29] !== isInline || $[30] !== isVoid ? (t12 = (event_3) => {
     if (!isVoid || isInline) {
-      debug$j("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
+      debug$i("Not dragging block"), IS_DRAGGING_BLOCK_ELEMENT.delete(editor), IS_DRAGGING.set(editor, !1);
       return;
     }
-    if (debug$j("Drag start"), IS_DRAGGING.set(editor, !0), event_3.dataTransfer && (event_3.dataTransfer.setData("application/portable-text", "something"), event_3.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
+    if (debug$i("Drag start"), IS_DRAGGING.set(editor, !0), event_3.dataTransfer && (event_3.dataTransfer.setData("application/portable-text", "something"), event_3.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
       let dragGhost = blockElement.cloneNode(!0);
       const customGhost = dragGhost.querySelector("[data-pt-drag-ghost-element]");
       if (customGhost && (dragGhost = customGhost), dragGhost.setAttribute("data-dragged", ""), document.body) {
@@ -1497,14 +1497,14 @@ function getAlphabetFromPattern(pattern) {
   for (let i = 0; i < pattern.length; i++) s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
   return s;
 }
-function match(text, pattern, searchLocation) {
+function match(text, pattern, searchLocation, options = {}) {
   if (text === null || pattern === null || searchLocation === null) throw new Error("Null input. (match())");
   const loc = Math.max(0, Math.min(searchLocation, text.length));
   if (text === pattern) return 0;
   if (text.length) {
     if (text.substring(loc, loc + pattern.length) === pattern) return loc;
   } else return -1;
-  return bitap(text, pattern, loc);
+  return bitap(text, pattern, loc, options);
 }
 function diffText1(diffs) {
   const text = [];
@@ -1536,10 +1536,10 @@ function levenshtein(diffs) {
   }
   return leven += Math.max(insertions, deletions), leven;
 }
-function xIndex(diffs, loc) {
+function xIndex(diffs, location) {
   let chars1 = 0, chars2 = 0, lastChars1 = 0, lastChars2 = 0, x;
-  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > loc)); x++) lastChars1 = chars1, lastChars2 = chars2;
-  return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (loc - lastChars1);
+  for (x = 0; x < diffs.length && (diffs[x][0] !== DIFF_INSERT && (chars1 += diffs[x][1].length), diffs[x][0] !== DIFF_DELETE && (chars2 += diffs[x][1].length), !(chars1 > location)); x++) lastChars1 = chars1, lastChars2 = chars2;
+  return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (location - lastChars1);
 }
 function countUtf8Bytes(str) {
   let bytes = 0;
@@ -1732,7 +1732,7 @@ function isRedoing(editor) {
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
-const debug$i = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
+const debug$h = 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) || []);
@@ -1745,7 +1745,7 @@ function createWithUndoRedo(options) {
     let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
     const remotePatches = getRemotePatches(editor);
     options.subscriptions.push(() => {
-      debug$i("Subscribing to patches");
+      debug$h("Subscribing to patches");
       const sub = editorActor.on("patches", ({
         patches: patches2,
         snapshot
@@ -1754,7 +1754,7 @@ function createWithUndoRedo(options) {
         patches2.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$i("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+              debug$h("Someone else cleared the content, resetting undo/redo history"), editor.history = {
                 undos: [],
                 redos: []
               }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -1770,7 +1770,7 @@ function createWithUndoRedo(options) {
         }), previousSnapshot = snapshot;
       });
       return () => {
-        debug$i("Unsubscribing to patches"), sub.unsubscribe();
+        debug$h("Unsubscribing to patches"), sub.unsubscribe();
       };
     }), editor.history = {
       undos: [],
@@ -1809,7 +1809,7 @@ function createWithUndoRedo(options) {
             operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
             timestamp: /* @__PURE__ */ new Date()
           };
-          undos.push(newStep), debug$i("Created new undo step", step);
+          undos.push(newStep), debug$h("Created new undo step", step);
         }
         for (; undos.length > UNDO_STEP_LIMIT; )
           undos.shift();
@@ -1826,7 +1826,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (undos.length > 0) {
         const step = undos[undos.length - 1];
-        if (debug$i("Undoing", step), step.operations.length > 0) {
+        if (debug$h("Undoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -1844,7 +1844,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$i("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+            debug$h("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
@@ -1863,7 +1863,7 @@ function createWithUndoRedo(options) {
       } = editor.history;
       if (redos.length > 0) {
         const step = redos[redos.length - 1];
-        if (debug$i("Redoing", step), step.operations.length > 0) {
+        if (debug$h("Redoing", step), step.operations.length > 0) {
           const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
@@ -1880,7 +1880,7 @@ function createWithUndoRedo(options) {
               });
             }), editor.normalize(), editor.onChange();
           } catch (err) {
-            debug$i("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
+            debug$h("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), slate.Transforms.deselect(editor), editor.history = {
               undos: [],
               redos: []
             }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
@@ -1900,16 +1900,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual__default.default({
       _key: blk._key
     }, patch.path[0]));
-    return debug$i(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$h(`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$i("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$h("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$i(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$h(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual__default.default({
@@ -2189,7 +2189,7 @@ const syncValueCallback = ({
       }
     }
   }
-}), debug$h = debugWithName("hook:useSyncValue");
+}), debug$g = debugWithName("hook:useSyncValue");
 async function updateValue({
   context,
   sendBack,
@@ -2199,7 +2199,7 @@ async function updateValue({
 }) {
   let isChanged = !1, isValid = !0;
   const hadSelection = !!slateEditor.selection;
-  if ((!value || value.length === 0) && (debug$h("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
+  if ((!value || value.length === 0) && (debug$g("Value is empty"), slate.Editor.withoutNormalizing(slateEditor, () => {
     withoutSaving(slateEditor, () => {
       withoutPatching(slateEditor, () => {
         hadSelection && slate.Transforms.deselect(slateEditor);
@@ -2255,14 +2255,14 @@ async function updateValue({
     });
   }
   if (!isValid) {
-    debug$h("Invalid value, returning"), sendBack({
+    debug$g("Invalid value, returning"), sendBack({
       type: "done syncing",
       value
     });
     return;
   }
   if (isChanged) {
-    debug$h("Server value changed, syncing editor");
+    debug$g("Server value changed, syncing editor");
     try {
       slateEditor.onChange();
     } catch (err) {
@@ -2290,7 +2290,7 @@ async function updateValue({
       value
     });
   } else
-    debug$h("Server value and editor value is equal, no need to sync.");
+    debug$g("Server value and editor value is equal, no need to sync.");
   sendBack({
     type: "done syncing",
     value
@@ -2324,7 +2324,7 @@ function syncBlock({
               type: "patch",
               patch
             });
-          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$h.enabled && debug$h("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$h.enabled && debug$h("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+          })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$g.enabled && debug$g("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$g.enabled && debug$g("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2332,9 +2332,9 @@ function syncBlock({
         }
         if (!oldBlock && blockValid) {
           const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-          debug$h.enabled && debug$h("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
+          debug$g.enabled && debug$g("Validating and inserting new block in the end of the value", currentBlock), validation.valid || validation.resolution?.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
             at: [currentBlockIndex]
-          }) : (debug$h("Invalid", validation), sendBack({
+          }) : (debug$g("Invalid", validation), sendBack({
             type: "invalid value",
             resolution: validation.resolution,
             value
@@ -2362,14 +2362,14 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     const oldBlockChildrenLength = oldBlock.children.length;
     currentBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - currentBlock.children.length)).forEach((_, index) => {
       const childIndex = oldBlockChildrenLength - 1 - index;
-      childIndex > 0 && (debug$h("Removing child"), slate.Transforms.removeNodes(slateEditor, {
+      childIndex > 0 && (debug$g("Removing child"), slate.Transforms.removeNodes(slateEditor, {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
       const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual__default.default(currentBlockChild, oldBlockChild), isTextChanged = !isEqual__default.default(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key) {
-          debug$h("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
+          debug$g("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
           const isSpanNode = slate.Text.isText(currentBlockChild) && currentBlockChild._type === "span" && slate.Text.isText(oldBlockChild) && oldBlockChild._type === "span";
@@ -2386,23 +2386,23 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), slate.Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$h("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode || (debug$g("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
             voids: !0
           }));
-        } else oldBlockChild ? (debug$h("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
+        } else oldBlockChild ? (debug$g("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$h("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+        }), slateEditor.onChange()) : oldBlockChild || (debug$g("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
           at: [currentBlockIndex, currentBlockChildIndex]
         }), slateEditor.onChange());
     });
   }
 }
-const debug$g = debugWithName("component:PortableTextEditor:Synchronizer");
+const debug$f = debugWithName("component:PortableTextEditor:Synchronizer");
 function Synchronizer(props) {
   const $ = reactCompilerRuntime.c(40), {
     editorActor,
@@ -2473,19 +2473,19 @@ function Synchronizer(props) {
   }, t12 = [syncActorRef, readOnly], $[25] = readOnly, $[26] = syncActorRef, $[27] = t11, $[28] = t12) : (t11 = $[27], t12 = $[28]), React.useEffect(t11, t12);
   let t13, t14;
   $[29] !== syncActorRef || $[30] !== value ? (t13 = () => {
-    debug$g("Value from props changed, syncing new value"), syncActorRef.send({
+    debug$f("Value from props changed, syncing new value"), syncActorRef.send({
       type: "update value",
       value
     });
   }, t14 = [syncActorRef, value], $[29] = syncActorRef, $[30] = value, $[31] = t13, $[32] = t14) : (t13 = $[31], t14 = $[32]), React.useEffect(t13, t14);
   let t15;
   $[33] !== editorActor || $[34] !== mutationActorRef ? (t15 = () => {
-    debug$g("Subscribing to patch events");
+    debug$f("Subscribing to patch events");
     const sub = editorActor.on("patch", (event_1) => {
       mutationActorRef.send(event_1);
     });
     return () => {
-      debug$g("Unsubscribing to patch events"), sub.unsubscribe();
+      debug$f("Unsubscribing to patch events"), sub.unsubscribe();
     };
   }, $[33] = editorActor, $[34] = mutationActorRef, $[35] = t15) : t15 = $[35];
   let t16;
@@ -2500,11 +2500,255 @@ function _temp(s) {
   return s.context.value;
 }
 Synchronizer.displayName = "Synchronizer";
-const debug$f = debugWithName("operationToPatches");
+const converterJson = {
+  serialize: ({
+    context,
+    event
+  }) => {
+    const portableTextConverter = context.converters.find((converter) => converter.mimeType === "application/x-portable-text");
+    return portableTextConverter ? {
+      ...portableTextConverter.serialize({
+        context,
+        event
+      }),
+      mimeType: "application/json",
+      originEvent: event.originEvent
+    } : {
+      type: "serialization.failure",
+      mimeType: "application/json",
+      originEvent: event.originEvent,
+      reason: "No application/x-portable-text Converter found"
+    };
+  },
+  deserialize: ({
+    context,
+    event
+  }) => {
+    const portableTextConverter = context.converters.find((converter) => converter.mimeType === "application/x-portable-text");
+    return portableTextConverter ? {
+      ...portableTextConverter.deserialize({
+        context,
+        event
+      }),
+      mimeType: "application/json"
+    } : {
+      type: "deserialization.failure",
+      mimeType: "application/json",
+      reason: "No application/x-portable-text Converter found"
+    };
+  },
+  mimeType: "application/json"
+};
+function isTypedObject(object) {
+  return isRecord(object) && typeof object._type == "string";
+}
+function isRecord(value) {
+  return !!value && (typeof value == "object" || typeof value == "function");
+}
+function parseBlock({
+  context,
+  block
+}) {
+  if (!isTypedObject(block) || block._type !== context.schema.block.name && !context.schema.blockObjects.some((blockObject) => blockObject.name === block._type))
+    return;
+  if (!types.isPortableTextTextBlock(block))
+    return {
+      ...block,
+      _key: context.keyGenerator()
+    };
+  const markDefKeyMap = /* @__PURE__ */ new Map(), markDefs = (block.markDefs ?? []).flatMap((markDef) => {
+    if (context.schema.annotations.some((annotation) => annotation.name === markDef._type)) {
+      const _key = context.keyGenerator();
+      return markDefKeyMap.set(markDef._key, _key), [{
+        ...markDef,
+        _key
+      }];
+    }
+    return [];
+  }), children = block.children.flatMap((child) => {
+    if (!isTypedObject(child))
+      return [];
+    if (child._type !== context.schema.span.name && !context.schema.inlineObjects.some((inlineObject) => inlineObject.name === child._type))
+      return [];
+    if (!types.isPortableTextSpan(child))
+      return [{
+        ...child,
+        _key: context.keyGenerator()
+      }];
+    const marks = (child.marks ?? []).flatMap((mark) => markDefKeyMap.has(mark) ? [markDefKeyMap.get(mark)] : context.schema.decorators.some((decorator) => decorator.value === mark) ? [mark] : []);
+    return [{
+      ...child,
+      _key: context.keyGenerator(),
+      marks
+    }];
+  }), parsedBlock = {
+    ...block,
+    _key: context.keyGenerator(),
+    children: children.length > 0 ? children : [{
+      _key: context.keyGenerator(),
+      _type: context.schema.span.name,
+      text: "",
+      marks: []
+    }],
+    markDefs
+  };
+  if (!context.schema.styles.find((style) => style.value === block.style)) {
+    const defaultStyle = context.schema.styles[0].value;
+    defaultStyle !== void 0 ? parsedBlock.style = defaultStyle : delete parsedBlock.style;
+  }
+  return context.schema.lists.find((list) => list.value === block.listItem) || (delete parsedBlock.listItem, delete parsedBlock.level), parsedBlock;
+}
+const converterPortableText = {
+  serialize: ({
+    context,
+    event
+  }) => {
+    if (!context.selection)
+      return {
+        type: "serialization.failure",
+        mimeType: "application/x-portable-text",
+        originEvent: event.originEvent,
+        reason: "No selection"
+      };
+    const blocks = util_sliceBlocks.sliceBlocks({
+      blocks: context.value,
+      selection: context.selection
+    });
+    return {
+      type: "serialization.success",
+      data: JSON.stringify(blocks),
+      mimeType: "application/x-portable-text",
+      originEvent: event.originEvent
+    };
+  },
+  deserialize: ({
+    context,
+    event
+  }) => {
+    const blocks = JSON.parse(event.data);
+    if (!Array.isArray(blocks))
+      return {
+        type: "deserialization.failure",
+        mimeType: "application/x-portable-text",
+        reason: "Data is not an array"
+      };
+    const parsedBlocks = blocks.flatMap((block) => {
+      const parsedBlock = parseBlock({
+        context,
+        block
+      });
+      return parsedBlock ? [parsedBlock] : [];
+    });
+    return parsedBlocks.length === 0 && blocks.length > 0 ? {
+      type: "deserialization.failure",
+      mimeType: "application/x-portable-text",
+      reason: "No blocks were parsed"
+    } : {
+      type: "deserialization.success",
+      data: parsedBlocks,
+      mimeType: "application/x-portable-text"
+    };
+  },
+  mimeType: "application/x-portable-text"
+}, converterTextHtml = {
+  serialize: ({
+    context,
+    event
+  }) => {
+    if (!context.selection)
+      return {
+        type: "serialization.failure",
+        mimeType: "text/html",
+        originEvent: event.originEvent,
+        reason: "No selection"
+      };
+    const blocks = util_sliceBlocks.sliceBlocks({
+      blocks: context.value,
+      selection: context.selection
+    }), html = toHtml.toHTML(blocks, {
+      onMissingComponent: !1,
+      components: {
+        unknownType: ({
+          children
+        }) => children !== void 0 ? `${children}` : ""
+      }
+    });
+    return html === "" ? {
+      type: "serialization.failure",
+      mimeType: "text/html",
+      originEvent: event.originEvent,
+      reason: "Serialized HTML is empty"
+    } : {
+      type: "serialization.success",
+      data: html,
+      mimeType: "text/html",
+      originEvent: event.originEvent
+    };
+  },
+  deserialize: ({
+    context,
+    event
+  }) => ({
+    type: "deserialization.success",
+    data: blockTools.htmlToBlocks(event.data, context.schema.portableText, {
+      keyGenerator: context.keyGenerator,
+      unstable_whitespaceOnPasteMode: context.schema.block.options.unstable_whitespaceOnPasteMode
+    }),
+    mimeType: "text/html"
+  }),
+  mimeType: "text/html"
+}, converterTextPlain = {
+  mimeType: "text/plain",
+  serialize: ({
+    context,
+    event
+  }) => context.selection ? {
+    type: "serialization.success",
+    data: util_sliceBlocks.sliceBlocks({
+      blocks: context.value,
+      selection: context.selection
+    }).map((block) => types.isPortableTextTextBlock(block) ? block.children.map((child) => child._type === context.schema.span.name ? child.text : `[${context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]`).join("") : `[${context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]`).join(`
+
+`),
+    mimeType: "text/plain",
+    originEvent: event.originEvent
+  } : {
+    type: "serialization.failure",
+    mimeType: "text/plain",
+    originEvent: event.originEvent,
+    reason: "No selection"
+  },
+  deserialize: ({
+    context,
+    event
+  }) => {
+    const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`;
+    return {
+      type: "deserialization.success",
+      data: blockTools.htmlToBlocks(textToHtml, context.schema.portableText, {
+        keyGenerator: context.keyGenerator
+      }),
+      mimeType: "text/plain"
+    };
+  }
+}, entityMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;",
+  "/": "&#x2F;",
+  "`": "&#x60;",
+  "=": "&#x3D;"
+};
+function escapeHtml(str) {
+  return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
+}
+const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain], debug$e = debugWithName("operationToPatches");
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$f.enabled && debug$f("Operation", JSON.stringify(operation, null, 2));
+    debug$e.enabled && debug$e("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");
@@ -2597,7 +2841,7 @@ function createOperationToPatches(types2) {
         _key: block.children[operation.path[1] - 1]._key
       }])];
     }
-    return debug$f("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$e("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], splitBlock = editor.children[operation.path[0]];
@@ -2655,9 +2899,9 @@ function createOperationToPatches(types2) {
         _key: block._key
       }, "children", {
         _key: spanToRemove._key
-      }])] : (debug$f("Span not found in editor trying to remove node"), []);
+      }])] : (debug$e("Span not found in editor trying to remove node"), []);
     } else
-      return debug$f("Not creating patch inside object block"), [];
+      return debug$e("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -2683,7 +2927,7 @@ function createOperationToPatches(types2) {
         _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$f("Void nodes can't be merged, not creating any patches");
+      debug$e("Void nodes can't be merged, not creating any patches");
     return patches$1;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -2864,9 +3108,11 @@ function createWithEventListeners(editorActor, subscriptions) {
       deleteBackward,
       deleteForward,
       insertBreak,
+      insertData,
       insertSoftBreak,
       insertText,
-      select
+      select,
+      setFragmentData
     } = editor;
     return editor.deleteBackward = (unit) => {
       if (isApplyingBehaviorActions(editor)) {
@@ -2906,6 +3152,19 @@ function createWithEventListeners(editorActor, subscriptions) {
         },
         editor
       });
+    }, editor.insertData = (dataTransfer) => {
+      if (isApplyingBehaviorActions(editor)) {
+        insertData(dataTransfer);
+        return;
+      }
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "deserialize",
+          dataTransfer
+        },
+        editor
+      });
     }, editor.insertSoftBreak = () => {
       if (isApplyingBehaviorActions(editor)) {
         insertSoftBreak();
@@ -2952,6 +3211,24 @@ function createWithEventListeners(editorActor, subscriptions) {
           select(location);
         }
       });
+    }, editor.setFragmentData = (dataTransfer, originEvent) => {
+      if (originEvent === "drag") {
+        setFragmentData(dataTransfer);
+        return;
+      }
+      if (isApplyingBehaviorActions(editor)) {
+        setFragmentData(dataTransfer);
+        return;
+      }
+      dataTransfer.clearData(), editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "serialize",
+          dataTransfer,
+          originEvent: originEvent ?? "unknown"
+        },
+        editor
+      });
     }, editor;
   };
 }
@@ -3049,13 +3326,13 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-const debug$e = debugWithName("applyPatches"), debugVerbose = debug$e.enabled && !0;
+const debug$d = debugWithName("applyPatches"), debugVerbose = debug$d.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose && (debug$e(`
+    debugVerbose && (debug$d(`
 
-NEW PATCH =============================================================`), debug$e(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$d(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -3071,7 +3348,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$e("Unhandled patch", patch.type);
+          debug$d("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -3086,9 +3363,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$e("Block not found"), !1;
+    return debug$d("Block not found"), !1;
   if (!child || !childPath)
-    return debug$e("Child not found"), !1;
+    return debug$d("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, {
@@ -3118,9 +3395,9 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$e("Block not found"), !1;
+    return debug$d("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$e("Ignoring patch targeting void value"), !1;
+    return debug$d("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -3128,7 +3405,7 @@ function insertPatch(editor, patch, schemaTypes) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$e(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$d(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -3137,14 +3414,14 @@ function insertPatch(editor, patch, schemaTypes) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$e("Child not found"), !1;
+    return debug$d("Child not found"), !1;
   const childrenToInsert = targetBlock && toSlateValue([{
     ...targetBlock,
     children: items
   }], {
     schemaTypes
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$e(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$d(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -3158,14 +3435,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$e("Block not found"), !1;
+    return debug$d("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$e("Ignoring setting void value"), !1;
+    return debug$d("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$e("Setting text property"), editor.apply({
+      value.text !== newText && (debug$d("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -3177,7 +3454,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$e("Setting non-text property"), editor.apply({
+      debug$d("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -3185,7 +3462,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$e("Setting block property");
+    debug$d("Setting block property");
     const {
       children,
       ...nextRest
@@ -3202,7 +3479,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$e("Setting children"), block.children.forEach((c, cIndex) => {
+    }), debug$d("Setting children"), block.children.forEach((c, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -3228,7 +3505,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$e("Removing everything"), debugState(editor, "before");
+    debug$d("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       slate.Transforms.removeNodes(editor, {
@@ -3255,13 +3532,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$e("Block not found"), !1;
+      return debug$d("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$e(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
+    return debug$d(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
       at: [blockIndex]
     }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$e("Child not found"), !1) : (debug$e(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$e(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$d("Child not found"), !1) : (debug$d(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose && debug$d(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -3269,7 +3546,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose && (debug$e(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$e(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose && (debug$d(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$d(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -3311,7 +3588,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$d = debugWithName("plugin:withPatches");
+const debug$c = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -3337,7 +3614,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               patches2.forEach((patch) => {
-                debug$d.enabled && debug$d(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                debug$c.enabled && debug$c(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -3350,10 +3627,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$d("Subscribing to remote patches");
+      debug$c("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$d("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$c("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       let patches$1 = [];
@@ -3404,7 +3681,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$c = debugWithName("plugin:withPlaceholderBlock");
+const debug$b = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -3429,7 +3706,7 @@ function createWithPlaceholderBlock(editorActor) {
         const node = op.node;
         if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
           const nextPath = slate.Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$c("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+          editor.children[nextPath[0]] || (debug$b("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
             decorators: []
           })));
         }
@@ -3438,7 +3715,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$b = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$a = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor, types2) {
   const defaultStyle = types2.styles[0].value;
   return function(editor) {
@@ -3451,7 +3728,7 @@ function createWithPortableTextBlockStyle(editorActor, types2) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$b(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$a(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               style: defaultStyle
@@ -3511,7 +3788,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$a = debugWithName("plugin:withPortableTextMarkModel");
+const debug$9 = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types2) {
   return function(editor) {
     const {
@@ -3525,7 +3802,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         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$a("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$9("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],
@@ -3538,7 +3815,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$a("Adding .markDefs to block node"), editorActor.send({
+        debug$9("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           markDefs: []
@@ -3550,7 +3827,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$a("Adding .marks to span node"), editorActor.send({
+        debug$9("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           marks: []
@@ -3564,7 +3841,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
       if (editor.isTextSpan(node)) {
         const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$a("Removing annotations from empty span node"), editorActor.send({
+          debug$9("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -3582,7 +3859,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
           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$a("Removing orphaned annotations from span node"), editorActor.send({
+              debug$9("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), slate.Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3600,7 +3877,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         if (editor.isTextBlock(block)) {
           const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$a("Removing orphaned annotations from span node"), editorActor.send({
+            debug$9("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -3618,7 +3895,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$a("Removing duplicate markDefs"), editorActor.send({
+          debug$9("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3633,7 +3910,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
       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$a("Removing markDef not in use"), editorActor.send({
+          debug$9("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -3850,7 +4127,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         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$a("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
+          debug$9("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -4050,7 +4327,7 @@ function createWithPortableTextSelections(editorActor, types2) {
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withSchemaTypes");
+const debug$8 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
   schemaTypes
@@ -4063,7 +4340,7 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$9("Setting span type on text node without a type");
+        debug$8("Setting span type on text node without a type");
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4079,7 +4356,7 @@ function createWithSchemaTypes({
         return;
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$9("Setting missing key on child node without a key");
+        debug$8("Setting missing key on child node without a key");
         const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4096,7 +4373,7 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
-const debug$8 = debugWithName("plugin:withUtils");
+const debug$7 = debugWithName("plugin:withUtils");
 function createWithUtils({
   editorActor,
   schemaTypes
@@ -4111,14 +4388,14 @@ function createWithUtils({
           depth: 2
         });
         if (!textNode || !slate.Text.isText(textNode) || textNode.text.length === 0) {
-          debug$8("pteExpandToWord: Can't expand to word here");
+          debug$7("pteExpandToWord: Can't expand to word here");
           return;
         }
         const {
           focus
         } = selection, focusOffset = focus.offset, charsBefore = textNode.text.slice(0, focusOffset), charsAfter = textNode.text.slice(focusOffset, -1), isEmpty = (str) => str.match(/\s/g), whiteSpaceBeforeIndex = charsBefore.split("").reverse().findIndex((str) => isEmpty(str)), newStartOffset = whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0, whiteSpaceAfterIndex = charsAfter.split("").findIndex((obj) => isEmpty(obj)), newEndOffset = charsBefore.length + (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1);
         if (!(newStartOffset === newEndOffset || Number.isNaN(newStartOffset) || Number.isNaN(newEndOffset))) {
-          debug$8("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
+          debug$7("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
             anchor: {
               ...selection.anchor,
               offset: newStartOffset
@@ -4130,7 +4407,7 @@ function createWithUtils({
           });
           return;
         }
-        debug$8("pteExpandToWord: Can't expand to word here");
+        debug$7("pteExpandToWord: Can't expand to word here");
       }
     }, editor.pteCreateTextBlock = (options) => toSlateValue([{
       _type: schemaTypes.block.name,
@@ -4176,12 +4453,12 @@ const withPlugins = (editor, options) => {
     schemaTypes
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
   return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
-}, debug$7 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
+}, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
 function createSlateEditor(config) {
   const existingSlateEditor = slateEditors.get(config.editorActor);
   if (existingSlateEditor)
-    return debug$7("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
-  debug$7("Creating new Slate editor instance", config.editorActor.id);
+    return debug$6("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
+  debug$6("Creating new Slate editor instance", config.editorActor.id);
   const unsubscriptions = [], subscriptions = [], instance = withPlugins(slateReact.withReact(slate.createEditor()), {
     editorActor: config.editorActor,
     subscriptions
@@ -4326,7 +4603,7 @@ function isStyleActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
 }
-const debug$6 = debugWithName("API:editable");
+const debug$5 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -4445,7 +4722,7 @@ function createEditableAPI(editor, editorActor) {
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types2.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types2.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      return isSpanNode && focusNode._type !== types2.span.name && (debug$5("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), slate.Transforms.insertNodes(editor, child, {
@@ -4583,18 +4860,18 @@ function createEditableAPI(editor, editorActor) {
           throw new Error("Invalid range");
         if (range) {
           if (!options?.mode || options?.mode === "selected") {
-            debug$6("Deleting content in selection"), slate.Transforms.delete(editor, {
+            debug$5("Deleting content in selection"), slate.Transforms.delete(editor, {
               at: range,
               hanging: !0,
               voids: !0
             }), editor.onChange();
             return;
           }
-          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
+          options?.mode === "blocks" && (debug$5("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && slate.Element.isElement(node)
-          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
+          })), options?.mode === "children" && (debug$5("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types2.span.name || // Text children
@@ -4728,7 +5005,7 @@ const addAnnotationActionImplementation = ({
   action
 }) => {
   const editor = action.editor;
-  if (debug$6("Removing annotation", action.annotation.name), !!editor.selection)
+  if (debug$5("Removing annotation", action.annotation.name), !!editor.selection)
     if (slate.Range.isCollapsed(editor.selection)) {
       const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
         depth: 1
@@ -4859,7 +5136,11 @@ function insertBlock({
     });
   }
 }
-const insertBlockObjectActionImplementation = ({
+const dataTransferSetActionImplementation = ({
+  action
+}) => {
+  action.dataTransfer.setData(action.mimeType, action.data);
+}, insertBlockObjectActionImplementation = ({
   context,
   action
 }) => {
@@ -4876,6 +5157,35 @@ const insertBlockObjectActionImplementation = ({
     editor: action.editor,
     schema: context.schema
   });
+}, insertBlocksActionImplementation = ({
+  context,
+  action
+}) => {
+  const fragment = toSlateValue(action.blocks, {
+    schemaTypes: context.schema
+  });
+  if (!action.editor.selection)
+    return;
+  const [focusBlock, focusPath] = slate.Editor.node(action.editor, action.editor.selection, {
+    depth: 1
+  });
+  if (action.editor.isTextBlock(focusBlock) && action.editor.isTextBlock(fragment[0])) {
+    const {
+      markDefs
+    } = focusBlock;
+    isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(action.editor, {
+      markDefs: uniq__default.default([...fragment[0].markDefs || [], ...markDefs || []])
+    }, {
+      at: focusPath,
+      mode: "lowest",
+      voids: !1
+    });
+  }
+  isEqualToEmptyEditor(action.editor.children, context.schema) ? (slate.Transforms.splitNodes(action.editor, {
+    at: [0, 0]
+  }), action.editor.insertFragment(fragment), slate.Transforms.removeNodes(action.editor, {
+    at: [0]
+  })) : action.editor.insertFragment(fragment);
 }, insertBreakActionImplementation = ({
   context,
   action
@@ -5104,6 +5414,7 @@ const insertBlockObjectActionImplementation = ({
   }) => {
     slateReact.ReactEditor.blur(action.editor);
   },
+  "data transfer.set": dataTransferSetActionImplementation,
   "decorator.add": addDecoratorActionImplementation,
   "decorator.remove": removeDecoratorActionImplementation,
   "decorator.toggle": toggleDecoratorActionImplementation,
@@ -5170,6 +5481,25 @@ const insertBlockObjectActionImplementation = ({
       at: range
     });
   },
+  "deserialization.failure": ({
+    action
+  }) => {
+    console.error(`Deserialization of ${action.mimeType} failed with reason ${action.reason}`);
+  },
+  "deserialization.success": ({
+    context,
+    action
+  }) => {
+    insertBlocksActionImplementation({
+      context,
+      action: {
+        type: "insert.blocks",
+        blocks: action.data,
+        editor: action.editor
+      }
+    });
+  },
+  "insert.blocks": insertBlocksActionImplementation,
   "insert.block object": insertBlockObjectActionImplementation,
   "insert.break": insertBreakActionImplementation,
   "insert.inline object": insertInlineObjectActionImplementation,
@@ -5281,6 +5611,23 @@ const insertBlockObjectActionImplementation = ({
     const nextBlockPath = [action.editor.selection.focus.path.slice(0, 1)[0] + 1];
     slate.Transforms.select(action.editor, nextBlockPath);
   },
+  "serialization.failure": ({
+    action
+  }) => {
+    console.error(`Serialization of ${action.mimeType} failed with reason ${action.reason}`);
+  },
+  "serialization.success": ({
+    context,
+    action
+  }) => {
+    dataTransferSetActionImplementation({
+      context,
+      action: {
+        ...action,
+        type: "data transfer.set"
+      }
+    });
+  },
   "style.toggle": toggleStyleActionImplementation,
   "style.add": addStyleActionImplementation,
   "style.remove": removeStyleActionImplementation,
@@ -5467,6 +5814,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "data transfer.set": {
+      behaviorActionImplementations["data transfer.set"]({
+        context,
+        action
+      });
+      break;
+    }
     case "decorator.toggle": {
       behaviorActionImplementations["decorator.toggle"]({
         context,
@@ -5488,6 +5842,20 @@ function performDefaultAction({
       });
       break;
     }
+    case "deserialization.failure": {
+      behaviorActionImplementations["deserialization.failure"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "deserialization.success": {
+      behaviorActionImplementations["deserialization.success"]({
+        context,
+        action
+      });
+      break;
+    }
     case "focus": {
       behaviorActionImplementations.focus({
         context,
@@ -5495,6 +5863,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "insert.blocks": {
+      behaviorActionImplementations["insert.blocks"]({
+        context,
+        action
+      });
+      break;
+    }
     case "insert.block object": {
       behaviorActionImplementations["insert.block object"]({
         context,
@@ -5544,6 +5919,20 @@ function performDefaultAction({
       });
       break;
     }
+    case "serialization.failure": {
+      behaviorActionImplementations["serialization.failure"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "serialization.success": {
+      behaviorActionImplementations["serialization.success"]({
+        context,
+        action
+      });
+      break;
+    }
     default:
       behaviorActionImplementations["style.toggle"]({
         context,
@@ -5561,6 +5950,7 @@ function getActiveDecorators({
   }.marks ?? []).filter((mark) => decorators.includes(mark));
 }
 function createEditorSnapshot({
+  converters,
   editor,
   keyGenerator,
   schema: schema2
@@ -5572,6 +5962,7 @@ function createEditorSnapshot({
         schema: schema2,
         slateEditorInstance: editor
       }),
+      converters,
       keyGenerator,
       schema: schema2,
       selection,
@@ -5646,7 +6037,7 @@ const editorMachine = xstate.setup({
       enqueue
     }) => {
       xstate.assertEvent(event, ["behavior event", "custom behavior event"]);
-      const defaultAction = event.type === "custom behavior event" || event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : {
+      const defaultAction = event.type === "custom behavior event" || event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "deserialize" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" || event.behaviorEvent.type === "serialize" ? void 0 : {
         ...event.behaviorEvent,
         editor: event.editor
       }, defaultActionCallback = event.type === "behavior event" ? event.defaultActionCallback : void 0, eventBehaviors = [...context.behaviors.values()].filter((behavior) => behavior.on === event.behaviorEvent.type);
@@ -5680,6 +6071,7 @@ const editorMachine = xstate.setup({
         return;
       }
       const editorSnapshot = createEditorSnapshot({
+        converters: [...context.converters],
         editor: event.editor,
         keyGenerator: context.keyGenerator,
         schema: context.schema
@@ -5769,6 +6161,7 @@ const editorMachine = xstate.setup({
     input
   }) => ({
     behaviors: new Set(input.behaviors ?? behavior_core.coreBehaviors),
+    converters: new Set(input.converters ?? []),
     keyGenerator: input.keyGenerator,
     pendingEvents: [],
     schema: input.schema,
@@ -5841,6 +6234,13 @@ const editorMachine = xstate.setup({
     "update behaviors": {
       actions: "assign behaviors"
     },
+    "update key generator": {
+      actions: xstate.assign({
+        keyGenerator: ({
+          event
+        }) => event.keyGenerator
+      })
+    },
     "update schema": {
       actions: "assign schema"
     },
@@ -5881,6 +6281,12 @@ const editorMachine = xstate.setup({
             },
             "read only": {
               on: {
+                "behavior event": {
+                  actions: "handle behavior event",
+                  guard: ({
+                    event
+                  }) => event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "data transfer.set" || event.behaviorEvent.type === "serialize" || event.behaviorEvent.type === "serialization.failure" || event.behaviorEvent.type === "serialization.success" || event.behaviorEvent.type === "select"
+                },
                 "update readOnly": {
                   guard: ({
                     event
@@ -6050,6 +6456,7 @@ function getEditorSnapshot({
 }) {
   return {
     context: {
+      converters: [...editorActorSnapshot.context.converters],
       activeDecorators: getActiveDecorators({
         schema: editorActorSnapshot.context.schema,
         slateEditorInstance
@@ -6104,6 +6511,7 @@ function useCreateEditor(config) {
 function editorConfigToMachineInput(config) {
   return {
     behaviors: config.behaviors,
+    converters: coreConverters,
     keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
     maxBlocks: config.maxBlocks,
     readOnly: config.readOnly,
@@ -6149,25 +6557,25 @@ const EditorActorContext = React.createContext({}), PortableTextEditorSelectionC
   if (selection === void 0)
     throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
   return selection;
-}, debug$5 = debugWithName("component:PortableTextEditor:SelectionProvider");
+}, debug$4 = debugWithName("component:PortableTextEditor:SelectionProvider");
 function PortableTextEditorSelectionProvider(props) {
   const $ = reactCompilerRuntime.c(6), [selection, setSelection] = React.useState(null);
   let t0, t1;
   $[0] !== props.editorActor ? (t0 = () => {
-    debug$5("Subscribing to selection changes");
+    debug$4("Subscribing to selection changes");
     const subscription = props.editorActor.on("selection", (event) => {
       React.startTransition(() => {
         setSelection(event.selection);
       });
     });
     return () => {
-      debug$5("Unsubscribing to selection changes"), subscription.unsubscribe();
+      debug$4("Unsubscribing to selection changes"), subscription.unsubscribe();
     };
   }, t1 = [props.editorActor], $[0] = props.editorActor, $[1] = t0, $[2] = t1) : (t0 = $[1], t1 = $[2]), React.useEffect(t0, t1);
   let t2;
   return $[3] !== props.children || $[4] !== selection ? (t2 = /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }), $[3] = props.children, $[4] = selection, $[5] = t2) : t2 = $[5], t2;
 }
-const debug$4 = debugWithName("component:PortableTextEditor");
+const debug$3 = debugWithName("component:PortableTextEditor");
 class PortableTextEditor extends React.Component {
   static displayName = "PortableTextEditor";
   /**
@@ -6229,13 +6637,13 @@ class PortableTextEditor extends React.Component {
   static isAnnotationActive = (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1;
   static addAnnotation = (editor, type, value) => editor.editable?.addAnnotation(type, value);
   static blur = (editor) => {
-    debug$4("Host blurred"), editor.editable?.blur();
+    debug$3("Host blurred"), editor.editable?.blur();
   };
   static delete = (editor, selection, options) => editor.editable?.delete(selection, options);
   static findDOMNode = (editor, element) => editor.editable?.findDOMNode(element);
   static findByPath = (editor, path) => editor.editable?.findByPath(path) || [];
   static focus = (editor) => {
-    debug$4("Host requesting focus"), editor.editable?.focus();
+    debug$3("Host requesting focus"), editor.editable?.focus();
   };
   static focusBlock = (editor) => editor.editable?.focusBlock();
   static focusChild = (editor) => editor.editable?.focusChild();
@@ -6246,7 +6654,7 @@ class PortableTextEditor extends React.Component {
   static isCollapsedSelection = (editor) => editor.editable?.isCollapsedSelection();
   static isExpandedSelection = (editor) => editor.editable?.isExpandedSelection();
   static isMarkActive = (editor, mark) => editor.editable?.isMarkActive(mark);
-  static insertChild = (editor, type, value) => (debug$4("Host inserting child"), editor.editable?.insertChild(type, value));
+  static insertChild = (editor, type, value) => (debug$3("Host inserting child"), editor.editable?.insertChild(type, value));
   static insertBlock = (editor, type, value) => editor.editable?.insertBlock(type, value);
   static insertBreak = (editor) => editor.editable?.insertBreak();
   static isVoid = (editor, element) => editor.editable?.isVoid(element);
@@ -6257,20 +6665,20 @@ class PortableTextEditor extends React.Component {
   };
   static marks = (editor) => editor.editable?.marks();
   static select = (editor, selection) => {
-    debug$4("Host setting selection", selection), editor.editable?.select(selection);
+    debug$3("Host setting selection", selection), editor.editable?.select(selection);
   };
   static removeAnnotation = (editor, type) => editor.editable?.removeAnnotation(type);
-  static toggleBlockStyle = (editor, blockStyle) => (debug$4("Host is toggling block style"), editor.editable?.toggleBlockStyle(blockStyle));
+  static toggleBlockStyle = (editor, blockStyle) => (debug$3("Host is toggling block style"), editor.editable?.toggleBlockStyle(blockStyle));
   static toggleList = (editor, listStyle) => editor.editable?.toggleList(listStyle);
   static toggleMark = (editor, mark) => {
-    debug$4("Host toggling mark", mark), editor.editable?.toggleMark(mark);
+    debug$3("Host toggling mark", mark), editor.editable?.toggleMark(mark);
   };
-  static getFragment = (editor) => (debug$4("Host getting fragment"), editor.editable?.getFragment());
+  static getFragment = (editor) => (debug$3("Host getting fragment"), editor.editable?.getFragment());
   static undo = (editor) => {
-    debug$4("Host undoing"), editor.editable?.undo();
+    debug$3("Host undoing"), editor.editable?.undo();
   };
   static redo = (editor) => {
-    debug$4("Host redoing"), editor.editable?.redo();
+    debug$3("Host redoing"), editor.editable?.redo();
   };
   static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
@@ -6296,7 +6704,7 @@ function RouteEventsToChanges(props) {
   const handleChange = useEffectEvent.useEffectEvent(t0);
   let t1, t2;
   return $[2] !== handleChange || $[3] !== props.editorActor ? (t1 = () => {
-    debug$4("Subscribing to editor changes");
+    debug$3("Subscribing to editor changes");
     const sub = props.editorActor.on("*", (event) => {
       bb5: switch (event.type) {
         case "blurred": {
@@ -6370,11 +6778,11 @@ function RouteEventsToChanges(props) {
       }
     });
     return () => {
-      debug$4("Unsubscribing to changes"), sub.unsubscribe();
+      debug$3("Unsubscribing to changes"), sub.unsubscribe();
     };
   }, t2 = [props.editorActor, handleChange], $[2] = handleChange, $[3] = props.editorActor, $[4] = t1, $[5] = t2) : (t1 = $[4], t2 = $[5]), React.useEffect(t1, t2), null;
 }
-const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
+const debug$2 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
     editorActor,
     attributes,
@@ -6402,7 +6810,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   const setSelectedFromRange = React.useCallback(() => {
     if (!shouldTrackSelectionAndFocus)
       return;
-    debug$3("Setting selection and focus from range");
+    debug$2("Setting selection and focus from range");
     const winSelection = window.getSelection();
     if (!winSelection) {
       setSelected(!1);
@@ -6498,7 +6906,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
   return React.useMemo(() => /* @__PURE__ */ jsxRuntime.jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
-const debug$2 = debugWithName("plugin:withHotKeys");
+const debug$1 = debugWithName("plugin:withHotKeys");
 function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions ?? {};
   return function(editor) {
@@ -6513,7 +6921,7 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
               const possibleMark = activeHotkeys[cat];
               if (possibleMark) {
                 const mark = possibleMark[hotkey];
-                debug$2(`HotKey ${hotkey} to toggle ${mark}`), editorActor.send({
+                debug$1(`HotKey ${hotkey} to toggle ${mark}`), editorActor.send({
                   type: "behavior event",
                   behaviorEvent: {
                     type: "decorator.toggle",
@@ -6540,204 +6948,6 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
     }, editor;
   };
 }
-const debug$1 = debugWithName("plugin:withInsertData");
-function createWithInsertData(editorActor, schemaTypes) {
-  return function(editor) {
-    const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => editor.isTextBlock(block) ? block.children.map((child) => child._type === spanTypeName ? child.text : `[${schemaTypes.inlineObjects.find((t) => t.name === child._type)?.title || "Object"}]`).join("") : `[${schemaTypes.blockObjects.find((t) => t.name === block._type)?.title || "Object"}]`).join(`
-
-`);
-    return editor.setFragmentData = (data, originEvent) => {
-      const {
-        selection
-      } = editor;
-      if (!selection)
-        return;
-      const [start, end] = slate.Range.edges(selection), startVoid = slate.Editor.void(editor, {
-        at: start.path
-      }), endVoid = slate.Editor.void(editor, {
-        at: end.path
-      });
-      if (slate.Range.isCollapsed(selection) && !startVoid)
-        return;
-      const domRange = slateReact.ReactEditor.toDOMRange(editor, selection);
-      let contents = domRange.cloneContents();
-      if (endVoid) {
-        const [voidNode] = endVoid, r = domRange.cloneRange(), domNode = slateReact.ReactEditor.toDOMNode(editor, voidNode);
-        r.setEndAfter(domNode), contents = r.cloneContents();
-      }
-      Array.from(contents.querySelectorAll("[data-slate-zero-width]")).forEach((zw) => {
-        const isNewline = zw.getAttribute("data-slate-zero-width") === "n";
-        zw.textContent = isNewline ? `
-` : "";
-      }), Array.from(contents.querySelectorAll("*")).forEach((elm) => {
-        elm.removeAttribute("contentEditable"), elm.removeAttribute("data-slate-inline"), elm.removeAttribute("data-slate-leaf"), elm.removeAttribute("data-slate-node"), elm.removeAttribute("data-slate-spacer"), elm.removeAttribute("data-slate-string"), elm.removeAttribute("data-slate-zero-width"), elm.removeAttribute("draggable");
-        for (const key in elm.attributes)
-          elm.hasAttribute(key) && elm.removeAttribute(key);
-      });
-      const div = contents.ownerDocument.createElement("div");
-      div.appendChild(contents), div.setAttribute("hidden", "true"), contents.ownerDocument.body.appendChild(div);
-      const asHTML = div.innerHTML;
-      contents.ownerDocument.body.removeChild(div);
-      const fragment = editor.getFragment(), portableText = fromSlateValue(fragment, blockTypeName), asJSON = JSON.stringify(portableText), asPlainText = toPlainText(portableText);
-      data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$1("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$1("Set fragment data", asJSON, asHTML);
-    }, editor.insertPortableTextData = (data) => {
-      if (!editor.selection)
-        return !1;
-      const pText = data.getData("application/x-portable-text"), origin = data.getData("application/x-portable-text-event-origin");
-      if (debug$1(`Inserting portable text from ${origin} event`, pText), pText) {
-        const parsed = JSON.parse(pText);
-        if (Array.isArray(parsed) && parsed.length > 0) {
-          const slateValue = _regenerateKeys(editor, toSlateValue(parsed, {
-            schemaTypes
-          }), editorActor.getSnapshot().context.keyGenerator, spanTypeName, schemaTypes), validation = validateValue(parsed, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
-          if (!validation.valid && !validation.resolution?.autoResolve) {
-            const errorDescription = `${validation.resolution?.description}`;
-            return editorActor.send({
-              type: "error",
-              name: "pasteError",
-              description: errorDescription,
-              data: validation
-            }), debug$1("Invalid insert result", validation), !1;
-          }
-          return _insertFragment(editor, slateValue, schemaTypes), !0;
-        }
-      }
-      return !1;
-    }, editor.insertTextOrHTMLData = (data) => {
-      if (!editor.selection)
-        return debug$1("No selection, not inserting"), !1;
-      const html = data.getData("text/html"), text = data.getData("text/plain");
-      if (html || text) {
-        debug$1("Inserting data", data);
-        let portableText, fragment, insertedType;
-        if (html) {
-          if (portableText = blockTools.htmlToBlocks(html, schemaTypes.portableText, {
-            unstable_whitespaceOnPasteMode: whitespaceOnPasteMode,
-            keyGenerator: editorActor.getSnapshot().context.keyGenerator
-          }), fragment = toSlateValue(portableText, {
-            schemaTypes
-          }), insertedType = "HTML", portableText.length === 0)
-            return !1;
-        } else {
-          const textToHtml = `<html><body>${escapeHtml(text).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`;
-          portableText = blockTools.htmlToBlocks(textToHtml, schemaTypes.portableText, {
-            keyGenerator: editorActor.getSnapshot().context.keyGenerator
-          }), fragment = toSlateValue(portableText, {
-            schemaTypes
-          }), insertedType = "text";
-        }
-        const validation = validateValue(portableText, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
-        if (!validation.valid) {
-          const errorDescription = `Could not validate the resulting portable text to insert.
-${validation.resolution?.description}
-Try to insert as plain text (shift-paste) instead.`;
-          return editorActor.send({
-            type: "error",
-            name: "pasteError",
-            description: errorDescription,
-            data: validation
-          }), debug$1("Invalid insert result", validation), !1;
-        }
-        return debug$1(`Inserting ${insertedType} fragment at ${JSON.stringify(editor.selection)}`), _insertFragment(editor, fragment, schemaTypes), !0;
-      }
-      return !1;
-    }, editor.insertData = (data) => {
-      editor.insertPortableTextData(data) || editor.insertTextOrHTMLData(data);
-    }, editor.insertFragmentData = (data) => {
-      const fragment = data.getData("application/x-portable-text");
-      if (fragment) {
-        const parsed = JSON.parse(fragment);
-        return editor.insertFragment(parsed), !0;
-      }
-      return !1;
-    }, editor;
-  };
-}
-const entityMap = {
-  "&": "&amp;",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-  "'": "&#39;",
-  "/": "&#x2F;",
-  "`": "&#x60;",
-  "=": "&#x3D;"
-};
-function escapeHtml(str) {
-  return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
-}
-function _regenerateKeys(editor, fragment, keyGenerator, spanTypeName, editorTypes) {
-  return fragment.map((node) => {
-    const newNode = {
-      ...node
-    };
-    if (editor.isTextBlock(newNode)) {
-      const annotations = editorTypes.annotations.map((t) => t.name);
-      if (annotations.length === 0) {
-        const {
-          markDefs,
-          ...NewNodeNoDefs
-        } = newNode;
-        return {
-          ...NewNodeNoDefs,
-          _key: keyGenerator()
-        };
-      }
-      if ((newNode.markDefs || []).some((def) => !annotations.includes(def._type))) {
-        const allowedAnnotations = (newNode.markDefs || []).filter((def) => annotations.includes(def._type));
-        return {
-          ...newNode,
-          markDefs: allowedAnnotations,
-          _key: keyGenerator()
-        };
-      }
-      newNode.markDefs = (newNode.markDefs || []).map((def) => {
-        const oldKey = def._key, newKey = keyGenerator();
-        return newNode.children = newNode.children.map((child) => child._type === spanTypeName && editor.isTextSpan(child) ? {
-          ...child,
-          marks: child.marks && child.marks.includes(oldKey) ? [...child.marks].filter((mark) => mark !== oldKey).concat(newKey) : child.marks
-        } : child), {
-          ...def,
-          _key: newKey
-        };
-      });
-    }
-    const nodeWithNewKeys = {
-      ...newNode,
-      _key: keyGenerator()
-    };
-    return editor.isTextBlock(nodeWithNewKeys) && (nodeWithNewKeys.children = nodeWithNewKeys.children.map((child) => ({
-      ...child,
-      _key: keyGenerator()
-    }))), nodeWithNewKeys;
-  });
-}
-function _insertFragment(editor, fragment, schemaTypes) {
-  editor.withoutNormalizing(() => {
-    if (!editor.selection)
-      return;
-    const [focusBlock, focusPath] = slate.Editor.node(editor, editor.selection, {
-      depth: 1
-    });
-    if (editor.isTextBlock(focusBlock) && editor.isTextBlock(fragment[0])) {
-      const {
-        markDefs
-      } = focusBlock;
-      debug$1("Mixing markDefs of focusBlock and fragments[0] block", markDefs, fragment[0].markDefs), isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(editor, {
-        markDefs: uniq__default.default([...fragment[0].markDefs || [], ...markDefs || []])
-      }, {
-        at: focusPath,
-        mode: "lowest",
-        voids: !1
-      });
-    }
-    isEqualToEmptyEditor(editor.children, schemaTypes) ? (slate.Transforms.splitNodes(editor, {
-      at: [0, 0]
-    }), editor.insertFragment(fragment), slate.Transforms.removeNodes(editor, {
-      at: [0]
-    })) : editor.insertFragment(fragment);
-  }), editor.onChange();
-}
 function withSyncRangeDecorations({
   editorActor,
   slateEditor,
@@ -6785,12 +6995,11 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     "edit mode": "read only"
   })), schemaTypes = react.useSelector(editorActor, (s_0) => s_0.context.schema), slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name;
   React.useMemo(() => {
-    const withInsertData = createWithInsertData(editorActor, schemaTypes);
     if (readOnly)
-      return debug("Editable is in read only mode"), withInsertData(slateEditor);
+      return debug("Editable is in read only mode"), slateEditor;
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
-    return debug("Editable is in edit mode"), withInsertData(withHotKeys(slateEditor));
-  }, [editorActor, hotkeys, portableTextEditor, readOnly, schemaTypes, slateEditor]);
+    return debug("Editable is in edit mode"), withHotKeys(slateEditor);
+  }, [editorActor, hotkeys, portableTextEditor, readOnly, slateEditor]);
   const renderElement = React.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(Element, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck }), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = React.useCallback((lProps) => {
     if (lProps.leaf._type === "span") {
       let rendered = /* @__PURE__ */ jsxRuntime.jsx(Leaf, { ...lProps, editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });