@portabletext/editor 2.21.3 → 3.0.0

package/lib/index.js

@@ -1,20 +1,17 @@
-import { c } from "react-compiler-runtime";
-import { useEffect, createContext, useContext, useState, useRef, forwardRef, Component, startTransition } from "react";
-import { useEditor, EditorContext } from "./_chunks-es/use-editor.js";
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { c } from "react-compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import noop from "lodash/noop.js";
+import { createContext, useContext, useEffect, useState, useRef, forwardRef, Component, startTransition } from "react";
 import { Element as Element$1, Text, Range, Editor, Node, Point, Path, Transforms, Operation, deleteText, createEditor } from "slate";
 import { useSelected, useSlateSelector, useSlateStatic, ReactEditor, useSlate, Editable, withReact, Slate } from "slate-react";
-import debug$g from "debug";
+import debug$j from "debug";
 import { DOMEditor, isDOMNode, EDITOR_TO_PENDING_SELECTION, IS_FOCUSED, IS_READ_ONLY } from "slate-dom";
-import { getBlockEndPoint, isSelectionCollapsed, isEqualSelectionPoints, isEmptyTextBlock } from "./_chunks-es/util.is-empty-text-block.js";
-import { getBlockStartPoint, getBlockKeyFromSelectionPoint, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, parseAnnotation, parseSpan, parseInlineObject, isKeyedSegment, isListBlock, isTypedObject, getSelectionStartPoint, getSelectionEndPoint, getTextBlockText } from "./_chunks-es/util.get-text-block-text.js";
+import { getBlockEndPoint, getBlockStartPoint, getBlockKeyFromSelectionPoint, isSelectionCollapsed, isEqualSelectionPoints, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, parseAnnotation, parseSpan, parseInlineObject, isKeyedSegment, isListBlock, isTypedObject, getSelectionStartPoint, getSelectionEndPoint } from "./_chunks-es/util.slice-blocks.js";
 import isEqual from "lodash/isEqual.js";
 import { isTextBlock, isSpan, compileSchema } from "@portabletext/schema";
 import { defineSchema } from "@portabletext/schema";
