@portabletext/editor 1.0.4 → 1.0.6

package/lib/index.js

@@ -1,10 +1,10 @@
 "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 = require("@sanity/types"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), isObject = require("lodash/isObject.js"), isString = require("lodash/isString.js"), findIndex = require("lodash/findIndex.js"), clone = require("lodash/clone.js"), omit = require("lodash/omit.js"), flatten$1 = 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");
+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 };
 }
-var isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$l), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), isObject__default = /* @__PURE__ */ _interopDefaultCompat(isObject), isString__default = /* @__PURE__ */ _interopDefaultCompat(isString), findIndex__default = /* @__PURE__ */ _interopDefaultCompat(findIndex), clone__default = /* @__PURE__ */ _interopDefaultCompat(clone), omit__default = /* @__PURE__ */ _interopDefaultCompat(omit), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten$1), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce);
+var isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$l), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce);
 const rootName = "sanity-pte:";
 debug__default.default(rootName);
 function debugWithName(name) {
@@ -701,1062 +701,240 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
-function isHighSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 55296 && charCode <= 56319;
-}
-function isLowSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 56320 && charCode <= 57343;
-}
-function cloneDiff(diff2) {
-  const [type, patch] = diff2;
-  return [type, patch];
-}
-function getCommonOverlap(textA, textB) {
-  let text1 = textA, text2 = textB;
-  const text1Length = text1.length, text2Length = text2.length;
-  if (text1Length === 0 || text2Length === 0)
-    return 0;
-  text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));
-  const textLength = Math.min(text1Length, text2Length);
-  if (text1 === text2)
-    return textLength;
-  let best = 0, length = 1;
-  for (let found = 0; found !== -1; ) {
-    const pattern = text1.substring(textLength - length);
-    if (found = text2.indexOf(pattern), found === -1)
-      return best;
-    length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);
+const debug$j = debugWithName("operationToPatches");
+debug$j.enabled = !1;
+function createOperationToPatches(types2) {
+  const textBlockName = types2.block.name;
+  function insertTextPatch(editor, operation, beforeValue) {
+    debug$j.enabled && debug$j("Operation", JSON.stringify(operation, null, 2));
+    const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
+    if (!block)
+      throw new Error("Could not find block");
+    const textChild = editor.isTextBlock(block) && editor.isTextSpan(block.children[operation.path[1]]) && block.children[operation.path[1]];
+    if (!textChild)
+      throw new Error("Could not find child");
+    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], prevBlock = beforeValue[operation.path[0]], prevChild = editor.isTextBlock(prevBlock) && prevBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevChild) ? prevChild.text : "", patch = patches.diffMatchPatch(prevText, textChild.text, path);
+    return patch.value.length ? [patch] : [];
   }
-  return best;
-}
-function getCommonPrefix(text1, text2) {
-  if (!text1 || !text2 || text1[0] !== text2[0])
-    return 0;
-  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;
-  for (; pointerMin < pointerMid; )
-    text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
-  return pointerMid;
-}
-function getCommonSuffix(text1, text2) {
-  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1])
-    return 0;
-  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;
-  for (; pointerMin < pointerMid; )
-    text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
-  return pointerMid;
-}
-function cleanupSemantic(rawDiffs) {
-  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
-  const equalities = [];
-  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
-  for (; pointer < diffs.length; )
-    diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
-  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {
-    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
-      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
-      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
-    }
-    pointer++;
+  function removeTextPatch(editor, operation, beforeValue) {
+    const block = editor && editor.children[operation.path[0]];
+    if (!block)
+      throw new Error("Could not find block");
+    const child = editor.isTextBlock(block) && block.children[operation.path[1]] || void 0, textChild = editor.isTextSpan(child) ? child : void 0;
+    if (child && !textChild)
+      throw new Error("Expected span");
+    if (!textChild)
+      throw new Error("Could not find child");
+    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], beforeBlock = beforeValue[operation.path[0]], prevTextChild = editor.isTextBlock(beforeBlock) && beforeBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevTextChild) && prevTextChild.text, patch = patches.diffMatchPatch(prevText || "", textChild.text, path);
+    return patch.value ? [patch] : [];
   }
-  return diffs;
-}
-const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
-function cleanupSemanticLossless(rawDiffs) {
-  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-  function diffCleanupSemanticScore(one, two) {
-    if (!one || !two)
-      return 6;
-    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
-    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
+  function setNodePatch(editor, operation) {
+    if (operation.path.length === 1) {
+      const block = editor.children[operation.path[0]];
+      if (typeof block._key != "string")
+        throw new Error("Expected block to have a _key");
+      const setNode = omitBy__default.default(
+        { ...editor.children[operation.path[0]], ...operation.newProperties },
+        isUndefined__default.default
+      );
+      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$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$1.push(
+                patches.set(val, [{ _key: blockKey }, "children", block.children.indexOf(child), keyName])
+              );
+            } else {
+              const val = get__default.default(operation.newProperties, keyName);
+              patches$1.push(patches.set(val, [{ _key: blockKey }, "children", { _key: childKey }, keyName]));
+            }
+          }), patches$1;
+        }
+        throw new Error("Could not find a valid child");
+      }
+      throw new Error("Could not find a valid block");
+    } else
+      throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
   }
-  let pointer = 1;
-  for (; pointer < diffs.length - 1; ) {
-    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
-      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];
-      const commonOffset = getCommonSuffix(equality1, edit);
-      if (commonOffset) {
-        const commonString = edit.substring(edit.length - commonOffset);
-        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
+  function insertNodePatch(editor, operation, beforeValue) {
+    const block = beforeValue[operation.path[0]], isTextBlock = editor.isTextBlock(block);
+    if (operation.path.length === 1) {
+      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block == null ? void 0 : block._key : beforeBlock == null ? void 0 : beforeBlock._key;
+      return targetKey ? [
+        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], position, [
+          { _key: targetKey }
+        ])
+      ] : [
+        patches.setIfMissing(beforeValue, []),
+        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [
+          operation.path[0]
+        ])
+      ];
+    } else if (isTextBlock && operation.path.length === 2 && editor.children[operation.path[0]]) {
+      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = { ...operation.node };
+      !node._type && slate.Text.isText(node) && (node._type = "span", node.marks = []);
+      const child = fromSlateValue(
+        [
+          {
+            _key: "bogus",
+            _type: textBlockName,
+            children: [node]
+          }
+        ],
+        textBlockName
+      )[0].children[0];
+      return [
+        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 }
+        ])
+      ];
+    }
+    return debug$j("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]];
+    if (!editor.isTextBlock(splitBlock))
+      throw new Error(
+        `Block with path ${JSON.stringify(
+          operation.path[0]
+        )} is not a text block and can't be split`
+      );
+    if (operation.path.length === 1) {
+      const oldBlock = beforeValue[operation.path[0]];
+      if (editor.isTextBlock(oldBlock)) {
+        const targetValue = fromSlateValue(
+          [editor.children[operation.path[0] + 1]],
+          textBlockName
+        )[0];
+        targetValue && (patches$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$1.push(patches.unset(path));
+        }));
       }
-      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-      for (; edit.charAt(0) === equality2.charAt(0); ) {
-        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
-        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
-        score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
+      return patches$1;
+    }
+    if (operation.path.length === 2) {
+      const splitSpan = splitBlock.children[operation.path[1]];
+      if (editor.isTextSpan(splitSpan)) {
+        const targetSpans = fromSlateValue(
+          [
+            {
+              ...splitBlock,
+              children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
+            }
+          ],
+          textBlockName
+        )[0].children;
+        patches$1.push(
+          patches.insert(targetSpans, "after", [
+            { _key: splitBlock._key },
+            "children",
+            { _key: splitSpan._key }
+          ])
+        ), patches$1.push(
+          patches.set(splitSpan.text, [
+            { _key: splitBlock._key },
+            "children",
+            { _key: splitSpan._key },
+            "text"
+          ])
+        );
       }
-      diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
+      return patches$1;
     }
-    pointer++;
+    return patches$1;
   }
-  return diffs;
-}
-function cleanupMerge(rawDiffs) {
-  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
-  diffs.push([DIFF_EQUAL, ""]);
-  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
-  for (; pointer < diffs.length; )
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        countInsert++, textInsert += diffs[pointer][1], pointer++;
-        break;
-      case DIFF_DELETE:
-        countDelete++, textDelete += diffs[pointer][1], pointer++;
-        break;
-      case DIFF_EQUAL:
-        countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
-        break;
-      default:
-        throw new Error("Unknown diff operation");
+  function removeNodePatch(editor, operation, beforeValue) {
+    const block = beforeValue[operation.path[0]];
+    if (operation.path.length === 1) {
+      if (block && 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 ? [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$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$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$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$1;
+  }
+  function moveNodePatch(editor, operation, beforeValue) {
+    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$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$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 }
+        ])
+      );
     }
