@portabletext/editor 7.9.0 → 7.10.1

package/lib/index.js

@@ -3,22 +3,23 @@ import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import React, { createContext, useContext, useRef, useEffect, useLayoutEffect, useState, useReducer, useCallback, memo, forwardRef, useMemo, Component, useSyncExternalStore, startTransition } from "react";
 import { serializePath, isKeyedSegment, getNode, getParent, parentPath, getChildren, getNodeChildren } from "./_chunks-es/get-parent.js";
-import { isPath, getLeaf, isRange, isPoint, isObject, isLeafObject, getAncestor, pathContains, getSpan, isBeforePoint, getText, rangeIntersects, getTextBlock, getUnionSchema, getFirstChild } from "./_chunks-es/get-first-child.js";
-import { rangeEdges, isTextBlockNode, isBackwardRange, hasNode, getNodes, isAncestorPath, isEditableContainer, getSibling, isInline, isObject as isObject$1, isSpanNode, isBlock, getEnclosingBlock, getAncestors, getPathSubSchema, getBlock, resolveContainerAt, comparePaths, getEnclosingContainer, comparePoints$1 as comparePoints, isAfterPoint } from "./_chunks-es/get-path-sub-schema.js";
+import { isPath, getLeaf, isRange, isPoint, isObject, isLeafObject, getAncestor, pathContains, getSpan, isBeforePoint, getText, rangeIntersects, getTextBlock, getUnionSchema, getFirstChild, getContainer } from "./_chunks-es/get-container.js";
+import { rangeEdges, isTextBlockNode, isBackwardRange, hasNode, getNodes, isAncestorPath, isEditableContainer, getSibling, isInline, isObject as isObject$1, isSpanNode, isBlock, getEnclosingBlock, getAncestors, getPathSubSchema, getBlock, resolveContainerAt, resolveChildEntryIndex, getEnclosingContainer, comparePoints$1 as comparePoints, comparePaths, isAfterPoint } from "./_chunks-es/get-path-sub-schema.js";
 import { isSpan, isTextBlock, getSubSchema, compileSchema } from "@portabletext/schema";
 import { defineSchema } from "@portabletext/schema";
 import scrollIntoView from "scroll-into-view-if-needed";
 import { createKeyboardShortcut, undo, redo, code, underline, italic as italic$1, bold as bold$1 } from "@portabletext/keyboard-shortcuts";
