@portabletext/editor 6.6.0 → 6.6.1

package/lib/index.js

@@ -9,7 +9,6 @@ import { isTypedObject, isKeyedSegment, isListBlock, getBlockEndPoint, getBlockS
 import { isTextBlockNode, isSpanNode, isSelectionCollapsed as isSelectionCollapsed$1, getFocusChild, getSelectedChildren, getSelectionStartPoint, getSelectionEndPoint, getFocusInlineObject, getFocusTextBlock, getFocusSpan, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getSelectionStartChild, getSelectionEndChild, getPreviousSpan, getNextSpan, getCaretWordSelection, getFocusBlockObject, getPreviousBlock, getNextBlock, getMarkState, isAtTheEndOfBlock, isAtTheStartOfBlock, getFocusListBlock, isActiveDecorator, getActiveAnnotations, getLastBlock, getSelectedTextBlocks, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-selecting-entire-blocks.js";
 import scrollIntoView from "scroll-into-view-if-needed";
 import { createKeyboardShortcut, code, underline, italic as italic$1, bold as bold$1, undo as undo$1, redo as redo$1 } from "@portabletext/keyboard-shortcuts";
-import { ResizeObserver } from "@juggle/resize-observer";
 import { isEmptyTextBlock, sliceTextBlock, getTextBlockText } from "./_chunks-es/util.slice-text-block.js";
 import { setup, fromCallback, assign, and, enqueueActions, emit, assertEvent, raise as raise$1, not, createActor } from "xstate";
 import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
@@ -47,36 +46,96 @@ function isChildArrayField(field) {
 function isObjectNode(context, node) {
   return isTypedObject(node) && node._type !== context.schema.block.name && node._type !== context.schema.span.name;
 }
-function indexedPathToKeyedPath(root, path2, schema) {
+function getChildren(context, path2) {
+  const traversalContext = {
+    schema: context.schema,
+    editableTypes: context.editableTypes
+  };
+  return getChildrenInternal(traversalContext, {
+    value: context.value
+  }, path2);
+}
+function getChildrenInternal(context, root, path2) {
+  const rootChildren = getNodeChildren(context, root, void 0, "");
+  if (!rootChildren)
+    return [];
+  let currentChildren = rootChildren.children, currentScope = rootChildren.scope, scopePath = rootChildren.scopePath, currentPath = [];
+  for (const index of path2) {
+    const node = currentChildren[index];
+    if (!node)
+      return [];
+    currentPath = [...currentPath, index];
+    const next = getNodeChildren(context, node, currentScope, scopePath);
+    if (!next)
+      return [];
+    currentChildren = next.children, currentScope = next.scope, scopePath = next.scopePath;
+  }
+  return currentChildren.map((child, index) => ({
+    node: child,
+    path: [...currentPath, index]
+  }));
+}
+const _textBlockResult = {
+  children: [],
+  scope: void 0,
+  scopePath: "",
+  fieldName: "children"
+}, _rootResult = {
+  children: [],
+  scope: void 0,
+  scopePath: "",
+  fieldName: "value"
+};
+function getNodeChildren(context, node, scope, scopePath) {
+  if (isTextBlock(context, node))
+    return _textBlockResult.children = node.children, _textBlockResult;
+  if (isObjectNode(context, node)) {
+    const scopedKey = scopePath ? `${scopePath}.${node._type}` : node._type;
+    if (!context.editableTypes.has(scopedKey))
+      return;
+    const arrayField = resolveChildArrayField({
+      schema: context.schema,
+      scope
+    }, node);
+    return arrayField ? {
+      children: node[arrayField.name],
+      scope: arrayField.of,
+      scopePath: scopedKey,
+      fieldName: arrayField.name
+    } : void 0;
+  }
+  if ("value" in node && Array.isArray(node.value) && !("_key" in node) && !("_type" in node))
+    return _rootResult.children = node.value, _rootResult;
+}
+function indexedPathToKeyedPath(context, path2) {
   if (path2.length === 0)
     return [];
   const keyedPath = [];
-  let currentChildren = root.children, currentScope;
+  let nodeChildren = getNodeChildren({
+    schema: context.schema,
+    editableTypes: context.editableTypes
+  }, {
+    value: context.value
+  }, void 0, "");
   for (let i = 0; i < path2.length; i++) {
-    const index = path2[i];
+    if (!nodeChildren)
+      return;
+    const index = path2.at(i);
     if (index === void 0)
       return;
-    const node = currentChildren[index];
+    const node = nodeChildren.children.at(index);
     if (!node || !node._key)
       return;
     if (keyedPath.push({
       _key: node._key
     }), i < path2.length - 1) {
-      if (isTextBlock({
-        schema
-      }, node))
-        keyedPath.push("children"), currentChildren = node.children, currentScope = void 0;
-      else if (isObjectNode({
-        schema
-      }, node)) {
-        const arrayField = resolveChildArrayField({
-          schema,
-          scope: currentScope
-        }, node);
-        if (!arrayField)
-          return;
-        keyedPath.push(arrayField.name), currentChildren = node[arrayField.name], currentScope = arrayField.of;
-      }
+      const childInfo = getNodeChildren({
+        schema: context.schema,
+        editableTypes: context.editableTypes
+      }, node, nodeChildren.scope, nodeChildren.scopePath);
+      if (!childInfo)
+        return;
+      keyedPath.push(childInfo.fieldName), nodeChildren = childInfo;
     }
   }
   return keyedPath;
@@ -90,7 +149,11 @@ function getDomNode(editor, path2) {
     return;
   if (path2.length === 0)
     return editorElement;
-  const keyedPath = indexedPathToKeyedPath(editor, path2, editor.schema);
+  const keyedPath = indexedPathToKeyedPath({
+    schema: editor.schema,
+    editableTypes: editor.editableTypes,
+    value: editor.children
+  }, path2);
   if (!keyedPath)
     return;
   const serializedPath = serializePath(keyedPath), blockIndex = path2.at(0);
@@ -140,64 +203,6 @@ function safeParse(text) {
     return console.error(error), "JSON.parse failed";
   }
 }
-function getChildren(context, path2) {
-  const traversalContext = {
-    schema: context.schema,
-    editableTypes: context.editableTypes
-  };
-  return getChildrenInternal(traversalContext, {
-    value: context.value
-  }, path2);
-}
-function getChildrenInternal(context, root, path2) {
-  const rootChildren = getNodeChildren(context, root, void 0, "");
-  if (!rootChildren)
-    return [];
-  let currentChildren = rootChildren.children, currentScope = rootChildren.scope, scopePath = rootChildren.scopePath, currentPath = [];
-  for (const index of path2) {
-    const node = currentChildren[index];
-    if (!node)
-      return [];
-    currentPath = [...currentPath, index];
-    const next = getNodeChildren(context, node, currentScope, scopePath);
-    if (!next)
-      return [];
-    currentChildren = next.children, currentScope = next.scope, scopePath = next.scopePath;
-  }
-  return currentChildren.map((child, index) => ({
-    node: child,
-    path: [...currentPath, index]
-  }));
-}
-const _textBlockResult = {
-  children: [],
-  scope: void 0,
-  scopePath: ""
-}, _rootResult = {
-  children: [],
-  scope: void 0,
-  scopePath: ""
-};
-function getNodeChildren(context, node, scope, scopePath) {
-  if (isTextBlock(context, node))
-    return _textBlockResult.children = node.children, _textBlockResult;
-  if (isObjectNode(context, node)) {
-    const scopedKey = scopePath ? `${scopePath}.${node._type}` : node._type;
-    if (!context.editableTypes.has(scopedKey))
-      return;
-    const arrayField = resolveChildArrayField({
-      schema: context.schema,
-      scope
-    }, node);
-    return arrayField ? {
-      children: node[arrayField.name],
-      scope: arrayField.of,
-      scopePath: scopedKey
-    } : void 0;
-  }
-  if ("value" in node && Array.isArray(node.value) && !("_key" in node) && !("_type" in node))
-    return _rootResult.children = node.value, _rootResult;
-}
 function getNode(context, path2) {
   if (path2.length === 0)
     return;
@@ -654,9 +659,12 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
         const domSelection = getSelection(root), domRange = DOMEditor.toDOMRange(editor, editor.selection);
         domSelection?.removeAllRanges(), domSelection?.addRange(domRange);
       }
-      editor.selection || editor.select(start(editor, [])), editor.focused = !0, el.focus({
+      if (editor.selection || editor.select(start(editor, [])), editor.focused = !0, el.focus({
         preventScroll: !0
-      });
+      }), editor.selection && root instanceof Document) {
+        const domSelection = getSelection(root), domRange = DOMEditor.toDOMRange(editor, editor.selection);
+        domSelection?.removeAllRanges(), domSelection?.addRange(domRange);
+      }
     }
   },
   getWindow: (editor) => {
@@ -1669,30 +1677,26 @@ function* positions(editor, options = {}) {
     if (isTextBlockNode({
       schema: editor.schema
     }, node)) {
-      if (editor.isInline(node))
-        continue;
-      {
-        const e = isAncestorPath(nodePath, end$1.path) ? end$1 : end(editor, nodePath), s = isAncestorPath(nodePath, start$1.path) ? start$1 : start(editor, nodePath);
-        blockText = "";
-        for (const {
-          node: spanNode,
-          path: spanPath
-        } of getNodes(editor, {
-          from: s.path,
-          to: e.path,
-          match: (n) => isSpan({
-            schema: editor.schema
-          }, n)
-        })) {
-          if (!isSpan({
-            schema: editor.schema
-          }, spanNode))
-            continue;
-          let spanText = spanNode.text;
-          pathEquals(spanPath, e.path) && (spanText = spanText.slice(0, e.offset)), pathEquals(spanPath, s.path) && (spanText = spanText.slice(s.offset)), blockText += spanText;
-        }
-        isNewBlock = !0;
+      const e = isAncestorPath(nodePath, end$1.path) ? end$1 : end(editor, nodePath), s = isAncestorPath(nodePath, start$1.path) ? start$1 : start(editor, nodePath);
+      blockText = "";
+      for (const {
+        node: spanNode,
+        path: spanPath
+      } of getNodes(editor, {
+        from: s.path,
+        to: e.path,
+        match: (n) => isSpan({
+          schema: editor.schema
+        }, n)
+      })) {
+        if (!isSpan({
+          schema: editor.schema
+        }, spanNode))
+          continue;
+        let spanText = spanNode.text;
+        pathEquals(spanPath, e.path) && (spanText = spanText.slice(0, e.offset)), pathEquals(spanPath, s.path) && (spanText = spanText.slice(s.offset)), blockText += spanText;
       }
+      isNewBlock = !0;
     }
     if (isObjectNode({
       schema: editor.schema
@@ -2342,6 +2346,11 @@ function transformPoint(point2, op, options = {}) {
       path2 = transformPath(path2, op);
       break;
     }
+    case "set_node": {
+      const newProperties = op.newProperties;
+      pathEquals(op.path, path2) && "text" in op.properties && (!("text" in newProperties) || newProperties.text == null) && (offset = 0);
+      break;
+    }
     default:
       return point2;
   }
@@ -3172,6 +3181,9 @@ const shallowCompare = (obj1, obj2) => Object.keys(obj1).length === Object.keys(
   }
   return decorationsByChild;
 };
+function isInline(context, path2) {
+  return !isBlock(context, path2);
+}
 function useGenericSelector(selector, equalityFn) {
   const [, forceRender] = useReducer((s) => s + 1, 0), latestSubscriptionCallbackError = useRef(void 0), latestSelector = useRef(() => null), latestSelectedState = useRef(null);
   let selectedState;
@@ -3244,7 +3256,7 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     renderPlaceholder,
     renderLeaf,
     renderText
-  } = props, editor = useSlateStatic(), isInline2 = editor.isInline(element), decorations = useDecorations(element, props.indexedPath, parentDecorations), children = useChildren({
+  } = props, editor = useSlateStatic(), isInline$1 = isInline(editor, props.indexedPath), decorations = useDecorations(element, props.indexedPath, parentDecorations), children = useChildren({
     parentDataPath: dataPath,
     decorations,
     node: element,
@@ -3257,7 +3269,7 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     "data-slate-node": "element",
     "data-pt-path": dataPath
   };
-  if (isInline2 && (attributes["data-slate-inline"] = !0), !isInline2 && isTextBlockNode({
+  if (isInline$1 && (attributes["data-slate-inline"] = !0), !isInline$1 && isTextBlockNode({
     schema: editor.schema
   }, element)) {
     const text = getText(editor, props.indexedPath), dir = text !== void 0 ? getDirection(text) : void 0;
@@ -3272,9 +3284,8 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
 }, MemoizedElement = React.memo(Element$1, (prev, next) => prev.dataPath === next.dataPath && prev.element === next.element && pathEquals(prev.indexedPath, next.indexedPath) && prev.renderElement === next.renderElement && prev.renderText === next.renderText && prev.renderLeaf === next.renderLeaf && prev.renderPlaceholder === next.renderPlaceholder && isElementDecorationsEqual(prev.decorations, next.decorations)), DefaultElement = (props) => {
   const {
     attributes,
-    children,
-    element
-  } = props, Tag = useSlateStatic().isInline(element) ? "span" : "div";
+    children
+  } = props, editor = useSlateStatic(), Tag = isInline(editor, props.indexedPath) ? "span" : "div";
   return /* @__PURE__ */ jsx(Tag, { ...attributes, style: {
     position: "relative"
   }, children });
@@ -3420,11 +3431,11 @@ const SlateString = (props) => {
     parent,
     indexedPath,
     text
-  } = props, editor = useSlateStatic(), parentIndexedPath = parentPath(indexedPath), isMarkPlaceholder = !!leaf[MARK_PLACEHOLDER_SYMBOL];
-  return leaf.text === "" && isTextBlock({
+  } = props, editor = useSlateStatic(), parentIndexedPath = parentPath(indexedPath), isMarkPlaceholder = !!leaf[MARK_PLACEHOLDER_SYMBOL], leafText = leaf.text ?? "";
+  return leafText === "" && isTextBlock({
     schema: editor.schema
-  }, parent) && parent.children[parent.children.length - 1] === text && !editor.isInline(parent) && getTextContent(editor, parentIndexedPath) === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isLineBreak: !0, isMarkPlaceholder }) : leaf.text === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isMarkPlaceholder }) : isLast && leaf.text.slice(-1) === `
-` ? /* @__PURE__ */ jsx(TextString, { isTrailing: !0, text: leaf.text }) : /* @__PURE__ */ jsx(TextString, { text: leaf.text });
+  }, parent) && parent.children[parent.children.length - 1] === text && getTextContent(editor, parentIndexedPath) === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isLineBreak: !0, isMarkPlaceholder }) : leafText === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isMarkPlaceholder }) : isLast && leafText.slice(-1) === `
+` ? /* @__PURE__ */ jsx(TextString, { isTrailing: !0, text: leafText }) : /* @__PURE__ */ jsx(TextString, { text: leafText });
 }, TextString = (props) => {
   const {
     text,
@@ -3466,17 +3477,9 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
     renderLeaf = defaultRenderLeaf,
     leafPosition
   } = props, editor = useSlateStatic(), placeholderResizeObserver = useRef(null), placeholderRef = useRef(null), [showPlaceholder, setShowPlaceholder] = useState(!1), showPlaceholderTimeoutRef = useRef(null), callbackPlaceholderRef = useCallback((placeholderEl) => {
-    if (disconnectPlaceholderResizeObserver(placeholderResizeObserver, placeholderEl == null), placeholderEl == null)
-      editor.domPlaceholderElement = null, leaf.onPlaceholderResize?.(null);
-    else {
-      if (editor.domPlaceholderElement = placeholderEl, !placeholderResizeObserver.current) {
-        const ResizeObserver$1 = window.ResizeObserver || ResizeObserver;
-        placeholderResizeObserver.current = new ResizeObserver$1(() => {
-          leaf.onPlaceholderResize?.(placeholderEl);
-        });
-      }
-      placeholderResizeObserver.current.observe(placeholderEl), placeholderRef.current = placeholderEl;
-    }
+    disconnectPlaceholderResizeObserver(placeholderResizeObserver, placeholderEl == null), placeholderEl == null ? (editor.domPlaceholderElement = null, leaf.onPlaceholderResize?.(null)) : (editor.domPlaceholderElement = placeholderEl, placeholderResizeObserver.current || (placeholderResizeObserver.current = new ResizeObserver(() => {
+      leaf.onPlaceholderResize?.(placeholderEl);
+    })), placeholderResizeObserver.current.observe(placeholderEl), placeholderRef.current = placeholderEl);
   }, [placeholderRef, leaf, editor]);
   let children = /* @__PURE__ */ jsx(SlateString, { isLast, leaf, parent, indexedPath, text });
   const leafIsPlaceholder = !!leaf[PLACEHOLDER_SYMBOL];
@@ -4366,7 +4369,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
             let blockPath = indexedPath;
             isTextBlockNode({
               schema: editor.schema
-            }, node) && !editor.isInline(node) || (blockPath = getAncestorTextBlock(editor, indexedPath)?.path ?? indexedPath.slice(0, 1));
+            }, node) || (blockPath = getAncestorTextBlock(editor, indexedPath)?.path ?? indexedPath.slice(0, 1));
             const range$1 = range(editor, blockPath);
             editor.select(range$1);
             return;
@@ -5786,7 +5789,7 @@ function RenderElement(props) {
     let t12;
     return $[0] !== props.attributes || $[1] !== props.children || $[2] !== props.element || $[3] !== props.readOnly || $[4] !== props.renderBlock || $[5] !== props.renderListItem || $[6] !== props.renderStyle || $[7] !== props.spellCheck || $[8] !== schema || $[9] !== t02 ? (t12 = /* @__PURE__ */ jsx(RenderTextBlock, { attributes: props.attributes, dropPosition: t02, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, renderListItem: props.renderListItem, renderStyle: props.renderStyle, schema, spellCheck: props.spellCheck, textBlock: props.element, children: props.children }), $[0] = props.attributes, $[1] = props.children, $[2] = props.element, $[3] = props.readOnly, $[4] = props.renderBlock, $[5] = props.renderListItem, $[6] = props.renderStyle, $[7] = props.spellCheck, $[8] = schema, $[9] = t02, $[10] = t12) : t12 = $[10], t12;
   }
-  if (slateStatic.isInline(props.element)) {
+  if (isInline(slateStatic, props.indexedPath)) {
     let t02;
     return $[11] !== props.attributes || $[12] !== props.children || $[13] !== props.element || $[14] !== props.indexedPath || $[15] !== props.readOnly || $[16] !== props.renderChild || $[17] !== schema ? (t02 = /* @__PURE__ */ jsx(RenderInlineObject, { attributes: props.attributes, element: props.element, indexedPath: props.indexedPath, readOnly: props.readOnly, renderChild: props.renderChild, schema, children: props.children }), $[11] = props.attributes, $[12] = props.children, $[13] = props.element, $[14] = props.indexedPath, $[15] = props.readOnly, $[16] = props.renderChild, $[17] = schema, $[18] = t02) : t02 = $[18], t02;
   }
@@ -7348,34 +7351,15 @@ function createEditableAPI(editor, editorActor) {
       return ![schema.block.name, schema.span.name].includes(element._type);
     },
     findByPath: (path2) => {
-      const blockKey = getBlockKeyFromSelectionPoint({
-        path: path2
-      });
-      if (!blockKey)
+      const indexedPath = keyedPathToIndexedPath(editor, path2, editor.blockIndexMap);
+      if (!indexedPath)
         return [void 0, void 0];
-      const blockIndex = editor.blockIndexMap.get(blockKey);
-      if (blockIndex === void 0)
-        return [void 0, void 0];
-      const block = editor.children.at(blockIndex);
-      if (!block)
-        return [void 0, void 0];
-      const childKey = getChildKeyFromSelectionPoint({
-        path: path2
-      });
-      if (path2.length === 1 && !childKey)
-        return [block, [{
-          _key: block._key
-        }]];
-      if (isTextBlock(editorActor.getSnapshot().context, block) && childKey) {
-        const child = block.children.find((child2) => child2._key === childKey);
-        if (child)
-          return [child, [{
-            _key: block._key
-          }, "children", {
-            _key: child._key
-          }]];
-      }
-      return [void 0, void 0];
+      const result = getNode({
+        schema: editor.schema,
+        editableTypes: editor.editableTypes,
+        value: editor.children
+      }, indexedPath);
+      return result ? [result.node, path2] : [void 0, void 0];
     },
     findDOMNode: (element) => {
       let node;
@@ -7790,915 +7774,303 @@ function createHistoryPlugin({
     }, editor;
   };
 }
-function isEnd(editor, point2, at) {
-  const editorEnd = end(editor, at);
-  return pointEquals(point2, editorEnd);
+function cloneDiff(diff2) {
+  const [type, patch] = diff2;
+  return [type, patch];
 }
-function isStart(editor, point2, at) {
-  if (point2.offset !== 0)
-    return !1;
-  const editorStart = start(editor, at);
-  return pointEquals(point2, editorStart);
+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 isEdge(editor, point2, at) {
-  return isStart(editor, point2, at) || isEnd(editor, point2, at);
+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 pathRef(editor, path2, options = {}) {
-  const {
-    affinity = "forward"
-  } = options, ref = {
-    current: path2,
-    affinity,
-    unref() {
-      const {
-        current
-      } = ref;
-      return editor.pathRefs.delete(ref), ref.current = null, current;
-    }
-  };
-  return editor.pathRefs.add(ref), ref;
+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 isNormalizing(editor) {
-  return editor.normalizing;
+function isHighSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 55296 && charCode <= 56319;
 }
-function normalize(editor, options = {}) {
-  const {
-    force = !1,
-    operation
-  } = options, getDirtyPaths2 = (editor2) => editor2.dirtyPaths, getDirtyPathKeys = (editor2) => editor2.dirtyPathKeys, popDirtyPath = (editor2) => {
-    const path2 = getDirtyPaths2(editor2).pop(), key = path2.length === 1 ? String(path2[0]) : path2.length === 2 ? `${path2[0]},${path2[1]}` : path2.join(",");
-    return getDirtyPathKeys(editor2).delete(key), path2;
-  };
-  if (isNormalizing(editor)) {
-    if (force) {
-      const allPaths = Array.from(getNodes(editor), (entry) => entry.path), allPathKeys = new Set(allPaths.map((p) => p.join(",")));
-      editor.dirtyPaths = allPaths, editor.dirtyPathKeys = allPathKeys;
-    }
-    getDirtyPaths2(editor).length !== 0 && withoutNormalizing(editor, () => {
-      for (const dirtyPath of getDirtyPaths2(editor))
-        if (dirtyPath.length !== 0 && hasNode(editor, dirtyPath)) {
-          const entry = getNode(editor, dirtyPath);
-          if (!entry)
-            continue;
-          const entryNode = entry.node;
-          isTextBlock({
-            schema: editor.schema
-          }, entryNode) && entryNode.children.length === 0 && editor.normalizeNode([entry.node, entry.path], {
-            operation
-          });
-        }
-      let dirtyPaths = getDirtyPaths2(editor);
-      const initialDirtyPathsLength = dirtyPaths.length;
-      let iteration = 0;
-      for (; dirtyPaths.length !== 0; ) {
-        if (!editor.shouldNormalize({
-          dirtyPaths,
-          iteration,
-          initialDirtyPathsLength,
-          operation
-        }))
-          return;
-        const dirtyPath = popDirtyPath(editor);
-        if (dirtyPath.length === 0)
-          editor.normalizeNode([editor, dirtyPath], {
-            operation
-          });
-        else if (hasNode(editor, dirtyPath)) {
-          const entry = getNode(editor, dirtyPath);
-          entry && editor.normalizeNode([entry.node, entry.path], {
-            operation
-          });
+function isLowSurrogate(char) {
+  const charCode = char.charCodeAt(0);
+  return charCode >= 56320 && charCode <= 57343;
+}
+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);
         }
-        iteration++, dirtyPaths = getDirtyPaths2(editor);
       }
-    });
+    }
+    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 setNormalizing(editor, isNormalizing2) {
-  editor.normalizing = isNormalizing2;
+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 withoutNormalizing(editor, fn) {
-  const value = isNormalizing(editor);
-  setNormalizing(editor, !1);
-  try {
-    fn();
-  } finally {
-    setNormalizing(editor, value);
+function findHalfMatch(text1, text2, timeout = 1) {
+  if (timeout <= 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;
   }
-  normalize(editor);
-}
-function rangeRefAffinities(range2, affinity) {
-  if (affinity === "inward") {
-    const isCollapsed = isCollapsedRange(range2);
-    if (isForwardRange(range2)) {
-      const anchorAffinity = "forward";
-      return [anchorAffinity, isCollapsed ? anchorAffinity : "backward"];
-    } else {
-      const anchorAffinity = "backward";
-      return [anchorAffinity, isCollapsed ? anchorAffinity : "forward"];
-    }
-  } else return affinity === "outward" ? isForwardRange(range2) ? ["backward", "forward"] : ["forward", "backward"] : [affinity, affinity];
+  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 applySplitNode(editor, path2, position) {
-  const nodeEntry = getNode(editor, path2);
-  if (!nodeEntry)
-    return;
-  const node = nodeEntry.node;
-  for (const ref of editor.pathRefs) {
-    const current = ref.current;
-    current && (ref.current = transformPathForSplit(current, path2, position, ref.affinity ?? "forward"));
+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));
   }
-  for (const ref of editor.pointRefs) {
-    const current = ref.current;
-    current && (ref.current = transformPointForSplit(current, path2, position, ref.affinity ?? "forward"));
+  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("");
   }
-  for (const ref of editor.rangeRefs) {
-    const current = ref.current;
-    if (current) {
-      const [anchorAffinity, focusAffinity] = rangeRefAffinities(current, ref.affinity), anchor = transformPointForSplit(current.anchor, path2, position, anchorAffinity ?? "forward"), focus = transformPointForSplit(current.focus, path2, position, focusAffinity ?? "forward");
-      anchor && focus ? ref.current = {
-        anchor,
-        focus
-      } : (ref.current = null, ref.unref());
+}
+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;
   }
-  if (editor.selection) {
-    const anchor = transformPointForSplit(editor.selection.anchor, path2, position, "forward"), focus = transformPointForSplit(editor.selection.focus, path2, position, "forward");
-    anchor && focus && (editor.selection = {
-      anchor,
-      focus
-    });
-  }
-  const pathRefs = new Set(editor.pathRefs), pointRefs = new Set(editor.pointRefs), rangeRefs = new Set(editor.rangeRefs);
-  editor.pathRefs.clear(), editor.pointRefs.clear(), editor.rangeRefs.clear();
-  const savedSelection = editor.selection;
-  try {
-    withoutNormalizing(editor, () => {
-      if (isSpan({
-        schema: editor.schema
-      }, node)) {
-        const {
-          text: _text,
-          ...properties
-        } = node, afterText = node.text.slice(position), newNode = {
-          ...properties,
-          text: afterText
-        };
-        editor.apply({
-          type: "remove_text",
-          path: path2,
-          offset: position,
-          text: afterText
-        }), editor.apply({
-          type: "insert_node",
-          path: nextPath(path2),
-          node: newNode
-        });
-      } else if (isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        const {
-          children: _children,
-          ...properties
-        } = node, children = node.children, afterChildren = children.slice(position), newNode = {
-          ...properties,
-          children: afterChildren
-        };
-        for (let i = children.length - 1; i >= position; i--)
-          editor.apply({
-            type: "remove_node",
-            path: [...path2, i],
-            node: children[i]
-          });
-        editor.apply({
-          type: "insert_node",
-          path: nextPath(path2),
-          node: newNode
-        });
-      }
-    });
-  } finally {
-    editor.selection = savedSelection;
-    for (const ref of pathRefs)
-      editor.pathRefs.add(ref);
-    for (const ref of pointRefs)
-      editor.pointRefs.add(ref);
-    for (const ref of rangeRefs)
-      editor.rangeRefs.add(ref);
-  }
-}
-function transformPathForSplit(path2, splitPath, position, affinity = "forward") {
-  const p = [...path2];
-  return pathEquals(splitPath, p) ? affinity === "forward" && (p[p.length - 1] = p[p.length - 1] + 1) : pathEndsBefore(splitPath, p) ? p[splitPath.length - 1] = p[splitPath.length - 1] + 1 : isAncestorPath(splitPath, p) && path2[splitPath.length] >= position && (p[splitPath.length - 1] = p[splitPath.length - 1] + 1, p[splitPath.length] = p[splitPath.length] - position), p;
-}
-function transformPointForSplit(point2, splitPath, position, affinity = "forward") {
-  let {
-    path: path2,
-    offset
-  } = point2;
-  return pathEquals(splitPath, path2) ? (position < offset || position === offset && affinity === "forward") && (offset -= position, path2 = transformPathForSplit(path2, splitPath, position, "forward")) : path2 = transformPathForSplit(path2, splitPath, position, affinity), {
-    path: path2,
-    offset
+  let maxLines = 4e4;
+  const chars1 = diffLinesToMunge(textA);
+  maxLines = 65535;
+  const chars2 = diffLinesToMunge(textB);
+  return {
+    chars1,
+    chars2,
+    lineArray
   };
 }
-function applyInsertNodeAtPath(editor, node, path2) {
-  editor.apply({
-    type: "insert_node",
-    path: path2,
-    node
+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
   });
-  const point2 = end(editor, path2);
-  point2 && applySelect(editor, point2);
-}
-function applyInsertNodeAtPoint(editor, node, at) {
-  withoutNormalizing(editor, () => {
-    const match2 = isSpan({
-      schema: editor.schema
-    }, node) ? (n) => isSpan({
-      schema: editor.schema
-    }, n) : (n) => isSpan({
-      schema: editor.schema
-    }, n) || isObjectNode({
-      schema: editor.schema
-    }, n), nodeEntry = getNode(editor, at.path), entry = nodeEntry && match2(nodeEntry.node) ? nodeEntry : void 0;
-    if (!entry)
-      return;
-    const matchPath2 = entry.path, ref = pathRef(editor, matchPath2), isAtEnd = isEnd(editor, at, matchPath2);
-    isEdge(editor, at, matchPath2) || applySplitNode(editor, at.path, at.offset);
-    const path2 = ref.unref(), insertPath = isAtEnd ? nextPath(path2) : path2;
-    editor.apply({
-      type: "insert_node",
-      path: insertPath,
-      node
-    });
-    const point2 = end(editor, insertPath);
-    point2 && applySelect(editor, point2);
-  });
-}
-function previousPath(path2) {
-  if (path2.length === 0)
-    throw new Error(`Cannot get the previous path of a root path [${path2}], because it has no previous index.`);
-  const last = path2[path2.length - 1];
-  if (last <= 0)
-    throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
-  return path2.slice(0, -1).concat(last - 1);
-}
-function applyMergeNode(editor, path2, position) {
-  const nodeEntry = getNode(editor, path2);
-  if (!nodeEntry)
-    return;
-  const node = nodeEntry.node, prevPath = previousPath(path2);
-  for (const ref of editor.pathRefs) {
-    const current = ref.current;
-    current && (ref.current = transformPathForMerge(current, path2, position));
-  }
-  for (const ref of editor.pointRefs) {
-    const current = ref.current;
-    current && (ref.current = transformPointForMerge(current, path2, position));
-  }
-  for (const ref of editor.rangeRefs) {
-    const current = ref.current;
-    if (current) {
-      const anchor = transformPointForMerge(current.anchor, path2, position), focus = transformPointForMerge(current.focus, path2, position);
-      anchor && focus ? ref.current = {
-        anchor,
-        focus
-      } : (ref.current = null, ref.unref());
-    }
-  }
-  if (editor.selection) {
-    const anchor = transformPointForMerge(editor.selection.anchor, path2, position), focus = transformPointForMerge(editor.selection.focus, path2, position);
-    anchor && focus && (editor.selection = {
-      anchor,
-      focus
-    });
-  }
-  const pathRefs = new Set(editor.pathRefs), pointRefs = new Set(editor.pointRefs), rangeRefs = new Set(editor.rangeRefs);
-  editor.pathRefs.clear(), editor.pointRefs.clear(), editor.rangeRefs.clear();
-  const savedSelection = editor.selection, editorAny = editor, savedPendingDiffs = editorAny.pendingDiffs, savedPendingSelection = editorAny.pendingSelection, savedPendingAction = editorAny.pendingAction;
-  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, path2, position)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
-    const sel = savedPendingSelection, anchor = transformPointForMerge(sel.anchor, path2, position), focus = transformPointForMerge(sel.focus, path2, position);
-    editorAny.pendingSelection = anchor && focus ? {
-      anchor,
-      focus
-    } : null;
-  }
-  if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
-    const action = savedPendingAction;
-    if ("offset" in action.at && typeof action.at.offset == "number") {
-      const at = transformPointForMerge(action.at, path2, position);
-      editorAny.pendingAction = at ? {
-        ...action,
-        at
-      } : null;
-    } else if (isRange(action.at)) {
-      const anchor = transformPointForMerge(action.at.anchor, path2, position), focus = transformPointForMerge(action.at.focus, path2, position);
-      editorAny.pendingAction = anchor && focus ? {
-        ...action,
-        at: {
-          anchor,
-          focus
+  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;
         }
-      } : null;
+        countInsert = 0, countDelete = 0, textDelete = "", textInsert = "";
+        break;
+      default:
+        throw new Error("Unknown diff operation.");
     }
+    pointer++;
   }
-  const preTransformedPendingDiffs = editorAny.pendingDiffs, preTransformedPendingSelection = editorAny.pendingSelection, preTransformedPendingAction = editorAny.pendingAction;
-  editorAny.pendingDiffs = [], editorAny.pendingSelection = null, editorAny.pendingAction = null;
-  try {
-    withoutNormalizing(editor, () => {
-      if (isSpan({
-        schema: editor.schema
-      }, node))
-        node.text.length > 0 && editor.apply({
-          type: "insert_text",
-          path: prevPath,
-          offset: position,
-          text: node.text
-        }), editor.apply({
-          type: "remove_node",
-          path: path2,
-          node
-        });
-      else if (isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        for (let i = 0; i < node.children.length; i++)
-          editor.apply({
-            type: "insert_node",
-            path: [...prevPath, position + i],
-            node: node.children[i]
-          });
-        editor.apply({
-          type: "remove_node",
-          path: path2,
-          node
-        });
-      }
-    });
-  } finally {
-    editor.selection = savedSelection;
-    for (const ref of pathRefs)
-      editor.pathRefs.add(ref);
-    for (const ref of pointRefs)
-      editor.pointRefs.add(ref);
-    for (const ref of rangeRefs)
-      editor.rangeRefs.add(ref);
-    editorAny.pendingDiffs = preTransformedPendingDiffs, editorAny.pendingSelection = preTransformedPendingSelection, editorAny.pendingAction = preTransformedPendingAction;
-  }
+  return diffs.pop(), diffs;
 }
-function transformTextDiffForMerge(textDiff, mergePath, position) {
-  const {
-    path: path2,
-    diff: diff2,
-    id
-  } = textDiff;
-  if (!pathEquals(mergePath, path2)) {
-    const newPath = transformPathForMerge(path2, mergePath, position);
-    return newPath ? {
-      diff: diff2,
-      id,
-      path: newPath
-    } : null;
+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 {
-    diff: {
-      start: diff2.start + position,
-      end: diff2.end + position,
-      text: diff2.text
-    },
-    id,
-    path: transformPathForMerge(path2, mergePath, position)
-  };
+  return opts.checkLines && text1.length > 100 && text2.length > 100 ? doLineModeDiff(text1, text2, opts) : bisect(text1, text2, opts.deadline);
 }
-function transformPathForMerge(path2, mergePath, position) {
-  const p = [...path2];
-  return pathEquals(mergePath, p) || pathEndsBefore(mergePath, p) ? p[mergePath.length - 1] = p[mergePath.length - 1] - 1 : isAncestorPath(mergePath, p) && (p[mergePath.length - 1] = p[mergePath.length - 1] - 1, p[mergePath.length] = p[mergePath.length] + position), p;
+var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
+  enumerable: !0,
+  configurable: !0,
+  writable: !0,
+  value
+}) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {})) __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2) for (var prop of __getOwnPropSymbols$2(b)) __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+};
+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 transformPointForMerge(point2, mergePath, position) {
-  let {
-    path: path2,
-    offset
-  } = point2;
-  return pathEquals(mergePath, path2) && (offset += position), path2 = transformPathForMerge(path2, mergePath, position), {
-    path: path2,
-    offset
-  };
+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 applySetNode(editor, props, path2) {
-  const nodeEntry = getNode(editor, path2);
-  if (!nodeEntry)
-    return;
-  const node = nodeEntry.node, nodeRecord = node, propsRecord = props, properties = {}, newProperties = {};
-  for (const key of Object.keys(propsRecord))
-    key !== "children" && (key === "text" && isSpanNode({
-      schema: editor.schema
-    }, node) || propsRecord[key] !== nodeRecord[key] && (nodeRecord.hasOwnProperty(key) && (properties[key] = nodeRecord[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key])));
-  (Object.keys(newProperties).length > 0 || Object.keys(properties).length > 0) && editor.apply({
-    type: "set_node",
-    path: path2,
-    properties,
-    newProperties
-  });
+function createDeadLine(timeout) {
+  let t = 1;
+  return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
 }
-function withNormalizeNode(editor, fn) {
-  const prev = editor.isNormalizingNode;
-  editor.isNormalizingNode = !0, fn(), editor.isNormalizingNode = prev;
+function createInternalOpts(opts) {
+  return __spreadValues$2({
+    checkLines: !0,
+    deadline: createDeadLine(opts.timeout || 1)
+  }, opts);
 }
-function withoutPatching(editor, fn) {
-  const prev = editor.isPatching;
-  editor.isPatching = !1, fn(), editor.isPatching = prev;
+function combineChar(data, char, dir) {
+  return dir === 1 ? data + char : char + data;
 }
-function createNormalizationPlugin(editorActor) {
-  return function(editor) {
-    const {
-      apply: apply2,
-      normalizeNode: normalizeNode2
-    } = editor, defaultStyle = editorActor.getSnapshot().context.schema.styles.at(0)?.name;
-    return editor.normalizeNode = (nodeEntry) => {
-      const [node, path2] = nodeEntry;
-      if (isEditor(node) && node.children.length === 0 && withoutPatching(editor, () => {
-        withNormalizeNode(editor, () => {
-          applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0]);
-        });
-      }), isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        const children = getChildren(editor, path2);
-        for (const {
-          node: child,
-          path: childPath
-        } of children) {
-          const childIndex = childPath[childPath.length - 1], nextNode = node.children[childIndex + 1];
-          if (isSpan({
-            schema: editor.schema
-          }, child) && isSpan({
-            schema: editor.schema
-          }, nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
-            debug$1.normalization("merging spans with same marks"), withNormalizeNode(editor, () => {
-              const mergePath = [childPath[0], childPath[1] + 1];
-              applyMergeNode(editor, mergePath, child.text.length);
-            });
-            return;
-          }
-        }
-      }
-      if (isTextBlockNode({
-        schema: editor.schema
-      }, node) && !Array.isArray(node.markDefs)) {
-        debug$1.normalization("adding .markDefs to block node"), withNormalizeNode(editor, () => {
-          applySetNode(editor, {
-            markDefs: []
-          }, path2);
-        });
-        return;
-      }
-      if (defaultStyle && isTextBlockNode({
-        schema: editor.schema
-      }, node) && typeof node.style > "u") {
-        debug$1.normalization("adding .style to block node"), withNormalizeNode(editor, () => {
-          applySetNode(editor, {
-            style: defaultStyle
-          }, path2);
-        });
-        return;
-      }
-      if (isSpanNode({
-        schema: editor.schema
-      }, node) && typeof node.text != "string") {
-        debug$1.normalization("Adding .text to span node"), withNormalizeNode(editor, () => {
-          editor.apply({
-            type: "set_node",
-            path: path2,
-            properties: {},
-            newProperties: {
-              text: ""
-            }
-          });
-        });
-        return;
-      }
-      if (isSpan({
-        schema: editor.schema
-      }, node) && !Array.isArray(node.marks)) {
-        debug$1.normalization("Adding .marks to span node"), withNormalizeNode(editor, () => {
-          applySetNode(editor, {
-            marks: []
-          }, path2);
-        });
-        return;
-      }
-      if (isSpan({
-        schema: editor.schema
-      }, node)) {
-        const blockPath = parentPath(path2);
-        if (!getTextBlockNode(editor, blockPath))
-          return;
-        const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators.includes(mark));
-        if (node.text === "" && annotations && annotations.length > 0) {
-          debug$1.normalization("removing annotations from empty span node"), withNormalizeNode(editor, () => {
-            applySetNode(editor, {
-              marks: node.marks?.filter((mark) => decorators.includes(mark))
-            }, path2);
-          });
-          return;
-        }
-      }
-      if (isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name);
-        for (const {
-          node: child,
-          path: childPath
-        } of getChildren(editor, path2))
-          if (isSpan({
-            schema: editor.schema
-          }, child)) {
-            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
-            if (orphanedAnnotations.length > 0) {
-              debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
-                applySetNode(editor, {
-                  marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
-                }, childPath);
-              });
-              return;
-            }
-          }
-      }
-      if (isSpan({
-        schema: editor.schema
-      }, node)) {
-        const blockPath = parentPath(path2), blockEntry2 = getTextBlockNode(editor, blockPath);
-        if (blockEntry2) {
-          const block = blockEntry2.node, decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
-          if (orphanedAnnotations.length > 0) {
-            debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
-              applySetNode(editor, {
-                marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
-              }, path2);
-            });
-            return;
-          }
-        }
-      }
-      if (isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
-        for (const markDef of markDefs)
-          markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
-        if (markDefs.length !== newMarkDefs.length) {
-          debug$1.normalization("removing duplicate markDefs"), withNormalizeNode(editor, () => {
-            applySetNode(editor, {
-              markDefs: newMarkDefs
-            }, path2);
-          });
-          return;
-        }
-      }
-      if (isTextBlock({
-        schema: editor.schema
-      }, node)) {
-        const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => isSpan({
-          schema: editor.schema
-        }, child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
-        if (node.markDefs && !isEqualMarkDefs(newMarkDefs, node.markDefs)) {
-          debug$1.normalization("removing markDef not in use"), withNormalizeNode(editor, () => {
-            applySetNode(editor, {
-              markDefs: newMarkDefs
-            }, path2);
-          });
-          return;
-        }
-      }
-      withNormalizeNode(editor, () => {
-        normalizeNode2(nodeEntry);
-      });
-    }, editor.apply = (op) => {
-      if (editor.isProcessingRemoteChanges) {
-        apply2(op);
-        return;
-      }
-      if (editor.isUndoing || editor.isRedoing) {
-        apply2(op);
-        return;
-      }
-      if (op.type === "set_selection")
-        if (op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
-          const previousSelectionIsCollapsed = isCollapsedRange({
-            anchor: op.properties.anchor,
-            focus: op.properties.focus
-          }), newSelectionIsCollapsed = isCollapsedRange({
-            anchor: op.newProperties.anchor,
-            focus: op.newProperties.focus
-          });
-          if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-            const focusSpan = getSpanNode(editor, op.properties.focus.path)?.node, newFocusSpan = getSpanNode(editor, op.newProperties.focus.path)?.node, movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
-            !movedToNextSpan && !movedToPreviousSpan && (editor.decoratorState = {});
-          }
-        } else
-          editor.decoratorState = {};
-      apply2(op);
-    }, editor;
-  };
-}
-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 isHighSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 55296 && charCode <= 56319;
+function splitChar(data, dir) {
+  return dir === 1 ? [data.substring(0, data.length - 1), data[data.length - 1]] : [data.substring(1), data[0]];
 }
