@portabletext/editor 1.10.2 → 1.11.0

package/lib/index.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var types = require("@sanity/types"), schema = require("@sanity/schema"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react$1 = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), react = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), xstate = require("xstate"), throttle = require("lodash/throttle.js"), useEffectEvent = require("use-effect-event"), debounce = require("lodash/debounce.js"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), getRandomValues = require("get-random-values-esm"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools");
+var types = require("@sanity/types"), schema = require("@sanity/schema"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), throttle = require("lodash/throttle.js"), debounce = require("lodash/debounce.js"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), getRandomValues = require("get-random-values-esm"), xstate = require("xstate"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), isHotkeyEsm = require("is-hotkey-esm"), blockTools = require("@sanity/block-tools");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$m), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
+var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$m), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), throttle__default = /* @__PURE__ */ _interopDefaultCompat(throttle), debounce__default = /* @__PURE__ */ _interopDefaultCompat(debounce), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy);
 function defineBehavior(behavior) {
   return behavior;
 }
@@ -296,6 +296,65 @@ const breakingBlockObject = {
   blockObjects: coreBlockObjectBehaviors,
   lists: coreListBehaviors
 };
+function createLinkBehaviors(config) {
+  const pasteLinkOnSelection = {
+    on: "paste",
+    guard: ({
+      context,
+      event
+    }) => {
+      const selectionCollapsed = selectionIsCollapsed(context), text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
+        url,
+        schema: context.schema
+      }) : void 0;
+      return annotation && !selectionCollapsed ? {
+        annotation
+      } : !1;
+    },
+    actions: [(_, {
+      annotation
+    }) => [{
+      type: "annotation.add",
+      annotation
+    }]]
+  }, pasteLinkAtCaret = {
+    on: "paste",
+    guard: ({
+      context,
+      event
+    }) => {
+      const focusSpan = getFocusSpan(context), selectionCollapsed = selectionIsCollapsed(context);
+      if (!focusSpan || !selectionCollapsed)
+        return !1;
+      const text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
+        url,
+        schema: context.schema
+      }) : void 0;
+      return url && annotation && selectionCollapsed ? {
+        focusSpan,
+        annotation,
+        url
+      } : !1;
+    },
+    actions: [(_, {
+      annotation,
+      url
+    }) => [{
+      type: "insert span",
+      text: url,
+      annotations: [annotation]
+    }]]
+  };
+  return [pasteLinkOnSelection, pasteLinkAtCaret];
+}
+function looksLikeUrl(text) {
+  let looksLikeUrl2 = !1;
+  try {
+    new URL(text), looksLikeUrl2 = !0;
+  } catch {
+  }
+  return looksLikeUrl2;
+}
 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"));
 }
@@ -552,65 +611,6 @@ function createMarkdownBehaviors(config) {
   };
   return [automaticBlockquoteOnSpace, automaticBreak, automaticHeadingOnSpace, clearStyleOnBackspace, automaticListOnSpace];
 }
-function createLinkBehaviors(config) {
-  const pasteLinkOnSelection = {
-    on: "paste",
-    guard: ({
-      context,
-      event
-    }) => {
-      const selectionCollapsed = selectionIsCollapsed(context), text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
-        url,
-        schema: context.schema
-      }) : void 0;
-      return annotation && !selectionCollapsed ? {
-        annotation
-      } : !1;
-    },
-    actions: [(_, {
-      annotation
-    }) => [{
-      type: "annotation.add",
-      annotation
-    }]]
-  }, pasteLinkAtCaret = {
-    on: "paste",
-    guard: ({
-      context,
-      event
-    }) => {
-      const focusSpan = getFocusSpan(context), selectionCollapsed = selectionIsCollapsed(context);
-      if (!focusSpan || !selectionCollapsed)
-        return !1;
-      const text = event.clipboardData.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
-        url,
-        schema: context.schema
-      }) : void 0;
-      return url && annotation && selectionCollapsed ? {
-        focusSpan,
-        annotation,
-        url
-      } : !1;
-    },
-    actions: [(_, {
-      annotation,
-      url
-    }) => [{
-      type: "insert span",
-      text: url,
-      annotations: [annotation]
-    }]]
-  };
-  return [pasteLinkOnSelection, pasteLinkAtCaret];
-}
-function looksLikeUrl(text) {
-  let looksLikeUrl2 = !1;
-  try {
-    new URL(text), looksLikeUrl2 = !0;
-  } catch {
-  }
-  return looksLikeUrl2;
-}
 function getPortableTextMemberSchemaTypes(portableTextType) {
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
@@ -1140,15 +1140,15 @@ const debug$l = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
     element,
     readOnly,
     blockRef
-  } = t0, editor = slateReact.useSlateStatic(), dragGhostRef = react.useRef(), [isDragOver, setIsDragOver] = react.useState(!1);
+  } = t0, editor = slateReact.useSlateStatic(), dragGhostRef = React.useRef(), [isDragOver, setIsDragOver] = React.useState(!1);
   let t1, t2;
   $[0] !== editor || $[1] !== element ? (t2 = slate.Editor.isVoid(editor, element), $[0] = editor, $[1] = element, $[2] = t2) : t2 = $[2], t1 = t2;
   const isVoid = t1;
   let t3, t4;
   $[3] !== editor || $[4] !== element ? (t4 = slate.Editor.isInline(editor, element), $[3] = editor, $[4] = element, $[5] = t4) : t4 = $[5], t3 = t4;
-  const isInline = t3, [blockElement, setBlockElement] = react.useState(null);
+  const isInline = t3, [blockElement, setBlockElement] = React.useState(null);
   let t5, t6;
-  $[6] !== blockRef || $[7] !== editor || $[8] !== element ? (t5 = () => setBlockElement(blockRef ? blockRef.current : slateReact.ReactEditor.toDOMNode(editor, element)), t6 = [editor, element, blockRef], $[6] = blockRef, $[7] = editor, $[8] = element, $[9] = t5, $[10] = t6) : (t5 = $[9], t6 = $[10]), react.useEffect(t5, t6);
+  $[6] !== blockRef || $[7] !== editor || $[8] !== element ? (t5 = () => setBlockElement(blockRef ? blockRef.current : slateReact.ReactEditor.toDOMNode(editor, element)), t6 = [editor, element, blockRef], $[6] = blockRef, $[7] = editor, $[8] = element, $[9] = t5, $[10] = t6) : (t5 = $[9], t6 = $[10]), React.useEffect(t5, t6);
   let t7;
   $[11] !== blockElement || $[12] !== editor || $[13] !== element ? (t7 = (event) => {
     const isMyDragOver = IS_DRAGGING_BLOCK_ELEMENT.get(editor);
@@ -1279,9 +1279,9 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
   renderStyle,
   spellCheck
 }) => {
-  const editor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), blockRef = react.useRef(null), inlineBlockObjectRef = react.useRef(null), focused = selected && editor.selection && slate.Range.isCollapsed(editor.selection) || !1, value = react.useMemo(() => fromSlateValue([element], schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0], [editor, element, schemaTypes.block.name]);
+  const editor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), blockRef = React.useRef(null), inlineBlockObjectRef = React.useRef(null), focused = selected && editor.selection && slate.Range.isCollapsed(editor.selection) || !1, value = React.useMemo(() => fromSlateValue([element], schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0], [editor, element, schemaTypes.block.name]);
   let renderedBlock = children, className;
-  const blockPath = react.useMemo(() => [{
+  const blockPath = React.useMemo(() => [{
     _key: element._key
   }], [element]);
   if (typeof element._type != "string")
@@ -1402,8 +1402,8 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
   ] }, element._key);
 };
 Element.displayName = "Element";