-import { rangesOverlap, getFocusInlineObject, getFocusTextBlock, getFocusSpan, getFragment, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, isSelectionCollapsed as isSelectionCollapsed$1, getFocusBlock, getSelectedBlocks, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getCaretWordSelection, getSelectionStartChild, getSelectionEndChild, getPreviousSpan, getNextSpan, getSelectionStartPoint, getSelectionEndPoint, getFocusBlockObject, getLastBlock, getFirstBlock, isAtTheEndOfBlock, isAtTheStartOfBlock, getRootAcceptedTypes, getMarkState, getFocusListBlock, getNextBlock, getPreviousBlock, getSelectedTextBlocks, isActiveDecorator, getFocusChild, getActiveAnnotations, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
+import { rangesOverlap, getFocusInlineObject, isSelectionCollapsed as isSelectionCollapsed$1, getFocusTextBlock, getFocusSpan, getFragment, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, getSelectedBlocks, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getCaretWordSelection, getSelectionStartChild, getSelectionStartPoint, getSelectionEndChild, getSelectionEndPoint, getPreviousSpan, getNextSpan, getFocusBlockObject, getLastBlock, getFirstBlock, isAtTheEndOfBlock, isAtTheStartOfBlock, getRootAcceptedTypes, getMarkState, getFocusListBlock, getNextBlock, getPreviousBlock, getSelectedTextBlocks, isActiveDecorator, getFocusChild, getActiveAnnotations, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
 import { isEqualSelectionPoints, blockOffsetToSpanSelectionPoint, getBlockKeyFromSelectionPoint, getBlockEndPoint, getBlockStartPoint, isSelectionCollapsed, defaultKeyGenerator, parseBlocks, parseBlock, isListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject } from "./_chunks-es/util.slice-blocks.js";
 import rawDebug from "debug";
-import { isEmptyTextBlock, getTextBlockText } from "./_chunks-es/util.is-empty-text-block.js";
+import { isEmptyTextBlock, isEqualSelections, getTextBlockText } from "./_chunks-es/util.is-equal-selections.js";
 import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
 import { setup, fromCallback, assign, and, assertEvent, enqueueActions, emit, not, raise as raise$1, createActor } from "xstate";
 import { htmlToPortableText } from "@portabletext/html";
 import { toHTML } from "@portabletext/to-html";
 import { markdownToPortableText, portableTextToMarkdown } from "@portabletext/markdown";
 import { applyAll, unset, set, insert, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
+import "xstate/guards";
 import { EditorContext as EditorContext$1 } from "./_chunks-es/use-editor.js";
 import { useEditor } from "./_chunks-es/use-editor.js";
 function getDomNode(editor, path2) {
@@ -1605,7 +1606,8 @@ function transformTextDiff(textDiff, op) {
     id
   } : null;
 }
-const RESOLVE_DELAY = 25, FLUSH_DELAY = 200, isDataTransfer = (value) => value?.constructor.name === "DataTransfer";
+const RESOLVE_DELAY = 25, FLUSH_DELAY = 200, debug$1 = (..._) => {
+}, isDataTransfer = (value) => value?.constructor.name === "DataTransfer";
 function createAndroidInputManager({
   editor,
   editorActor,
@@ -1642,6 +1644,7 @@ function createAndroidInputManager({
     const selectionRef = editor.snapshot.context.selection && rangeRef(editor, editor.snapshot.context.selection, {
       affinity: "forward"
     });
+    debug$1("flush", editor.pendingAction, editor.pendingDiffs);
     let scheduleSelectionChange = hasPendingDiffs(), diff2;
     for (; diff2 = editor.pendingDiffs?.[0]; ) {
       const range2 = targetRange(diff2);
@@ -2874,7 +2877,13 @@ const useChildren = (props) => {
   });
   return childContainer && childContainer !== parentContainer ? /* @__PURE__ */ jsx(ParentContainerContext, { value: childContainer, children: /* @__PURE__ */ jsx(NewPipelineContext.Provider, { value: !0, children: elements }) }) : /* @__PURE__ */ jsx(Fragment, { children: elements });
 }, EngineSelectorContext = createContext({}), refEquality = (a, b) => a === b;
-function useEngineSelector(selector, equalityFn = refEquality) {
+function useRegistrationsSelector(selector, equalityFn = refEquality) {
+  return useChannelSelector(selector, equalityFn, "registrations");
+}
+function useListIndexSelector(selector, equalityFn = refEquality) {
+  return useChannelSelector(selector, equalityFn, "listIndex");
+}
+function useChannelSelector(selector, equalityFn, channel) {
   const context = useContext(EngineSelectorContext);
   if (!context)
     throw new Error("The `useEngineSelector` hook must be used inside the <Engine> component's context.");
@@ -2882,36 +2891,32 @@ function useEngineSelector(selector, equalityFn = refEquality) {
     addEventListener
   } = context, editor = useEngineStatic(), genericSelector = useCallback(() => selector(editor), [editor, selector]), [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
   return useIsomorphicLayoutEffect(() => {
-    const unsubscribe = addEventListener(update);
+    const unsubscribe = addEventListener(update, channel);
     return update(), unsubscribe;
-  }, [addEventListener, update]), selectedState;
+  }, [addEventListener, update, channel]), selectedState;
 }
 function useSelectorContext() {
-  const eventListeners = useRef(/* @__PURE__ */ new Set()), deferredEventListeners = useRef(/* @__PURE__ */ new Set()), onChange = useCallback(() => {
+  const eventListeners = useRef(/* @__PURE__ */ new Set()), registrationListeners = useRef(/* @__PURE__ */ new Set()), listIndexListeners = useRef(/* @__PURE__ */ new Set()), onChange = useCallback((changed) => {
     eventListeners.current.forEach((listener) => {
       listener();
-    });
-  }, []), flushDeferred = useCallback(() => {
-    deferredEventListeners.current.forEach((listener) => {
+    }), changed.registrations && registrationListeners.current.forEach((listener) => {
       listener();
-    }), deferredEventListeners.current.clear();
-  }, []), addEventListener = useCallback((callbackProp) => (eventListeners.current.add(callbackProp), () => {
-    eventListeners.current.delete(callbackProp);
-  }), []);
+    }), changed.listIndex && listIndexListeners.current.forEach((listener) => {
+      listener();
+    });
+  }, []), addEventListener = useCallback((callbackProp, channel) => {
+    const listeners = channel === "registrations" ? registrationListeners.current : channel === "listIndex" ? listIndexListeners.current : eventListeners.current;
+    return listeners.add(callbackProp), () => {
+      listeners.delete(callbackProp);
+    };
+  }, []);
   return {
     selectorContext: useMemo(() => ({
-      addEventListener,
-      flushDeferred
-    }), [addEventListener, flushDeferred]),
+      addEventListener
+    }), [addEventListener]),
     onChange
   };
 }
-function useFlushDeferredSelectorsOnRender() {
-  const {
-    flushDeferred
-  } = useContext(EngineSelectorContext);
-  useIsomorphicLayoutEffect(flushDeferred);
-}
 const useEngine = () => {
   const {
     addEventListener
@@ -3094,10 +3099,8 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       const domSelection = getSelection(root2);
       if (activeElement === el2)
         state.latestElement = activeElement, editor.focused = !0;
-      else {
-        editor.focused = !1;
+      else if (editor.focused = !1, !readOnly)
         return;
-      }
       if (!domSelection)
         return deselect(editor);
       const {
@@ -3109,7 +3112,16 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           exactMatch: !1,
           suppressThrow: !0
         });
-        range2 && (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing() ? editor.select(range2) : androidInputManager?.handleUserSelect(range2));
+        if (range2)
+          if (!editor.composing && !androidInputManager?.hasPendingChanges() && !androidInputManager?.isFlushing()) {
+            if (editor.select(range2), domSelection.isCollapsed && anchorNode && anchorNode.nodeType === Node.ELEMENT_NODE)
+              try {
+                const canonicalRange = DOMEditor.toDOMRange(editor, range2);
+                domSelection.setBaseAndExtent(canonicalRange.startContainer, canonicalRange.startOffset, canonicalRange.startContainer, canonicalRange.startOffset);
+              } catch {
+              }
+          } else
+            androidInputManager?.handleUserSelect(range2);
       }
       readOnly && (!anchorNodeSelectable || !focusNodeInEditor) && deselect(editor);
     }
@@ -3470,7 +3482,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     };
   }, [scheduleOnDOMSelectionChange]);
   const decorations = decorate([editor, []]), decorateContext = useDecorateContext(decorate);