-  diffs[diffs.length - 1][1] === "" && diffs.pop();
-  let hasChanges = !1;
-  for (pointer = 1; pointer < diffs.length - 1; )
-    diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;
-  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
-}
-function trueCount() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)
-    args[_key] = arguments[_key];
-  return args.reduce((n, bool) => n + (bool ? 1 : 0), 0);
-}
-function cleanupEfficiency(rawDiffs) {
-  let editCost = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 4, diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
-  const equalities = [];
-  let equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;
-  for (; pointer < diffs.length; )
-    diffs[pointer][0] === DIFF_EQUAL ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === DIFF_DELETE ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;
-  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
-}
-function bisect(text1, text2, deadline) {
-  const text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = new Array(vLength), v2 = new Array(vLength);
-  for (let x = 0; x < vLength; x++)
-    v1[x] = -1, v2[x] = -1;
-  v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;
-  const delta = text1Length - text2Length, front = delta % 2 !== 0;
-  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
-  for (let d = 0; d < maxD && !(Date.now() > deadline); d++) {
-    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
-      const k1Offset = vOffset + k1;
-      let x1;
-      k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? x1 = v1[k1Offset + 1] : x1 = v1[k1Offset - 1] + 1;
-      let y1 = x1 - k1;
-      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); )
-        x1++, y1++;
-      if (v1[k1Offset] = x1, x1 > text1Length)
-        k1end += 2;
-      else if (y1 > text2Length)
-        k1start += 2;
-      else if (front) {
-        const k2Offset = vOffset + delta - k1;
-        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
-          const x2 = text1Length - v2[k2Offset];
-          if (x1 >= x2)
-            return bisectSplit(text1, text2, x1, y1, deadline);
-        }
-      }
-    }
-    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
-      const k2Offset = vOffset + k2;
-      let x2;
-      k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? x2 = v2[k2Offset + 1] : x2 = v2[k2Offset - 1] + 1;
-      let y2 = x2 - k2;
-      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); )
-        x2++, y2++;
-      if (v2[k2Offset] = x2, x2 > text1Length)
-        k2end += 2;
-      else if (y2 > text2Length)
-        k2start += 2;
-      else if (!front) {
-        const k1Offset = vOffset + delta - k2;
-        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
-          const x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;
-          if (x2 = text1Length - x2, x1 >= x2)
-            return bisectSplit(text1, text2, x1, y1, deadline);
-        }
-      }
-    }
-  }
-  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
-}
-function bisectSplit(text1, text2, x, y, deadline) {
-  const text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = doDiff(text1a, text2a, {
-    checkLines: !1,
-    deadline
-  }), diffsb = doDiff(text1b, text2b, {
-    checkLines: !1,
-    deadline
-  });
-  return diffs.concat(diffsb);
-}
-function findHalfMatch(text1, text2) {
-  if ((arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1) <= 0)
-    return null;
-  const longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;
-  if (longText.length < 4 || shortText.length * 2 < longText.length)
-    return null;
-  const halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2));
-  let halfMatch;
-  if (halfMatch1 && halfMatch2)
-    halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
-  else {
-    if (!halfMatch1 && !halfMatch2)
-      return null;
-    halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;
-  }
-  if (!halfMatch)
-    throw new Error("Unable to find a half match.");
-  let text1A, text1B, text2A, text2B;
-  text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);
-  const midCommon = halfMatch[4];
-  return [text1A, text1B, text2A, text2B, midCommon];
-}
-function halfMatchI(longText, shortText, i) {
-  const seed = longText.slice(i, i + Math.floor(longText.length / 4));
-  let j = -1, bestCommon = "", bestLongTextA, bestLongTextB, bestShortTextA, bestShortTextB;
-  for (; (j = shortText.indexOf(seed, j + 1)) !== -1; ) {
-    const prefixLength = getCommonPrefix(longText.slice(i), shortText.slice(j)), suffixLength = getCommonSuffix(longText.slice(0, i), shortText.slice(0, j));
-    bestCommon.length < suffixLength + prefixLength && (bestCommon = shortText.slice(j - suffixLength, j) + shortText.slice(j, j + prefixLength), bestLongTextA = longText.slice(0, i - suffixLength), bestLongTextB = longText.slice(i + prefixLength), bestShortTextA = shortText.slice(0, j - suffixLength), bestShortTextB = shortText.slice(j + prefixLength));
-  }
-  return bestCommon.length * 2 >= longText.length ? [bestLongTextA || "", bestLongTextB || "", bestShortTextA || "", bestShortTextB || "", bestCommon || ""] : null;
-}
-function charsToLines(diffs, lineArray) {
-  for (let x = 0; x < diffs.length; x++) {
-    const chars = diffs[x][1], text = [];
-    for (let y = 0; y < chars.length; y++)
-      text[y] = lineArray[chars.charCodeAt(y)];
-    diffs[x][1] = text.join("");
-  }
-}
-function linesToChars(textA, textB) {
-  const lineArray = [], lineHash = {};
-  lineArray[0] = "";
-  function diffLinesToMunge(text) {
-    let chars = "", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length;
-    for (; lineEnd < text.length - 1; ) {
-      lineEnd = text.indexOf(`
-`, lineStart), lineEnd === -1 && (lineEnd = text.length - 1);
-      let line = text.slice(lineStart, lineEnd + 1);
-      (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : lineHash[line] !== void 0) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength === maxLines && (line = text.slice(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;
-    }
-    return chars;
+    return patches$1;
   }
-  let maxLines = 4e4;
-  const chars1 = diffLinesToMunge(textA);
-  maxLines = 65535;
-  const chars2 = diffLinesToMunge(textB);
   return {
-    chars1,
-    chars2,
-    lineArray
+    insertNodePatch,
+    insertTextPatch,
+    mergeNodePatch,
+    moveNodePatch,
+    removeNodePatch,
+    removeTextPatch,
+    setNodePatch,
+    splitNodePatch
   };
 }
-function doLineModeDiff(textA, textB, opts) {
-  let text1 = textA, text2 = textB;
-  const a = linesToChars(text1, text2);
-  text1 = a.chars1, text2 = a.chars2;
-  const linearray = a.lineArray;
-  let diffs = doDiff(text1, text2, {
-    checkLines: !1,
-    deadline: opts.deadline
-  });
-  charsToLines(diffs, linearray), diffs = cleanupSemantic(diffs), diffs.push([DIFF_EQUAL, ""]);
-  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "";
-  for (; pointer < diffs.length; ) {
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        countInsert++, textInsert += diffs[pointer][1];
-        break;
-      case DIFF_DELETE:
-        countDelete++, textDelete += diffs[pointer][1];
-        break;
-      case DIFF_EQUAL:
-        if (countDelete >= 1 && countInsert >= 1) {
-          diffs.splice(pointer - countDelete - countInsert, countDelete + countInsert), pointer = pointer - countDelete - countInsert;
-          const aa = doDiff(textDelete, textInsert, {
-            checkLines: !1,
-            deadline: opts.deadline
-          });
-          for (let j = aa.length - 1; j >= 0; j--)
-            diffs.splice(pointer, 0, aa[j]);
-          pointer += aa.length;
-        }
-        countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
-        break;
-      default:
-        throw new Error("Unknown diff operation.");
-    }
-    pointer++;
-  }
-  return diffs.pop(), diffs;
-}
-function computeDiff(text1, text2, opts) {
-  let diffs;
-  if (!text1)
-    return [[DIFF_INSERT, text2]];
-  if (!text2)
-    return [[DIFF_DELETE, text1]];
-  const longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
-  if (i !== -1)
-    return diffs = [[DIFF_INSERT, longtext.substring(0, i)], [DIFF_EQUAL, shorttext], [DIFF_INSERT, longtext.substring(i + shorttext.length)]], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;
-  if (shorttext.length === 1)
-    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
-  const halfMatch = findHalfMatch(text1, text2);
-  if (halfMatch) {
-    const text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);
-    return diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);
-  }
-  return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
-}
-const DIFF_DELETE = -1, DIFF_INSERT = 1, DIFF_EQUAL = 0;
-function diff(textA, textB, opts) {
-  if (textA === null || textB === null)
-    throw new Error("Null input. (diff)");
-  const diffs = doDiff(textA, textB, createInternalOpts(opts || {}));
-  return adjustDiffForSurrogatePairs(diffs), diffs;
-}
-function doDiff(textA, textB, options) {
-  let text1 = textA, text2 = textB;
-  if (text1 === text2)
-    return text1 ? [[DIFF_EQUAL, text1]] : [];
-  let commonlength = getCommonPrefix(text1, text2);
-  const commonprefix = text1.substring(0, commonlength);
-  text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);
-  const commonsuffix = text1.substring(text1.length - commonlength);
-  text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);
-  let diffs = computeDiff(text1, text2, options);
-  return commonprefix && diffs.unshift([DIFF_EQUAL, commonprefix]), commonsuffix && diffs.push([DIFF_EQUAL, commonsuffix]), diffs = cleanupMerge(diffs), diffs;
-}
-function createDeadLine(timeout) {
-  let t = 1;
-  return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
-}
-function createInternalOpts(opts) {
-  return {
-    checkLines: !0,
-    deadline: createDeadLine(opts.timeout || 1),
-    ...opts
-  };
-}
-function combineChar(data, char, dir) {
-  return dir === 1 ? data + char : char + data;
-}
-function splitChar(data, dir) {
-  return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];
-}
-function hasSharedChar(diffs, i, j, dir) {
-  return dir === 1 ? diffs[i][1][diffs[i][1].length - 1] === diffs[j][1][diffs[j][1].length - 1] : diffs[i][1][0] === diffs[j][1][0];
-}
-function deisolateChar(diffs, i, dir) {
-  const inv = dir === 1 ? -1 : 1;
-  let insertIdx = null, deleteIdx = null, j = i + dir;
-  for (; j >= 0 && j < diffs.length && (insertIdx === null || deleteIdx === null); j += dir) {
-    const [op, text2] = diffs[j];
-    if (text2.length !== 0) {
-      if (op === DIFF_INSERT) {
-        insertIdx === null && (insertIdx = j);
-        continue;
-      } else if (op === DIFF_DELETE) {
-        deleteIdx === null && (deleteIdx = j);
-        continue;
-      } else if (op === DIFF_EQUAL) {
-        if (insertIdx === null && deleteIdx === null) {
-          const [rest, char2] = splitChar(diffs[i][1], dir);
-          diffs[i][1] = rest, diffs[j][1] = combineChar(diffs[j][1], char2, inv);
-          return;
-        }
-        break;
-      }
-    }
-  }
-  if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
-    const [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
-    diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
-    return;
-  }
-  const [text, char] = splitChar(diffs[i][1], dir);
-  diffs[i][1] = text, insertIdx === null ? (diffs.splice(j, 0, [DIFF_INSERT, char]), deleteIdx !== null && deleteIdx >= j && deleteIdx++) : diffs[insertIdx][1] = combineChar(diffs[insertIdx][1], char, inv), deleteIdx === null ? diffs.splice(j, 0, [DIFF_DELETE, char]) : diffs[deleteIdx][1] = combineChar(diffs[deleteIdx][1], char, inv);
-}
-function adjustDiffForSurrogatePairs(diffs) {
-  for (let i = 0; i < diffs.length; i++) {
-    const [diffType, diffText] = diffs[i];
-    if (diffText.length === 0) continue;
-    const firstChar = diffText[0], lastChar = diffText[diffText.length - 1];
-    isHighSurrogate(lastChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, -1);
-  }
-  for (let i = 0; i < diffs.length; i++)
-    diffs[i][1].length === 0 && diffs.splice(i, 1);
-}
-const DEFAULT_OPTIONS = {
-  /**
-   * At what point is no match declared (0.0 = perfection, 1.0 = very loose).
-   */
-  threshold: 0.5,
-  /**
-   * How far to search for a match (0 = exact location, 1000+ = broad match).
-   * A match this many characters away from the expected location will add
-   * 1.0 to the score (0.0 is a perfect match).
-   */
-  distance: 1e3
-};
-function applyDefaults(options) {
-  return {
-    ...DEFAULT_OPTIONS,
-    ...options
-  };
-}
-const MAX_BITS$1 = 32;
-function bitap(text, pattern, loc) {
-  let opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
-  if (pattern.length > MAX_BITS$1)
-    throw new Error("Pattern too long for this browser.");
-  const options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);
-  function getBitapScore(e, x) {
-    const accuracy = e / pattern.length, proximity = Math.abs(loc - x);
-    return options.distance ? accuracy + proximity / options.distance : proximity ? 1 : accuracy;
-  }
-  let scoreThreshold = options.threshold, bestLoc = text.indexOf(pattern, loc);
-  bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold), bestLoc = text.lastIndexOf(pattern, loc + pattern.length), bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold)));
-  const matchmask = 1 << pattern.length - 1;
-  bestLoc = -1;
-  let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];
-  for (let d = 0; d < pattern.length; d++) {
-    for (binMin = 0, binMid = binMax; binMin < binMid; )
-      getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
-    binMax = binMid;
-    let start = Math.max(1, loc - binMid + 1);
-    const finish = Math.min(loc + binMid, text.length) + pattern.length, rd = new Array(finish + 2);
-    rd[finish + 1] = (1 << d) - 1;
-    for (let j = finish; j >= start; j--) {
-      const charMatch = s[text.charAt(j - 1)];
-      if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | ((lastRd[j + 1] | lastRd[j]) << 1 | 1) | lastRd[j + 1], rd[j] & matchmask) {
-        const score = getBitapScore(d, j - 1);
-        if (score <= scoreThreshold)
-          if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc)
-            start = Math.max(1, 2 * loc - bestLoc);
-          else
-            break;
-      }
-    }
-    if (getBitapScore(d + 1, loc) > scoreThreshold)
-      break;
-    lastRd = rd;
-  }
-  return bestLoc;
-}
-function getAlphabetFromPattern(pattern) {
-  const s = {};
-  for (let i = 0; i < pattern.length; i++)
-    s[pattern.charAt(i)] = 0;
-  for (let i = 0; i < pattern.length; i++)
-    s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
-  return s;
-}
-function match(text, pattern, searchLocation) {
-  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);
-}
-function createPatchObject(start1, start2) {
-  return {
-    diffs: [],
-    start1,
-    start2,
-    utf8Start1: start1,
-    utf8Start2: start2,
-    length1: 0,
-    length2: 0,
-    utf8Length1: 0,
-    utf8Length2: 0
-  };
-}
-function diffText1(diffs) {
-  const text = [];
-  for (let x = 0; x < diffs.length; x++)
-    diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);
-  return text.join("");
-}
-function diffText2(diffs) {
-  const text = [];
-  for (let x = 0; x < diffs.length; x++)
-    diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);
-  return text.join("");
-}
-function countUtf8Bytes(str) {
-  let bytes = 0;
-  for (let i = 0; i < str.length; i++) {
-    const codePoint = str.codePointAt(i);
-    if (typeof codePoint > "u")
-      throw new Error("Failed to get codepoint");
-    bytes += utf8len(codePoint);
-  }
-  return bytes;
-}
-function adjustIndiciesToUcs2(patches, base) {
-  let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, byteOffset = 0, idx = 0;
-  function advanceTo(target) {
-    for (; byteOffset < target; ) {
-      const codePoint = base.codePointAt(idx);
-      if (typeof codePoint > "u")
-        return idx;
-      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;
-    }
-    if (!options.allowExceedingIndices && byteOffset !== target)
-      throw new Error("Failed to determine byte offset");
-    return idx;
-  }
-  const adjusted = [];
-  for (const patch of patches)
-    adjusted.push({
-      diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
-      start1: advanceTo(patch.start1),
-      start2: advanceTo(patch.start2),
-      utf8Start1: patch.utf8Start1,
-      utf8Start2: patch.utf8Start2,
-      length1: patch.length1,
-      length2: patch.length2,
-      utf8Length1: patch.utf8Length1,
-      utf8Length2: patch.utf8Length2
-    });
-  return adjusted;
-}
-function utf8len(codePoint) {
-  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
-}
-const MAX_BITS = 32, DEFAULT_MARGIN = 4, DEFAULT_OPTS = {
-  margin: 4
-};
-function getDefaultOpts() {
-  let opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
-  return {
-    ...DEFAULT_OPTS,
-    ...opts
-  };
-}
-function make(a, b, options) {
-  if (typeof a == "string" && typeof b == "string") {
-    let diffs = diff(a, b, {
-      checkLines: !0
-    });
-    return diffs.length > 2 && (diffs = cleanupSemantic(diffs), diffs = cleanupEfficiency(diffs)), _make(a, diffs, getDefaultOpts(options));
-  }
-  if (a && Array.isArray(a) && typeof b > "u")
-    return _make(diffText1(a), a, getDefaultOpts(options));
-  if (typeof a == "string" && b && Array.isArray(b))
-    return _make(a, b, getDefaultOpts(options));
-  throw new Error("Unknown call format to make()");
-}
-function _make(textA, diffs, options) {
-  if (diffs.length === 0)
-    return [];
-  const patches = [];
-  let patch = createPatchObject(0, 0), patchDiffLength = 0, charCount1 = 0, charCount2 = 0, utf8Count1 = 0, utf8Count2 = 0, prepatchText = textA, postpatchText = textA;
-  for (let x = 0; x < diffs.length; x++) {
-    const currentDiff = diffs[x], [diffType, diffText] = currentDiff, diffTextLength = diffText.length, diffByteLength = countUtf8Bytes(diffText);
-    switch (!patchDiffLength && diffType !== DIFF_EQUAL && (patch.start1 = charCount1, patch.start2 = charCount2, patch.utf8Start1 = utf8Count1, patch.utf8Start2 = utf8Count2), diffType) {
-      case DIFF_INSERT:
-        patch.diffs[patchDiffLength++] = currentDiff, patch.length2 += diffTextLength, patch.utf8Length2 += diffByteLength, postpatchText = postpatchText.substring(0, charCount2) + diffText + postpatchText.substring(charCount2);
-        break;
-      case DIFF_DELETE:
-        patch.length1 += diffTextLength, patch.utf8Length1 += diffByteLength, patch.diffs[patchDiffLength++] = currentDiff, postpatchText = postpatchText.substring(0, charCount2) + postpatchText.substring(charCount2 + diffTextLength);
-        break;
-      case DIFF_EQUAL:
-        diffTextLength <= 2 * options.margin && patchDiffLength && diffs.length !== x + 1 ? (patch.diffs[patchDiffLength++] = currentDiff, patch.length1 += diffTextLength, patch.length2 += diffTextLength, patch.utf8Length1 += diffByteLength, patch.utf8Length2 += diffByteLength) : diffTextLength >= 2 * options.margin && patchDiffLength && (addContext(patch, prepatchText, options), patches.push(patch), patch = createPatchObject(-1, -1), patchDiffLength = 0, prepatchText = postpatchText, charCount1 = charCount2, utf8Count1 = utf8Count2);
-        break;
-      default:
-        throw new Error("Unknown diff type");
-    }
-    diffType !== DIFF_INSERT && (charCount1 += diffTextLength, utf8Count1 += diffByteLength), diffType !== DIFF_DELETE && (charCount2 += diffTextLength, utf8Count2 += diffByteLength);
-  }
-  return patchDiffLength && (addContext(patch, prepatchText, options), patches.push(patch)), patches;
-}
-function addContext(patch, text, opts) {
-  if (text.length === 0)
-    return;
-  let pattern = text.substring(patch.start2, patch.start2 + patch.length1), padding = 0;
-  for (; text.indexOf(pattern) !== text.lastIndexOf(pattern) && pattern.length < MAX_BITS - opts.margin - opts.margin; )
-    padding += opts.margin, pattern = text.substring(patch.start2 - padding, patch.start2 + patch.length1 + padding);
-  padding += opts.margin;
-  let prefixStart = patch.start2 - padding;
-  prefixStart >= 1 && isLowSurrogate(text[prefixStart]) && prefixStart--;
-  const prefix = text.substring(prefixStart, patch.start2);
-  prefix && patch.diffs.unshift([DIFF_EQUAL, prefix]);
-  const prefixLength = prefix.length, prefixUtf8Length = countUtf8Bytes(prefix);
-  let suffixEnd = patch.start2 + patch.length1 + padding;
-  suffixEnd < text.length && isLowSurrogate(text[suffixEnd]) && suffixEnd++;
-  const suffix = text.substring(patch.start2 + patch.length1, suffixEnd);
-  suffix && patch.diffs.push([DIFF_EQUAL, suffix]);
-  const suffixLength = suffix.length, suffixUtf8Length = countUtf8Bytes(suffix);
-  patch.start1 -= prefixLength, patch.start2 -= prefixLength, patch.utf8Start1 -= prefixUtf8Length, patch.utf8Start2 -= prefixUtf8Length, patch.length1 += prefixLength + suffixLength, patch.length2 += prefixLength + suffixLength, patch.utf8Length1 += prefixUtf8Length + suffixUtf8Length, patch.utf8Length2 += prefixUtf8Length + suffixUtf8Length;
-}
-function levenshtein(diffs) {
-  let leven = 0, insertions = 0, deletions = 0;
-  for (let x = 0; x < diffs.length; x++) {
-    const op = diffs[x][0], data = diffs[x][1];
-    switch (op) {
-      case DIFF_INSERT:
-        insertions += data.length;
-        break;
-      case DIFF_DELETE:
-        deletions += data.length;
-        break;
-      case DIFF_EQUAL:
-        leven += Math.max(insertions, deletions), insertions = 0, deletions = 0;
-        break;
-      default:
-        throw new Error("Unknown diff operation.");
-    }
-  }
-  return leven += Math.max(insertions, deletions), leven;
-}
-function xIndex(diffs, loc) {
-  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);
-}
-function addPadding(patches) {
-  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)
-    p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
-  let patch = patches[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)
-    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;
-    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
-  }
-  return nullPadding;
-}
-function splitMax(patches) {
-  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)
-      continue;
-    const bigpatch = patches[x];
-    patches.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);
-      let empty = !0;
-      if (preContext !== "") {
-        const precontextByteCount = countUtf8Bytes(preContext);
-        patch.length1 = preContext.length, patch.utf8Length1 = precontextByteCount, patch.length2 = preContext.length, patch.utf8Length2 = precontextByteCount, patch.diffs.push([DIFF_EQUAL, preContext]);
-      }
-      for (; bigpatch.diffs.length !== 0 && patch.length1 < patchSize - margin; ) {
-        const diffType = bigpatch.diffs[0][0];
-        let diffText = bigpatch.diffs[0][1], diffTextByteCount = countUtf8Bytes(diffText);
-        if (diffType === DIFF_INSERT) {
-          patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length;
-          const diff2 = bigpatch.diffs.shift();
-          diff2 && patch.diffs.push(diff2), empty = !1;
-        } else diffType === DIFF_DELETE && patch.diffs.length === 1 && patch.diffs[0][0] === DIFF_EQUAL && diffText.length > 2 * patchSize ? (patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, empty = !1, patch.diffs.push([diffType, diffText]), bigpatch.diffs.shift()) : (diffText = diffText.substring(0, patchSize - patch.length1 - margin), diffTextByteCount = countUtf8Bytes(diffText), patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, diffType === DIFF_EQUAL ? (patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length) : empty = !1, patch.diffs.push([diffType, diffText]), diffText === bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diffText.length));
-      }
-      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);
-    }
-  }
-}
-function apply$4(patches, originalText) {
-  let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
-  if (typeof patches == "string")
-    throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
-  let text = originalText;
-  if (patches.length === 0)
-    return [text, []];
-  const parsed = adjustIndiciesToUcs2(patches, 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);
-  let delta = 0;
-  const results = [];
-  for (let x = 0; x < parsed.length; x++) {
-    const expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs);
-    let startLoc, endLoc = -1;
-    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - MAX_BITS), expectedLoc + text1.length - MAX_BITS), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1)
-      results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
-    else {
-      results[x] = !0, delta = startLoc - expectedLoc;
-      let text2;
-      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2)
-        text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
-      else {
-        let diffs = diff(text1, text2, {
-          checkLines: !1
-        });
-        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold)
-          results[x] = !1;
-        else {
-          diffs = cleanupSemanticLossless(diffs);
-          let index1 = 0, index2 = 0;
-          for (let y = 0; y < parsed[x].diffs.length; y++) {
-            const mod = parsed[x].diffs[y];
-            mod[0] !== DIFF_EQUAL && (index2 = xIndex(diffs, index1)), mod[0] === DIFF_INSERT ? text = text.substring(0, startLoc + index2) + mod[1] + text.substring(startLoc + index2) : mod[0] === DIFF_DELETE && (text = text.substring(0, startLoc + index2) + text.substring(startLoc + xIndex(diffs, index1 + mod[1].length))), mod[0] !== DIFF_DELETE && (index1 += mod[1].length);
-          }
-        }
-      }
-    }
-  }
-  return text = text.substring(nullPadding.length, text.length - nullPadding.length), [text, results];
-}
-function stringify(patches) {
-  return patches.map(stringifyPatch).join("");
-}
-function stringifyPatch(patch) {
-  const {
-    utf8Length1,
-    utf8Length2,
-    utf8Start1,
-    utf8Start2,
-    diffs
-  } = patch;
-  let coords1;
-  utf8Length1 === 0 ? coords1 = "".concat(utf8Start1, ",0") : utf8Length1 === 1 ? coords1 = "".concat(utf8Start1 + 1) : coords1 = "".concat(utf8Start1 + 1, ",").concat(utf8Length1);
-  let coords2;
-  utf8Length2 === 0 ? coords2 = "".concat(utf8Start2, ",0") : utf8Length2 === 1 ? coords2 = "".concat(utf8Start2 + 1) : coords2 = "".concat(utf8Start2 + 1, ",").concat(utf8Length2);
-  const text = ["@@ -".concat(coords1, " +").concat(coords2, ` @@
-`)];
-  let op;
-  for (let x = 0; x < diffs.length; x++) {
-    switch (diffs[x][0]) {
-      case DIFF_INSERT:
-        op = "+";
-        break;
-      case DIFF_DELETE:
-        op = "-";
-        break;
-      case DIFF_EQUAL:
-        op = " ";
-        break;
-      default:
-        throw new Error("Unknown patch operation.");
-    }
-    text[x + 1] = "".concat(op + encodeURI(diffs[x][1]), `
-`);
-  }
-  return text.join("").replace(/%20/g, " ");
-}
-const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
-function parse(textline) {
-  if (!textline)
-    return [];
-  const patches = [], lines = textline.split(`
-`);
-  let textPointer = 0;
-  for (; textPointer < lines.length; ) {
-    const m = lines[textPointer].match(patchHeader);
-    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; ) {
-      const currentLine = lines[textPointer], sign = currentLine.charAt(0);
-      if (sign === "@")
-        break;
-      if (sign === "") {
-        textPointer++;
-        continue;
-      }
-      let line;
-      try {
-        line = decodeURI(currentLine.slice(1));
-      } catch {
-        throw new Error("Illegal escape in parse: ".concat(currentLine));
-      }
-      const utf8Diff = countUtf8Bytes(line) - line.length;
-      if (sign === "-")
-        patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;
-      else if (sign === "+")
-        patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;
-      else if (sign === " ")
-        patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
-      else
-        throw new Error('Invalid patch mode "'.concat(sign, '" in: ').concat(line));
-      textPointer++;
-    }
-  }
-  return patches;
-}
-function toInt(num) {
-  return parseInt(num, 10);
-}
-function setIfMissing(value, path = []) {
-  return {
-    type: "setIfMissing",
-    path,
-    value
-  };
-}
-function diffMatchPatch$1(currentValue, nextValue, path = []) {
-  const patches = make(currentValue, nextValue), patch = stringify(patches);
-  return { type: "diffMatchPatch", path, value: patch };
-}
-function insert$1(items, position, path = []) {
-  return {
-    type: "insert",
-    path,
-    position,
-    items
-  };
-}
-function set(value, path = []) {
-  return { type: "set", path, value };
-}
-function unset(path = []) {
-  return { type: "unset", path };
-}
-const debug$j = debugWithName("operationToPatches");
-debug$j.enabled = !1;
-function createOperationToPatches(types2) {
-  const textBlockName = types2.block.name;
-  function insertTextPatch(editor, operation, beforeValue) {
-    debug$j.enabled && debug$j("Operation", JSON.stringify(operation, null, 2));
-    const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
-    if (!block)
-      throw new Error("Could not find block");
-    const textChild = editor.isTextBlock(block) && editor.isTextSpan(block.children[operation.path[1]]) && block.children[operation.path[1]];
-    if (!textChild)
-      throw new Error("Could not find child");
-    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], prevBlock = beforeValue[operation.path[0]], prevChild = editor.isTextBlock(prevBlock) && prevBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevChild) ? prevChild.text : "", patch = diffMatchPatch$1(prevText, textChild.text, path);
-    return patch.value.length ? [patch] : [];
-  }
-  function removeTextPatch(editor, operation, beforeValue) {
-    const block = editor && editor.children[operation.path[0]];
-    if (!block)
-      throw new Error("Could not find block");
-    const child = editor.isTextBlock(block) && block.children[operation.path[1]] || void 0, textChild = editor.isTextSpan(child) ? child : void 0;
-    if (child && !textChild)
-      throw new Error("Expected span");
-    if (!textChild)
-      throw new Error("Could not find child");
-    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], beforeBlock = beforeValue[operation.path[0]], prevTextChild = editor.isTextBlock(beforeBlock) && beforeBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevTextChild) && prevTextChild.text, patch = diffMatchPatch$1(prevText || "", textChild.text, path);
-    return patch.value ? [patch] : [];
-  }
-  function setNodePatch(editor, operation) {
-    if (operation.path.length === 1) {
-      const block = editor.children[operation.path[0]];
-      if (typeof block._key != "string")
-        throw new Error("Expected block to have a _key");
-      const setNode = omitBy__default.default(
-        { ...editor.children[operation.path[0]], ...operation.newProperties },
-        isUndefined__default.default
-      );
-      return [set(fromSlateValue([setNode], textBlockName)[0], [{ _key: block._key }])];
-    } else if (operation.path.length === 2) {
-      const block = editor.children[operation.path[0]];
-      if (editor.isTextBlock(block)) {
-        const child = block.children[operation.path[1]];
-        if (child) {
-          const blockKey = block._key, childKey = child._key, patches = [], keys = Object.keys(operation.newProperties);
-          return keys.forEach((keyName) => {
-            if (keys.length === 1 && keyName === "_key") {
-              const val = get__default.default(operation.newProperties, keyName);
-              patches.push(
-                set(val, [{ _key: blockKey }, "children", block.children.indexOf(child), keyName])
-              );
-            } else {
-              const val = get__default.default(operation.newProperties, keyName);
-              patches.push(set(val, [{ _key: blockKey }, "children", { _key: childKey }, keyName]));
-            }
-          }), patches;
-        }
-        throw new Error("Could not find a valid child");
-      }
-      throw new Error("Could not find a valid block");
-    } else
-      throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
-  }
-  function insertNodePatch(editor, operation, beforeValue) {
-    const block = beforeValue[operation.path[0]], isTextBlock = editor.isTextBlock(block);
-    if (operation.path.length === 1) {
-      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block == null ? void 0 : block._key : beforeBlock == null ? void 0 : beforeBlock._key;
-      return targetKey ? [
-        insert$1([fromSlateValue([operation.node], textBlockName)[0]], position, [
-          { _key: targetKey }
-        ])
-      ] : [
-        setIfMissing(beforeValue, []),
-        insert$1([fromSlateValue([operation.node], textBlockName)[0]], "before", [
-          operation.path[0]
-        ])
-      ];
-    } else if (isTextBlock && operation.path.length === 2 && editor.children[operation.path[0]]) {
-      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = { ...operation.node };
-      !node._type && slate.Text.isText(node) && (node._type = "span", node.marks = []);
-      const child = fromSlateValue(
-        [
-          {
-            _key: "bogus",
-            _type: textBlockName,
-            children: [node]
-          }
-        ],
-        textBlockName
-      )[0].children[0];
-      return [
-        insert$1([child], position, [
-          { _key: block._key },
-          "children",
-          block.children.length <= 1 || !block.children[operation.path[1] - 1] ? 0 : { _key: block.children[operation.path[1] - 1]._key }
-        ])
-      ];
-    }
-    return debug$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]];
-    if (!editor.isTextBlock(splitBlock))
-      throw new Error(
-        `Block with path ${JSON.stringify(
-          operation.path[0]
-        )} is not a text block and can't be split`
-      );
-    if (operation.path.length === 1) {
-      const oldBlock = beforeValue[operation.path[0]];
-      if (editor.isTextBlock(oldBlock)) {
-        const targetValue = fromSlateValue(
-          [editor.children[operation.path[0] + 1]],
-          textBlockName
-        )[0];
-        targetValue && (patches.push(insert$1([targetValue], "after", [{ _key: splitBlock._key }])), oldBlock.children.slice(operation.position).forEach((span) => {
-          const path = [{ _key: oldBlock._key }, "children", { _key: span._key }];
-          patches.push(unset(path));
-        }));
-      }
-      return patches;
-    }
-    if (operation.path.length === 2) {
-      const splitSpan = splitBlock.children[operation.path[1]];
-      if (editor.isTextSpan(splitSpan)) {
-        const targetSpans = fromSlateValue(
-          [
-            {
-              ...splitBlock,
-              children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
-            }
-          ],
-          textBlockName
-        )[0].children;
-        patches.push(
-          insert$1(targetSpans, "after", [
-            { _key: splitBlock._key },
-            "children",
-            { _key: splitSpan._key }
-          ])
-        ), patches.push(
-          set(splitSpan.text, [
-            { _key: splitBlock._key },
-            "children",
-            { _key: splitSpan._key },
-            "text"
-          ])
-        );
-      }
-      return patches;
-    }
-    return patches;
-  }
-  function removeNodePatch(editor, operation, beforeValue) {
-    const block = beforeValue[operation.path[0]];
-    if (operation.path.length === 1) {
-      if (block && block._key)
-        return [unset([{ _key: block._key }])];
-      throw new Error("Block not found");
-    } else if (editor.isTextBlock(block) && operation.path.length === 2) {
-      const spanToRemove = editor.isTextBlock(block) && block.children && block.children[operation.path[1]];
-      return spanToRemove ? [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]];
-    if (operation.path.length === 1)
-      if (block != null && block._key) {
-        const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
-        patches.push(set(newBlock, [{ _key: newBlock._key }])), patches.push(unset([{ _key: block._key }]));
-      } else
-        throw new Error("Target key not found!");
-    else if (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(
-        set(targetSpan.text, [{ _key: block._key }, "children", { _key: targetSpan._key }, "text"])
-      ), mergedSpan && patches.push(unset([{ _key: block._key }, "children", { _key: mergedSpan._key }])));
-    } else
-      debug$j("Void nodes can't be merged, not creating any patches");
-    return patches;
-  }
-  function moveNodePatch(editor, operation, beforeValue) {
-    const patches = [], block = beforeValue[operation.path[0]], targetBlock = beforeValue[operation.newPath[0]];
-    if (operation.path.length === 1) {
-      const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
-      patches.push(unset([{ _key: block._key }])), patches.push(
-        insert$1([fromSlateValue([block], textBlockName)[0]], position, [{ _key: targetBlock._key }])
-      );
-    } else if (operation.path.length === 2 && editor.isTextBlock(block) && editor.isTextBlock(targetBlock)) {
-      const child = block.children[operation.path[1]], targetChild = targetBlock.children[operation.newPath[1]], position = operation.newPath[1] === targetBlock.children.length ? "after" : "before", childToInsert = fromSlateValue([block], textBlockName)[0].children[operation.path[1]];
-      patches.push(unset([{ _key: block._key }, "children", { _key: child._key }])), patches.push(
-        insert$1([childToInsert], position, [
-          { _key: targetBlock._key },
-          "children",
-          { _key: targetChild._key }
-        ])
-      );
-    }
-    return patches;
-  }
-  return {
-    insertNodePatch,
-    insertTextPatch,
-    mergeNodePatch,
-    moveNodePatch,
-    removeNodePatch,
-    removeTextPatch,
-    setNodePatch,
-    splitNodePatch
-  };
-}
-const debug$i = debugWithName("API:editable");
-function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
-  return function(editor) {
-    return portableTextEditor.setEditable({
-      focus: () => {
-        slateReact.ReactEditor.focus(editor);
-      },
-      blur: () => {
-        slateReact.ReactEditor.blur(editor);
-      },
-      toggleMark: (mark) => {
-        editor.pteToggleMark(mark);
-      },
-      toggleList: (listStyle) => {
-        editor.pteToggleListItem(listStyle);
-      },
-      toggleBlockStyle: (blockStyle) => {
-        editor.pteToggleBlockStyle(blockStyle);
-      },
-      isMarkActive: (mark) => {
-        try {
-          return editor.pteIsMarkActive(mark);
-        } catch (err) {
-          return console.warn(err), !1;
+const debug$i = debugWithName("API:editable");
+function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
+  return function(editor) {
+    return portableTextEditor.setEditable({
+      focus: () => {
+        slateReact.ReactEditor.focus(editor);
+      },
+      blur: () => {
+        slateReact.ReactEditor.blur(editor);
+      },
+      toggleMark: (mark) => {
+        editor.pteToggleMark(mark);
+      },
+      toggleList: (listStyle) => {
+        editor.pteToggleListItem(listStyle);
+      },
+      toggleBlockStyle: (blockStyle) => {
+        editor.pteToggleBlockStyle(blockStyle);
+      },
+      isMarkActive: (mark) => {
+        try {
+          return editor.pteIsMarkActive(mark);
+        } catch (err) {
+          return console.warn(err), !1;
         }
       },
       marks: () => ({
@@ -2059,275 +1237,803 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
             }
           }), slate.Editor.normalize(editor), editor.onChange();
         }
-      },
-      getSelection: () => {
-        let ptRange = null;
-        if (editor.selection) {
-          const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
-          if (existing)
-            return existing;
-          ptRange = toPortableTextRange(
-            fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
-            editor.selection,
-            types$1
-          ), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+      },
+      getSelection: () => {
+        let ptRange = null;
+        if (editor.selection) {
+          const existing = SLATE_TO_PORTABLE_TEXT_RANGE.get(editor.selection);
+          if (existing)
+            return existing;
+          ptRange = toPortableTextRange(
+            fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+            editor.selection,
+            types$1
+          ), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
+        }
+        return ptRange;
+      },
+      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(), 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);
+      }
+    }), editor;
+  };
+}
+function createWithInsertBreak(types2) {
+  return function(editor) {
+    const { insertBreak } = editor;
+    return editor.insertBreak = () => {
+      if (editor.selection) {
+        const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+        if (editor.isTextBlock(focusBlock)) {
+          const [, end] = slate.Range.edges(editor.selection), isEndAtStartOfNode = slate.Editor.isStart(editor, end, end.path), isEmptyTextBlock = focusBlock && isEqualToEmptyEditor([focusBlock], types2);
+          if (isEndAtStartOfNode && !isEmptyTextBlock) {
+            slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock());
+            const [nextBlockPath] = slate.Path.next(focusBlockPath);
+            slate.Transforms.select(editor, {
+              anchor: { path: [nextBlockPath, 0], offset: 0 },
+              focus: { path: [nextBlockPath, 0], offset: 0 }
+            }), editor.onChange();
+            return;
+          }
+        }
+      }
+      insertBreak();
+    }, editor;
+  };
+}
+function createWithMaxBlocks(maxBlocks) {
+  return function(editor) {
+    const { apply: apply2 } = editor;
+    return editor.apply = (operation) => {
+      const rows = maxBlocks;
+      rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
+    }, editor;
+  };
+}
+const PRESERVE_KEYS = /* @__PURE__ */ new WeakMap();
+function withPreserveKeys(editor, fn) {
+  const prev = isPreservingKeys(editor);
+  PRESERVE_KEYS.set(editor, !0), fn(), PRESERVE_KEYS.set(editor, prev);
+}
+function isPreservingKeys(editor) {
+  return PRESERVE_KEYS.get(editor);
+}
+function createWithObjectKeys(schemaTypes, keyGenerator) {
+  return function(editor) {
+    PRESERVE_KEYS.set(editor, !1);
+    const { apply: apply2, normalizeNode } = editor;
+    return editor.apply = (operation) => {
+      if (operation.type === "split_node") {
+        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.properties);
+        operation.properties = {
+          ...operation.properties,
+          ...withNewKey ? { _key: keyGenerator() } : {}
+        };
+      }
+      if (operation.type === "insert_node") {
+        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.node);
+        slate.Editor.isEditor(operation.node) || (operation.node = {
+          ...operation.node,
+          ...withNewKey ? { _key: keyGenerator() } : {}
+        });
+      }
+      apply2(operation);
+    }, editor.normalizeNode = (entry) => {
+      const [node, path] = entry;
+      if (slate.Element.isElement(node) && node._type === schemaTypes.block.name) {
+        node._key || slate.Transforms.setNodes(editor, { _key: keyGenerator() }, { at: path });
+        for (const [child, childPath] of slate.Node.children(editor, path))
+          if (!child._key) {
+            slate.Transforms.setNodes(editor, { _key: keyGenerator() }, { at: childPath });
+            return;
+          }
+      }
+      normalizeNode(entry);
+    }, editor;
+  };
+}
+function isHighSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 55296 && charCode <= 56319;
+}
+function isLowSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 56320 && charCode <= 57343;
+}
+function cloneDiff(diff2) {
+  const [type, patch] = diff2;
+  return [type, patch];
+}
+function getCommonOverlap(textA, textB) {
+  let text1 = textA, text2 = textB;
+  const text1Length = text1.length, text2Length = text2.length;
+  if (text1Length === 0 || text2Length === 0)
+    return 0;
+  text1Length > text2Length ? text1 = text1.substring(text1Length - text2Length) : text1Length < text2Length && (text2 = text2.substring(0, text1Length));
+  const textLength = Math.min(text1Length, text2Length);
+  if (text1 === text2)
+    return textLength;
+  let best = 0, length = 1;
+  for (let found = 0; found !== -1; ) {
+    const pattern = text1.substring(textLength - length);
+    if (found = text2.indexOf(pattern), found === -1)
+      return best;
+    length += found, (found === 0 || text1.substring(textLength - length) === text2.substring(0, length)) && (best = length, length++);
+  }
+  return best;
+}
+function getCommonPrefix(text1, text2) {
+  if (!text1 || !text2 || text1[0] !== text2[0])
+    return 0;
+  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerStart = 0;
+  for (; pointerMin < pointerMid; )
+    text1.substring(pointerStart, pointerMid) === text2.substring(pointerStart, pointerMid) ? (pointerMin = pointerMid, pointerStart = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  return pointerMid;
+}
+function getCommonSuffix(text1, text2) {
+  if (!text1 || !text2 || text1[text1.length - 1] !== text2[text2.length - 1])
+    return 0;
+  let pointerMin = 0, pointerMax = Math.min(text1.length, text2.length), pointerMid = pointerMax, pointerEnd = 0;
+  for (; pointerMin < pointerMid; )
+    text1.substring(text1.length - pointerMid, text1.length - pointerEnd) === text2.substring(text2.length - pointerMid, text2.length - pointerEnd) ? (pointerMin = pointerMid, pointerEnd = pointerMin) : pointerMax = pointerMid, pointerMid = Math.floor((pointerMax - pointerMin) / 2 + pointerMin);
+  return pointerMid;
+}
+function cleanupSemantic(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
+  const equalities = [];
+  let equalitiesLength = 0, lastEquality = null, pointer = 0, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0;
+  for (; pointer < diffs.length; )
+    diffs[pointer][0] === DIFF_EQUAL ? (equalities[equalitiesLength++] = pointer, lengthInsertions1 = lengthInsertions2, lengthDeletions1 = lengthDeletions2, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = diffs[pointer][1]) : (diffs[pointer][0] === DIFF_INSERT ? lengthInsertions2 += diffs[pointer][1].length : lengthDeletions2 += diffs[pointer][1].length, lastEquality && lastEquality.length <= Math.max(lengthInsertions1, lengthDeletions1) && lastEquality.length <= Math.max(lengthInsertions2, lengthDeletions2) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, lengthInsertions1 = 0, lengthDeletions1 = 0, lengthInsertions2 = 0, lengthDeletions2 = 0, lastEquality = null, hasChanges = !0)), pointer++;
+  for (hasChanges && (diffs = cleanupMerge(diffs)), diffs = cleanupSemanticLossless(diffs), pointer = 1; pointer < diffs.length; ) {
+    if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
+      const deletion = diffs[pointer - 1][1], insertion = diffs[pointer][1], overlapLength1 = getCommonOverlap(deletion, insertion), overlapLength2 = getCommonOverlap(insertion, deletion);
+      overlapLength1 >= overlapLength2 ? (overlapLength1 >= deletion.length / 2 || overlapLength1 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, insertion.substring(0, overlapLength1)]), diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlapLength1), diffs[pointer + 1][1] = insertion.substring(overlapLength1), pointer++) : (overlapLength2 >= deletion.length / 2 || overlapLength2 >= insertion.length / 2) && (diffs.splice(pointer, 0, [DIFF_EQUAL, deletion.substring(0, overlapLength2)]), diffs[pointer - 1][0] = DIFF_INSERT, diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlapLength2), diffs[pointer + 1][0] = DIFF_DELETE, diffs[pointer + 1][1] = deletion.substring(overlapLength2), pointer++), pointer++;
+    }
+    pointer++;
+  }
+  return diffs;
+}
+const nonAlphaNumericRegex = /[^a-zA-Z0-9]/, whitespaceRegex = /\s/, linebreakRegex = /[\r\n]/, blanklineEndRegex = /\n\r?\n$/, blanklineStartRegex = /^\r?\n\r?\n/;
+function cleanupSemanticLossless(rawDiffs) {
+  const diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  function diffCleanupSemanticScore(one, two) {
+    if (!one || !two)
+      return 6;
+    const char1 = one.charAt(one.length - 1), char2 = two.charAt(0), nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex), nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex), whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex), whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex), lineBreak1 = whitespace1 && char1.match(linebreakRegex), lineBreak2 = whitespace2 && char2.match(linebreakRegex), blankLine1 = lineBreak1 && one.match(blanklineEndRegex), blankLine2 = lineBreak2 && two.match(blanklineStartRegex);
+    return blankLine1 || blankLine2 ? 5 : lineBreak1 || lineBreak2 ? 4 : nonAlphaNumeric1 && !whitespace1 && whitespace2 ? 3 : whitespace1 || whitespace2 ? 2 : nonAlphaNumeric1 || nonAlphaNumeric2 ? 1 : 0;
+  }
+  let pointer = 1;
+  for (; pointer < diffs.length - 1; ) {
+    if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+      let equality1 = diffs[pointer - 1][1], edit = diffs[pointer][1], equality2 = diffs[pointer + 1][1];
+      const commonOffset = getCommonSuffix(equality1, edit);
+      if (commonOffset) {
+        const commonString = edit.substring(edit.length - commonOffset);
+        equality1 = equality1.substring(0, equality1.length - commonOffset), edit = commonString + edit.substring(0, edit.length - commonOffset), equality2 = commonString + equality2;
+      }
+      let bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2, bestScore = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+      for (; edit.charAt(0) === equality2.charAt(0); ) {
+        equality1 += edit.charAt(0), edit = edit.substring(1) + equality2.charAt(0), equality2 = equality2.substring(1);
+        const score = diffCleanupSemanticScore(equality1, edit) + diffCleanupSemanticScore(edit, equality2);
+        score >= bestScore && (bestScore = score, bestEquality1 = equality1, bestEdit = edit, bestEquality2 = equality2);
+      }
+      diffs[pointer - 1][1] !== bestEquality1 && (bestEquality1 ? diffs[pointer - 1][1] = bestEquality1 : (diffs.splice(pointer - 1, 1), pointer--), diffs[pointer][1] = bestEdit, bestEquality2 ? diffs[pointer + 1][1] = bestEquality2 : (diffs.splice(pointer + 1, 1), pointer--));
+    }
+    pointer++;
+  }
+  return diffs;
+}
+function cleanupMerge(rawDiffs) {
+  let diffs = rawDiffs.map((diff2) => cloneDiff(diff2));
+  diffs.push([DIFF_EQUAL, ""]);
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "", commonlength;
+  for (; pointer < diffs.length; )
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        countInsert++, textInsert += diffs[pointer][1], pointer++;
+        break;
+      case DIFF_DELETE:
+        countDelete++, textDelete += diffs[pointer][1], pointer++;
+        break;
+      case DIFF_EQUAL:
+        countDelete + countInsert > 1 ? (countDelete !== 0 && countInsert !== 0 && (commonlength = getCommonPrefix(textInsert, textDelete), commonlength !== 0 && (pointer - countDelete - countInsert > 0 && diffs[pointer - countDelete - countInsert - 1][0] === DIFF_EQUAL ? diffs[pointer - countDelete - countInsert - 1][1] += textInsert.substring(0, commonlength) : (diffs.splice(0, 0, [DIFF_EQUAL, textInsert.substring(0, commonlength)]), pointer++), textInsert = textInsert.substring(commonlength), textDelete = textDelete.substring(commonlength)), commonlength = getCommonSuffix(textInsert, textDelete), commonlength !== 0 && (diffs[pointer][1] = textInsert.substring(textInsert.length - commonlength) + diffs[pointer][1], textInsert = textInsert.substring(0, textInsert.length - commonlength), textDelete = textDelete.substring(0, textDelete.length - commonlength))), pointer -= countDelete + countInsert, diffs.splice(pointer, countDelete + countInsert), textDelete.length && (diffs.splice(pointer, 0, [DIFF_DELETE, textDelete]), pointer++), textInsert.length && (diffs.splice(pointer, 0, [DIFF_INSERT, textInsert]), pointer++), pointer++) : pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL ? (diffs[pointer - 1][1] += diffs[pointer][1], diffs.splice(pointer, 1)) : pointer++, countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+        break;
+      default:
+        throw new Error("Unknown diff operation");
+    }
+  diffs[diffs.length - 1][1] === "" && diffs.pop();
+  let hasChanges = !1;
+  for (pointer = 1; pointer < diffs.length - 1; )
+    diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL && (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1] ? (diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length), diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1], diffs.splice(pointer - 1, 1), hasChanges = !0) : diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1] && (diffs[pointer - 1][1] += diffs[pointer + 1][1], diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1], diffs.splice(pointer + 1, 1), hasChanges = !0)), pointer++;
+  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+}
+function trueCount() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)
+    args[_key] = arguments[_key];
+  return args.reduce((n, bool) => n + (bool ? 1 : 0), 0);
+}
+function cleanupEfficiency(rawDiffs) {
+  let editCost = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 4, diffs = rawDiffs.map((diff2) => cloneDiff(diff2)), hasChanges = !1;
+  const equalities = [];
+  let equalitiesLength = 0, lastEquality = null, pointer = 0, preIns = !1, preDel = !1, postIns = !1, postDel = !1;
+  for (; pointer < diffs.length; )
+    diffs[pointer][0] === DIFF_EQUAL ? (diffs[pointer][1].length < editCost && (postIns || postDel) ? (equalities[equalitiesLength++] = pointer, preIns = postIns, preDel = postDel, lastEquality = diffs[pointer][1]) : (equalitiesLength = 0, lastEquality = null), postIns = !1, postDel = !1) : (diffs[pointer][0] === DIFF_DELETE ? postDel = !0 : postIns = !0, lastEquality && (preIns && preDel && postIns && postDel || lastEquality.length < editCost / 2 && trueCount(preIns, preDel, postIns, postDel) === 3) && (diffs.splice(equalities[equalitiesLength - 1], 0, [DIFF_DELETE, lastEquality]), diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT, equalitiesLength--, lastEquality = null, preIns && preDel ? (postIns = !0, postDel = !0, equalitiesLength = 0) : (equalitiesLength--, pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1, postIns = !1, postDel = !1), hasChanges = !0)), pointer++;
+  return hasChanges && (diffs = cleanupMerge(diffs)), diffs;
+}
+function bisect(text1, text2, deadline) {
+  const text1Length = text1.length, text2Length = text2.length, maxD = Math.ceil((text1Length + text2Length) / 2), vOffset = maxD, vLength = 2 * maxD, v1 = new Array(vLength), v2 = new Array(vLength);
+  for (let x = 0; x < vLength; x++)
+    v1[x] = -1, v2[x] = -1;
+  v1[vOffset + 1] = 0, v2[vOffset + 1] = 0;
+  const delta = text1Length - text2Length, front = delta % 2 !== 0;
+  let k1start = 0, k1end = 0, k2start = 0, k2end = 0;
+  for (let d = 0; d < maxD && !(Date.now() > deadline); d++) {
+    for (let k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
+      const k1Offset = vOffset + k1;
+      let x1;
+      k1 === -d || k1 !== d && v1[k1Offset - 1] < v1[k1Offset + 1] ? x1 = v1[k1Offset + 1] : x1 = v1[k1Offset - 1] + 1;
+      let y1 = x1 - k1;
+      for (; x1 < text1Length && y1 < text2Length && text1.charAt(x1) === text2.charAt(y1); )
+        x1++, y1++;
+      if (v1[k1Offset] = x1, x1 > text1Length)
+        k1end += 2;
+      else if (y1 > text2Length)
+        k1start += 2;
+      else if (front) {
+        const k2Offset = vOffset + delta - k1;
+        if (k2Offset >= 0 && k2Offset < vLength && v2[k2Offset] !== -1) {
+          const x2 = text1Length - v2[k2Offset];
+          if (x1 >= x2)
+            return bisectSplit(text1, text2, x1, y1, deadline);
+        }
+      }
+    }
+    for (let k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
+      const k2Offset = vOffset + k2;
+      let x2;
+      k2 === -d || k2 !== d && v2[k2Offset - 1] < v2[k2Offset + 1] ? x2 = v2[k2Offset + 1] : x2 = v2[k2Offset - 1] + 1;
+      let y2 = x2 - k2;
+      for (; x2 < text1Length && y2 < text2Length && text1.charAt(text1Length - x2 - 1) === text2.charAt(text2Length - y2 - 1); )
+        x2++, y2++;
+      if (v2[k2Offset] = x2, x2 > text1Length)
+        k2end += 2;
+      else if (y2 > text2Length)
+        k2start += 2;
+      else if (!front) {
+        const k1Offset = vOffset + delta - k2;
+        if (k1Offset >= 0 && k1Offset < vLength && v1[k1Offset] !== -1) {
+          const x1 = v1[k1Offset], y1 = vOffset + x1 - k1Offset;
+          if (x2 = text1Length - x2, x1 >= x2)
+            return bisectSplit(text1, text2, x1, y1, deadline);
         }
-        return ptRange;
-      },
-      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(), 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);
       }
-    }), editor;
+    }
+  }
+  return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+}
+function bisectSplit(text1, text2, x, y, deadline) {
+  const text1a = text1.substring(0, x), text2a = text2.substring(0, y), text1b = text1.substring(x), text2b = text2.substring(y), diffs = doDiff(text1a, text2a, {
+    checkLines: !1,
+    deadline
+  }), diffsb = doDiff(text1b, text2b, {
+    checkLines: !1,
+    deadline
+  });
+  return diffs.concat(diffsb);
+}
+function findHalfMatch(text1, text2) {
+  if ((arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1) <= 0)
+    return null;
+  const longText = text1.length > text2.length ? text1 : text2, shortText = text1.length > text2.length ? text2 : text1;
+  if (longText.length < 4 || shortText.length * 2 < longText.length)
+    return null;
+  const halfMatch1 = halfMatchI(longText, shortText, Math.ceil(longText.length / 4)), halfMatch2 = halfMatchI(longText, shortText, Math.ceil(longText.length / 2));
+  let halfMatch;
+  if (halfMatch1 && halfMatch2)
+    halfMatch = halfMatch1[4].length > halfMatch2[4].length ? halfMatch1 : halfMatch2;
+  else {
+    if (!halfMatch1 && !halfMatch2)
+      return null;
+    halfMatch2 ? halfMatch1 || (halfMatch = halfMatch2) : halfMatch = halfMatch1;
+  }
+  if (!halfMatch)
+    throw new Error("Unable to find a half match.");
+  let text1A, text1B, text2A, text2B;
+  text1.length > text2.length ? (text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3]) : (text2A = halfMatch[0], text2B = halfMatch[1], text1A = halfMatch[2], text1B = halfMatch[3]);
+  const midCommon = halfMatch[4];
+  return [text1A, text1B, text2A, text2B, midCommon];
+}
+function halfMatchI(longText, shortText, i) {
+  const seed = longText.slice(i, i + Math.floor(longText.length / 4));
+  let j = -1, bestCommon = "", bestLongTextA, bestLongTextB, bestShortTextA, bestShortTextB;
+  for (; (j = shortText.indexOf(seed, j + 1)) !== -1; ) {
+    const prefixLength = getCommonPrefix(longText.slice(i), shortText.slice(j)), suffixLength = getCommonSuffix(longText.slice(0, i), shortText.slice(0, j));
+    bestCommon.length < suffixLength + prefixLength && (bestCommon = shortText.slice(j - suffixLength, j) + shortText.slice(j, j + prefixLength), bestLongTextA = longText.slice(0, i - suffixLength), bestLongTextB = longText.slice(i + prefixLength), bestShortTextA = shortText.slice(0, j - suffixLength), bestShortTextB = shortText.slice(j + prefixLength));
+  }
+  return bestCommon.length * 2 >= longText.length ? [bestLongTextA || "", bestLongTextB || "", bestShortTextA || "", bestShortTextB || "", bestCommon || ""] : null;
+}
+function charsToLines(diffs, lineArray) {
+  for (let x = 0; x < diffs.length; x++) {
+    const chars = diffs[x][1], text = [];
+    for (let y = 0; y < chars.length; y++)
+      text[y] = lineArray[chars.charCodeAt(y)];
+    diffs[x][1] = text.join("");
+  }
+}
+function linesToChars(textA, textB) {
+  const lineArray = [], lineHash = {};
+  lineArray[0] = "";
+  function diffLinesToMunge(text) {
+    let chars = "", lineStart = 0, lineEnd = -1, lineArrayLength = lineArray.length;
+    for (; lineEnd < text.length - 1; ) {
+      lineEnd = text.indexOf(`
+`, lineStart), lineEnd === -1 && (lineEnd = text.length - 1);
+      let line = text.slice(lineStart, lineEnd + 1);
+      (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : lineHash[line] !== void 0) ? chars += String.fromCharCode(lineHash[line]) : (lineArrayLength === maxLines && (line = text.slice(lineStart), lineEnd = text.length), chars += String.fromCharCode(lineArrayLength), lineHash[line] = lineArrayLength, lineArray[lineArrayLength++] = line), lineStart = lineEnd + 1;
+    }
+    return chars;
+  }
+  let maxLines = 4e4;
+  const chars1 = diffLinesToMunge(textA);
+  maxLines = 65535;
+  const chars2 = diffLinesToMunge(textB);
+  return {
+    chars1,
+    chars2,
+    lineArray
   };
 }
