@lexical/yjs 0.36.2 → 0.36.3-nightly.20251003.0

package/LexicalYjs.dev.js

@@ -235,6 +235,35 @@ function isExcludedProperty(name, node, binding) {
   const excludedProperties = binding.excludedProperties.get(nodeKlass);
   return excludedProperties != null && excludedProperties.has(name);
 }
+function initializeNodeProperties(binding) {
+  const {
+    editor,
+    nodeProperties
+  } = binding;
+  editor.update(() => {
+    editor._nodes.forEach(nodeInfo => {
+      const node = new nodeInfo.klass();
+      const defaultProperties = {};
+      for (const [property, value] of Object.entries(node)) {
+        if (!isExcludedProperty(property, node, binding)) {
+          defaultProperties[property] = value;
+        }
+      }
+      nodeProperties.set(node.__type, Object.freeze(defaultProperties));
+    });
+  });
+}
+function getDefaultNodeProperties(node, binding) {
+  const type = node.__type;
+  const {
+    nodeProperties
+  } = binding;
+  const properties = nodeProperties.get(type);
+  if (!(properties !== undefined)) {
+    formatDevErrorMessage(`Node properties for ${type} not initialized for sync`);
+  }
+  return properties;
+}
 function $createCollabNodeFromLexicalNode(binding, lexicalNode, parent) {
   const nodeType = lexicalNode.__type;
   let collabNode;
@@ -325,16 +354,16 @@ function createLexicalNodeFromCollabNode(binding, collabNode, parentKey) {
   return lexicalNode;
 }
 function $syncPropertiesFromYjs(binding, sharedType, lexicalNode, keysChanged) {
-  const properties = keysChanged === null ? sharedType instanceof yjs.Map ? Array.from(sharedType.keys()) : Object.keys(sharedType.getAttributes()) : Array.from(keysChanged);
+  const properties = keysChanged === null ? sharedType instanceof yjs.Map ? Array.from(sharedType.keys()) : sharedType instanceof yjs.XmlText || sharedType instanceof yjs.XmlElement ? Object.keys(sharedType.getAttributes()) : Object.keys(sharedType) : Array.from(keysChanged);
   let writableNode;
   for (let i = 0; i < properties.length; i++) {
     const property = properties[i];
     if (isExcludedProperty(property, lexicalNode, binding)) {
-      if (property === '__state') {
+      if (property === '__state' && isBindingV1(binding)) {
         if (!writableNode) {
           writableNode = lexicalNode.getWritable();
         }
-        $syncNodeStateToLexical(binding, sharedType, writableNode);
+        $syncNodeStateToLexical(sharedType, writableNode);
       }
       continue;
     }
@@ -365,8 +394,10 @@ function $syncPropertiesFromYjs(binding, sharedType, lexicalNode, keysChanged) {
 function sharedTypeGet(sharedType, property) {
   if (sharedType instanceof yjs.Map) {
     return sharedType.get(property);
-  } else {
+  } else if (sharedType instanceof yjs.XmlText || sharedType instanceof yjs.XmlElement) {
     return sharedType.getAttribute(property);
+  } else {
+    return sharedType[property];
   }
 }
 function sharedTypeSet(sharedType, property, nextValue) {
@@ -376,7 +407,7 @@ function sharedTypeSet(sharedType, property, nextValue) {
     sharedType.setAttribute(property, nextValue);
   }
 }
-function $syncNodeStateToLexical(binding, sharedType, lexicalNode) {
+function $syncNodeStateToLexical(sharedType, lexicalNode) {
   const existingState = sharedTypeGet(sharedType, '__state');
   if (!(existingState instanceof yjs.Map)) {
     return;
@@ -416,15 +447,7 @@ function syncNodeStateFromLexical(binding, sharedType, prevLexicalNode, nextLexi
   }
 }
 function syncPropertiesFromLexical(binding, sharedType, prevLexicalNode, nextLexicalNode) {
-  const type = nextLexicalNode.__type;
-  const nodeProperties = binding.nodeProperties;
-  let properties = nodeProperties.get(type);
-  if (properties === undefined) {
-    properties = Object.keys(nextLexicalNode).filter(property => {
-      return !isExcludedProperty(property, nextLexicalNode, binding);
-    });
-    nodeProperties.set(type, properties);
-  }
+  const properties = Object.keys(getDefaultNodeProperties(nextLexicalNode, binding));
   const EditorClass = binding.editor.constructor;
   syncNodeStateFromLexical(binding, sharedType, prevLexicalNode, nextLexicalNode);
   for (let i = 0; i < properties.length; i++) {
@@ -1065,16 +1088,98 @@ function $createCollabElementNode(xmlText, parent, type) {
   return collabNode;
 }
 
-function createBinding(editor, provider, id, doc, docMap, excludedProperties) {
+// Stores mappings between Yjs shared types and the Lexical nodes they were last associated with.
+class CollabV2Mapping {
+  _nodeMap = new Map();
+  _sharedTypeToNodeKeys = new Map();
+  _nodeKeyToSharedType = new Map();
+  set(sharedType, node) {
+    const isArray = node instanceof Array;
+
+    // Clear all existing associations for this key.
+    this.delete(sharedType);
+
+    // If nodes were associated with other shared types, remove those associations.
+    const nodes = isArray ? node : [node];
+    for (const n of nodes) {
+      const key = n.getKey();
+      if (this._nodeKeyToSharedType.has(key)) {
+        const otherSharedType = this._nodeKeyToSharedType.get(key);
+        const keyIndex = this._sharedTypeToNodeKeys.get(otherSharedType).indexOf(key);
+        if (keyIndex !== -1) {
+          this._sharedTypeToNodeKeys.get(otherSharedType).splice(keyIndex, 1);
+        }
+        this._nodeKeyToSharedType.delete(key);
+        this._nodeMap.delete(key);
+      }
+    }
+    if (sharedType instanceof yjs.XmlText) {
+      if (!isArray) {
+        formatDevErrorMessage(`Text nodes must be mapped as an array`);
+      }
+      if (node.length === 0) {
+        return;
+      }
+      this._sharedTypeToNodeKeys.set(sharedType, node.map(n => n.getKey()));
+      for (const n of node) {
+        this._nodeMap.set(n.getKey(), n);
+        this._nodeKeyToSharedType.set(n.getKey(), sharedType);
+      }
+    } else {
+      if (!!isArray) {
+        formatDevErrorMessage(`Element nodes must be mapped as a single node`);
+      }
+      if (!!lexical.$isTextNode(node)) {
+        formatDevErrorMessage(`Text nodes must be mapped to XmlText`);
+      }
+      this._sharedTypeToNodeKeys.set(sharedType, [node.getKey()]);
+      this._nodeMap.set(node.getKey(), node);
+      this._nodeKeyToSharedType.set(node.getKey(), sharedType);
+    }
+  }
+  get(sharedType) {
+    const nodes = this._sharedTypeToNodeKeys.get(sharedType);
+    if (nodes === undefined) {
+      return undefined;
+    }
+    if (sharedType instanceof yjs.XmlText) {
+      const arr = Array.from(nodes.map(nodeKey => this._nodeMap.get(nodeKey)));
+      return arr.length > 0 ? arr : undefined;
+    }
+    return this._nodeMap.get(nodes[0]);
+  }
+  getSharedType(node) {
+    return this._nodeKeyToSharedType.get(node.getKey());
+  }
+  delete(sharedType) {
+    const nodeKeys = this._sharedTypeToNodeKeys.get(sharedType);
+    if (nodeKeys === undefined) {
+      return;
+    }
+    for (const nodeKey of nodeKeys) {
+      this._nodeMap.delete(nodeKey);
+      this._nodeKeyToSharedType.delete(nodeKey);
+    }
+    this._sharedTypeToNodeKeys.delete(sharedType);
+  }
+  deleteNode(nodeKey) {
+    const sharedType = this._nodeKeyToSharedType.get(nodeKey);
+    if (sharedType) {
+      this.delete(sharedType);
+    }
+    this._nodeMap.delete(nodeKey);
+  }
+  has(sharedType) {
+    return this._sharedTypeToNodeKeys.has(sharedType);
+  }
+}
+
+function createBaseBinding(editor, id, doc, docMap, excludedProperties) {
   if (!(doc !== undefined && doc !== null)) {
     formatDevErrorMessage(`createBinding: doc is null or undefined`);
   }
-  const rootXmlText = doc.get('root', yjs.XmlText);
-  const root = $createCollabElementNode(rootXmlText, null, 'root');
-  root._key = 'root';
-  return {
+  const binding = {
     clientID: doc.clientID,
-    collabNodeMap: new Map(),
     cursors: new Map(),
     cursorsContainer: null,
     doc,
@@ -1082,10 +1187,41 @@ function createBinding(editor, provider, id, doc, docMap, excludedProperties) {
     editor,
     excludedProperties: excludedProperties || new Map(),
     id,
-    nodeProperties: new Map(),
+    nodeProperties: new Map()
+  };
+  initializeNodeProperties(binding);
+  return binding;
+}
+function createBinding(editor, provider, id, doc, docMap, excludedProperties) {
+  if (!(doc !== undefined && doc !== null)) {
+    formatDevErrorMessage(`createBinding: doc is null or undefined`);
+  }
+  const rootXmlText = doc.get('root', yjs.XmlText);
+  const root = $createCollabElementNode(rootXmlText, null, 'root');
+  root._key = 'root';
+  return {
+    ...createBaseBinding(editor, id, doc, docMap, excludedProperties),
+    collabNodeMap: new Map(),
     root
   };
 }
+function createBindingV2__EXPERIMENTAL(editor, id, doc, docMap, options = {}) {
+  if (!(doc !== undefined && doc !== null)) {
+    formatDevErrorMessage(`createBinding: doc is null or undefined`);
+  }
+  const {
+    excludedProperties,
+    rootName = 'root-v2'
+  } = options;
+  return {
+    ...createBaseBinding(editor, id, doc, docMap, excludedProperties),
+    mapping: new CollabV2Mapping(),
+    root: doc.get(rootName, yjs.XmlElement)
+  };
+}
+function isBindingV1(binding) {
+  return Object.hasOwn(binding, 'collabNodeMap');
+}
 
 function createRelativePosition(point, binding) {
   const collabNodeMap = binding.collabNodeMap;
@@ -1122,6 +1258,49 @@ function createRelativePosition(point, binding) {
   }
   return yjs.createRelativePositionFromTypeIndex(sharedType, offset);
 }
+function createRelativePositionV2(point, binding) {
+  const {
+    mapping
+  } = binding;
+  const {
+    offset
+  } = point;
+  const node = point.getNode();
+  const yType = mapping.getSharedType(node);
+  if (yType === undefined) {
+    return null;
+  }
+  if (point.type === 'text') {
+    if (!lexical.$isTextNode(node)) {
+      formatDevErrorMessage(`Text point must be a text node`);
+    }
+    let prevSibling = node.getPreviousSibling();
+    let adjustedOffset = offset;
+    while (lexical.$isTextNode(prevSibling)) {
+      adjustedOffset += prevSibling.getTextContentSize();
+      prevSibling = prevSibling.getPreviousSibling();
+    }
+    return yjs.createRelativePositionFromTypeIndex(yType, adjustedOffset);
+  } else if (point.type === 'element') {
+    if (!lexical.$isElementNode(node)) {
+      formatDevErrorMessage(`Element point must be an element node`);
+    }
+    let i = 0;
+    let child = node.getFirstChild();
+    while (child !== null && i < offset) {
+      if (lexical.$isTextNode(child)) {
+        let nextSibling = child.getNextSibling();
+        while (lexical.$isTextNode(nextSibling)) {
+          nextSibling = nextSibling.getNextSibling();
+        }
+      }
+      i++;
+      child = child.getNextSibling();
+    }
+    return yjs.createRelativePositionFromTypeIndex(yType, i);
+  }
+  return null;
+}
 function createAbsolutePosition(relativePosition, binding) {
   return yjs.createAbsolutePositionFromRelativePosition(relativePosition, binding.doc);
 }
@@ -1263,6 +1442,9 @@ function updateCursor(binding, cursor, nextSelection, nodeMap) {
     selections.pop();
   }
 }
+/**
+ * @deprecated Use `$getAnchorAndFocusForUserState` instead.
+ */
 function getAnchorAndFocusCollabNodesForUserState(binding, userState) {
   const {
     anchorPos,
@@ -1287,6 +1469,56 @@ function getAnchorAndFocusCollabNodesForUserState(binding, userState) {
     focusOffset
   };
 }
+function $getAnchorAndFocusForUserState(binding, userState) {
+  const {
+    anchorPos,
+    focusPos
+  } = userState;
+  const anchorAbsPos = anchorPos ? createAbsolutePosition(anchorPos, binding) : null;
+  const focusAbsPos = focusPos ? createAbsolutePosition(focusPos, binding) : null;
+  if (anchorAbsPos === null || focusAbsPos === null) {
+    return {
+      anchorKey: null,
+      anchorOffset: 0,
+      focusKey: null,
+      focusOffset: 0
+    };
+  }
+  if (isBindingV1(binding)) {
+    const [anchorCollabNode, anchorOffset] = getCollabNodeAndOffset(anchorAbsPos.type, anchorAbsPos.index);
+    const [focusCollabNode, focusOffset] = getCollabNodeAndOffset(focusAbsPos.type, focusAbsPos.index);
+    return {
+      anchorKey: anchorCollabNode !== null ? anchorCollabNode.getKey() : null,
+      anchorOffset,
+      focusKey: focusCollabNode !== null ? focusCollabNode.getKey() : null,
+      focusOffset
+    };
+  }
+  let [anchorNode, anchorOffset] = $getNodeAndOffsetV2(binding.mapping, anchorAbsPos);
+  let [focusNode, focusOffset] = $getNodeAndOffsetV2(binding.mapping, focusAbsPos);
+  // For a non-collapsed selection, if the start of the selection is as the end of a text node,
+  // move it to the beginning of the next text node (if one exists).
+  if (focusNode && anchorNode && (focusNode !== anchorNode || focusOffset !== anchorOffset)) {
+    const isBackwards = focusNode.isBefore(anchorNode);
+    const startNode = isBackwards ? focusNode : anchorNode;
+    const startOffset = isBackwards ? focusOffset : anchorOffset;
+    if (lexical.$isTextNode(startNode) && lexical.$isTextNode(startNode.getNextSibling()) && startOffset === startNode.getTextContentSize()) {
+      if (isBackwards) {
+        focusNode = startNode.getNextSibling();
+        focusOffset = 0;
+      } else {
+        anchorNode = startNode.getNextSibling();
+        anchorOffset = 0;
+      }
+    }
+  }
+  return {
+    anchorKey: anchorNode !== null ? anchorNode.getKey() : null,
+    anchorOffset,
+    focusKey: focusNode !== null ? focusNode.getKey() : null,
+    focusOffset
+  };
+}
 function $syncLocalCursorPosition(binding, provider) {
   const awareness = provider.awareness;
   const localState = awareness.getLocalState();
@@ -1294,14 +1526,12 @@ function $syncLocalCursorPosition(binding, provider) {
     return;
   }
   const {
-    anchorCollabNode,
+    anchorKey,
     anchorOffset,
-    focusCollabNode,
+    focusKey,
     focusOffset
-  } = getAnchorAndFocusCollabNodesForUserState(binding, localState);
-  if (anchorCollabNode !== null && focusCollabNode !== null) {
-    const anchorKey = anchorCollabNode.getKey();
-    const focusKey = focusCollabNode.getKey();
+  } = $getAnchorAndFocusForUserState(binding, localState);
+  if (anchorKey !== null && focusKey !== null) {
     const selection = lexical.$getSelection();
     if (!lexical.$isRangeSelection(selection)) {
       return;
@@ -1342,6 +1572,46 @@ sharedType, offset) {
   }
   return [null, 0];
 }
+function $getNodeAndOffsetV2(mapping, absolutePosition) {
+  const yType = absolutePosition.type;
+  const yOffset = absolutePosition.index;
+  if (yType instanceof yjs.XmlElement) {
+    const node = mapping.get(yType);
+    if (node === undefined) {
+      return [null, 0];
+    }
+    if (!lexical.$isElementNode(node)) {
+      return [node, yOffset];
+    }
+    let remainingYOffset = yOffset;
+    let lexicalOffset = 0;
+    const children = node.getChildren();
+    while (remainingYOffset > 0 && lexicalOffset < children.length) {
+      const child = children[lexicalOffset];
+      remainingYOffset -= 1;
+      lexicalOffset += 1;
+      if (lexical.$isTextNode(child)) {
+        while (lexicalOffset < children.length && lexical.$isTextNode(children[lexicalOffset])) {
+          lexicalOffset += 1;
+        }
+      }
+    }
+    return [node, lexicalOffset];
+  } else {
+    const nodes = mapping.get(yType);
+    if (nodes === undefined) {
+      return [null, 0];
+    }
+    let i = 0;
+    let adjustedOffset = yOffset;
+    while (adjustedOffset > nodes[i].getTextContentSize() && i + 1 < nodes.length) {
+      adjustedOffset -= nodes[i].getTextContentSize();
+      i++;
+    }
+    const textNode = nodes[i];
+    return [textNode, Math.min(adjustedOffset, textNode.getTextContentSize())];
+  }
+}
 function getAwarenessStatesDefault(_binding, provider) {
   return provider.awareness.getStates();
 }
@@ -1373,14 +1643,12 @@ function syncCursorPositions(binding, provider, options) {
       }
       if (focusing) {
         const {
-          anchorCollabNode,
+          anchorKey,
           anchorOffset,
-          focusCollabNode,
+          focusKey,
           focusOffset
-        } = getAnchorAndFocusCollabNodesForUserState(binding, awareness);
-        if (anchorCollabNode !== null && focusCollabNode !== null) {
-          const anchorKey = anchorCollabNode.getKey();
-          const focusKey = focusCollabNode.getKey();
+        } = editor.read(() => $getAnchorAndFocusForUserState(binding, awareness));
+        if (anchorKey !== null && focusKey !== null) {
           selection = cursor.selection;
           if (selection === null) {
             selection = createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset);
@@ -1431,8 +1699,13 @@ function syncLexicalSelectionToYjs(binding, provider, prevSelection, nextSelecti
     }
   }
   if (lexical.$isRangeSelection(nextSelection)) {
-    anchorPos = createRelativePosition(nextSelection.anchor, binding);
-    focusPos = createRelativePosition(nextSelection.focus, binding);
+    if (isBindingV1(binding)) {
+      anchorPos = createRelativePosition(nextSelection.anchor, binding);
+      focusPos = createRelativePosition(nextSelection.focus, binding);
+    } else {
+      anchorPos = createRelativePositionV2(nextSelection.anchor, binding);
+      focusPos = createRelativePositionV2(nextSelection.focus, binding);
+    }
   }
   if (shouldUpdatePosition(currentAnchorPos, anchorPos) || shouldUpdatePosition(currentFocusPos, focusPos)) {
     awareness.setLocalState({
@@ -1447,6 +1720,568 @@ function syncLexicalSelectionToYjs(binding, provider, prevSelection, nextSelecti
   }
 }
 
+/*
+const isVisible = (item: Item, snapshot?: Snapshot): boolean =>
+  snapshot === undefined
+    ? !item.deleted
+    : snapshot.sv.has(item.id.client) &&
+      snapshot.sv.get(item.id.client)! > item.id.clock &&
+      !isDeleted(snapshot.ds, item.id);
+*/
+
+// https://docs.yjs.dev/api/shared-types/y.xmlelement
+// "Define a top-level type; Note that the nodeName is always "undefined""
+const isRootElement = el => el.nodeName === 'UNDEFINED';
+const $createOrUpdateNodeFromYElement = (el, binding, keysChanged, childListChanged, snapshot, prevSnapshot, computeYChange) => {
+  let node = binding.mapping.get(el);
+  if (node && keysChanged && keysChanged.size === 0 && !childListChanged) {
+    return node;
+  }
+  const type = isRootElement(el) ? lexical.RootNode.getType() : el.nodeName;
+  const registeredNodes = binding.editor._nodes;
+  const nodeInfo = registeredNodes.get(type);
+  if (nodeInfo === undefined) {
+    throw new Error(`$createOrUpdateNodeFromYElement: Node ${type} is not registered`);
+  }
+  if (!node) {
+    node = new nodeInfo.klass();
+    keysChanged = null;
+    childListChanged = true;
+  }
+  if (childListChanged && node instanceof lexical.ElementNode) {
+    const children = [];
+    const $createChildren = childType => {
+      if (childType instanceof yjs.XmlElement) {
+        const n = $createOrUpdateNodeFromYElement(childType, binding, new Set(), false, snapshot, prevSnapshot, computeYChange);
+        if (n !== null) {
+          children.push(n);
+        }
+      } else if (childType instanceof yjs.XmlText) {
+        const ns = $createOrUpdateTextNodesFromYText(childType, binding, snapshot, prevSnapshot, computeYChange);
+        if (ns !== null) {
+          ns.forEach(textchild => {
+            if (textchild !== null) {
+              children.push(textchild);
+            }
+          });
+        }
+      } else {
+        {
+          formatDevErrorMessage(`XmlHook is not supported`);
+        }
+      }
+    };
+    {
+      el.toArray().forEach($createChildren);
+    }
+    $spliceChildren(node, children);
+  }
+  const attrs = el.getAttributes(snapshot);
+  // TODO(collab-v2): support for ychange
+  /*
+  if (snapshot !== undefined) {
+    if (!isVisible(el._item!, snapshot)) {
+      attrs.ychange = computeYChange
+        ? computeYChange('removed', el._item!.id)
+        : {type: 'removed'};
+    } else if (!isVisible(el._item!, prevSnapshot)) {
+      attrs.ychange = computeYChange
+        ? computeYChange('added', el._item!.id)
+        : {type: 'added'};
+    }
+  }
+  */
+  const properties = {
+    ...getDefaultNodeProperties(node, binding)
+  };
+  const state = {};
+  for (const k in attrs) {
+    if (k.startsWith(STATE_KEY_PREFIX)) {
+      state[attrKeyToStateKey(k)] = attrs[k];
+    } else {
+      properties[k] = attrs[k];
+    }
+  }
+  $syncPropertiesFromYjs(binding, properties, node, keysChanged);
+  if (!keysChanged) {
+    lexical.$getWritableNodeState(node).updateFromJSON(state);
+  } else {
+    const stateKeysChanged = Object.keys(state).filter(k => keysChanged.has(stateKeyToAttrKey(k)));
+    if (stateKeysChanged.length > 0) {
+      const writableState = lexical.$getWritableNodeState(node);
+      for (const k of stateKeysChanged) {
+        writableState.updateFromUnknown(k, state[k]);
+      }
+    }
+  }
+  const latestNode = node.getLatest();
+  binding.mapping.set(el, latestNode);
+  return latestNode;
+};
+const $spliceChildren = (node, nextChildren) => {
+  const prevChildren = node.getChildren();
+  const prevChildrenKeySet = new Set(prevChildren.map(child => child.getKey()));
+  const nextChildrenKeySet = new Set(nextChildren.map(child => child.getKey()));
+  const prevEndIndex = prevChildren.length - 1;
+  const nextEndIndex = nextChildren.length - 1;
+  let prevIndex = 0;
+  let nextIndex = 0;
+  while (prevIndex <= prevEndIndex && nextIndex <= nextEndIndex) {
+    const prevKey = prevChildren[prevIndex].getKey();
+    const nextKey = nextChildren[nextIndex].getKey();
+    if (prevKey === nextKey) {
+      prevIndex++;
+      nextIndex++;
+      continue;
+    }
+    const nextHasPrevKey = nextChildrenKeySet.has(prevKey);
+    const prevHasNextKey = prevChildrenKeySet.has(nextKey);
+    if (!nextHasPrevKey) {
+      // If removing the last node, insert remaining new nodes immediately, otherwise if the node
+      // cannot be empty, it will remove itself from its parent.
+      if (nextIndex === 0 && node.getChildrenSize() === 1) {
+        node.splice(nextIndex, 1, nextChildren.slice(nextIndex));
+        return;
+      }
+      // Remove
+      node.splice(nextIndex, 1, []);
+      prevIndex++;
+      continue;
+    }
+
+    // Create or replace
+    const nextChildNode = nextChildren[nextIndex];
+    if (prevHasNextKey) {
+      node.splice(nextIndex, 1, [nextChildNode]);
+      prevIndex++;
+      nextIndex++;
+    } else {
+      node.splice(nextIndex, 0, [nextChildNode]);
+      nextIndex++;
+    }
+  }
+  const appendNewChildren = prevIndex > prevEndIndex;
+  const removeOldChildren = nextIndex > nextEndIndex;
+  if (appendNewChildren && !removeOldChildren) {
+    node.append(...nextChildren.slice(nextIndex));
+  } else if (removeOldChildren && !appendNewChildren) {
+    node.splice(nextChildren.length, node.getChildrenSize() - nextChildren.length, []);
+  }
+};
+const $createOrUpdateTextNodesFromYText = (text, binding, snapshot, prevSnapshot, computeYChange) => {
+  const deltas = toDelta(text, snapshot, prevSnapshot, computeYChange);
+
+  // Use existing text nodes if the count and types all align, otherwise throw out the existing
+  // nodes and create new ones.
+  let nodes = binding.mapping.get(text) ?? [];
+  const nodeTypes = deltas.map(delta => delta.attributes.t ?? lexical.TextNode.getType());
+  const canReuseNodes = nodes.length === nodeTypes.length && nodes.every((node, i) => node.getType() === nodeTypes[i]);
+  if (!canReuseNodes) {
+    const registeredNodes = binding.editor._nodes;
+    nodes = nodeTypes.map(type => {
+      const nodeInfo = registeredNodes.get(type);
+      if (nodeInfo === undefined) {
+        throw new Error(`$createTextNodesFromYText: Node ${type} is not registered`);
+      }
+      const node = new nodeInfo.klass();
+      if (!lexical.$isTextNode(node)) {
+        throw new Error(`$createTextNodesFromYText: Node ${type} is not a TextNode`);
+      }
+      return node;
+    });
+  }
+
+  // Sync text, properties and state to the text nodes.
+  for (let i = 0; i < deltas.length; i++) {
+    const node = nodes[i];
+    const delta = deltas[i];
+    const {
+      attributes,
+      insert
+    } = delta;
+    if (node.__text !== insert) {
+      node.setTextContent(insert);
+    }
+    const properties = {
+      ...getDefaultNodeProperties(node, binding),
+      ...attributes.p
+    };
+    const state = Object.fromEntries(Object.entries(attributes).filter(([k]) => k.startsWith(STATE_KEY_PREFIX)).map(([k, v]) => [attrKeyToStateKey(k), v]));
+    $syncPropertiesFromYjs(binding, properties, node, null);
+    lexical.$getWritableNodeState(node).updateFromJSON(state);
+  }
+  const latestNodes = nodes.map(node => node.getLatest());
+  binding.mapping.set(text, latestNodes);
+  return latestNodes;
+};
+const $createTypeFromTextNodes = (nodes, binding) => {
+  const type = new yjs.XmlText();
+  $updateYText(type, nodes, binding);
+  return type;
+};
+const createTypeFromElementNode = (node, binding) => {
+  const type = new yjs.XmlElement(node.getType());
+  const attrs = {
+    ...propertiesToAttributes(node, binding),
+    ...stateToAttributes(node)
+  };
+  for (const key in attrs) {
+    const val = attrs[key];
+    if (val !== null) {
+      // TODO(collab-v2): typing for XmlElement generic
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      type.setAttribute(key, val);
+    }
+  }
+  if (!(node instanceof lexical.ElementNode)) {
+    return type;
+  }
+  type.insert(0, normalizeNodeContent(node).map(n => $createTypeFromTextOrElementNode(n, binding)));
+  binding.mapping.set(type, node);
+  return type;
+};
+const $createTypeFromTextOrElementNode = (node, meta) => node instanceof Array ? $createTypeFromTextNodes(node, meta) : createTypeFromElementNode(node, meta);
+const isObject = val => typeof val === 'object' && val != null;
+const equalAttrs = (pattrs, yattrs) => {
+  const keys = Object.keys(pattrs).filter(key => pattrs[key] !== null);
+  if (yattrs == null) {
+    return keys.length === 0;
+  }
+  let eq = keys.length === Object.keys(yattrs).filter(key => yattrs[key] !== null).length;
+  for (let i = 0; i < keys.length && eq; i++) {
+    const key = keys[i];
+    const l = pattrs[key];
+    const r = yattrs[key];
+    eq = key === 'ychange' || l === r || isObject(l) && isObject(r) && equalAttrs(l, r);
+  }
+  return eq;
+};
+const normalizeNodeContent = node => {
+  if (!(node instanceof lexical.ElementNode)) {
+    return [];
+  }
+  const c = node.getChildren();
+  const res = [];
+  for (let i = 0; i < c.length; i++) {
+    const n = c[i];
+    if (lexical.$isTextNode(n)) {
+      const textNodes = [];
+      for (let maybeTextNode = c[i]; i < c.length && lexical.$isTextNode(maybeTextNode); maybeTextNode = c[++i]) {
+        textNodes.push(maybeTextNode);
+      }
+      i--;
+      res.push(textNodes);
+    } else {
+      res.push(n);
+    }
+  }
+  return res;
+};
+const equalYTextLText = (ytext, ltexts, binding) => {
+  const deltas = toDelta(ytext);
+  return deltas.length === ltexts.length && deltas.every((d, i) => {
+    const ltext = ltexts[i];
+    const type = d.attributes.t ?? lexical.TextNode.getType();
+    const propertyAttrs = d.attributes.p ?? {};
+    const stateAttrs = Object.fromEntries(Object.entries(d.attributes).filter(([k]) => k.startsWith(STATE_KEY_PREFIX)));
+    return d.insert === ltext.getTextContent() && type === ltext.getType() && equalAttrs(propertyAttrs, propertiesToAttributes(ltext, binding)) && equalAttrs(stateAttrs, stateToAttributes(ltext));
+  });
+};
+const equalYTypePNode = (ytype, lnode, binding) => {
+  if (ytype instanceof yjs.XmlElement && !(lnode instanceof Array) && matchNodeName(ytype, lnode)) {
+    const normalizedContent = normalizeNodeContent(lnode);
+    return ytype._length === normalizedContent.length && equalAttrs(ytype.getAttributes(), {
+      ...propertiesToAttributes(lnode, binding),
+      ...stateToAttributes(lnode)
+    }) && ytype.toArray().every((ychild, i) => equalYTypePNode(ychild, normalizedContent[i], binding));
+  }
+  return ytype instanceof yjs.XmlText && lnode instanceof Array && equalYTextLText(ytype, lnode, binding);
+};
+const mappedIdentity = (mapped, lcontent) => mapped === lcontent || mapped instanceof Array && lcontent instanceof Array && mapped.length === lcontent.length && mapped.every((a, i) => lcontent[i] === a);
+const computeChildEqualityFactor = (ytype, lnode, binding) => {
+  const yChildren = ytype.toArray();
+  const pChildren = normalizeNodeContent(lnode);
+  const pChildCnt = pChildren.length;
+  const yChildCnt = yChildren.length;
+  const minCnt = Math.min(yChildCnt, pChildCnt);
+  let left = 0;
+  let right = 0;
+  let foundMappedChild = false;
+  for (; left < minCnt; left++) {
+    const leftY = yChildren[left];
+    const leftP = pChildren[left];
+    if (leftY instanceof yjs.XmlHook) {
+      break;
+    } else if (mappedIdentity(binding.mapping.get(leftY), leftP)) {
+      foundMappedChild = true; // definite (good) match!
+    } else if (!equalYTypePNode(leftY, leftP, binding)) {
+      break;
+    }
+  }
+  for (; left + right < minCnt; right++) {
+    const rightY = yChildren[yChildCnt - right - 1];
+    const rightP = pChildren[pChildCnt - right - 1];
+    if (rightY instanceof yjs.XmlHook) {
+      break;
+    } else if (mappedIdentity(binding.mapping.get(rightY), rightP)) {
+      foundMappedChild = true;
+    } else if (!equalYTypePNode(rightY, rightP, binding)) {
+      break;
+    }
+  }
+  return {
+    equalityFactor: left + right,
+    foundMappedChild
+  };
+};
+const ytextTrans = ytext => {
+  let str = '';
+  let n = ytext._start;
+  const nAttrs = {};
+  while (n !== null) {
+    if (!n.deleted) {
+      if (n.countable && n.content instanceof yjs.ContentString) {
+        str += n.content.str;
+      } else if (n.content instanceof yjs.ContentFormat) {
+        nAttrs[n.content.key] = null;
+      }
+    }
+    n = n.right;
+  }
+  return {
+    nAttrs,
+    str
+  };
+};
+const $updateYText = (ytext, ltexts, binding) => {
+  binding.mapping.set(ytext, ltexts);
+  const {
+    nAttrs,
+    str
+  } = ytextTrans(ytext);
+  const content = ltexts.map((node, i) => {
+    const nodeType = node.getType();
+    let p = propertiesToAttributes(node, binding);
+    if (Object.keys(p).length === 0) {
+      p = null;
+    }
+    return {
+      attributes: Object.assign({}, nAttrs, {
+        ...(nodeType !== lexical.TextNode.getType() && {
+          t: nodeType
+        }),
+        p,
+        ...stateToAttributes(node),
+        ...(i > 0 && {
+          i
+        }) // Prevent Yjs from merging text nodes itself.
+      }),
+      insert: node.getTextContent(),
+      nodeKey: node.getKey()
+    };
+  });
+  const nextText = content.map(c => c.insert).join('');
+  const selection = lexical.$getSelection();
+  let cursorOffset;
+  if (lexical.$isRangeSelection(selection) && selection.isCollapsed()) {
+    cursorOffset = 0;
+    for (const c of content) {
+      if (c.nodeKey === selection.anchor.key) {
+        cursorOffset += selection.anchor.offset;
+        break;
+      }
+      cursorOffset += c.insert.length;
+    }
+  } else {
+    cursorOffset = nextText.length;
+  }
+  const {
+    insert,
+    remove,
+    index
+  } = simpleDiffWithCursor(str, nextText, cursorOffset);
+  ytext.delete(index, remove);
+  ytext.insert(index, insert);
+  ytext.applyDelta(content.map(c => ({
+    attributes: c.attributes,
+    retain: c.insert.length
+  })));
+};
+const toDelta = (ytext, snapshot, prevSnapshot, computeYChange) => {
+  return ytext.toDelta(snapshot, prevSnapshot, computeYChange).map(delta => ({
+    ...delta,
+    attributes: delta.attributes ?? {}
+  }));
+};
+const propertiesToAttributes = (node, meta) => {
+  const defaultProperties = getDefaultNodeProperties(node, meta);
+  const attrs = {};
+  Object.entries(defaultProperties).forEach(([property, defaultValue]) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const value = node[property];
+    if (value !== defaultValue) {
+      attrs[property] = value;
+    }
+  });
+  return attrs;
+};
+const STATE_KEY_PREFIX = 's_';
+const stateKeyToAttrKey = key => STATE_KEY_PREFIX + key;
+const attrKeyToStateKey = key => {
+  if (!key.startsWith(STATE_KEY_PREFIX)) {
+    throw new Error(`Invalid state key: ${key}`);
+  }
+  return key.slice(STATE_KEY_PREFIX.length);
+};
+const stateToAttributes = node => {
+  const state = node.__state;
+  if (!state) {
+    return {};
+  }
+  const [unknown = {}, known] = state.getInternalState();
+  const attrs = {};
+  for (const [k, v] of Object.entries(unknown)) {
+    attrs[stateKeyToAttrKey(k)] = v;
+  }
+  for (const [stateConfig, v] of known) {
+    attrs[stateKeyToAttrKey(stateConfig.key)] = stateConfig.unparse(v);
+  }
+  return attrs;
+};
+const $updateYFragment = (y, yDomFragment, node, binding, dirtyElements) => {
+  if (yDomFragment instanceof yjs.XmlElement && yDomFragment.nodeName !== node.getType() && !(isRootElement(yDomFragment) && node.getType() === lexical.RootNode.getType())) {
+    throw new Error('node name mismatch!');
+  }
+  binding.mapping.set(yDomFragment, node);
+  // update attributes
+  if (yDomFragment instanceof yjs.XmlElement) {
+    const yDomAttrs = yDomFragment.getAttributes();
+    const lexicalAttrs = {
+      ...propertiesToAttributes(node, binding),
+      ...stateToAttributes(node)
+    };
+    for (const key in lexicalAttrs) {
+      if (lexicalAttrs[key] != null) {
+        if (yDomAttrs[key] !== lexicalAttrs[key] && key !== 'ychange') {
+          // TODO(collab-v2): typing for XmlElement generic
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          yDomFragment.setAttribute(key, lexicalAttrs[key]);
+        }
+      } else {
+        yDomFragment.removeAttribute(key);
+      }
+    }
+    // remove all keys that are no longer in pAttrs
+    for (const key in yDomAttrs) {
+      if (lexicalAttrs[key] === undefined) {
+        yDomFragment.removeAttribute(key);
+      }
+    }
+  }
+  // update children
+  const lChildren = normalizeNodeContent(node);
+  const lChildCnt = lChildren.length;
+  const yChildren = yDomFragment.toArray();
+  const yChildCnt = yChildren.length;
+  const minCnt = Math.min(lChildCnt, yChildCnt);
+  let left = 0;
+  let right = 0;
+  // find number of matching elements from left
+  for (; left < minCnt; left++) {
+    const leftY = yChildren[left];
+    const leftL = lChildren[left];
+    if (leftY instanceof yjs.XmlHook) {
+      break;
+    } else if (mappedIdentity(binding.mapping.get(leftY), leftL)) {
+      if (leftL instanceof lexical.ElementNode && dirtyElements.has(leftL.getKey())) {
+        $updateYFragment(y, leftY, leftL, binding, dirtyElements);
+      }
+    } else if (equalYTypePNode(leftY, leftL, binding)) {
+      // update mapping
+      binding.mapping.set(leftY, leftL);
+    } else {
+      break;
+    }
+  }
+  // find number of matching elements from right
+  for (; right + left < minCnt; right++) {
+    const rightY = yChildren[yChildCnt - right - 1];
+    const rightL = lChildren[lChildCnt - right - 1];
+    if (rightY instanceof yjs.XmlHook) {
+      break;
+    } else if (mappedIdentity(binding.mapping.get(rightY), rightL)) {
+      if (rightL instanceof lexical.ElementNode && dirtyElements.has(rightL.getKey())) {
+        $updateYFragment(y, rightY, rightL, binding, dirtyElements);
+      }
+    } else if (equalYTypePNode(rightY, rightL, binding)) {
+      // update mapping
+      binding.mapping.set(rightY, rightL);
+    } else {
+      break;
+    }
+  }
+  // try to compare and update
+  while (yChildCnt - left - right > 0 && lChildCnt - left - right > 0) {
+    const leftY = yChildren[left];
+    const leftL = lChildren[left];
+    const rightY = yChildren[yChildCnt - right - 1];
+    const rightL = lChildren[lChildCnt - right - 1];
+    if (leftY instanceof yjs.XmlText && leftL instanceof Array) {
+      if (!equalYTextLText(leftY, leftL, binding)) {
+        $updateYText(leftY, leftL, binding);
+      }
+      left += 1;
+    } else {
+      let updateLeft = leftY instanceof yjs.XmlElement && matchNodeName(leftY, leftL);
+      let updateRight = rightY instanceof yjs.XmlElement && matchNodeName(rightY, rightL);
+      if (updateLeft && updateRight) {
+        // decide which which element to update
+        const equalityLeft = computeChildEqualityFactor(leftY, leftL, binding);
+        const equalityRight = computeChildEqualityFactor(rightY, rightL, binding);
+        if (equalityLeft.foundMappedChild && !equalityRight.foundMappedChild) {
+          updateRight = false;
+        } else if (!equalityLeft.foundMappedChild && equalityRight.foundMappedChild) {
+          updateLeft = false;
+        } else if (equalityLeft.equalityFactor < equalityRight.equalityFactor) {
+          updateLeft = false;
+        } else {
+          updateRight = false;
+        }
+      }
+      if (updateLeft) {
+        $updateYFragment(y, leftY, leftL, binding, dirtyElements);
+        left += 1;
+      } else if (updateRight) {
+        $updateYFragment(y, rightY, rightL, binding, dirtyElements);
+        right += 1;
+      } else {
+        binding.mapping.delete(yDomFragment.get(left));
+        yDomFragment.delete(left, 1);
+        yDomFragment.insert(left, [$createTypeFromTextOrElementNode(leftL, binding)]);
+        left += 1;
+      }
+    }
+  }
+  const yDelLen = yChildCnt - left - right;
+  if (yChildCnt === 1 && lChildCnt === 0 && yChildren[0] instanceof yjs.XmlText) {
+    binding.mapping.delete(yChildren[0]);
+    // Edge case handling https://github.com/yjs/y-prosemirror/issues/108
+    // Only delete the content of the Y.Text to retain remote changes on the same Y.Text object
+    yChildren[0].delete(0, yChildren[0].length);
+  } else if (yDelLen > 0) {
+    yDomFragment.slice(left, left + yDelLen).forEach(type => binding.mapping.delete(type));
+    yDomFragment.delete(left, yDelLen);
+  }
+  if (left + right < lChildCnt) {
+    const ins = [];
+    for (let i = left; i < lChildCnt - right; i++) {
+      ins.push($createTypeFromTextOrElementNode(lChildren[i], binding));
+    }
+    yDomFragment.insert(left, ins);
+  }
+};
+const matchNodeName = (yElement, lnode) => !(lnode instanceof Array) && yElement.nodeName === lnode.getType();
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function $syncStateEvent(binding, event) {
   const {
@@ -1533,23 +2368,7 @@ function syncYjsChangesToLexical(binding, provider, events, isFromUndoManger, sy
       const event = events[i];
       $syncEvent(binding, event);
     }
-    const selection = lexical.$getSelection();
-    if (lexical.$isRangeSelection(selection)) {
-      if (doesSelectionNeedRecovering(selection)) {
-        const prevSelection = currentEditorState._selection;
-        if (lexical.$isRangeSelection(prevSelection)) {
-          $syncLocalCursorPosition(binding, provider);
-          if (doesSelectionNeedRecovering(selection)) {
-            // If the selected node is deleted, move the selection to the previous or parent node.
-            const anchorNodeKey = selection.anchor.key;
-            $moveSelectionToPreviousNode(anchorNodeKey, currentEditorState);
-          }
-        }
-        syncLexicalSelectionToYjs(binding, provider, prevSelection, lexical.$getSelection());
-      } else {
-        $syncLocalCursorPosition(binding, provider);
-      }
-    }
+    $syncCursorFromYjs(currentEditorState, binding, provider);
     if (!isFromUndoManger) {
       // If it is an external change, we don't want the current scroll position to get changed
       // since the user might've intentionally scrolled somewhere else in the document.
@@ -1558,19 +2377,31 @@ function syncYjsChangesToLexical(binding, provider, events, isFromUndoManger, sy
   }, {
     onUpdate: () => {
       syncCursorPositionsFn(binding, provider);
-      // If there was a collision on the top level paragraph
-      // we need to re-add a paragraph. To ensure this insertion properly syncs with other clients,
-      // it must be placed outside of the update block above that has tags 'collaboration' or 'historic'.
-      editor.update(() => {
-        if (lexical.$getRoot().getChildrenSize() === 0) {
-          lexical.$getRoot().append(lexical.$createParagraphNode());
-        }
-      });
+      editor.update(() => $ensureEditorNotEmpty());
     },
     skipTransforms: true,
     tag: isFromUndoManger ? lexical.HISTORIC_TAG : lexical.COLLABORATION_TAG
   });
 }
+function $syncCursorFromYjs(editorState, binding, provider) {
+  const selection = lexical.$getSelection();
+  if (lexical.$isRangeSelection(selection)) {
+    if (doesSelectionNeedRecovering(selection)) {
+      const prevSelection = editorState._selection;
+      if (lexical.$isRangeSelection(prevSelection)) {
+        $syncLocalCursorPosition(binding, provider);
+        if (doesSelectionNeedRecovering(selection)) {
+          // If the selected node is deleted, move the selection to the previous or parent node.
+          const anchorNodeKey = selection.anchor.key;
+          $moveSelectionToPreviousNode(anchorNodeKey, editorState);
+        }
+      }
+      syncLexicalSelectionToYjs(binding, provider, prevSelection, lexical.$getSelection());
+    } else {
+      $syncLocalCursorPosition(binding, provider);
+    }
+  }
+}
 function $handleNormalizationMergeConflicts(binding, normalizedNodes) {
   // We handle the merge operations here
   const normalizedNodesKeys = Array.from(normalizedNodes);
@@ -1611,6 +2442,15 @@ function $handleNormalizationMergeConflicts(binding, normalizedNodes) {
     collabNode._text = text;
   }
 }
+
+// If there was a collision on the top level paragraph
+// we need to re-add a paragraph. To ensure this insertion properly syncs with other clients,
+// it must be placed outside of the update block above that has tags 'collaboration' or 'historic'.
+function $ensureEditorNotEmpty() {
+  if (lexical.$getRoot().getChildrenSize() === 0) {
+    lexical.$getRoot().append(lexical.$createParagraphNode());
+  }
+}
 function syncLexicalUpdateToYjs(binding, provider, prevEditorState, currEditorState, dirtyElements, dirtyLeaves, normalizedNodes, tags) {
   syncWithTransaction(binding, () => {
     currEditorState.read(() => {
@@ -1640,6 +2480,96 @@ function syncLexicalUpdateToYjs(binding, provider, prevEditorState, currEditorSt
     });
   });
 }
+function $syncEventV2(binding, event) {
+  const {
+    target
+  } = event;
+  if (target instanceof yjs.XmlElement && event instanceof yjs.YXmlEvent) {
+    $createOrUpdateNodeFromYElement(target, binding, event.attributesChanged,
+    // @ts-expect-error childListChanged is private
+    event.childListChanged);
+  } else if (target instanceof yjs.XmlText && event instanceof yjs.YTextEvent) {
+    const parent = target.parent;
+    if (parent instanceof yjs.XmlElement) {
+      // Need to sync via parent element in order to attach new next nodes.
+      $createOrUpdateNodeFromYElement(parent, binding, new Set(), true);
+    } else {
+      {
+        formatDevErrorMessage(`Expected XmlElement parent for XmlText`);
+      }
+    }
+  } else {
+    {
+      formatDevErrorMessage(`Expected xml or text event`);
+    }
+  }
+}
+function syncYjsChangesToLexicalV2__EXPERIMENTAL(binding, provider, events, transaction, isFromUndoManger) {
+  const editor = binding.editor;
+  const editorState = editor._editorState;
+
+  // Remove deleted nodes from the mapping
+  yjs.iterateDeletedStructs(transaction, transaction.deleteSet, struct => {
+    if (struct.constructor === yjs.Item) {
+      const content = struct.content;
+      const type = content.type;
+      if (type) {
+        binding.mapping.delete(type);
+      }
+    }
+  });
+
+  // This line precompute the delta before editor update. The reason is
+  // delta is computed when it is accessed. Note that this can only be
+  // safely computed during the event call. If it is accessed after event
+  // call it might result in unexpected behavior.
+  // https://github.com/yjs/yjs/blob/00ef472d68545cb260abd35c2de4b3b78719c9e4/src/utils/YEvent.js#L132
+  events.forEach(event => event.delta);
+  editor.update(() => {
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      $syncEventV2(binding, event);
+    }
+    $syncCursorFromYjs(editorState, binding, provider);
+    if (!isFromUndoManger) {
+      // If it is an external change, we don't want the current scroll position to get changed
+      // since the user might've intentionally scrolled somewhere else in the document.
+      lexical.$addUpdateTag(lexical.SKIP_SCROLL_INTO_VIEW_TAG);
+    }
+  }, {
+    // Need any text node normalization to be synchronously updated back to Yjs, otherwise the
+    // binding.mapping will get out of sync.
+    discrete: true,
+    onUpdate: () => {
+      syncCursorPositions(binding, provider);
+      editor.update(() => $ensureEditorNotEmpty());
+    },
+    skipTransforms: true,
+    tag: isFromUndoManger ? lexical.HISTORIC_TAG : lexical.COLLABORATION_TAG
+  });
+}
+function syncLexicalUpdateToYjsV2__EXPERIMENTAL(binding, provider, prevEditorState, currEditorState, dirtyElements, normalizedNodes, tags) {
+  const isFromYjs = tags.has(lexical.COLLABORATION_TAG) || tags.has(lexical.HISTORIC_TAG);
+  if (isFromYjs && normalizedNodes.size === 0) {
+    return;
+  }
+
+  // Nodes are normalized synchronously (`discrete: true` above), so the mapping may now be
+  // incorrect for these nodes, as they point to `getLatest` which is mutable within an update.
+  normalizedNodes.forEach(nodeKey => {
+    binding.mapping.deleteNode(nodeKey);
+  });
+  syncWithTransaction(binding, () => {
+    currEditorState.read(() => {
+      if (dirtyElements.has('root')) {
+        $updateYFragment(binding.doc, binding.root, lexical.$getRoot(), binding, new Set(dirtyElements.keys()));
+      }
+      const selection = lexical.$getSelection();
+      const prevSelection = prevEditorState._selection;
+      syncLexicalSelectionToYjs(binding, provider, prevSelection, selection);
+    });
+  });
+}
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1688,10 +2618,13 @@ function setLocalStateFocus(provider, name, color, focusing, awarenessData) {
 exports.CONNECTED_COMMAND = CONNECTED_COMMAND;
 exports.TOGGLE_CONNECT_COMMAND = TOGGLE_CONNECT_COMMAND;
 exports.createBinding = createBinding;
+exports.createBindingV2__EXPERIMENTAL = createBindingV2__EXPERIMENTAL;
 exports.createUndoManager = createUndoManager;
 exports.getAnchorAndFocusCollabNodesForUserState = getAnchorAndFocusCollabNodesForUserState;
 exports.initLocalState = initLocalState;
 exports.setLocalStateFocus = setLocalStateFocus;
 exports.syncCursorPositions = syncCursorPositions;
 exports.syncLexicalUpdateToYjs = syncLexicalUpdateToYjs;
+exports.syncLexicalUpdateToYjsV2__EXPERIMENTAL = syncLexicalUpdateToYjsV2__EXPERIMENTAL;
 exports.syncYjsChangesToLexical = syncYjsChangesToLexical;
+exports.syncYjsChangesToLexicalV2__EXPERIMENTAL = syncYjsChangesToLexicalV2__EXPERIMENTAL;