-  return useFlushDeferredSelectorsOnRender(), /* @__PURE__ */ jsx(ReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsx(DecorateContext.Provider, { value: decorateContext, children: /* @__PURE__ */ jsx(RestoreDOM, { node: ref, receivedUserInput, children: /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx(ReadOnlyContext.Provider, { value: readOnly, children: /* @__PURE__ */ jsx(DecorateContext.Provider, { value: decorateContext, children: /* @__PURE__ */ jsx(RestoreDOM, { node: ref, receivedUserInput, children: /* @__PURE__ */ jsx(
     "div",
     {
       role: readOnly ? void 0 : "textbox",
@@ -4046,6 +4058,33 @@ const debug = {
   syncValue: createDebugger("sync:value"),
   syncPatch: createDebugger("sync:patch")
 };
+function getPointAtCoordinates(editorEngine, coordinates) {
+  let domRange;
+  try {
+    const window2 = DOMEditor.getWindow(editorEngine);
+    if (window2.document.caretPositionFromPoint !== void 0) {
+      const position = window2.document.caretPositionFromPoint(coordinates.x, coordinates.y);
+      if (position)
+        try {
+          domRange = window2.document.createRange(), domRange.setStart(position.offsetNode, position.offset), domRange.setEnd(position.offsetNode, position.offset);
+        } catch {
+        }
+    } else window2.document.caretRangeFromPoint !== void 0 && (domRange = window2.document.caretRangeFromPoint(coordinates.x, coordinates.y) ?? void 0);
+  } catch {
+    return null;
+  }
+  if (!domRange)
+    return null;
+  try {
+    return DOMEditor.toEditorSelection(editorEngine, domRange, {
+      exactMatch: !1,
+      // It can still throw even with this option set to true
+      suppressThrow: !1
+    })?.focus ?? null;
+  } catch {
+    return null;
+  }
+}
 function isDragEvent(event) {
   return "dataTransfer" in event;
 }
@@ -4217,31 +4256,14 @@ function getEventPositionBlock({
 function getSelectionFromEvent(editor, event) {
   if (!event.target || !isDOMNode(event.target))
     return;
-  const window2 = DOMEditor.getWindow(editor);
-  let domRange;
-  if (window2.document.caretPositionFromPoint !== void 0) {
-    const position = window2.document.caretPositionFromPoint(event.clientX, event.clientY);
-    if (position)
-      try {
-        domRange = window2.document.createRange(), domRange.setStart(position.offsetNode, position.offset), domRange.setEnd(position.offsetNode, position.offset);
-      } catch {
-      }
-  } else if (window2.document.caretRangeFromPoint !== void 0)
-    domRange = window2.document.caretRangeFromPoint(event.clientX, event.clientY) ?? void 0;
-  else {
-    console.warn("Neither caretPositionFromPoint nor caretRangeFromPoint is supported");
-    return;
-  }
-  if (domRange)
-    try {
-      return DOMEditor.toEditorSelection(editor, domRange, {
-        exactMatch: !1,
-        // It can still throw even with this option set to true
-        suppressThrow: !1
-      });
-    } catch {
-      return;
-    }
+  const point2 = getPointAtCoordinates(editor, {
+    x: event.clientX,
+    y: event.clientY
+  });
+  return point2 ? {
+    anchor: point2,
+    focus: point2
+  } : void 0;
 }
 function isEventContainer(editorEngine, eventNode, eventPath) {
   return isEditor(eventNode) ? !0 : isEditableContainer(editorEngine.snapshot, eventNode, eventPath);
@@ -4260,6 +4282,7 @@ function getDragSelection({
   }))
     return dragSelection;
   const draggingCollapsedSelection = isSelectionCollapsed$1({
+    ...snapshot,
     context: {
       ...snapshot.context,
       selection: eventSelection
@@ -5518,7 +5541,7 @@ function RenderTextBlock(props) {
   const serializedPath = t2, selected = useIsSelectedContainer(serializedPath), focused = useIsFocusedContainer(serializedPath), dropPosition = useElementDropPosition(props.path);
   let t3;
   $[7] !== serializedPath ? (t3 = (editor) => getListIndexMap(editor).get(serializedPath), $[7] = serializedPath, $[8] = t3) : t3 = $[8];
-  const listIndex = useEngineSelector(t3), subSchema = useBlockSubSchema(props.path);
+  const listIndex = useListIndexSelector(t3), subSchema = useBlockSubSchema(props.path);
   let children = props.children;
   if (props.legacy.renderStyle && props.textBlock.style) {
     let t42;
@@ -5684,7 +5707,7 @@ function RenderElement(props) {
   const inlinePositionalOverride = t1;
   let t2;
   $[6] !== type ? (t2 = (engine) => [engine.containers.get(type), engine.blockObjects.get(type), engine.blockObjects.get("*"), engine.inlineObjects.get(type), engine.inlineObjects.get("*"), engine.textBlocks.get(type), engine.textBlocks.get("*")], $[6] = type, $[7] = t2) : t2 = $[7];
-  const [globalContainerConfig, globalBlockObjectConfig, globalBlockObjectCatchAll, globalInlineObjectConfig, globalInlineObjectCatchAll, textBlockConfig, textBlockCatchAll] = useEngineSelector(t2, tupleRefEqual);
+  const [globalContainerConfig, globalBlockObjectConfig, globalBlockObjectCatchAll, globalInlineObjectConfig, globalInlineObjectCatchAll, textBlockConfig, textBlockCatchAll] = useRegistrationsSelector(t2, tupleRefEqual);
   let t3;
   bb0: {
     if (blockPositionalOverride && "container" in blockPositionalOverride) {
@@ -5876,7 +5899,7 @@ function useSpanConfig(node, _path) {
   const positional = t0;
   let t1;
   $[3] !== node._type ? (t1 = (engine) => [engine.spans.get(node._type), engine.spans.get("*")], $[3] = node._type, $[4] = t1) : t1 = $[4];
-  const [globalSpan, globalSpanCatchAll] = useEngineSelector(t1, tupleRefEqual);
+  const [globalSpan, globalSpanCatchAll] = useRegistrationsSelector(t1, tupleRefEqual);
   return positional && "span" in positional ? positional.span.render === void 0 ? globalSpan ?? globalSpanCatchAll : positional : globalSpan ?? globalSpanCatchAll;
 }
 function RenderSpan(props) {
@@ -5893,7 +5916,7 @@ function RenderSpan(props) {
   }, parent) ? parent : void 0;
   let t2;
   $[3] !== block?.children || $[4] !== props.leaf._key ? (t2 = block?.children.find((_child) => _child._key === props.leaf._key), $[3] = block?.children, $[4] = props.leaf._key, $[5] = t2) : t2 = $[5];
-  const child = t2, subSchema = useBlockSubSchema(props.path), spanConfig = useSpanConfig(child ?? props.leaf), isInNewPipeline = useContext(NewPipelineContext);
+  const child = t2, subSchema = useBlockSubSchema(props.path), spanConfig = useSpanConfig(child ?? props.leaf, props.path), isInNewPipeline = useContext(NewPipelineContext);
   let t3;
   $[6] !== props.path ? (t3 = serializePath(props.path), $[6] = props.path, $[7] = t3) : t3 = $[7];
   const serializedPath = t3, focused = useIsFocusedLeaf(serializedPath), selected = useIsSelectedLeaf(serializedPath);
@@ -6135,15 +6158,19 @@ function validateSelection(editorEngine, editorElement) {
   if (!root || editorElement !== root.activeElement)
     return;
   const domSelection = DOMEditor.getWindow(editorEngine).getSelection();
-  if (!domSelection || domSelection.rangeCount === 0)
-    return;
-  const existingDOMRange = domSelection.getRangeAt(0);
-  try {
-    const newDOMRange = DOMEditor.toDOMRange(editorEngine, editorEngine.snapshot.context.selection);
-    (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug.selection("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
-  } catch {
-    debug.selection("Could not resolve selection, skipping DOM sync this tick");
-  }
+  if (!(!domSelection || domSelection.rangeCount === 0))
+    try {
+      const domEditorSelection = DOMEditor.toEditorSelection(editorEngine, domSelection, {
+        exactMatch: !1,
+        suppressThrow: !0
+      });
+      if (domEditorSelection && isEqualSelections(domEditorSelection, editorEngine.snapshot.context.selection))
+        return;
+      const newDOMRange = DOMEditor.toDOMRange(editorEngine, editorEngine.snapshot.context.selection);
+      debug.selection("DOM range out of sync, validating selection"), domSelection.removeAllRanges(), domSelection.addRange(newDOMRange);
+    } catch {
+      debug.selection("Could not resolve selection, skipping DOM sync this tick");
+    }
 }
 const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   const $ = c(179);
@@ -6742,7 +6769,11 @@ const Engine = (props) => {
     selectorContext,
     onChange: handleSelectorChange
   } = useSelectorContext(), onContextChange = useCallback(() => {
-    handleSelectorChange();
+    const pending = editor.selectorChannelsPending, registrations = pending.registrations, listIndex = pending.listIndex;
+    pending.registrations = !1, pending.listIndex = !1, handleSelectorChange({
+      registrations,
+      listIndex
+    });
   }, [editor, handleSelectorChange]);
   return useEffect(() => (editor.onContextChange = onContextChange, () => {
     editor.onContextChange = () => {
@@ -7686,6 +7717,87 @@ function transformRangeRef(ref, op, root) {
   });
   ref.current = path2, path2 == null && ref.unref();
 }
+function splitNodePath(path2) {
+  let nodePathEnd = path2.length;
+  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
+    nodePathEnd--;
+  return {
+    nodePath: path2.slice(0, nodePathEnd),
+    propertyPath: path2.slice(nodePathEnd)
+  };
+}
+function findNearestSpans(snapshot, path2) {
+  return {
+    previousSpan: findPreviousSpan(snapshot, path2),
+    nextSpan: findNextSpan(snapshot, path2)
+  };
+}
+function findNextSpan(snapshot, path2) {
+  const descendantSpan = firstSpanIn(snapshot, path2);
+  if (descendantSpan)
+    return descendantSpan;
+  let currentPath = path2;
+  for (; currentPath.length > 0; ) {
+    const parentPath2 = nodeParentPath(currentPath), siblings = getChildren(snapshot, parentPath2), index = resolveChildEntryIndex(snapshot.blockIndexMap, siblings, currentPath);
+    if (index !== -1)
+      for (let siblingIndex = index + 1; siblingIndex < siblings.length; siblingIndex++) {
+        const sibling = siblings[siblingIndex];
+        if (isSpan({
+          schema: snapshot.context.schema
+        }, sibling.node))
+          return {
+            node: sibling.node,
+            path: sibling.path
+          };
+        const siblingDescendantSpan = firstSpanIn(snapshot, sibling.path);
+        if (siblingDescendantSpan)
+          return siblingDescendantSpan;
+      }
+    currentPath = parentPath2;
+  }
+}
+function findPreviousSpan(snapshot, path2) {
+  let currentPath = path2;
+  for (; currentPath.length > 0; ) {
+    const parentPath2 = nodeParentPath(currentPath), siblings = getChildren(snapshot, parentPath2), index = resolveChildEntryIndex(snapshot.blockIndexMap, siblings, currentPath);
+    if (index !== -1)
+      for (let siblingIndex = index - 1; siblingIndex >= 0; siblingIndex--) {
+        const sibling = siblings[siblingIndex], siblingDescendantSpan = lastSpanIn(snapshot, sibling.path);
+        if (siblingDescendantSpan)
+          return siblingDescendantSpan;
+        if (isSpan({
+          schema: snapshot.context.schema
+        }, sibling.node))
+          return {
+            node: sibling.node,
+            path: sibling.path
+          };
+      }
+    currentPath = parentPath2;
+  }
+}
+function firstSpanIn(snapshot, path2) {
+  for (const entry of getNodes(snapshot, {
+    at: path2,
+    match: (node) => isSpan({
+      schema: snapshot.context.schema
+    }, node)
+  }))
+    return entry;
+}
+function lastSpanIn(snapshot, path2) {
+  for (const entry of getNodes(snapshot, {
+    at: path2,
+    match: (node) => isSpan({
+      schema: snapshot.context.schema
+    }, node),
+    reverse: !0
+  }))
+    return entry;
+}
+function nodeParentPath(path2) {
+  return splitNodePath(path2.slice(0, -1)).nodePath;
+}
 function getValue(root, path2) {
   let current = root;
   for (const segment of path2) {
@@ -7915,7 +8027,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: setNodePath,
         propertyPath: setPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (setNodePath.length === 0)
         break;
       if (setPropertyPath.length === 0) {
@@ -7970,26 +8082,16 @@ function applyOperation(editor, op) {
             if (selection != null && result != null)
               selection[key] = result;
             else {
-              let prev, next;
-              for (const {
-                node: n,
-                path: p
-              } of getNodes(editor.snapshot))
-                if (isSpan({
-                  schema: editor.snapshot.context.schema
-                }, n) && !pathEquals(p, path2))
-                  if (comparePaths(p, path2, editor.snapshot.context) === -1)
-                    prev = [n, p];
-                  else {
-                    next = [n, p];
-                    break;
-                  }
+              const {
+                previousSpan,
+                nextSpan
+              } = findNearestSpans(editor.snapshot, path2);
               let preferNext = !1;
-              prev && next && (isSiblingPath(prev[1], path2) ? preferNext = !1 : pathEquals(next[1], path2) ? preferNext = !0 : preferNext = commonPath(prev[1], path2).length < commonPath(next[1], path2).length), prev && !preferNext ? selection[key] = {
-                path: prev[1],
-                offset: prev[0].text.length
-              } : next ? selection[key] = {
-                path: next[1],
+              previousSpan && nextSpan && (isSiblingPath(previousSpan.path, path2) ? preferNext = !1 : preferNext = commonPath(previousSpan.path, path2).length < commonPath(nextSpan.path, path2).length), previousSpan && !preferNext ? selection[key] = {
+                path: previousSpan.path,
+                offset: previousSpan.node.text.length
+              } : nextSpan ? selection[key] = {
+                path: nextSpan.path,
                 offset: 0
               } : selection = null;
             }
@@ -8026,7 +8128,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: unsetNodePath,
         propertyPath: unsetPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (unsetPropertyPath.length === 0 || unsetNodePath.length === 0)
         break;
       if (!op.inverse && !editor.isProcessingRemoteChanges) {
@@ -8133,26 +8235,6 @@ function resolveBlockIndex(editor, segment) {
   const value = editor.snapshot.context.value, index = editor.blockIndexMap.get(serializePath([segment]));
   return index !== void 0 && value[index]?._key === segment._key ? index : value.findIndex((block) => block._key === segment._key);
 }
-function splitNodeAndPropertyPath(path2) {
-  let lastKeyedOrNumericIndex = -1;
-  for (let i = path2.length - 1; i >= 0; i--) {
-    const segment = path2[i];
-    if (isKeyedSegment(segment) || typeof segment == "number") {
-      lastKeyedOrNumericIndex = i;
-      break;
-    }
-  }
-  if (lastKeyedOrNumericIndex === -1)
-    return {
-      nodePath: [],
-      propertyPath: path2.filter((segment) => typeof segment == "string")
-    };
-  const nodePath = path2.slice(0, lastKeyedOrNumericIndex + 1), propertyPath = path2.slice(lastKeyedOrNumericIndex + 1).filter((segment) => typeof segment == "string");
-  return {
-    nodePath,
-    propertyPath
-  };
-}
 function deepSet(node, propertyPath, value) {
   if (propertyPath.length === 0)
     return node;
@@ -10393,7 +10475,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
         return;
       }
       if (typeof op.path[op.path.length - 1] == "string") {
-        hasKeyedEntries(resolveValueAtPath(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        hasKeyedEntries(getValue(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const removeIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10421,7 +10503,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
           handleKeyChange(map, beforeValue, afterValue, op.path.slice(0, -1), context);
           return;
         }
-        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(resolveValueAtPath(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(getValue(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const childIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10558,33 +10640,14 @@ function resolveIndexableNode(context, value, keyedPath) {
   };
 }
 function reconcileOwnerSubtree(map, context, beforeValue, afterValue, propertyPath) {
-  let ownerPathEnd = propertyPath.length;
-  for (; ownerPathEnd > 0 && typeof propertyPath[ownerPathEnd - 1] == "string"; )
-    ownerPathEnd--;
-  if (ownerPathEnd === 0)
-    return;
-  const ownerPath = propertyPath.slice(0, ownerPathEnd);
-  pruneSubtreeAtPath(
+  const ownerPath = splitNodePath(propertyPath).nodePath;
+  ownerPath.length !== 0 && (pruneSubtreeAtPath(
     map,
     beforeValue,
     ownerPath,
     /*keepSelf*/
     !0
-  ), addSubtree(map, context, afterValue, ownerPath);
-}
-function resolveValueAtPath(value, path2) {
-  let nodePathEnd = path2.length;
-  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
-    nodePathEnd--;
-  if (nodePathEnd === 0)
-    return;
-  let current = resolveNodeAtPath(value, path2.slice(0, nodePathEnd));
-  for (let i = nodePathEnd; i < path2.length; i++) {
-    if (current === null || typeof current != "object")
-      return;
-    current = current[path2[i]];
-  }
-  return current;
+  ), addSubtree(map, context, afterValue, ownerPath));
 }
 function hasKeyedEntries(value) {
   return Array.isArray(value) && value.some((entry) => entry !== null && typeof entry == "object" && entry._key !== void 0);
@@ -10733,7 +10796,7 @@ ${safeStringify(event.operation, 2)}`);
     operation.type !== "set.selection" && (operation.type === "insert.text" || operation.type === "remove.text" || (transformBlockIndexMap(editor.blockIndexMap, operation, event.beforeValue, editor.snapshot.context.value, {
       schema: context.schema,
       containers: editor.snapshot.context.containers
-    }), editor.listIndexMapDirty = !0, invalidateVerifiedGroups(editor.verifiedUniqueChildGroups, operation)));
+    }), editor.listIndexMapDirty = !0, editor.selectorChannelsPending.listIndex = !0, invalidateVerifiedGroups(editor.verifiedUniqueChildGroups, operation)));
   });
   return () => {
     unsubscribeNormalizationLog?.(), unsubscribeIndexMaps();
@@ -10767,7 +10830,10 @@ function createEditorEngine(config) {
   }, editor.containers = /* @__PURE__ */ new Map(), editor.blockObjects = /* @__PURE__ */ new Map(), editor.inlineObjects = /* @__PURE__ */ new Map(), editor.spans = /* @__PURE__ */ new Map(), editor.textBlocks = /* @__PURE__ */ new Map(), editor.decoratedRanges = [], editor.blockIndexMap = blockIndexMap, editor.history = {
     undos: [],
     redos: []
-  }, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.listIndexMapDirty = !1, editor.verifiedUniqueChildGroups = /* @__PURE__ */ new Set(), editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
+  }, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.listIndexMapDirty = !1, editor.selectorChannelsPending = {
+    registrations: !1,
+    listIndex: !1
+  }, editor.verifiedUniqueChildGroups = /* @__PURE__ */ new Set(), editor.remotePatches = [], editor.undoStepId = void 0, editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
   const editorEngine = plugins(withDOM(editor), {
     editorActor: config.editorActor
   });
@@ -10808,7 +10874,8 @@ function createEditorDom(sendBack, editorEngine) {
     getBlockNodes: (snapshot) => getBlockNodes(editorEngine, snapshot),
     getChildNodes: (snapshot) => getChildNodes(editorEngine, snapshot),
     getEditorElement: () => getEditorElement(editorEngine),
-    getSelectionRect: (snapshot) => getSelectionRect(snapshot),
+    getSelectionRect: (snapshot) => getSelectionRect(editorEngine, snapshot),
+    getPointAtCoordinates: (coordinates) => getPointAtCoordinates(editorEngine, coordinates),
     getStartBlockElement: (snapshot) => getStartBlockElement(editorEngine, snapshot),
     getEndBlockElement: (snapshot) => getEndBlockElement(editorEngine, snapshot),
     setDragGhost: ({
@@ -10861,12 +10928,15 @@ function getChildNodes(editorEngine, snapshot) {
 function getEditorElement(editorEngine) {
   return getDomNode(editorEngine, []);
 }
-function getSelectionRect(snapshot) {
-  if (!snapshot.context.selection)
+function getSelectionRect(editorEngine, snapshot) {
+  const selection = snapshot.context.selection;
+  if (!selection)
     return null;
   try {
-    const selection = window.getSelection();
-    return selection ? selection.getRangeAt(0).getBoundingClientRect() : null;
+    const engineRange = resolveSelection({
+      snapshot
+    }, selection);
+    return engineRange ? DOMEditor.toDOMRange(editorEngine, engineRange).getBoundingClientRect() : null;
   } catch {
     return null;
   }
@@ -10915,6 +10985,7 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
       return !1;
     const caretWordSelection = getCaretWordSelection(adjustedSnapshot);
     return !caretWordSelection || !isSelectionExpanded({
+      ...adjustedSnapshot,
       context: {
         ...adjustedSnapshot.context,
         selection: caretWordSelection
@@ -11102,6 +11173,22 @@ const addAnnotationOnCollapsedSelection = defineBehavior({
     undo,
     redo
   },
+  selectAll: createKeyboardShortcut({
+    default: [{
+      key: "A",
+      alt: !1,
+      ctrl: !0,
+      meta: !1,
+      shift: !1
+    }],
+    apple: [{
+      key: "A",
+      alt: !1,
+      ctrl: !1,
+      meta: !0,
+      shift: !1
+    }]
+  }),
   tab: createKeyboardShortcut({
     default: [{
       key: "Tab",
@@ -12144,11 +12231,13 @@ const MAX_LIST_LEVEL = 10, clearListOnBackspace = defineBehavior({
     if (!isListBlock(snapshot.context, startBlock) || !isListBlock(snapshot.context, endBlock))
       return !1;
     const deleteStartPoint = getSelectionStartPoint({
+      ...snapshot,
       context: {
         ...snapshot.context,
         selection: at
       }
     }), deleteEndPoint = getSelectionEndPoint({
+      ...snapshot,
       context: {
         ...snapshot.context,
         selection: at
@@ -14558,7 +14647,14 @@ const moveBackwardOperationImplementation = ({
 }, selectOperationImplementation = ({
   operation
 }) => {
-  const newSelection = resolveSelection(operation.editor, operation.at);
+  let newSelection = resolveSelection(operation.editor, operation.at);
+  if (newSelection) {
+    const anchorContainer = getContainer(operation.editor.snapshot, newSelection.anchor.path), focusContainer = getContainer(operation.editor.snapshot, newSelection.focus.path), containers = anchorContainer ? [anchorContainer] : [];
+    focusContainer && focusContainer.node !== anchorContainer?.node && containers.push(focusContainer), containers.length > 0 && (withoutNormalizing(operation.editor, () => {
+      for (const entry of containers)
+        operation.editor.isNormalizingNode = !0, operation.editor.normalizeNode([entry.node, entry.path]), operation.editor.isNormalizingNode = !1;
+    }), newSelection = resolveSelection(operation.editor, operation.at));
+  }
   newSelection ? applySelect(operation.editor, newSelection) : applyDeselect(operation.editor), operation.editor.focused && operation.editor.snapshot.context.readOnly && (operation.editor.focused = !1);
 }, setOperationImplementation = ({
   operation
@@ -15853,6 +15949,50 @@ const abstractInsertBehaviors = [
       type: "history.redo"
     })]]
   }),
+  /**
+   * Manual handling of select-all. The native gesture cannot be trusted to
+   * build the range: chromium produces an already-collapsed range whenever a
+   * non-editable element sits at either content edge of the editing host,
+   * which any document starting or ending with a void block or a
+   * chrome-bearing container render does. "Everything" is a model-level
+   * statement, so the range is computed from the model instead of
+   * round-tripping through the DOM selection.
+   */
+  defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      if (!defaultKeyboardShortcuts.selectAll.guard(event.originEvent))
+        return !1;
+      const startLeaf = getLeaf(snapshot, [], {
+        edge: "start"
+      }), endLeaf = getLeaf(snapshot, [], {
+        edge: "end"
+      }), startBlock = startLeaf ? getEnclosingBlock(snapshot, startLeaf.path) : void 0, endBlock = endLeaf ? getEnclosingBlock(snapshot, endLeaf.path) : void 0;
+      return !startBlock || !endBlock ? !1 : {
+        anchor: getBlockStartPoint({
+          context: snapshot.context,
+          block: startBlock
+        }),
+        focus: getBlockEndPoint({
+          context: snapshot.context,
+          block: endBlock
+        })
+      };
+    },
+    actions: [(_, {
+      anchor,
+      focus
+    }) => [raise({
+      type: "select",
+      at: {
+        anchor,
+        focus
+      }
+    })]]
+  }),
   /**
    * Fix edge case where Shift+ArrowLeft didn't reduce a selection hanging
    * onto an empty text block.
@@ -16727,15 +16867,17 @@ function synthesizeBlockChildrenField(schema) {
     of: ofMembers
   };
 }
-function resolveFieldOn(fields, type, fieldName) {
+function resolveFieldOn(fields, fieldName) {
   const field = fields.find((candidate) => candidate.name === fieldName);
-  if (!(!field || !isChildArrayField(field))) {
-    if (containsOnlyPrimitiveTypes(field)) {
-      console.warn(`Field '${field.name}' on '${type}' doesn't contain block or container types and will be excluded`);
-      return;
-    }
-    return field;
-  }
+  return field ? isChildArrayField(field) ? containsOnlyPrimitiveTypes(field) ? {
+    failure: "field-primitive-only"
+  } : {
+    field
+  } : {
+    failure: "field-not-array"
+  } : {
+    failure: "field-missing"
+  };
 }
 function findInlineDeclarationIn(parentOf, type) {
   for (const member of parentOf)
@@ -16763,28 +16905,35 @@ function findInlineFields(schema, type) {
         isChildArrayField(field) && walk(field.of);
   return best;
 }
-function resolveContainerField(schema, type, fieldName, parentOf) {
+function resolveContainerFieldResolution(schema, type, fieldName, parentOf) {
   if (type === "block")
-    return fieldName !== "children" ? void 0 : synthesizeBlockChildrenField(schema);
+    return fieldName !== "children" ? {
+      failure: "field-missing"
+    } : {
+      field: synthesizeBlockChildrenField(schema)
+    };
   if (parentOf) {
     const inlineMatch = findInlineDeclarationIn(parentOf, type);
     if (inlineMatch)
-      return resolveFieldOn(inlineMatch, type, fieldName);
+      return resolveFieldOn(inlineMatch, fieldName);
   }
   const rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === type), rootFields = rootMatch && "fields" in rootMatch && rootMatch.fields && rootMatch.fields.length > 0 ? rootMatch.fields : void 0, inlineFields = rootFields ? void 0 : findInlineFields(schema, type), fields = rootFields ?? inlineFields;
-  if (fields)
-    return resolveFieldOn(fields, type, fieldName);
+  return fields ? resolveFieldOn(fields, fieldName) : rootMatch ? {
+    failure: "field-missing"
+  } : {
+    failure: "unknown-type"
+  };
 }
 function resolveNestedContainer(schema, container, chain = [], onFailure = "warn", parentOf) {
-  const field = resolveContainerField(schema, container.type, container.arrayField, parentOf);
-  if (!field) {
-    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: field "${container.arrayField}" not found on type "${container.type}"${location}. Registration skipped.`;
+  const resolution = resolveContainerFieldResolution(schema, container.type, container.arrayField, parentOf);
+  if ("failure" in resolution) {
+    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: ${describeContainerFailure(resolution.failure, container)}${location}. Registration skipped.`;
     if (onFailure === "throw")
       throw new Error(message);
     console.warn(message);
     return;
   }
-  const nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
+  const field = resolution.field, nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
     if (entry.kind === "container") {
       const resolved = resolveNestedContainer(schema, entry, nextChain, onFailure, field.of);
       return resolved ? [resolved] : [];
@@ -16801,6 +16950,18 @@ function resolveNestedContainer(schema, container, chain = [], onFailure = "warn
     } : {}
   };
 }
+function describeContainerFailure(failure, container) {
+  switch (failure) {
+    case "unknown-type":
+      return `type "${container.type}" not found in the schema`;
+    case "field-missing":
+      return `field "${container.arrayField}" not found on type "${container.type}"`;
+    case "field-not-array":
+      return `field "${container.arrayField}" on type "${container.type}" is not an array`;
+    case "field-primitive-only":
+      return `field "${container.arrayField}" on type "${container.type}" contains only primitive types and cannot hold block content`;
+  }
+}
 function resolveTextBlockConfig(textBlock) {
   const resolvedOf = textBlock.of ? textBlock.of.flatMap((entry) => entry.kind === "span" ? [{
     span: entry
@@ -16853,14 +17014,14 @@ function registerNodeOnEngine(engine, node) {
     const containers = new Map(engine.containers);
     containers.set(node.type, containerConfig), engine.containers = containers, engine.snapshot.context.containers = buildPublicContainers(containers), normalize(engine, {
       force: !0
-    }), engine.onChange();
+    }), notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "textBlock") {
     if (isTypeAlreadyRegistered(engine, "textBlock", node.type))
       return;
     const textBlocks = new Map(engine.textBlocks);
-    textBlocks.set(node.type, resolveTextBlockConfig(node)), engine.textBlocks = textBlocks, engine.onChange();
+    textBlocks.set(node.type, resolveTextBlockConfig(node)), engine.textBlocks = textBlocks, notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "span") {
@@ -16869,7 +17030,7 @@ function registerNodeOnEngine(engine, node) {
     const spans = new Map(engine.spans);
     spans.set(node.type, {
       span: node
-    }), engine.spans = spans, engine.onChange();
+    }), engine.spans = spans, notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "blockObject") {
@@ -16878,7 +17039,7 @@ function registerNodeOnEngine(engine, node) {
     const blockObjects = new Map(engine.blockObjects);
     blockObjects.set(node.type, {
       blockObject: node
-    }), engine.blockObjects = blockObjects, engine.onChange();
+    }), engine.blockObjects = blockObjects, notifyRegistrationsChanged(engine);
     return;
   }
   if (isTypeAlreadyRegistered(engine, "inlineObject", node.type))
@@ -16886,33 +17047,36 @@ function registerNodeOnEngine(engine, node) {
   const inlineObjects = new Map(engine.inlineObjects);
   inlineObjects.set(node.type, {
     inlineObject: node
-  }), engine.inlineObjects = inlineObjects, engine.onChange();
+  }), engine.inlineObjects = inlineObjects, notifyRegistrationsChanged(engine);
 }
 function unregisterNodeOnEngine(engine, node) {
   if (node.kind === "container") {
     const containers = new Map(engine.containers);
     containers.delete(node.type), engine.containers = containers, engine.snapshot.context.containers = buildPublicContainers(containers), normalize(engine, {
       force: !0
-    }), engine.onChange();
+    }), notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "textBlock") {
     const textBlocks = new Map(engine.textBlocks);
-    textBlocks.delete(node.type), engine.textBlocks = textBlocks, engine.onChange();
+    textBlocks.delete(node.type), engine.textBlocks = textBlocks, notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "span") {
     const spans = new Map(engine.spans);
-    spans.delete(node.type), engine.spans = spans, engine.onChange();
+    spans.delete(node.type), engine.spans = spans, notifyRegistrationsChanged(engine);
     return;
   }
   if (node.kind === "blockObject") {
     const blockObjects = new Map(engine.blockObjects);
-    blockObjects.delete(node.type), engine.blockObjects = blockObjects, engine.onChange();
+    blockObjects.delete(node.type), engine.blockObjects = blockObjects, notifyRegistrationsChanged(engine);
     return;
   }
   const inlineObjects = new Map(engine.inlineObjects);
-  inlineObjects.delete(node.type), engine.inlineObjects = inlineObjects, engine.onChange();
+  inlineObjects.delete(node.type), engine.inlineObjects = inlineObjects, notifyRegistrationsChanged(engine);
+}
+function notifyRegistrationsChanged(engine) {
+  engine.selectorChannelsPending.registrations = !0, engine.onChange();
 }
 function rerouteExternalBehaviorEvent({
   event,