-function isLowSurrogate(char) {
-  const charCode = char.charCodeAt(0);
-  return charCode >= 56320 && charCode <= 57343;
+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 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);
+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;
       }
     }
   }
-  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, timeout = 1) {
-  if (timeout <= 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 (insertIdx !== null && deleteIdx !== null && hasSharedChar(diffs, insertIdx, deleteIdx, dir)) {
+    const [insertText2, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText2] = splitChar(diffs[deleteIdx][1], inv);
+    diffs[insertIdx][1] = insertText2, diffs[deleteIdx][1] = deleteText2, diffs[i][1] = combineChar(diffs[i][1], insertChar, dir);
+    return;
   }
-  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];
+  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 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));
+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);
   }
-  return bestCommon.length * 2 >= longText.length ? [bestLongTextA || "", bestLongTextB || "", bestShortTextA || "", bestShortTextB || "", bestCommon || ""] : null;
+  for (let i = 0; i < diffs.length; i++) diffs[i][1].length === 0 && diffs.splice(i, 1);
 }
-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 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 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 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);
-}
-var __defProp$2 = Object.defineProperty, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
-  enumerable: !0,
-  configurable: !0,
-  writable: !0,
-  value
-}) : obj[key] = value, __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {})) __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2) for (var prop of __getOwnPropSymbols$2(b)) __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
-  return a;
-};
-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 __spreadValues$2({
-    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 [insertText2, insertChar] = splitChar(diffs[insertIdx][1], inv), [deleteText2] = splitChar(diffs[deleteIdx][1], inv);
-    diffs[insertIdx][1] = insertText2, diffs[deleteIdx][1] = deleteText2, 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);
-}
-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;
+  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) {
@@ -9038,6 +8410,35 @@ function parse(textline) {
 function toInt(num) {
   return parseInt(num, 10);
 }
+function pathRef(editor, path2, options = {}) {
+  const {
+    affinity = "forward"
+  } = options, ref = {
+    current: path2,
+    affinity,
+    unref() {
+      const {
+        current
+      } = ref;
+      return editor.pathRefs.delete(ref), ref.current = null, current;
+    }
+  };
+  return editor.pathRefs.add(ref), ref;
+}
+function applySetNode(editor, props, path2) {
+  const nodeEntry = getNode(editor, path2);
+  if (!nodeEntry)
+    return;
+  const nodeRecord = nodeEntry.node, propsRecord = props, properties = {}, newProperties = {};
+  for (const key of Object.keys(propsRecord))
+    propsRecord[key] !== nodeRecord[key] && (nodeRecord.hasOwnProperty(key) && (properties[key] = nodeRecord[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key]));
+  (Object.keys(newProperties).length > 0 || Object.keys(properties).length > 0) && editor.apply({
+    type: "set_node",
+    path: path2,
+    properties,
+    newProperties
+  });
+}
 function toSlateBlock(block, {
   schemaTypes
 }) {
@@ -9283,7 +8684,7 @@ function setPatch(editor, patch) {
     } else
       return applySetNode(editor, updatedBlock, [block.index]), !0;
   }
-  if (blockIsTextBlock && patch.path[1] !== "children") {
+  if (blockIsTextBlock && (patch.path.length === 2 || patch.path[1] !== "children")) {
     const updatedBlock = applyAll(block.node, [{
       ...patch,
       path: patch.path.slice(1)
@@ -9568,13 +8969,13 @@ function setNodePatch(schema, children, operation) {
       const patches = [], _key = operation.newProperties._key;
       _key !== void 0 && patches.push(set(_key, [blockIndex, "_key"]));
       for (const [key, propertyValue] of Object.entries(operation.newProperties))
-        key === "_key" || key === "children" || patches.push(set(propertyValue, [{
+        key !== "_key" && patches.push(set(propertyValue, [{
           _key: block._key
         }, key]));
       for (const key of Object.keys(operation.properties))
-        key === "_key" || key === "children" || key in operation.newProperties || patches.push(unset([{
+        key !== "_key" && (key in operation.newProperties || patches.push(unset([{
           _key: block._key
-        }, key]));
+        }, key])));
       return patches;
     }
   } else if (operation.path.length === 2) {
@@ -9593,7 +8994,7 @@ function setNodePatch(schema, children, operation) {
             _key: blockKey
           }, "children", block.children.indexOf(child), "_key"]));
           for (const [key, propertyValue] of Object.entries(operation.newProperties))
-            key === "_key" || key === "children" || patches.push(set(propertyValue, [{
+            key !== "_key" && patches.push(set(propertyValue, [{
               _key: blockKey
             }, "children", {
               _key: childKey
@@ -9673,6 +9074,75 @@ function removeNodePatch(schema, beforeValue, operation) {
   } else
     return [];
 }
+function isNormalizing(editor) {
+  return editor.normalizing;
+}
+function setNormalizing(editor, isNormalizing2) {
+  editor.normalizing = isNormalizing2;
+}
+function withoutNormalizing(editor, fn) {
+  const value = isNormalizing(editor);
+  setNormalizing(editor, !1);
+  try {
+    fn();
+  } finally {
+    setNormalizing(editor, value);
+  }
+  normalize(editor);
+}
+function normalize(editor, options = {}) {
+  const {
+    force = !1,
+    operation
+  } = options, getDirtyPaths = (editor2) => editor2.dirtyPaths, getDirtyPathKeys = (editor2) => editor2.dirtyPathKeys, popDirtyPath = (editor2) => {
+    const path2 = getDirtyPaths(editor2).pop(), key = path2.length === 1 ? String(path2[0]) : path2.length === 2 ? `${path2[0]},${path2[1]}` : path2.join(",");
+    return getDirtyPathKeys(editor2).delete(key), path2;
+  };
+  if (isNormalizing(editor)) {
+    if (force) {
+      const allPaths = Array.from(getNodes(editor), (entry) => entry.path), allPathKeys = new Set(allPaths.map((p) => p.join(",")));
+      editor.dirtyPaths = allPaths, editor.dirtyPathKeys = allPathKeys;
+    }
+    getDirtyPaths(editor).length !== 0 && withoutNormalizing(editor, () => {
+      for (const dirtyPath of getDirtyPaths(editor))
+        if (dirtyPath.length !== 0 && hasNode(editor, dirtyPath)) {
+          const entry = getNode(editor, dirtyPath);
+          if (!entry)
+            continue;
+          const entryNode = entry.node;
+          isTextBlock({
+            schema: editor.schema
+          }, entryNode) && entryNode.children.length === 0 && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
+            operation
+          }), editor.isNormalizingNode = !1);
+        }
+      let dirtyPaths = getDirtyPaths(editor);
+      const initialDirtyPathsLength = dirtyPaths.length;
+      let iteration = 0;
+      for (; dirtyPaths.length !== 0; ) {
+        if (!editor.shouldNormalize({
+          dirtyPaths,
+          iteration,
+          initialDirtyPathsLength,
+          operation
+        }))
+          return;
+        const dirtyPath = popDirtyPath(editor);
+        if (dirtyPath.length === 0)
+          editor.isNormalizingNode = !0, editor.normalizeNode([editor, dirtyPath], {
+            operation
+          }), editor.isNormalizingNode = !1;
+        else if (hasNode(editor, dirtyPath)) {
+          const entry = getNode(editor, dirtyPath);
+          entry && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
+            operation
+          }), editor.isNormalizingNode = !1);
+        }
+        iteration++, dirtyPaths = getDirtyPaths(editor);
+      }
+    });
+  }
+}
 function withRemoteChanges(editor, fn) {
   const prev = editor.isProcessingRemoteChanges;
   editor.isProcessingRemoteChanges = !0, fn(), editor.isProcessingRemoteChanges = prev;
@@ -9681,6 +9151,10 @@ function pluginWithoutHistory(editor, fn) {
   const prev = editor.withHistory;
   editor.withHistory = !1, fn(), editor.withHistory = prev;
 }
+function withoutPatching(editor, fn) {
+  const prev = editor.isPatching;
+  editor.isPatching = !1, fn(), editor.isPatching = prev;
+}
 function createPatchesPlugin({
   editorActor,
   relayActor,
@@ -9772,136 +9246,8 @@ function createPatchesPlugin({
     }, editor;
   };
 }
-function createSchemaPlugin({
-  editorActor
-}) {
-  return function(editor) {
-    editor.schema = editorActor.getSnapshot().context.schema, editor.isInline = (element) => {
-      if (isEditor(element))
-        return !1;
-      const snapshot = editorActor.getSnapshot();
-      if (!snapshot.context.schema.inlineObjects.map((obj) => obj.name).includes(element._type))
-        return !1;
-      if (snapshot.context.schema.blockObjects.map((obj) => obj.name).includes(element._type)) {
-        for (const child of editor.children)
-          if (child === element)
-            return !1;
-      }
-      return !0;
-    };
-    const {
-      normalizeNode: normalizeNode2
-    } = editor;
-    return editor.normalizeNode = (entry) => {
-      const [node, path2] = entry;
-      if (isEditor(node)) {
-        normalizeNode2(entry);
-        return;
-      }
-      if (node._type === void 0 && path2.length === 2) {
-        debug$1.normalization("Setting span type on text node without a type");
-        const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
-        withNormalizeNode(editor, () => {
-          applySetNode(editor, {
-            ...span,
-            _type: editorActor.getSnapshot().context.schema.span.name,
-            _key: key
-          }, path2);
-        });
-        return;
-      }
-      if (node._key === void 0 && (path2.length === 1 || path2.length === 2)) {
-        debug$1.normalization("Setting missing key on child node without a key");
-        const key = editorActor.getSnapshot().context.keyGenerator();
-        withNormalizeNode(editor, () => {
-          applySetNode(editor, {
-            _key: key
-          }, path2);
-        });
-        return;
-      }
-      withNormalizeNode(editor, () => {
-        normalizeNode2(entry);
-      });
-    }, editor;
-  };
-}
-function createUniqueKeysPlugin(editorActor) {
-  const context = editorActor.getSnapshot().context;
-  return function(editor) {
-    const {
-      apply: apply2,
-      normalizeNode: normalizeNode2
-    } = editor;
-    return editor.apply = (operation) => {
-      if (editor.isProcessingRemoteChanges) {
-        apply2(operation);
-        return;
-      }
-      if (editor.isUndoing || editor.isRedoing) {
-        apply2(operation);
-        return;
-      }
-      if (operation.type === "insert_node" && !isEditor(operation.node)) {
-        const _key = operation.node._key && keyExistsAtPath({
-          blockIndexMap: editor.blockIndexMap,
-          context: {
-            schema: context.schema,
-            value: editor.children
-          }
-        }, operation.path, operation.node._key) ? void 0 : operation.node._key;
-        apply2({
-          ...operation,
-          node: {
-            ...operation.node,
-            _key: _key === void 0 ? editorActor.getSnapshot().context.keyGenerator() : _key
-          }
-        });
-        return;
-      }
-      apply2(operation);
-    }, editor.normalizeNode = (entry) => {
-      const [_node, path2] = entry, parent = getParent(editor, path2), siblings = parent ? getChildren(editor, parent.path) : editor.children.map((child, index) => ({
-        node: child,
-        path: [index]
-      })), siblingKeys = /* @__PURE__ */ new Set();
-      for (const sibling of siblings) {
-        if (sibling.node._key && siblingKeys.has(sibling.node._key)) {
-          const _key = editorActor.getSnapshot().context.keyGenerator();
-          siblingKeys.add(_key), withNormalizeNode(editor, () => {
-            applySetNode(editor, {
-              _key
-            }, path2);
-          });
-          return;
-        }
-        if (!sibling.node._key) {
-          const _key = editorActor.getSnapshot().context.keyGenerator();
-          siblingKeys.add(_key), withNormalizeNode(editor, () => {
-            applySetNode(editor, {
-              _key
-            }, path2);
-          });
-          return;
-        }
-        siblingKeys.add(sibling.node._key);
-      }
-      withNormalizeNode(editor, () => {
-        normalizeNode2(entry);
-      });
-    }, editor;
-  };
-}
-function keyExistsAtPath(snapshot, path2, key) {
-  if (path2.length === 1)
-    return snapshot.blockIndexMap.has(key);
-  if (path2.length > 2)
-    return !1;
-  const parentBlockIndex = path2.at(0), parentBlock = parentBlockIndex !== void 0 ? snapshot.context.value.at(parentBlockIndex) : void 0;
-  return !parentBlock || !isTextBlock(snapshot.context, parentBlock) ? !1 : parentBlock.children.some((child) => child._key === key);
-}
-function updateSelectionPlugin({
-  editor,
+function updateSelectionPlugin({
+  editor,
   editorActor
 }) {
   const updateSelection = () => {
@@ -9963,21 +9309,100 @@ const plugins = (editor, options) => {
   const e = editor, {
     editorActor,
     relayActor
-  } = options, uniqueKeysPlugin = createUniqueKeysPlugin(editorActor), schemaPlugin = createSchemaPlugin({
-    editorActor
-  }), patchesPlugin = createPatchesPlugin({
+  } = options, patchesPlugin = createPatchesPlugin({
     editorActor,
     relayActor,
     subscriptions: options.subscriptions
   }), historyPlugin = createHistoryPlugin({
     editorActor,
     subscriptions: options.subscriptions
-  }), normalizationPlugin = createNormalizationPlugin(editorActor);
-  return createBehaviorApiPlugin(editorActor)(schemaPlugin(uniqueKeysPlugin(normalizationPlugin(historyPlugin(patchesPlugin(updateValuePlugin(editorActor.getSnapshot().context, updateSelectionPlugin({
+  });
+  return createBehaviorApiPlugin(editorActor)(historyPlugin(patchesPlugin(updateValuePlugin(editorActor.getSnapshot().context, updateSelectionPlugin({
     editorActor,
     editor: e
-  }))))))));
-}, PathRef = {
+  })))));
+};
+function pathLevels(path2) {
+  const list = [];
+  for (let i = 0; i <= path2.length; i++)
+    list.push(path2.slice(0, i));
+  return list;
+}
+function getChildFieldName(context, path2) {
+  let nodeChildren = getNodeChildren({
+    schema: context.schema,
+    editableTypes: context.editableTypes
+  }, {
+    value: context.value
+  }, void 0, "");
+  for (let i = 0; i < path2.length; i++) {
+    if (!nodeChildren)
+      return;
+    const index = path2.at(i);
+    if (index === void 0)
+      return;
+    const node = nodeChildren.children.at(index);
+    if (!node)
+      return;
+    if (i === path2.length - 1)
+      return getNodeChildren({
+        schema: context.schema,
+        editableTypes: context.editableTypes
+      }, node, nodeChildren.scope, nodeChildren.scopePath)?.fieldName;
+    nodeChildren = getNodeChildren({
+      schema: context.schema,
+      editableTypes: context.editableTypes
+    }, node, nodeChildren.scope, nodeChildren.scopePath);
+  }
+}
+function getDirtyIndexedPaths(context, op) {
+  switch (op.type) {
+    case "insert_text":
+    case "remove_text":
+    case "set_node": {
+      const {
+        path: path2
+      } = op, levels = pathLevels(path2);
+      if (op.type === "set_node") {
+        const childFieldName = getChildFieldName(context, path2);
+        if (childFieldName) {
+          const newChildren = op.newProperties[childFieldName];
+          if (Array.isArray(newChildren))
+            for (let i = 0; i < newChildren.length; i++) {
+              const child = newChildren[i];
+              if (typeof child != "object" || child === null)
+                continue;
+              const childPath = [...path2, i];
+              levels.push(childPath);
+              for (const entry of getNodeDescendants(context, child))
+                levels.push(childPath.concat(entry.path));
+            }
+        }
+      }
+      return levels;
+    }
+    case "insert_node": {
+      const {
+        node,
+        path: path2
+      } = op, levels = pathLevels(path2);
+      if (isSpan(context, node))
+        return levels;
+      for (const entry of getNodeDescendants(context, node))
+        levels.push(path2.concat(entry.path));
+      return levels;
+    }
+    case "remove_node": {
+      const {
+        path: path2
+      } = op;
+      return [...pathLevels(path2).slice(0, -1)];
+    }
+    default:
+      return [];
+  }
+}
+const PathRef = {
   transform(ref, op) {
     const {
       current
@@ -10062,7 +9487,7 @@ function replaceChildren(xs, index, removeCount, ...newValues) {
 }
 const removeChildren = replaceChildren, modifyDescendant = (root, path2, schema, f) => {
   if (path2.length === 0)
-    throw new Error("Cannot modify the editor");
+    return;
   const editableTypes = isEditor(root) ? root.editableTypes : /* @__PURE__ */ new Set(), context = {
     schema,
     editableTypes
@@ -10070,28 +9495,42 @@ const removeChildren = replaceChildren, modifyDescendant = (root, path2, schema,
     schema
   }, root) ? root : void 0;
   if (!typedRoot)
-    throw new Error("Cannot modify descendant: root has no children");
+    return;
   const nodeEntry = getNode({
     ...context,
     value: typedRoot.children
   }, path2);
   if (!nodeEntry)
-    throw new Error(`Cannot find a descendant at path [${path2}]`);
+    return;
   const node = nodeEntry.node, slicedPath = path2.slice();
   let modifiedNode = f(node);
+  const fieldNames = [];
+  {
+    let currentNode = {
+      value: typedRoot.children
+    }, scope, scopePath = "";
+    for (let i = 0; i < path2.length; i++) {
+      const result = getNodeChildren(context, currentNode, scope, scopePath);
+      if (!result)
+        return;
+      fieldNames.push(result.fieldName);
+      const child = result.children.at(path2.at(i));
+      if (!child)
+        return;
+      currentNode = child, scope = result.scope, scopePath = result.scopePath;
+    }
+  }
   for (; slicedPath.length > 1; ) {
-    const index2 = slicedPath.pop(), ancestorEntry = getNode({
+    const index2 = slicedPath.pop(), level = slicedPath.length, fieldName = fieldNames.at(level), ancestorEntry = getNode({
       ...context,
       value: typedRoot.children
     }, slicedPath);
     if (!ancestorEntry)
-      throw new Error(`Cannot find ancestor at path [${slicedPath}]`);
-    const ancestorNode = ancestorEntry.node;
+      return;
+    const ancestorNode = ancestorEntry.node, ancestorRecord = ancestorNode, currentChildren = Array.isArray(ancestorRecord[fieldName]) ? ancestorRecord[fieldName] : [];
     modifiedNode = {
       ...ancestorNode,
-      children: replaceChildren(isTextBlock({
-        schema
-      }, ancestorNode) ? ancestorNode.children : [], index2, 1, modifiedNode)
+      [fieldName]: replaceChildren(currentChildren, index2, 1, modifiedNode)
     };
   }
   const index = slicedPath.pop(), newRootChildren = replaceChildren(isEditor(root) || isTextBlock({
@@ -10101,35 +9540,32 @@ const removeChildren = replaceChildren, modifyDescendant = (root, path2, schema,
 }, modifyChildren = (root, path2, schema, f) => {
   path2.length === 0 ? root.children = f(isEditor(root) || isTextBlock({
     schema
-  }, root) ? root.children : []) : modifyDescendant(root, path2, schema, (node) => {
-    if (isSpan({
-      schema
-    }, node) || isObjectNode({
+  }, root) ? root.children : []) : modifyDescendant(root, path2, schema, (node) => ({
+    ...node,
+    children: f(isTextBlock({
       schema
-    }, node))
-      throw new Error(`Cannot get the element at path [${path2}] because it refers to a leaf node: ${safeStringify(node)}`);
-    return {
-      ...node,
-      children: f(isTextBlock({
-        schema
-      }, node) ? node.children : [])
-    };
-  });
-}, modifyLeaf = (root, path2, schema, f) => modifyDescendant(root, path2, schema, (node) => {
-  if (!isSpan({
-    schema
-  }, node))
-    throw new Error(`Cannot get the leaf node at path [${path2}] because it refers to a non-leaf node: ${safeStringify(node)}`);
-  return f(node);
-});
+    }, node) ? node.children : [])
+  }));
+}, modifyLeaf = (root, path2, schema, f) => modifyDescendant(root, path2, schema, (node) => isSpan({
+  schema
+}, node) ? f(node) : node);
 function applyOperation(editor, op) {
   let transformSelection = !1;
   switch (op.type) {
     case "insert_node": {
       const {
-        path: path2,
+        path: path2
+      } = op;
+      let {
         node
       } = op;
+      if (!editor.isProcessingRemoteChanges && !editor.isUndoing && !editor.isRedoing && node._key !== void 0) {
+        const insertParentPath = parentPath(path2);
+        (insertParentPath.length === 0 ? editor.children : getChildren(editor, insertParentPath).map((entry) => entry.node)).some((sibling) => sibling._key === node._key) && (node = {
+          ...node,
+          _key: editor.keyGenerator()
+        }, op.node = node);
+      }
       modifyChildren(editor, parentPath(path2), editor.schema, (children) => {
         const index = path2[path2.length - 1];
         if (index > children.length)
@@ -10226,15 +9662,13 @@ function applyOperation(editor, op) {
           ...node
         };
         for (const key in newProperties) {
-          if (key === "children")
-            throw new Error(`Cannot set the "${key}" property of nodes!`);
           const value = newProperties[key];
           value == null ? delete newNode[key] : newNode[key] = value;
         }
         for (const key in properties)
           newProperties.hasOwnProperty(key) || delete newNode[key];
         return newNode;
-      });
+      }), transformSelection = !0;
       break;
     }
     case "set_selection": {
@@ -10278,15 +9712,6 @@ function applyOperation(editor, op) {
     rangeEquals(selection, editor.selection) || (editor.selection = selection);
   }
 }
-const isBatchingDirtyPaths = (editor) => editor.batchingDirtyPaths, batchDirtyPaths = (editor, fn, update) => {
-  const value = editor.batchingDirtyPaths;
-  editor.batchingDirtyPaths = !0;
-  try {
-    fn(), update();
-  } finally {
-    editor.batchingDirtyPaths = value;
-  }
-};
 function updateDirtyPaths(editor, newDirtyPaths, transform) {
   const oldDirtyPaths = editor.dirtyPaths, oldDirtyPathKeys = editor.dirtyPathKeys;
   let dirtyPaths, dirtyPathKeys;
@@ -10315,607 +9740,640 @@ const apply = (editor, op) => {
     PointRef.transform(ref, op);
   for (const ref of editor.rangeRefs)
     transformRangeRef(ref, op);
-  if (!isBatchingDirtyPaths(editor)) {
-    const transform = operationCanTransformPath(op) ? (p) => transformPath(p, op) : void 0;
-    updateDirtyPaths(editor, editor.getDirtyPaths(op), transform);
-  }
-  applyOperation(editor, op), editor.operations.push(op), normalize(editor, {
+  const needsTransform = operationCanTransformPath(op), isAppendAtEnd = needsTransform && op.type === "insert_node" && op.path.length === 1 && op.path[0] >= editor.children.length, transform = needsTransform && !isAppendAtEnd ? (p) => transformPath(p, op) : void 0;
+  if (updateDirtyPaths(editor, getDirtyIndexedPaths(editor, op), transform), applyOperation(editor, op), editor.operations.push(op), normalize(editor, {
     operation: op
-  }), op.type === "set_selection" && (editor.marks = null), editor.flushing || (editor.flushing = !0, Promise.resolve().then(() => {
+  }), op.type === "set_selection")
+    if (editor.marks = null, op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+      const previousSelectionIsCollapsed = isCollapsedRange({
+        anchor: op.properties.anchor,
+        focus: op.properties.focus
+      }), newSelectionIsCollapsed = isCollapsedRange({
+        anchor: op.newProperties.anchor,
+        focus: op.newProperties.focus
+      });
+      if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
+        const focusSpan = getSpanNode(editor, op.properties.focus.path)?.node, newFocusSpan = getSpanNode(editor, op.newProperties.focus.path)?.node, movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+        !movedToNextSpan && !movedToPreviousSpan && (editor.decoratorState = {});
+      }
+    } else
+      editor.decoratorState = {};
+  editor.flushing || (editor.flushing = !0, Promise.resolve().then(() => {
     editor.flushing = !1, editor.onChange({
       operation: op
     }), editor.operations = [];
   }));
 };
-function pathLevels(path2, options = {}) {
-  const {
-    reverse = !1
-  } = options, list = [];
-  for (let i = 0; i <= path2.length; i++)
-    list.push(path2.slice(0, i));
-  return reverse && list.reverse(), list;
+function isEnd(editor, point2, at) {
+  const editorEnd = end(editor, at);
+  return pointEquals(point2, editorEnd);
 }
-function pathAncestors(path2, options = {}) {
-  const {
-    reverse = !1
-  } = options;
-  let paths = pathLevels(path2, options);
-  return reverse ? paths = paths.slice(1) : paths = paths.slice(0, -1), paths;
+function isStart(editor, point2, at) {
+  if (point2.offset !== 0)
+    return !1;
+  const editorStart = start(editor, at);
+  return pointEquals(point2, editorStart);
 }
-const getDirtyPaths = (editor, op) => {
-  switch (op.type) {
-    case "insert_text":
-    case "remove_text":
-    case "set_node": {
-      const {
-        path: path2
-      } = op;
-      return pathLevels(path2);
-    }
-    case "insert_node": {
-      const {
-        node,
-        path: path2
-      } = op, levels = pathLevels(path2);
-      if (isSpan(editor, node))
-        return levels;
-      for (const entry of getNodeDescendants(editor, node))
-        levels.push(path2.concat(entry.path));
-      return levels;
-    }
-    case "remove_node": {
-      const {
-        path: path2
-      } = op;
-      return [...pathAncestors(path2)];
+function isEdge(editor, point2, at) {
+  return isStart(editor, point2, at) || isEnd(editor, point2, at);
+}
+function rangeRefAffinities(range2, affinity) {
+  if (affinity === "inward") {
+    const isCollapsed = isCollapsedRange(range2);
+    if (isForwardRange(range2)) {
+      const anchorAffinity = "forward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "backward"];
+    } else {
+      const anchorAffinity = "backward";
+      return [anchorAffinity, isCollapsed ? anchorAffinity : "forward"];
     }
-    default:
-      return [];
+  } else return affinity === "outward" ? isForwardRange(range2) ? ["backward", "forward"] : ["forward", "backward"] : [affinity, affinity];
+}
+function applySplitNode(editor, path2, position) {
+  const nodeEntry = getNode(editor, path2);
+  if (!nodeEntry)
+    return;
+  const node = nodeEntry.node;
+  for (const ref of editor.pathRefs) {
+    const current = ref.current;
+    current && (ref.current = transformPathForSplit(current, path2, position, ref.affinity ?? "forward"));
   }
-};
-function pointRef(editor, point2, options = {}) {
-  const {
-    affinity = "forward"
-  } = options, ref = {
-    current: point2,
-    affinity,
-    unref() {
-      const {
-        current
-      } = ref;
-      return editor.pointRefs.delete(ref), ref.current = null, current;
+  for (const ref of editor.pointRefs) {
+    const current = ref.current;
+    current && (ref.current = transformPointForSplit(current, path2, position, ref.affinity ?? "forward"));
+  }
+  for (const ref of editor.rangeRefs) {
+    const current = ref.current;
+    if (current) {
+      const [anchorAffinity, focusAffinity] = rangeRefAffinities(current, ref.affinity), anchor = transformPointForSplit(current.anchor, path2, position, anchorAffinity ?? "forward"), focus = transformPointForSplit(current.focus, path2, position, focusAffinity ?? "forward");
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
     }
-  };
-  return editor.pointRefs.add(ref), ref;
-}
-const getDefaultInsertLocation = (editor) => editor.selection ? editor.selection : editor.children.length > 0 ? end(editor, []) : [0];
-function shouldMergeNodesRemovePrevNode(editor, prev, _current) {
-  let isEmptyElement = !1;
-  if (isTextBlock({
-    schema: editor.schema
-  }, prev.node)) {
-    const prevChildren = prev.node.children;
-    isEmptyElement = prevChildren.length === 0 || prevChildren.length === 1 && isSpan({
-      schema: editor.schema
-    }, prevChildren[0]) && prevChildren[0].text === "";
   }
-  return isEmptyElement || isSpan({
-    schema: editor.schema
-  }, prev.node) && prev.node.text === "" && prev.path[prev.path.length - 1] !== 0;
-}
-function isCommonPath(path2, another) {
-  return path2.length <= another.length && comparePaths(path2, another) === 0;
-}
-function insertText(editor, text, options = {}) {
-  withoutNormalizing(editor, () => {
-    const {
-      includeObjectNodes = !1
-    } = options;
-    let {
-      at = getDefaultInsertLocation(editor)
-    } = options;
-    if (isPath(at) && (at = range(editor, at)), isRange(at))
-      if (isCollapsedRange(at))
-        at = at.anchor;
-      else {
-        const end2 = rangeEnd(at);
-        if (!includeObjectNodes) {
-          const endPath = path(editor, end2), endEntry = getNode(editor, endPath);
-          if (endEntry && isObjectNode({
-            schema: editor.schema
-          }, endEntry.node) ? endEntry : getAncestorObjectNode(editor, end2.path))
-            return;
-        }
-        const start2 = rangeStart(at), startRef = pointRef(editor, start2), endRef = pointRef(editor, end2);
-        deleteText(editor, {
-          at,
-          includeObjectNodes
-        });
-        const startPoint = startRef.unref(), endPoint = endRef.unref();
-        at = startPoint || endPoint, editor.setSelection({
-          anchor: at,
-          focus: at
+  if (editor.selection) {
+    const anchor = transformPointForSplit(editor.selection.anchor, path2, position, "forward"), focus = transformPointForSplit(editor.selection.focus, path2, position, "forward");
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
+  }
+  const pathRefs = new Set(editor.pathRefs), pointRefs = new Set(editor.pointRefs), rangeRefs = new Set(editor.rangeRefs);
+  editor.pathRefs.clear(), editor.pointRefs.clear(), editor.rangeRefs.clear();
+  const savedSelection = editor.selection;
+  try {
+    withoutNormalizing(editor, () => {
+      if (isSpan({
+        schema: editor.schema
+      }, node)) {
+        const {
+          text: _text,
+          ...properties
+        } = node, afterText = node.text.slice(position), newNode = {
+          ...properties,
+          text: afterText
+        };
+        editor.apply({
+          type: "remove_text",
+          path: path2,
+          offset: position,
+          text: afterText
+        }), editor.apply({
+          type: "insert_node",
+          path: nextPath(path2),
+          node: newNode
         });
-      }
-    if (!includeObjectNodes) {
-      const atPath = path(editor, at), atEntry = getNode(editor, atPath);
-      if (atEntry && isObjectNode({
+      } else if (isTextBlock({
         schema: editor.schema
-      }, atEntry.node) ? atEntry : getAncestorObjectNode(editor, at.path))
-        return;
-    }
-    const {
-      path: path$1,
-      offset
-    } = at;
-    text.length > 0 && editor.apply({
-      type: "insert_text",
-      path: path$1,
-      offset,
-      text
-    });
-  });
-}
-const matchPath = (editor, path2) => {
-  const matchedEntry = getNode(editor, path2);
-  if (!matchedEntry)
-    return () => !1;
-  const matchedNode = matchedEntry.node;
-  return (n) => n === matchedNode;
-};
-function removeNodes(editor, options = {}) {
-  withoutNormalizing(editor, () => {
-    const {
-      hanging = !1,
-      mode = "lowest"
-    } = options;
-    let {
-      at = editor.selection,
-      match: match2
-    } = options;
-    if (!at)
-      return;
-    match2 == null && (match2 = isPath(at) ? matchPath(editor, at) : (n) => isTextBlockNode({
-      schema: editor.schema
-    }, n)), !hanging && isRange(at) && (at = unhangRange(editor, at));
-    let from, to;
-    if (isRange(at)) {
-      const [start2, end2] = rangeEdges(at);
-      from = start2.path, to = end2.path;
-    } else isPath(at) ? (from = path(editor, at, {
-      edge: "start"
-    }), to = path(editor, at, {
-      edge: "end"
-    })) : (from = at.path, to = at.path);
-    const depths = [];
-    let hit;
-    for (const {
-      node,
-      path: nodePath
-    } of getNodes(editor, {
-      from,
-      to,
-      match: (n, p) => match2(n, p)
-    })) {
-      const isLower = hit && comparePaths(nodePath, hit[1]) === 0;
-      if (mode === "highest" && isLower)
-        continue;
-      if (mode === "lowest" && isLower) {
-        hit = [node, nodePath];
-        continue;
-      }
-      const emit2 = mode === "lowest" ? hit : [node, nodePath];
-      emit2 && depths.push(emit2), hit = [node, nodePath];
-    }
-    mode === "lowest" && hit && depths.push(hit);
-    const pathRefs = Array.from(depths, ([, p]) => pathRef(editor, p));
-    for (const ref of pathRefs) {
-      const path2 = ref.unref();
-      if (path2) {
-        const removedEntry = getNode(editor, path2);
-        if (removedEntry) {
-          const removedNode = removedEntry.node;
+      }, node)) {
+        const {
+          children: _children,
+          ...properties
+        } = node, children = node.children, afterChildren = children.slice(position), newNode = {
+          ...properties,
+          children: afterChildren
+        };
+        for (let i = children.length - 1; i >= position; i--)
           editor.apply({
             type: "remove_node",
-            path: path2,
-            node: removedNode
+            path: [...path2, i],
+            node: children[i]
           });
-        }
+        editor.apply({
+          type: "insert_node",
+          path: nextPath(path2),
+          node: newNode
+        });
       }
-    }
+    });
+  } finally {
+    editor.selection = savedSelection;
+    for (const ref of pathRefs)
+      editor.pathRefs.add(ref);
+    for (const ref of pointRefs)
+      editor.pointRefs.add(ref);
+    for (const ref of rangeRefs)
+      editor.rangeRefs.add(ref);
+  }
+}
+function transformPathForSplit(path2, splitPath, position, affinity = "forward") {
+  const p = [...path2];
+  return pathEquals(splitPath, p) ? affinity === "forward" && (p[p.length - 1] = p[p.length - 1] + 1) : pathEndsBefore(splitPath, p) ? p[splitPath.length - 1] = p[splitPath.length - 1] + 1 : isAncestorPath(splitPath, p) && path2[splitPath.length] >= position && (p[splitPath.length - 1] = p[splitPath.length - 1] + 1, p[splitPath.length] = p[splitPath.length] - position), p;
+}
+function transformPointForSplit(point2, splitPath, position, affinity = "forward") {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return pathEquals(splitPath, path2) ? (position < offset || position === offset && affinity === "forward") && (offset -= position, path2 = transformPathForSplit(path2, splitPath, position, "forward")) : path2 = transformPathForSplit(path2, splitPath, position, affinity), {
+    path: path2,
+    offset
+  };
+}
+function applyInsertNodeAtPath(editor, node, path2) {
+  editor.apply({
+    type: "insert_node",
+    path: path2,
+    node
   });
+  const point2 = end(editor, path2);
+  point2 && applySelect(editor, point2);
 }
-function deleteText(editor, options = {}) {
+function applyInsertNodeAtPoint(editor, node, at) {
   withoutNormalizing(editor, () => {
-    const {
-      reverse = !1,
-      unit = "character",
-      distance = 1,
-      includeObjectNodes = !1
-    } = options;
-    let {
-      at = editor.selection,
-      hanging = !1
-    } = options;
-    if (!at)
-      return;
-    let isCollapsed = !1;
-    if (isRange(at) && isCollapsedRange(at) && (isCollapsed = !0, at = at.anchor), isPoint(at)) {
-      const furthestObjectNode = getHighestObjectNode(editor, at.path);
-      if (!includeObjectNodes && furthestObjectNode)
-        at = furthestObjectNode.path;
-      else {
-        const opts = {
-          unit,
-          distance
-        }, target = reverse ? before(editor, at, opts) || start(editor, []) : after(editor, at, opts) || end(editor, []);
-        at = {
-          anchor: at,
-          focus: target
-        }, hanging = !0;
-      }
-    }
-    if (isPath(at)) {
-      removeNodes(editor, {
-        at,
-        includeObjectNodes
-      });
-      return;
-    }
-    if (isCollapsedRange(at))
+    const match2 = isSpan({
+      schema: editor.schema
+    }, node) ? (n) => isSpan({
+      schema: editor.schema
+    }, n) : (n) => isSpan({
+      schema: editor.schema
+    }, n) || isObjectNode({
+      schema: editor.schema
+    }, n), nodeEntry = getNode(editor, at.path), entry = nodeEntry && match2(nodeEntry.node) ? nodeEntry : void 0;
+    if (!entry)
       return;
-    if (!hanging) {
-      const [, end2] = rangeEdges(at), endOfDoc = end(editor, []);
-      pointEquals(end2, endOfDoc) || (at = unhangRange(editor, at));
-    }
-    let [start$1, end$1] = rangeEdges(at);
-    const startBlock = getAncestorTextBlock(editor, start$1.path), endBlock = getAncestorTextBlock(editor, end$1.path), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock.path, endBlock.path), isSingleText = pathEquals(start$1.path, end$1.path), startNonEditable = includeObjectNodes ? null : getHighestObjectNode(editor, start$1.path), endNonEditable = includeObjectNodes ? null : getHighestObjectNode(editor, end$1.path);
-    if (startNonEditable) {
-      const beforePoint = before(editor, start$1);
-      beforePoint && startBlock && isAncestorPath(startBlock.path, beforePoint.path) && (start$1 = beforePoint);
-    }
-    if (endNonEditable) {
-      const afterPoint = after(editor, end$1);
-      afterPoint && endBlock && isAncestorPath(endBlock.path, afterPoint.path) && (end$1 = afterPoint);
-    }
-    const matches = [];
-    let lastPath;
-    for (const entry of getNodes(editor, {
-      from: start$1.path,
-      to: end$1.path
-    })) {
-      const {
-        node,
-        path: entryPath
-      } = entry;
-      lastPath && comparePaths(entryPath, lastPath) === 0 || (!includeObjectNodes && isObjectNode({
-        schema: editor.schema
-      }, node) || !isCommonPath(entryPath, start$1.path) && !isCommonPath(entryPath, end$1.path)) && (matches.push(entry), lastPath = entryPath);
+    const matchPath2 = entry.path, ref = pathRef(editor, matchPath2), isAtEnd = isEnd(editor, at, matchPath2);
+    isEdge(editor, at, matchPath2) || applySplitNode(editor, at.path, at.offset);
+    const path2 = ref.unref(), insertPath = isAtEnd ? nextPath(path2) : path2;
+    editor.apply({
+      type: "insert_node",
+      path: insertPath,
+      node
+    });
+    const point2 = end(editor, insertPath);
+    point2 && applySelect(editor, point2);
+  });
+}
+function previousPath(path2) {
+  if (path2.length === 0)
+    throw new Error(`Cannot get the previous path of a root path [${path2}], because it has no previous index.`);
+  const last = path2[path2.length - 1];
+  if (last <= 0)
+    throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
+  return path2.slice(0, -1).concat(last - 1);
+}
+function applyMergeNode(editor, path2, position) {
+  const nodeEntry = getNode(editor, path2);
+  if (!nodeEntry)
+    return;
+  const node = nodeEntry.node, prevPath = previousPath(path2);
+  for (const ref of editor.pathRefs) {
+    const current = ref.current;
+    current && (ref.current = transformPathForMerge(current, path2, position));
+  }
+  for (const ref of editor.pointRefs) {
+    const current = ref.current;
+    current && (ref.current = transformPointForMerge(current, path2, position));
+  }
+  for (const ref of editor.rangeRefs) {
+    const current = ref.current;
+    if (current) {
+      const anchor = transformPointForMerge(current.anchor, path2, position), focus = transformPointForMerge(current.focus, path2, position);
+      anchor && focus ? ref.current = {
+        anchor,
+        focus
+      } : (ref.current = null, ref.unref());
     }
-    const pathRefs = Array.from(matches, (entry) => pathRef(editor, entry.path)), startRef = pointRef(editor, start$1), endRef = pointRef(editor, end$1);
-    let removedText = "";
-    if (!isSingleText && !startNonEditable) {
-      const point22 = startRef.current, nodeEntry = getSpanNode(editor, point22.path);
-      if (nodeEntry) {
-        const node = nodeEntry.node, {
-          path: path2
-        } = point22, {
-          offset
-        } = start$1, text = node.text.slice(offset);
-        text.length > 0 && (editor.apply({
-          type: "remove_text",
-          path: path2,
-          offset,
-          text
-        }), removedText = text);
-      }
+  }
+  if (editor.selection) {
+    const anchor = transformPointForMerge(editor.selection.anchor, path2, position), focus = transformPointForMerge(editor.selection.focus, path2, position);
+    anchor && focus && (editor.selection = {
+      anchor,
+      focus
+    });
+  }
+  const pathRefs = new Set(editor.pathRefs), pointRefs = new Set(editor.pointRefs), rangeRefs = new Set(editor.rangeRefs);
+  editor.pathRefs.clear(), editor.pointRefs.clear(), editor.rangeRefs.clear();
+  const savedSelection = editor.selection, editorAny = editor, savedPendingDiffs = editorAny.pendingDiffs, savedPendingSelection = editorAny.pendingSelection, savedPendingAction = editorAny.pendingAction;
+  if (Array.isArray(savedPendingDiffs) && savedPendingDiffs.length > 0 && (editorAny.pendingDiffs = savedPendingDiffs.map((textDiff) => transformTextDiffForMerge(textDiff, path2, position)).filter(Boolean)), savedPendingSelection && typeof savedPendingSelection == "object" && "anchor" in savedPendingSelection && "focus" in savedPendingSelection) {
+    const sel = savedPendingSelection, anchor = transformPointForMerge(sel.anchor, path2, position), focus = transformPointForMerge(sel.focus, path2, position);
+    editorAny.pendingSelection = anchor && focus ? {
+      anchor,
+      focus
+    } : null;
+  }
+  if (savedPendingAction && typeof savedPendingAction == "object" && "at" in savedPendingAction) {
+    const action = savedPendingAction;
+    if ("offset" in action.at && typeof action.at.offset == "number") {
+      const at = transformPointForMerge(action.at, path2, position);
+      editorAny.pendingAction = at ? {
+        ...action,
+        at
+      } : null;
+    } else if (isRange(action.at)) {
+      const anchor = transformPointForMerge(action.at.anchor, path2, position), focus = transformPointForMerge(action.at.focus, path2, position);
+      editorAny.pendingAction = anchor && focus ? {
+        ...action,
+        at: {
+          anchor,
+          focus
+        }
+      } : null;
     }
-    if (pathRefs.reverse().map((r) => r.unref()).filter((r) => r !== null).forEach((p) => {
-      removeNodes(editor, {
-        at: p,
-        includeObjectNodes
-      });
-    }), !endNonEditable) {
-      const point22 = endRef.current, endNodeEntry = getSpanNode(editor, point22.path);
-      if (endNodeEntry) {
-        const node = endNodeEntry.node, {
-          path: path2
-        } = point22, offset = isSingleText ? start$1.offset : 0, text = node.text.slice(offset, end$1.offset);
-        text.length > 0 && (editor.apply({
-          type: "remove_text",
+  }
+  const preTransformedPendingDiffs = editorAny.pendingDiffs, preTransformedPendingSelection = editorAny.pendingSelection, preTransformedPendingAction = editorAny.pendingAction;
+  editorAny.pendingDiffs = [], editorAny.pendingSelection = null, editorAny.pendingAction = null;
+  try {
+    withoutNormalizing(editor, () => {
+      if (isSpan({
+        schema: editor.schema
+      }, node))
+        node.text.length > 0 && editor.apply({
+          type: "insert_text",
+          path: prevPath,
+          offset: position,
+          text: node.text
+        }), editor.apply({
+          type: "remove_node",
           path: path2,
-          offset,
-          text
-        }), removedText = text);
-      }
-    }
-    if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {
-      const mergeAt = endRef.current, mergeMatch = (n) => isTextBlock({
+          node
+        });
+      else if (isTextBlock({
         schema: editor.schema
-      }, n), current = getAncestor(editor, mergeAt.path, mergeMatch), beforePoint = before(editor, mergeAt), prev = beforePoint ? getNodes(editor, {
-        to: beforePoint.path,
-        match: mergeMatch,
-        reverse: !0
-      }).next().value : void 0;
-      if (current && prev) {
-        const {
-          node: mergeNode,
-          path: mergePath
-        } = current, {
-          node: prevNode,
-          path: prevPath
-        } = prev;
-        if (mergePath.length !== 0 && prevPath.length !== 0) {
-          const newPath = nextPath(prevPath), common = commonPath(mergePath, prevPath), isPreviousSibling = isSiblingPath(mergePath, prevPath), editorLevels = pathLevels(mergePath).filter((levelPath) => levelPath.length > 0).map((levelPath) => getNode(editor, levelPath)).filter((entry) => entry !== void 0).map((entry) => entry.node).slice(Math.max(0, common.length - 1)).slice(0, -1), hasSingleChildNest = (node) => {
-            if (isTextBlock({
-              schema: editor.schema
-            }, node)) {
-              const elementChildren = node.children;
-              return elementChildren.length === 1 ? hasSingleChildNest(elementChildren[0]) : !1;
-            } else return !isEditor(node);
-          }, emptyAncestor = getAncestors(editor, mergePath).reverse().find((ancestor) => editorLevels.includes(ancestor.node) && hasSingleChildNest(ancestor.node)), emptyRef = emptyAncestor && pathRef(editor, emptyAncestor.path);
-          let position;
-          if (isSpan({
-            schema: editor.schema
-          }, mergeNode) && isSpan({
-            schema: editor.schema
-          }, prevNode))
-            position = prevNode.text.length;
-          else if (isTextBlock({
-            schema: editor.schema
-          }, mergeNode) && isTextBlock({
-            schema: editor.schema
-          }, prevNode))
-            position = prevNode.children.length;
-          else
-            throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${safeStringify(mergeNode)} ${safeStringify(prevNode)}`);
-          if (!isPreviousSibling) {
-            const moveNodeEntry = getNode(editor, mergePath);
-            if (moveNodeEntry) {
-              const moveNode = moveNodeEntry.node;
-              editor.apply({
-                type: "remove_node",
-                path: mergePath,
-                node: moveNode
-              }), editor.apply({
-                type: "insert_node",
-                path: newPath,
-                node: moveNode
-              });
-            }
-          }
-          if (emptyRef && removeNodes(editor, {
-            at: emptyRef.current,
-            includeObjectNodes
-          }), shouldMergeNodesRemovePrevNode(editor, {
-            node: prevNode,
-            path: prevPath
-          }, {
-            node: mergeNode,
-            path: mergePath
-          }))
-            removeNodes(editor, {
-              at: prevPath,
-              includeObjectNodes
-            });
-          else {
-            const pteEditor = editor;
-            if (isTextBlock({
-              schema: editor.schema
-            }, mergeNode) && isTextBlock({
-              schema: editor.schema
-            }, prevNode) && Array.isArray(mergeNode.markDefs) && mergeNode.markDefs.length > 0) {
-              const targetPath = isPreviousSibling ? prevPath : previousPath(newPath), oldDefs = Array.isArray(prevNode.markDefs) && prevNode.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...mergeNode.markDefs].map((def) => [def._key, def])).values()];
-              applySetNode(pteEditor, {
-                markDefs: newMarkDefs
-              }, targetPath);
-            }
-            applyMergeNode(pteEditor, newPath, position);
-          }
-          emptyRef && emptyRef.unref();
-        }
+      }, node)) {
+        for (let i = 0; i < node.children.length; i++)
+          editor.apply({
+            type: "insert_node",
+            path: [...prevPath, position + i],
+            node: node.children[i]
+          });
+        editor.apply({
+          type: "remove_node",
+          path: path2,
+          node
+        });
       }
-    }
-    isCollapsed && reverse && unit === "character" && removedText.length > 1 && removedText.match(/[\u0980-\u09FF\u0E00-\u0E7F\u1000-\u109F\u0900-\u097F\u1780-\u17FF\u0D00-\u0D7F\u0B00-\u0B7F\u0A00-\u0A7F\u0B80-\u0BFF\u0C00-\u0C7F]+/) && insertText(editor, removedText.slice(0, removedText.length - distance));
-    const startUnref = startRef.unref(), endUnref = endRef.unref(), point2 = reverse ? startUnref || endUnref : endUnref || startUnref;
-    options.at == null && point2 && editor.select(point2);
-  });
+    });
+  } finally {
+    editor.selection = savedSelection;
+    for (const ref of pathRefs)
+      editor.pathRefs.add(ref);
+    for (const ref of pointRefs)
+      editor.pointRefs.add(ref);
+    for (const ref of rangeRefs)
+      editor.rangeRefs.add(ref);
+    editorAny.pendingDiffs = preTransformedPendingDiffs, editorAny.pendingSelection = preTransformedPendingSelection, editorAny.pendingAction = preTransformedPendingAction;
+  }
+}
+function transformTextDiffForMerge(textDiff, mergePath, position) {
+  const {
+    path: path2,
+    diff: diff2,
+    id
+  } = textDiff;
+  if (!pathEquals(mergePath, path2)) {
+    const newPath = transformPathForMerge(path2, mergePath, position);
+    return newPath ? {
+      diff: diff2,
+      id,
+      path: newPath
+    } : null;
+  }
+  return {
+    diff: {
+      start: diff2.start + position,
+      end: diff2.end + position,
+      text: diff2.text
+    },
+    id,
+    path: transformPathForMerge(path2, mergePath, position)
+  };
+}
+function transformPathForMerge(path2, mergePath, position) {
+  const p = [...path2];
+  return pathEquals(mergePath, p) || pathEndsBefore(mergePath, p) ? p[mergePath.length - 1] = p[mergePath.length - 1] - 1 : isAncestorPath(mergePath, p) && (p[mergePath.length - 1] = p[mergePath.length - 1] - 1, p[mergePath.length] = p[mergePath.length] + position), p;
+}
+function transformPointForMerge(point2, mergePath, position) {
+  let {
+    path: path2,
+    offset
+  } = point2;
+  return pathEquals(mergePath, path2) && (offset += position), path2 = transformPathForMerge(path2, mergePath, position), {
+    path: path2,
+    offset
+  };
+}
+function createSpanNode(context) {
+  return {
+    _type: context.schema.span.name,
+    _key: context.keyGenerator(),
+    text: "",
+    marks: []
+  };
 }
-function insertNodes(editor, nodes, options = {}) {
+const matchPath = (editor, path2) => {
+  const matchedEntry = getNode(editor, path2);
+  if (!matchedEntry)
+    return () => !1;
+  const matchedNode = matchedEntry.node;
+  return (n) => n === matchedNode;
+};
+function removeNodes(editor, options = {}) {
   withoutNormalizing(editor, () => {
     const {
       hanging = !1,
-      includeObjectNodes = !1,
-      mode = "lowest",
-      batchDirty = !0
+      mode = "lowest"
     } = options;
     let {
-      at,
-      match: match2,
-      select: select2
+      at = editor.selection,
+      match: match2
     } = options;
-    if (nodes.length === 0)
+    if (!at)
       return;
-    const node = nodes[0];
-    if (at || (at = getDefaultInsertLocation(editor), select2 !== !1 && (select2 = !0)), select2 == null && (select2 = !1), isRange(at))
-      if (hanging || (at = unhangRange(editor, at)), isCollapsedRange(at))
-        at = at.anchor;
-      else {
-        const [, end2] = rangeEdges(at), endPointRef = pointRef(editor, end2);
-        deleteText(editor, {
-          at
-        }), at = endPointRef.unref();
+    match2 == null && (match2 = isPath(at) ? matchPath(editor, at) : (n) => isTextBlockNode({
+      schema: editor.schema
+    }, n)), !hanging && isRange(at) && (at = unhangRange(editor, at));
+    let from, to;
+    if (isRange(at)) {
+      const [start2, end2] = rangeEdges(at);
+      from = start2.path, to = end2.path;
+    } else isPath(at) ? (from = path(editor, at, {
+      edge: "start"
+    }), to = path(editor, at, {
+      edge: "end"
+    })) : (from = at.path, to = at.path);
+    const depths = [];
+    let hit;
+    for (const {
+      node,
+      path: nodePath
+    } of getNodes(editor, {
+      from,
+      to,
+      match: (n, p) => match2(n, p)
+    })) {
+      const isLower = hit && comparePaths(nodePath, hit[1]) === 0;
+      if (mode === "highest" && isLower)
+        continue;
+      if (mode === "lowest" && isLower) {
+        hit = [node, nodePath];
+        continue;
       }
-    if (isPoint(at)) {
-      match2 == null && (isSpan({
-        schema: editor.schema
-      }, node) ? match2 = (n) => isSpan({
-        schema: editor.schema
-      }, n) : editor.isInline(node) ? match2 = (n) => isSpan({
-        schema: editor.schema
-      }, n) || editor.isInline(n) : match2 = (n) => isTextBlockNode({
-        schema: editor.schema
-      }, n));
-      const entry = firstNodeWithMode(editor, {
-        from: path(editor, at.path, {
-          edge: "start"
-        }),
-        to: path(editor, at.path, {
-          edge: "end"
-        }),
-        match: match2,
-        mode
-      });
-      if (entry) {
-        const matchPath2 = entry.path, matchPathRef = pathRef(editor, matchPath2), isAtEnd = isEnd(editor, at, matchPath2);
-        {
-          const splitAt = at, beforeRef = pointRef(editor, splitAt, {
-            affinity: "backward"
+      const emit2 = mode === "lowest" ? hit : [node, nodePath];
+      emit2 && depths.push(emit2), hit = [node, nodePath];
+    }
+    mode === "lowest" && hit && depths.push(hit);
+    const pathRefs = Array.from(depths, ([, p]) => pathRef(editor, p));
+    for (const ref of pathRefs) {
+      const path2 = ref.unref();
+      if (path2) {
+        const removedEntry = getNode(editor, path2);
+        if (removedEntry) {
+          const removedNode = removedEntry.node;
+          editor.apply({
+            type: "remove_node",
+            path: path2,
+            node: removedNode
           });
-          let afterRef;
-          try {
-            const highest = firstNodeWithMode(editor, {
-              from: splitAt.path,
-              to: splitAt.path,
-              match: match2,
-              mode
-            });
-            if (highest) {
-              afterRef = pointRef(editor, splitAt);
-              const depth = splitAt.path.length, highestPath = highest.path, lowestPath = splitAt.path.slice(0, depth);
-              let position = splitAt.offset;
-              const levelEntries = pathLevels(lowestPath).filter((levelPath) => levelPath.length > 0).map((levelPath) => getNode(editor, levelPath)).filter((entry2) => entry2 !== void 0).reverse();
-              for (const {
-                path: nodePath
-              } of levelEntries) {
-                let split = !1;
-                if (nodePath.length < highestPath.length || nodePath.length === 0)
-                  break;
-                const point2 = beforeRef.current, isEndOfNode = isEnd(editor, point2, nodePath);
-                isEdge(editor, point2, nodePath) || (split = !0, applySplitNode(editor, nodePath, position)), position = nodePath[nodePath.length - 1] + (split || isEndOfNode ? 1 : 0);
-              }
-            }
-          } finally {
-            beforeRef.unref(), afterRef?.unref();
-          }
         }
-        const path2 = matchPathRef.unref();
-        at = isAtEnd ? nextPath(path2) : path2;
-      } else
-        return;
+      }
     }
-    const parentPath_ = parentPath(at);
-    let index = at[at.length - 1];
-    if (!includeObjectNodes) {
-      const parentNodePath = path(editor, parentPath_), parentNodeEntry = getNode(editor, parentNodePath);
-      if (parentNodeEntry && isObjectNode({
+  });
+}
+const normalizeNode = (editor, entry) => {
+  const [node, path2] = entry, nodeRecord = node;
+  if (isEditor(node) && node.children.length === 0) {
+    withoutPatching(editor, () => {
+      applyInsertNodeAtPath(editor, createPlaceholderBlock(editor), [0]);
+    });
+    return;
+  }
+  if (isTextBlock({
+    schema: editor.schema
+  }, node)) {
+    const children = getChildren(editor, path2);
+    for (const {
+      node: child,
+      path: childPath
+    } of children) {
+      const childIndex = childPath[childPath.length - 1], nextNode = node.children[childIndex + 1];
+      if (isSpan({
+        schema: editor.schema
+      }, child) && isSpan({
         schema: editor.schema
-      }, parentNodeEntry.node) ? parentNodeEntry : getAncestorObjectNode(editor, parentPath_))
+      }, nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
+        debug$1.normalization("merging spans with same marks");
+        const mergePath = [...path2, childIndex + 1];
+        applyMergeNode(editor, mergePath, child.text.length);
         return;
+      }
     }
-    if (batchDirty) {
-      const batchedOps = [], newDirtyPaths = pathLevels(parentPath_);
-      batchDirtyPaths(editor, () => {
-        for (const node2 of nodes) {
-          const path2 = parentPath_.concat(index);
-          index++;
-          const op = {
-            type: "insert_node",
-            path: path2,
-            node: node2
-          };
-          if (editor.apply(op), at = nextPath(at), batchedOps.push(op), !isSpan(editor, node2))
-            for (const {
-              path: p
-            } of getNodeDescendants(editor, node2))
-              newDirtyPaths.push(path2.concat(p));
+  }
+  if (nodeRecord._type === void 0 && path2.length > 0) {
+    const parent = getNode(editor, parentPath(path2));
+    if (parent && isTextBlock({
+      schema: editor.schema
+    }, parent.node)) {
+      debug$1.normalization("Setting span type on node without a type"), editor.apply({
+        type: "set_node",
+        path: path2,
+        properties: {},
+        newProperties: {
+          _type: editor.schema.span.name
         }
-      }, () => {
-        updateDirtyPaths(editor, newDirtyPaths, (p) => {
-          let newPath = p;
-          for (const op of batchedOps)
-            if (operationCanTransformPath(op) && (newPath = transformPath(newPath, op), !newPath))
-              return null;
-          return newPath;
-        });
       });
-    } else
-      for (const node2 of nodes) {
-        const path2 = parentPath_.concat(index);
-        index++, editor.apply({
-          type: "insert_node",
+      return;
+    }
+  }
+  if (nodeRecord._key === void 0 && path2.length > 0) {
+    debug$1.normalization("Setting missing key on node"), editor.apply({
+      type: "set_node",
+      path: path2,
+      properties: {},
+      newProperties: {
+        _key: editor.keyGenerator()
+      }
+    });
+    return;
+  }
+  if (path2.length > 0 && nodeRecord._key !== void 0) {
+    const parent = getParent(editor, path2), siblings = parent ? getChildren(editor, parent.path) : editor.children.map((child, index) => ({
+      node: child,
+      path: [index]
+    }));
+    for (const sibling of siblings) {
+      if (pathEquals(sibling.path, path2))
+        break;
+      if (sibling.node._key === nodeRecord._key) {
+        debug$1.normalization("Fixing duplicate key on node"), editor.apply({
+          type: "set_node",
           path: path2,
-          node: node2
-        }), at = nextPath(at);
+          properties: {},
+          newProperties: {
+            _key: editor.keyGenerator()
+          }
+        });
+        return;
       }
-    if (at = previousPath(at), select2) {
-      const point2 = end(editor, at);
-      point2 && editor.select(point2);
     }
-  });
-}
-function firstNodeWithMode(editor, options) {
-  const {
-    from,
-    to,
-    match: match2,
-    mode
-  } = options;
-  let hit;
-  for (const {
-    node,
-    path: nodePath
-  } of getNodes(editor, {
-    from,
-    to,
-    match: match2
-  })) {
-    const entry = {
-      node,
-      path: nodePath
-    }, isLower = hit && comparePaths(nodePath, hit.path) === 0;
-    if (mode === "highest" && isLower)
-      continue;
-    if (mode === "lowest" && isLower) {
-      hit = entry;
-      continue;
+  }
+  if (isTextBlockNode({
+    schema: editor.schema
+  }, node) && !Array.isArray(node.markDefs)) {
+    debug$1.normalization("adding .markDefs to block node"), applySetNode(editor, {
+      markDefs: []
+    }, path2);
+    return;
+  }
+  {
+    const defaultStyle = editor.schema.styles.at(0)?.name;
+    if (defaultStyle && isTextBlockNode({
+      schema: editor.schema
+    }, node) && typeof node.style > "u") {
+      debug$1.normalization("adding .style to block node"), applySetNode(editor, {
+        style: defaultStyle
+      }, path2);
+      return;
     }
-    const emit2 = mode === "lowest" ? hit : entry;
-    if (emit2)
-      return emit2;
-    hit = entry;
   }
-  return hit;
-}
-const normalizeNode = (editor, entry) => {
-  const [node, path2] = entry;
   if (isSpan({
     schema: editor.schema
-  }, node) || isObjectNode({
-    schema: editor.schema
-  }, node))
+  }, node) && !Array.isArray(node.marks)) {
+    debug$1.normalization("Adding .marks to span node"), applySetNode(editor, {
+      marks: []
+    }, path2);
     return;
-  node.children ??= [];
-  let element = node;
-  if (element !== editor && element.children.length === 0) {
-    const child = editor.createSpan();
-    insertNodes(editor, [child], {
-      at: path2.concat(0),
-      includeObjectNodes: !0
-    });
-    const refetched = getTextBlockNode(editor, path2)?.node;
-    if (!refetched)
+  }
+  if (isSpan({
+    schema: editor.schema
+  }, node)) {
+    const blockPath = parentPath(path2);
+    if (!getTextBlockNode(editor, blockPath))
+      return;
+    const decorators = editor.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators.includes(mark));
+    if (node.text === "" && annotations && annotations.length > 0) {
+      debug$1.normalization("removing annotations from empty span node"), applySetNode(editor, {
+        marks: node.marks?.filter((mark) => decorators.includes(mark))
+      }, path2);
+      return;
+    }
+  }
+  if (isTextBlock({
+    schema: editor.schema
+  }, node)) {
+    const decorators = editor.schema.decorators.map((decorator) => decorator.name);
+    for (const {
+      node: child,
+      path: childPath
+    } of getChildren(editor, path2))
+      if (isSpan({
+        schema: editor.schema
+      }, child)) {
+        const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
+        if (orphanedAnnotations.length > 0) {
+          debug$1.normalization("removing orphaned annotations from span node"), applySetNode(editor, {
+            marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
+          }, childPath);
+          return;
+        }
+      }
+  }
+  if (isSpan({
+    schema: editor.schema
+  }, node)) {
+    const blockPath = parentPath(path2), blockEntry2 = getTextBlockNode(editor, blockPath);
+    if (blockEntry2) {
+      const block = blockEntry2.node, decorators = editor.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+      if (orphanedAnnotations.length > 0) {
+        debug$1.normalization("removing orphaned annotations from span node"), applySetNode(editor, {
+          marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
+        }, path2);
+        return;
+      }
+    }
+  }
+  if (isTextBlock({
+    schema: editor.schema
+  }, node)) {
+    const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
+    for (const markDef of markDefs)
+      markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
+    if (markDefs.length !== newMarkDefs.length) {
+      debug$1.normalization("removing duplicate markDefs"), applySetNode(editor, {
+        markDefs: newMarkDefs
+      }, path2);
+      return;
+    }
+  }
+  if (isTextBlock({
+    schema: editor.schema
+  }, node)) {
+    const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => isSpan({
+      schema: editor.schema
+    }, child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
+    if (node.markDefs && !isEqualMarkDefs(newMarkDefs, node.markDefs)) {
+      debug$1.normalization("removing markDef not in use"), applySetNode(editor, {
+        markDefs: newMarkDefs
+      }, path2);
       return;
-    element = refetched;
+    }
   }
-  const firstChild = element.children[0];
-  if (!isEditor(element) && (editor.isInline(element) || isSpan({
+  if (isSpanNode({
     schema: editor.schema
-  }, firstChild) || isObjectNode({
+  }, node)) {
+    if (typeof node.text != "string") {
+      debug$1.normalization("Adding .text to span node"), editor.apply({
+        type: "set_node",
+        path: path2,
+        properties: {},
+        newProperties: {
+          text: ""
+        }
+      });
+      return;
+    }
+    return;
+  }
+  if (!isObjectNode({
     schema: editor.schema
-  }, firstChild) || isTextBlock({
+  }, node) && isTextBlockNode({
     schema: editor.schema
-  }, firstChild) && editor.isInline(firstChild)))
+  }, node)) {
+    if (!Array.isArray(node.children)) {
+      editor.apply({
+        type: "set_node",
+        path: path2,
+        properties: {},
+        newProperties: {
+          children: []
+        }
+      });
+      return;
+    }
+    let element = node;
+    if (element.children.length === 0) {
+      const child = createSpanNode(editor);
+      editor.apply({
+        type: "insert_node",
+        path: path2.concat(0),
+        node: child
+      });
+      const refetched = getTextBlockNode(editor, path2)?.node;
+      if (!refetched)
+        return;
+      element = refetched;
+    }
     for (let n = 0; n < element.children.length; n++) {
       const child = element.children[n], prev = element.children[n - 1];
       if (isSpan({
@@ -10953,54 +10411,17 @@ const normalizeNode = (editor, entry) => {
             element = refetched, n--;
           }
         }
-      } else if (isTextBlock({
-        schema: editor.schema
-      }, child))
-        if (editor.isInline(child)) {
-          if (prev == null || !isSpan({
-            schema: editor.schema
-          }, prev)) {
-            const newChild = editor.createSpan();
-            insertNodes(editor, [newChild], {
-              at: path2.concat(n),
-              includeObjectNodes: !0
-            });
-            const refetched = getTextBlockNode(editor, path2)?.node;
-            if (!refetched)
-              return;
-            element = refetched, n++;
-          }
-          if (n === element.children.length - 1) {
-            const newChild = editor.createSpan();
-            insertNodes(editor, [newChild], {
-              at: path2.concat(n + 1),
-              includeObjectNodes: !0
-            });
-            const refetched = getTextBlockNode(editor, path2)?.node;
-            if (!refetched)
-              return;
-            element = refetched, n++;
-          }
-        } else {
-          removeNodes(editor, {
-            at: path2.concat(n),
-            includeObjectNodes: !0
-          });
-          const refetched = getTextBlockNode(editor, path2)?.node;
-          if (!refetched)
-            return;
-          element = refetched, n--;
-        }
-      else if (isObjectNode({
+      } else if (isObjectNode({
         schema: editor.schema
       }, child)) {
         if (prev == null || !isSpan({
           schema: editor.schema
         }, prev)) {
-          const newChild = editor.createSpan();
-          insertNodes(editor, [newChild], {
-            at: path2.concat(n),
-            includeObjectNodes: !0
+          const newChild = createSpanNode(editor);
+          editor.apply({
+            type: "insert_node",
+            path: path2.concat(n),
+            node: newChild
           });
           const refetched = getTextBlockNode(editor, path2)?.node;
           if (!refetched)
@@ -11008,10 +10429,11 @@ const normalizeNode = (editor, entry) => {
           element = refetched, n++;
         }
         if (n === element.children.length - 1) {
-          const newChild = editor.createSpan();
-          insertNodes(editor, [newChild], {
-            at: path2.concat(n + 1),
-            includeObjectNodes: !0
+          const newChild = createSpanNode(editor);
+          editor.apply({
+            type: "insert_node",
+            path: path2.concat(n + 1),
+            node: newChild
           });
           const refetched = getTextBlockNode(editor, path2)?.node;
           if (!refetched)
@@ -11020,28 +10442,8 @@ const normalizeNode = (editor, entry) => {
         }
       }
     }
-  else
-    for (let n = 0; n < element.children.length; n++) {
-      const child = element.children[n];
-      if (isSpan({
-        schema: editor.schema
-      }, child) || isTextBlock({
-        schema: editor.schema
-      }, child) && editor.isInline(child)) {
-        if (removeNodes(editor, {
-          at: path2.concat(n),
-          includeObjectNodes: !0
-        }), path2.length === 0)
-          element = editor;
-        else {
-          const refetched = getTextBlockNode(editor, path2)?.node;
-          if (!refetched)
-            return;
-          element = refetched;
-        }
-        n--;
-      }
-    }
+    return;
+  }
 };
 function select(editor, target) {
   const {
@@ -11081,7 +10483,7 @@ const shouldNormalize = (_editor, {
   if (iteration > maxIterations)
     throw new Error(`Could not completely normalize the editor after ${maxIterations} iterations! This is usually due to incorrect normalization logic that leaves a node in an invalid state.`);
   return !0;
-}, createEditor = (context) => {
+}, createEditor = () => {
   const e = {
     [EDITOR_BRAND]: !0,
     children: [],
@@ -11095,24 +10497,15 @@ const shouldNormalize = (_editor, {
     dirtyPathKeys: /* @__PURE__ */ new Set(),
     flushing: !1,
     normalizing: !0,
-    batchingDirtyPaths: !1,
     pathRefs: /* @__PURE__ */ new Set(),
     pointRefs: /* @__PURE__ */ new Set(),
     rangeRefs: /* @__PURE__ */ new Set(),
-    createSpan: () => ({
-      _type: context.schema.span.name,
-      _key: context.keyGenerator(),
-      text: "",
-      marks: []
-    }),
-    isInline: () => !1,
     onChange: () => {
     },
     // Core
     apply: (...args) => apply(e, ...args),
     // Editor
     normalizeNode: (...args) => normalizeNode(e, ...args),
-    getDirtyPaths: (...args) => getDirtyPaths(e, ...args),
     shouldNormalize: (...args) => shouldNormalize(e, ...args),
     // Overrideable commands
     select: (...args) => select(e, ...args),
@@ -11475,11 +10868,8 @@ const withDOM = (editor) => {
 };
 function createSlateEditor(config) {
   debug$1.setup("creating new slate editor instance");
-  const context = config.editorActor.getSnapshot().context, placeholderBlock = createPlaceholderBlock(context), editor = createEditor({
-    schema: context.schema,
-    keyGenerator: context.keyGenerator
-  });
-  editor.editableTypes = /* @__PURE__ */ new Set(), editor.decoratedRanges = [], editor.decoratorState = {}, editor.blockIndexMap = /* @__PURE__ */ new Map(), editor.history = {
+  const context = config.editorActor.getSnapshot().context, placeholderBlock = createPlaceholderBlock(context), editor = createEditor();
+  editor.schema = context.schema, editor.keyGenerator = context.keyGenerator, editor.editableTypes = /* @__PURE__ */ new Set(), editor.decoratedRanges = [], editor.decoratorState = {}, editor.blockIndexMap = /* @__PURE__ */ new Map(), editor.history = {
     undos: [],
     redos: []
   }, editor.lastSelection = null, editor.lastSlateSelection = null, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.remotePatches = [], editor.undoStepId = void 0, editor.children = [placeholderBlock], editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
@@ -13235,7 +12625,7 @@ const removeAnnotationOperationImplementation = ({
   if (isTextBlockNode(context, slateBlock)) {
     const filteredProps = {};
     for (const key of Object.keys(operation.props))
-      if (!(key === "_type" || key === "children")) {
+      if (key !== "_type") {
         if (key === "_key") {
           filteredProps[key] = operation.props[key];
           continue;
@@ -13292,7 +12682,7 @@ const removeAnnotationOperationImplementation = ({
   if (!slateBlock)
     throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
   if (isTextBlockNode(context, slateBlock)) {
-    const propsToRemove = operation.props.filter((prop) => prop !== "_type" && prop !== "_key" && prop !== "children"), unsetProps2 = {};
+    const propsToRemove = operation.props.filter((prop) => prop !== "_type" && prop !== "_key"), unsetProps2 = {};
     for (const prop of propsToRemove)
       unsetProps2[prop] = null;
     applySetNode(operation.editor, unsetProps2, [blockIndex]), operation.props.includes("_key") && applySetNode(operation.editor, {
@@ -13411,19 +12801,14 @@ const removeAnnotationOperationImplementation = ({
   }, child)) {
     const newNode = {};
     for (const prop of operation.props)
-      if (prop !== "text" && prop !== "_type") {
+      if (prop !== "_type") {
         if (prop === "_key") {
           newNode._key = context.keyGenerator();
           continue;
         }
         newNode[prop] = null;
       }
-    applySetNode(operation.editor, newNode, childPath), operation.props.includes("text") && operation.editor.apply({
-      type: "remove_text",
-      path: childPath,
-      offset: 0,
-      text: child.text
-    });
+    applySetNode(operation.editor, newNode, childPath);
     return;
   }
   if (isObjectNode({
@@ -13492,125 +12877,401 @@ const removeAnnotationOperationImplementation = ({
       if (!blockEntry)
         return;
       const {
-        node: block,
-        path: blockPath
-      } = blockEntry, lonelyEmptySpan = isTextBlock({
-        schema: editor.schema
-      }, block) && block.children.length === 1 && isSpan({
+        node: block,
+        path: blockPath
+      } = blockEntry, lonelyEmptySpan = isTextBlock({
+        schema: editor.schema
+      }, block) && block.children.length === 1 && isSpan({
+        schema: editor.schema
+      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+      if (lonelyEmptySpan) {
+        const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark), newMarks = existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator;
+        for (const {
+          path: spanPath
+        } of Array.from(getNodes(editor, {
+          at: blockPath,
+          match: (node) => isSpan({
+            schema: editor.schema
+          }, node)
+        })))
+          applySetNode(editor, {
+            marks: newMarks
+          }, spanPath);
+      } else
+        editor.decoratorState[mark] = !0;
+    }
+    if (editor.selection) {
+      const selection = editor.selection;
+      editor.selection = {
+        ...selection
+      };
+    }
+  }
+}, decoratorRemoveOperationImplementation = ({
+  context,
+  operation
+}) => {
+  const editor = operation.editor, mark = operation.decorator, at = operation.at ? toSlateRange({
+    context: {
+      schema: context.schema,
+      value: operation.editor.children,
+      selection: operation.at
+    },
+    blockIndexMap: operation.editor.blockIndexMap
+  }) : editor.selection;
+  if (at) {
+    if (isExpandedRange(at)) {
+      const ref = rangeRef(editor, at, {
+        affinity: "inward"
+      }), decoratorLeafEntry = getNode(editor, at.anchor.path), decoratorLeaf = decoratorLeafEntry && isLeaf(editor, decoratorLeafEntry.path) ? decoratorLeafEntry.node : void 0;
+      if (!(decoratorLeaf && isCollapsedRange(at) && isSpan({
+        schema: editor.schema
+      }, decoratorLeaf) && decoratorLeaf.text.length > 0)) {
+        const [start2, end2] = rangeEdges(at);
+        (!isEnd(editor, end2, end2.path) || !isEdge(editor, end2, end2.path)) && applySplitNode(editor, end2.path, end2.offset), (!isStart(editor, start2, start2.path) || !isEdge(editor, start2, start2.path)) && applySplitNode(editor, start2.path, start2.offset);
+      }
+      const updatedAt = ref.unref();
+      if (updatedAt) {
+        const splitTextNodes = [...getNodes(editor, {
+          from: rangeStart(updatedAt).path,
+          to: rangeEnd(updatedAt).path,
+          match: (n) => isSpan({
+            schema: editor.schema
+          }, n)
+        })];
+        for (const {
+          node,
+          path: nodePath
+        } of splitTextNodes) {
+          if (!isSpan({
+            schema: editor.schema
+          }, node))
+            continue;
+          const block = editor.children[nodePath[0]];
+          isTextBlock({
+            schema: editor.schema
+          }, block) && block.children.includes(node) && applySetNode(editor, {
+            marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
+            _type: context.schema.span.name
+          }, nodePath);
+        }
+      }
+    } else {
+      const blockEntry = getNode(editor, path(editor, at, {
+        depth: 1
+      }));
+      if (!blockEntry)
+        return;
+      const {
+        node: block,
+        path: blockPath
+      } = blockEntry, lonelyEmptySpan = isTextBlock({
+        schema: editor.schema
+      }, block) && block.children.length === 1 && isSpan({
+        schema: editor.schema
+      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+      if (lonelyEmptySpan) {
+        const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
+        for (const {
+          path: spanPath
+        } of Array.from(getNodes(editor, {
+          at: blockPath,
+          match: (node) => isSpan({
+            schema: editor.schema
+          }, node)
+        })))
+          applySetNode(editor, {
+            marks: existingMarksWithoutDecorator
+          }, spanPath);
+      } else
+        editor.decoratorState[mark] = !1;
+    }
+    if (editor.selection) {
+      const selection = editor.selection;
+      editor.selection = {
+        ...selection
+      };
+    }
+  }
+};
+function pointRef(editor, point2, options = {}) {
+  const {
+    affinity = "forward"
+  } = options, ref = {
+    current: point2,
+    affinity,
+    unref() {
+      const {
+        current
+      } = ref;
+      return editor.pointRefs.delete(ref), ref.current = null, current;
+    }
+  };
+  return editor.pointRefs.add(ref), ref;
+}
+function shouldMergeNodesRemovePrevNode(editor, prev, _current) {
+  let isEmptyElement = !1;
+  if (isTextBlock({
+    schema: editor.schema
+  }, prev.node)) {
+    const prevChildren = prev.node.children;
+    isEmptyElement = prevChildren.length === 0 || prevChildren.length === 1 && isSpan({
+      schema: editor.schema
+    }, prevChildren[0]) && prevChildren[0].text === "";
+  }
+  return isEmptyElement || isSpan({
+    schema: editor.schema
+  }, prev.node) && prev.node.text === "" && prev.path[prev.path.length - 1] !== 0;
+}
+function isCommonPath(path2, another) {
+  return path2.length <= another.length && comparePaths(path2, another) === 0;
+}
+const getDefaultInsertLocation = (editor) => editor.selection ? editor.selection : editor.children.length > 0 ? end(editor, []) : [0];
+function insertText(editor, text, options = {}) {
+  withoutNormalizing(editor, () => {
+    const {
+      includeObjectNodes = !1
+    } = options;
+    let {
+      at = getDefaultInsertLocation(editor)
+    } = options;
+    if (isPath(at) && (at = range(editor, at)), isRange(at))
+      if (isCollapsedRange(at))
+        at = at.anchor;
+      else {
+        const end2 = rangeEnd(at);
+        if (!includeObjectNodes) {
+          const endPath = path(editor, end2), endEntry = getNode(editor, endPath);
+          if (endEntry && isObjectNode({
+            schema: editor.schema
+          }, endEntry.node) ? endEntry : getAncestorObjectNode(editor, end2.path))
+            return;
+        }
+        const start2 = rangeStart(at), startRef = pointRef(editor, start2), endRef = pointRef(editor, end2);
+        deleteText(editor, {
+          at,
+          includeObjectNodes
+        });
+        const startPoint = startRef.unref(), endPoint = endRef.unref();
+        at = startPoint || endPoint, editor.setSelection({
+          anchor: at,
+          focus: at
+        });
+      }
+    if (!includeObjectNodes) {
+      const atPath = path(editor, at), atEntry = getNode(editor, atPath);
+      if (atEntry && isObjectNode({
+        schema: editor.schema
+      }, atEntry.node) ? atEntry : getAncestorObjectNode(editor, at.path))
+        return;
+    }
+    const {
+      path: path$1,
+      offset
+    } = at;
+    text.length > 0 && editor.apply({
+      type: "insert_text",
+      path: path$1,
+      offset,
+      text
+    });
+  });
+}
+function deleteText(editor, options = {}) {
+  withoutNormalizing(editor, () => {
+    const {
+      reverse = !1,
+      unit = "character",
+      distance = 1,
+      includeObjectNodes = !1
+    } = options;
+    let {
+      at = editor.selection,
+      hanging = !1
+    } = options;
+    if (!at)
+      return;
+    let isCollapsed = !1;
+    if (isRange(at) && isCollapsedRange(at) && (isCollapsed = !0, at = at.anchor), isPoint(at)) {
+      const furthestObjectNode = getHighestObjectNode(editor, at.path);
+      if (!includeObjectNodes && furthestObjectNode)
+        at = furthestObjectNode.path;
+      else {
+        const opts = {
+          unit,
+          distance
+        }, target = reverse ? before(editor, at, opts) || start(editor, []) : after(editor, at, opts) || end(editor, []);
+        at = {
+          anchor: at,
+          focus: target
+        }, hanging = !0;
+      }
+    }
+    if (isPath(at)) {
+      removeNodes(editor, {
+        at,
+        includeObjectNodes
+      });
+      return;
+    }
+    if (isCollapsedRange(at))
+      return;
+    if (!hanging) {
+      const [, end2] = rangeEdges(at), endOfDoc = end(editor, []);
+      pointEquals(end2, endOfDoc) || (at = unhangRange(editor, at));
+    }
+    let [start$1, end$1] = rangeEdges(at);
+    const startBlock = getAncestorTextBlock(editor, start$1.path), endBlock = getAncestorTextBlock(editor, end$1.path), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock.path, endBlock.path), isSingleText = pathEquals(start$1.path, end$1.path), startNonEditable = includeObjectNodes ? null : getHighestObjectNode(editor, start$1.path), endNonEditable = includeObjectNodes ? null : getHighestObjectNode(editor, end$1.path);
+    if (startNonEditable) {
+      const beforePoint = before(editor, start$1);
+      beforePoint && startBlock && isAncestorPath(startBlock.path, beforePoint.path) && (start$1 = beforePoint);
+    }
+    if (endNonEditable) {
+      const afterPoint = after(editor, end$1);
+      afterPoint && endBlock && isAncestorPath(endBlock.path, afterPoint.path) && (end$1 = afterPoint);
+    }
+    const matches = [];
+    let lastPath;
+    for (const entry of getNodes(editor, {
+      from: start$1.path,
+      to: end$1.path
+    })) {
+      const {
+        node,
+        path: entryPath
+      } = entry;
+      lastPath && comparePaths(entryPath, lastPath) === 0 || (!includeObjectNodes && isObjectNode({
         schema: editor.schema
-      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
-      if (lonelyEmptySpan) {
-        const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark), newMarks = existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator;
-        for (const {
-          path: spanPath
-        } of Array.from(getNodes(editor, {
-          at: blockPath,
-          match: (node) => isSpan({
-            schema: editor.schema
-          }, node)
-        })))
-          applySetNode(editor, {
-            marks: newMarks
-          }, spanPath);
-      } else
-        editor.decoratorState[mark] = !0;
+      }, node) || !isCommonPath(entryPath, start$1.path) && !isCommonPath(entryPath, end$1.path)) && (matches.push(entry), lastPath = entryPath);
     }
-    if (editor.selection) {
-      const selection = editor.selection;
-      editor.selection = {
-        ...selection
-      };
+    const pathRefs = Array.from(matches, (entry) => pathRef(editor, entry.path)), startRef = pointRef(editor, start$1), endRef = pointRef(editor, end$1);
+    let removedText = "";
+    if (!isSingleText && !startNonEditable) {
+      const point22 = startRef.current, nodeEntry = getSpanNode(editor, point22.path);
+      if (nodeEntry) {
+        const node = nodeEntry.node, {
+          path: path2
+        } = point22, {
+          offset
+        } = start$1, text = node.text.slice(offset);
+        text.length > 0 && (editor.apply({
+          type: "remove_text",
+          path: path2,
+          offset,
+          text
+        }), removedText = text);
+      }
     }
-  }
-}, decoratorRemoveOperationImplementation = ({
-  context,
-  operation
-}) => {
-  const editor = operation.editor, mark = operation.decorator, at = operation.at ? toSlateRange({
-    context: {
-      schema: context.schema,
-      value: operation.editor.children,
-      selection: operation.at
-    },
-    blockIndexMap: operation.editor.blockIndexMap
-  }) : editor.selection;
-  if (at) {
-    if (isExpandedRange(at)) {
-      const ref = rangeRef(editor, at, {
-        affinity: "inward"
-      }), decoratorLeafEntry = getNode(editor, at.anchor.path), decoratorLeaf = decoratorLeafEntry && isLeaf(editor, decoratorLeafEntry.path) ? decoratorLeafEntry.node : void 0;
-      if (!(decoratorLeaf && isCollapsedRange(at) && isSpan({
-        schema: editor.schema
-      }, decoratorLeaf) && decoratorLeaf.text.length > 0)) {
-        const [start2, end2] = rangeEdges(at);
-        (!isEnd(editor, end2, end2.path) || !isEdge(editor, end2, end2.path)) && applySplitNode(editor, end2.path, end2.offset), (!isStart(editor, start2, start2.path) || !isEdge(editor, start2, start2.path)) && applySplitNode(editor, start2.path, start2.offset);
+    if (pathRefs.reverse().map((r) => r.unref()).filter((r) => r !== null).forEach((p) => {
+      removeNodes(editor, {
+        at: p,
+        includeObjectNodes
+      });
+    }), !endNonEditable) {
+      const point22 = endRef.current, endNodeEntry = getSpanNode(editor, point22.path);
+      if (endNodeEntry) {
+        const node = endNodeEntry.node, {
+          path: path2
+        } = point22, offset = isSingleText ? start$1.offset : 0, text = node.text.slice(offset, end$1.offset);
+        text.length > 0 && (editor.apply({
+          type: "remove_text",
+          path: path2,
+          offset,
+          text
+        }), removedText = text);
       }
-      const updatedAt = ref.unref();
-      if (updatedAt) {
-        const splitTextNodes = [...getNodes(editor, {
-          from: rangeStart(updatedAt).path,
-          to: rangeEnd(updatedAt).path,
-          match: (n) => isSpan({
+    }
+    if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {
+      const mergeAt = endRef.current, mergeMatch = (n) => isTextBlock({
+        schema: editor.schema
+      }, n), current = getAncestor(editor, mergeAt.path, mergeMatch), beforePoint = before(editor, mergeAt), prev = beforePoint ? getNodes(editor, {
+        to: beforePoint.path,
+        match: mergeMatch,
+        reverse: !0
+      }).next().value : void 0;
+      if (current && prev) {
+        const {
+          node: mergeNode,
+          path: mergePath
+        } = current, {
+          node: prevNode,
+          path: prevPath
+        } = prev;
+        if (mergePath.length !== 0 && prevPath.length !== 0) {
+          const newPath = nextPath(prevPath), common = commonPath(mergePath, prevPath), isPreviousSibling = isSiblingPath(mergePath, prevPath), editorLevels = pathLevels(mergePath).filter((levelPath) => levelPath.length > 0).map((levelPath) => getNode(editor, levelPath)).filter((entry) => entry !== void 0).map((entry) => entry.node).slice(Math.max(0, common.length - 1)).slice(0, -1), hasSingleChildNest = (node) => {
+            if (isTextBlock({
+              schema: editor.schema
+            }, node)) {
+              const elementChildren = node.children;
+              return elementChildren.length === 1 ? hasSingleChildNest(elementChildren[0]) : !1;
+            } else return !isEditor(node);
+          }, emptyAncestor = getAncestors(editor, mergePath).reverse().find((ancestor) => editorLevels.includes(ancestor.node) && hasSingleChildNest(ancestor.node)), emptyRef = emptyAncestor && pathRef(editor, emptyAncestor.path);
+          let position;
+          if (isSpan({
             schema: editor.schema
-          }, n)
-        })];
-        for (const {
-          node,
-          path: nodePath
-        } of splitTextNodes) {
-          if (!isSpan({
+          }, mergeNode) && isSpan({
             schema: editor.schema
-          }, node))
-            continue;
-          const block = editor.children[nodePath[0]];
-          isTextBlock({
+          }, prevNode))
+            position = prevNode.text.length;
+          else if (isTextBlock({
             schema: editor.schema
-          }, block) && block.children.includes(node) && applySetNode(editor, {
-            marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
-            _type: context.schema.span.name
-          }, nodePath);
+          }, mergeNode) && isTextBlock({
+            schema: editor.schema
+          }, prevNode))
+            position = prevNode.children.length;
+          else
+            throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${safeStringify(mergeNode)} ${safeStringify(prevNode)}`);
+          if (!isPreviousSibling) {
+            const moveNodeEntry = getNode(editor, mergePath);
+            if (moveNodeEntry) {
+              const moveNode = moveNodeEntry.node;
+              editor.apply({
+                type: "remove_node",
+                path: mergePath,
+                node: moveNode
+              }), editor.apply({
+                type: "insert_node",
+                path: newPath,
+                node: moveNode
+              });
+            }
+          }
+          if (emptyRef && removeNodes(editor, {
+            at: emptyRef.current,
+            includeObjectNodes
+          }), shouldMergeNodesRemovePrevNode(editor, {
+            node: prevNode,
+            path: prevPath
+          }, {
+            node: mergeNode,
+            path: mergePath
+          }))
+            removeNodes(editor, {
+              at: prevPath,
+              includeObjectNodes
+            });
+          else {
+            const pteEditor = editor;
+            if (isTextBlock({
+              schema: editor.schema
+            }, mergeNode) && isTextBlock({
+              schema: editor.schema
+            }, prevNode) && Array.isArray(mergeNode.markDefs) && mergeNode.markDefs.length > 0) {
+              const targetPath = isPreviousSibling ? prevPath : previousPath(newPath), oldDefs = Array.isArray(prevNode.markDefs) && prevNode.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...mergeNode.markDefs].map((def) => [def._key, def])).values()];
+              applySetNode(pteEditor, {
+                markDefs: newMarkDefs
+              }, targetPath);
+            }
+            applyMergeNode(pteEditor, newPath, position);
+          }
+          emptyRef && emptyRef.unref();
         }
       }
-    } else {
-      const blockEntry = getNode(editor, path(editor, at, {
-        depth: 1
-      }));
-      if (!blockEntry)
-        return;
-      const {
-        node: block,
-        path: blockPath
-      } = blockEntry, lonelyEmptySpan = isTextBlock({
-        schema: editor.schema
-      }, block) && block.children.length === 1 && isSpan({
-        schema: editor.schema
-      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
-      if (lonelyEmptySpan) {
-        const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
-        for (const {
-          path: spanPath
-        } of Array.from(getNodes(editor, {
-          at: blockPath,
-          match: (node) => isSpan({
-            schema: editor.schema
-          }, node)
-        })))
-          applySetNode(editor, {
-            marks: existingMarksWithoutDecorator
-          }, spanPath);
-      } else
-        editor.decoratorState[mark] = !1;
-    }
-    if (editor.selection) {
-      const selection = editor.selection;
-      editor.selection = {
-        ...selection
-      };
     }
-  }
-};
-function isInline(context, path2) {
-  return !isBlock(context, path2);
+    isCollapsed && reverse && unit === "character" && removedText.length > 1 && removedText.match(/[\u0980-\u09FF\u0E00-\u0E7F\u1000-\u109F\u0900-\u097F\u1780-\u17FF\u0D00-\u0D7F\u0B00-\u0B7F\u0A00-\u0A7F\u0B80-\u0BFF\u0C00-\u0C7F]+/) && insertText(editor, removedText.slice(0, removedText.length - distance));
+    const startUnref = startRef.unref(), endUnref = endRef.unref(), point2 = reverse ? startUnref || endUnref : endUnref || startUnref;
+    options.at == null && point2 && editor.select(point2);
+  });
 }
 const deleteOperationImplementation = ({
   context,
@@ -18692,8 +18353,11 @@ function updateBlock({
 }) {
   const slateBlock = toSlateBlock(block, {
     schemaTypes: context.schema
-  });
-  applySetNode(slateEditor, slateBlock, [index]);
+  }), {
+    children: _children,
+    ...blockProps
+  } = slateBlock;
+  applySetNode(slateEditor, blockProps, [index]);
   const oldRecord = oldSlateBlock, newRecord = slateBlock, removedProperties = {};
   for (const key of Object.keys(oldRecord))
     key === "children" || key === "text" || newRecord.hasOwnProperty(key) || (removedProperties[key] = oldRecord[key]);
@@ -18728,7 +18392,12 @@ function updateBlock({
       }, oldBlockChild) && currentBlockChild.text !== oldBlockChild.text, path2 = [index, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key && currentBlockChild._type === oldBlockChild?._type) {
-          debug$1.syncValue("Updating changed child", currentBlockChild, oldBlockChild), applySetNode(slateEditor, currentBlockChild, path2);
+          debug$1.syncValue("Updating changed child", currentBlockChild, oldBlockChild);
+          const {
+            text: _text,
+            ...childProps
+          } = currentBlockChild;
+          applySetNode(slateEditor, childProps, path2);
           const isSpanNode2 = isSpan({
             schema: context.schema
           }, currentBlockChild) && isSpan({