@portabletext/editor 7.3.4 → 7.5.0

package/lib/index.js

@@ -2,7 +2,7 @@ import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 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 { isKeyedSegment, getNode, getParent, parentPath, getChildren, getNodeChildren } from "./_chunks-es/get-parent.js";
+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 { isSpan, isTextBlock, compileSchema } from "@portabletext/schema";
@@ -21,9 +21,6 @@ import { markdownToPortableText, portableTextToMarkdown } from "@portabletext/ma
 import { applyAll, unset, set, insert, setIfMissing, diffMatchPatch as diffMatchPatch$1 } from "@portabletext/patches";
 import { EditorContext as EditorContext$1 } from "./_chunks-es/use-editor.js";
 import { useEditor } from "./_chunks-es/use-editor.js";
-function serializePath(path2) {
-  return path2.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
-}
 function getDomNode(editor, path2) {
   const editorElement = editor.domElement;
   if (!editorElement)
@@ -32,7 +29,7 @@ function getDomNode(editor, path2) {
     return editorElement;
   const serializedPath = serializePath(path2), selector = `[data-pt-path="${CSS.escape(serializedPath)}"]`, blockSegment = path2[0];
   if (isKeyedSegment(blockSegment)) {
-    const blockIndex = editor.blockIndexMap.get(blockSegment._key);
+    const blockIndex = editor.blockIndexMap.get(serializePath([blockSegment]));
     if (blockIndex !== void 0) {
       const blockNode = editorElement.children[blockIndex];
       if (blockNode instanceof HTMLElement) {
@@ -7642,8 +7639,8 @@ const modifyDescendant = (editor, path2, f) => {
   if (rootNumericIndex !== void 0)
     rootIndex = rootNumericIndex;
   else if (keyedSegments.length > 0) {
-    const rootKey = keyedSegments[0]._key;
-    editor.blockIndexMap.has(rootKey) ? rootIndex = editor.blockIndexMap.get(rootKey) : rootIndex = findIndexByKey(editor.snapshot.context.value, rootKey);
+    const rootSegment = keyedSegments[0], mapIndex = editor.blockIndexMap.get(serializePath([rootSegment]));
+    rootIndex = mapIndex !== void 0 ? mapIndex : findIndexByKey(editor.snapshot.context.value, rootSegment._key);
   } else {
     const firstSegment = path2[0];
     rootIndex = typeof firstSegment == "number" ? firstSegment : -1;
@@ -7682,9 +7679,7 @@ function applyOperation(editor, op) {
       let {
         node
       } = op;
-      const isRootInsert = parentPath(path2).length === 0;
-      let insertIndex = -1;
-      if (modifyChildren(editor, parentPath(path2), (children) => {
+      modifyChildren(editor, parentPath(path2), (children) => {
         !editor.isProcessingRemoteChanges && !editor.isUndoing && !editor.isRedoing && node._key !== void 0 && children.some((sibling) => sibling._key === node._key) && (node = {
           ...node,
           _key: editor.snapshot.context.keyGenerator()
@@ -7692,7 +7687,7 @@ function applyOperation(editor, op) {
         const lastSegment = path2[path2.length - 1];
         let index;
         if (isKeyedSegment(lastSegment)) {
-          const siblingIndex = resolveChildIndex$1(children, lastSegment._key, isRootInsert ? editor.blockIndexMap : void 0);
+          const siblingIndex = resolveChildIndex$1(editor.blockIndexMap, path2.slice(0, -1), lastSegment, children);
           if (siblingIndex === -1)
             throw new Error(`Cannot apply an "insert" operation at path [${path2}] because the sibling was not found.`);
           index = op.position === "after" ? siblingIndex + 1 : siblingIndex;
@@ -7707,14 +7702,8 @@ function applyOperation(editor, op) {
           path: node._key !== void 0 ? replaceLastSegment(path2, {
             _key: node._key
           }) : path2
-        }), insertIndex = index, insertChildren(children, index, node);
-      }), isRootInsert && insertIndex !== -1) {
-        if (insertIndex < editor.blockIndexMap.size)
-          for (const [key, idx] of editor.blockIndexMap)
-            idx >= insertIndex && editor.blockIndexMap.set(key, idx + 1);
-        editor.blockIndexMap.set(node._key, insertIndex);
-      }
-      transformSelection = !0;
+        }), insertChildren(children, index, node);
+      }), transformSelection = !0;
       break;
     }
     case "insert.text": {
@@ -7768,14 +7757,7 @@ function applyOperation(editor, op) {
         };
       }
       if (path2.length === 0) {
-        if (Array.isArray(value)) {
-          editor.snapshot.context.value = value, editor.blockIndexMap.clear();
-          for (let i = 0; i < editor.snapshot.context.value.length; i++) {
-            const child = editor.snapshot.context.value[i];
-            child && editor.blockIndexMap.set(child._key, i);
-          }
-        }
-        transformSelection = !0;
+        Array.isArray(value) && (editor.snapshot.context.value = value), transformSelection = !0;
         break;
       }
       const {
@@ -7791,20 +7773,17 @@ function applyOperation(editor, op) {
       if (getNode(editor.snapshot, setNodePath))
         if (setPropertyPath.length === 1) {
           const propertyName = setPropertyPath[0];
-          if (modifyDescendant(editor, setNodePath, (node) => ({
+          modifyDescendant(editor, setNodePath, (node) => ({
             ...node,
             [propertyName]: value
-          })), propertyName === "_key" && setNodePath.length === 1 && op.inverse?.type === "set" && typeof op.inverse.value == "string" && typeof value == "string") {
-            const blockIndex = editor.blockIndexMap.get(op.inverse.value);
-            blockIndex !== void 0 && (editor.blockIndexMap.delete(op.inverse.value), editor.blockIndexMap.set(value, blockIndex));
-          }
+          }));
         } else
           modifyDescendant(editor, setNodePath, (node) => deepSet(node, setPropertyPath, value));
       else {
-        const blockKey = findBlockKey(path2);
-        if (!blockKey)
+        const blockSegment = findBlockSegment(path2);
+        if (!blockSegment)
           break;
-        const blockIndex = resolveBlockIndex(editor, blockKey);
+        const blockIndex = resolveBlockIndex(editor, blockSegment);
         if (blockIndex === -1)
           break;
         const block = editor.snapshot.context.value[blockIndex];
@@ -7825,7 +7804,7 @@ function applyOperation(editor, op) {
           type: "set",
           path: path2,
           value: editor.snapshot.context.value
-        }), editor.snapshot.context.value = [], editor.blockIndexMap.clear(), transformSelection = !0;
+        }), editor.snapshot.context.value = [], transformSelection = !0;
         break;
       }
       const lastSegment = path2[path2.length - 1];
@@ -7868,11 +7847,9 @@ function applyOperation(editor, op) {
             backward: isBackwardRange(selection, editor.snapshot.context)
           } : null;
         }
-        const isRootRemove = parentPath(path2).length === 0;
-        let removeIndex = -1, removedKey;
-        if (modifyChildren(editor, parentPath(path2), (children) => {
+        modifyChildren(editor, parentPath(path2), (children) => {
           let index;
-          if (isKeyedSegment(lastSegment) ? index = resolveChildIndex$1(children, lastSegment._key, isRootRemove ? editor.blockIndexMap : void 0) : index = lastSegment, index === -1 || index >= children.length)
+          if (isKeyedSegment(lastSegment) ? index = resolveChildIndex$1(editor.blockIndexMap, path2.slice(0, -1), lastSegment, children) : index = lastSegment, index === -1 || index >= children.length)
             throw new Error(`Cannot apply an "unset" (node removal) operation at path [${path2}] because the node was not found.`);
           if (!op.inverse && !editor.isProcessingRemoteChanges) {
             const previousSibling = index > 0 ? children[index - 1] : void 0;
@@ -7890,12 +7867,8 @@ function applyOperation(editor, op) {
               position: "before"
             };
           }
-          return removedKey = children[index]?._key, removeIndex = index, removeChildren(children, index, 1);
-        }), isRootRemove && removeIndex !== -1 && removedKey) {
-          editor.blockIndexMap.delete(removedKey);
-          for (const [key, idx] of editor.blockIndexMap)
-            idx > removeIndex && editor.blockIndexMap.set(key, idx - 1);
-        }
+          return removeChildren(children, index, 1);
+        });
         break;
       }
       const {
@@ -7926,10 +7899,10 @@ function applyOperation(editor, op) {
         } else
           modifyDescendant(editor, unsetNodePath, (node) => deepUnset(node, unsetPropertyPath));
       else {
-        const blockKey = findBlockKey(path2);
-        if (!blockKey)
+        const blockSegment = findBlockSegment(path2);
+        if (!blockSegment)
           break;
-        const blockIndex = resolveBlockIndex(editor, blockKey);
+        const blockIndex = resolveBlockIndex(editor, blockSegment);
         if (blockIndex === -1)
           break;
         const block = editor.snapshot.context.value[blockIndex];
@@ -7995,25 +7968,18 @@ function replaceLastSegment(path2, segment) {
   const result = [...path2];
   return result[result.length - 1] = segment, result;
 }
-function resolveChildIndex$1(children, key, blockIndexMap) {
-  if (blockIndexMap) {
-    const index = blockIndexMap.get(key);
-    if (index !== void 0) {
-      const candidate = children[index];
-      if (candidate && candidate._key === key)
-        return index;
-    }
-  }
-  return children.findIndex((child) => child._key === key);
+function resolveChildIndex$1(blockIndexMap, parentSegments, segment, children) {
+  const index = blockIndexMap.get(serializePath([...parentSegments, segment]));
+  return index !== void 0 && children[index]?._key === segment._key ? index : children.findIndex((child) => child._key === segment._key);
 }
-function findBlockKey(path2) {
+function findBlockSegment(path2) {
   const firstSegment = path2[0];
   if (isKeyedSegment(firstSegment))
-    return firstSegment._key;
+    return firstSegment;
 }
-function resolveBlockIndex(editor, blockKey) {
-  const mapIndex = editor.blockIndexMap.get(blockKey);
-  return mapIndex !== void 0 ? mapIndex : editor.snapshot.context.value.findIndex((child) => child._key === blockKey);
+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;
@@ -9202,18 +9168,47 @@ const shouldNormalize = (_editor, {
     const onContextChange = e.onContextChange;
     onContextChange && onContextChange(options), onChange(options);
   }, e;
-}, levelIndexMaps = /* @__PURE__ */ new Map();
+};
+class BlockIndexMap extends Map {
+  get(key) {
+    return key.startsWith("[_key==") ? super.get(key) : super.get(serializePath([{
+      _key: key
+    }]));
+  }
+  has(key) {
+    return key.startsWith("[_key==") ? super.has(key) : super.has(serializePath([{
+      _key: key
+    }]));
+  }
+}
+const levelIndexMaps = /* @__PURE__ */ new Map();
 function buildIndexMaps(context, {
   blockIndexMap,
   listIndexMap
 }) {
-  blockIndexMap.clear(), listIndexMap.clear(), levelIndexMaps.clear();
+  blockIndexMap.clear();
+  for (let blockIndex = 0; blockIndex < context.value.length; blockIndex++) {
+    const block = context.value.at(blockIndex);
+    if (block === void 0 || block._key === void 0)
+      continue;
+    const blockPath = [{
+      _key: block._key
+    }], blockKey = serializePath(blockPath);
+    blockIndexMap.has(blockKey) || blockIndexMap.set(blockKey, blockIndex), collectDescendantIndexes(context, block, blockPath, void 0, blockIndexMap);
+  }
+  buildListIndexMap(context, listIndexMap);
+}
+function buildListIndexMap(context, listIndexMap) {
+  listIndexMap.clear(), levelIndexMaps.clear();
   let previousListItem;
   for (let blockIndex = 0; blockIndex < context.value.length; blockIndex++) {
     const block = context.value.at(blockIndex);
     if (block === void 0)
       continue;
-    if (blockIndexMap.set(block._key, blockIndex), !isTextBlockNode(context, block)) {
+    const blockPath = [{
+      _key: block._key
+    }];
+    if (!isTextBlockNode(context, block)) {
       levelIndexMaps.clear(), previousListItem = void 0;
       continue;
     }
@@ -9223,9 +9218,7 @@ function buildIndexMaps(context, {
     }
     if (!previousListItem) {
       const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(serializePath([{
-        _key: block._key
-      }]), 1), previousListItem = {
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(serializePath(blockPath), 1), previousListItem = {
         listItem: block.listItem,
         level: block.level
       };
@@ -9233,9 +9226,7 @@ function buildIndexMaps(context, {
     }
     if (previousListItem.listItem === block.listItem && previousListItem.level < block.level) {
       const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(serializePath([{
-        _key: block._key
-      }]), 1), previousListItem = {
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(serializePath(blockPath), 1), previousListItem = {
         listItem: block.listItem,
         level: block.level
       };
@@ -9252,14 +9243,25 @@ function buildIndexMaps(context, {
       });
     });
     const levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(block.level) ?? 0;
-    levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(serializePath([{
-      _key: block._key
-    }]), levelCounter + 1), previousListItem = {
+    levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(serializePath(blockPath), levelCounter + 1), previousListItem = {
       listItem: block.listItem,
       level: block.level
     };
   }
 }
+function collectDescendantIndexes(context, node, nodePath, parent, blockIndexMap) {
+  const result = getNodeChildren(context, node, parent);
+  if (result)
+    for (let i = 0; i < result.children.length; i++) {
+      const child = result.children[i];
+      if (!child._key)
+        continue;
+      const childSegment = {
+        _key: child._key
+      }, childPath = [...nodePath, result.fieldName, childSegment], childKey = serializePath(childPath);
+      blockIndexMap.has(childKey) || blockIndexMap.set(childKey, i), collectDescendantIndexes(context, child, childPath, result.parent, blockIndexMap);
+    }
+}
 function withRemoteChanges(editor, fn) {
   const prev = editor.isProcessingRemoteChanges;
   editor.isProcessingRemoteChanges = !0, fn(), editor.isProcessingRemoteChanges = prev;
@@ -10243,7 +10245,7 @@ function textPatch(snapshot, operation, beforeValue) {
       containers: snapshot.context.containers,
       value: beforeValue
     },
-    blockIndexMap: /* @__PURE__ */ new Map()
+    blockIndexMap: snapshot.blockIndexMap
   }, prevSpan = getSpan(beforeSnapshot, operation.path), patch = diffMatchPatch$1(prevSpan?.node.text ?? "", span.node.text, [...operation.path, "text"]);
   return patch.value.length ? [patch] : [];
 }
@@ -10294,6 +10296,279 @@ function subscribePatchGeneration({
         });
   });
 }
+function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
+  switch (op.type) {
+    case "insert.text":
+    case "remove.text":
+    case "set.selection":
+      return;
+    case "insert": {
+      const lastSegment = op.path[op.path.length - 1], anchorIndex = typeof lastSegment == "number" ? lastSegment : resolveChildIndexInValue(beforeValue, op.path);
+      if (anchorIndex < 0)
+        return;
+      const siblingContext = resolveSiblingContext(context, afterValue, op.path);
+      if (!siblingContext)
+        return;
+      const insertIndex = Math.min(op.position === "after" ? anchorIndex + 1 : anchorIndex, siblingContext.children.length - 1);
+      reindexSiblings(map, siblingContext, insertIndex);
+      const insertedNumericPath = [...op.path.slice(0, -1), insertIndex];
+      addSubtree(map, context, afterValue, insertedNumericPath);
+      return;
+    }
+    case "unset": {
+      if (op.path.length === 0) {
+        map.clear();
+        return;
+      }
+      const lastSegment = op.path[op.path.length - 1];
+      if (typeof lastSegment == "string") {
+        hasKeyedEntries(resolveValueAtPath(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        return;
+      }
+      const removeIndex = typeof lastSegment == "number" ? lastSegment : resolveChildIndexInValue(beforeValue, op.path);
+      if (pruneSubtreeAtPath(map, beforeValue, op.path), removeIndex >= 0) {
+        const siblingContext = resolveSiblingContext(context, afterValue, op.path);
+        siblingContext && reindexSiblings(map, siblingContext, removeIndex);
+      }
+      return;
+    }
+    case "set": {
+      if (op.path.length === 0) {
+        map.clear(), buildIndexMaps({
+          schema: context.schema,
+          value: afterValue,
+          containers: context.containers
+        }, {
+          blockIndexMap: map,
+          listIndexMap: /* @__PURE__ */ new Map()
+        });
+        return;
+      }
+      const lastSegment = op.path[op.path.length - 1];
+      if (typeof lastSegment == "string") {
+        if (lastSegment === "_key") {
+          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);
+        return;
+      }
+      const childIndex = resolveChildIndexInValue(beforeValue, op.path);
+      pruneSubtreeAtPath(map, beforeValue, op.path), childIndex >= 0 && addSubtree(map, context, afterValue, [...op.path.slice(0, -1), childIndex]);
+      return;
+    }
+  }
+}
+function resolveChildIndexInValue(value, path2) {
+  let currentChildren = value;
+  for (let i = 0; i < path2.length - 1; i++) {
+    const segment = path2[i];
+    if (typeof segment == "string")
+      continue;
+    let node;
+    if (isKeyedSegment(segment) ? node = currentChildren.find((c2) => c2._key === segment._key) : typeof segment == "number" && (node = currentChildren.at(segment)), !node)
+      return -1;
+    const next = path2[i + 1];
+    if (typeof next == "string") {
+      const field = node[next];
+      if (!Array.isArray(field))
+        return -1;
+      currentChildren = field, i++;
+    }
+  }
+  const last = path2[path2.length - 1];
+  return typeof last == "number" ? last : isKeyedSegment(last) ? currentChildren.findIndex((c2) => c2._key === last._key) : -1;
+}
+function resolveSiblingContext(context, value, opPath) {
+  if (opPath.length === 1)
+    return {
+      children: value,
+      serializedPrefix: ""
+    };
+  const fieldSegment = opPath[opPath.length - 2];
+  if (typeof fieldSegment != "string")
+    return;
+  const keyedParentPath = toKeyedPath(value, parentPath(opPath));
+  if (keyedParentPath === void 0)
+    return;
+  const resolvedParent = resolveIndexableNode(context, value, keyedParentPath);
+  if (!resolvedParent)
+    return;
+  const childrenResult = getNodeChildren(context, resolvedParent.node, resolvedParent.containerOfParent);
+  if (!(!childrenResult || childrenResult.fieldName !== fieldSegment))
+    return {
+      children: childrenResult.children,
+      serializedPrefix: serializePath([...keyedParentPath, fieldSegment])
+    };
+}
+function reindexSiblings(map, siblingContext, startIndex) {
+  for (let childIndex = Math.max(0, startIndex); childIndex < siblingContext.children.length; childIndex++) {
+    const child = siblingContext.children[childIndex];
+    !child || child._key === void 0 || map.set(`${siblingContext.serializedPrefix}[_key=="${child._key}"]`, childIndex);
+  }
+}
+function pruneSubtreeAtPath(map, beforeValue, nodePath, keepSelf = !1) {
+  const node = resolveNodeAtPath(beforeValue, nodePath);
+  if (!node)
+    return;
+  const keyedPath = toKeyedPath(beforeValue, nodePath);
+  keyedPath !== void 0 && (keepSelf || map.delete(serializePath(keyedPath)), walkKeyedChildrenInValue(node, keyedPath, (childPath) => {
+    map.delete(serializePath(childPath));
+  }));
+}
+function walkKeyedChildrenInValue(node, nodePath, visit) {
+  for (const key of Object.keys(node)) {
+    const field = node[key];
+    if (Array.isArray(field))
+      for (const child of field) {
+        if (!child || child._key === void 0)
+          continue;
+        const childPath = [...nodePath, key, {
+          _key: child._key
+        }];
+        visit(childPath), walkKeyedChildrenInValue(child, childPath, visit);
+      }
+  }
+}
+function addSubtree(map, context, afterValue, opPath) {
+  const keyedPath = toKeyedPath(afterValue, opPath);
+  if (keyedPath === void 0)
+    return;
+  const resolved = resolveIndexableNode(context, afterValue, keyedPath);
+  if (!resolved)
+    return;
+  const childIndex = resolveChildIndexInValue(afterValue, opPath);
+  childIndex >= 0 && map.set(serializePath(keyedPath), childIndex), collectDescendantIndexes(context, resolved.node, keyedPath, resolved.containerOfParent, map);
+}
+function resolveIndexableNode(context, value, keyedPath) {
+  if (keyedPath.length === 0)
+    return;
+  let current = {
+    value
+  }, containerOfParent, index = 0;
+  for (; index < keyedPath.length; ) {
+    const childrenResult = getNodeChildren(context, current, containerOfParent);
+    if (!childrenResult)
+      return;
+    if (index > 0) {
+      const fieldSegment = keyedPath[index];
+      if (typeof fieldSegment != "string" || fieldSegment !== childrenResult.fieldName)
+        return;
+      index++;
+    }
+    const childSegment = keyedPath[index];
+    let child;
+    if (isKeyedSegment(childSegment) ? child = childrenResult.children.find((candidate) => candidate._key === childSegment._key) : typeof childSegment == "number" && (child = childrenResult.children.at(childSegment)), !child)
+      return;
+    current = child, containerOfParent = childrenResult.parent, index++;
+  }
+  return {
+    node: current,
+    containerOfParent
+  };
+}
+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(
+    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;
+}
+function hasKeyedEntries(value) {
+  return Array.isArray(value) && value.some((entry) => entry !== null && typeof entry == "object" && entry._key !== void 0);
+}
+function toKeyedPath(value, path2) {
+  const result = [];
+  let currentChildren = value, currentNode;
+  for (let i = 0; i < path2.length; i++) {
+    const segment = path2[i];
+    if (typeof segment == "string") {
+      if (result.push(segment), !currentNode)
+        return;
+      const field = currentNode[segment];
+      if (!Array.isArray(field))
+        return;
+      currentChildren = field;
+      continue;
+    }
+    if (typeof segment == "number") {
+      if (currentNode = currentChildren.at(segment), !currentNode || currentNode._key === void 0)
+        return;
+      result.push({
+        _key: currentNode._key
+      });
+      continue;
+    }
+    if (isKeyedSegment(segment)) {
+      if (currentNode = currentChildren.find((c2) => c2._key === segment._key), !currentNode)
+        return;
+      result.push(segment);
+      continue;
+    }
+    return;
+  }
+  return result;
+}
+function handleKeyChange(map, beforeValue, afterValue, nodePath, context) {
+  pruneSubtreeAtPath(
+    map,
+    beforeValue,
+    nodePath,
+    /*keepSelf*/
+    !1
+  );
+  const childIndex = resolveChildIndexInValue(beforeValue, nodePath);
+  if (childIndex < 0)
+    return;
+  const newKeyedNodePath = [...nodePath.slice(0, -1), childIndex];
+  addSubtree(map, context, afterValue, newKeyedNodePath);
+}
+function resolveNodeAtPath(value, path2) {
+  let currentChildren = value, currentNode;
+  for (let i = 0; i < path2.length; i++) {
+    const segment = path2[i];
+    if (typeof segment == "string") {
+      if (!currentNode)
+        return;
+      const field = currentNode[segment];
+      if (!Array.isArray(field))
+        return;
+      currentChildren = field;
+      continue;
+    }
+    if (isKeyedSegment(segment))
+      currentNode = currentChildren.find((c2) => c2._key === segment._key);
+    else if (typeof segment == "number")
+      currentNode = currentChildren.at(segment);
+    else
+      return;
+    if (!currentNode)
+      return;
+  }
+  return currentNode;
+}
 function subscribeUpdateValue(context, editor) {
   const unsubscribeNormalizationLog = debug.normalization.enabled ? subscribeToOperations(editor, (event) => {
     event.isNormalizingNode && debug.normalization(`((engine operation))
@@ -10302,13 +10577,13 @@ ${safeStringify(event.operation, 2)}`);
     phase: "before"
   }) : void 0, unsubscribeIndexMaps = subscribeToOperations(editor, (event) => {
     const operation = event.operation;
-    operation.type !== "set.selection" && (operation.type === "insert.text" || operation.type === "remove.text" || operation.path.length <= 2 && buildIndexMaps({
+    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
+    }), operation.path.length <= 2 && buildListIndexMap({
       schema: context.schema,
       value: editor.snapshot.context.value
-    }, {
-      blockIndexMap: editor.blockIndexMap,
-      listIndexMap: editor.listIndexMap
-    }));
+    }, editor.listIndexMap)));
   });
   return () => {
     unsubscribeNormalizationLog?.(), unsubscribeIndexMaps();
@@ -10316,7 +10591,7 @@ ${safeStringify(event.operation, 2)}`);
 }
 function createEditorEngine(config) {
   debug.setup("creating new editor engine instance");
-  const context = config.editorActor.getSnapshot().context, placeholderBlock = createPlaceholderBlock({
+  const context = config.editorActor.getSnapshot().context, blockIndexMap = new BlockIndexMap(), placeholderBlock = createPlaceholderBlock({
     context: {
       schema: context.schema,
       // No containers registered at engine-init time. NodePlugin
@@ -10325,10 +10600,10 @@ function createEditorEngine(config) {
       value: [],
       keyGenerator: context.keyGenerator
     },
-    blockIndexMap: /* @__PURE__ */ new Map()
+    blockIndexMap
   }), editor = createEditor();
   editor.snapshot = {
-    blockIndexMap: /* @__PURE__ */ new Map(),
+    blockIndexMap,
     context: {
       containers: /* @__PURE__ */ new Map(),
       converters: context.initialConverters,
@@ -10339,7 +10614,7 @@ function createEditorEngine(config) {
       value: [placeholderBlock]
     },
     decoratorState: {}
-  }, 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 = editor.snapshot.blockIndexMap, editor.history = {
+  }, 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.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;
@@ -10359,7 +10634,8 @@ function createEditorEngine(config) {
     editor: editorEngine
   }), buildIndexMaps({
     schema: context.schema,
-    value: editorEngine.snapshot.context.value
+    value: editorEngine.snapshot.context.value,
+    containers: editorEngine.snapshot.context.containers
   }, {
     blockIndexMap: editorEngine.blockIndexMap,
     listIndexMap: editorEngine.listIndexMap
@@ -14798,7 +15074,9 @@ const abstractDeserializeBehaviors = [
   })
 ];
 function getUniqueBlockKey(blockKey) {
-  return (snapshot) => !blockKey || snapshot.blockIndexMap.has(blockKey) ? snapshot.context.keyGenerator() : blockKey;
+  return (snapshot) => !blockKey || snapshot.blockIndexMap.has(serializePath([{
+    _key: blockKey
+  }])) ? snapshot.context.keyGenerator() : blockKey;
 }
 function selectionAt(path2) {
   return {
@@ -18253,6 +18531,7 @@ function createInternalEditor(config) {
         case "invalid value":
         case "loading":
         case "mutation":
+        case "operation":
         case "patch":
         case "read only":
         case "ready":
@@ -18295,6 +18574,16 @@ function editorConfigToMachineInput(config) {
     initialValue: config.initialValue
   };
 }
+const publicOperationTypeRecord = {
+  insert: !0,
+  "insert.text": !0,
+  "remove.text": !0,
+  set: !0,
+  unset: !0
+}, publicOperationTypes = new Set(Object.keys(publicOperationTypeRecord));
+function isPublicOperation(operation) {
+  return publicOperationTypes.has(operation.type);
+}
 function createActors(config) {
   debug.setup("creating new actors");
   const mutationBatcher = createMutationBatcher({
@@ -18312,7 +18601,12 @@ function createActors(config) {
       editorEngine: config.editorEngine
     }
   });
-  return config.subscriptions.push(mutationBatcher.subscribe), config.subscriptions.push(() => {
+  return config.subscriptions.push(mutationBatcher.subscribe), config.subscriptions.push(() => subscribeToOperations(config.editorEngine, (event) => {
+    isPublicOperation(event.operation) && config.relay.send({
+      type: "operation",
+      operation: event.operation
+    });
+  })), config.subscriptions.push(() => {
     const subscription = syncActor.on("*", (event) => {
       switch (event.type) {
         case "invalid value":