@portabletext/editor 1.50.3 → 1.50.5

package/lib/index.js

@@ -9,9 +9,9 @@ import { Element as Element$1, Text, Range, Editor, Node, Point, Transforms, Pat
 import { useSlateStatic, useSelected, withReact, ReactEditor, Slate, useSlate, Editable } from "slate-react";
 import debug$i from "debug";
 import { getBlockEndPoint, isEmptyTextBlock, isEqualSelectionPoints } from "./_chunks-es/util.is-equal-selection-points.js";
-import { getBlockStartPoint, isKeyedSegment as isKeyedSegment$1, parseInlineObject, parseTextBlock, parseBlockObject, parseBlock, sliceBlocks, isTextBlock, parseAnnotation, blockOffsetToSpanSelectionPoint, isSpan$1 as isSpan, isListBlock, getTextBlockText, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
-import { isSelectionCollapsed, getFocusTextBlock, getFocusSpan, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock as getSelectionStartBlock$1, getSelectionEndBlock as getSelectionEndBlock$1, getFocusBlock as getFocusBlock$1, getFocusBlockObject, getPreviousBlock, getNextBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock } from "./_chunks-es/selector.is-selection-expanded.js";
-import { getFocusInlineObject, isOverlappingSelection, isSelectingEntireBlocks, getTrimmedSelection, getCaretWordSelection, isAtTheEndOfBlock, isAtTheStartOfBlock, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, getActiveAnnotations } from "./_chunks-es/selector.is-selecting-entire-blocks.js";
+import { getBlockStartPoint, isKeyedSegment as isKeyedSegment$1, parseInlineObject, parseTextBlock, parseBlockObject, parseBlock, sliceBlocks, isTextBlock, parseAnnotation, blockOffsetToSpanSelectionPoint, isSpan$1 as isSpan, isListBlock, isTypedObject, getTextBlockText, parseBlocks } from "./_chunks-es/util.slice-blocks.js";
+import { isSelectionCollapsed, getFocusTextBlock, getFocusSpan as getFocusSpan$1, getSelectedBlocks, isSelectionExpanded, getSelectionStartBlock as getSelectionStartBlock$1, getSelectionEndBlock as getSelectionEndBlock$1, getFocusBlock as getFocusBlock$1, getFocusBlockObject, getPreviousBlock, getNextBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getFocusListBlock } from "./_chunks-es/selector.is-selection-expanded.js";
+import { getFocusInlineObject, isOverlappingSelection, isSelectingEntireBlocks, getTrimmedSelection, getCaretWordSelection, isAtTheEndOfBlock, isAtTheStartOfBlock, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, getActiveAnnotations as getActiveAnnotations$1 } from "./_chunks-es/selector.is-selecting-entire-blocks.js";
 import { DOMEditor, isDOMNode } from "slate-dom";
 import { isSelectionCollapsed as isSelectionCollapsed$1, selectionPointToBlockOffset, getSelectionStartPoint, getSelectionEndPoint } from "./_chunks-es/util.selection-point-to-block-offset.js";
 import isEqual from "lodash/isEqual.js";
@@ -31,6 +31,7 @@ import { applyAll, unset, insert, set, setIfMissing, diffMatchPatch as diffMatch
 import get from "lodash/get.js";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
+import { createDraft, finishDraft } from "immer";
 import startCase from "lodash.startcase";
 import isPlainObject from "lodash/isPlainObject.js";
 function EditorEventListener(props) {
@@ -86,7 +87,7 @@ function getDragSelection({
       ...snapshot.context,
       selection: eventSelection
     }
-  }), draggedSpan = getFocusSpan({
+  }), draggedSpan = getFocusSpan$1({
     context: {
       ...snapshot.context,
       selection: eventSelection
@@ -248,6 +249,34 @@ function getFocusBlock({
     return [void 0, void 0];
   }
 }
+function getFocusSpan({
+  editor
+}) {
+  if (!editor.selection)
+    return [void 0, void 0];
+  try {
+    const [node, path] = Editor.node(editor, editor.selection.focus.path);
+    if (editor.isTextSpan(node))
+      return [node, path];
+  } catch {
+    return [void 0, void 0];
+  }
+  return [void 0, void 0];
+}
+function getSelectedSpans({
+  editor
+}) {
+  if (!editor.selection)
+    return [];
+  try {
+    return Array.from(Editor.nodes(editor, {
+      at: editor.selection,
+      match: (node) => editor.isTextSpan(node)
+    }));
+  } catch {
+    return [];
+  }
+}
 function getSelectionStartBlock({
   editor
 }) {
@@ -1376,13 +1405,68 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
+function createPlaceholderBlock(context) {
+  return {
+    _type: context.schema.block.name,
+    _key: context.keyGenerator(),
+    style: context.schema.styles[0].name ?? "normal",
+    markDefs: [],
+    children: [{
+      _type: context.schema.span.name,
+      _key: context.keyGenerator(),
+      text: "",
+      marks: []
+    }]
+  };
+}
+function getActiveAnnotations({
+  markState,
+  schema
+}) {
+  return (markState?.marks ?? []).filter((mark) => !schema.decorators.map((decorator) => decorator.name).includes(mark));
+}
+function getActiveDecorators({
+  decoratorState,
+  markState,
+  schema
+}) {
+  const decorators = schema.decorators.map((decorator) => decorator.name);
+  let activeDecorators = (markState?.marks ?? []).filter((mark) => decorators.includes(mark));
+  for (const decorator in decoratorState)
+    decoratorState[decorator] === !1 ? activeDecorators = activeDecorators.filter((activeDecorator) => activeDecorator !== decorator) : decoratorState[decorator] === !0 && (activeDecorators.includes(decorator) || activeDecorators.push(decorator));
+  return activeDecorators;
+}
 const insertTextOperationImplementation = ({
+  context,
   operation
 }) => {
-  operation.editor.marks ? Transforms.insertNodes(operation.editor, {
+  const activeDecorators = getActiveDecorators({
+    decoratorState: operation.editor.decoratorState,
+    markState: operation.editor.markState,
+    schema: context.schema
+  }), activeAnnotations = getActiveAnnotations({
+    markState: operation.editor.markState,
+    schema: context.schema
+  }), [focusSpan] = getFocusSpan({
+    editor: operation.editor
+  });
+  if (!focusSpan) {
+    Transforms.insertText(operation.editor, operation.text);
+    return;
+  }
+  if (operation.editor.markState && operation.editor.markState.state === "unchanged") {
+    const markStateDecorators = (operation.editor.markState.marks ?? []).filter((mark) => context.schema.decorators.map((decorator) => decorator.name).includes(mark));
+    if (markStateDecorators.length === activeDecorators.length && markStateDecorators.every((mark) => activeDecorators.includes(mark))) {
+      Transforms.insertText(operation.editor, operation.text);
+      return;
+    }
+  }
+  Transforms.insertNodes(operation.editor, {
+    _type: focusSpan._type,
+    _key: context.keyGenerator(),
     text: operation.text,
-    ...operation.editor.marks
-  }) : Transforms.insertText(operation.editor, operation.text), operation.editor.marks = null;
+    marks: [...activeDecorators, ...activeAnnotations]
+  }), operation.editor.decoratorState = {};
 };
 function isPortableTextSpan(node) {
   return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
@@ -1455,6 +1539,50 @@ function isRedoing(editor) {
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
+function defaultCompare(a, b) {
+  return a === b;
+}
+function useEditorSelector(editor, selector, t0) {
+  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
+  let t1;
+  return $[0] !== editor || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
+    const snapshot = getEditorSnapshot({
+      editorActorSnapshot,
+      slateEditorInstance: editor._internal.slateEditor.instance
+    });
+    return selector(snapshot);
+  }, $[0] = editor, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
+}
+function getEditorSnapshot({
+  editorActorSnapshot,
+  slateEditorInstance
+}) {
+  return {
+    context: {
+      converters: [...editorActorSnapshot.context.converters],
+      keyGenerator: editorActorSnapshot.context.keyGenerator,
+      readOnly: editorActorSnapshot.matches({
+        "edit mode": "read only"
+      }),
+      schema: editorActorSnapshot.context.schema,
+      selection: editorActorSnapshot.context.selection,
+      value: slateEditorInstance.value
+    },
+    beta: {
+      activeAnnotations: getActiveAnnotations({
+        markState: slateEditorInstance.markState,
+        schema: editorActorSnapshot.context.schema
+      }),
+      activeDecorators: getActiveDecorators({
+        decoratorState: slateEditorInstance.decoratorState,
+        markState: slateEditorInstance.markState,
+        schema: editorActorSnapshot.context.schema
+      }),
+      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
+      internalDrag: editorActorSnapshot.context.internalDrag
+    }
+  };
+}
 const debug$h = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
@@ -1599,7 +1727,7 @@ function createWithPortableTextMarkModel(editorActor) {
         apply2(op);
         return;
       }
-      if (op.type === "set_selection" && Editor.marks(editor) && op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
+      if (op.type === "set_selection" && op.properties && op.newProperties && op.properties.anchor && op.properties.focus && op.newProperties.anchor && op.newProperties.focus) {
         const previousSelectionIsCollapsed = Range.isCollapsed({
           anchor: op.properties.anchor,
           focus: op.properties.focus
@@ -1619,8 +1747,7 @@ function createWithPortableTextMarkModel(editorActor) {
             match: (n) => editor.isTextSpan(n),
             voids: !1
           }))[0]?.[0], 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;
-          if (movedToNextSpan || movedToPreviousSpan)
-            return;
+          !movedToNextSpan && !movedToPreviousSpan && (editor.decoratorState = {});
         }
       }
       if (op.type === "insert_node") {
@@ -1668,88 +1795,21 @@ function createWithPortableTextMarkModel(editorActor) {
         }
       }
       if (op.type === "insert_text") {
-        const {
-          selection
-        } = editor, collapsedSelection = selection ? Range.isCollapsed(selection) : !1;
-        if (selection && collapsedSelection) {
-          const [_block, blockPath] = Editor.node(editor, selection, {
-            depth: 1
-          }), [span, spanPath] = Array.from(Editor.nodes(editor, {
-            mode: "lowest",
-            at: selection.focus,
-            match: (n) => editor.isTextSpan(n),
-            voids: !1
-          }))[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
-            editor,
-            blockPath,
-            spanPath
-          }), nextSpan = getNextSpan({
-            editor,
-            blockPath,
-            spanPath
-          }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
-          if (spanHasAnnotations && !spanIsEmpty) {
-            if (atTheBeginningOfSpan) {
-              if (previousSpanHasSameMarks) {
-                Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: previousSpan?.marks ?? []
-                });
-                return;
-              } else if (previousSpanHasSameAnnotations) {
-                Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: previousSpan?.marks ?? []
-                });
-                return;
-              } else if (previousSpanHasSameAnnotation) {
-                apply2(op);
-                return;
-              } else if (!previousSpan) {
-                Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: []
-                });
-                return;
-              }
-            }
-            if (atTheEndOfSpan) {
-              if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations) {
-                Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: nextSpan?.marks ?? []
-                });
-                return;
-              }
-              if (!nextSpan) {
-                Transforms.insertNodes(editor, {
-                  _type: "span",
-                  _key: editorActor.getSnapshot().context.keyGenerator(),
-                  text: op.text,
-                  marks: []
-                });
-                return;
-              }
-            }
-          }
-          if (atTheBeginningOfSpan && !spanIsEmpty && previousSpan) {
-            Transforms.insertNodes(editor, {
-              _type: "span",
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              text: op.text,
-              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter((mark) => decorators.includes(mark))
-            });
-            return;
-          }
+        if (!editor.markState) {
+          apply2(op);
+          return;
+        }
+        if (editor.markState.state === "unchanged") {
+          apply2(op);
+          return;
         }
+        Transforms.insertNodes(editor, {
+          _type: "span",
+          _key: editorActor.getSnapshot().context.keyGenerator(),
+          text: op.text,
+          marks: editor.markState.marks
+        });
+        return;
       }
       if (op.type === "remove_text") {
         const {
@@ -1778,12 +1838,13 @@ function createWithPortableTextMarkModel(editorActor) {
               spanPath
             }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
             if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
-              const marksWithoutAnnotationMarks = ({
-                ...Editor.marks(editor) || {}
-              }.marks || []).filter((mark) => decorators.includes(mark));
+              const snapshot = getEditorSnapshot({
+                editorActorSnapshot: editorActor.getSnapshot(),
+                slateEditorInstance: editor
+              });
               Editor.withoutNormalizing(editor, () => {
                 apply2(op), Transforms.setNodes(editor, {
-                  marks: marksWithoutAnnotationMarks
+                  marks: snapshot.beta.activeDecorators
                 }, {
                   at: op.path
                 });
@@ -1846,18 +1907,8 @@ const removeDecoratorOperationImplementation = ({
           at: blockPath,
           match: (node) => editor.isTextSpan(node)
         });
-      } else {
-        const existingMarks = {
-          ...Editor.marks(editor) || {}
-        }.marks || [], marks = {
-          ...Editor.marks(editor) || {},
-          marks: existingMarks.filter((eMark) => eMark !== mark)
-        };
-        editor.marks = {
-          marks: marks.marks,
-          _type: "span"
-        };
-      }
+      } else
+        editor.decoratorState[mark] = !1;
     }
     if (editor.selection) {
       const selection2 = editor.selection;
@@ -1867,23 +1918,6 @@ const removeDecoratorOperationImplementation = ({
     }
   }
 };
-function isDecoratorActive({
-  editor,
-  decorator
-}) {
-  if (!editor.selection)
-    return !1;
-  const selectedTextNodes = Array.from(Editor.nodes(editor, {
-    match: Text.isText,
-    at: editor.selection
-  }));
-  return selectedTextNodes.length === 0 ? !1 : Range.isExpanded(editor.selection) ? selectedTextNodes.every((n) => {
-    const [node] = n;
-    return node.marks?.includes(decorator);
-  }) : ({
-    ...Editor.marks(editor) || {}
-  }.marks || []).includes(decorator);
-}
 function cloneDiff(diff2) {
   const [type, patch] = diff2;
   return [type, patch];
@@ -3103,7 +3137,6 @@ const addAnnotationOperationImplementation = ({
       backward: editorSelection?.backward
     }), trimmedSelection = getTrimmedSelection({
       context: {
-        activeDecorators: [],
         converters: [],
         keyGenerator: context.keyGenerator,
         readOnly: !1,
@@ -3149,15 +3182,8 @@ const addAnnotationOperationImplementation = ({
         at: blockPath,
         match: (node) => editor.isTextSpan(node)
       });
-    } else {
-      const existingMarks = {
-        ...Editor.marks(editor) || {}
-      }.marks || [], marks = {
-        ...Editor.marks(editor) || {},
-        marks: [...existingMarks, mark]
-      };
-      editor.marks = marks;
-    }
+    } else
+      editor.decoratorState[mark] = !0;
   }
   if (editor.selection) {
     const selection2 = editor.selection;
@@ -3690,7 +3716,6 @@ function createWithEventListeners(editorActor) {
     if (editorActor.getSnapshot().context.maxBlocks !== void 0)
       return editor;
     const {
-      insertText,
       select
     } = editor;
     return editor.deleteBackward = (unit) => {
@@ -3768,9 +3793,18 @@ function createWithEventListeners(editorActor) {
         },
         editor
       });
-    }, editor.insertText = (text, options) => {
+    }, editor.insertText = (text) => {
       if (isApplyingBehaviorOperations(editor)) {
-        insertText(text, options);
+        insertTextOperationImplementation({
+          context: {
+            keyGenerator: editorActor.getSnapshot().context.keyGenerator,
+            schema: editorActor.getSnapshot().context.schema
+          },
+          operation: {
+            text,
+            editor
+          }
+        });
         return;
       }
       editorActor.send({
@@ -4744,6 +4778,378 @@ function createWithUtils({
     })[0], editor;
   };
 }
+function getMarkState({
+  schema,
+  editor
+}) {
+  if (!editor.selection)
+    return;
+  const [block, blockPath] = getFocusBlock({
+    editor
+  }), [span, spanPath] = getFocusSpan({
+    editor
+  });
+  if (!block || !editor.isTextBlock(block) || !span)
+    return;
+  if (Range.isExpanded(editor.selection)) {
+    const selectedSpans = getSelectedSpans({
+      editor
+    });
+    let index = 0, marks2 = [];
+    for (const [span2] of selectedSpans)
+      index === 0 ? marks2 = span2.marks ?? [] : (span2.marks?.length === 0 || (span2.marks ?? [])?.some((mark) => !marks2.includes(mark))) && (marks2 = []), index++;
+    return {
+      state: "unchanged",
+      marks: marks2
+    };
+  }
+  const decorators = schema.decorators.map((decorator) => decorator.name), marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = editor.selection.anchor.offset === 0, atTheEndOfSpan = editor.selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
+    editor,
+    blockPath,
+    spanPath
+  }), nextSpan = getNextSpan({
+    editor,
+    blockPath,
+    spanPath
+  }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
+  if (spanHasAnnotations && !spanIsEmpty) {
+    if (atTheBeginningOfSpan) {
+      if (previousSpanHasSameMarks)
+        return {
+          state: "changed",
+          marks: previousSpan?.marks ?? []
+        };
+      if (previousSpanHasSameAnnotations)
+        return {
+          state: "changed",
+          marks: previousSpan?.marks ?? []
+        };
+      if (previousSpanHasSameAnnotation)
+        return {
+          state: "unchanged",
+          marks: span.marks ?? []
+        };
+      if (!previousSpan)
+        return {
+          state: "changed",
+          marks: []
+        };
+    }
+    if (atTheEndOfSpan) {
+      if (nextSpan && nextSpanSharesSomeAnnotations && nextSpanAnnotations.length < spanAnnotations.length || !nextSpanSharesSomeAnnotations)
+        return {
+          state: "changed",
+          marks: nextSpan?.marks ?? []
+        };
+      if (!nextSpan)
+        return {
+          state: "changed",
+          marks: []
+        };
+    }
+  }
+  return atTheBeginningOfSpan && !spanIsEmpty && previousSpan ? previousSpanHasAnnotations ? {
+    state: "changed",
+    marks: []
+  } : {
+    state: "changed",
+    marks: (previousSpan?.marks ?? []).filter((mark) => decorators.includes(mark))
+  } : {
+    state: "unchanged",
+    marks: span.marks ?? []
+  };
+}
+function pluginUpdateMarkState(context, editor) {
+  const {
+    apply: apply2
+  } = editor;
+  return editor.apply = (operation) => {
+    apply2(operation), editor.markState = getMarkState({
+      editor,
+      schema: context.schema
+    });
+  }, editor;
+}
+function isEditorNode(node) {
+  return typeof node == "object" && node !== null ? !("_type" in node) && "children" in node && Array.isArray(node.children) : !1;
+}
+function isTextBlockNode(context, node) {
+  return isTypedObject(node) && node._type === context.schema.block.name;
+}
+function isSpanNode(context, node) {
+  return typeof node != "object" || node === null || "children" in node ? !1 : "_type" in node ? node._type === context.schema.span.name : "text" in node;
+}
+function isPartialSpanNode(node) {
+  return typeof node == "object" && node !== null && "text" in node && typeof node.text == "string";
+}
+function isObjectNode(context, node) {
+  return !isEditorNode(node) && !isTextBlockNode(context, node) && !isSpanNode(context, node) && !isPartialSpanNode(node);
+}
+function getBlock(root, path) {
+  const index = path.at(0);
+  if (!(index === void 0 || path.length !== 1))
+    return root.children.at(index);
+}
+function getNode(context, root, path) {
+  if (path.length === 0)
+    return root;
+  if (path.length === 1)
+    return getBlock(root, path);
+  if (path.length === 2) {
+    const block = getBlock(root, path.slice(0, 1));
+    return !block || !isTextBlockNode(context, block) ? void 0 : block.children.at(path[1]) || void 0;
+  }
+}
+function getSpan(context, root, path) {
+  const node = getNode(context, root, path);
+  if (node && isSpanNode(context, node))
+    return node;
+}
+function getParent(context, root, path) {
+  if (path.length === 0)
+    return;
+  const parentPath = path.slice(0, -1);
+  if (parentPath.length === 0)
+    return root;
+  const blockIndex = parentPath.at(0);
+  if (blockIndex === void 0 || parentPath.length !== 1)
+    return;
+  const block = root.children.at(blockIndex);
+  if (block && isTextBlockNode(context, block))
+    return block;
+}
+function applyOperationToPortableText(context, value, operation) {
+  const draft = createDraft({
+    children: value
+  });
+  try {
+    applyOperationToPortableTextDraft(context, draft, operation);
+  } catch (e) {
+    console.error(e);
+  }
+  return finishDraft(draft).children;
+}
+function applyOperationToPortableTextDraft(context, root, operation) {
+  switch (operation.type) {
+    case "insert_node": {
+      const {
+        path,
+        node: insertedNode
+      } = operation, parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!parent || index > parent.children.length)
+        break;
+      if (path.length === 1) {
+        if (isTextBlockNode(context, insertedNode)) {
+          parent.children.splice(index, 0, {
+            ...insertedNode,
+            children: insertedNode.children.map((child) => "__inline" in child ? {
+              _key: child._key,
+              _type: child._type,
+              ..."value" in child && typeof child.value == "object" ? child.value : {}
+            } : child)
+          });
+          break;
+        }
+        if (Element$1.isElement(insertedNode) && !("__inline" in insertedNode)) {
+          parent.children.splice(index, 0, {
+            _key: insertedNode._key,
+            _type: insertedNode._type,
+            ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
+          });
+          break;
+        }
+      }
+      if (path.length === 2) {
+        if (!isTextBlockNode(context, parent))
+          break;
+        if (isPartialSpanNode(insertedNode)) {
+          parent.children.splice(index, 0, insertedNode);
+          break;
+        }
+        if ("__inline" in insertedNode) {
+          parent.children.splice(index, 0, {
+            _key: insertedNode._key,
+            _type: insertedNode._type,
+            ..."value" in insertedNode && typeof insertedNode.value == "object" ? insertedNode.value : {}
+          });
+          break;
+        }
+      }
+      break;
+    }
+    case "insert_text": {
+      const {
+        path,
+        offset,
+        text
+      } = operation;
+      if (text.length === 0) break;
+      const span = getSpan(context, root, path);
+      if (!span)
+        break;
+      const before = span.text.slice(0, offset), after = span.text.slice(offset);
+      span.text = before + text + after;
+      break;
+    }
+    case "merge_node": {
+      const {
+        path
+      } = operation, node = getNode(context, root, path), prevPath = Path.previous(path), prev = getNode(context, root, prevPath), parent = getParent(context, root, path);
+      if (!node || !prev || !parent)
+        break;
+      const index = path[path.length - 1];
+      if (isPartialSpanNode(node) && isPartialSpanNode(prev))
+        prev.text += node.text;
+      else if (isTextBlockNode(context, node) && isTextBlockNode(context, prev))
+        prev.children.push(...node.children);
+      else
+        break;
+      parent.children.splice(index, 1);
+      break;
+    }
+    case "move_node": {
+      const {
+        path,
+        newPath
+      } = operation;
+      if (Path.isAncestor(path, newPath))
+        break;
+      const node = getNode(context, root, path), parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!node || !parent)
+        break;
+      parent.children.splice(index, 1);
+      const truePath = Path.transform(path, operation), newParent = getNode(context, root, Path.parent(truePath)), newIndex = truePath[truePath.length - 1];
+      if (!newParent || !("children" in newParent) || !Array.isArray(newParent.children))
+        break;
+      newParent.children.splice(newIndex, 0, node);
+      break;
+    }
+    case "remove_node": {
+      const {
+        path
+      } = operation, index = path[path.length - 1];
+      getParent(context, root, path)?.children.splice(index, 1);
+      break;
+    }
+    case "remove_text": {
+      const {
+        path,
+        offset,
+        text
+      } = operation;
+      if (text.length === 0)
+        break;
+      const span = getSpan(context, root, path);
+      if (!span)
+        break;
+      const before = span.text.slice(0, offset), after = span.text.slice(offset + text.length);
+      span.text = before + after;
+      break;
+    }
+    case "set_node": {
+      const {
+        path,
+        properties,
+        newProperties
+      } = operation, node = getNode(context, root, path);
+      if (!node || isEditorNode(node))
+        break;
+      if (isObjectNode(context, node)) {
+        const valueBefore = "value" in properties && typeof properties.value == "object" ? properties.value : {}, valueAfter = "value" in newProperties && typeof newProperties.value == "object" ? newProperties.value : {};
+        for (const key in newProperties) {
+          if (key === "value")
+            continue;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          key !== "value" && (newProperties.hasOwnProperty(key) || delete node[key]);
+        for (const key in valueAfter) {
+          const value = valueAfter[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in valueBefore)
+          valueAfter.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      if (isTextBlockNode(context, node)) {
+        for (const key in newProperties) {
+          if (key === "children" || key === "text")
+            break;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          newProperties.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      if (isPartialSpanNode(node)) {
+        for (const key in newProperties) {
+          if (key === "text")
+            break;
+          const value = newProperties[key];
+          value == null ? delete node[key] : node[key] = value;
+        }
+        for (const key in properties)
+          newProperties.hasOwnProperty(key) || delete node[key];
+        break;
+      }
+      break;
+    }
+    case "split_node": {
+      const {
+        path,
+        position,
+        properties
+      } = operation;
+      if (path.length === 0)
+        break;
+      const parent = getParent(context, root, path), index = path[path.length - 1];
+      if (!parent)
+        break;
+      if (isEditorNode(parent)) {
+        const block = getBlock(root, path);
+        if (!block || !isTextBlockNode(context, block))
+          break;
+        const before = block.children.slice(0, position), after = block.children.slice(position);
+        block.children = before;
+        const newTextBlockNode = {
+          ...properties,
+          children: after,
+          _type: context.schema.block.name
+        };
+        parent.children.splice(index + 1, 0, newTextBlockNode);
+        break;
+      }
+      if (isTextBlockNode(context, parent)) {
+        const node = getNode(context, root, path);
+        if (!node || !isSpanNode(context, node))
+          break;
+        const before = node.text.slice(0, position), after = node.text.slice(position);
+        node.text = before;
+        const newSpanNode = {
+          ...properties,
+          text: after
+        };
+        parent.children.splice(index + 1, 0, newSpanNode);
+      }
+      break;
+    }
+  }
+  return root;
+}
+function pluginUpdateValue(context, editor) {
+  const {
+    apply: apply2
+  } = editor;
+  return editor.apply = (operation) => {
+    if (operation.type === "set_selection") {
+      apply2(operation);
+      return;
+    }
+    editor.value = applyOperationToPortableText(context, editor.value, operation), apply2(operation);
+  }, editor;
+}
 const withPlugins = (editor, options) => {
   const e = editor, {
     editorActor,
@@ -4760,7 +5166,7 @@ const withPlugins = (editor, options) => {
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
     editorActor
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
-  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
+  return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(pluginUpdateValue(editorActor.getSnapshot().context, pluginUpdateMarkState(editorActor.getSnapshot().context, e)))))))))))));
 }, debug$a = debugWithName("setup");
 function createSlateEditor(config) {
   debug$a("Creating new Slate editor instance");
@@ -4769,10 +5175,10 @@ function createSlateEditor(config) {
     relayActor: config.relayActor,
     subscriptions: config.subscriptions
   });
