@portabletext/editor 1.0.3 → 1.0.5

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$l = require("debug"), types$1 = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), schema = require("@sanity/schema"), patchEvent = require("@portabletext/patches/patch-event"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), apply$1 = require("@portabletext/patches/apply"), flatten = require("lodash/flatten.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), content = require("@sanity/util/content"), debounce = require("lodash/debounce.js"), types = require("@portabletext/patches/types");
+var jsxRuntime = require("react/jsx-runtime"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$l = require("debug"), types = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), schema = require("@sanity/schema"), patches = require("@portabletext/patches"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), flatten = require("lodash/flatten.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools"), isPlainObject = require("lodash/isPlainObject.js"), throttle = require("lodash/throttle.js"), content = require("@sanity/util/content"), debounce = require("lodash/debounce.js");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -31,7 +31,7 @@ function createArrayedPath(point, editor) {
   const [block, blockPath] = Array.from(
     slate.Editor.nodes(editor, {
       at: [],
-      match: (n) => types$1.isKeySegment(point.path[0]) && n._key === point.path[0]._key
+      match: (n) => types.isKeySegment(point.path[0]) && n._key === point.path[0]._key
     })
   )[0] || [void 0, void 0];
   if (!block || !slate.Element.isElement(block))
@@ -713,7 +713,7 @@ function createOperationToPatches(types2) {
     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 = patchEvent.diffMatchPatch(prevText, textChild.text, path);
+    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 = patches.diffMatchPatch(prevText, textChild.text, path);
     return patch.value.length ? [patch] : [];
   }
   function removeTextPatch(editor, operation, beforeValue) {
@@ -725,7 +725,7 @@ function createOperationToPatches(types2) {
       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 = patchEvent.diffMatchPatch(prevText || "", textChild.text, path);
+    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 = patches.diffMatchPatch(prevText || "", textChild.text, path);
     return patch.value ? [patch] : [];
   }
   function setNodePatch(editor, operation) {
@@ -737,24 +737,24 @@ function createOperationToPatches(types2) {
         { ...editor.children[operation.path[0]], ...operation.newProperties },
         isUndefined__default.default
       );
-      return [patchEvent.set(fromSlateValue([setNode], textBlockName)[0], [{ _key: block._key }])];
+      return [patches.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);
+          const blockKey = block._key, childKey = child._key, patches$1 = [], keys = Object.keys(operation.newProperties);
           return keys.forEach((keyName) => {
             if (keys.length === 1 && keyName === "_key") {
               const val = get__default.default(operation.newProperties, keyName);
-              patches.push(
-                patchEvent.set(val, [{ _key: blockKey }, "children", block.children.indexOf(child), keyName])
+              patches$1.push(
+                patches.set(val, [{ _key: blockKey }, "children", block.children.indexOf(child), keyName])
               );
             } else {
               const val = get__default.default(operation.newProperties, keyName);
-              patches.push(patchEvent.set(val, [{ _key: blockKey }, "children", { _key: childKey }, keyName]));
+              patches$1.push(patches.set(val, [{ _key: blockKey }, "children", { _key: childKey }, keyName]));
             }
-          }), patches;
+          }), patches$1;
         }
         throw new Error("Could not find a valid child");
       }
@@ -767,12 +767,12 @@ function createOperationToPatches(types2) {
     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 == null ? void 0 : block._key : beforeBlock == null ? void 0 : beforeBlock._key;
       return targetKey ? [
-        patchEvent.insert([fromSlateValue([operation.node], textBlockName)[0]], position, [
+        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], position, [
           { _key: targetKey }
         ])
       ] : [
-        patchEvent.setIfMissing(beforeValue, []),
-        patchEvent.insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [
+        patches.setIfMissing(beforeValue, []),
+        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [
           operation.path[0]
         ])
       ];
@@ -790,7 +790,7 @@ function createOperationToPatches(types2) {
         textBlockName
       )[0].children[0];
       return [
-        patchEvent.insert([child], position, [
+        patches.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 }
@@ -800,7 +800,7 @@ function createOperationToPatches(types2) {
     return debug$j("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
-    const patches = [], splitBlock = editor.children[operation.path[0]];
+    const patches$1 = [], splitBlock = editor.children[operation.path[0]];
     if (!editor.isTextBlock(splitBlock))
       throw new Error(
         `Block with path ${JSON.stringify(
@@ -814,12 +814,12 @@ function createOperationToPatches(types2) {
           [editor.children[operation.path[0] + 1]],
           textBlockName
         )[0];
-        targetValue && (patches.push(patchEvent.insert([targetValue], "after", [{ _key: splitBlock._key }])), oldBlock.children.slice(operation.position).forEach((span) => {
+        targetValue && (patches$1.push(patches.insert([targetValue], "after", [{ _key: splitBlock._key }])), oldBlock.children.slice(operation.position).forEach((span) => {
           const path = [{ _key: oldBlock._key }, "children", { _key: span._key }];
-          patches.push(patchEvent.unset(path));
+          patches$1.push(patches.unset(path));
         }));
       }
-      return patches;
+      return patches$1;
     }
     if (operation.path.length === 2) {
       const splitSpan = splitBlock.children[operation.path[1]];
@@ -833,14 +833,14 @@ function createOperationToPatches(types2) {
           ],
           textBlockName
         )[0].children;
-        patches.push(
-          patchEvent.insert(targetSpans, "after", [
+        patches$1.push(
+          patches.insert(targetSpans, "after", [
             { _key: splitBlock._key },
             "children",
             { _key: splitSpan._key }
           ])
-        ), patches.push(
-          patchEvent.set(splitSpan.text, [
+        ), patches$1.push(
+          patches.set(splitSpan.text, [
             { _key: splitBlock._key },
             "children",
             { _key: splitSpan._key },
@@ -848,57 +848,57 @@ function createOperationToPatches(types2) {
           ])
         );
       }
-      return patches;
+      return patches$1;
     }
-    return patches;
+    return patches$1;
   }
   function removeNodePatch(editor, operation, beforeValue) {
     const block = beforeValue[operation.path[0]];
     if (operation.path.length === 1) {
       if (block && block._key)
-        return [patchEvent.unset([{ _key: block._key }])];
+        return [patches.unset([{ _key: block._key }])];
       throw new Error("Block not found");
     } else if (editor.isTextBlock(block) && operation.path.length === 2) {
       const spanToRemove = editor.isTextBlock(block) && block.children && block.children[operation.path[1]];
-      return spanToRemove ? [patchEvent.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$j("Span not found in editor trying to remove node"), []);
+      return spanToRemove ? [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$j("Span not found in editor trying to remove node"), []);
     } else
       return debug$j("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
-    const patches = [], block = beforeValue[operation.path[0]], targetBlock = editor.children[operation.path[0]];
+    const patches$1 = [], block = beforeValue[operation.path[0]], targetBlock = editor.children[operation.path[0]];
     if (operation.path.length === 1)
       if (block != null && block._key) {
         const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
-        patches.push(patchEvent.set(newBlock, [{ _key: newBlock._key }])), patches.push(patchEvent.unset([{ _key: block._key }]));
+        patches$1.push(patches.set(newBlock, [{ _key: newBlock._key }])), patches$1.push(patches.unset([{ _key: block._key }]));
       } else
         throw new Error("Target key not found!");
     else if (operation.path.length === 2 && editor.isTextBlock(targetBlock)) {
       const mergedSpan = editor.isTextBlock(block) && block.children[operation.path[1]] || void 0, targetSpan = targetBlock.children[operation.path[1] - 1];
-      editor.isTextSpan(targetSpan) && (patches.push(
-        patchEvent.set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
-      ), mergedSpan && patches.push(patchEvent.unset([{ _key: block._key }, "children", { _key: mergedSpan._key }])));
+      editor.isTextSpan(targetSpan) && (patches$1.push(
+        patches.set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
+      ), mergedSpan && patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: mergedSpan._key }])));
     } else
       debug$j("Void nodes can't be merged, not creating any patches");
-    return patches;
+    return patches$1;
   }
   function moveNodePatch(editor, operation, beforeValue) {
-    const patches = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
+    const patches$1 = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
     if (operation.path.length === 1) {
       const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
-      patches.push(patchEvent.unset([{ _key: block._key }])), patches.push(
-        patchEvent.insert([fromSlateValue([block], textBlockName)[0]], position, [{ _key: targetBlock._key }])
+      patches$1.push(patches.unset([{ _key: block._key }])), patches$1.push(
+        patches.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(patchEvent.unset([{ _key: block._key }, "children", { _key: child._key }])), patches.push(
-        patchEvent.insert([childToInsert], position, [
+      patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: child._key }])), patches$1.push(
+        patches.insert([childToInsert], position, [
           { _key: targetBlock._key },
           "children",
           { _key: targetChild._key }
         ])
       );
     }
-    return patches;
+    return patches$1;
   }
   return {
     insertNodePatch,
@@ -912,7 +912,7 @@ function createOperationToPatches(types2) {
   };
 }
 const debug$i = debugWithName("API:editable");
-function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
+function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
   return function(editor) {
     return portableTextEditor.setEditable({
       focus: () => {
@@ -950,7 +950,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
         if (editor.selection) {
           const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
           if (block)
-            return fromSlateValue([block], types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
+            return fromSlateValue([block], types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
         }
       },
       focusChild: () => {
@@ -959,7 +959,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           if (block && editor.isTextBlock(block))
             return fromSlateValue(
               [block],
-              types2.block.name,
+              types$1.block.name,
               KEY_TO_VALUE_ELEMENT.get(editor)
             )[0].children[editor.selection.focus.path[1]];
         }
@@ -971,18 +971,18 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
         const [focusBlock] = Array.from(
           slate.Editor.nodes(editor, {
             at: editor.selection.focus.path.slice(0, 1),
-            match: (n) => n._type === types2.block.name
+            match: (n) => n._type === types$1.block.name
           })
         )[0] || [void 0];
         if (!focusBlock)
           throw new Error("No focused text block");
-        if (type.name !== types2.span.name && !types2.inlineObjects.some((t) => t.name === type.name))
+        if (type.name !== types$1.span.name && !types$1.inlineObjects.some((t) => t.name === type.name))
           throw new Error("This type cannot be inserted as a child to a text block");
         const child = toSlateValue(
           [
             {
               _key: keyGenerator(),
-              _type: types2.block.name,
+              _type: types$1.block.name,
               children: [
                 {
                   _key: keyGenerator(),
@@ -993,14 +993,14 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
             }
           ],
           portableTextEditor
-        )[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$i("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
+        )[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types$1.span.name, focusNode = slate.Node.get(editor, focusChildPath);
+        return isSpanNode && focusNode._type !== types$1.span.name && (debug$i("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
           select: !0,
           at: editor.selection
         }), editor.onChange(), ((_a = toPortableTextRange(
-          fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+          fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
           editor.selection,
-          types2
+          types$1
         )) == null ? void 0 : _a.focus.path) || [];
       },
       insertBlock: (type, value) => {
@@ -1019,13 +1019,13 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
         )[0], [focusBlock] = Array.from(
           slate.Editor.nodes(editor, {
             at: editor.selection.focus.path.slice(0, 1),
-            match: (n) => n._type === types2.block.name
+            match: (n) => n._type === types$1.block.name
           })
         )[0] || [void 0];
-        return focusBlock && isEqualToEmptyEditor([focusBlock], types2) && slate.Transforms.removeNodes(editor, { at: editor.selection }), slate.Editor.insertNode(editor, block), editor.onChange(), ((_a = toPortableTextRange(
-          fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+        return focusBlock && isEqualToEmptyEditor([focusBlock], types$1) && slate.Transforms.removeNodes(editor, { at: editor.selection }), slate.Editor.insertNode(editor, block), editor.onChange(), ((_a = toPortableTextRange(
+          fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
           editor.selection,
-          types2
+          types$1
         )) == null ? void 0 : _a.focus.path) || [];
       },
       hasBlockStyle: (style) => {
@@ -1042,7 +1042,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           return !1;
         }
       },
-      isVoid: (element) => ![types2.block.name, types2.span.name].includes(element._type),
+      isVoid: (element) => ![types$1.block.name, types$1.span.name].includes(element._type),
       findByPath: (path) => {
         const slatePath = toSlateRange(
           { focus: { path, offset: 0 }, anchor: { path, offset: 0 } },
@@ -1052,10 +1052,10 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           const [block, blockPath] = slate.Editor.node(editor, slatePath.focus.path.slice(0, 1));
           if (block && blockPath && typeof block._key == "string") {
             if (path.length === 1 && slatePath.focus.path.length === 1)
-              return [fromSlateValue([block], types2.block.name)[0], [{ _key: block._key }]];
+              return [fromSlateValue([block], types$1.block.name)[0], [{ _key: block._key }]];
             const ptBlock = fromSlateValue(
               [block],
-              types2.block.name,
+              types$1.block.name,
               KEY_TO_VALUE_ELEMENT.get(editor)
             )[0];
             if (editor.isTextBlock(ptBlock)) {
@@ -1114,7 +1114,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           if (spans.some(
             ([span]) => {
               var _a;
-              return !types$1.isPortableTextSpan(span) || !span.marks || ((_a = span.marks) == null ? void 0 : _a.length) === 0;
+              return !types.isPortableTextSpan(span) || !span.marks || ((_a = span.marks) == null ? void 0 : _a.length) === 0;
             }
           ))
             return !1;
@@ -1124,7 +1124,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           }, []);
           return spans.every(([span]) => {
             var _a;
-            if (!types$1.isPortableTextSpan(span)) return !1;
+            if (!types.isPortableTextSpan(span)) return !1;
             const spanMarkDefs = (_a = span.marks) == null ? void 0 : _a.map(
               (markKey) => {
                 var _a2;
@@ -1164,7 +1164,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
               },
               {
                 at: editor.selection,
-                match: (n) => n._type === types2.span.name
+                match: (n) => n._type === types$1.span.name
               }
             ), editor.onChange(), editor.selection && slate.Transforms.insertNodes(
               editor,
@@ -1174,9 +1174,9 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
               }
             );
             const newPortableTextEditorSelection = toPortableTextRange(
-              fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+              fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
               editor.selection,
-              types2
+              types$1
             );
             newPortableTextEditorSelection && (returnValue = {
               spanPath: newPortableTextEditorSelection.focus.path,
@@ -1207,7 +1207,7 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
             })), (options == null ? void 0 : options.mode) === "children" && (debug$i("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
               at: range,
               voids: !0,
-              match: (node) => node._type === types2.span.name || // Text children
+              match: (node) => node._type === types$1.span.name || // Text children
               !editor.isTextBlock(node) && slate.Element.isElement(node)
             })), editor.children.length === 0 && (editor.children = [editor.pteCreateEmptyBlock()]), editor.onChange();
           }
@@ -1245,20 +1245,20 @@ function createWithEditableAPI(portableTextEditor, types2, keyGenerator) {
           if (existing)
             return existing;
           ptRange = toPortableTextRange(
-            fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+            fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
             editor.selection,
-            types2
+            types$1
           ), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
         }
         return ptRange;
       },
-      getValue: () => fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+      getValue: () => fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
       isCollapsedSelection: () => !!editor.selection && slate.Range.isCollapsed(editor.selection),
       isExpandedSelection: () => !!editor.selection && slate.Range.isExpanded(editor.selection),
       insertBreak: () => {
         editor.insertBreak(), editor.onChange();
       },
-      getFragment: () => fromSlateValue(editor.getFragment(), types2.block.name),
+      getFragment: () => fromSlateValue(editor.getFragment(), types$1.block.name),
       isSelectionsOverlapping: (selectionA, selectionB) => {
         const rangeA = toSlateRange(selectionA, editor), rangeB = toSlateRange(selectionB, editor);
         return slate.Range.isRange(rangeA) && slate.Range.isRange(rangeB) && slate.Range.includes(rangeA, rangeB);
@@ -1839,7 +1839,7 @@ function countUtf8Bytes(str) {
   }
   return bytes;
 }
-function adjustIndiciesToUcs2(patches, base) {
+function adjustIndiciesToUcs2(patches2, base) {
   let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, byteOffset = 0, idx = 0;
   function advanceTo(target) {
     for (; byteOffset < target; ) {
@@ -1853,7 +1853,7 @@ function adjustIndiciesToUcs2(patches, base) {
     return idx;
   }
   const adjusted = [];
-  for (const patch of patches)
+  for (const patch of patches2)
     adjusted.push({
       diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
       start1: advanceTo(patch.start1),
@@ -1897,21 +1897,21 @@ function xIndex(diffs, loc) {
     lastChars1 = chars1, lastChars2 = chars2;
   return diffs.length !== x && diffs[x][0] === DIFF_DELETE ? lastChars2 : lastChars2 + (loc - lastChars1);
 }
-function addPadding(patches) {
+function addPadding(patches2) {
   const paddingLength = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
   let nullPadding = "";
   for (let x = 1; x <= paddingLength; x++)
     nullPadding += String.fromCharCode(x);
-  for (const p of patches)
+  for (const p of patches2)
     p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
-  let patch = patches[0], diffs = patch.diffs;
+  let patch = patches2[0], diffs = patch.diffs;
   if (diffs.length === 0 || diffs[0][0] !== DIFF_EQUAL)
     diffs.unshift([DIFF_EQUAL, nullPadding]), patch.start1 -= paddingLength, patch.start2 -= paddingLength, patch.utf8Start1 -= paddingLength, patch.utf8Start2 -= paddingLength, patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
   else if (paddingLength > diffs[0][1].length) {
     const firstDiffLength = diffs[0][1].length, extraLength = paddingLength - firstDiffLength;
     diffs[0][1] = nullPadding.substring(firstDiffLength) + diffs[0][1], patch.start1 -= extraLength, patch.start2 -= extraLength, patch.utf8Start1 -= extraLength, patch.utf8Start2 -= extraLength, patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
   }
-  if (patch = patches[patches.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL)
+  if (patch = patches2[patches2.length - 1], diffs = patch.diffs, diffs.length === 0 || diffs[diffs.length - 1][0] !== DIFF_EQUAL)
     diffs.push([DIFF_EQUAL, nullPadding]), patch.length1 += paddingLength, patch.length2 += paddingLength, patch.utf8Length1 += paddingLength, patch.utf8Length2 += paddingLength;
   else if (paddingLength > diffs[diffs.length - 1][1].length) {
     const extraLength = paddingLength - diffs[diffs.length - 1][1].length;
@@ -1919,14 +1919,14 @@ function addPadding(patches) {
   }
   return nullPadding;
 }
-function splitMax(patches) {
+function splitMax(patches2) {
   let margin = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : DEFAULT_MARGIN;
   const patchSize = MAX_BITS;
-  for (let x = 0; x < patches.length; x++) {
-    if (patches[x].length1 <= patchSize)
+  for (let x = 0; x < patches2.length; x++) {
+    if (patches2[x].length1 <= patchSize)
       continue;
-    const bigpatch = patches[x];
-    patches.splice(x--, 1);
+    const bigpatch = patches2[x];
+    patches2.splice(x--, 1);
     let start1 = bigpatch.start1, start2 = bigpatch.start2, preContext = "";
     for (; bigpatch.diffs.length !== 0; ) {
       const patch = createPatchObject(start1 - preContext.length, start2 - preContext.length);
@@ -1946,18 +1946,18 @@ function splitMax(patches) {
       }
       preContext = diffText2(patch.diffs), preContext = preContext.substring(preContext.length - margin);
       const postContext = diffText1(bigpatch.diffs).substring(0, margin), postContextByteCount = countUtf8Bytes(postContext);
-      postContext !== "" && (patch.length1 += postContext.length, patch.length2 += postContext.length, patch.utf8Length1 += postContextByteCount, patch.utf8Length2 += postContextByteCount, patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL ? patch.diffs[patch.diffs.length - 1][1] += postContext : patch.diffs.push([DIFF_EQUAL, postContext])), empty || patches.splice(++x, 0, patch);
+      postContext !== "" && (patch.length1 += postContext.length, patch.length2 += postContext.length, patch.utf8Length1 += postContextByteCount, patch.utf8Length2 += postContextByteCount, patch.diffs.length !== 0 && patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL ? patch.diffs[patch.diffs.length - 1][1] += postContext : patch.diffs.push([DIFF_EQUAL, postContext])), empty || patches2.splice(++x, 0, patch);
     }
   }
 }
-function apply(patches, originalText) {
+function apply(patches2, originalText) {
   let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  if (typeof patches == "string")
+  if (typeof patches2 == "string")
     throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
   let text = originalText;
-  if (patches.length === 0)
+  if (patches2.length === 0)
     return [text, []];
-  const parsed = adjustIndiciesToUcs2(patches, text, {
+  const parsed = adjustIndiciesToUcs2(patches2, text, {
     allowExceedingIndices: opts.allowExceedingIndices
   }), margin = opts.margin || DEFAULT_MARGIN, deleteThreshold = opts.deleteThreshold || 0.4, nullPadding = addPadding(parsed, margin);
   text = nullPadding + text + nullPadding, splitMax(parsed, margin);
@@ -1996,7 +1996,7 @@ const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
 function parse(textline) {
   if (!textline)
     return [];
-  const patches = [], lines = textline.split(`
+  const patches2 = [], lines = textline.split(`
 `);
   let textPointer = 0;
   for (; textPointer < lines.length; ) {
@@ -2004,7 +2004,7 @@ function parse(textline) {
     if (!m)
       throw new Error("Invalid patch string: ".concat(lines[textPointer]));
     const patch = createPatchObject(toInt(m[1]), toInt(m[3]));
-    for (patches.push(patch), m[2] === "" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === "0" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === "" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === "0" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length; ) {
+    for (patches2.push(patch), m[2] === "" ? (patch.start1--, patch.utf8Start1--, patch.length1 = 1, patch.utf8Length1 = 1) : m[2] === "0" ? (patch.length1 = 0, patch.utf8Length1 = 0) : (patch.start1--, patch.utf8Start1--, patch.utf8Length1 = toInt(m[2]), patch.length1 = patch.utf8Length1), m[4] === "" ? (patch.start2--, patch.utf8Start2--, patch.length2 = 1, patch.utf8Length2 = 1) : m[4] === "0" ? (patch.length2 = 0, patch.utf8Length2 = 0) : (patch.start2--, patch.utf8Start2--, patch.utf8Length2 = toInt(m[4]), patch.length2 = patch.utf8Length2), textPointer++; textPointer < lines.length; ) {
       const currentLine = lines[textPointer], sign = currentLine.charAt(0);
       if (sign === "@")
         break;
@@ -2030,7 +2030,7 @@ function parse(textline) {
       textPointer++;
     }
   }
-  return patches;
+  return patches2;
 }
 function toInt(num) {
   return parseInt(num, 10);
@@ -2074,7 +2074,7 @@ function diffMatchPatch(editor, patch) {
     return debug$h("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 patches = parse(patch.value), [newValue] = apply(patches, child.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
+  const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
   debugState(editor, "before");
   let offset = 0;
   for (const [op, text] of diff$1)
@@ -2163,7 +2163,7 @@ function setPatch(editor, patch) {
       });
     });
   } else if (block && "value" in block) {
-    const newVal = apply$1.applyAll([block.value], [patch])[0];
+    const newVal = patches.applyAll([block.value], [patch])[0];
     return slate.Transforms.setNodes(editor, { ...block, value: newVal }, { at: blockPath }), !0;
   }
   return debugState(editor, "after"), !0;
@@ -2245,9 +2245,9 @@ function createWithUndoRedo(options) {
     const remotePatches = getRemotePatches(editor);
     patches$ && editor.subscriptions.push(() => {
       debug$g("Subscribing to patches");
-      const sub = patches$.subscribe(({ patches, snapshot }) => {
+      const sub = patches$.subscribe(({ patches: patches2, snapshot }) => {
         let reset = !1;
-        patches.forEach((patch) => {
+        patches2.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
               debug$g("Someone else cleared the content, resetting undo/redo history"), editor.history = { undos: [], redos: [] }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
@@ -2453,7 +2453,7 @@ function createWithPatches({
     const handleBufferedRemotePatches = () => {
       if (bufferedPatches.length === 0)
         return;
-      const patches = bufferedPatches;
+      const patches2 = bufferedPatches;
       bufferedPatches = [];
       let changed = !1;
       withRemoteChanges(editor, () => {
@@ -2461,7 +2461,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               withPreserveKeys(editor, () => {
-                patches.forEach((patch) => {
+                patches2.forEach((patch) => {
                   debug$f.enabled && debug$f(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
                 });
               });
@@ -2469,8 +2469,8 @@ function createWithPatches({
           });
         }), changed && (editor.normalize(), editor.onChange());
       });
-    }, handlePatches = ({ patches }) => {
-      const remotePatches = patches.filter((p) => p.origin !== "local");
+    }, handlePatches = ({ patches: patches2 }) => {
+      const remotePatches = patches2.filter((p) => p.origin !== "local");
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return patches$ && editor.subscriptions.push(() => {
@@ -2482,71 +2482,71 @@ function createWithPatches({
     }), editor.apply = (operation) => {
       if (readOnly)
         return apply2(operation), editor;
-      let patches = [];
+      let patches$1 = [];
       previousChildren = editor.children;
       const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes);
       apply2(operation);
       const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes);
       if (!isPatching(editor))
         return editor;
-      switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches.push(patchEvent.insert(previousChildren, "before", [0])), operation.type) {
+      switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches$1.push(patches.insert(previousChildren, "before", [0])), operation.type) {
         case "insert_text":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.insertTextPatch(editor, operation, previousChildren)
           ];
           break;
         case "remove_text":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.removeTextPatch(editor, operation, previousChildren)
           ];
           break;
         case "remove_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.removeNodePatch(editor, operation, previousChildren)
           ];
           break;
         case "split_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.splitNodePatch(editor, operation, previousChildren)
           ];
           break;
         case "insert_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.insertNodePatch(editor, operation, previousChildren)
           ];
           break;
         case "set_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.setNodePatch(editor, operation, previousChildren)
           ];
           break;
         case "merge_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.mergeNodePatch(editor, operation, previousChildren)
           ];
           break;
         case "move_node":
-          patches = [
-            ...patches,
+          patches$1 = [
+            ...patches$1,
             ...patchFunctions.moveNodePatch(editor, operation, previousChildren)
           ];
           break;
       }
-      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, patchEvent.unset([])], change$.next({
+      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches$1 = [...patches$1, patches.unset([])], change$.next({
         type: "unset",
         previousValue: fromSlateValue(
           previousChildren,
           schemaTypes.block.name,
           KEY_TO_VALUE_ELEMENT.get(editor)
         )
-      })), editorWasEmpty && patches.length > 0 && (patches = [patchEvent.setIfMissing([], []), ...patches]), patches.length > 0 && patches.forEach((patch) => {
+      })), editorWasEmpty && patches$1.length > 0 && (patches$1 = [patches.setIfMissing([], []), ...patches$1]), patches$1.length > 0 && patches$1.forEach((patch) => {
         change$.next({
           type: "patch",
           patch: { ...patch, origin: "local" }
@@ -2958,7 +2958,7 @@ function createWithSchemaTypes({
   keyGenerator
 }) {
   return function(editor) {
-    editor.isTextBlock = (value) => types$1.isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => types$1.isPortableTextSpan(value) && value._type == schemaTypes.span.name, editor.isListBlock = (value) => types$1.isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
+    editor.isTextBlock = (value) => types.isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => types.isPortableTextSpan(value) && value._type == schemaTypes.span.name, editor.isListBlock = (value) => types.isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
     const { normalizeNode } = editor;
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
@@ -3027,7 +3027,7 @@ const debug$7 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
   },
   custom: {}
 };
-function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
+function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions || DEFAULT_HOTKEYS;
   return function(editor) {
     return editor.pteWithHotKeys = (event) => {
@@ -3078,7 +3078,7 @@ function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
         }
       }
       if (isBackspace && editor.selection && editor.selection.focus.path[0] === 0 && slate.Range.isCollapsed(editor.selection)) {
-        const focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1)), nextPath = slate.Path.next(editor.selection.focus.path.slice(0, 1)), nextBlock = slate.Node.has(editor, nextPath), isTextBlock = types$1.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && ((_b = (_a = focusBlock.children) == null ? void 0 : _a[0]) == null ? void 0 : _b.text) === "";
+        const focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1)), nextPath = slate.Path.next(editor.selection.focus.path.slice(0, 1)), nextBlock = slate.Node.has(editor, nextPath), isTextBlock = types.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && ((_b = (_a = focusBlock.children) == null ? void 0 : _a[0]) == null ? void 0 : _b.text) === "";
         if (nextBlock && isTextBlock && isEmptyFocusBlock) {
           event.preventDefault(), event.stopPropagation(), slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), editor.onChange();
           return;
@@ -3088,7 +3088,7 @@ function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
         const prevPath = slate.Path.previous(editor.selection.focus.path.slice(0, 1)), prevBlock = slate.Node.descendant(editor, prevPath), focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
         if (prevBlock && focusBlock && slate.Editor.isVoid(editor, prevBlock) && editor.selection.focus.offset === 0) {
           debug$7("Preventing deleting void block above"), event.preventDefault(), event.stopPropagation();
-          const isTextBlock = types$1.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && ((_d = (_c = focusBlock.children) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) === "";
+          const isTextBlock = types.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && ((_d = (_c = focusBlock.children) == null ? void 0 : _c[0]) == null ? void 0 : _d.text) === "";
           if (!isTextBlock || isEmptyFocusBlock) {
             slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, prevPath), editor.onChange();
             return;
@@ -3111,10 +3111,10 @@ function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
         }
       }
       if ((isTab || isShiftTab) && editor.selection) {
-        const [focusChild] = slate.Editor.node(editor, editor.selection.focus, { depth: 2 }), [focusBlock] = types$1.isPortableTextSpan(focusChild) ? slate.Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && types$1.isPortableTextTextBlock(focusBlock) && types$1.isPortableTextSpan(focusChild) && (focusChild.marks || []).filter(
+        const [focusChild] = slate.Editor.node(editor, editor.selection.focus, { depth: 2 }), [focusBlock] = types.isPortableTextSpan(focusChild) ? slate.Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && types.isPortableTextTextBlock(focusBlock) && types.isPortableTextSpan(focusChild) && (focusChild.marks || []).filter(
           (m) => (focusBlock.markDefs || []).map((def) => def._key).includes(m)
         ).length > 0, [start] = slate.Range.edges(editor.selection), atStartOfNode = slate.Editor.isStart(editor, start, start.path);
-        focusChild && types$1.isPortableTextSpan(focusChild) && (!hasAnnotationFocus || atStartOfNode) && editor.pteIncrementBlockLevels(isShiftTab) && event.preventDefault();
+        focusChild && types.isPortableTextSpan(focusChild) && (!hasAnnotationFocus || atStartOfNode) && editor.pteIncrementBlockLevels(isShiftTab) && event.preventDefault();
       }
       if (isEnter && !isShiftEnter && editor.selection) {
         const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
@@ -3122,7 +3122,7 @@ function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
           editor.pteEndList() && event.preventDefault();
           return;
         }
-        if (editor.isTextBlock(focusBlock) && focusBlock.style && focusBlock.style !== types2.styles[0].value) {
+        if (editor.isTextBlock(focusBlock) && focusBlock.style && focusBlock.style !== types$1.styles[0].value) {
           const [, end] = slate.Range.edges(editor.selection);
           if (slate.Editor.isEnd(editor, end, end.path)) {
             slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()), event.preventDefault(), editor.onChange();
@@ -3148,13 +3148,13 @@ function createWithHotkeys(types2, portableTextEditor, hotkeysFromOptions) {
     }, editor;
   };
 }
-function validateValue(value, types2, keyGenerator) {
+function validateValue(value, types$1, keyGenerator) {
   let resolution = null, valid = !0;
-  const validChildTypes = [types2.span.name, ...types2.inlineObjects.map((t) => t.name)], validBlockTypes = [types2.block.name, ...types2.blockObjects.map((t) => t.name)];
+  const validChildTypes = [types$1.span.name, ...types$1.inlineObjects.map((t) => t.name)], validBlockTypes = [types$1.block.name, ...types$1.blockObjects.map((t) => t.name)];
   return value === void 0 ? { valid: !0, resolution: null, value } : !Array.isArray(value) || value.length === 0 ? {
     valid: !1,
     resolution: {
-      patches: [patchEvent.unset([])],
+      patches: [patches.unset([])],
       description: "Editor value must be an array of Portable Text blocks, or undefined.",
       action: "Unset the value",
       item: value,
@@ -3167,7 +3167,7 @@ function validateValue(value, types2, keyGenerator) {
   } : (value.some((blk, index) => {
     if (!isPlainObject__default.default(blk))
       return resolution = {
-        patches: [patchEvent.unset([index])],
+        patches: [patches.unset([index])],
         description: `Block must be an object, got ${String(blk)}`,
         action: "Unset invalid item",
         item: blk,
@@ -3179,7 +3179,7 @@ function validateValue(value, types2, keyGenerator) {
       }, !0;
     if (!blk._key || typeof blk._key != "string")
       return resolution = {
-        patches: [patchEvent.set({ ...blk, _key: keyGenerator() }, [index])],
+        patches: [patches.set({ ...blk, _key: keyGenerator() }, [index])],
         description: `Block at index ${index} is missing required _key.`,
         action: "Set the block with a random _key value",
         item: blk,
@@ -3191,9 +3191,9 @@ function validateValue(value, types2, keyGenerator) {
       }, !0;
     if (!blk._type || !validBlockTypes.includes(blk._type)) {
       if (blk._type === "block") {
-        const currentBlockTypeName = types2.block.name;
+        const currentBlockTypeName = types$1.block.name;
         return resolution = {
-          patches: [patchEvent.set({ ...blk, _type: currentBlockTypeName }, [{ _key: blk._key }])],
+          patches: [patches.set({ ...blk, _type: currentBlockTypeName }, [{ _key: blk._key }])],
           description: `Block with _key '${blk._key}' has invalid type name '${blk._type}'. According to the schema, the block type name is '${currentBlockTypeName}'`,
           action: `Use type '${currentBlockTypeName}'`,
           item: blk,
@@ -3204,18 +3204,18 @@ function validateValue(value, types2, keyGenerator) {
           }
         }, !0;
       }
-      return !blk._type && types$1.isPortableTextTextBlock({ ...blk, _type: types2.block.name }) ? (resolution = {
-        patches: [patchEvent.set({ ...blk, _type: types2.block.name }, [{ _key: blk._key }])],
-        description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types2.block.name}'`,
-        action: `Use type '${types2.block.name}'`,
+      return !blk._type && types.isPortableTextTextBlock({ ...blk, _type: types$1.block.name }) ? (resolution = {
+        patches: [patches.set({ ...blk, _type: types$1.block.name }, [{ _key: blk._key }])],
+        description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types$1.block.name}'`,
+        action: `Use type '${types$1.block.name}'`,
         item: blk,
         i18n: {
           description: "inputs.portable-text.invalid-value.missing-block-type.description",
           action: "inputs.portable-text.invalid-value.missing-block-type.action",
-          values: { key: blk._key, expectedTypeName: types2.block.name }
+          values: { key: blk._key, expectedTypeName: types$1.block.name }
         }
       }, !0) : blk._type ? (resolution = {
-        patches: [patchEvent.unset([{ _key: blk._key }])],
+        patches: [patches.unset([{ _key: blk._key }])],
         description: `Block with _key '${blk._key}' has invalid _type '${blk._type}'`,
         action: "Remove the block",
         item: blk,
@@ -3225,7 +3225,7 @@ function validateValue(value, types2, keyGenerator) {
           values: { key: blk._key, typeName: blk._type }
         }
       }, !0) : (resolution = {
-        patches: [patchEvent.unset([{ _key: blk._key }])],
+        patches: [patches.unset([{ _key: blk._key }])],
         description: `Block with _key '${blk._key}' is missing an _type property`,
         action: "Remove the block",
         item: blk,
@@ -3236,11 +3236,11 @@ function validateValue(value, types2, keyGenerator) {
         }
       }, !0);
     }
-    if (blk._type === types2.block.name) {
+    if (blk._type === types$1.block.name) {
       const textBlock = blk;
       if (textBlock.children && !Array.isArray(textBlock.children))
         return resolution = {
-          patches: [patchEvent.set({ children: [] }, [{ _key: textBlock._key }])],
+          patches: [patches.set({ children: [] }, [{ _key: textBlock._key }])],
           description: `Text block with _key '${textBlock._key}' has a invalid required property 'children'.`,
           action: "Reset the children property",
           item: textBlock,
@@ -3252,7 +3252,7 @@ function validateValue(value, types2, keyGenerator) {
         }, !0;
       if (textBlock.children === void 0 || Array.isArray(textBlock.children) && textBlock.children.length === 0) {
         const newSpan = {
-          _type: types2.span.name,
+          _type: types$1.span.name,
           _key: keyGenerator(),
           text: "",
           marks: []
@@ -3260,8 +3260,8 @@ function validateValue(value, types2, keyGenerator) {
         return resolution = {
           autoResolve: !0,
           patches: [
-            patchEvent.setIfMissing([], [{ _key: blk._key }, "children"]),
-            patchEvent.insert([newSpan], "after", [{ _key: blk._key }, "children", 0])
+            patches.setIfMissing([], [{ _key: blk._key }, "children"]),
+            patches.insert([newSpan], "after", [{ _key: blk._key }, "children", 0])
           ],
           description: `Children for text block with _key '${blk._key}' is empty.`,
           action: "Insert an empty text",
@@ -3275,7 +3275,7 @@ function validateValue(value, types2, keyGenerator) {
       }
       if (blk.markDefs && !Array.isArray(blk.markDefs))
         return resolution = {
-          patches: [patchEvent.set({ ...textBlock, markDefs: EMPTY_MARKDEFS }, [{ _key: textBlock._key }])],
+          patches: [patches.set({ ...textBlock, markDefs: EMPTY_MARKDEFS }, [{ _key: textBlock._key }])],
           description: "Block has invalid required property 'markDefs'.",
           action: "Add empty markDefs array",
           item: textBlock,
@@ -3287,7 +3287,7 @@ function validateValue(value, types2, keyGenerator) {
         }, !0;
       const allUsedMarks = uniq__default.default(
         flatten__default.default(
-          textBlock.children.filter((cld) => cld._type === types2.span.name).map((cld) => cld.marks || [])
+          textBlock.children.filter((cld) => cld._type === types$1.span.name).map((cld) => cld.marks || [])
         )
       );
       if (Array.isArray(blk.markDefs) && blk.markDefs.length > 0) {
@@ -3298,7 +3298,7 @@ function validateValue(value, types2, keyGenerator) {
           return resolution = {
             autoResolve: !0,
             patches: unusedMarkDefs.map(
-              (markDefKey) => patchEvent.unset([{ _key: blk._key }, "markDefs", { _key: markDefKey }])
+              (markDefKey) => patches.unset([{ _key: blk._key }, "markDefs", { _key: markDefKey }])
             ),
             description: `Block contains orphaned data (unused mark definitions): ${unusedMarkDefs.join(
               ", "
@@ -3313,19 +3313,19 @@ function validateValue(value, types2, keyGenerator) {
           }, !0;
       }
       const orphanedMarks = allUsedMarks.filter(
-        (mark) => !types2.decorators.map((dec) => dec.value).includes(mark)
+        (mark) => !types$1.decorators.map((dec) => dec.value).includes(mark)
       ).filter(
         (mark) => textBlock.markDefs === void 0 || !textBlock.markDefs.find((def) => def._key === mark)
       );
       if (orphanedMarks.length > 0) {
         const spanChildren = textBlock.children.filter(
-          (cld) => cld._type === types2.span.name && Array.isArray(cld.marks) && cld.marks.some((mark) => orphanedMarks.includes(mark))
+          (cld) => cld._type === types$1.span.name && Array.isArray(cld.marks) && cld.marks.some((mark) => orphanedMarks.includes(mark))
         );
         if (spanChildren) {
           const orphaned = orphanedMarks.join(", ");
           return resolution = {
             autoResolve: !0,
-            patches: spanChildren.map((child) => patchEvent.set(
+            patches: spanChildren.map((child) => patches.set(
               (child.marks || []).filter((cMrk) => !orphanedMarks.includes(cMrk)),
               [{ _key: blk._key }, "children", { _key: child._key }, "marks"]
             )),
@@ -3343,7 +3343,7 @@ function validateValue(value, types2, keyGenerator) {
       textBlock.children.some((child, cIndex) => {
         if (!isPlainObject__default.default(child))
           return resolution = {
-            patches: [patchEvent.unset([{ _key: blk._key }, "children", cIndex])],
+            patches: [patches.unset([{ _key: blk._key }, "children", cIndex])],
             description: `Child at index '${cIndex}' in block with key '${blk._key}' is not an object.`,
             action: "Remove the item",
             item: blk,
@@ -3357,7 +3357,7 @@ function validateValue(value, types2, keyGenerator) {
           const newChild = { ...child, _key: keyGenerator() };
           return resolution = {
             autoResolve: !0,
-            patches: [patchEvent.set(newChild, [{ _key: blk._key }, "children", cIndex])],
+            patches: [patches.set(newChild, [{ _key: blk._key }, "children", cIndex])],
             description: `Child at index ${cIndex} is missing required _key in block with _key ${blk._key}.`,
             action: "Set a new random _key on the object",
             item: blk,
@@ -3368,9 +3368,9 @@ function validateValue(value, types2, keyGenerator) {
             }
           }, !0;
         }
-        return child._type ? validChildTypes.includes(child._type) ? child._type === types2.span.name && typeof child.text != "string" ? (resolution = {
+        return child._type ? validChildTypes.includes(child._type) ? child._type === types$1.span.name && typeof child.text != "string" ? (resolution = {
           patches: [
-            patchEvent.set({ ...child, text: "" }, [{ _key: blk._key }, "children", { _key: child._key }])
+            patches.set({ ...child, text: "" }, [{ _key: blk._key }, "children", { _key: child._key }])
           ],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' has missing or invalid text property!`,
           action: "Write an empty text property to the object",
@@ -3381,7 +3381,7 @@ function validateValue(value, types2, keyGenerator) {
             values: { key: blk._key, childKey: child._key }
           }
         }, !0) : !1 : (resolution = {
-          patches: [patchEvent.unset([{ _key: blk._key }, "children", { _key: child._key }])],
+          patches: [patches.unset([{ _key: blk._key }, "children", { _key: child._key }])],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' has invalid '_type' property (${child._type}).`,
           action: "Remove the object",
           item: blk,
@@ -3391,7 +3391,7 @@ function validateValue(value, types2, keyGenerator) {
             values: { key: blk._key, childKey: child._key, childType: child._type }
           }
         }, !0) : (resolution = {
-          patches: [patchEvent.unset([{ _key: blk._key }, "children", { _key: child._key }])],
+          patches: [patches.unset([{ _key: blk._key }, "children", { _key: child._key }])],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' is missing '_type' property.`,
           action: "Remove the object",
           item: blk,
@@ -4561,12 +4561,4 @@ exports.PortableTextEditor = PortableTextEditor;
 exports.keyGenerator = defaultKeyGenerator;
 exports.usePortableTextEditor = usePortableTextEditor;
 exports.usePortableTextEditorSelection = usePortableTextEditorSelection;
-Object.keys(types).forEach(function(k) {
-  k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k) && Object.defineProperty(exports, k, {
-    enumerable: !0,
-    get: function() {
-      return types[k];
-    }
-  });
-});
 //# sourceMappingURL=index.js.map