-const PortableTextEditorContext = react.createContext(null), usePortableTextEditor = () => {
-  const editor = react.useContext(PortableTextEditorContext);
+const PortableTextEditorContext = React.createContext(null), usePortableTextEditor = () => {
+  const editor = React.useContext(PortableTextEditorContext);
   if (!editor)
     throw new Error("The `usePortableTextEditor` hook must be used inside the <PortableTextEditor> component's context.");
   return editor;
@@ -2752,19 +2752,20 @@ function useSyncValue(props) {
   const {
     editorActor,
     portableTextEditor,
-    readOnly
-  } = props, schemaTypes = editorActor.getSnapshot().context.schema, previousValue = react.useRef(), slateEditor = slateReact.useSlate(), updateValueFunctionRef = react.useRef(), updateFromCurrentValue = react.useCallback(() => {
+    readOnly,
+    slateEditor
+  } = props, schemaTypes = editorActor.getSnapshot().context.schema, previousValue = React.useRef(), updateValueFunctionRef = React.useRef(), updateFromCurrentValue = React.useCallback(() => {
     const currentValue = CURRENT_VALUE.get(portableTextEditor);
     if (previousValue.current === currentValue) {
       debug$j("Value is the same object as previous, not need to sync");
       return;
     }
     updateValueFunctionRef.current && currentValue && (debug$j("Updating the value debounced"), updateValueFunctionRef.current(currentValue));
-  }, [portableTextEditor]), updateValueDebounced = react.useMemo(() => debounce__default.default(updateFromCurrentValue, 1e3, {
+  }, [portableTextEditor]), updateValueDebounced = React.useMemo(() => debounce__default.default(updateFromCurrentValue, 1e3, {
     trailing: !0,
     leading: !1
   }), [updateFromCurrentValue]);
-  return react.useMemo(() => {
+  return React.useMemo(() => {
     const updateFunction = (value) => {
       CURRENT_VALUE.set(portableTextEditor, value);
       const isProcessingLocalChanges = isChangingLocally(slateEditor), isProcessingRemoteChanges = isChangingRemotely(slateEditor);
@@ -2936,27 +2937,29 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
 }
 const debug$i = debugWithName("component:PortableTextEditor:Synchronizer"), debugVerbose$3 = debug$i.enabled && !1, FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3;
 function Synchronizer(props) {
-  const $ = reactCompilerRuntime.c(28), portableTextEditor = usePortableTextEditor(), readOnly = react$1.useSelector(props.editorActor, _temp$1), value = react$1.useSelector(props.editorActor, _temp2), {
+  const $ = reactCompilerRuntime.c(26), readOnly = react.useSelector(props.editorActor, _temp), value = react.useSelector(props.editorActor, _temp2), {
     editorActor,
     getValue,
-    onChange
+    portableTextEditor,
+    slateEditor
   } = props;
   let t0;
   $[0] === Symbol.for("react.memo_cache_sentinel") ? (t0 = [], $[0] = t0) : t0 = $[0];
-  const pendingPatches = react.useRef(t0);
+  const pendingPatches = React.useRef(t0);
   let t1;
-  $[1] !== editorActor || $[2] !== portableTextEditor || $[3] !== readOnly ? (t1 = {
+  $[1] !== editorActor || $[2] !== portableTextEditor || $[3] !== readOnly || $[4] !== slateEditor ? (t1 = {
     editorActor,
     portableTextEditor,
-    readOnly
-  }, $[1] = editorActor, $[2] = portableTextEditor, $[3] = readOnly, $[4] = t1) : t1 = $[4];
-  const syncValue = useSyncValue(t1), slateEditor = slateReact.useSlate();
+    readOnly,
+    slateEditor
+  }, $[1] = editorActor, $[2] = portableTextEditor, $[3] = readOnly, $[4] = slateEditor, $[5] = t1) : t1 = $[5];
+  const syncValue = useSyncValue(t1);
   let t2, t3;
-  $[5] !== slateEditor ? (t2 = () => {
+  $[6] !== slateEditor ? (t2 = () => {
     IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !1);
-  }, t3 = [slateEditor], $[5] = slateEditor, $[6] = t2, $[7] = t3) : (t2 = $[6], t3 = $[7]), react.useEffect(t2, t3);
+  }, t3 = [slateEditor], $[6] = slateEditor, $[7] = t2, $[8] = t3) : (t2 = $[7], t3 = $[8]), React.useEffect(t2, t3);
   let t4;
-  $[8] !== editorActor || $[9] !== getValue || $[10] !== slateEditor ? (t4 = () => {
+  $[9] !== editorActor || $[10] !== getValue || $[11] !== slateEditor ? (t4 = () => {
     if (pendingPatches.current.length > 0) {
       debug$i("Flushing pending patches"), debugVerbose$3 && debug$i(`Patches:
 ${JSON.stringify(pendingPatches.current, null, 2)}`);
@@ -2968,17 +2971,14 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
       }), pendingPatches.current = [];
     }
     IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !1);
-  }, $[8] = editorActor, $[9] = getValue, $[10] = slateEditor, $[11] = t4) : t4 = $[11];
+  }, $[9] = editorActor, $[10] = getValue, $[11] = slateEditor, $[12] = t4) : t4 = $[12];
   const onFlushPendingPatches = t4;
   let t5, t6;
-  $[12] !== onFlushPendingPatches ? (t5 = () => () => {
+  $[13] !== onFlushPendingPatches ? (t5 = () => () => {
     onFlushPendingPatches();
-  }, t6 = [onFlushPendingPatches], $[12] = onFlushPendingPatches, $[13] = t5, $[14] = t6) : (t5 = $[13], t6 = $[14]), react.useEffect(t5, t6);
-  let t7;
-  $[15] !== onChange ? (t7 = (change) => onChange(change), $[15] = onChange, $[16] = t7) : t7 = $[16];
-  const handleChange = useEffectEvent.useEffectEvent(t7);
-  let t8, t9;
-  $[17] !== editorActor || $[18] !== handleChange || $[19] !== onFlushPendingPatches || $[20] !== slateEditor ? (t8 = () => {
+  }, t6 = [onFlushPendingPatches], $[13] = onFlushPendingPatches, $[14] = t5, $[15] = t6) : (t5 = $[14], t6 = $[15]), React.useEffect(t5, t6);
+  let t7, t8;
+  $[16] !== editorActor || $[17] !== onFlushPendingPatches || $[18] !== slateEditor ? (t7 = () => {
     const onFlushPendingPatchesThrottled = throttle__default.default(() => {
       if (slate.Editor.isNormalizing(slateEditor)) {
         onFlushPendingPatches();
@@ -2989,90 +2989,76 @@ ${JSON.stringify(pendingPatches.current, null, 2)}`);
       leading: !1,
       trailing: !0
     });
-    debug$i("Subscribing to editor changes");
-    const sub = editorActor.on("*", (event) => {
-      bb22: switch (event.type) {
-        case "patch": {
-          IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !0), pendingPatches.current.push(event.patch), onFlushPendingPatchesThrottled(), handleChange(event);
-          break bb22;
-        }
-        case "loading": {
-          handleChange({
-            type: "loading",
-            isLoading: !0
-          });
-          break bb22;
-        }
-        case "done loading": {
-          handleChange({
-            type: "loading",
-            isLoading: !1
-          });
-          break bb22;
-        }
-        case "focused": {
-          handleChange({
-            type: "focus",
-            event: event.event
-          });
-          break bb22;
-        }
-        case "value changed": {
-          handleChange({
-            type: "value",
-            value: event.value
-          });
-          break bb22;
-        }
-        case "invalid value": {
-          handleChange({
-            type: "invalidValue",
-            resolution: event.resolution,
-            value: event.value
-          });
-          break bb22;
-        }
-        case "error": {
-          handleChange({
-            ...event,
-            level: "warning"
-          });
-          break bb22;
-        }
-        case "annotation.add":
-        case "annotation.remove":
-        case "annotation.toggle":
-        case "focus":
-        case "patches":
-          break bb22;
-        default:
-          handleChange(event);
-      }
+    debug$i("Subscribing to patch events");
+    const sub = editorActor.on("patch", (event) => {
+      IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !0), pendingPatches.current.push(event.patch), onFlushPendingPatchesThrottled();
     });
     return () => {
-      debug$i("Unsubscribing to changes"), sub.unsubscribe();
+      debug$i("Unsubscribing to patch events"), sub.unsubscribe();
     };
-  }, t9 = [editorActor, handleChange, onFlushPendingPatches, slateEditor], $[17] = editorActor, $[18] = handleChange, $[19] = onFlushPendingPatches, $[20] = slateEditor, $[21] = t8, $[22] = t9) : (t8 = $[21], t9 = $[22]), react.useEffect(t8, t9);
-  const isInitialValueFromProps = react.useRef(!0);
-  let t10, t11;
-  return $[23] !== editorActor || $[24] !== syncValue || $[25] !== value ? (t10 = () => {
+  }, t8 = [editorActor, onFlushPendingPatches, slateEditor], $[16] = editorActor, $[17] = onFlushPendingPatches, $[18] = slateEditor, $[19] = t7, $[20] = t8) : (t7 = $[19], t8 = $[20]), React.useEffect(t7, t8);
+  const isInitialValueFromProps = React.useRef(!0);
+  let t10, t9;
+  return $[21] !== editorActor || $[22] !== syncValue || $[23] !== value ? (t9 = () => {
     debug$i("Value from props changed, syncing new value"), syncValue(value), isInitialValueFromProps.current && (editorActor.send({
       type: "ready"
     }), isInitialValueFromProps.current = !1);
-  }, t11 = [editorActor, syncValue, value], $[23] = editorActor, $[24] = syncValue, $[25] = value, $[26] = t10, $[27] = t11) : (t10 = $[26], t11 = $[27]), react.useEffect(t10, t11), null;
+  }, t10 = [editorActor, syncValue, value], $[21] = editorActor, $[22] = syncValue, $[23] = value, $[24] = t10, $[25] = t9) : (t10 = $[24], t9 = $[25]), React.useEffect(t9, t10), null;
 }
 function _temp2(s_0) {
   return s_0.context.value;
 }
-function _temp$1(s) {
+function _temp(s) {
   return s.context.readOnly;
 }
 Synchronizer.displayName = "Synchronizer";
-const debug$h = debugWithName("operationToPatches");
+const EditorActorContext = React.createContext({}), PortableTextEditorSelectionContext = React.createContext(null), usePortableTextEditorSelection = () => {
+  const selection = React.useContext(PortableTextEditorSelectionContext);
+  if (selection === void 0)
+    throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
+  return selection;
+}, debug$h = debugWithName("component:PortableTextEditor:SelectionProvider"), debugVerbose$2 = debug$h.enabled && !1;
+function PortableTextEditorSelectionProvider(props) {
+  const $ = reactCompilerRuntime.c(6), [selection, setSelection] = React.useState(null);
+  let t0, t1;
+  $[0] !== props.editorActor ? (t0 = () => {
+    debug$h("Subscribing to selection changes");
+    const subscription = props.editorActor.on("selection", (event) => {
+      React.startTransition(() => {
+        debugVerbose$2 && debug$h("Setting selection"), setSelection(event.selection);
+      });
+    });
+    return () => {
+      debug$h("Unsubscribing to selection changes"), subscription.unsubscribe();
+    };
+  }, t1 = [props.editorActor], $[0] = props.editorActor, $[1] = t0, $[2] = t1) : (t0 = $[1], t1 = $[2]), React.useEffect(t0, t1);
+  let t2;
+  return $[3] !== props.children || $[4] !== selection ? (t2 = /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }), $[3] = props.children, $[4] = selection, $[5] = t2) : t2 = $[5], t2;
+}
+const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
+  let table;
+  return () => {
+    if (table)
+      return table;
+    table = [];
+    for (let i = 0; i < 256; ++i)
+      table[i] = (i + 256).toString(16).slice(1);
+    return table;
+  };
+})();
+function whatwgRNG(length = 16) {
+  const rnds8 = new Uint8Array(length);
+  return getRandomValues__default.default(rnds8), rnds8;
+}
+function randomKey(length) {
+  const table = getByteHexTable();
+  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+}
+const debug$g = debugWithName("operationToPatches");
 function createOperationToPatches(types2) {
   const textBlockName = types2.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
-    debug$h.enabled && debug$h("Operation", JSON.stringify(operation, null, 2));
+    debug$g.enabled && debug$g("Operation", JSON.stringify(operation, null, 2));
     const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
     if (!block)
       throw new Error("Could not find block");
@@ -3165,7 +3151,7 @@ function createOperationToPatches(types2) {
         _key: block.children[operation.path[1] - 1]._key
       }])];
     }
-    return debug$h("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$g("Something was inserted into a void block. Not producing editor patches."), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], splitBlock = editor.children[operation.path[0]];
@@ -3223,9 +3209,9 @@ function createOperationToPatches(types2) {
         _key: block._key
       }, "children", {
         _key: spanToRemove._key
-      }])] : (debug$h("Span not found in editor trying to remove node"), []);
+      }])] : (debug$g("Span not found in editor trying to remove node"), []);
     } else
-      return debug$h("Not creating patch inside object block"), [];
+      return debug$g("Not creating patch inside object block"), [];
   }
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
@@ -3251,7 +3237,7 @@ function createOperationToPatches(types2) {
         _key: removedSpan._key
       }])) : console.warn(`Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`, JSON.stringify(block, null, 2)));
     } else
-      debug$h("Void nodes can't be merged, not creating any patches");
+      debug$g("Void nodes can't be merged, not creating any patches");
     return patches$1;
   }
   function moveNodePatch(editor, operation, beforeValue) {
@@ -3496,13 +3482,13 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
-const debug$g = debugWithName("applyPatches"), debugVerbose$2 = debug$g.enabled && !0;
+const debug$f = debugWithName("applyPatches"), debugVerbose$1 = debug$f.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
     let changed = !1;
-    debugVerbose$2 && (debug$g(`
+    debugVerbose$1 && (debug$f(`
 
-NEW PATCH =============================================================`), debug$g(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`), debug$f(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -3518,7 +3504,7 @@ NEW PATCH =============================================================`), debug
           changed = diffMatchPatch(editor, patch);
           break;
         default:
-          debug$g("Unhandled patch", patch.type);
+          debug$f("Unhandled patch", patch.type);
       }
     } catch (err) {
       console.error(err);
@@ -3533,9 +3519,9 @@ function diffMatchPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$g("Block not found"), !1;
+    return debug$f("Block not found"), !1;
   if (!child || !childPath)
-    return debug$g("Child not found"), !1;
+    return debug$f("Child not found"), !1;
   if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child))
     return !1;
   const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, {
@@ -3565,9 +3551,9 @@ function insertPatch(editor, patch, schemaTypes) {
     childPath: targetChildPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!targetBlock || !targetBlockPath)
-    return debug$g("Block not found"), !1;
+    return debug$f("Block not found"), !1;
   if (patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$g("Ignoring patch targeting void value"), !1;
+    return debug$f("Ignoring patch targeting void value"), !1;
   if (patch.path.length === 1) {
     const {
       items: items2,
@@ -3575,7 +3561,7 @@ function insertPatch(editor, patch, schemaTypes) {
     } = patch, blocksToInsert = toSlateValue(items2, {
       schemaTypes
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
-    return debug$g(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
+    return debug$f(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), slate.Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
     }), debugState(editor, "after"), !0;
   }
@@ -3584,14 +3570,14 @@ function insertPatch(editor, patch, schemaTypes) {
     position
   } = patch;
   if (!targetChild || !targetChildPath)
-    return debug$g("Child not found"), !1;
+    return debug$f("Child not found"), !1;
   const childrenToInsert = targetBlock && toSlateValue([{
     ...targetBlock,
     children: items
   }], {
     schemaTypes
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$g(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+  return debug$f(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
   }), debugState(editor, "after"), !0;
 }
@@ -3605,14 +3591,14 @@ function setPatch(editor, patch) {
     childPath
   } = findBlockAndChildFromPath(editor, patch.path);
   if (!block)
-    return debug$g("Block not found"), !1;
+    return debug$f("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
   if (isTextBlock && patch.path.length > 1 && patch.path[1] !== "children")
-    return debug$g("Ignoring setting void value"), !1;
+    return debug$f("Ignoring setting void value"), !1;
   if (debugState(editor, "before"), isTextBlock && child && childPath) {
     if (slate.Text.isText(value) && slate.Text.isText(child)) {
       const newText = child.text;
-      value.text !== newText && (debug$g("Setting text property"), editor.apply({
+      value.text !== newText && (debug$f("Setting text property"), editor.apply({
         type: "remove_text",
         path: childPath,
         offset: 0,
@@ -3624,7 +3610,7 @@ function setPatch(editor, patch) {
         text: value.text
       }), editor.onChange());
     } else
-      debug$g("Setting non-text property"), editor.apply({
+      debug$f("Setting non-text property"), editor.apply({
         type: "set_node",
         path: childPath,
         properties: {},
@@ -3632,7 +3618,7 @@ function setPatch(editor, patch) {
       });
     return !0;
   } else if (slate.Element.isElement(block) && patch.path.length === 1 && blockPath) {
-    debug$g("Setting block property");
+    debug$f("Setting block property");
     const {
       children,
       ...nextRest
@@ -3649,7 +3635,7 @@ function setPatch(editor, patch) {
         ...prevRest
       },
       newProperties: nextRest
-    }), debug$g("Setting children"), block.children.forEach((c, cIndex) => {
+    }), debug$f("Setting children"), block.children.forEach((c, cIndex) => {
       editor.apply({
         type: "remove_node",
         path: blockPath.concat(block.children.length - 1 - cIndex),
@@ -3675,7 +3661,7 @@ function setPatch(editor, patch) {
 }
 function unsetPatch(editor, patch) {
   if (patch.path.length === 0) {
-    debug$g("Removing everything"), debugState(editor, "before");
+    debug$f("Removing everything"), debugState(editor, "before");
     const previousSelection = editor.selection;
     return slate.Transforms.deselect(editor), editor.children.forEach((_child, i) => {
       slate.Transforms.removeNodes(editor, {
@@ -3702,13 +3688,13 @@ function unsetPatch(editor, patch) {
   } = findBlockAndChildFromPath(editor, patch.path);
   if (patch.path.length === 1) {
     if (!block || !blockPath)
-      return debug$g("Block not found"), !1;
+      return debug$f("Block not found"), !1;
     const blockIndex = blockPath[0];
-    return debug$g(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
+    return debug$f(`Removing block at path [${blockIndex}]`), debugState(editor, "before"), slate.Transforms.removeNodes(editor, {
       at: [blockIndex]
     }), debugState(editor, "after"), !0;
   }
-  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$g("Child not found"), !1) : (debug$g(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose$2 && debug$g(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
+  return editor.isTextBlock(block) && patch.path[1] === "children" && patch.path.length === 3 ? !child || !childPath ? (debug$f("Child not found"), !1) : (debug$f(`Unsetting child at path ${JSON.stringify(childPath)}`), debugState(editor, "before"), debugVerbose$1 && debug$f(`Removing child at path ${JSON.stringify(childPath)}`), slate.Transforms.removeNodes(editor, {
     at: childPath
   }), debugState(editor, "after"), !0) : !1;
 }
@@ -3716,7 +3702,7 @@ function isKeyedSegment(segment) {
   return typeof segment == "object" && "_key" in segment;
 }
 function debugState(editor, stateName) {
-  debugVerbose$2 && (debug$g(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$g(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
+  debugVerbose$1 && (debug$f(`Children ${stateName}:`, JSON.stringify(editor.children, null, 2)), debug$f(`Selection ${stateName}: `, JSON.stringify(editor.selection, null, 2)));
 }
 function findBlockFromPath(editor, path) {
   let blockIndex = -1;
@@ -3758,7 +3744,7 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
-const debug$f = debugWithName("plugin:withPatches");
+const debug$e = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
@@ -3784,7 +3770,7 @@ function createWithPatches({
           withoutPatching(editor, () => {
             withoutSaving(editor, () => {
               patches2.forEach((patch) => {
-                debug$f.enabled && debug$f(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
+                debug$e.enabled && debug$e(`Handling remote patch ${JSON.stringify(patch)}`), changed = applyPatch(editor, patch);
               });
             });
           });
@@ -3797,10 +3783,10 @@ function createWithPatches({
       remotePatches.length !== 0 && (bufferedPatches = bufferedPatches.concat(remotePatches), handleBufferedRemotePatches());
     };
     return subscriptions.push(() => {
-      debug$f("Subscribing to remote patches");
+      debug$e("Subscribing to remote patches");
       const sub = editorActor.on("patches", handlePatches);
       return () => {
-        debug$f("Unsubscribing to remote patches"), sub.unsubscribe();
+        debug$e("Unsubscribing to remote patches"), sub.unsubscribe();
       };
     }), editor.apply = (operation) => {
       if (editorActor.getSnapshot().context.readOnly)
@@ -3853,7 +3839,7 @@ function createWithPatches({
     }, editor;
   };
 }
-const debug$e = debugWithName("plugin:withPlaceholderBlock");
+const debug$d = debugWithName("plugin:withPlaceholderBlock");
 function createWithPlaceholderBlock(editorActor) {
   return function(editor) {
     const {
@@ -3873,7 +3859,7 @@ function createWithPlaceholderBlock(editorActor) {
           const node = op.node;
           if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
             const nextPath = slate.Path.next(op.path);
-            editor.children[nextPath[0]] || (debug$e("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
+            editor.children[nextPath[0]] || (debug$d("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateTextBlock({
               decorators: []
             })));
           }
@@ -3883,7 +3869,7 @@ function createWithPlaceholderBlock(editorActor) {
     }, editor;
   };
 }
-const debug$d = debugWithName("plugin:withPortableTextBlockStyle");
+const debug$c = debugWithName("plugin:withPortableTextBlockStyle");
 function createWithPortableTextBlockStyle(editorActor, types2) {
   const defaultStyle = types2.styles[0].value;
   return function(editor) {
@@ -3896,7 +3882,7 @@ function createWithPortableTextBlockStyle(editorActor, types2) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$d(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
+            debug$c(`Normalizing split node to ${defaultStyle} style`, op), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               style: defaultStyle
@@ -3918,12 +3904,12 @@ function createWithPortableTextBlockStyle(editorActor, types2) {
         at: editor.selection,
         match: (node) => editor.isTextBlock(node)
       })].forEach(([node, path]) => {
-        editor.isTextBlock(node) && node.style === blockStyle ? (debug$d(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(editor, {
+        editor.isTextBlock(node) && node.style === blockStyle ? (debug$c(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(editor, {
           ...node,
           style: defaultStyle
         }, {
           at: path
-        })) : (blockStyle ? debug$d(`Setting style '${blockStyle}'`) : debug$d("Setting default style", defaultStyle), slate.Transforms.setNodes(editor, {
+        })) : (blockStyle ? debug$c(`Setting style '${blockStyle}'`) : debug$c("Setting default style", defaultStyle), slate.Transforms.setNodes(editor, {
           ...node,
           style: blockStyle || defaultStyle
         }, {
@@ -3933,11 +3919,11 @@ function createWithPortableTextBlockStyle(editorActor, types2) {
     }, editor;
   };
 }
-const debug$c = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
+const debug$b = debugWithName("plugin:withPortableTextLists"), MAX_LIST_LEVEL = 10;
 function createWithPortableTextLists(types2) {
   return function(editor) {
     return editor.pteToggleListItem = (listItemStyle) => {
-      editor.pteHasListStyle(listItemStyle) ? (debug$c(`Remove list item '${listItemStyle}'`), editor.pteUnsetListItem(listItemStyle)) : (debug$c(`Add list item '${listItemStyle}'`), editor.pteSetListItem(listItemStyle));
+      editor.pteHasListStyle(listItemStyle) ? (debug$b(`Remove list item '${listItemStyle}'`), editor.pteUnsetListItem(listItemStyle)) : (debug$b(`Add list item '${listItemStyle}'`), editor.pteSetListItem(listItemStyle));
     }, editor.pteUnsetListItem = (listItemStyle) => {
       editor.selection && [...slate.Editor.nodes(editor, {
         at: editor.selection,
@@ -3953,7 +3939,7 @@ function createWithPortableTextLists(types2) {
             listItem: void 0,
             level: void 0
           };
-          debug$c(`Unsetting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, newNode, {
+          debug$b(`Unsetting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, newNode, {
             at: path
           });
         }
@@ -3963,7 +3949,7 @@ function createWithPortableTextLists(types2) {
         at: editor.selection,
         match: (node) => editor.isTextBlock(node)
       })].forEach(([node, path]) => {
-        debug$c(`Setting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, {
+        debug$b(`Setting list '${listItemStyle}'`), slate.Transforms.setNodes(editor, {
           ...node,
           level: 1,
           listItem: listItemStyle || types2.lists[0] && types2.lists[0].value
@@ -3979,7 +3965,7 @@ function createWithPortableTextLists(types2) {
         match: (node) => slate.Element.isElement(node) && editor.isListBlock(node) && node.children.length === 1 && slate.Text.isText(node.children[0]) && node.children[0].text === ""
       })];
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
-        slate.Element.isElement(node) && (debug$c("Unset list"), slate.Transforms.setNodes(editor, {
+        slate.Element.isElement(node) && (debug$b("Unset list"), slate.Transforms.setNodes(editor, {
           ...node,
           level: void 0,
           listItem: void 0
@@ -3997,7 +3983,7 @@ function createWithPortableTextLists(types2) {
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
         if (editor.isListBlock(node)) {
           let level = node.level || 1;
-          reverse ? (level--, debug$c("Decrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))) : (level++, debug$c("Incrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))), slate.Transforms.setNodes(editor, {
+          reverse ? (level--, debug$b("Decrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))) : (level++, debug$b("Incrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))), slate.Transforms.setNodes(editor, {
             level: Math.min(MAX_LIST_LEVEL, Math.max(1, level))
           }, {
             at: path
@@ -4043,7 +4029,7 @@ function getNextSpan({
     }
   return nextSpan;
 }
-const debug$b = debugWithName("plugin:withPortableTextMarkModel");
+const debug$a = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types2) {
   return function(editor) {
     const {
@@ -4057,7 +4043,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         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$b("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
+            debug$a("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.mergeNodes(editor, {
               at: [childPath[0], childPath[1] + 1],
@@ -4070,7 +4056,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         }
       }
       if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
-        debug$b("Adding .markDefs to block node"), editorActor.send({
+        debug$a("Adding .markDefs to block node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           markDefs: []
@@ -4082,7 +4068,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         return;
       }
       if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
-        debug$b("Adding .marks to span node"), editorActor.send({
+        debug$a("Adding .marks to span node"), editorActor.send({
           type: "normalizing"
         }), slate.Transforms.setNodes(editor, {
           marks: []
@@ -4096,7 +4082,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
       if (editor.isTextSpan(node)) {
         const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
-          debug$b("Removing annotations from empty span node"), editorActor.send({
+          debug$a("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             marks: node.marks?.filter((mark) => decorators2.includes(mark))
@@ -4114,7 +4100,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
           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$b("Removing orphaned annotations from span node"), editorActor.send({
+              debug$a("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
               }), slate.Transforms.setNodes(editor, {
                 marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -4132,7 +4118,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         if (editor.isTextBlock(block)) {
           const decorators2 = types2.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
-            debug$b("Removing orphaned annotations from span node"), editorActor.send({
+            debug$a("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
             }), slate.Transforms.setNodes(editor, {
               marks: marks.filter((mark) => !orphanedAnnotations.includes(mark))
@@ -4150,7 +4136,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
-          debug$b("Removing duplicate markDefs"), editorActor.send({
+          debug$a("Removing duplicate markDefs"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -4165,7 +4151,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
       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) => slate.Text.isText(child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node.markDefs && !isEqual__default.default(newMarkDefs, node.markDefs)) {
-          debug$b("Removing markDef not in use"), editorActor.send({
+          debug$a("Removing markDef not in use"), editorActor.send({
             type: "normalizing"
           }), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
@@ -4382,7 +4368,7 @@ function createWithPortableTextMarkModel(editorActor, types2) {
         const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-          debug$b("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
+          debug$a("Copying markDefs over to merged block", op), slate.Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
             at: targetPath,
@@ -4534,7 +4520,7 @@ const toggleDecoratorActionImplementation = ({
       decorator: action.decorator
     }
   });
-}, debug$a = debugWithName("plugin:withPortableTextSelections"), debugVerbose$1 = debug$a.enabled && !1;
+}, debug$9 = debugWithName("plugin:withPortableTextSelections"), debugVerbose = debug$9.enabled && !1;
 function createWithPortableTextSelections(editorActor, types2) {
   let prevSelection = null;
   return function(editor) {
@@ -4550,7 +4536,7 @@ function createWithPortableTextSelections(editorActor, types2) {
             ptRange = toPortableTextRange(value, editor.selection, types2), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
           }
         }
-        debugVerbose$1 && debug$a(`Emitting selection ${JSON.stringify(ptRange || null)} (${JSON.stringify(editor.selection)})`), ptRange ? editorActor.send({
+        debugVerbose && debug$9(`Emitting selection ${JSON.stringify(ptRange || null)} (${JSON.stringify(editor.selection)})`), ptRange ? editorActor.send({
           type: "selection",
           selection: ptRange
         }) : editorActor.send({
@@ -4568,7 +4554,7 @@ function createWithPortableTextSelections(editorActor, types2) {
     }, editor;
   };
 }
-const debug$9 = debugWithName("plugin:withSchemaTypes");
+const debug$8 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
   schemaTypes
@@ -4581,7 +4567,7 @@ function createWithSchemaTypes({
     return editor.normalizeNode = (entry) => {
       const [node, path] = entry;
       if (node._type === void 0 && path.length === 2) {
-        debug$9("Setting span type on text node without a type");
+        debug$8("Setting span type on text node without a type");
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4597,7 +4583,7 @@ function createWithSchemaTypes({
         return;
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
-        debug$9("Setting missing key on child node without a key");
+        debug$8("Setting missing key on child node without a key");
         const key = editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
@@ -4614,7 +4600,7 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
-const debug$8 = debugWithName("plugin:withUtils");
+const debug$7 = debugWithName("plugin:withUtils");
 function createWithUtils({
   editorActor,
   schemaTypes
@@ -4629,14 +4615,14 @@ function createWithUtils({
           depth: 2
         });
         if (!textNode || !slate.Text.isText(textNode) || textNode.text.length === 0) {
-          debug$8("pteExpandToWord: Can't expand to word here");
+          debug$7("pteExpandToWord: Can't expand to word here");
           return;
         }
         const {
           focus
         } = selection, focusOffset = focus.offset, charsBefore = textNode.text.slice(0, focusOffset), charsAfter = textNode.text.slice(focusOffset, -1), isEmpty = (str) => str.match(/\s/g), whiteSpaceBeforeIndex = charsBefore.split("").reverse().findIndex((str) => isEmpty(str)), newStartOffset = whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0, whiteSpaceAfterIndex = charsAfter.split("").findIndex((obj) => isEmpty(obj)), newEndOffset = charsBefore.length + (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1);
         if (!(newStartOffset === newEndOffset || Number.isNaN(newStartOffset) || Number.isNaN(newEndOffset))) {
-          debug$8("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
+          debug$7("pteExpandToWord: Expanding to focused word"), slate.Transforms.setSelection(editor, {
             anchor: {
               ...selection.anchor,
               offset: newStartOffset
@@ -4648,7 +4634,7 @@ function createWithUtils({
           });
           return;
         }
-        debug$8("pteExpandToWord: Can't expand to word here");
+        debug$7("pteExpandToWord: Can't expand to word here");
       }
     }, editor.pteCreateTextBlock = (options) => toSlateValue([{
       _type: schemaTypes.block.name,
@@ -4674,16 +4660,10 @@ function createWithUtils({
     })[0], editor;
   };
 }
-const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, options) => {
+const withPlugins = (editor, options) => {
   const e = editor, {
     editorActor
-  } = options, schemaTypes = editorActor.getSnapshot().context.schema;
-  e.destroy ? e.destroy() : originalFnMap.set(e, {
-    apply: e.apply,
-    onChange: e.onChange,
-    normalizeNode: e.normalizeNode
-  });
-  const operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
+  } = options, schemaTypes = editorActor.getSnapshot().context.schema, operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
     editorActor,
     schemaTypes
   }), withPatches = createWithPatches({
@@ -4698,38 +4678,21 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
   }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
     editorActor,
     schemaTypes
-  }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes), withEventListeners = createWithEventListeners(editorActor, options.subscriptions);
-  return e.destroy = () => {
-    const originalFunctions = originalFnMap.get(e);
-    if (!originalFunctions)
-      throw new Error("Could not find pristine versions of editor functions");
-    e.apply = originalFunctions.apply, e.history = {
-      undos: [],
-      redos: []
-    }, e.normalizeNode = originalFunctions.normalizeNode, e.onChange = originalFunctions.onChange;
-  }, withEventListeners(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPortableTextLists(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e))))))))))));
-}, debug$7 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
+  }), withPortableTextSelections = createWithPortableTextSelections(editorActor, schemaTypes);
+  return createWithEventListeners(editorActor, options.subscriptions)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPortableTextLists(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e))))))))))));
+}, debug$6 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
 function createSlateEditor(config) {
   const existingSlateEditor = slateEditors.get(config.editorActor);
   if (existingSlateEditor)
-    return debug$7("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
-  debug$7("Creating new Slate editor instance", config.editorActor.id);
-  let unsubscriptions = [], subscriptions = [];
-  const instance = withPlugins(slateReact.withReact(slate.createEditor()), {
+    return debug$6("Reusing existing Slate editor instance", config.editorActor.id), existingSlateEditor;
+  debug$6("Creating new Slate editor instance", config.editorActor.id);
+  const unsubscriptions = [], subscriptions = [], instance = withPlugins(slateReact.withReact(slate.createEditor()), {
     editorActor: config.editorActor,
     subscriptions
   });
   KEY_TO_VALUE_ELEMENT.set(instance, {}), KEY_TO_SLATE_ELEMENT.set(instance, {});
   for (const subscription of subscriptions)
     unsubscriptions.push(subscription());
-  config.editorActor.subscribe((snapshot) => {
-    if (snapshot.status !== "active") {
-      debug$7("Destroying Slate editor"), instance.destroy();
-      for (const unsubscribe of unsubscriptions)
-        unsubscribe();
-      subscriptions = [], unsubscriptions = [];
-    }
-  });
   const initialValue = [instance.pteCreateTextBlock({
     decorators: []
   })], slateEditor = {
@@ -4738,7 +4701,7 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const EditorActorContext = react.createContext({}), debug$6 = debugWithName("API:editable");
+const debug$5 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -4819,7 +4782,7 @@ function createEditableAPI(editor, editorActor) {
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types2.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-      return isSpanNode && focusNode._type !== types2.span.name && (debug$6("Inserting span child next to inline object child, moving selection + 1"), editor.move({
+      return isSpanNode && focusNode._type !== types2.span.name && (debug$5("Inserting span child next to inline object child, moving selection + 1"), editor.move({
         distance: 1,
         unit: "character"
       })), slate.Transforms.insertNodes(editor, child, {
@@ -4951,18 +4914,18 @@ function createEditableAPI(editor, editorActor) {
           throw new Error("Invalid range");
         if (range) {
           if (!options?.mode || options?.mode === "selected") {
-            debug$6("Deleting content in selection"), slate.Transforms.delete(editor, {
+            debug$5("Deleting content in selection"), slate.Transforms.delete(editor, {
               at: range,
               hanging: !0,
               voids: !0
             }), editor.onChange();
             return;
           }
-          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
+          options?.mode === "blocks" && (debug$5("Deleting blocks touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && slate.Element.isElement(node)
-          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
+          })), options?.mode === "children" && (debug$5("Deleting children touched by selection"), slate.Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types2.span.name || // Text children
@@ -5125,7 +5088,7 @@ const addAnnotationActionImplementation = ({
   action
 }) => {
   const editor = action.editor;
-  if (debug$6("Removing annotation", action.annotation.name), !!editor.selection)
+  if (debug$5("Removing annotation", action.annotation.name), !!editor.selection)
     if (slate.Range.isCollapsed(editor.selection)) {
       const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
         depth: 1
@@ -5778,8 +5741,8 @@ const editorMachine = xstate.setup({
     keyGenerator: input.keyGenerator,
     pendingEvents: [],
     schema: input.schema,
-    readOnly: !1,
-    maxBlocks: void 0,
+    readOnly: input.readOnly ?? !1,
+    maxBlocks: input.maxBlocks,
     value: input.value
   }),
   on: {
@@ -5884,11 +5847,16 @@ const editorMachine = xstate.setup({
       })
     },
     "toggle readOnly": {
-      actions: xstate.assign({
+      actions: [xstate.assign({
         readOnly: ({
           context
         }) => !context.readOnly
-      })
+      }), xstate.emit(({
+        context
+      }) => ({
+        type: "readOnly toggled",
+        readOnly: context.readOnly
+      }))]
     },
     "update maxBlocks": {
       actions: xstate.assign({
@@ -5979,50 +5947,65 @@ const editorMachine = xstate.setup({
       }
     }
   }
-}), PortableTextEditorSelectionContext = react.createContext(null), usePortableTextEditorSelection = () => {
-  const selection = react.useContext(PortableTextEditorSelectionContext);
-  if (selection === void 0)
-    throw new Error("The `usePortableTextEditorSelection` hook must be used inside the <PortableTextEditor> component's context.");
-  return selection;
-}, debug$5 = debugWithName("component:PortableTextEditor:SelectionProvider"), debugVerbose = debug$5.enabled && !1;
-function PortableTextEditorSelectionProvider(props) {
-  const $ = reactCompilerRuntime.c(6), [selection, setSelection] = react.useState(null);
-  let t0, t1;
-  $[0] !== props.editorActor ? (t0 = () => {
-    debug$5("Subscribing to selection changes");
-    const subscription = props.editorActor.on("selection", (event) => {
-      react.startTransition(() => {
-        debugVerbose && debug$5("Setting selection"), setSelection(event.selection);
-      });
-    });
-    return () => {
-      debug$5("Unsubscribing to selection changes"), subscription.unsubscribe();
-    };
-  }, t1 = [props.editorActor], $[0] = props.editorActor, $[1] = t0, $[2] = t1) : (t0 = $[1], t1 = $[2]), react.useEffect(t0, t1);
-  let t2;
-  return $[3] !== props.children || $[4] !== selection ? (t2 = /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }), $[3] = props.children, $[4] = selection, $[5] = t2) : t2 = $[5], t2;
-}
-const defaultKeyGenerator = () => randomKey(12), getByteHexTable = /* @__PURE__ */ (() => {
-  let table;
-  return () => {
-    if (table)
-      return table;
-    table = [];
-    for (let i = 0; i < 256; ++i)
-      table[i] = (i + 256).toString(16).slice(1);
-    return table;
+});
+function createEditor(config) {
+  const editorActor = xstate.createActor(editorMachine, {
+    input: editorConfigToMachineInput(config)
+  });
+  editorActor.start();
+  const slateEditor = createSlateEditor({
+    editorActor
+  }), editable = createEditableAPI(slateEditor.instance, editorActor);
+  return {
+    send: (event) => {
+      editorActor.send(event);
+    },
+    on: (event, listener) => editorActor.on(
+      event,
+      // @ts-ignore
+      listener
+    ),
+    editable,
+    _internal: {
+      editorActor,
+      slateEditor
+    }
   };
-})();
-function whatwgRNG(length = 16) {
-  const rnds8 = new Uint8Array(length);
-  return getRandomValues__default.default(rnds8), rnds8;
 }
-function randomKey(length) {
-  const table = getByteHexTable();
-  return whatwgRNG(length).reduce((str, n) => str + table[n], "").slice(0, length);
+function useEditor(config) {
+  const editorActor = react.useActorRef(editorMachine, {
+    input: editorConfigToMachineInput(config)
+  }), slateEditor = createSlateEditor({
+    editorActor
+  }), editable = React.useMemo(() => createEditableAPI(slateEditor.instance, editorActor), [slateEditor.instance, editorActor]), send = React.useCallback((event) => {
+    editorActor.send(event);
+  }, [editorActor]), on = React.useCallback((event_0, listener) => editorActor.on(
+    event_0,
+    // @ts-ignore
+    listener
+  ), [editorActor]);
+  return React.useMemo(() => ({
+    send,
+    on,
+    editable,
+    _internal: {
+      editorActor,
+      slateEditor
+    }
+  }), [send, on, editable, editorActor, slateEditor]);
+}
+function editorConfigToMachineInput(config) {
+  return {
+    behaviors: config.behaviors,
+    keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
+    maxBlocks: config.maxBlocks,
+    readOnly: config.readOnly,
+    schema: config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : getPortableTextMemberSchemaTypes(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)),
+    value: config.initialValue
+  };
 }
 const debug$4 = debugWithName("component:PortableTextEditor");
-class PortableTextEditor extends react.Component {
+class PortableTextEditor extends React.Component {
   static displayName = "PortableTextEditor";
   /**
    * An observable of all the editor changes.
@@ -6032,66 +6015,49 @@ class PortableTextEditor extends react.Component {
    * A lookup table for all the relevant schema types for this portable text type.
    */
   /**
+   * The editor instance
+   */
+  /*
    * The editor API (currently implemented with Slate).
    */
   constructor(props) {
-    if (super(props), props.editor) {
-      const editor = props.editor;
-      this.editorActor = editor._internal.editorActor, this.slateEditor = editor._internal.slateEditor, this.editorActor.start(), this.schemaTypes = this.editorActor.getSnapshot().context.schema;
-    } else {
-      if (!props.schemaType)
-        throw new Error('PortableTextEditor: missing "schemaType" property');
-      props.incomingPatches$ && console.warn("The prop 'incomingPatches$' is deprecated and renamed to 'patches$'"), this.schemaTypes = getPortableTextMemberSchemaTypes(props.schemaType.hasOwnProperty("jsonType") ? props.schemaType : compileType(props.schemaType)), this.editorActor = xstate.createActor(editorMachine, {
-        input: {
-          keyGenerator: props.keyGenerator || defaultKeyGenerator,
-          schema: this.schemaTypes,
-          value: props.value
-        }
-      }), this.editorActor.start(), this.slateEditor = createSlateEditor({
-        editorActor: this.editorActor
-      }), props.readOnly && this.editorActor.send({
-        type: "toggle readOnly"
-      }), props.maxBlocks && this.editorActor.send({
-        type: "update maxBlocks",
-        maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10)
-      });
-    }
-    this.editable = createEditableAPI(this.slateEditor.instance, this.editorActor);
+    super(props), props.editor ? this.editor = props.editor : this.editor = createEditor({
+      keyGenerator: props.keyGenerator ?? defaultKeyGenerator,
+      schema: props.schemaType,
+      initialValue: props.value,
+      maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
+      readOnly: props.readOnly
+    }), this.schemaTypes = this.editor._internal.editorActor.getSnapshot().context.schema, this.editable = this.editor.editable;
   }
   componentDidUpdate(prevProps) {
-    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = getPortableTextMemberSchemaTypes(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editorActor.send({
+    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = getPortableTextMemberSchemaTypes(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
       type: "update schema",
       schema: this.schemaTypes
-    })), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editorActor.send({
+    })), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({
       type: "toggle readOnly"
-    }), this.props.maxBlocks !== prevProps.maxBlocks && this.editorActor.send({
+    }), 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.editorActor.send({
+    }), this.props.value !== prevProps.value && this.editor._internal.editorActor.send({
       type: "update value",
       value: this.props.value
     }), this.props.editorRef !== prevProps.editorRef && this.props.editorRef && (this.props.editorRef.current = this));
   }
   setEditable = (editable) => {
-    this.editable = {
-      ...this.editable,
+    this.editor.editable = {
+      ...this.editor.editable,
       ...editable
     };
   };
-  getValue = () => {
-    if (this.editable)
-      return this.editable.getValue();
-  };
   render() {
     const legacyPatches = this.props.editor ? void 0 : this.props.incomingPatches$ ?? this.props.patches$;
     return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-      legacyPatches ? /* @__PURE__ */ jsxRuntime.jsx(RoutePatchesObservableToEditorActor, { editorActor: this.editorActor, patches$: legacyPatches }) : null,
-      /* @__PURE__ */ jsxRuntime.jsx(EditorActorContext.Provider, { value: this.editorActor, children: /* @__PURE__ */ jsxRuntime.jsx(slateReact.Slate, { editor: this.slateEditor.instance, initialValue: this.slateEditor.initialValue, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsxRuntime.jsxs(PortableTextEditorSelectionProvider, { editorActor: this.editorActor, children: [
-        /* @__PURE__ */ jsxRuntime.jsx(Synchronizer, { editorActor: this.editorActor, getValue: this.getValue, onChange: (change) => {
-          this.props.editor || this.props.onChange(change), this.change$.next(change);
-        } }),
-        this.props.children
-      ] }) }) }) })
+      legacyPatches ? /* @__PURE__ */ jsxRuntime.jsx(RoutePatchesObservableToEditorActor, { editorActor: this.editor._internal.editorActor, patches$: legacyPatches }) : null,
+      /* @__PURE__ */ jsxRuntime.jsx(RouteEventsToChanges, { editorActor: this.editor._internal.editorActor, onChange: (change) => {
+        this.props.editor || this.props.onChange(change), this.change$.next(change);
+      } }),
+      /* @__PURE__ */ jsxRuntime.jsx(Synchronizer, { editorActor: this.editor._internal.editorActor, getValue: this.editor.editable.getValue, portableTextEditor: this, slateEditor: this.editor._internal.slateEditor.instance }),
+      /* @__PURE__ */ jsxRuntime.jsx(EditorActorContext.Provider, { value: this.editor._internal.editorActor, children: /* @__PURE__ */ jsxRuntime.jsx(slateReact.Slate, { editor: this.editor._internal.slateEditor.instance, initialValue: this.editor._internal.slateEditor.initialValue, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionProvider, { editorActor: this.editor._internal.editorActor, children: this.props.children }) }) }) })
     ] });
   }
   // Static API methods
@@ -6157,7 +6123,80 @@ function RoutePatchesObservableToEditorActor(props) {
     return () => {
       subscription.unsubscribe();
     };
-  }, t1 = [props.editorActor, props.patches$], $[0] = props.editorActor, $[1] = props.patches$, $[2] = t0, $[3] = t1) : (t0 = $[2], t1 = $[3]), react.useEffect(t0, t1), null;
+  }, t1 = [props.editorActor, props.patches$], $[0] = props.editorActor, $[1] = props.patches$, $[2] = t0, $[3] = t1) : (t0 = $[2], t1 = $[3]), React.useEffect(t0, t1), null;
+}
+function RouteEventsToChanges(props) {
+  const $ = reactCompilerRuntime.c(6);
+  let t0;
+  $[0] !== props ? (t0 = (change) => props.onChange(change), $[0] = props, $[1] = t0) : t0 = $[1];
+  const handleChange = useEffectEvent.useEffectEvent(t0);
+  let t1, t2;
+  return $[2] !== handleChange || $[3] !== props.editorActor ? (t1 = () => {
+    debug$4("Subscribing to editor changes");
+    const sub = props.editorActor.on("*", (event) => {
+      bb5: switch (event.type) {
+        case "patch": {
+          handleChange(event);
+          break bb5;
+        }
+        case "loading": {
+          handleChange({
+            type: "loading",
+            isLoading: !0
+          });
+          break bb5;
+        }
+        case "done loading": {
+          handleChange({
+            type: "loading",
+            isLoading: !1
+          });
+          break bb5;
+        }
+        case "focused": {
+          handleChange({
+            type: "focus",
+            event: event.event
+          });
+          break bb5;
+        }
+        case "value changed": {
+          handleChange({
+            type: "value",
+            value: event.value
+          });
+          break bb5;
+        }
+        case "invalid value": {
+          handleChange({
+            type: "invalidValue",
+            resolution: event.resolution,
+            value: event.value
+          });
+          break bb5;
+        }
+        case "error": {
+          handleChange({
+            ...event,
+            level: "warning"
+          });
+          break bb5;
+        }
+        case "annotation.add":
+        case "annotation.remove":
+        case "annotation.toggle":
+        case "focus":
+        case "patches":
+        case "readOnly toggled":
+          break bb5;
+        default:
+          handleChange(event);
+      }
+    });
+    return () => {
+      debug$4("Unsubscribing to changes"), sub.unsubscribe();
+    };
+  }, t2 = [props.editorActor, handleChange], $[2] = handleChange, $[3] = props.editorActor, $[4] = t1, $[5] = t2) : (t1 = $[4], t2 = $[5]), React.useEffect(t1, t2), null;
 }
 const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
@@ -6169,22 +6208,22 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     renderChild,
     renderDecorator,
     renderAnnotation
-  } = props, spanRef = react.useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = react.useState(!1), [selected, setSelected] = react.useState(!1), block = children.props.parent, path = react.useMemo(() => block ? [{
+  } = props, spanRef = React.useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = React.useState(!1), [selected, setSelected] = React.useState(!1), block = children.props.parent, path = React.useMemo(() => block ? [{
     _key: block?._key
   }, "children", {
     _key: leaf._key
-  }] : [], [block, leaf._key]), decoratorValues = react.useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = react.useMemo(() => uniq__default.default((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = react.useMemo(() => annotationMarks.map((mark_0) => !decoratorValues.includes(mark_0) && block?.markDefs?.find((def) => def._key === mark_0)).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
-  react.useEffect(() => {
+  }] : [], [block, leaf._key]), decoratorValues = React.useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = React.useMemo(() => uniq__default.default((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = React.useMemo(() => annotationMarks.map((mark_0) => !decoratorValues.includes(mark_0) && block?.markDefs?.find((def) => def._key === mark_0)).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
+  React.useEffect(() => {
     if (!shouldTrackSelectionAndFocus) {
       setFocused(!1);
       return;
     }
     const sel = PortableTextEditor.getSelection(portableTextEditor);
-    sel && isEqual__default.default(sel.focus.path, path) && PortableTextEditor.isCollapsedSelection(portableTextEditor) && react.startTransition(() => {
+    sel && isEqual__default.default(sel.focus.path, path) && PortableTextEditor.isCollapsedSelection(portableTextEditor) && React.startTransition(() => {
       setFocused(!0);
     });
   }, [shouldTrackSelectionAndFocus, path, portableTextEditor]);
-  const setSelectedFromRange = react.useCallback(() => {
+  const setSelectedFromRange = React.useCallback(() => {
     if (!shouldTrackSelectionAndFocus)
       return;
     debug$3("Setting selection and focus from range");
@@ -6199,7 +6238,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     } else
       setSelected(!1);
   }, [shouldTrackSelectionAndFocus]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     if (!shouldTrackSelectionAndFocus)
       return;
     const onBlur = editorActor.on("blur", () => {
@@ -6213,8 +6252,8 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     return () => {
       onBlur.unsubscribe(), onFocus.unsubscribe(), onSelection.unsubscribe();
     };
-  }, [editorActor, path, portableTextEditor, setSelectedFromRange, shouldTrackSelectionAndFocus]), react.useEffect(() => setSelectedFromRange(), [setSelectedFromRange]);
-  const content = react.useMemo(() => {
+  }, [editorActor, path, portableTextEditor, setSelectedFromRange, shouldTrackSelectionAndFocus]), React.useEffect(() => setSelectedFromRange(), [setSelectedFromRange]);
+  const content = React.useMemo(() => {
     let returnedChildren = children;
     if (slate.Text.isText(leaf) && leaf._type === schemaTypes.span.name && (marks.forEach((mark_1) => {
       const schemaType = schemaTypes.decorators.find((dec_0) => dec_0.value === mark_1);
@@ -6280,7 +6319,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     }
     return returnedChildren;
   }, [annotations, block, children, focused, leaf, marks, path, renderAnnotation, renderChild, renderDecorator, schemaTypes.annotations, schemaTypes.decorators, schemaTypes.span, selected]);
-  return react.useMemo(() => /* @__PURE__ */ jsxRuntime.jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
+  return React.useMemo(() => /* @__PURE__ */ jsxRuntime.jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
 const debug$2 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
@@ -6593,7 +6632,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   pointerEvents: "none",
   left: 0,
   right: 0
-}, PortableTextEditable = react.forwardRef(function(props, forwardedRef) {
+}, PortableTextEditable = React.forwardRef(function(props, forwardedRef) {
   const {
     hotkeys,
     onBlur,
@@ -6614,19 +6653,17 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     scrollSelectionIntoView,
     spellCheck,
     ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), ref = react.useRef(null), [editableElement, setEditableElement] = react.useState(null), [hasInvalidValue, setHasInvalidValue] = react.useState(!1), [rangeDecorationState, setRangeDecorationsState] = react.useState([]);
-  react.useImperativeHandle(forwardedRef, () => ref.current);
-  const rangeDecorationsRef = react.useRef(rangeDecorations), editorActor = react.useContext(EditorActorContext), readOnly = react$1.useSelector(editorActor, (s) => s.context.readOnly), {
-    schemaTypes
-  } = portableTextEditor, slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name;
-  react.useMemo(() => {
+  } = props, portableTextEditor = usePortableTextEditor(), ref = React.useRef(null), [editableElement, setEditableElement] = React.useState(null), [hasInvalidValue, setHasInvalidValue] = React.useState(!1), [rangeDecorationState, setRangeDecorationsState] = React.useState([]);
+  React.useImperativeHandle(forwardedRef, () => ref.current);
+  const rangeDecorationsRef = React.useRef(rangeDecorations), editorActor = React.useContext(EditorActorContext), readOnly = react.useSelector(editorActor, (s) => s.context.readOnly), schemaTypes = react.useSelector(editorActor, (s_0) => s_0.context.schema), slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name;
+  React.useMemo(() => {
     const withInsertData = createWithInsertData(editorActor, schemaTypes);
     if (readOnly)
       return debug("Editable is in read only mode"), withInsertData(slateEditor);
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
     return debug("Editable is in edit mode"), withInsertData(withHotKeys(slateEditor));
   }, [editorActor, hotkeys, portableTextEditor, readOnly, schemaTypes, slateEditor]);
-  const renderElement = react.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(Element, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck }), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = react.useCallback((lProps) => {
+  const renderElement = React.useCallback((eProps) => /* @__PURE__ */ jsxRuntime.jsx(Element, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck }), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = React.useCallback((lProps) => {
     if (lProps.leaf._type === "span") {
       let rendered = /* @__PURE__ */ jsxRuntime.jsx(Leaf, { ...lProps, editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });
       if (renderPlaceholder && lProps.leaf.placeholder && lProps.text.text === "")
@@ -6640,7 +6677,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       })), rendered;
     }
     return lProps.children;
-  }, [editorActor, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder, schemaTypes]), restoreSelectionFromProps = react.useCallback(() => {
+  }, [editorActor, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder, schemaTypes]), restoreSelectionFromProps = React.useCallback(() => {
     if (propsSelection) {
       debug(`Selection from props ${JSON.stringify(propsSelection)}`);
       const normalizedSelection = normalizeSelection(propsSelection, fromSlateValue(slateEditor.children, blockTypeName));
@@ -6653,7 +6690,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
         }), slateEditor.onChange());
       }
     }
-  }, [blockTypeName, editorActor, propsSelection, slateEditor]), syncRangeDecorations = react.useCallback((operation) => {
+  }, [blockTypeName, editorActor, propsSelection, slateEditor]), syncRangeDecorations = React.useCallback((operation) => {
     if (rangeDecorations && rangeDecorations.length > 0) {
       const newSlateRanges = [];
       if (rangeDecorations.forEach((rangeDecorationItem) => {
@@ -6686,7 +6723,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     }
     setRangeDecorationsState((rangeDecorationState_0) => rangeDecorationState_0.length > 0 ? [] : rangeDecorationState_0);
   }, [portableTextEditor, rangeDecorations, schemaTypes, slateEditor]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     const onReady = editorActor.on("ready", () => {
       restoreSelectionFromProps();
     }), onInvalidValue = editorActor.on("invalid value", () => {
@@ -6697,21 +6734,21 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     return () => {
       onReady.unsubscribe(), onInvalidValue.unsubscribe(), onValueChanged.unsubscribe();
     };
-  }, [editorActor, restoreSelectionFromProps]), react.useEffect(() => {
+  }, [editorActor, restoreSelectionFromProps]), React.useEffect(() => {
     propsSelection && !hasInvalidValue && restoreSelectionFromProps();
   }, [hasInvalidValue, propsSelection, restoreSelectionFromProps]);
-  const [syncedRangeDecorations, setSyncedRangeDecorations] = react.useState(!1);
-  react.useEffect(() => {
+  const [syncedRangeDecorations, setSyncedRangeDecorations] = React.useState(!1);
+  React.useEffect(() => {
     syncedRangeDecorations || (setSyncedRangeDecorations(!0), syncRangeDecorations());
-  }, [syncRangeDecorations, syncedRangeDecorations]), react.useEffect(() => {
+  }, [syncRangeDecorations, syncedRangeDecorations]), React.useEffect(() => {
     isEqual__default.default(rangeDecorations, rangeDecorationsRef.current) || syncRangeDecorations(), rangeDecorationsRef.current = rangeDecorations;
-  }, [rangeDecorations, syncRangeDecorations]), react.useEffect(() => {
+  }, [rangeDecorations, syncRangeDecorations]), React.useEffect(() => {
     const teardown = withSyncRangeDecorations(slateEditor, syncRangeDecorations);
     return () => teardown();
   }, [slateEditor, syncRangeDecorations]);
-  const handleCopy = react.useCallback((event) => {
+  const handleCopy = React.useCallback((event) => {
     onCopy && onCopy(event) !== void 0 && event.preventDefault();
-  }, [onCopy]), handlePaste = react.useCallback((event_0) => {
+  }, [onCopy]), handlePaste = React.useCallback((event_0) => {
     const value_0 = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(value_0, slateEditor.selection, schemaTypes)?.focus.path || [], onPasteResult = onPaste?.({
       event: event_0,
       value: value_0,
@@ -6736,7 +6773,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       },
       editor: slateEditor
     })), debug("No result from custom paste handler, pasting normally");
-  }, [editorActor, onPaste, portableTextEditor, schemaTypes, slateEditor]), handleOnFocus = react.useCallback((event_1) => {
+  }, [editorActor, onPaste, portableTextEditor, schemaTypes, slateEditor]), handleOnFocus = React.useCallback((event_1) => {
     if (onFocus && onFocus(event_1), !event_1.isDefaultPrevented()) {
       const selection = PortableTextEditor.getSelection(portableTextEditor);
       selection === null && (slate.Transforms.select(slateEditor, slate.Editor.start(slateEditor, [])), slateEditor.onChange()), editorActor.send({
@@ -6749,20 +6786,20 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
         selection
       });
     }
-  }, [editorActor, onFocus, portableTextEditor, slateEditor]), handleClick = react.useCallback((event_2) => {
+  }, [editorActor, onFocus, portableTextEditor, slateEditor]), handleClick = React.useCallback((event_2) => {
     onClick && onClick(event_2);
     const focusBlockPath = slateEditor.selection ? slateEditor.selection.focus.path.slice(0, 1) : void 0, focusBlock = focusBlockPath ? slate.Node.descendant(slateEditor, focusBlockPath) : void 0, [_, lastNodePath] = slate.Node.last(slateEditor, []), lastBlockPath = lastNodePath.slice(0, 1), lastNodeFocused = focusBlockPath ? slate.Path.equals(lastBlockPath, focusBlockPath) : !1, lastBlockIsVoid = focusBlock ? !slateEditor.isTextBlock(focusBlock) : !1;
     slateEditor.selection && slate.Range.isCollapsed(slateEditor.selection) && lastNodeFocused && lastBlockIsVoid && (slate.Transforms.insertNodes(slateEditor, slateEditor.pteCreateTextBlock({
       decorators: []
     })), slateEditor.onChange());
-  }, [onClick, slateEditor]), handleOnBlur = react.useCallback((event_3) => {
+  }, [onClick, slateEditor]), handleOnBlur = React.useCallback((event_3) => {
     onBlur && onBlur(event_3), event_3.isPropagationStopped() || editorActor.send({
       type: "blur",
       event: event_3
     });
-  }, [editorActor, onBlur]), handleOnBeforeInput = react.useCallback((event_4) => {
+  }, [editorActor, onBlur]), handleOnBeforeInput = React.useCallback((event_4) => {
     onBeforeInput && onBeforeInput(event_4);
-  }, [onBeforeInput]), validateSelection = react.useCallback(() => {
+  }, [onBeforeInput]), validateSelection = React.useCallback(() => {
     if (!slateEditor.selection)
       return;
     const root = slateReact.ReactEditor.findDocumentOrShadowRoot(slateEditor), {
@@ -6781,7 +6818,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       debug("Could not resolve selection, selecting top document"), slate.Transforms.deselect(slateEditor), slateEditor.children.length > 0 && slate.Transforms.select(slateEditor, [0, 0]), slateEditor.onChange();
     }
   }, [ref, slateEditor]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     if (editableElement) {
       const mutationObserver = new MutationObserver(validateSelection);
       return mutationObserver.observe(editableElement, {
@@ -6795,14 +6832,14 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       };
     }
   }, [validateSelection, editableElement]);
-  const handleKeyDown = react.useCallback((event_5) => {
+  const handleKeyDown = React.useCallback((event_5) => {
     props.onKeyDown && props.onKeyDown(event_5), event_5.isDefaultPrevented() || slateEditor.pteWithHotKeys(event_5);
-  }, [props, slateEditor]), scrollSelectionIntoViewToSlate = react.useMemo(() => {
+  }, [props, slateEditor]), scrollSelectionIntoViewToSlate = React.useMemo(() => {
     if (scrollSelectionIntoView !== void 0)
       return scrollSelectionIntoView === null ? noop__default.default : (_editor, domRange) => {
         scrollSelectionIntoView(portableTextEditor, domRange);
       };
-  }, [portableTextEditor, scrollSelectionIntoView]), decorate = react.useCallback(([, path_0]) => {
+  }, [portableTextEditor, scrollSelectionIntoView]), decorate = React.useCallback(([, path_0]) => {
     if (isEqualToEmptyEditor(slateEditor.children, schemaTypes))
       return [{
         anchor: {
@@ -6829,7 +6866,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     }) || slate.Range.includes(item, path_0));
     return result_1.length > 0 ? result_1 : [];
   }, [slateEditor, schemaTypes, rangeDecorationState]);
-  return react.useEffect(() => {
+  return React.useEffect(() => {
     ref.current = slateReact.ReactEditor.toDOMNode(slateEditor, slateEditor), setEditableElement(ref.current);
   }, [slateEditor, ref]), portableTextEditor ? hasInvalidValue ? null : /* @__PURE__ */ jsxRuntime.jsx(
     slateReact.Editable,
@@ -6854,45 +6891,55 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   ) : null;
 });
 PortableTextEditable.displayName = "ForwardRef(PortableTextEditable)";
-function useEditor(config) {
-  const $ = reactCompilerRuntime.c(21), t0 = config.keyGenerator ?? defaultKeyGenerator;
-  let t1;
-  $[0] !== config.schema || $[1] !== config.schemaDefinition ? (t1 = config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : getPortableTextMemberSchemaTypes(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), $[0] = config.schema, $[1] = config.schemaDefinition, $[2] = t1) : t1 = $[2];
+const EditorContext = React__default.default.createContext(void 0);
+function EditorProvider(props) {
+  const $ = reactCompilerRuntime.c(30), editor = useEditor(props.config), editorActor = editor._internal.editorActor, slateEditor = editor._internal.slateEditor, editable = editor.editable;
+  let t0, t1;
+  $[0] !== editor ? (t1 = new PortableTextEditor({
+    editor
+  }), $[0] = editor, $[1] = t1) : t1 = $[1], t0 = t1;
+  const portableTextEditor = t0;
   let t2;
-  $[3] !== config.behaviors || $[4] !== config.initialValue || $[5] !== t0 || $[6] !== t1 ? (t2 = {
-    input: {
-      behaviors: config.behaviors,
-      keyGenerator: t0,
-      schema: t1,
-      value: config.initialValue
-    }
-  }, $[3] = config.behaviors, $[4] = config.initialValue, $[5] = t0, $[6] = t1, $[7] = t2) : t2 = $[7];
-  const editorActor = react$1.useActorRef(editorMachine, t2);
+  $[2] !== portableTextEditor.change$ ? (t2 = (change) => {
+    portableTextEditor.change$.next(change);
+  }, $[2] = portableTextEditor.change$, $[3] = t2) : t2 = $[3];
   let t3;
-  $[8] !== editorActor ? (t3 = createSlateEditor({
-    editorActor
-  }), $[8] = editorActor, $[9] = t3) : t3 = $[9];
-  const slateEditor = t3, readOnly = react$1.useSelector(editorActor, _temp);
-  let t4, t5;
-  $[10] !== editorActor ? (t4 = (event) => {
-    editorActor.send(event);
-  }, t5 = (event_0, listener) => editorActor.on(event_0, listener), $[10] = editorActor, $[11] = t4, $[12] = t5) : (t4 = $[11], t5 = $[12]);
+  $[4] !== editorActor || $[5] !== t2 ? (t3 = /* @__PURE__ */ jsxRuntime.jsx(RouteEventsToChanges, { editorActor, onChange: t2 }), $[4] = editorActor, $[5] = t2, $[6] = t3) : t3 = $[6];
+  let t4;
+  $[7] !== editable.getValue || $[8] !== editorActor || $[9] !== portableTextEditor || $[10] !== slateEditor.instance ? (t4 = /* @__PURE__ */ jsxRuntime.jsx(Synchronizer, { editorActor, getValue: editable.getValue, portableTextEditor, slateEditor: slateEditor.instance }), $[7] = editable.getValue, $[8] = editorActor, $[9] = portableTextEditor, $[10] = slateEditor.instance, $[11] = t4) : t4 = $[11];
+  let t5;
+  $[12] !== editorActor || $[13] !== props.children ? (t5 = /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorSelectionProvider, { editorActor, children: props.children }), $[12] = editorActor, $[13] = props.children, $[14] = t5) : t5 = $[14];
   let t6;
-  $[13] !== editorActor || $[14] !== slateEditor ? (t6 = {
-    editorActor,
-    slateEditor
-  }, $[13] = editorActor, $[14] = slateEditor, $[15] = t6) : t6 = $[15];
+  $[15] !== portableTextEditor || $[16] !== t5 ? (t6 = /* @__PURE__ */ jsxRuntime.jsx(PortableTextEditorContext.Provider, { value: portableTextEditor, children: t5 }), $[15] = portableTextEditor, $[16] = t5, $[17] = t6) : t6 = $[17];
   let t7;
-  return $[16] !== readOnly || $[17] !== t4 || $[18] !== t5 || $[19] !== t6 ? (t7 = {
-    send: t4,
-    on: t5,
-    readOnly,
-    _internal: t6
-  }, $[16] = readOnly, $[17] = t4, $[18] = t5, $[19] = t6, $[20] = t7) : t7 = $[20], t7;
+  $[18] !== slateEditor.initialValue || $[19] !== slateEditor.instance || $[20] !== t6 ? (t7 = /* @__PURE__ */ jsxRuntime.jsx(slateReact.Slate, { editor: slateEditor.instance, initialValue: slateEditor.initialValue, children: t6 }), $[18] = slateEditor.initialValue, $[19] = slateEditor.instance, $[20] = t6, $[21] = t7) : t7 = $[21];
+  let t8;
+  $[22] !== editorActor || $[23] !== t7 ? (t8 = /* @__PURE__ */ jsxRuntime.jsx(EditorActorContext.Provider, { value: editorActor, children: t7 }), $[22] = editorActor, $[23] = t7, $[24] = t8) : t8 = $[24];
+  let t9;
+  return $[25] !== editor || $[26] !== t3 || $[27] !== t4 || $[28] !== t8 ? (t9 = /* @__PURE__ */ jsxRuntime.jsxs(EditorContext.Provider, { value: editor, children: [
+    t3,
+    t4,
+    t8
+  ] }), $[25] = editor, $[26] = t3, $[27] = t4, $[28] = t8, $[29] = t9) : t9 = $[29], t9;
+}
+function useEditorContext() {
+  const editor = React__default.default.useContext(EditorContext);
+  if (!editor)
+    throw new Error("No Editor set. Use EditorProvider to set one.");
+  return editor;
 }
-function _temp(s) {
-  return s.context.readOnly;
+function EditorEventListener(props) {
+  const $ = reactCompilerRuntime.c(4), editor = useEditorContext(), on = useEffectEvent.useEffectEvent(props.on);
+  let t0, t1;
+  return $[0] !== editor || $[1] !== on ? (t0 = () => {
+    const subscription = editor.on("*", on);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, t1 = [editor, on], $[0] = editor, $[1] = on, $[2] = t0, $[3] = t1) : (t0 = $[2], t1 = $[3]), React.useEffect(t0, t1), null;
 }
+exports.EditorEventListener = EditorEventListener;
+exports.EditorProvider = EditorProvider;
 exports.PortableTextEditable = PortableTextEditable;
 exports.PortableTextEditor = PortableTextEditor;
 exports.coreBehavior = coreBehavior;
@@ -6904,6 +6951,7 @@ exports.defineSchema = defineSchema;
 exports.editorMachine = editorMachine;
 exports.keyGenerator = defaultKeyGenerator;
 exports.useEditor = useEditor;
+exports.useEditorContext = useEditorContext;
 exports.usePortableTextEditor = usePortableTextEditor;
 exports.usePortableTextEditorSelection = usePortableTextEditorSelection;
 //# sourceMappingURL=index.js.map