-  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {});
-  const initialValue = [instance.pteCreateTextBlock({
-    decorators: []
-  })];
+  KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {}), instance.decoratorState = {}, instance.markState = void 0, instance.value = [createPlaceholderBlock(config.editorActor.getSnapshot().context)];
+  const initialValue = toSlateValue(instance.value, {
+    schemaTypes: config.editorActor.getSnapshot().context.schema
+  });
   return {
     instance,
     initialValue
@@ -5225,7 +5631,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
     const focusTextBlock = getFocusTextBlock(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
     if (!snapshot.context.selection || !focusTextBlock || !selectionCollapsed)
       return !1;
-    const focusSpan = getFocusSpan(snapshot), focusDecorators = focusSpan?.node.marks?.filter((mark) => snapshot.context.schema.decorators.some((decorator) => decorator.name === mark) ?? []), focusAnnotations = focusSpan?.node.marks?.filter((mark) => !snapshot.context.schema.decorators.some((decorator) => decorator.name === mark)) ?? [], focusListItem = focusTextBlock.node.listItem, focusLevel = focusTextBlock.node.level;
+    const focusSpan = getFocusSpan$1(snapshot), focusDecorators = focusSpan?.node.marks?.filter((mark) => snapshot.context.schema.decorators.some((decorator) => decorator.name === mark) ?? []), focusAnnotations = focusSpan?.node.marks?.filter((mark) => !snapshot.context.schema.decorators.some((decorator) => decorator.name === mark)) ?? [], focusListItem = focusTextBlock.node.listItem, focusLevel = focusTextBlock.node.level;
     return isAtTheStartOfBlock(focusTextBlock)(snapshot) ? {
       focusAnnotations,
       focusDecorators,
@@ -5334,7 +5740,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
   guard: ({
     snapshot
   }) => {
-    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan(snapshot);
+    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan$1(snapshot);
     return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && snapshot.context.selection?.focus.offset === 0 && focusTextBlock.node.level === 1 ? {
       focusTextBlock
     } : !1;
@@ -5351,7 +5757,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
   guard: ({
     snapshot
   }) => {
-    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan(snapshot);
+    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan$1(snapshot);
     return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && snapshot.context.selection?.focus.offset === 0 && focusTextBlock.node.level !== void 0 && focusTextBlock.node.level > 1 ? {
       focusTextBlock,
       level: focusTextBlock.node.level - 1
@@ -5520,7 +5926,6 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
         converters: [],
         schema: snapshot.context.schema,
         keyGenerator: snapshot.context.keyGenerator,
-        activeDecorators: [],
         readOnly: !1,
         value: snapshot.context.value,
         selection
@@ -6050,7 +6455,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
     guard: ({
       snapshot
     }) => {
-      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+      const focusSpan = getFocusSpan$1(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
       return focusSpan && selectionCollapsed;
     },
     actions: []
@@ -6069,7 +6474,7 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
     guard: ({
       snapshot
     }) => {
-      const focusSpan = getFocusSpan(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+      const focusSpan = getFocusSpan$1(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
       return focusSpan && selectionCollapsed;
     },
     actions: []
@@ -6216,9 +6621,9 @@ const arrowDownOnLonelyBlockObject = defineBehavior({
       event
     }) => {
       if (getFocusTextBlock(snapshot) && event.mimeType === "text/plain" && event.originEvent.type === "clipboard.paste") {
-        const activeDecorators = snapshot.context.activeDecorators;
+        const activeDecorators = snapshot.beta.activeDecorators;
         return {
-          activeAnnotations: getActiveAnnotations(snapshot),
+          activeAnnotations: getActiveAnnotations$1(snapshot),
           activeDecorators,
           textRuns: event.data.flatMap((block) => isTextBlock(snapshot.context, block) ? [getTextBlockText(block)] : [])
         };
@@ -6564,43 +6969,6 @@ function sortByPriority(items) {
     result.includes(item) || result.push(item);
   return [...result, ...itemsWithoutPriority];
 }
-function slateChildrenToBlocks(schema, value) {
-  const blocks = new Array(value.length);
-  for (let blockIndex = 0; blockIndex < value.length; blockIndex++) {
-    const descendant = value[blockIndex];
-    if (descendant._type !== schema.block.name) {
-      blocks[blockIndex] = {
-        _key: descendant._key,
-        _type: descendant._type,
-        ..."value" in descendant && typeof descendant.value == "object" ? descendant.value : {}
-      };
-      continue;
-    }
-    const children = "children" in descendant ? descendant.children : [], processedChildren = new Array(children.length);
-    for (let childIndex = 0; childIndex < children.length; childIndex++) {
-      const child = children[childIndex];
-      processedChildren[childIndex] = child._type === schema.span.name ? child : {
-        _key: child._key,
-        _type: child._type,
-        ..."value" in child && typeof child.value == "object" ? child.value : {}
-      };
-    }
-    blocks[blockIndex] = {
-      ...descendant,
-      children: processedChildren
-    };
-  }
-  return blocks;
-}
-function getActiveDecorators({
-  schema,
-  slateEditorInstance
-}) {
-  const decorators = schema.decorators.map((decorator) => decorator.name);
-  return ({
-    ...Editor.marks(slateEditorInstance) ?? {}
-  }.marks ?? []).filter((mark) => decorators.includes(mark));
-}
 function createEditorSnapshot({
   converters,
   editor,
@@ -6610,25 +6978,30 @@ function createEditorSnapshot({
   hasTag,
   internalDrag
 }) {
-  const value = slateChildrenToBlocks(schema, editor.children), selection = editor.selection ? slateRangeToSelection({
+  const selection = editor.selection ? slateRangeToSelection({
     schema,
     editor,
     range: editor.selection
   }) : null;
   return {
     context: {
-      activeDecorators: getActiveDecorators({
-        schema,
-        slateEditorInstance: editor
-      }),
       converters,
       keyGenerator,
       readOnly,
       schema,
       selection,
-      value
+      value: editor.value
     },
     beta: {
+      activeAnnotations: getActiveAnnotations({
+        markState: editor.markState,
+        schema
+      }),
+      activeDecorators: getActiveDecorators({
+        decoratorState: editor.decoratorState,
+        markState: editor.markState,
+        schema
+      }),
       hasTag,
       internalDrag
     }
@@ -7311,45 +7684,6 @@ function compileSchemaDefinitionToLegacySchema(definition) {
     } : inlineObject)
   };
 }
-function defaultCompare(a, b) {
-  return a === b;
-}
-function useEditorSelector(editor, selector, t0) {
-  const $ = c(3), compare = t0 === void 0 ? defaultCompare : t0;
-  let t1;
-  return $[0] !== editor || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
-    const snapshot = getEditorSnapshot({
-      editorActorSnapshot,
-      slateEditorInstance: editor._internal.slateEditor.instance
-    });
-    return selector(snapshot);
-  }, $[0] = editor, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
-}
-function getEditorSnapshot({
-  editorActorSnapshot,
-  slateEditorInstance
-}) {
-  return {
-    context: {
-      converters: [...editorActorSnapshot.context.converters],
-      activeDecorators: getActiveDecorators({
-        schema: editorActorSnapshot.context.schema,
-        slateEditorInstance
-      }),
-      keyGenerator: editorActorSnapshot.context.keyGenerator,
-      readOnly: editorActorSnapshot.matches({
-        "edit mode": "read only"
-      }),
-      schema: editorActorSnapshot.context.schema,
-      selection: editorActorSnapshot.context.selection,
-      value: slateChildrenToBlocks(editorActorSnapshot.context.schema, slateEditorInstance.children)
-    },
-    beta: {
-      hasTag: (tag) => editorActorSnapshot.hasTag(tag),
-      internalDrag: editorActorSnapshot.context.internalDrag
-    }
-  };
-}
 const debug$7 = debugWithName("mutation-machine"), mutationMachine = setup({
   types: {
     context: {},
@@ -7643,19 +7977,17 @@ function createEditableAPI(editor, editorActor) {
         editor
       });
     },
-    isMarkActive: (mark) => {
-      try {
-        return isDecoratorActive({
-          editor,
-          decorator: mark
-        });
-      } catch (err) {
-        return console.warn(err), !1;
-      }
+    isMarkActive: (mark) => getEditorSnapshot({
+      editorActorSnapshot: editorActor.getSnapshot(),
+      slateEditorInstance: editor
+    }).beta.activeDecorators.includes(mark),
+    marks: () => {
+      const snapshot = getEditorSnapshot({
+        editorActorSnapshot: editorActor.getSnapshot(),
+        slateEditorInstance: editor
+      });
+      return [...snapshot.beta.activeAnnotations, ...snapshot.beta.activeDecorators];
     },
-    marks: () => ({
-      ...Editor.marks(editor) || {}
-    }).marks || [],
     undo: () => {
       editorActor.send({
         type: "behavior event",
@@ -7729,8 +8061,8 @@ function createEditableAPI(editor, editorActor) {
         }]
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
-      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode2 = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
+      return isSpanNode2 && focusNode._type !== types.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), Transforms.insertNodes(editor, child, {
@@ -8770,8 +9102,8 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
           debug$5("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
-          const isSpanNode = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
-          isSpanNode && isTextChanged ? (oldBlockChild.text.length > 0 && Transforms.delete(slateEditor, {
+          const isSpanNode2 = Text.isText(currentBlockChild) && currentBlockChild._type === "span" && Text.isText(oldBlockChild) && oldBlockChild._type === "span";
+          isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && Transforms.delete(slateEditor, {
             at: {
               focus: {
                 path,
@@ -8784,7 +9116,7 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
             }
           }), Transforms.insertText(slateEditor, currentBlockChild.text, {
             at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
+          }), slateEditor.onChange()) : isSpanNode2 || (debug$5("Updating changed inline object child", currentBlockChild), Transforms.setNodes(slateEditor, {
             _key: VOID_CHILD_KEY
           }, {
             at: [...path, 0],
@@ -9154,6 +9486,7 @@ class PortableTextEditor extends Component {
   /*
    * The editor API (currently implemented with Slate).
    */
+  subscriptions = [];
   unsubscribers = [];
   constructor(props) {
     if (super(props), props.editor)
@@ -9170,23 +9503,20 @@ class PortableTextEditor extends Component {
         readOnly: props.readOnly,
         schema: props.schemaType
       });
-      this.unsubscribers.push((() => {
-        const subscription = actors.relayActor.on("*", (event) => {
-          const change = eventToChange(event);
-          change && (props.onChange(change), this.change$.next(change));
-        });
-        return () => {
-          subscription.unsubscribe();
-        };
-      })());
-      for (const subscription of subscriptions)
-        this.unsubscribers.push(subscription());
-      this.actors = actors, this.editor = editor, this.schemaTypes = actors.editorActor.getSnapshot().context.getLegacySchema();
+      this.subscriptions = subscriptions, this.actors = actors, this.editor = editor, this.schemaTypes = actors.editorActor.getSnapshot().context.getLegacySchema();
     }
     this.editable = this.editor._internal.editable;
   }
   componentDidMount() {
-    this.actors && (this.actors.editorActor.start(), this.actors.mutationActor.start(), this.actors.relayActor.start(), this.actors.syncActor.start());
+    if (!this.actors)
+      return;
+    for (const subscription of this.subscriptions)
+      this.unsubscribers.push(subscription());
+    const relayActorSubscription = this.actors.relayActor.on("*", (event) => {
+      const change = eventToChange(event);
+      change && (this.props.editor || this.props.onChange(change), this.change$.next(change));
+    });
+    this.unsubscribers.push(relayActorSubscription.unsubscribe), this.actors.editorActor.start(), this.actors.mutationActor.start(), this.actors.relayActor.start(), this.actors.syncActor.start();
   }
   componentDidUpdate(prevProps) {
     !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({