-import { getFocusInlineObject, getSelectedBlocks, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, isSelectingEntireBlocks, getActiveDecorators, isActiveAnnotation, getCaretWordSelection, getFocusBlockObject, getPreviousBlock, getNextBlock, getMarkState, getActiveAnnotationsMarks, isAtTheEndOfBlock, isAtTheStartOfBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock, getSelectionEndPoint as getSelectionEndPoint$1, isActiveDecorator, getActiveAnnotations, getSelectedTextBlocks, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
-import { isSelectionCollapsed as isSelectionCollapsed$1, getFocusTextBlock, getFocusSpan as getFocusSpan$1, isSelectionExpanded, getFocusBlock as getFocusBlock$1, getSelectedValue, getSelectionStartPoint as getSelectionStartPoint$1, getFocusChild as getFocusChild$1 } from "./_chunks-es/selector.get-selection-text.js";
+import { getFocusInlineObject, isSelectionCollapsed as isSelectionCollapsed$1, getFocusTextBlock, getFocusSpan as getFocusSpan$1, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock as getFocusBlock$1, isSelectingEntireBlocks, getSelectedValue, getActiveDecorators, isActiveAnnotation, getCaretWordSelection, getFocusBlockObject, getPreviousBlock, getNextBlock, getMarkState, getActiveAnnotationsMarks, isAtTheEndOfBlock, isAtTheStartOfBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, isActiveDecorator, getFocusChild as getFocusChild$1, getActiveAnnotations, getSelectedTextBlocks, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
 import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
 import uniq from "lodash/uniq.js";
 import { setup, fromCallback, assign, and, enqueueActions, emit, assertEvent, raise as raise$1, not, createActor } from "xstate";
@@ -25,26 +22,18 @@ import { Schema } from "@sanity/schema";
 import flatten from "lodash/flatten.js";
 import omit from "lodash/omit.js";
 import { applyAll, unset, insert, set, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
+import { isEmptyTextBlock, sliceTextBlock, getTextBlockText } from "./_chunks-es/util.slice-text-block.js";
 import { createDraft, finishDraft } from "immer";
 import { createKeyboardShortcut, code, underline, italic, bold, undo, redo } from "@portabletext/keyboard-shortcuts";
-import { sliceTextBlock } from "./_chunks-es/util.slice-text-block.js";
 import isPlainObject from "lodash/isPlainObject.js";
+import { EditorContext } from "./_chunks-es/use-editor.js";
+import { useEditor } from "./_chunks-es/use-editor.js";
 import { Subject } from "rxjs";
-function EditorEventListener(props) {
-  const $ = c(4), editor = useEditor();
-  let t0, t1;
-  return $[0] !== editor || $[1] !== props.on ? (t0 = () => {
-    const subscription = editor.on("*", props.on);
-    return () => {
-      subscription.unsubscribe();
-    };
-  }, t1 = [editor, props.on], $[0] = editor, $[1] = props.on, $[2] = t0, $[3] = t1) : (t0 = $[2], t1 = $[3]), useEffect(t0, t1), null;
-}
 const rootName = "sanity-pte:";
-debug$g(rootName);
+debug$j(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$g && debug$g.enabled(namespace) ? debug$g(namespace) : debug$g(rootName);
+  return debug$j && debug$j.enabled(namespace) ? debug$j(namespace) : debug$j(rootName);
 }
 const VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
@@ -1547,7 +1536,7 @@ function toKeyName(name) {
   const keyName = name.toLowerCase();
   return aliases[keyName] ?? keyName;
 }
-const debug$f = debugWithName("plugin:withHotKeys");
+const debug$i = debugWithName("plugin:withHotKeys");
 function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions) {
   const reservedHotkeys = ["enter", "tab", "shift", "delete", "end"], activeHotkeys = hotkeysFromOptions ?? {};
   return function(editor) {
@@ -1562,7 +1551,7 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
               const possibleMark = activeHotkeys[cat];
               if (possibleMark) {
                 const mark = possibleMark[hotkey];
-                debug$f(`HotKey ${hotkey} to toggle ${mark}`), editorActor.send({
+                debug$i(`HotKey ${hotkey} to toggle ${mark}`), editorActor.send({
                   type: "behavior event",
                   behaviorEvent: {
                     type: "decorator.toggle",
@@ -1891,7 +1880,7 @@ function createDecorate(schema, slateEditor) {
     }) || Range.includes(decoratedRange, path));
   };
 }
-const RelayActorContext = createContext({}), debug$e = debugWithName("validate selection machine"), validateSelectionSetup = setup({
+const RelayActorContext = createContext({}), debug$h = debugWithName("validate selection machine"), validateSelectionSetup = setup({
   types: {
     context: {},
     input: {},
@@ -1963,12 +1952,12 @@ function validateSelection(slateEditor, editorElement) {
   const existingDOMRange = domSelection.getRangeAt(0);
   try {
     const newDOMRange = ReactEditor.toDOMRange(slateEditor, slateEditor.selection);
-    (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug$e("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
+    (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug$h("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
   } catch {
-    debug$e("Could not resolve selection, selecting top document"), Transforms.deselect(slateEditor), slateEditor.children.length > 0 && Transforms.select(slateEditor, Editor.start(slateEditor, [])), slateEditor.onChange();
+    debug$h("Could not resolve selection, selecting top document"), Transforms.deselect(slateEditor), slateEditor.children.length > 0 && Transforms.select(slateEditor, Editor.start(slateEditor, [])), slateEditor.onChange();
   }
 }
-const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), debug$d = debugWithName("component:Editable"), PortableTextEditable = forwardRef(function(props, forwardedRef) {
+const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), debug$g = debugWithName("component:Editable"), PortableTextEditable = forwardRef(function(props, forwardedRef) {
   const $ = c(176);
   let hotkeys, onBeforeInput, onBlur, onClick, onCopy, onCut, onDrag, onDragEnd, onDragEnter, onDragLeave, onDragOver, onDragStart, onDrop, onFocus, onPaste, propsSelection, rangeDecorations, renderAnnotation, renderBlock, renderChild, renderDecorator, renderListItem, renderPlaceholder, renderStyle, restProps, scrollSelectionIntoView, spellCheck;
   $[0] !== props ? ({
@@ -2057,10 +2046,10 @@ const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE
   let t14;
   $[63] !== editorActor || $[64] !== propsSelection || $[65] !== slateEditor ? (t14 = () => {
     if (propsSelection) {
-      debug$d(`Selection from props ${JSON.stringify(propsSelection)}`);
+      debug$g(`Selection from props ${JSON.stringify(propsSelection)}`);
       const normalizedSelection = normalizeSelection(propsSelection, fromSlateValue(slateEditor.children, editorActor.getSnapshot().context.schema.block.name));
       if (normalizedSelection !== null) {
-        debug$d(`Normalized selection from props ${JSON.stringify(normalizedSelection)}`);
+        debug$g(`Normalized selection from props ${JSON.stringify(normalizedSelection)}`);
         const slateRange = toSlateRange({
           context: {
             schema: editorActor.getSnapshot().context.schema,
@@ -2172,8 +2161,8 @@ const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE
       event_1.preventDefault(), relayActor.send({
         type: "loading"
       }), Promise.resolve(onPasteResult).then((result_1) => {
-        if (debug$d("Custom paste function from client resolved", result_1), !result_1 || !result_1.insert) {
-          debug$d("No result from custom paste handler, pasting normally");
+        if (debug$g("Custom paste function from client resolved", result_1), !result_1 || !result_1.insert) {
+          debug$g("No result from custom paste handler, pasting normally");
           const selection_1 = editorActor.getSnapshot().context.selection, position_1 = selection_1 ? {
             selection: selection_1
           } : void 0;
@@ -2240,7 +2229,7 @@ const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE
         nativeEvent: event_1
       });
     }
-    debug$d("No result from custom paste handler, pasting normally");
+    debug$g("No result from custom paste handler, pasting normally");
   }, $[85] = editorActor, $[86] = onPaste, $[87] = portableTextEditor, $[88] = relayActor, $[89] = slateEditor, $[90] = t21) : t21 = $[90];
   const handlePaste = t21;
   let t22;
@@ -2873,6 +2862,183 @@ function createPlaceholderBlock(context) {
     }]
   };
 }
+function withRemoteChanges(editor, fn) {
+  const prev = isChangingRemotely(editor) || !1;
+  IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
+}
+function isChangingRemotely(editor) {
+  return IS_PROCESSING_REMOTE_CHANGES.get(editor);
+}
+const REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) ?? []), IS_REDOING = /* @__PURE__ */ new WeakMap();
+function pluginRedoing(editor, fn) {
+  const prev = isRedoing(editor);
+  IS_REDOING.set(editor, !0), fn(), IS_REDOING.set(editor, prev);
+}
+function isRedoing(editor) {
+  return IS_REDOING.get(editor) ?? !1;
+}
+function setIsRedoing(editor, isRedoing2) {
+  IS_REDOING.set(editor, isRedoing2);
+}
+const IS_UDOING = /* @__PURE__ */ new WeakMap();
+function pluginUndoing(editor, fn) {
+  const prev = isUndoing(editor);
+  IS_UDOING.set(editor, !0), fn(), IS_UDOING.set(editor, prev);
+}
+function isUndoing(editor) {
+  return IS_UDOING.get(editor) ?? !1;
+}
+function setIsUndoing(editor, isUndoing2) {
+  IS_UDOING.set(editor, isUndoing2);
+}
+const WITH_HISTORY = /* @__PURE__ */ new WeakMap();
+function isWithHistory(editor) {
+  return WITH_HISTORY.get(editor) ?? !0;
+}
+function pluginWithoutHistory(editor, fn) {
+  const withHistory = isWithHistory(editor);
+  WITH_HISTORY.set(editor, !1), fn(), WITH_HISTORY.set(editor, withHistory);
+}
+function setWithHistory(editor, withHistory) {
+  WITH_HISTORY.set(editor, withHistory);
+}
+const IS_NORMALIZING_NODE = /* @__PURE__ */ new WeakMap();
+function withNormalizeNode(editor, fn) {
+  const prev = IS_NORMALIZING_NODE.get(editor);
+  IS_NORMALIZING_NODE.set(editor, !0), fn(), IS_NORMALIZING_NODE.set(editor, prev);
+}
+function isNormalizingNode(editor) {
+  return IS_NORMALIZING_NODE.get(editor) ?? !1;
+}
+const CURRENT_UNDO_STEP_ID = /* @__PURE__ */ new WeakMap();
+function getCurrentUndoStepId(editor) {
+  return CURRENT_UNDO_STEP_ID.get(editor)?.undoStepId;
+}
+function createUndoStepId(editor) {
+  CURRENT_UNDO_STEP_ID.set(editor, {
+    undoStepId: defaultKeyGenerator()
+  });
+}
+function clearUndoStepId(editor) {
+  CURRENT_UNDO_STEP_ID.set(editor, void 0);
+}
+function createUndoSteps({
+  steps,
+  op,
+  editor,
+  currentUndoStepId,
+  previousUndoStepId
+}) {
+  const lastStep = steps.at(-1);
+  if (!lastStep)
+    return createNewStep(steps, op, editor);
+  if (editor.operations.length > 0)
+    return currentUndoStepId === previousUndoStepId || isNormalizingNode(editor) ? mergeIntoLastStep(steps, lastStep, op) : createNewStep(steps, op, editor);
+  if (op.type === "set_selection" && currentUndoStepId === void 0 && previousUndoStepId !== void 0 || op.type === "set_selection" && currentUndoStepId !== void 0 && previousUndoStepId !== void 0 && previousUndoStepId !== currentUndoStepId)
+    return mergeIntoLastStep(steps, lastStep, op);
+  if (currentUndoStepId === void 0 && previousUndoStepId === void 0) {
+    if (op.type === "set_selection")
+      return mergeIntoLastStep(steps, lastStep, op);
+    const lastOp = lastStep.operations.at(-1);
+    return lastOp && op.type === "insert_text" && lastOp.type === "insert_text" && op.offset === lastOp.offset + lastOp.text.length && Path.equals(op.path, lastOp.path) && op.text !== " " || lastOp && op.type === "remove_text" && lastOp.type === "remove_text" && op.offset + op.text.length === lastOp.offset && Path.equals(op.path, lastOp.path) ? mergeIntoLastStep(steps, lastStep, op) : createNewStep(steps, op, editor);
+  }
+  return createNewStep(steps, op, editor);
+}
+function createNewStep(steps, op, editor) {
+  const operations = editor.selection === null ? [op] : [{
+    type: "set_selection",
+    properties: {
+      ...editor.selection
+    },
+    newProperties: {
+      ...editor.selection
+    }
+  }, op];
+  return [...steps, {
+    operations,
+    timestamp: /* @__PURE__ */ new Date()
+  }];
+}
+function mergeIntoLastStep(steps, lastStep, op) {
+  return [...steps.slice(0, -1), {
+    timestamp: lastStep.timestamp,
+    operations: [...lastStep.operations, op]
+  }];
+}
+const debug$f = debugWithName("plugin:history"), UNDO_STEP_LIMIT = 1e3;
+function pluginHistory({
+  editorActor,
+  subscriptions
+}) {
+  return (editor) => {
+    const remotePatches = getRemotePatches(editor);
+    let previousSnapshot = fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name), previousUndoStepId = getCurrentUndoStepId(editor);
+    subscriptions.push(() => {
+      const subscription = editorActor.on("patches", ({
+        patches,
+        snapshot
+      }) => {
+        let reset = !1;
+        for (const patch of patches)
+          if (!reset && patch.origin !== "local") {
+            if (patch.type === "unset" && patch.path.length === 0) {
+              debug$f("Someone else cleared the content, resetting undo/redo history"), editor.history = {
+                undos: [],
+                redos: []
+              }, remotePatches.splice(0, remotePatches.length), setWithHistory(editor, !0), reset = !0;
+              return;
+            }
+            remotePatches.push({
+              patch,
+              time: /* @__PURE__ */ new Date(),
+              snapshot,
+              previousSnapshot
+            });
+          }
+        previousSnapshot = snapshot;
+      });
+      return () => {
+        subscription.unsubscribe();
+      };
+    }), editor.history = {
+      undos: [],
+      redos: []
+    };
+    const {
+      apply: apply2
+    } = editor;
+    return editor.apply = (op) => {
+      if (editorActor.getSnapshot().matches({
+        "edit mode": "read only"
+      })) {
+        apply2(op);
+        return;
+      }
+      if (isChangingRemotely(editor)) {
+        apply2(op);
+        return;
+      }
+      if (isUndoing(editor) || isRedoing(editor)) {
+        apply2(op);
+        return;
+      }
+      const withHistory = isWithHistory(editor), currentUndoStepId = getCurrentUndoStepId(editor);
+      if (!withHistory) {
+        previousUndoStepId = currentUndoStepId, apply2(op);
+        return;
+      }
+      for (op.type !== "set_selection" && (editor.history.redos = []), editor.history.undos = createUndoSteps({
+        steps: editor.history.undos,
+        op,
+        editor,
+        currentUndoStepId,
+        previousUndoStepId
+      }); editor.history.undos.length > UNDO_STEP_LIMIT; )
+        editor.history.undos.shift();
+      previousUndoStepId = currentUndoStepId, apply2(op);
+    }, editor;
+  };
+}
 function getPreviousSpan({
   editor,
   blockPath,
@@ -2901,43 +3067,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const IS_NORMALIZING_NODE = /* @__PURE__ */ new WeakMap();
-function withNormalizeNode(editor, fn) {
-  const prev = IS_NORMALIZING_NODE.get(editor);
-  IS_NORMALIZING_NODE.set(editor, !0), fn(), IS_NORMALIZING_NODE.set(editor, prev);
-}
-function isNormalizingNode(editor) {
-  return IS_NORMALIZING_NODE.get(editor) ?? !1;
-}
-function withRemoteChanges(editor, fn) {
-  const prev = isChangingRemotely(editor) || !1;
-  IS_PROCESSING_REMOTE_CHANGES.set(editor, !0), fn(), IS_PROCESSING_REMOTE_CHANGES.set(editor, prev);
-}
-function isChangingRemotely(editor) {
-  return IS_PROCESSING_REMOTE_CHANGES.get(editor);
-}
-const IS_UDOING = /* @__PURE__ */ new WeakMap(), IS_REDOING = /* @__PURE__ */ new WeakMap();
-function withUndoing(editor, fn) {
-  const prev = isUndoing(editor);
-  IS_UDOING.set(editor, !0), fn(), IS_UDOING.set(editor, prev);
-}
-function isUndoing(editor) {
-  return IS_UDOING.get(editor) ?? !1;
-}
-function setIsUndoing(editor, isUndoing2) {
-  IS_UDOING.set(editor, isUndoing2);
-}
-function withRedoing(editor, fn) {
-  const prev = isRedoing(editor);
-  IS_REDOING.set(editor, !0), fn(), IS_REDOING.set(editor, prev);
-}
-function isRedoing(editor) {
-  return IS_REDOING.get(editor) ?? !1;
-}
-function setIsRedoing(editor, isRedoing2) {
-  IS_REDOING.set(editor, isRedoing2);
-}
-const debug$c = debugWithName("plugin:withPortableTextMarkModel");
+const debug$e = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
@@ -2951,7 +3081,7 @@ function createWithPortableTextMarkModel(editorActor) {
         for (const [child, childPath] of children) {
           const nextNode = node.children[childPath[1] + 1];
           if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
-            debug$c("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), withNormalizeNode(editor, () => {
+            debug$e("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), withNormalizeNode(editor, () => {
               Transforms.mergeNodes(editor, {
                 at: [childPath[0], childPath[1] + 1],
                 voids: !0
@@ -2962,7 +3092,7 @@ function createWithPortableTextMarkModel(editorActor) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$c("Adding .markDefs to block node"), withNormalizeNode(editor, () => {
+        debug$e("Adding .markDefs to block node"), withNormalizeNode(editor, () => {
           Transforms.setNodes(editor, {
             markDefs: []
           }, {
@@ -2972,7 +3102,7 @@ function createWithPortableTextMarkModel(editorActor) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$c("Adding .marks to span node"), withNormalizeNode(editor, () => {
+        debug$e("Adding .marks to span node"), withNormalizeNode(editor, () => {
           Transforms.setNodes(editor, {
             marks: []
           }, {
@@ -2984,7 +3114,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$c("Removing annotations from empty span node"), withNormalizeNode(editor, () => {
+          debug$e("Removing annotations from empty span node"), withNormalizeNode(editor, () => {
             Transforms.setNodes(editor, {
               marks: node.marks?.filter((mark) => decorators2.includes(mark))
             }, {
@@ -3000,7 +3130,7 @@ function createWithPortableTextMarkModel(editorActor) {
           if (editor.isTextSpan(child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
-              debug$c("Removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
+              debug$e("Removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
                 Transforms.setNodes(editor, {
                   marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
                 }, {
@@ -3016,7 +3146,7 @@ function createWithPortableTextMarkModel(editorActor) {
         if (editor.isTextBlock(block)) {
           const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$c("Removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
+            debug$e("Removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
               Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
               }, {
@@ -3032,7 +3162,7 @@ function createWithPortableTextMarkModel(editorActor) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$c("Removing duplicate markDefs"), withNormalizeNode(editor, () => {
+          debug$e("Removing duplicate markDefs"), withNormalizeNode(editor, () => {
             Transforms.setNodes(editor, {
               markDefs: newMarkDefs
             }, {
@@ -3045,7 +3175,7 @@ function createWithPortableTextMarkModel(editorActor) {
       if (editor.isTextBlock(node) && !editor.operations.some((op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1)) {
         const newMarkDefs = (node.markDefs || []).filter((def) => node.children.find((child) => Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual(newMarkDefs, node.markDefs)) {
-          debug$c("Removing markDef not in use"), withNormalizeNode(editor, () => {
+          debug$e("Removing markDef not in use"), withNormalizeNode(editor, () => {
             Transforms.setNodes(editor, {
               markDefs: newMarkDefs
             }, {
@@ -3137,7 +3267,7 @@ function createWithPortableTextMarkModel(editorActor) {
         const [targetBlock, targetPath] = Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq([...oldDefs, ...op.properties.markDefs]);
-          debug$c("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
+          debug$e("Copying markDefs over to merged block", op), Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -3833,174 +3963,7 @@ function parse(textline) {
 function toInt(num) {
   return parseInt(num, 10);
 }
-const CURRENT_UNDO_STEP = /* @__PURE__ */ new WeakMap();
-function getCurrentUndoStepId(editor) {
-  return CURRENT_UNDO_STEP.get(editor)?.undoStepId;
-}
-function createUndoStep(editor) {
-  CURRENT_UNDO_STEP.set(editor, {
-    undoStepId: defaultKeyGenerator()
-  });
-}
-function clearUndoStep(editor) {
-  CURRENT_UNDO_STEP.set(editor, void 0);
-}
-const debug$b = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
-  const state = SAVING.get(editor);
-  return state === void 0 ? !0 : state;
-}, getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) || []);
-function createWithUndoRedo(options) {
-  const {
-    editorActor
-  } = options;
-  return (editor) => {
-    let previousSnapshot = fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name);
-    const remotePatches = getRemotePatches(editor);
-    let previousUndoStepId = getCurrentUndoStepId(editor);
-    options.subscriptions.push(() => {
-      debug$b("Subscribing to patches");
-      const sub = editorActor.on("patches", ({
-        patches,
-        snapshot
-      }) => {
-        let reset = !1;
-        patches.forEach((patch) => {
-          if (!reset && patch.origin !== "local" && remotePatches) {
-            if (patch.type === "unset" && patch.path.length === 0) {
-              debug$b("Someone else cleared the content, resetting undo/redo history"), editor.history = {
-                undos: [],
-                redos: []
-              }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
-              return;
-            }
-            remotePatches.push({
-              patch,
-              time: /* @__PURE__ */ new Date(),
-              snapshot,
-              previousSnapshot
-            });
-          }
-        }), previousSnapshot = snapshot;
-      });
-      return () => {
-        debug$b("Unsubscribing to patches"), sub.unsubscribe();
-      };
-    }), editor.history = {
-      undos: [],
-      redos: []
-    };
-    const {
-      apply: apply2
-    } = editor;
-    return editor.apply = (op) => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      })) {
-        apply2(op);
-        return;
-      }
-      if (isChangingRemotely(editor)) {
-        apply2(op);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(op);
-        return;
-      }
-      const savingUndoSteps = isSaving(editor), currentUndoStepId = getCurrentUndoStepId(editor);
-      if (!savingUndoSteps) {
-        previousUndoStepId = currentUndoStepId, apply2(op);
-        return;
-      }
-      op.type !== "set_selection" && (editor.history.redos = []);
-      const step = editor.history.undos.at(editor.history.undos.length - 1);
-      if (!step) {
-        editor.history.undos.push({
-          operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
-          timestamp: /* @__PURE__ */ new Date()
-        }), apply2(op), previousUndoStepId = currentUndoStepId;
-        return;
-      }
-      const selectingWithoutUndoStepId = op.type === "set_selection" && currentUndoStepId === void 0 && previousUndoStepId !== void 0, selectingWithDifferentUndoStepId = op.type === "set_selection" && currentUndoStepId !== void 0 && previousUndoStepId !== void 0 && previousUndoStepId !== currentUndoStepId, lastOp = step.operations.at(-1);
-      for ((editor.operations.length > 0 ? currentUndoStepId === previousUndoStepId || isNormalizingNode(editor) : selectingWithoutUndoStepId || selectingWithDifferentUndoStepId || currentUndoStepId === void 0 && previousUndoStepId === void 0 ? shouldMerge(op, lastOp) || lastOp?.type === "set_selection" && op.type === "set_selection" : currentUndoStepId === previousUndoStepId || isNormalizingNode(editor)) ? step.operations.push(op) : editor.history.undos.push({
-        operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
-        timestamp: /* @__PURE__ */ new Date()
-      }); editor.history.undos.length > UNDO_STEP_LIMIT; )
-        editor.history.undos.shift();
-      previousUndoStepId = currentUndoStepId, apply2(op);
-    }, editor;
-  };
-}
-const historyUndoOperationImplementation = ({
-  operation
-}) => {
-  const editor = operation.editor, {
-    undos
-  } = editor.history, remotePatches = getRemotePatches(editor);
-  if (undos.length > 0) {
-    const step = undos[undos.length - 1];
-    if (debug$b("Undoing", step), step.operations.length > 0) {
-      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
-      let transformedOperations = step.operations;
-      otherPatches.forEach((item) => {
-        transformedOperations = flatten(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
-      });
-      const reversedOperations = transformedOperations.map(Operation.inverse).reverse();
-      try {
-        Editor.withoutNormalizing(editor, () => {
-          withUndoing(editor, () => {
-            withoutSaving(editor, () => {
-              reversedOperations.forEach((op) => {
-                editor.apply(op);
-              });
-            });
-          });
-        });
-      } catch (err) {
-        debug$b("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
-          undos: [],
-          redos: []
-        }, SAVING.set(editor, !0), setIsUndoing(editor, !1), editor.onChange();
-        return;
-      }
-      editor.history.redos.push(step), editor.history.undos.pop();
-    }
-  }
-}, historyRedoOperationImplementation = ({
-  operation
-}) => {
-  const editor = operation.editor, {
-    redos
-  } = editor.history, remotePatches = getRemotePatches(editor);
-  if (redos.length > 0) {
-    const step = redos[redos.length - 1];
-    if (debug$b("Redoing", step), step.operations.length > 0) {
-      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
-      let transformedOperations = step.operations;
-      otherPatches.forEach((item) => {
-        transformedOperations = flatten(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
-      });
-      try {
-        Editor.withoutNormalizing(editor, () => {
-          withRedoing(editor, () => {
-            withoutSaving(editor, () => {
-              transformedOperations.forEach((op) => {
-                editor.apply(op);
-              });
-            });
-          });
-        });
-      } catch (err) {
-        debug$b("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
-          undos: [],
-          redos: []
-        }, SAVING.set(editor, !0), setIsRedoing(editor, !1), editor.onChange();
-        return;
-      }
-      editor.history.undos.push(step), editor.history.redos.pop();
-    }
-  }
-};
+const debug$d = debugWithName("transformOperation");
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
   const transformedOperation = {
     ...operation
@@ -4009,16 +3972,16 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return debug$b(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    return debug$d(`Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 1) {
     const unsetBlockIndex = (previousSnapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
     }, patch.path[0]));
-    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$b("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
+    return "path" in transformedOperation && Array.isArray(transformedOperation.path) && transformedOperation.path[0] === unsetBlockIndex ? (debug$d("Skipping transformation that targeted removed block"), []) : [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)];
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$b(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$d(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
   if (patch.type === "diffMatchPatch") {
     const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
     return !operationTargetBlock || !isEqual({
@@ -4085,27 +4048,80 @@ function adjustBlockPath(operation, level, blockIndex) {
   }
   return transformedOperation;
 }
-const shouldMerge = (op, prev) => !!(op.type === "set_selection" || prev && op.type === "insert_text" && prev.type === "insert_text" && op.offset === prev.offset + prev.text.length && Path.equals(op.path, prev.path) && op.text !== " " || prev && op.type === "remove_text" && prev.type === "remove_text" && op.offset + op.text.length === prev.offset && Path.equals(op.path, prev.path));
-function withoutSaving(editor, fn) {
-  const prev = isSaving(editor);
-  SAVING.set(editor, !1), fn(), SAVING.set(editor, prev);
-}
-function createSelectOperation(editor) {
-  return {
-    type: "set_selection",
-    properties: {
-      ...editor.selection
-    },
-    newProperties: {
-      ...editor.selection
-    }
-  };
-}
 function findOperationTargetBlock(editor, operation) {
   let block;
   return operation.type === "set_selection" && editor.selection ? block = editor.children[editor.selection.focus.path[0]] : "path" in operation && (block = editor.children[operation.path[0]]), block;
 }
-const addAnnotationOperationImplementation = ({
+const debug$c = debugWithName("behavior.operation.history.redo"), historyRedoOperationImplementation = ({
+  operation
+}) => {
+  const editor = operation.editor, {
+    redos
+  } = editor.history, remotePatches = getRemotePatches(editor);
+  if (redos.length > 0) {
+    const step = redos[redos.length - 1];
+    if (debug$c("Redoing", step), step.operations.length > 0) {
+      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+      let transformedOperations = step.operations;
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
+      });
+      try {
+        Editor.withoutNormalizing(editor, () => {
+          pluginRedoing(editor, () => {
+            pluginWithoutHistory(editor, () => {
+              transformedOperations.forEach((op) => {
+                editor.apply(op);
+              });
+            });
+          });
+        });
+      } catch (err) {
+        debug$c("Could not perform redo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+          undos: [],
+          redos: []
+        }, setWithHistory(editor, !0), setIsRedoing(editor, !1), editor.onChange();
+        return;
+      }
+      editor.history.undos.push(step), editor.history.redos.pop();
+    }
+  }
+}, debug$b = debugWithName("behavior.operation.history.undo"), historyUndoOperationImplementation = ({
+  operation
+}) => {
+  const editor = operation.editor, {
+    undos
+  } = editor.history, remotePatches = getRemotePatches(editor);
+  if (undos.length > 0) {
+    const step = undos[undos.length - 1];
+    if (debug$b("Undoing", step), step.operations.length > 0) {
+      const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+      let transformedOperations = step.operations;
+      otherPatches.forEach((item) => {
+        transformedOperations = flatten(transformedOperations.map((op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)));
+      });
+      const reversedOperations = transformedOperations.map(Operation.inverse).reverse();
+      try {
+        Editor.withoutNormalizing(editor, () => {
+          pluginUndoing(editor, () => {
+            pluginWithoutHistory(editor, () => {
+              reversedOperations.forEach((op) => {
+                editor.apply(op);
+              });
+            });
+          });
+        });
+      } catch (err) {
+        debug$b("Could not perform undo step", err), remotePatches.splice(0, remotePatches.length), Transforms.deselect(editor), editor.history = {
+          undos: [],
+          redos: []
+        }, setWithHistory(editor, !0), setIsUndoing(editor, !1), editor.onChange();
+        return;
+      }
+      editor.history.redos.push(step), editor.history.undos.pop();
+    }
+  }
+}, addAnnotationOperationImplementation = ({
   context,
   operation
 }) => {
@@ -5182,8 +5198,6 @@ function isPerformingBehaviorOperation(editor) {
 }
 function createWithEventListeners(editorActor) {
   return function(editor) {
-    if (editorActor.getSnapshot().context.maxBlocks !== void 0)
-      return editor;
     const {
       delete: editorDelete,
       select
@@ -5380,31 +5394,6 @@ function createWithEventListeners(editorActor) {
     }, editor;
   };
 }
-function createWithMaxBlocks(editorActor) {
-  return function(editor) {
-    const {
-      apply: apply2
-    } = editor;
-    return editor.apply = (operation) => {
-      if (editorActor.getSnapshot().matches({
-        "edit mode": "read only"
-      })) {
-        apply2(operation);
-        return;
-      }
-      if (isChangingRemotely(editor)) {
-        apply2(operation);
-        return;
-      }
-      if (isUndoing(editor) || isRedoing(editor)) {
-        apply2(operation);
-        return;
-      }
-      const rows = editorActor.getSnapshot().context.maxBlocks ?? -1;
-      rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
-    }, editor;
-  };
-}
 function createWithObjectKeys(editorActor) {
   return function(editor) {
     const {
@@ -6249,7 +6238,7 @@ function createWithPatches({
       withRemoteChanges(editor, () => {
         Editor.withoutNormalizing(editor, () => {
           withoutPatching(editor, () => {
-            withoutSaving(editor, () => {
+            pluginWithoutHistory(editor, () => {
               for (const patch of patches) {
                 debug$a.enabled && debug$a(`Handling remote patch ${JSON.stringify(patch)}`);
                 try {
@@ -6765,16 +6754,16 @@ const withPlugins = (editor, options) => {
     editorActor,
     relayActor,
     subscriptions: options.subscriptions
-  }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
+  }), withUndoRedo = pluginHistory({
     editorActor,
     subscriptions: options.subscriptions
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
     editorActor
   });
-  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(pluginUpdateValue(editorActor.getSnapshot().context, pluginUpdateSelection({
+  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPlaceholderBlock(withUtils(withUndoRedo(withPatches(pluginUpdateValue(editorActor.getSnapshot().context, pluginUpdateSelection({
     editorActor,
     editor: e
-  })))))))))));
+  }))))))))));
 }, debug$7 = debugWithName("setup");
 function createSlateEditor(config) {
   debug$7("Creating new Slate editor instance");
@@ -9868,7 +9857,7 @@ function performEvent({
   nativeEvent,
   sendBack
 }) {
-  mode === "send" && !isNativeBehaviorEvent(event) && createUndoStep(editor), debug$6(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
+  mode === "send" && !isNativeBehaviorEvent(event) && createUndoStepId(editor), debug$6(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2));
   const eventBehaviors = [...remainingEventBehaviors, ...abstractBehaviors].filter((behavior) => {
     if (behavior.on === "*")
       return !0;
@@ -9876,7 +9865,7 @@ function performEvent({
     return listenedNamespace !== void 0 && eventNamespace !== void 0 && listenedNamespace === eventNamespace || listenedNamespace !== void 0 && eventNamespace === void 0 && listenedNamespace === event.type ? !0 : behavior.on === event.type;
   });
   if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
-    nativeEvent?.preventDefault(), mode === "send" && clearUndoStep(editor), withPerformingBehaviorOperation(editor, () => {
+    nativeEvent?.preventDefault(), mode === "send" && clearUndoStepId(editor), withPerformingBehaviorOperation(editor, () => {
       debug$6(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
         context: {
           keyGenerator,
@@ -9925,7 +9914,7 @@ function performEvent({
         continue;
       nativeEventPrevented = actions.some((action) => action.type === "raise" || action.type === "execute") || !actions.some((action) => action.type === "forward");
       let undoStepCreated = !1;
-      actionSetIndex > 0 && (createUndoStep(editor), undoStepCreated = !0), !undoStepCreated && actions.some((action) => action.type === "execute") && (createUndoStep(editor), undoStepCreated = !0);
+      actionSetIndex > 0 && (createUndoStepId(editor), undoStepCreated = !0), !undoStepCreated && actions.some((action) => action.type === "execute") && (createUndoStepId(editor), undoStepCreated = !0);
       const actionTypes = actions.map((action) => action.type), uniqueActionTypes = new Set(actionTypes), raiseGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("raise"), executeGroup = actionTypes.length > 1 && uniqueActionTypes.size === 1 && uniqueActionTypes.has("execute");
       withoutNormalizingConditional(editor, () => raiseGroup || executeGroup, () => {
         for (const action of actions) {
@@ -9983,11 +9972,11 @@ function performEvent({
             sendBack
           });
         }
-      }), undoStepCreated && clearUndoStep(editor);
+      }), undoStepCreated && clearUndoStepId(editor);
     }
     break;
   }
-  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), mode === "send" && clearUndoStep(editor), withPerformingBehaviorOperation(editor, () => {
+  !defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event) ? (nativeEvent?.preventDefault(), mode === "send" && clearUndoStepId(editor), withPerformingBehaviorOperation(editor, () => {
     debug$6(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2)), performOperation({
       context: {
         keyGenerator,
@@ -10275,7 +10264,6 @@ const editorMachine = setup({
     schema: input.schema,
     selection: null,
     initialReadOnly: input.readOnly ?? !1,
-    maxBlocks: input.maxBlocks,
     initialValue: input.initialValue
   }),
   on: {
@@ -10285,13 +10273,6 @@ const editorMachine = setup({
     "remove behavior": {
       actions: "remove behavior from context"
     },
-    "update maxBlocks": {
-      actions: assign({
-        maxBlocks: ({
-          event
-        }) => event.maxBlocks
-      })
-    },
     "add slate editor": {
       actions: "add slate editor to context"
     },
@@ -11955,7 +11936,7 @@ function clearEditor({
   hadSelection
 }) {
   Editor.withoutNormalizing(slateEditor, () => {
-    withoutSaving(slateEditor, () => {
+    pluginWithoutHistory(slateEditor, () => {
       withRemoteChanges(slateEditor, () => {
         withoutPatching(slateEditor, () => {
           if (doneSyncing)
@@ -12205,7 +12186,6 @@ function createInternalEditor(config) {
           break;
         case "update readOnly":
         case "patches":
-        case "update maxBlocks":
           editorActor.send(event);
           break;
         default:
@@ -12259,7 +12239,6 @@ function editorConfigToMachineInput(config) {
     converters: createCoreConverters(legacySchema),
     getLegacySchema: () => legacySchema,
     keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
-    maxBlocks: config.maxBlocks,
     readOnly: config.readOnly,
     schema,
     initialValue: config.initialValue
@@ -12302,7 +12281,6 @@ function createActors(config) {
       }), config.editorActor.send({
         type: "mutation",
         patches: event.patches,
-        snapshot: event.snapshot,
         value: event.snapshot
       })), event.type === "patch" && config.relayActor.send(event);
     });
@@ -12415,7 +12393,11 @@ function eventToChange(event) {
         value: event.value
       };
     case "mutation":
-      return event;
+      return {
+        type: "mutation",
+        patches: event.patches,
+        snapshot: event.value
+      };
     case "ready":
       return event;
     case "selection":
@@ -12453,7 +12435,6 @@ class PortableTextEditor extends Component {
       } = createInternalEditor({
         initialValue: props.value,
         keyGenerator: props.keyGenerator,
-        maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
         readOnly: props.readOnly,
         schema: props.schemaType
       });
@@ -12476,9 +12457,6 @@ class PortableTextEditor extends Component {
     !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && console.warn("Updating schema type is no longer supported"), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({
       type: "update readOnly",
       readOnly: this.props.readOnly ?? !1
-    }), this.props.maxBlocks !== prevProps.maxBlocks && this.editor._internal.editorActor.send({
-      type: "update maxBlocks",
-      maxBlocks: this.props.maxBlocks === void 0 ? void 0 : Number.parseInt(this.props.maxBlocks.toString(), 10)
     }), this.props.value !== prevProps.value && this.editor.send({
       type: "update value",
       value: this.props.value
@@ -12927,7 +12905,6 @@ const usePortableTextEditorSelection = () => {
   }, t1 = [editorActor], $[0] = editorActor, $[1] = t0, $[2] = t1) : (t0 = $[1], t1 = $[2]), useEffect(t0, t1), selection;
 };
 export {
-  EditorEventListener,
   EditorProvider,
   PortableTextEditable,
   PortableTextEditor,