@portabletext/editor 1.27.0 → 1.30.0

package/lib/_chunks-cjs/plugin.event-listener.cjs

@@ -1,5 +1,5 @@
 "use strict";
-var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), jsxRuntime = require("react/jsx-runtime"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$f = require("debug"), slate = require("slate"), xstate = require("xstate"), isEqual = require("lodash/isEqual.js"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), startCase = require("lodash.startcase"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), util_isEmptyTextBlock = require("./util.is-empty-text-block.cjs"), behavior_core = require("./behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), rxjs = require("rxjs");
+var reactCompilerRuntime = require("react-compiler-runtime"), React = require("react"), useEffectEvent = require("use-effect-event"), jsxRuntime = require("react/jsx-runtime"), slateReact = require("slate-react"), react = require("@xstate/react"), debug$f = require("debug"), slate = require("slate"), xstate = require("xstate"), isEqual = require("lodash/isEqual.js"), patches = require("@portabletext/patches"), types = require("@sanity/types"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), uniq = require("lodash/uniq.js"), parseBlocks = require("./parse-blocks.cjs"), util_sliceBlocks = require("./util.slice-blocks.cjs"), blockTools = require("@portabletext/block-tools"), toHtml = require("@portabletext/to-html"), schema = require("@sanity/schema"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), startCase = require("lodash.startcase"), selector_isAtTheStartOfBlock = require("./selector.is-at-the-start-of-block.cjs"), util_isEmptyTextBlock = require("./util.is-empty-text-block.cjs"), behavior_core = require("./behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), rxjs = require("rxjs");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
@@ -2214,83 +2214,7 @@ const converterJson = {
       reason: "No application/x-portable-text Converter found"
     };
   }
-};
-function isTypedObject(object) {
-  return isRecord(object) && typeof object._type == "string";
-}
-function isRecord(value) {
-  return !!value && (typeof value == "object" || typeof value == "function");
-}
-function parseBlock({
-  context,
-  block,
-  options
-}) {
-  if (!isTypedObject(block) || block._type !== context.schema.block.name && !context.schema.blockObjects.some((blockObject) => blockObject.name === block._type))
-    return;
-  if (block._type !== context.schema.block.name) {
-    const _key = options.refreshKeys ? context.keyGenerator() : typeof block._key == "string" ? block._key : context.keyGenerator();
-    return {
-      ...block,
-      _key
-    };
-  }
-  if (!types.isPortableTextTextBlock(block))
-    return {
-      _type: context.schema.block.name,
-      _key: options.refreshKeys ? context.keyGenerator() : typeof block._key == "string" ? block._key : context.keyGenerator(),
-      children: [{
-        _key: context.keyGenerator(),
-        _type: context.schema.span.name,
-        text: "",
-        marks: []
-      }],
-      markDefs: [],
-      style: context.schema.styles[0].value
-    };
-  const markDefKeyMap = /* @__PURE__ */ new Map(), markDefs = (block.markDefs ?? []).flatMap((markDef) => {
-    if (context.schema.annotations.some((annotation) => annotation.name === markDef._type)) {
-      const _key = options.refreshKeys ? context.keyGenerator() : markDef._key;
-      return markDefKeyMap.set(markDef._key, _key), [{
-        ...markDef,
-        _key
-      }];
-    }
-    return [];
-  }), children = block.children.flatMap((child) => {
-    if (!isTypedObject(child))
-      return [];
-    if (child._type !== context.schema.span.name && !context.schema.inlineObjects.some((inlineObject) => inlineObject.name === child._type))
-      return [];
-    if (!types.isPortableTextSpan(child))
-      return [{
-        ...child,
-        _key: options.refreshKeys ? context.keyGenerator() : child._key
-      }];
-    const marks = (child.marks ?? []).flatMap((mark) => markDefKeyMap.has(mark) ? [markDefKeyMap.get(mark)] : context.schema.decorators.some((decorator) => decorator.value === mark) ? [mark] : []);
-    return [{
-      ...child,
-      _key: options.refreshKeys ? context.keyGenerator() : child._key,
-      marks
-    }];
-  }), parsedBlock = {
-    ...block,
-    _key: options.refreshKeys ? context.keyGenerator() : block._key,
-    children: children.length > 0 ? children : [{
-      _key: context.keyGenerator(),
-      _type: context.schema.span.name,
-      text: "",
-      marks: []
-    }],
-    markDefs
-  };
-  if (!context.schema.styles.find((style) => style.value === block.style)) {
-    const defaultStyle = context.schema.styles[0].value;
-    defaultStyle !== void 0 ? parsedBlock.style = defaultStyle : delete parsedBlock.style;
-  }
-  return context.schema.lists.find((list) => list.value === block.listItem) || (delete parsedBlock.listItem, delete parsedBlock.level), parsedBlock;
-}
-const converterPortableText = {
+}, converterPortableText = {
   mimeType: "application/x-portable-text",
   serialize: ({
     context,
@@ -2326,7 +2250,7 @@ const converterPortableText = {
         reason: "Data is not an array"
       };
     const parsedBlocks = blocks.flatMap((block) => {
-      const parsedBlock = parseBlock({
+      const parsedBlock = parseBlocks.parseBlock({
         context,
         block,
         options: {
@@ -3103,15 +3027,20 @@ function setPatch(editor, patch) {
         node: c
       });
     });
-  } else if (block && "value" in block) {
-    const newVal = patches.applyAll([block.value], [patch])[0];
-    return slate.Transforms.setNodes(editor, {
-      ...block,
-      value: newVal
-    }, {
-      at: blockPath
-    }), !0;
-  }
+  } else if (block && "value" in block)
+    if (patch.path.length > 1 && patch.path[1] !== "children") {
+      const newVal = patches.applyAll(block.value, [{
+        ...patch,
+        path: patch.path.slice(1)
+      }]);
+      slate.Transforms.setNodes(editor, {
+        ...block,
+        value: newVal
+      }, {
+        at: blockPath
+      });
+    } else
+      return !1;
   return debugState(editor, "after"), !0;
 }
 function unsetPatch(editor, patch) {
@@ -4793,6 +4722,13 @@ const blockSetBehaviorActionImplementation = ({
   action
 }) => {
   action.dataTransfer.setData(action.mimeType, action.data);
+}, deleteActionImplementation = ({
+  action
+}) => {
+  const range = toSlateRange(action.selection, action.editor);
+  if (!range)
+    throw new Error(`Failed to get Slate Range for selection ${JSON.stringify(action.selection)}`);
+  slate.select(action.editor, range), slate.deleteFragment(action.editor);
 }, insertBlockObjectActionImplementation = ({
   context,
   action
@@ -4848,67 +4784,64 @@ const blockSetBehaviorActionImplementation = ({
     return;
   const anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock) && anchorBlockPath[0] === focusBlockPath[0]) {
-    slate.Editor.withoutNormalizing(editor, () => {
-      if (!editor.selection)
-        return;
-      slate.Transforms.splitNodes(editor, {
-        at: editor.selection
-      });
-      const [nextNode, nextNodePath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
-        depth: 1
-      });
-      if (slate.Transforms.setSelection(editor, {
-        anchor: {
-          path: [...nextNodePath, 0],
-          offset: 0
-        },
-        focus: {
-          path: [...nextNodePath, 0],
-          offset: 0
-        }
-      }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.markDefs.length > 0) {
-        const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextNodePath);
-        for (const [child, childPath] of children) {
-          if (!editor.isTextSpan(child))
-            continue;
-          const marks = child.marks ?? [];
-          for (const mark of marks)
-            schema2.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
-          const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
-          isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
-            marks: newMarks
-          }, {
-            at: childPath
-          });
-        }
-        const newMarkDefs = nextNode.markDefs.map((markDef) => ({
-          ...markDef,
-          _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-        }));
-        isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
-          markDefs: newMarkDefs
+    slate.Transforms.splitNodes(editor, {
+      at: editor.selection
+    });
+    const [nextBlock, nextBlockPath] = slate.Editor.node(editor, slate.Path.next(focusBlockPath), {
+      depth: 1
+    }), nextChild = slate.Node.child(nextBlock, 0);
+    if (!editor.isTextSpan(nextChild) && slate.Transforms.insertNodes(editor, {
+      _key: context.keyGenerator(),
+      _type: "span",
+      text: "",
+      marks: []
+    }, {
+      at: [nextBlockPath[0], 0]
+    }), slate.Transforms.setSelection(editor, {
+      anchor: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      },
+      focus: {
+        path: [...nextBlockPath, 0],
+        offset: 0
+      }
+    }), editor.isTextBlock(nextBlock) && nextBlock.markDefs && nextBlock.markDefs.length > 0) {
+      const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(slate.Node.children(editor, focusBlockPath)).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextBlockPath);
+      for (const [child, childPath] of children) {
+        if (!editor.isTextSpan(child))
+          continue;
+        const marks = child.marks ?? [];
+        for (const mark of marks)
+          schema2.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+        const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
+        isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(editor, {
+          marks: newMarks
         }, {
-          at: nextNodePath,
-          match: (node) => editor.isTextBlock(node)
+          at: childPath
         });
       }
-    }), editor.onChange();
+      const newMarkDefs = nextBlock.markDefs.map((markDef) => ({
+        ...markDef,
+        _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+      }));
+      isEqual__default.default(nextBlock.markDefs, newMarkDefs) || slate.Transforms.setNodes(editor, {
+        markDefs: newMarkDefs
+      }, {
+        at: nextBlockPath,
+        match: (node) => editor.isTextBlock(node)
+      });
+    }
     return;
   }
   slate.Transforms.splitNodes(editor, {
     always: !0
   });
 }, insertSoftBreakActionImplementation = ({
-  context,
   action
 }) => {
-  insertBreakActionImplementation({
-    context,
-    action: {
-      ...action,
-      type: "insert.break"
-    }
-  });
+  slate.insertText(action.editor, `
+`);
 }, insertInlineObjectActionImplementation = ({
   context,
   action
@@ -4978,7 +4911,7 @@ const blockSetBehaviorActionImplementation = ({
   context,
   action
 }) => {
-  const parsedBlock = parseBlock({
+  const parsedBlock = parseBlocks.parseBlock({
     block: action.block,
     context,
     options: {
@@ -5060,6 +4993,7 @@ const blockSetBehaviorActionImplementation = ({
   }) => {
     slateReact.ReactEditor.focus(action.editor);
   },
+  delete: deleteActionImplementation,
   "delete.backward": ({
     action
   }) => {
@@ -5368,6 +5302,13 @@ function performDefaultAction({
       });
       break;
     }
+    case "delete": {
+      behaviorActionImplementations.delete({
+        context,
+        action
+      });
+      break;
+    }
     case "delete.backward": {
       behaviorActionImplementations["delete.backward"]({
         context,
@@ -6346,30 +6287,224 @@ class PortableTextEditor extends React.Component {
       /* @__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
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isActive = useEditorSelector(editor, selectors.getActiveAnnotations)
+   * ```
+   */
   static activeAnnotations = (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : [];
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isActive = useEditorSelector(editor, selectors.isActiveAnnotation(...))
+   * ```
+   */
   static isAnnotationActive = (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1;
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'annotation.add',
+   *  annotation: {
+   *    name: '...',
+   *    value: {...},
+   *  }
+   * })
+   * ```
+   */
   static addAnnotation = (editor, type, value) => editor.editable?.addAnnotation(type, value);
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'blur',
+   * })
+   * ```
+   */
   static blur = (editor) => {
     debug("Host blurred"), editor.editable?.blur();
   };
   static delete = (editor, selection, options) => editor.editable?.delete(selection, options);
   static findDOMNode = (editor, element) => editor.editable?.findDOMNode(element);
   static findByPath = (editor, path) => editor.editable?.findByPath(path) || [];
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'focus',
+   * })
+   * ```
+   */
   static focus = (editor) => {
     debug("Host requesting focus"), editor.editable?.focus();
   };
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const focusBlock = useEditorSelector(editor, selectors.getFocusBlock)
+   * ```
+   */
   static focusBlock = (editor) => editor.editable?.focusBlock();
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const focusChild = useEditorSelector(editor, selectors.getFocusChild)
+   * ```
+   */
   static focusChild = (editor) => editor.editable?.focusChild();
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const selection = useEditorSelector(editor, selectors.getSelection)
+   * ```
+   */
   static getSelection = (editor) => editor.editable ? editor.editable.getSelection() : null;
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const value = useEditorSelector(editor, selectors.getValue)
+   * ```
+   */
   static getValue = (editor) => editor.editable?.getValue();
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isActive = useEditorSelector(editor, selectors.isActiveStyle(...))
+   * ```
+   */
   static hasBlockStyle = (editor, blockStyle) => editor.editable?.hasBlockStyle(blockStyle);
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isActive = useEditorSelector(editor, selectors.isActiveListItem(...))
+   * ```
+   */
   static hasListStyle = (editor, listStyle) => editor.editable?.hasListStyle(listStyle);
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isSelectionCollapsed = useEditorSelector(editor, selectors.isSelectionCollapsed)
+   * ```
+   */
   static isCollapsedSelection = (editor) => editor.editable?.isCollapsedSelection();
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isSelectionExpanded = useEditorSelector(editor, selectors.isSelectionExpanded)
+   * ```
+   */
   static isExpandedSelection = (editor) => editor.editable?.isExpandedSelection();
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isActive = useEditorSelector(editor, selectors.isActiveDecorator(...))
+   * ```
+   */
   static isMarkActive = (editor, mark) => editor.editable?.isMarkActive(mark);
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'insert.span',
+   *  text: '...',
+   *  annotations: [{name: '...', value: {...}}],
+   *  decorators: ['...'],
+   * })
+   * editor.send({
+   *  type: 'insert.inline object',
+   *  inlineObject: {
+   *    name: '...',
+   *    value: {...},
+   *  },
+   * })
+   * ```
+   */
   static insertChild = (editor, type, value) => (debug("Host inserting child"), editor.editable?.insertChild(type, value));
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'insert.block object',
+   *  blockObject: {
+   *    name: '...',
+   *    value: {...},
+   *  },
+   *  placement: 'auto' | 'after' | 'before',
+   * })
+   * ```
+   */
   static insertBlock = (editor, type, value) => editor.editable?.insertBlock(type, value);
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'insert.break',
+   * })
+   * ```
+   */
   static insertBreak = (editor) => editor.editable?.insertBreak();
   static isVoid = (editor, element) => editor.editable?.isVoid(element);
   static isObjectPath = (_editor, path) => {
@@ -6378,15 +6513,87 @@ class PortableTextEditor extends React.Component {
     return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
   };
   static marks = (editor) => editor.editable?.marks();
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'select',
+   *  selection: {...},
+   * })
+   * ```
+   */
   static select = (editor, selection) => {
     debug("Host setting selection", selection), editor.editable?.select(selection);
   };
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'annotation.remove',
+   *  annotation: {
+   *    name: '...',
+   *  },
+   * })
+   * ```
+   */
   static removeAnnotation = (editor, type) => editor.editable?.removeAnnotation(type);
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'style.toggle',
+   *  style: '...',
+   * })
+   * ```
+   */
   static toggleBlockStyle = (editor, blockStyle) => (debug("Host is toggling block style"), editor.editable?.toggleBlockStyle(blockStyle));
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'list item.toggle',
+   *  listItem: '...',
+   * })
+   * ```
+   */
   static toggleList = (editor, listStyle) => editor.editable?.toggleList(listStyle);
+  /**
+   * @deprecated
+   * Use `editor.send(...)` instead
+   *
+   * ```
+   * const editor = useEditor()
+   * editor.send({
+   *  type: 'decorator.toggle',
+   *  decorator: '...',
+   * })
+   * ```
+   */
   static toggleMark = (editor, mark) => {
     debug("Host toggling mark", mark), editor.editable?.toggleMark(mark);
   };
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const selectedSlice = useEditorSelector(editor, selectors.getSelectedSlice)
+   * ```
+   */
   static getFragment = (editor) => (debug("Host getting fragment"), editor.editable?.getFragment());
   static undo = (editor) => {
     debug("Host undoing"), editor.editable?.undo();
@@ -6394,6 +6601,16 @@ class PortableTextEditor extends React.Component {
   static redo = (editor) => {
     debug("Host redoing"), editor.editable?.redo();
   };
+  /**
+   * @deprecated
+   * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
+   *
+   * ```
+   * import * as selectors from '@portabletext/editor/selectors'
+   * const editor = useEditor()
+   * const isOverlapping = useEditorSelector(editor, selectors.isOverlappingSelection(selectionB))
+   * ```
+   */
   static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
 function RoutePatchesObservableToEditorActor(props) {