-function createWithInsertBreak(types2) {
-  return function(editor) {
-    const { insertBreak } = editor;
-    return editor.insertBreak = () => {
-      if (editor.selection) {
-        const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-        if (editor.isTextBlock(focusBlock)) {
-          const [, end] = slate.Range.edges(editor.selection), isEndAtStartOfNode = slate.Editor.isStart(editor, end, end.path), isEmptyTextBlock = focusBlock && isEqualToEmptyEditor([focusBlock], types2);
-          if (isEndAtStartOfNode && !isEmptyTextBlock) {
-            slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock());
-            const [nextBlockPath] = slate.Path.next(focusBlockPath);
-            slate.Transforms.select(editor, {
-              anchor: { path: [nextBlockPath, 0], offset: 0 },
-              focus: { path: [nextBlockPath, 0], offset: 0 }
-            }), editor.onChange();
-            return;
-          }
+function doLineModeDiff(textA, textB, opts) {
+  let text1 = textA, text2 = textB;
+  const a = linesToChars(text1, text2);
+  text1 = a.chars1, text2 = a.chars2;
+  const linearray = a.lineArray;
+  let diffs = doDiff(text1, text2, {
+    checkLines: !1,
+    deadline: opts.deadline
+  });
+  charsToLines(diffs, linearray), diffs = cleanupSemantic(diffs), diffs.push([DIFF_EQUAL, ""]);
+  let pointer = 0, countDelete = 0, countInsert = 0, textDelete = "", textInsert = "";
+  for (; pointer < diffs.length; ) {
+    switch (diffs[pointer][0]) {
+      case DIFF_INSERT:
+        countInsert++, textInsert += diffs[pointer][1];
+        break;
+      case DIFF_DELETE:
+        countDelete++, textDelete += diffs[pointer][1];
+        break;
+      case DIFF_EQUAL:
+        if (countDelete >= 1 && countInsert >= 1) {
+          diffs.splice(pointer - countDelete - countInsert, countDelete + countInsert), pointer = pointer - countDelete - countInsert;
+          const aa = doDiff(textDelete, textInsert, {
+            checkLines: !1,
+            deadline: opts.deadline
+          });
+          for (let j = aa.length - 1; j >= 0; j--)
+            diffs.splice(pointer, 0, aa[j]);
+          pointer += aa.length;
         }
-      }
-      insertBreak();
-    }, editor;
-  };
+        countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+        break;
+      default:
+        throw new Error("Unknown diff operation.");
+    }
+    pointer++;
+  }
+  return diffs.pop(), diffs;
 }
-function createWithMaxBlocks(maxBlocks) {
-  return function(editor) {
-    const { apply: apply2 } = editor;
-    return editor.apply = (operation) => {
-      const rows = maxBlocks;
-      rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
-    }, editor;
+function computeDiff(text1, text2, opts) {
+  let diffs;
+  if (!text1)
+    return [[DIFF_INSERT, text2]];
+  if (!text2)
+    return [[DIFF_DELETE, text1]];
+  const longtext = text1.length > text2.length ? text1 : text2, shorttext = text1.length > text2.length ? text2 : text1, i = longtext.indexOf(shorttext);
+  if (i !== -1)
+    return diffs = [[DIFF_INSERT, longtext.substring(0, i)], [DIFF_EQUAL, shorttext], [DIFF_INSERT, longtext.substring(i + shorttext.length)]], text1.length > text2.length && (diffs[0][0] = DIFF_DELETE, diffs[2][0] = DIFF_DELETE), diffs;
+  if (shorttext.length === 1)
+    return [[DIFF_DELETE, text1], [DIFF_INSERT, text2]];
+  const halfMatch = findHalfMatch(text1, text2);
+  if (halfMatch) {
+    const text1A = halfMatch[0], text1B = halfMatch[1], text2A = halfMatch[2], text2B = halfMatch[3], midCommon = halfMatch[4], diffsA = doDiff(text1A, text2A, opts), diffsB = doDiff(text1B, text2B, opts);
+    return diffsA.concat([[DIFF_EQUAL, midCommon]], diffsB);
+  }
+  return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
+}
+const DIFF_DELETE = -1, DIFF_INSERT = 1, DIFF_EQUAL = 0;
+function diff(textA, textB, opts) {
+  if (textA === null || textB === null)
+    throw new Error("Null input. (diff)");
+  const diffs = doDiff(textA, textB, createInternalOpts(opts || {}));
+  return adjustDiffForSurrogatePairs(diffs), diffs;
+}
+function doDiff(textA, textB, options) {
+  let text1 = textA, text2 = textB;
+  if (text1 === text2)
+    return text1 ? [[DIFF_EQUAL, text1]] : [];
+  let commonlength = getCommonPrefix(text1, text2);
+  const commonprefix = text1.substring(0, commonlength);
+  text1 = text1.substring(commonlength), text2 = text2.substring(commonlength), commonlength = getCommonSuffix(text1, text2);
+  const commonsuffix = text1.substring(text1.length - commonlength);
+  text1 = text1.substring(0, text1.length - commonlength), text2 = text2.substring(0, text2.length - commonlength);
+  let diffs = computeDiff(text1, text2, options);
+  return commonprefix && diffs.unshift([DIFF_EQUAL, commonprefix]), commonsuffix && diffs.push([DIFF_EQUAL, commonsuffix]), diffs = cleanupMerge(diffs), diffs;
+}
+function createDeadLine(timeout) {
+  let t = 1;
+  return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
+}
+function createInternalOpts(opts) {
+  return {
+    checkLines: !0,
+    deadline: createDeadLine(opts.timeout || 1),
+    ...opts
   };
 }
-const PRESERVE_KEYS = /* @__PURE__ */ new WeakMap();
-function withPreserveKeys(editor, fn) {
-  const prev = isPreservingKeys(editor);
-  PRESERVE_KEYS.set(editor, !0), fn(), PRESERVE_KEYS.set(editor, prev);
+function combineChar(data, char, dir) {
+  return dir === 1 ? data + char : char + data;
 }
-function isPreservingKeys(editor) {
-  return PRESERVE_KEYS.get(editor);
+function splitChar(data, dir) {
+  return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];
 }
-function createWithObjectKeys(schemaTypes, keyGenerator) {
-  return function(editor) {
-    PRESERVE_KEYS.set(editor, !1);
-    const { apply: apply2, normalizeNode } = editor;
-    return editor.apply = (operation) => {
-      if (operation.type === "split_node") {
-        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.properties);
-        operation.properties = {
-          ...operation.properties,
-          ...withNewKey ? { _key: keyGenerator() } : {}
-        };
-      }
-      if (operation.type === "insert_node") {
-        const withNewKey = !isPreservingKeys(editor) || !("_key" in operation.node);
-        slate.Editor.isEditor(operation.node) || (operation.node = {
-          ...operation.node,
-          ...withNewKey ? { _key: keyGenerator() } : {}
-        });
+function hasSharedChar(diffs, i, j, dir) {
+  return dir === 1 ? diffs[i][1][diffs[i][1].length - 1] === diffs[j][1][diffs[j][1].length - 1] : diffs[i][1][0] === diffs[j][1][0];
+}
+function deisolateChar(diffs, i, dir) {
+  const inv = dir === 1 ? -1 : 1;
+  let insertIdx = null, deleteIdx = null, j = i + dir;
+  for (; j >= 0 && j < diffs.length && (insertIdx === null || deleteIdx === null); j += dir) {
+    const [op, text2] = diffs[j];
+    if (text2.length !== 0) {
+      if (op === DIFF_INSERT) {
+        insertIdx === null && (insertIdx = j);
+        continue;
+      } else if (op === DIFF_DELETE) {
+        deleteIdx === null && (deleteIdx = j);
+        continue;
+      } else if (op === DIFF_EQUAL) {
+        if (insertIdx === null && deleteIdx === null) {
+          const [rest, char2] = splitChar(diffs[i][1], dir);
+          diffs[i][1] = rest, diffs[j][1] = combineChar(diffs[j][1], char2, inv);
+          return;
+        }
+        break;
       }
-      apply2(operation);
-    }, editor.normalizeNode = (entry) => {
-      const [node, path] = entry;
-      if (slate.Element.isElement(node) && node._type === schemaTypes.block.name) {
-        node._key || slate.Transforms.setNodes(editor, { _key: keyGenerator() }, { at: path });
-        for (const [child, childPath] of slate.Node.children(editor, path))
-          if (!child._key) {
-            slate.Transforms.setNodes(editor, { _key: keyGenerator() }, { at: childPath });
-            return;
-          }
+    }
+  }
+  if (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
+    const [insertText, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText] = splitChar(diffs[deleteIdx][1], inv);
+    diffs[insertIdx][1] = insertText, diffs[deleteIdx][1] = deleteText, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
+    return;
+  }
+  const [text, char] = splitChar(diffs[i][1], dir);
+  diffs[i][1] = text, insertIdx === null ? (diffs.splice(j, 0, [DIFF_INSERT, char]), deleteIdx !== null && deleteIdx >= j && deleteIdx++) : diffs[insertIdx][1] = combineChar(diffs[insertIdx][1], char, inv), deleteIdx === null ? diffs.splice(j, 0, [DIFF_DELETE, char]) : diffs[deleteIdx][1] = combineChar(diffs[deleteIdx][1], char, inv);
+}
+function adjustDiffForSurrogatePairs(diffs) {
+  for (let i = 0; i < diffs.length; i++) {
+    const [diffType, diffText] = diffs[i];
+    if (diffText.length === 0) continue;
+    const firstChar = diffText[0], lastChar = diffText[diffText.length - 1];
+    isHighSurrogate(lastChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, 1), isLowSurrogate(firstChar) && diffType === DIFF_EQUAL && deisolateChar(diffs, i, -1);
+  }
+  for (let i = 0; i < diffs.length; i++)
+    diffs[i][1].length === 0 && diffs.splice(i, 1);
+}
+const DEFAULT_OPTIONS = {
+  /**
+   * At what point is no match declared (0.0 = perfection, 1.0 = very loose).
+   */
+  threshold: 0.5,
+  /**
+   * How far to search for a match (0 = exact location, 1000+ = broad match).
+   * A match this many characters away from the expected location will add
+   * 1.0 to the score (0.0 is a perfect match).
+   */
+  distance: 1e3
+};
+function applyDefaults(options) {
+  return {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+}
+const MAX_BITS$1 = 32;
+function bitap(text, pattern, loc) {
+  let opts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
+  if (pattern.length > MAX_BITS$1)
+    throw new Error("Pattern too long for this browser.");
+  const options = applyDefaults(opts), s = getAlphabetFromPattern(pattern);
+  function getBitapScore(e, x) {
+    const accuracy = e / pattern.length, proximity = Math.abs(loc - x);
+    return options.distance ? accuracy + proximity / options.distance : proximity ? 1 : accuracy;
+  }
+  let scoreThreshold = options.threshold, bestLoc = text.indexOf(pattern, loc);
+  bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold), bestLoc = text.lastIndexOf(pattern, loc + pattern.length), bestLoc !== -1 && (scoreThreshold = Math.min(getBitapScore(0, bestLoc), scoreThreshold)));
+  const matchmask = 1 << pattern.length - 1;
+  bestLoc = -1;
+  let binMin, binMid, binMax = pattern.length + text.length, lastRd = [];
+  for (let d = 0; d < pattern.length; d++) {
+    for (binMin = 0, binMid = binMax; binMin < binMid; )
+      getBitapScore(d, loc + binMid) <= scoreThreshold ? binMin = binMid : binMax = binMid, binMid = Math.floor((binMax - binMin) / 2 + binMin);
+    binMax = binMid;
+    let start = Math.max(1, loc - binMid + 1);
+    const finish = Math.min(loc + binMid, text.length) + pattern.length, rd = new Array(finish + 2);
+    rd[finish + 1] = (1 << d) - 1;
+    for (let j = finish; j >= start; j--) {
+      const charMatch = s[text.charAt(j - 1)];
+      if (d === 0 ? rd[j] = (rd[j + 1] << 1 | 1) & charMatch : rd[j] = (rd[j + 1] << 1 | 1) & charMatch | ((lastRd[j + 1] | lastRd[j]) << 1 | 1) | lastRd[j + 1], rd[j] & matchmask) {
+        const score = getBitapScore(d, j - 1);
+        if (score <= scoreThreshold)
+          if (scoreThreshold = score, bestLoc = j - 1, bestLoc > loc)
+            start = Math.max(1, 2 * loc - bestLoc);
+          else
+            break;
       }
-      normalizeNode(entry);
-    }, editor;
-  };
+    }
+    if (getBitapScore(d + 1, loc) > scoreThreshold)
+      break;
+    lastRd = rd;
+  }
+  return bestLoc;
+}
+function getAlphabetFromPattern(pattern) {
+  const s = {};
+  for (let i = 0; i < pattern.length; i++)
+    s[pattern.charAt(i)] = 0;
+  for (let i = 0; i < pattern.length; i++)
+    s[pattern.charAt(i)] |= 1 << pattern.length - i - 1;
+  return s;
 }
-const BEFORE = "before", AFTER = "after";
-function insert(array, position, index, ...args) {
-  if (position !== BEFORE && position !== AFTER)
-    throw new Error(`Invalid position "${position}", must be either ${BEFORE} or ${AFTER}`);
-  const items = flatten(...args);
-  if (array.length === 0)
-    return items;
-  const len = array.length, idx = Math.abs((len + index) % len) % len, normalizedIdx = position === "after" ? idx + 1 : idx, copy = array.slice();
-  return copy.splice(normalizedIdx, 0, ...flatten(items)), copy;
+function match(text, pattern, searchLocation) {
+  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);
 }
-function flatten(...values) {
-  return values.reduce((prev, item) => prev.concat(item), []);
+function createPatchObject(start1, start2) {
+  return {
+    diffs: [],
+    start1,
+    start2,
+    utf8Start1: start1,
+    utf8Start2: start2,
+    length1: 0,
+    length2: 0,
+    utf8Length1: 0,
+    utf8Length2: 0
+  };
 }
-const hasOwn = Object.prototype.hasOwnProperty.call.bind(Object.prototype.hasOwnProperty);
-function move(arr, from, to) {
-  const nextValue = arr.slice(), val = nextValue[from];
-  return nextValue.splice(from, 1), nextValue.splice(to, 0, val), nextValue;
+function diffText1(diffs) {
+  const text = [];
+  for (let x = 0; x < diffs.length; x++)
+    diffs[x][0] !== DIFF_INSERT && (text[x] = diffs[x][1]);
+  return text.join("");
 }
-function findTargetIndex(array, pathSegment) {
-  if (typeof pathSegment == "number")
-    return pathSegment;
-  const index = findIndex__default.default(array, pathSegment);
-  return index === -1 ? !1 : index;
+function diffText2(diffs) {
+  const text = [];
+  for (let x = 0; x < diffs.length; x++)
+    diffs[x][0] !== DIFF_DELETE && (text[x] = diffs[x][1]);
+  return text.join("");
 }
-function apply$3(value, patch) {
-  const nextValue = value.slice();
-  if (patch.path.length === 0) {
-    if (patch.type === "setIfMissing") {
-      if (!Array.isArray(patch.value))
-        throw new Error("Cannot set value of an array to a non-array");
-      return value === void 0 ? patch.value : value;
-    } else if (patch.type === "set") {
-      if (!Array.isArray(patch.value))
-        throw new Error("Cannot set value of an array to a non-array");
-      return patch.value;
-    } else {
-      if (patch.type === "unset")
-        return;
-      if (patch.type === "move") {
-        if (!patch.value || !hasOwn(patch.value, "from") || !hasOwn(patch.value, "to"))
-          throw new Error(
-            `Invalid value of 'move' patch. Expected a value with "from" and "to" indexes, instead got: ${JSON.stringify(
-              patch.value
-            )}`
-          );
-        return move(nextValue, patch.value.from, patch.value.to);
-      }
-    }
-    throw new Error(`Invalid array operation: ${patch.type}`);
+function countUtf8Bytes(str) {
+  let bytes = 0;
+  for (let i = 0; i < str.length; i++) {
+    const codePoint = str.codePointAt(i);
+    if (typeof codePoint > "u")
+      throw new Error("Failed to get codepoint");
+    bytes += utf8len(codePoint);
   }
-  const [head, ...tail] = patch.path, index = findTargetIndex(value, head);
-  if (index === !1)
-    return nextValue;
-  if (tail.length === 0) {
-    if (patch.type === "insert") {
-      const { position, items } = patch;
-      return insert(value, position, index, items);
-    } else if (patch.type === "unset") {
-      if (typeof index != "number")
-        throw new Error(`Expected array index to be a number, instead got "${index}"`);
-      return nextValue.splice(index, 1), nextValue;
+  return bytes;
+}
+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; ) {
+      const codePoint = base.codePointAt(idx);
+      if (typeof codePoint > "u")
+        return idx;
+      byteOffset += utf8len(codePoint), codePoint > 65535 ? idx += 2 : idx += 1;
     }
+    if (!options.allowExceedingIndices && byteOffset !== target)
+      throw new Error("Failed to determine byte offset");
+    return idx;
   }
-  return nextValue[index] = _apply(nextValue[index], {
-    ...patch,
-    path: tail
-  }), nextValue;
+  const adjusted = [];
+  for (const patch of patches2)
+    adjusted.push({
+      diffs: patch.diffs.map((diff2) => cloneDiff(diff2)),
+      start1: advanceTo(patch.start1),
+      start2: advanceTo(patch.start2),
+      utf8Start1: patch.utf8Start1,
+      utf8Start2: patch.utf8Start2,
+      length1: patch.length1,
+      length2: patch.length2,
+      utf8Length1: patch.utf8Length1,
+      utf8Length2: patch.utf8Length2
+    });
+  return adjusted;
 }
-function apply$2(value, patch) {
-  const nextValue = clone__default.default(value);
-  if (patch.path.length === 0) {
-    if (patch.type === "set") {
-      if (!isObject__default.default(patch.value))
-        throw new Error("Cannot set value of an object to a non-object");
-      return patch.value;
-    } else {
-      if (patch.type === "unset")
-        return;
-      if (patch.type === "setIfMissing")
-        return value === void 0 ? patch.value : value;
+function utf8len(codePoint) {
+  return codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+}
+const MAX_BITS = 32, DEFAULT_MARGIN = 4;
+function levenshtein(diffs) {
+  let leven = 0, insertions = 0, deletions = 0;
+  for (let x = 0; x < diffs.length; x++) {
+    const op = diffs[x][0], data = diffs[x][1];
+    switch (op) {
+      case DIFF_INSERT:
+        insertions += data.length;
+        break;
+      case DIFF_DELETE:
+        deletions += data.length;
+        break;
+      case DIFF_EQUAL:
+        leven += Math.max(insertions, deletions), insertions = 0, deletions = 0;
+        break;
+      default:
+        throw new Error("Unknown diff operation.");
     }
-    throw new Error(`Invalid object operation: ${patch.type}`);
   }
-  const [head, ...tail] = patch.path;
-  if (typeof head != "string")
-    throw new Error(`Expected field name to be a string, instad got: ${head}`);
-  return tail.length === 0 && patch.type === "unset" ? omit__default.default(nextValue, head) : (nextValue[head] = _apply(nextValue[head], {
-    ...patch,
-    path: tail
-  }), nextValue);
+  return leven += Math.max(insertions, deletions), leven;
 }
-const OPERATIONS$1 = {
-  replace(_currentValue, nextValue) {
-    return nextValue;
-  },
-  set(_currentValue, nextValue) {
-    return nextValue;
-  },
-  setIfMissing(currentValue, nextValue) {
-    return currentValue === void 0 ? nextValue : currentValue;
-  },
-  unset(_currentValue, _nextValue) {
-  },
-  inc(currentValue, nextValue) {
-    return currentValue + nextValue;
-  },
-  dec(currentValue, nextValue) {
-    return currentValue - nextValue;
+function xIndex(diffs, loc) {
+  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);
+}
+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 patches2)
+    p.start1 += paddingLength, p.start2 += paddingLength, p.utf8Start1 += paddingLength, p.utf8Start2 += paddingLength;
+  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;
   }
-}, SUPPORTED_PATCH_TYPES$1 = Object.keys(OPERATIONS$1);
-function apply$1(value, patch) {
-  if (!SUPPORTED_PATCH_TYPES$1.includes(patch.type))
-    throw new Error(
-      `Received patch of unsupported type: "${JSON.stringify(
-        patch.type
-      )}" for primitives. This is most likely a bug.`
-    );
-  if (patch.path.length > 0)
-    throw new Error(
-      `Cannot apply deep operations on primitive values. Received patch with type "${patch.type}" and path "${patch.path.map((path) => JSON.stringify(path)).join(".")} that targeted the value "${JSON.stringify(value)}"`
-    );
-  return OPERATIONS$1[patch.type](value, patch.value);
+  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;
+    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength), patch.length1 += extraLength, patch.length2 += extraLength, patch.utf8Length1 += extraLength, patch.utf8Length2 += extraLength;
+  }
+  return nullPadding;
 }
-const OPERATIONS = {
-  replace(_currentValue, nextValue) {
-    return nextValue;
-  },
-  set(_currentValue, nextValue) {
-    return nextValue;
-  },
-  setIfMissing(currentValue, nextValue) {
-    return currentValue === void 0 ? nextValue : currentValue;
-  },
-  unset(_currentValue, _nextValue) {
-  },
-  diffMatchPatch(currentValue, nextValue) {
-    const [result] = apply$4(parse(nextValue), currentValue, {
-      allowExceedingIndices: !0
-    });
-    return result;
+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 < patches2.length; x++) {
+    if (patches2[x].length1 <= patchSize)
+      continue;
+    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);
+      let empty = !0;
+      if (preContext !== "") {
+        const precontextByteCount = countUtf8Bytes(preContext);
+        patch.length1 = preContext.length, patch.utf8Length1 = precontextByteCount, patch.length2 = preContext.length, patch.utf8Length2 = precontextByteCount, patch.diffs.push([DIFF_EQUAL, preContext]);
+      }
+      for (; bigpatch.diffs.length !== 0 && patch.length1 < patchSize - margin; ) {
+        const diffType = bigpatch.diffs[0][0];
+        let diffText = bigpatch.diffs[0][1], diffTextByteCount = countUtf8Bytes(diffText);
+        if (diffType === DIFF_INSERT) {
+          patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length;
+          const diff2 = bigpatch.diffs.shift();
+          diff2 && patch.diffs.push(diff2), empty = !1;
+        } else diffType === DIFF_DELETE && patch.diffs.length === 1 && patch.diffs[0][0] === DIFF_EQUAL && diffText.length > 2 * patchSize ? (patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, empty = !1, patch.diffs.push([diffType, diffText]), bigpatch.diffs.shift()) : (diffText = diffText.substring(0, patchSize - patch.length1 - margin), diffTextByteCount = countUtf8Bytes(diffText), patch.length1 += diffText.length, patch.utf8Length1 += diffTextByteCount, start1 += diffText.length, diffType === DIFF_EQUAL ? (patch.length2 += diffText.length, patch.utf8Length2 += diffTextByteCount, start2 += diffText.length) : empty = !1, patch.diffs.push([diffType, diffText]), diffText === bigpatch.diffs[0][1] ? bigpatch.diffs.shift() : bigpatch.diffs[0][1] = bigpatch.diffs[0][1].substring(diffText.length));
+      }
+      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 || patches2.splice(++x, 0, patch);
+    }
   }
-}, SUPPORTED_PATCH_TYPES = Object.keys(OPERATIONS);
-function apply(value, patch) {
-  if (!SUPPORTED_PATCH_TYPES.includes(patch.type))
-    throw new Error(
-      `Received patch of unsupported type: "${JSON.stringify(
-        patch.type
-      )}" for string. This is most likely a bug.`
-    );
-  if (patch.path.length > 0)
-    throw new Error(
-      `Cannot apply deep operations on string values. Received patch with type "${patch.type}" and path "${patch.path.join(".")} that targeted the value "${JSON.stringify(value)}"`
-    );
-  const func = OPERATIONS[patch.type];
-  if (func)
-    return func(value, patch.value);
-  throw new Error("Unknown patch type");
 }
-function applyAll(value, patches) {
-  return patches.reduce(_apply, value);
+function apply(patches2, originalText) {
+  let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  if (typeof patches2 == "string")
+    throw new Error("Patches must be an array - pass the patch to `parsePatch()` first");
+  let text = originalText;
+  if (patches2.length === 0)
+    return [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);
+  let delta = 0;
+  const results = [];
+  for (let x = 0; x < parsed.length; x++) {
+    const expectedLoc = parsed[x].start2 + delta, text1 = diffText1(parsed[x].diffs);
+    let startLoc, endLoc = -1;
+    if (text1.length > MAX_BITS ? (startLoc = match(text, text1.substring(0, MAX_BITS), expectedLoc), startLoc !== -1 && (endLoc = match(text, text1.substring(text1.length - MAX_BITS), expectedLoc + text1.length - MAX_BITS), (endLoc === -1 || startLoc >= endLoc) && (startLoc = -1))) : startLoc = match(text, text1, expectedLoc), startLoc === -1)
+      results[x] = !1, delta -= parsed[x].length2 - parsed[x].length1;
+    else {
+      results[x] = !0, delta = startLoc - expectedLoc;
+      let text2;
+      if (endLoc === -1 ? text2 = text.substring(startLoc, startLoc + text1.length) : text2 = text.substring(startLoc, endLoc + MAX_BITS), text1 === text2)
+        text = text.substring(0, startLoc) + diffText2(parsed[x].diffs) + text.substring(startLoc + text1.length);
+      else {
+        let diffs = diff(text1, text2, {
+          checkLines: !1
+        });
+        if (text1.length > MAX_BITS && levenshtein(diffs) / text1.length > deleteThreshold)
+          results[x] = !1;
+        else {
+          diffs = cleanupSemanticLossless(diffs);
+          let index1 = 0, index2 = 0;
+          for (let y = 0; y < parsed[x].diffs.length; y++) {
+            const mod = parsed[x].diffs[y];
+            mod[0] !== DIFF_EQUAL && (index2 = xIndex(diffs, index1)), mod[0] === DIFF_INSERT ? text = text.substring(0, startLoc + index2) + mod[1] + text.substring(startLoc + index2) : mod[0] === DIFF_DELETE && (text = text.substring(0, startLoc + index2) + text.substring(startLoc + xIndex(diffs, index1 + mod[1].length))), mod[0] !== DIFF_DELETE && (index1 += mod[1].length);
+          }
+        }
+      }
+    }
+  }
+  return text = text.substring(nullPadding.length, text.length - nullPadding.length), [text, results];
 }
-function applyPatch(value, patch) {
-  return Array.isArray(value) ? apply$3(value, patch) : isString__default.default(value) ? apply(value, patch) : isObject__default.default(value) ? apply$2(value, patch) : apply$1(value, patch);
+const patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
+function parse(textline) {
+  if (!textline)
+    return [];
+  const patches2 = [], lines = textline.split(`
+`);
+  let textPointer = 0;
+  for (; textPointer < lines.length; ) {
+    const m = lines[textPointer].match(patchHeader);
+    if (!m)
+      throw new Error("Invalid patch string: ".concat(lines[textPointer]));
+    const patch = createPatchObject(toInt(m[1]), toInt(m[3]));
+    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;
+      if (sign === "") {
+        textPointer++;
+        continue;
+      }
+      let line;
+      try {
+        line = decodeURI(currentLine.slice(1));
+      } catch {
+        throw new Error("Illegal escape in parse: ".concat(currentLine));
+      }
+      const utf8Diff = countUtf8Bytes(line) - line.length;
+      if (sign === "-")
+        patch.diffs.push([DIFF_DELETE, line]), patch.length1 -= utf8Diff;
+      else if (sign === "+")
+        patch.diffs.push([DIFF_INSERT, line]), patch.length2 -= utf8Diff;
+      else if (sign === " ")
+        patch.diffs.push([DIFF_EQUAL, line]), patch.length1 -= utf8Diff, patch.length2 -= utf8Diff;
+      else
+        throw new Error('Invalid patch mode "'.concat(sign, '" in: ').concat(line));
+      textPointer++;
+    }
+  }
+  return patches2;
 }
-function _apply(value, patch) {
-  return applyPatch(value, patch);
+function toInt(num) {
+  return parseInt(num, 10);
 }
 const debug$h = debugWithName("applyPatches"), debugVerbose$3 = debug$h.enabled && !0;
 function createApplyPatch(schemaTypes) {
@@ -2368,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$4(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)
@@ -2457,7 +2163,7 @@ function setPatch(editor, patch) {
       });
     });
   } else if (block && "value" in block) {
-    const newVal = 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;
@@ -2539,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;
@@ -2739,7 +2445,7 @@ function createWithPatches({
   schemaTypes
 }) {
   let previousChildren;
-  const applyPatch2 = createApplyPatch(schemaTypes);
+  const applyPatch = createApplyPatch(schemaTypes);
   return function(editor) {
     IS_PROCESSING_REMOTE_CHANGES.set(editor, !1), PATCHING.set(editor, !0), previousChildren = [...editor.children];
     const { apply: apply2 } = editor;
@@ -2747,7 +2453,7 @@ function createWithPatches({
     const handleBufferedRemotePatches = () => {
       if (bufferedPatches.length === 0)
         return;
-      const patches = bufferedPatches;
+      const patches2 = bufferedPatches;
       bufferedPatches = [];
       let changed = !1;
       withRemoteChanges(editor, () => {
@@ -2755,16 +2461,16 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               withPreserveKeys(editor, () => {
-                patches.forEach((patch) => {
-                  debug$f.enabled && debug$f(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch2(editor, patch);
+                patches2.forEach((patch) => {
+                  debug$f.enabled && debug$f(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
                 });
               });
             });
           });
         }), 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(() => {
@@ -2776,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(insert$1(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, 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 = [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" }
@@ -3448,7 +3154,7 @@ function validateValue(value, types$1, keyGenerator) {
   return value === void 0 ? { valid: !0, resolution: null, value } : !Array.isArray(value) || value.length === 0 ? {
     valid: !1,
     resolution: {
-      patches: [unset([])],
+      patches: [patches.unset([])],
       description: "Editor value must be an array of Portable Text blocks, or undefined.",
       action: "Unset the value",
       item: value,
@@ -3461,7 +3167,7 @@ function validateValue(value, types$1, keyGenerator) {
   } : (value.some((blk, index) => {
     if (!isPlainObject__default.default(blk))
       return resolution = {
-        patches: [unset([index])],
+        patches: [patches.unset([index])],
         description: `Block must be an object, got ${String(blk)}`,
         action: "Unset invalid item",
         item: blk,
@@ -3473,7 +3179,7 @@ function validateValue(value, types$1, keyGenerator) {
       }, !0;
     if (!blk._key || typeof blk._key != "string")
       return resolution = {
-        patches: [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,
@@ -3487,7 +3193,7 @@ function validateValue(value, types$1, keyGenerator) {
       if (blk._type === "block") {
         const currentBlockTypeName = types$1.block.name;
         return resolution = {
-          patches: [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,
@@ -3499,7 +3205,7 @@ function validateValue(value, types$1, keyGenerator) {
         }, !0;
       }
       return !blk._type && types.isPortableTextTextBlock({ ...blk, _type: types$1.block.name }) ? (resolution = {
-        patches: [set({ ...blk, _type: types$1.block.name }, [{ _key: blk._key }])],
+        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,
@@ -3509,7 +3215,7 @@ function validateValue(value, types$1, keyGenerator) {
           values: { key: blk._key, expectedTypeName: types$1.block.name }
         }
       }, !0) : blk._type ? (resolution = {
-        patches: [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,
@@ -3519,7 +3225,7 @@ function validateValue(value, types$1, keyGenerator) {
           values: { key: blk._key, typeName: blk._type }
         }
       }, !0) : (resolution = {
-        patches: [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,
@@ -3534,7 +3240,7 @@ function validateValue(value, types$1, keyGenerator) {
       const textBlock = blk;
       if (textBlock.children && !Array.isArray(textBlock.children))
         return resolution = {
-          patches: [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,
@@ -3554,8 +3260,8 @@ function validateValue(value, types$1, keyGenerator) {
         return resolution = {
           autoResolve: !0,
           patches: [
-            setIfMissing([], [{ _key: blk._key }, "children"]),
-            insert$1([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",
@@ -3569,7 +3275,7 @@ function validateValue(value, types$1, keyGenerator) {
       }
       if (blk.markDefs && !Array.isArray(blk.markDefs))
         return resolution = {
-          patches: [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,
@@ -3592,7 +3298,7 @@ function validateValue(value, types$1, keyGenerator) {
           return resolution = {
             autoResolve: !0,
             patches: unusedMarkDefs.map(
-              (markDefKey) => 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(
               ", "
@@ -3619,7 +3325,7 @@ function validateValue(value, types$1, keyGenerator) {
           const orphaned = orphanedMarks.join(", ");
           return resolution = {
             autoResolve: !0,
-            patches: spanChildren.map((child) => set(
+            patches: spanChildren.map((child) => patches.set(
               (child.marks || []).filter((cMrk) => !orphanedMarks.includes(cMrk)),
               [{ _key: blk._key }, "children", { _key: child._key }, "marks"]
             )),
@@ -3637,7 +3343,7 @@ function validateValue(value, types$1, keyGenerator) {
       textBlock.children.some((child, cIndex) => {
         if (!isPlainObject__default.default(child))
           return resolution = {
-            patches: [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,
@@ -3651,7 +3357,7 @@ function validateValue(value, types$1, keyGenerator) {
           const newChild = { ...child, _key: keyGenerator() };
           return resolution = {
             autoResolve: !0,
-            patches: [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,
@@ -3664,7 +3370,7 @@ function validateValue(value, types$1, keyGenerator) {
         }
         return child._type ? validChildTypes.includes(child._type) ? child._type === types$1.span.name && typeof child.text != "string" ? (resolution = {
           patches: [
-            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",
@@ -3675,7 +3381,7 @@ function validateValue(value, types$1, keyGenerator) {
             values: { key: blk._key, childKey: child._key }
           }
         }, !0) : !1 : (resolution = {
-          patches: [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,
@@ -3685,7 +3391,7 @@ function validateValue(value, types$1, keyGenerator) {
             values: { key: blk._key, childKey: child._key, childType: child._type }
           }
         }, !0) : (resolution = {
-          patches: [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,