@lexical/yjs 0.1.6 → 0.1.10

package/LexicalYjs.dev.js

@@ -0,0 +1,2487 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var yjs = require('yjs');
+var lexical = require('lexical');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class CollabLineBreakNode {
+  constructor(map, parent) {
+    this._key = '';
+    this._map = map;
+    this._parent = parent;
+    this._type = 'linebreak';
+  }
+
+  getNode() {
+    const node = lexical.$getNodeByKey(this._key);
+    return lexical.$isLineBreakNode(node) ? node : null;
+  }
+
+  getKey() {
+    return this._key;
+  }
+
+  getSharedType() {
+    return this._map;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getSize() {
+    return 1;
+  }
+
+  getOffset() {
+    const collabElementNode = this._parent;
+    return collabElementNode.getChildOffset(this);
+  }
+
+  destroy(binding) {
+    const collabNodeMap = binding.collabNodeMap;
+    collabNodeMap.delete(this._key);
+  }
+
+}
+function $createCollabLineBreakNode(map, parent) {
+  const collabNode = new CollabLineBreakNode(map, parent); // $FlowFixMe: internal field
+
+  map._collabNode = collabNode;
+  return collabNode;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function simpleDiffWithCursor(a, b, cursor) {
+  const aLength = a.length;
+  const bLength = b.length;
+  let left = 0; // number of same characters counting from left
+
+  let right = 0; // number of same characters counting from right
+  // Iterate left to the right until we find a changed character
+  // First iteration considers the current cursor position
+
+  while (left < aLength && left < bLength && a[left] === b[left] && left < cursor) {
+    left++;
+  } // Iterate right to the left until we find a changed character
+
+
+  while (right + left < aLength && right + left < bLength && a[aLength - right - 1] === b[bLength - right - 1]) {
+    right++;
+  } // Try to iterate left further to the right without caring about the current cursor position
+
+
+  while (right + left < aLength && right + left < bLength && a[left] === b[left]) {
+    left++;
+  }
+
+  return {
+    index: left,
+    insert: b.slice(left, bLength - right),
+    remove: aLength - left - right
+  };
+}
+
+function diffTextContentAndApplyDelta(collabNode, key, prevText, nextText) {
+  const selection = lexical.$getSelection();
+  let cursorOffset = nextText.length;
+
+  if (lexical.$isRangeSelection(selection) && selection.isCollapsed()) {
+    const anchor = selection.anchor;
+
+    if (anchor.key === key) {
+      cursorOffset = anchor.offset;
+    }
+  }
+
+  const diff = simpleDiffWithCursor(prevText, nextText, cursorOffset);
+  collabNode.spliceText(diff.index, diff.remove, diff.insert);
+}
+
+class CollabTextNode {
+  constructor(map, text, parent, type) {
+    this._key = '';
+    this._map = map;
+    this._parent = parent;
+    this._text = text;
+    this._type = type;
+    this._normalized = false;
+  }
+
+  getPrevNode(nodeMap) {
+    if (nodeMap === null) {
+      return null;
+    }
+
+    const node = nodeMap.get(this._key);
+    return lexical.$isTextNode(node) ? node : null;
+  }
+
+  getNode() {
+    const node = lexical.$getNodeByKey(this._key);
+    return lexical.$isTextNode(node) ? node : null;
+  }
+
+  getSharedType() {
+    return this._map;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getKey() {
+    return this._key;
+  }
+
+  getSize() {
+    return this._text.length + (this._normalized ? 0 : 1);
+  }
+
+  getOffset() {
+    const collabElementNode = this._parent;
+    return collabElementNode.getChildOffset(this);
+  }
+
+  spliceText(index, delCount, newText) {
+    const collabElementNode = this._parent;
+    const xmlText = collabElementNode._xmlText;
+    const offset = this.getOffset() + 1 + index;
+
+    if (delCount !== 0) {
+      xmlText.delete(offset, delCount);
+    }
+
+    if (newText !== '') {
+      xmlText.insert(offset, newText);
+    }
+  }
+
+  syncPropertiesAndTextFromLexical(binding, nextLexicalNode, prevNodeMap) {
+    const prevLexicalNode = this.getPrevNode(prevNodeMap);
+    const nextText = nextLexicalNode.__text;
+    syncPropertiesFromLexical(binding, this._map, prevLexicalNode, nextLexicalNode);
+
+    if (prevLexicalNode !== null) {
+      const prevText = prevLexicalNode.__text;
+
+      if (prevText !== nextText) {
+        const key = nextLexicalNode.__key;
+        diffTextContentAndApplyDelta(this, key, prevText, nextText);
+        this._text = nextText;
+      }
+    }
+  }
+
+  syncPropertiesAndTextFromYjs(binding, keysChanged) {
+    const lexicalNode = this.getNode();
+
+    if (lexicalNode === null) {
+      throw new Error('Should never happen');
+    }
+
+    syncPropertiesFromYjs(binding, this._map, lexicalNode, keysChanged);
+    const collabText = this._text;
+
+    if (lexicalNode.__text !== collabText) {
+      const writable = lexicalNode.getWritable();
+      writable.__text = collabText;
+    }
+  }
+
+  destroy(binding) {
+    const collabNodeMap = binding.collabNodeMap;
+    collabNodeMap.delete(this._key);
+  }
+
+}
+function $createCollabTextNode(map, text, parent, type) {
+  const collabNode = new CollabTextNode(map, text, parent, type); // $FlowFixMe: internal field
+
+  map._collabNode = collabNode;
+  return collabNode;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+const excludedProperties = new Set(['__key', '__children', '__parent', '__cachedText', '__text', '__state']);
+function $getNodeByKeyOrThrow(key) {
+  const node = lexical.$getNodeByKey(key);
+
+  if (node === null) {
+    throw new Error('Should never happen');
+  }
+
+  return node;
+}
+function $createCollabNodeFromLexicalNode(binding, lexicalNode, parent) {
+  const nodeType = lexicalNode.__type;
+  let collabNode;
+
+  if (lexical.$isElementNode(lexicalNode)) {
+    const xmlText = new yjs.XmlText();
+    collabNode = $createCollabElementNode(xmlText, parent, nodeType);
+    collabNode.syncPropertiesFromLexical(binding, lexicalNode, null);
+    collabNode.syncChildrenFromLexical(binding, lexicalNode, null, null, null);
+  } else if (lexical.$isTextNode(lexicalNode)) {
+    // TODO create a token text node for immutable, segmented or inert nodes.
+    const map = new yjs.Map();
+    collabNode = $createCollabTextNode(map, lexicalNode.__text, parent, nodeType);
+    collabNode.syncPropertiesAndTextFromLexical(binding, lexicalNode, null);
+  } else if (lexical.$isLineBreakNode(lexicalNode)) {
+    const map = new yjs.Map();
+    map.set('__type', 'linebreak');
+    collabNode = $createCollabLineBreakNode(map, parent);
+  } else if (lexical.$isDecoratorNode(lexicalNode)) {
+    const xmlElem = new yjs.XmlElement();
+    collabNode = $createCollabDecoratorNode(xmlElem, parent, nodeType);
+    collabNode.syncPropertiesFromLexical(binding, lexicalNode, null);
+  } else {
+    throw new Error('Should never happen');
+  }
+
+  collabNode._key = lexicalNode.__key;
+  return collabNode;
+}
+
+function getNodeTypeFromSharedType(sharedType) {
+  const type = sharedType instanceof yjs.Map ? sharedType.get('__type') : sharedType.getAttribute('__type');
+
+  if (type == null) {
+    throw new Error('Should never happen');
+  }
+
+  return type;
+}
+
+function getOrInitCollabNodeFromSharedType(binding, sharedType, parent) {
+  // $FlowFixMe: internal field
+  const collabNode = sharedType._collabNode;
+
+  if (collabNode === undefined) {
+    const registeredNodes = binding.editor._nodes;
+    const type = getNodeTypeFromSharedType(sharedType);
+    const nodeInfo = registeredNodes.get(type);
+
+    if (nodeInfo === undefined) {
+      throw new Error('Should never happen');
+    }
+
+    const sharedParent = sharedType.parent;
+    const targetParent = parent === undefined && sharedParent !== null ? getOrInitCollabNodeFromSharedType(binding, sharedParent) : parent || null;
+
+    if (!(targetParent instanceof CollabElementNode)) {
+      throw new Error('Should never happen');
+    }
+
+    if (sharedType instanceof yjs.XmlText) {
+      return $createCollabElementNode(sharedType, targetParent, type);
+    } else if (sharedType instanceof yjs.Map) {
+      if (targetParent === null) {
+        throw new Error('Should never happen');
+      }
+
+      if (type === 'linebreak') {
+        return $createCollabLineBreakNode(sharedType, targetParent);
+      }
+
+      return $createCollabTextNode(sharedType, '', targetParent, type);
+    } else if (sharedType instanceof yjs.XmlElement) {
+      return $createCollabDecoratorNode(sharedType, targetParent, type);
+    }
+  }
+
+  return collabNode;
+}
+function createLexicalNodeFromCollabNode(binding, collabNode, parentKey) {
+  const type = collabNode.getType();
+  const registeredNodes = binding.editor._nodes;
+  const nodeInfo = registeredNodes.get(type);
+
+  if (nodeInfo === undefined) {
+    throw new Error('createLexicalNode failed');
+  } // $FlowFixMe: needs refining
+
+
+  const lexicalNode = new nodeInfo.klass();
+  lexicalNode.__parent = parentKey;
+  collabNode._key = lexicalNode.__key;
+
+  if (collabNode instanceof CollabElementNode) {
+    const xmlText = collabNode._xmlText;
+    collabNode.syncPropertiesFromYjs(binding, null);
+    collabNode.applyChildrenYjsDelta(binding, xmlText.toDelta());
+    collabNode.syncChildrenFromYjs(binding);
+  } else if (collabNode instanceof CollabTextNode) {
+    collabNode.syncPropertiesAndTextFromYjs(binding, null);
+  } else if (collabNode instanceof CollabDecoratorNode) {
+    collabNode.syncPropertiesFromYjs(binding, null);
+  }
+
+  binding.collabNodeMap.set(lexicalNode.__key, collabNode);
+  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);
+  let writableNode;
+
+  for (let i = 0; i < properties.length; i++) {
+    const property = properties[i];
+
+    if (excludedProperties.has(property)) {
+      continue;
+    } // $FlowFixMe: intentional
+
+
+    const prevValue = lexicalNode[property];
+    const nextValue = sharedType instanceof yjs.Map ? sharedType.get(property) : sharedType.getAttribute(property);
+
+    if (prevValue !== nextValue) {
+      if (writableNode === undefined) {
+        writableNode = lexicalNode.getWritable();
+      } // $FlowFixMe
+
+
+      writableNode[property] = nextValue;
+    }
+  }
+}
+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 !excludedProperties.has(property);
+    });
+    nodeProperties.set(type, properties);
+  }
+
+  for (let i = 0; i < properties.length; i++) {
+    const property = properties[i];
+    const prevValue = // $FlowFixMe: intentional override
+    prevLexicalNode === null ? undefined : prevLexicalNode[property]; // $FlowFixMe: intentional override
+
+    const nextValue = nextLexicalNode[property];
+
+    if (prevValue !== nextValue) {
+      if (sharedType instanceof yjs.Map) {
+        sharedType.set(property, nextValue);
+      } else {
+        sharedType.setAttribute(property, nextValue);
+      }
+    }
+  }
+}
+function spliceString(str, index, delCount, newText) {
+  return str.slice(0, index) + newText + str.slice(index + delCount);
+}
+function getPositionFromElementAndOffset(node, offset, boundaryIsEdge) {
+  let index = 0;
+  let i = 0;
+  const children = node._children;
+  const childrenLength = children.length;
+
+  for (; i < childrenLength; i++) {
+    const child = children[i];
+    const childOffset = index;
+    const size = child.getSize();
+    index += size;
+    const exceedsBoundary = boundaryIsEdge ? index >= offset : index > offset;
+
+    if (exceedsBoundary && child instanceof CollabTextNode) {
+      let textOffset = offset - childOffset - 1;
+
+      if (textOffset < 0) {
+        textOffset = 0;
+      }
+
+      const diffLength = size - textOffset;
+      return {
+        length: diffLength,
+        node: child,
+        nodeIndex: i,
+        offset: textOffset
+      };
+    }
+
+    if (index > offset) {
+      return {
+        length: 0,
+        node: child,
+        nodeIndex: i,
+        offset: childOffset
+      };
+    } else if (i === childrenLength - 1) {
+      return {
+        length: 0,
+        node: null,
+        nodeIndex: i + 1,
+        offset: childOffset + 1
+      };
+    }
+  }
+
+  return {
+    length: 0,
+    node: null,
+    nodeIndex: 0,
+    offset: 0
+  };
+}
+function doesSelectionNeedRecovering(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  let recoveryNeeded = false;
+
+  try {
+    const anchorNode = anchor.getNode();
+    const focusNode = focus.getNode();
+
+    if ( // We might have removed a node that no longer exists
+    !anchorNode.isAttached() || !focusNode.isAttached() || // If we've split a node, then the offset might not be right
+    lexical.$isTextNode(anchorNode) && anchor.offset > anchorNode.getTextContentSize() || lexical.$isTextNode(focusNode) && focus.offset > focusNode.getTextContentSize()) {
+      recoveryNeeded = true;
+    }
+  } catch (e) {
+    // Sometimes checking nor a node via getNode might trigger
+    // an error, so we need recovery then too.
+    recoveryNeeded = true;
+  }
+
+  return recoveryNeeded;
+}
+function syncWithTransaction(binding, fn) {
+  binding.doc.transact(fn, binding);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+let isMutationFromCollab = false;
+function mutationFromCollab(fn) {
+  const prevIsMutationFromCollab = isMutationFromCollab;
+
+  try {
+    isMutationFromCollab = true;
+    fn();
+  } finally {
+    isMutationFromCollab = prevIsMutationFromCollab;
+  }
+}
+function observeDecoratorMap(binding, collabNode, decoratorMap, yjsMap) {
+  const unobserve = decoratorMap.observe(changedKey => {
+    if (isMutationFromCollab) {
+      return;
+    }
+
+    syncWithTransaction(binding, () => syncLexicalDecoratorMapKeyToYjs(binding, collabNode, decoratorMap._map, yjsMap, changedKey));
+  });
+
+  collabNode._unobservers.add(unobserve);
+}
+
+function observeDecoratorArray(binding, collabNode, decoratorArray, yjsArray) {
+  const unobserve = decoratorArray.observe((changedIndex, delCount) => {
+    if (isMutationFromCollab) {
+      return;
+    }
+
+    syncWithTransaction(binding, () => {
+      if (delCount > 0) {
+        yjsArray.delete(changedIndex, delCount);
+      }
+
+      syncLexicalDecoratorArrayValueToYjs(binding, collabNode, decoratorArray._array, yjsArray, changedIndex);
+    });
+  });
+
+  collabNode._unobservers.add(unobserve);
+}
+
+function syncLexicalDecoratorMapKeyToYjs(binding, collabNode, internalMap, yjsMap, key) {
+  const lexicalValue = internalMap.get(key);
+  let yjsValue = yjsMap.get(key);
+
+  if (lexicalValue !== yjsValue) {
+    if (lexical.isDecoratorMap(lexicalValue)) {
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Map(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode;
+        yjsValue.set('type', 'map');
+        yjsMap.set(key, yjsValue);
+        observeDecoratorMap(binding, collabNode, lexicalValue, yjsValue);
+      }
+
+      syncLexicalDecoratorMapToYjs(binding, collabNode, lexicalValue, yjsValue);
+    } else if (lexical.isDecoratorEditor(lexicalValue)) {
+      let doc;
+
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Map(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode; // Create a subdocument
+
+        doc = new yjs.Doc();
+        yjsValue.set('doc', doc);
+        yjsValue.set('type', 'editor');
+        yjsMap.set(key, yjsValue);
+      }
+
+      doc = doc || yjsValue.get('doc');
+      const yjsId = yjsValue.get('id');
+      const lexicalId = lexicalValue.id;
+
+      if (yjsId !== lexicalId) {
+        const yjsDocMap = binding.docMap;
+        yjsDocMap.delete(yjsId);
+        yjsValue.set('id', lexicalId);
+        yjsDocMap.set(lexicalId, doc);
+      }
+    } else if (lexical.isDecoratorArray(lexicalValue)) {
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Array(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode;
+        yjsMap.set(key, yjsValue);
+        observeDecoratorArray(binding, collabNode, lexicalValue, yjsValue);
+      }
+
+      syncLexicalDecoratorArrayToYjs(binding, collabNode, lexicalValue, yjsValue);
+    } else {
+      if (lexical.isDecoratorArray(yjsValue) || lexical.isDecoratorMap(yjsValue)) {
+        yjsValue.destroy();
+      }
+
+      yjsMap.set(key, lexicalValue);
+    }
+  }
+}
+
+function syncLexicalDecoratorArrayValueToYjs(binding, collabNode, internalArray, yjsArray, index) {
+  const lexicalValue = internalArray[index];
+  let yjsValue = yjsArray.get(index);
+
+  if (lexicalValue !== yjsValue) {
+    if (lexical.isDecoratorMap(lexicalValue)) {
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Map(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode;
+        yjsValue.set('type', 'map');
+        yjsArray.insert(index, [yjsValue]);
+        observeDecoratorMap(binding, collabNode, lexicalValue, yjsValue);
+      }
+
+      syncLexicalDecoratorMapToYjs(binding, collabNode, lexicalValue, yjsValue);
+    } else if (lexical.isDecoratorEditor(lexicalValue)) {
+      let doc;
+
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Map(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode; // Create a subdocument
+
+        doc = new yjs.Doc();
+        yjsValue.set('doc', doc);
+        yjsValue.set('type', 'editor');
+        yjsArray.insert(index, [yjsValue]);
+      }
+
+      doc = doc || yjsValue.get('doc');
+      const yjsId = yjsValue.get('id');
+      const lexicalId = lexicalValue.id;
+
+      if (yjsId !== lexicalId) {
+        const yjsDocMap = binding.docMap;
+        yjsDocMap.delete(yjsId);
+        yjsValue.set('id', lexicalId);
+        yjsDocMap.set(lexicalId, doc);
+      }
+    } else if (lexical.isDecoratorArray(lexicalValue)) {
+      if (yjsValue === undefined) {
+        yjsValue = new yjs.Array(); // $FlowFixMe: internal field
+
+        yjsValue._lexicalValue = lexicalValue; // $FlowFixMe: internal field
+
+        yjsValue._collabNode = collabNode;
+        yjsArray.insert(index, [yjsValue]);
+        observeDecoratorArray(binding, collabNode, lexicalValue, yjsValue);
+      }
+
+      syncLexicalDecoratorArrayToYjs(binding, collabNode, lexicalValue, yjsValue);
+    } else {
+      yjsArray.insert(index, [lexicalValue]);
+    }
+  }
+}
+
+function syncLexicalDecoratorMapToYjs(binding, collabNode, decoratorMap, yjsMap) {
+  const internalMap = decoratorMap._map;
+  const keys = Array.from(internalMap.keys());
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    syncLexicalDecoratorMapKeyToYjs(binding, collabNode, internalMap, yjsMap, key);
+  }
+}
+
+function syncLexicalDecoratorArrayToYjs(binding, collabNode, decoratorArray, yjsArray) {
+  const internalArray = decoratorArray._array;
+
+  for (let i = 0; i < internalArray.length; i++) {
+    syncLexicalDecoratorArrayValueToYjs(binding, collabNode, internalArray, yjsArray, i);
+  }
+}
+
+function syncYjsDecoratorMapKeyToLexical(binding, collabNode, yjsMap, decoratorMap, key) {
+  const lexicalValue = decoratorMap.get(key);
+  const yjsValue = yjsMap.get(key);
+
+  if (lexicalValue !== yjsValue) {
+    // $FlowFixMe: internal field
+    let nextValue = yjsValue._lexicalValue;
+
+    if (yjsValue instanceof yjs.Map) {
+      const type = yjsValue.get('type');
+
+      if (type === 'editor') {
+        if (nextValue === undefined) {
+          const yjsDocMap = binding.docMap;
+          const id = yjsValue.get('id');
+          const doc = yjsValue.get('doc');
+          nextValue = lexical.createDecoratorEditor(id);
+          yjsValue._lexicalValue = nextValue;
+          yjsValue._collabNode = collabNode;
+          yjsDocMap.set(id, doc);
+          mutationFromCollab(() => decoratorMap.set(key, nextValue));
+        }
+      } else if (type === 'map') {
+        if (nextValue === undefined) {
+          nextValue = lexical.createDecoratorMap(binding.editor);
+          observeDecoratorMap(binding, collabNode, nextValue, yjsValue);
+          yjsValue._lexicalValue = nextValue;
+          yjsValue._collabNode = collabNode;
+          mutationFromCollab(() => decoratorMap.set(key, nextValue));
+        }
+
+        syncYjsDecoratorMapToLexical(binding, collabNode, yjsValue, nextValue, null);
+      } else {
+        {
+          throw Error(`Should never happen`);
+        }
+      }
+    } else if (yjsValue instanceof yjs.Array) {
+      if (nextValue === undefined) {
+        nextValue = lexical.createDecoratorArray(binding.editor);
+        observeDecoratorArray(binding, collabNode, nextValue, yjsValue);
+        yjsValue._lexicalValue = nextValue;
+        yjsValue._collabNode = collabNode;
+        mutationFromCollab(() => decoratorMap.set(key, nextValue));
+      }
+
+      syncYjsDecoratorArrayToLexical(binding, collabNode, yjsValue, nextValue);
+    } else {
+      mutationFromCollab(() => decoratorMap.set(key, yjsValue));
+    }
+  }
+}
+
+function syncYjsDecoratorArrayValueToLexical(binding, collabNode, yjsArray, decoratorArray, index) {
+  const lexicalValue = decoratorArray._array[index];
+  const yjsValue = yjsArray.get(index);
+
+  if (lexicalValue !== yjsValue) {
+    // $FlowFixMe: internal field
+    let nextValue = yjsValue._lexicalValue;
+
+    if (yjsValue instanceof yjs.Map) {
+      const type = yjsValue.get('type');
+
+      if (type === 'editor') {
+        if (nextValue === undefined) {
+          const yjsDocMap = binding.docMap;
+          const id = yjsValue.get('id');
+          const doc = yjsValue.get('doc');
+          nextValue = lexical.createDecoratorEditor(id);
+          yjsValue._lexicalValue = nextValue;
+          yjsValue._collabNode = collabNode;
+          yjsDocMap.set(id, doc);
+          mutationFromCollab(() => decoratorArray.splice(index, 0, nextValue));
+        }
+      } else if (type === 'map') {
+        if (nextValue === undefined) {
+          nextValue = lexical.createDecoratorMap(binding.editor);
+          observeDecoratorMap(binding, collabNode, nextValue, yjsValue);
+          yjsValue._lexicalValue = nextValue;
+          yjsValue._collabNode = collabNode;
+          mutationFromCollab(() => decoratorArray.splice(index, 0, nextValue));
+        }
+
+        syncYjsDecoratorMapToLexical(binding, collabNode, yjsValue, nextValue, null);
+      } else {
+        {
+          throw Error(`Should never happen`);
+        }
+      }
+    } else if (yjsValue instanceof yjs.Array) {
+      if (nextValue === undefined) {
+        nextValue = lexical.createDecoratorArray(binding.editor);
+        observeDecoratorArray(binding, collabNode, nextValue, yjsValue);
+        yjsValue._lexicalValue = nextValue;
+        yjsValue._collabNode = collabNode;
+        mutationFromCollab(() => decoratorArray.splice(index, 0, nextValue));
+      }
+
+      syncYjsDecoratorArrayToLexical(binding, collabNode, yjsValue, nextValue);
+    } else {
+      mutationFromCollab(() => decoratorArray.splice(index, 0, yjsValue));
+    }
+  }
+}
+function syncYjsDecoratorArrayToLexical(binding, collabNode, yjsArray, decoratorArray) {
+  const length = Math.max(yjsArray.length, decoratorArray.getLength());
+
+  for (let i = 0; i < length; i++) {
+    syncYjsDecoratorArrayValueToLexical(binding, collabNode, yjsArray, decoratorArray, i);
+  }
+}
+function syncYjsDecoratorMapToLexical(binding, collabNode, yjsMap, decoratorMap, keysChanged) {
+  const keys = keysChanged === null ? Array.from(yjsMap.keys()) : Array.from(keysChanged);
+
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    syncYjsDecoratorMapKeyToLexical(binding, collabNode, yjsMap, decoratorMap, key);
+  }
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class CollabDecoratorNode {
+  constructor(xmlElem, parent, type) {
+    this._key = '';
+    this._xmlElem = xmlElem;
+    this._parent = parent;
+    this._type = type;
+    this._unobservers = new Set();
+  }
+
+  getPrevNode(nodeMap) {
+    if (nodeMap === null) {
+      return null;
+    }
+
+    const node = nodeMap.get(this._key);
+    return lexical.$isDecoratorNode(node) ? node : null;
+  }
+
+  getNode() {
+    const node = lexical.$getNodeByKey(this._key);
+    return lexical.$isDecoratorNode(node) ? node : null;
+  }
+
+  getSharedType() {
+    return this._xmlElem;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getKey() {
+    return this._key;
+  }
+
+  getSize() {
+    return 1;
+  }
+
+  getOffset() {
+    const collabElementNode = this._parent;
+    return collabElementNode.getChildOffset(this);
+  }
+
+  syncPropertiesFromLexical(binding, nextLexicalNode, prevNodeMap) {
+    const prevLexicalNode = this.getPrevNode(prevNodeMap);
+    const xmlElem = this._xmlElem;
+    const prevDecoratorMap = prevLexicalNode === null ? null : prevLexicalNode.__state;
+    const nextDecoratorMap = nextLexicalNode.__state;
+    syncPropertiesFromLexical(binding, xmlElem, prevLexicalNode, nextLexicalNode); // Handle bindings
+
+    if (prevDecoratorMap !== nextDecoratorMap) {
+      const yjsMap = new yjs.Map();
+      xmlElem.insert(0, [yjsMap]); // $FlowFixMe: internal field
+
+      yjsMap._lexicalValue = nextDecoratorMap; // $FlowFixMe: internal field
+
+      yjsMap._collabNode = this;
+      syncLexicalDecoratorMapToYjs(binding, this, nextDecoratorMap, yjsMap);
+      observeDecoratorMap(binding, this, nextDecoratorMap, yjsMap);
+    }
+  }
+
+  syncPropertiesFromYjs(binding, keysChanged) {
+    const lexicalNode = this.getNode();
+
+    if (lexicalNode === null) {
+      throw new Error('Should never happen');
+    }
+
+    const xmlElem = this._xmlElem; // $FlowFixMe: should always be true
+
+    const yjsMap = xmlElem.firstChild;
+    const decoratorMap = lexicalNode.__state; // $FlowFixMe: internal field
+
+    yjsMap._lexicalValue = decoratorMap; // $FlowFixMe: internal field
+
+    yjsMap._collabNode = this;
+    syncPropertiesFromYjs(binding, xmlElem, lexicalNode, keysChanged);
+    syncYjsDecoratorMapToLexical(binding, this, yjsMap, decoratorMap, null);
+    observeDecoratorMap(binding, this, decoratorMap, yjsMap);
+  }
+
+  destroy(binding) {
+    const collabNodeMap = binding.collabNodeMap;
+    collabNodeMap.delete(this._key);
+
+    this._unobservers.forEach(unobserver => unobserver());
+
+    this._unobservers.clear();
+  }
+
+}
+function $createCollabDecoratorNode(xmlElem, parent, type) {
+  const collabNode = new CollabDecoratorNode(xmlElem, parent, type); // $FlowFixMe: internal field
+
+  xmlElem._collabNode = collabNode;
+  return collabNode;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class CollabElementNode {
+  constructor(xmlText, parent, type) {
+    this._key = '';
+    this._children = [];
+    this._xmlText = xmlText;
+    this._type = type;
+    this._parent = parent;
+  }
+
+  getPrevNode(nodeMap) {
+    if (nodeMap === null) {
+      return null;
+    }
+
+    const node = nodeMap.get(this._key);
+    return lexical.$isElementNode(node) ? node : null;
+  }
+
+  getNode() {
+    const node = lexical.$getNodeByKey(this._key);
+    return lexical.$isElementNode(node) ? node : null;
+  }
+
+  getSharedType() {
+    return this._xmlText;
+  }
+
+  getType() {
+    return this._type;
+  }
+
+  getKey() {
+    return this._key;
+  }
+
+  isEmpty() {
+    return this._children.length === 0;
+  }
+
+  getSize() {
+    return 1;
+  }
+
+  getOffset() {
+    const collabElementNode = this._parent;
+
+    if (collabElementNode === null) {
+      throw new Error('Should never happen');
+    }
+
+    return collabElementNode.getChildOffset(this);
+  }
+
+  syncPropertiesFromYjs(binding, keysChanged) {
+    const lexicalNode = this.getNode();
+
+    if (lexicalNode === null) {
+      this.getNode();
+      throw new Error('Should never happen');
+    }
+
+    syncPropertiesFromYjs(binding, this._xmlText, lexicalNode, keysChanged);
+  }
+
+  applyChildrenYjsDelta(binding, deltas) {
+    const children = this._children;
+    let currIndex = 0;
+
+    for (let i = 0; i < deltas.length; i++) {
+      const delta = deltas[i];
+      const insertDelta = delta.insert;
+      const deleteDelta = delta.delete;
+
+      if (delta.retain != null) {
+        currIndex += delta.retain;
+      } else if (typeof deleteDelta === 'number') {
+        let deletionSize = deleteDelta;
+
+        while (deletionSize > 0) {
+          const {
+            node,
+            nodeIndex,
+            offset,
+            length
+          } = getPositionFromElementAndOffset(this, currIndex, false);
+
+          if (node instanceof CollabElementNode || node instanceof CollabLineBreakNode || node instanceof CollabDecoratorNode) {
+            children.splice(nodeIndex, 1);
+            deletionSize -= 1;
+          } else if (node instanceof CollabTextNode) {
+            const delCount = Math.min(deletionSize, length);
+            const prevCollabNode = nodeIndex !== 0 ? children[nodeIndex - 1] : null;
+            const nodeSize = node.getSize();
+
+            if (offset === 0 && delCount === 1 && nodeIndex > 0 && prevCollabNode instanceof CollabTextNode && length === nodeSize && // If the node has no keys, it's been deleted
+            Array.from(node._map.keys()).length === 0) {
+              // Merge the text node with previous.
+              prevCollabNode._text += node._text;
+              children.splice(nodeIndex, 1);
+            } else if (offset === 0 && delCount === nodeSize) {
+              // The entire thing needs removing
+              children.splice(nodeIndex, 1);
+            } else {
+              node._text = spliceString(node._text, offset, delCount, '');
+            }
+
+            deletionSize -= delCount;
+          } else {
+            // Can occur due to the deletion from the dangling text heuristic below.
+            break;
+          }
+        }
+      } else if (insertDelta != null) {
+        if (typeof insertDelta === 'string') {
+          const {
+            node,
+            offset
+          } = getPositionFromElementAndOffset(this, currIndex, true);
+
+          if (node instanceof CollabTextNode) {
+            node._text = spliceString(node._text, offset, 0, insertDelta);
+          } else {
+            // TODO: maybe we can improve this by keeping around a redundant
+            // text node map, rather than removing all the text nodes, so there
+            // never can be dangling text.
+            // We have a conflict where there was likely a CollabTextNode and
+            // an Lexical TextNode too, but they were removed in a merge. So
+            // let's just ignore the text and trigger a removal for it from our
+            // shared type.
+            this._xmlText.delete(offset, insertDelta.length);
+          }
+
+          currIndex += insertDelta.length;
+        } else {
+          const sharedType = insertDelta;
+          const {
+            nodeIndex
+          } = getPositionFromElementAndOffset(this, currIndex, false);
+          const collabNode = getOrInitCollabNodeFromSharedType(binding, sharedType, this);
+          children.splice(nodeIndex, 0, collabNode);
+          currIndex += 1;
+        }
+      } else {
+        throw new Error('Unexpected delta format');
+      }
+    }
+  }
+
+  syncChildrenFromYjs(binding) {
+    // Now diff the children of the collab node with that of our existing Lexical node.
+    const lexicalNode = this.getNode();
+
+    if (lexicalNode === null) {
+      this.getNode();
+      throw new Error('Should never happen');
+    }
+
+    const key = lexicalNode.__key;
+    const prevLexicalChildrenKeys = lexicalNode.__children;
+    const nextLexicalChildrenKeys = [];
+    const lexicalChildrenKeysLength = prevLexicalChildrenKeys.length;
+    const collabChildren = this._children;
+    const collabChildrenLength = collabChildren.length;
+    const collabNodeMap = binding.collabNodeMap;
+    const visitedKeys = new Set();
+    let collabKeys; // Assign the new children key array that we're about to mutate
+
+    let writableLexicalNode;
+
+    if (collabChildrenLength !== lexicalChildrenKeysLength) {
+      writableLexicalNode = lazilyCloneElementNode(lexicalNode, writableLexicalNode, nextLexicalChildrenKeys);
+    }
+
+    let prevIndex = 0;
+
+    for (let i = 0; i < collabChildrenLength; i++) {
+      const lexicalChildKey = prevLexicalChildrenKeys[prevIndex];
+      const childCollabNode = collabChildren[i];
+      const collabLexicalChildNode = childCollabNode.getNode();
+      const collabKey = childCollabNode._key;
+
+      if (collabLexicalChildNode !== null && lexicalChildKey === collabKey) {
+        const childNeedsUpdating = lexical.$isTextNode(collabLexicalChildNode); // Update
+
+        visitedKeys.add(lexicalChildKey);
+
+        if (childNeedsUpdating) {
+          childCollabNode._key = lexicalChildKey;
+
+          if (childCollabNode instanceof CollabElementNode) {
+            const xmlText = childCollabNode._xmlText;
+            childCollabNode.syncPropertiesFromYjs(binding, null);
+            childCollabNode.applyChildrenYjsDelta(binding, xmlText.toDelta());
+            childCollabNode.syncChildrenFromYjs(binding);
+          } else if (childCollabNode instanceof CollabTextNode) {
+            childCollabNode.syncPropertiesAndTextFromYjs(binding, null);
+          } else if (childCollabNode instanceof CollabDecoratorNode) {
+            childCollabNode.syncPropertiesFromYjs(binding, null);
+          } else if (!(childCollabNode instanceof CollabLineBreakNode)) {
+            throw new Error('Should never happen');
+          }
+        }
+
+        nextLexicalChildrenKeys[i] = lexicalChildKey;
+        prevIndex++;
+      } else {
+        if (collabKeys === undefined) {
+          collabKeys = new Set();
+
+          for (let s = 0; s < collabChildrenLength; s++) {
+            const child = collabChildren[s];
+            const childKey = child._key;
+
+            if (childKey !== '') {
+              collabKeys.add(childKey);
+            }
+          }
+        }
+
+        if (collabLexicalChildNode !== null && lexicalChildKey !== undefined && !collabKeys.has(lexicalChildKey)) {
+          i--;
+          prevIndex++;
+          continue;
+        }
+
+        writableLexicalNode = lazilyCloneElementNode(lexicalNode, writableLexicalNode, nextLexicalChildrenKeys); // Create/Replace
+
+        const lexicalChildNode = createLexicalNodeFromCollabNode(binding, childCollabNode, key);
+        const childKey = lexicalChildNode.__key;
+        collabNodeMap.set(childKey, childCollabNode);
+        nextLexicalChildrenKeys[i] = childKey;
+      }
+    }
+
+    for (let i = 0; i < lexicalChildrenKeysLength; i++) {
+      const lexicalChildKey = prevLexicalChildrenKeys[i];
+
+      if (!visitedKeys.has(lexicalChildKey)) {
+        // Remove
+        const lexicalChildNode = $getNodeByKeyOrThrow(lexicalChildKey).getWritable();
+        const collabNode = binding.collabNodeMap.get(lexicalChildKey);
+
+        if (collabNode !== undefined) {
+          collabNode.destroy(binding);
+        }
+
+        lexicalChildNode.__parent = null;
+      }
+    }
+  }
+
+  syncPropertiesFromLexical(binding, nextLexicalNode, prevNodeMap) {
+    syncPropertiesFromLexical(binding, this._xmlText, this.getPrevNode(prevNodeMap), nextLexicalNode);
+  }
+
+  _syncChildFromLexical(binding, index, key, prevNodeMap, dirtyElements, dirtyLeaves) {
+    const childCollabNode = this._children[index]; // Update
+
+    const nextChildNode = $getNodeByKeyOrThrow(key);
+
+    if (childCollabNode instanceof CollabElementNode && lexical.$isElementNode(nextChildNode)) {
+      childCollabNode.syncPropertiesFromLexical(binding, nextChildNode, prevNodeMap);
+      childCollabNode.syncChildrenFromLexical(binding, nextChildNode, prevNodeMap, dirtyElements, dirtyLeaves);
+    } else if (childCollabNode instanceof CollabTextNode && lexical.$isTextNode(nextChildNode)) {
+      childCollabNode.syncPropertiesAndTextFromLexical(binding, nextChildNode, prevNodeMap);
+    } else if (childCollabNode instanceof CollabDecoratorNode && lexical.$isDecoratorNode(nextChildNode)) {
+      childCollabNode.syncPropertiesFromLexical(binding, nextChildNode, prevNodeMap);
+    }
+  }
+
+  syncChildrenFromLexical(binding, nextLexicalNode, prevNodeMap, dirtyElements, dirtyLeaves) {
+    const prevLexicalNode = this.getPrevNode(prevNodeMap);
+    const prevChildren = prevLexicalNode === null ? [] : prevLexicalNode.__children;
+    const nextChildren = nextLexicalNode.__children;
+    const prevEndIndex = prevChildren.length - 1;
+    const nextEndIndex = nextChildren.length - 1;
+    const collabNodeMap = binding.collabNodeMap;
+    let prevChildrenSet;
+    let nextChildrenSet;
+    let prevIndex = 0;
+    let nextIndex = 0;
+
+    while (prevIndex <= prevEndIndex && nextIndex <= nextEndIndex) {
+      const prevKey = prevChildren[prevIndex];
+      const nextKey = nextChildren[nextIndex];
+
+      if (prevKey === nextKey) {
+        // Nove move, create or remove
+        this._syncChildFromLexical(binding, nextIndex, nextKey, prevNodeMap, dirtyElements, dirtyLeaves);
+
+        prevIndex++;
+        nextIndex++;
+      } else {
+        if (prevChildrenSet === undefined) {
+          prevChildrenSet = new Set(prevChildren);
+        }
+
+        if (nextChildrenSet === undefined) {
+          nextChildrenSet = new Set(nextChildren);
+        }
+
+        const nextHasPrevKey = nextChildrenSet.has(prevKey);
+        const prevHasNextKey = prevChildrenSet.has(nextKey);
+
+        if (!nextHasPrevKey) {
+          // Remove
+          this.splice(binding, nextIndex, 1);
+          prevIndex++;
+        } else {
+          // Create or replace
+          const nextChildNode = $getNodeByKeyOrThrow(nextKey);
+          const collabNode = $createCollabNodeFromLexicalNode(binding, nextChildNode, this);
+          collabNodeMap.set(nextKey, collabNode);
+
+          if (prevHasNextKey) {
+            this.splice(binding, nextIndex, 1, collabNode);
+            prevIndex++;
+            nextIndex++;
+          } else {
+            this.splice(binding, nextIndex, 0, collabNode);
+            nextIndex++;
+          }
+        }
+      }
+    }
+
+    const appendNewChildren = prevIndex > prevEndIndex;
+    const removeOldChildren = nextIndex > nextEndIndex;
+
+    if (appendNewChildren && !removeOldChildren) {
+      for (; nextIndex <= nextEndIndex; ++nextIndex) {
+        const key = nextChildren[nextIndex];
+        const nextChildNode = $getNodeByKeyOrThrow(key);
+        const collabNode = $createCollabNodeFromLexicalNode(binding, nextChildNode, this);
+        this.append(collabNode);
+        collabNodeMap.set(key, collabNode);
+      }
+    } else if (removeOldChildren && !appendNewChildren) {
+      for (let i = this._children.length - 1; i >= nextIndex; i--) {
+        this.splice(binding, i, 1);
+      }
+    }
+  }
+
+  append(collabNode) {
+    const xmlText = this._xmlText;
+    const children = this._children;
+    const lastChild = children[children.length - 1];
+    const offset = lastChild !== undefined ? lastChild.getOffset() + lastChild.getSize() : 0;
+
+    if (collabNode instanceof CollabElementNode) {
+      xmlText.insertEmbed(offset, collabNode._xmlText);
+    } else if (collabNode instanceof CollabTextNode) {
+      const map = collabNode._map;
+
+      if (map.parent === null) {
+        xmlText.insertEmbed(offset, map);
+      }
+
+      xmlText.insert(offset + 1, collabNode._text);
+    } else if (collabNode instanceof CollabLineBreakNode) {
+      xmlText.insertEmbed(offset, collabNode._map);
+    } else if (collabNode instanceof CollabDecoratorNode) {
+      xmlText.insertEmbed(offset, collabNode._xmlElem);
+    }
+
+    this._children.push(collabNode);
+  }
+
+  splice(binding, index, delCount, collabNode) {
+    const children = this._children;
+    const child = children[index];
+
+    if (child === undefined) {
+      if (collabNode !== undefined) {
+        this.append(collabNode);
+      } else {
+        throw new Error('Should never happen');
+      }
+
+      return;
+    }
+
+    const offset = child.getOffset();
+
+    if (offset === -1) {
+      throw new Error('Should never happen');
+    }
+
+    const xmlText = this._xmlText;
+
+    if (delCount !== 0) {
+      // What if we delete many nodes, don't we need to get all their
+      // sizes?
+      xmlText.delete(offset, child.getSize());
+    }
+
+    if (collabNode instanceof CollabElementNode) {
+      xmlText.insertEmbed(offset, collabNode._xmlText);
+    } else if (collabNode instanceof CollabTextNode) {
+      const map = collabNode._map;
+
+      if (map.parent === null) {
+        xmlText.insertEmbed(offset, map);
+      }
+
+      xmlText.insert(offset + 1, collabNode._text);
+    } else if (collabNode instanceof CollabLineBreakNode) {
+      xmlText.insertEmbed(offset, collabNode._map);
+    } else if (collabNode instanceof CollabDecoratorNode) {
+      xmlText.insertEmbed(offset, collabNode._xmlElem);
+    }
+
+    if (delCount !== 0) {
+      const childrenToDelete = children.slice(index, index + delCount);
+
+      for (let i = 0; i < childrenToDelete.length; i++) {
+        childrenToDelete[i].destroy(binding);
+      }
+    }
+
+    if (collabNode !== undefined) {
+      children.splice(index, delCount, collabNode);
+    } else {
+      children.splice(index, delCount);
+    }
+  }
+
+  getChildOffset(collabNode) {
+    let offset = 0;
+    const children = this._children;
+
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+
+      if (child === collabNode) {
+        return offset;
+      }
+
+      offset += child.getSize();
+    }
+
+    return -1;
+  }
+
+  destroy(binding) {
+    const collabNodeMap = binding.collabNodeMap;
+    const children = this._children;
+
+    for (let i = 0; i < children.length; i++) {
+      children[i].destroy(binding);
+    }
+
+    collabNodeMap.delete(this._key);
+  }
+
+}
+
+function lazilyCloneElementNode(lexicalNode, writableLexicalNode, nextLexicalChildrenKeys) {
+  if (writableLexicalNode === undefined) {
+    const clone = lexicalNode.getWritable();
+    clone.__children = nextLexicalChildrenKeys;
+    return clone;
+  }
+
+  return writableLexicalNode;
+}
+
+function $createCollabElementNode(xmlText, parent, type) {
+  const collabNode = new CollabElementNode(xmlText, parent, type); // $FlowFixMe: internal field
+
+  xmlText._collabNode = collabNode;
+  return collabNode;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function createBinding(editor, provider, id, docMap) {
+  const doc = docMap.get(id);
+
+  if (doc === undefined) {
+    throw new Error('Should never happen');
+  } // $FlowFixMe: this will work
+
+
+  const rootXmlText = doc.get('root', yjs.XmlText);
+  const root = $createCollabElementNode(rootXmlText, null, 'root');
+  root._key = 'root'; // $FlowFixMe: our Flow bindings need fixing
+
+  return {
+    clientID: doc.clientID,
+    collabNodeMap: new Map(),
+    cursors: new Map(),
+    cursorsContainer: null,
+    doc,
+    docMap,
+    editor,
+    id,
+    nodeProperties: new Map(),
+    root
+  };
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function createRelativePosition(point, binding) {
+  const collabNodeMap = binding.collabNodeMap;
+  const collabNode = collabNodeMap.get(point.key);
+
+  if (collabNode === undefined) {
+    return null;
+  }
+
+  let offset = point.offset;
+  let sharedType = collabNode.getSharedType();
+
+  if (collabNode instanceof CollabTextNode) {
+    sharedType = collabNode._parent._xmlText;
+    const currentOffset = collabNode.getOffset();
+
+    if (currentOffset === -1) {
+      return null;
+    }
+
+    offset = currentOffset + 1 + offset;
+  }
+
+  return yjs.createRelativePositionFromTypeIndex(sharedType, offset);
+}
+
+function createAbsolutePosition(relativePosition, binding) {
+  return yjs.createAbsolutePositionFromRelativePosition(relativePosition, binding.doc);
+}
+
+function shouldUpdatePosition(currentPos, pos) {
+  if (currentPos == null) {
+    if (pos != null) {
+      return true;
+    }
+  } else if (pos == null || !yjs.compareRelativePositions(currentPos, pos)) {
+    return true;
+  }
+
+  return false;
+}
+
+function createCursor(name, color) {
+  return {
+    color: color,
+    name: name,
+    selection: null
+  };
+}
+
+function destroySelection(binding, selection) {
+  const cursorsContainer = binding.cursorsContainer;
+
+  if (cursorsContainer !== null) {
+    const selections = selection.selections;
+    const selectionsLength = selections.length;
+
+    for (let i = 0; i < selectionsLength; i++) {
+      cursorsContainer.removeChild(selections[i]);
+    }
+  }
+}
+
+function destroyCursor(binding, cursor) {
+  const selection = cursor.selection;
+
+  if (selection !== null) {
+    destroySelection(binding, selection);
+  }
+}
+
+function getDOMTextNode(element) {
+  let node = element;
+
+  while (node != null) {
+    if (node.nodeType === 3) {
+      // $FlowFixMe: this is a Text
+      return node;
+    }
+
+    node = node.firstChild;
+  }
+
+  return null;
+}
+
+function createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset) {
+  const color = cursor.color;
+  const caret = document.createElement('span');
+  caret.style.cssText = `position:absolute;top:0;bottom:0;right:-1px;width:1px;background-color:rgb(${color});z-index:10;`;
+  const name = document.createElement('span');
+  name.textContent = cursor.name;
+  name.style.cssText = `position:absolute;left:-2px;top:-16px;background-color:rgb(${color});color:#fff;line-height:12px;height:12px;font-size:12px;padding:2px;font-family:Arial;font-weight:bold`;
+  caret.appendChild(name);
+  return {
+    anchor: {
+      key: anchorKey,
+      offset: anchorOffset
+    },
+    caret,
+    color,
+    focus: {
+      key: focusKey,
+      offset: focusOffset
+    },
+    name,
+    range: document.createRange(),
+    selections: []
+  };
+}
+
+function getDOMIndexWithinParent(node) {
+  const parent = node.parentNode;
+
+  if (parent == null) {
+    throw new Error('Should never happen');
+  }
+
+  return [parent, Array.from(parent.childNodes).indexOf(node)];
+}
+
+function updateCursor(binding, cursor, nextSelection, nodeMap) {
+  const editor = binding.editor;
+  const rootElement = editor.getRootElement();
+  const cursorsContainer = binding.cursorsContainer;
+
+  if (cursorsContainer === null || rootElement === null) {
+    return;
+  }
+
+  const prevSelection = cursor.selection;
+
+  if (nextSelection === null) {
+    if (prevSelection === null) {
+      return;
+    } else {
+      cursor.selection = null;
+      destroySelection(binding, prevSelection);
+      return;
+    }
+  } else {
+    cursor.selection = nextSelection;
+  }
+
+  const range = nextSelection.range;
+  const caret = nextSelection.caret;
+  const color = nextSelection.color;
+  const selections = nextSelection.selections;
+  const anchor = nextSelection.anchor;
+  const focus = nextSelection.focus;
+  const anchorKey = anchor.key;
+  const focusKey = focus.key;
+  const anchorNode = nodeMap.get(anchorKey);
+  const focusNode = nodeMap.get(focusKey);
+  let anchorDOM = editor.getElementByKey(anchorKey);
+  let focusDOM = editor.getElementByKey(focusKey);
+  let anchorOffset = anchor.offset;
+  let focusOffset = focus.offset;
+
+  if (lexical.$isTextNode(anchorNode)) {
+    anchorDOM = getDOMTextNode(anchorDOM);
+  }
+
+  if (lexical.$isTextNode(focusNode)) {
+    focusDOM = getDOMTextNode(focusDOM);
+  }
+
+  if (anchorNode === undefined || focusNode === undefined || anchorDOM === null || focusDOM === null) {
+    return;
+  }
+
+  if (anchorDOM.nodeName === 'BR') {
+    [anchorDOM, anchorOffset] = getDOMIndexWithinParent(anchorDOM);
+  }
+
+  if (focusDOM.nodeName === 'BR') {
+    [focusDOM, focusOffset] = getDOMIndexWithinParent(focusDOM);
+  }
+
+  const firstChild = anchorDOM.firstChild;
+
+  if (anchorDOM === focusDOM && firstChild != null && firstChild.nodeName === 'BR' && anchorOffset === 0 && focusOffset === 0) {
+    focusOffset = 1;
+  }
+
+  try {
+    range.setStart(anchorDOM, anchorOffset);
+    range.setEnd(focusDOM, focusOffset);
+  } catch (e) {
+    return;
+  }
+
+  if (range.collapsed && (anchorOffset !== focusOffset || anchorKey !== focusKey)) {
+    // Range is backwards, we need to reverse it
+    range.setStart(focusDOM, focusOffset);
+    range.setEnd(anchorDOM, anchorOffset);
+  } // We need to
+
+
+  const rootRect = rootElement.getBoundingClientRect();
+  const computedStyle = getComputedStyle(rootElement);
+  const rootPadding = parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
+  const selectionRects = Array.from(range.getClientRects());
+  let selectionRectsLength = selectionRects.length;
+  const selectionsLength = selections.length;
+
+  for (let i = 0; i < selectionRectsLength; i++) {
+    const selectionRect = selectionRects[i];
+
+    if (selectionRect.width + rootPadding === rootRect.width) {
+      // Exclude selections that span the entire element
+      selectionRects.splice(i--, 1);
+      selectionRectsLength--;
+      continue;
+    }
+
+    let selection = selections[i];
+
+    if (selection === undefined) {
+      selection = document.createElement('span');
+      selections[i] = selection;
+      cursorsContainer.appendChild(selection);
+    }
+
+    const style = `position:absolute;top:${selectionRect.top}px;left:${selectionRect.left}px;height:${selectionRect.height}px;width:${selectionRect.width}px;background-color:rgba(${color}, 0.3);pointer-events:none;z-index:10;`;
+    selection.style.cssText = style;
+
+    if (i === selectionRectsLength - 1) {
+      if (caret.parentNode !== selection) {
+        selection.appendChild(caret);
+      }
+    }
+  }
+
+  for (let i = selectionsLength - 1; i >= selectionRectsLength; i--) {
+    const selection = selections[i];
+    cursorsContainer.removeChild(selection);
+    selections.pop();
+  }
+}
+
+function syncLocalCursorPosition(binding, provider) {
+  const awareness = provider.awareness;
+  const localState = awareness.getLocalState();
+
+  if (localState === null) {
+    return;
+  }
+
+  const anchorPos = localState.anchorPos;
+  const focusPos = localState.focusPos;
+
+  if (anchorPos !== null && focusPos !== null) {
+    const anchorAbsPos = createAbsolutePosition(anchorPos, binding);
+    const focusAbsPos = createAbsolutePosition(focusPos, binding);
+
+    if (anchorAbsPos !== null && focusAbsPos !== null) {
+      const [anchorCollabNode, anchorOffset] = getCollabNodeAndOffset(anchorAbsPos.type, anchorAbsPos.index);
+      const [focusCollabNode, focusOffset] = getCollabNodeAndOffset(focusAbsPos.type, focusAbsPos.index);
+
+      if (anchorCollabNode !== null && focusCollabNode !== null) {
+        const anchorKey = anchorCollabNode.getKey();
+        const focusKey = focusCollabNode.getKey();
+        const selection = lexical.$getSelection();
+
+        if (!lexical.$isRangeSelection(selection)) {
+          return;
+        }
+
+        const anchor = selection.anchor;
+        const focus = selection.focus;
+
+        if (anchor.key !== anchorKey || anchor.offset !== anchorOffset) {
+          const anchorNode = lexical.$getNodeByKey(anchorKey);
+          selection.anchor.set(anchorKey, anchorOffset, lexical.$isElementNode(anchorNode) ? 'element' : 'text');
+        }
+
+        if (focus.key !== focusKey || focus.offset !== focusOffset) {
+          const focusNode = lexical.$getNodeByKey(focusKey);
+          selection.focus.set(focusKey, focusOffset, lexical.$isElementNode(focusNode) ? 'element' : 'text');
+        }
+      }
+    }
+  }
+}
+
+function getCollabNodeAndOffset(sharedType, offset) {
+  // $FlowFixMe: internal field
+  const collabNode = sharedType._collabNode;
+
+  if (collabNode === undefined) {
+    return [null, 0];
+  }
+
+  if (collabNode instanceof CollabElementNode) {
+    const {
+      node,
+      offset: collabNodeOffset
+    } = getPositionFromElementAndOffset(collabNode, offset, true);
+
+    if (node === null) {
+      return [collabNode, 0];
+    } else {
+      return [node, collabNodeOffset];
+    }
+  }
+
+  return [null, 0];
+}
+
+function syncCursorPositions(binding, provider) {
+  const awarenessStates = Array.from(provider.awareness.getStates());
+  const localClientID = binding.clientID;
+  const cursors = binding.cursors;
+  const editor = binding.editor;
+  const nodeMap = editor._editorState._nodeMap;
+  const visitedClientIDs = new Set();
+
+  for (let i = 0; i < awarenessStates.length; i++) {
+    const awarenessState = awarenessStates[i];
+    const [clientID, awareness] = awarenessState;
+
+    if (clientID !== localClientID) {
+      visitedClientIDs.add(clientID);
+      const {
+        anchorPos,
+        focusPos,
+        name,
+        color,
+        focusing
+      } = awareness;
+      let selection = null;
+      let cursor = cursors.get(clientID);
+
+      if (cursor === undefined) {
+        cursor = createCursor(name, color);
+        cursors.set(clientID, cursor);
+      }
+
+      if (anchorPos !== null && focusPos !== null && focusing) {
+        const anchorAbsPos = createAbsolutePosition(anchorPos, binding);
+        const focusAbsPos = createAbsolutePosition(focusPos, binding);
+
+        if (anchorAbsPos !== null && focusAbsPos !== null) {
+          const [anchorCollabNode, anchorOffset] = getCollabNodeAndOffset(anchorAbsPos.type, anchorAbsPos.index);
+          const [focusCollabNode, focusOffset] = getCollabNodeAndOffset(focusAbsPos.type, focusAbsPos.index);
+
+          if (anchorCollabNode !== null && focusCollabNode !== null) {
+            const anchorKey = anchorCollabNode.getKey();
+            const focusKey = focusCollabNode.getKey();
+            selection = cursor.selection;
+
+            if (selection === null) {
+              selection = createCursorSelection(cursor, anchorKey, anchorOffset, focusKey, focusOffset);
+            } else {
+              const anchor = selection.anchor;
+              const focus = selection.focus;
+              anchor.key = anchorKey;
+              anchor.offset = anchorOffset;
+              focus.key = focusKey;
+              focus.offset = focusOffset;
+            }
+          }
+        }
+      }
+
+      updateCursor(binding, cursor, selection, nodeMap);
+    }
+  }
+
+  const allClientIDs = Array.from(cursors.keys());
+
+  for (let i = 0; i < allClientIDs.length; i++) {
+    const clientID = allClientIDs[i];
+
+    if (!visitedClientIDs.has(clientID)) {
+      const cursor = cursors.get(clientID);
+
+      if (cursor !== undefined) {
+        destroyCursor(binding, cursor);
+        cursors.delete(clientID);
+      }
+    }
+  }
+}
+function syncLexicalSelectionToYjs(binding, provider, prevSelection, nextSelection) {
+  const awareness = provider.awareness;
+  const localState = awareness.getLocalState();
+
+  if (localState === null) {
+    return;
+  }
+
+  const {
+    anchorPos: currentAnchorPos,
+    focusPos: currentFocusPos,
+    name,
+    color,
+    focusing
+  } = localState;
+  let anchorPos = null;
+  let focusPos = null;
+
+  if (nextSelection === null || currentAnchorPos !== null && !nextSelection.is(prevSelection)) {
+    if (prevSelection === null) {
+      return;
+    }
+  }
+
+  if (lexical.$isRangeSelection(nextSelection)) {
+    anchorPos = createRelativePosition(nextSelection.anchor, binding);
+    focusPos = createRelativePosition(nextSelection.focus, binding);
+  }
+
+  if (shouldUpdatePosition(currentAnchorPos, anchorPos) || shouldUpdatePosition(currentFocusPos, focusPos)) {
+    awareness.setLocalState({
+      anchorPos,
+      color,
+      focusPos,
+      focusing,
+      name
+    });
+  }
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class OffsetView {
+  constructor(offsetMap, firstNode, blockOffsetSize = 1) {
+    this._offsetMap = offsetMap;
+    this._firstNode = firstNode;
+    this._blockOffsetSize = blockOffsetSize;
+  }
+
+  createSelectionFromOffsets(originalStart, originalEnd, diffOffsetView) {
+    const firstNode = this._firstNode;
+
+    if (firstNode === null) {
+      return null;
+    }
+
+    let start = originalStart;
+    let end = originalEnd;
+    let startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+    let endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+
+    if (diffOffsetView !== undefined) {
+      start = $getAdjustedOffsetFromDiff(start, startOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      startOffsetNode = $searchForNodeWithOffset(firstNode, start, this._blockOffsetSize);
+      end = $getAdjustedOffsetFromDiff(end, endOffsetNode, diffOffsetView, this, this._blockOffsetSize);
+      endOffsetNode = $searchForNodeWithOffset(firstNode, end, this._blockOffsetSize);
+    }
+
+    if (startOffsetNode === null || endOffsetNode === null) {
+      return null;
+    }
+
+    let startKey = startOffsetNode.key;
+    let endKey = endOffsetNode.key;
+    const startNode = lexical.$getNodeByKey(startKey);
+    const endNode = lexical.$getNodeByKey(endKey);
+
+    if (startNode === null || endNode === null) {
+      return null;
+    }
+
+    let startOffset = 0;
+    let endOffset = 0;
+    let startType = 'element';
+    let endType = 'element';
+
+    if (startOffsetNode.type === 'text') {
+      startOffset = start - startOffsetNode.start;
+      startType = 'text'; // If we are at the edge of a text node and we
+      // don't have a collapsed selection, then let's
+      // try and correct the offset node.
+
+      const sibling = startNode.getNextSibling();
+
+      if (start !== end && startOffset === startNode.getTextContentSize() && lexical.$isTextNode(sibling)) {
+        startOffset = 0;
+        startKey = sibling.__key;
+      }
+    } else if (startOffsetNode.type === 'inline') {
+      startKey = startNode.getParentOrThrow().getKey();
+      startOffset = end > startOffsetNode.start ? startOffsetNode.end : startOffsetNode.start;
+    }
+
+    if (endOffsetNode.type === 'text') {
+      endOffset = end - endOffsetNode.start;
+      endType = 'text';
+    } else if (endOffsetNode.type === 'inline') {
+      endKey = endNode.getParentOrThrow().getKey();
+      endOffset = end > endOffsetNode.start ? endOffsetNode.end : endOffsetNode.start;
+    }
+
+    const selection = lexical.$createRangeSelection();
+
+    if (selection === null) {
+      return null;
+    }
+
+    selection.anchor.set(startKey, startOffset, startType);
+    selection.focus.set(endKey, endOffset, endType);
+    return selection;
+  }
+
+  getOffsetsFromSelection(selection) {
+    const anchor = selection.anchor;
+    const focus = selection.focus;
+    const offsetMap = this._offsetMap;
+    const anchorOffset = anchor.offset;
+    const focusOffset = focus.offset;
+    let start = -1;
+    let end = -1;
+
+    if (anchor.type === 'text') {
+      const offsetNode = offsetMap.get(anchor.key);
+
+      if (offsetNode !== undefined) {
+        start = offsetNode.start + anchorOffset;
+      }
+    } else {
+      const node = anchor.getNode().getDescendantByIndex(anchorOffset);
+      const offsetNode = offsetMap.get(node.getKey());
+
+      if (offsetNode !== undefined) {
+        const isAtEnd = node.getIndexWithinParent() !== anchorOffset;
+        start = isAtEnd ? offsetNode.end : offsetNode.start;
+      }
+    }
+
+    if (focus.type === 'text') {
+      const offsetNode = offsetMap.get(focus.key);
+
+      if (offsetNode !== undefined) {
+        end = offsetNode.start + focus.offset;
+      }
+    } else {
+      const node = focus.getNode().getDescendantByIndex(focusOffset);
+      const offsetNode = offsetMap.get(node.getKey());
+
+      if (offsetNode !== undefined) {
+        const isAtEnd = node.getIndexWithinParent() !== focusOffset;
+        end = isAtEnd ? offsetNode.end : offsetNode.start;
+      }
+    }
+
+    return [start, end];
+  }
+
+}
+
+function $getAdjustedOffsetFromDiff(offset, offsetNode, prevOffsetView, offsetView, blockOffsetSize) {
+  const prevOffsetMap = prevOffsetView._offsetMap;
+  const offsetMap = offsetView._offsetMap;
+  const visited = new Set();
+  let adjustedOffset = offset;
+  let currentNode = offsetNode;
+
+  while (currentNode !== null) {
+    const key = currentNode.key;
+    const prevNode = prevOffsetMap.get(key);
+    const diff = currentNode.end - currentNode.start;
+    visited.add(key);
+
+    if (prevNode === undefined) {
+      adjustedOffset += diff;
+    } else {
+      const prevDiff = prevNode.end - prevNode.start;
+
+      if (prevDiff !== diff) {
+        adjustedOffset += diff - prevDiff;
+      }
+    }
+
+    const sibling = currentNode.prev;
+
+    if (sibling !== null) {
+      currentNode = sibling;
+      continue;
+    }
+
+    let parent = currentNode.parent;
+
+    while (parent !== null) {
+      let parentSibling = parent.prev;
+
+      if (parentSibling !== null) {
+        const parentSiblingKey = parentSibling.key;
+        const prevParentSibling = prevOffsetMap.get(parentSiblingKey);
+        const parentDiff = parentSibling.end - parentSibling.start;
+        visited.add(parentSiblingKey);
+
+        if (prevParentSibling === undefined) {
+          adjustedOffset += parentDiff;
+        } else {
+          const prevParentDiff = prevParentSibling.end - prevParentSibling.start;
+
+          if (prevParentDiff !== parentDiff) {
+            adjustedOffset += parentDiff - prevParentDiff;
+          }
+        }
+
+        parentSibling = parentSibling.prev;
+      }
+
+      parent = parent.parent;
+    }
+
+    break;
+  } // Now traverse through the old offsets nodes and find any nodes we missed
+  // above, because they were not in the latest offset node view (they have been
+  // deleted).
+
+
+  const prevFirstNode = prevOffsetView._firstNode;
+
+  if (prevFirstNode !== null) {
+    currentNode = $searchForNodeWithOffset(prevFirstNode, offset, blockOffsetSize);
+    let alreadyVisistedParentOfCurrentNode = false;
+
+    while (currentNode !== null) {
+      if (!visited.has(currentNode.key)) {
+        alreadyVisistedParentOfCurrentNode = true;
+        break;
+      }
+
+      currentNode = currentNode.parent;
+    }
+
+    if (!alreadyVisistedParentOfCurrentNode) {
+      while (currentNode !== null) {
+        const key = currentNode.key;
+
+        if (!visited.has(key)) {
+          const node = offsetMap.get(key);
+          const prevDiff = currentNode.end - currentNode.start;
+
+          if (node === undefined) {
+            adjustedOffset -= prevDiff;
+          } else {
+            const diff = node.end - node.start;
+
+            if (prevDiff !== diff) {
+              adjustedOffset += diff - prevDiff;
+            }
+          }
+        }
+
+        currentNode = currentNode.prev;
+      }
+    }
+  }
+
+  return adjustedOffset;
+}
+
+function $searchForNodeWithOffset(firstNode, offset, blockOffsetSize) {
+  let currentNode = firstNode;
+
+  while (currentNode !== null) {
+    const end = currentNode.end + (currentNode.type !== 'element' || blockOffsetSize === 0 ? 1 : 0);
+
+    if (offset < end) {
+      const child = currentNode.child;
+
+      if (child !== null) {
+        currentNode = child;
+        continue;
+      }
+
+      return currentNode;
+    }
+
+    const sibling = currentNode.next;
+
+    if (sibling === null) {
+      break;
+    }
+
+    currentNode = sibling;
+  }
+
+  return null;
+}
+
+function $createInternalOffsetNode(child, type, start, end, key, parent) {
+  // $FlowFixMe: not sure why Flow doesn't like this?
+  return {
+    child,
+    end,
+    key,
+    next: null,
+    parent,
+    prev: null,
+    start,
+    type
+  };
+}
+
+function $createOffsetNode(state, key, parent, nodeMap, offsetMap, blockOffsetSize) {
+  const node = nodeMap.get(key);
+
+  if (node === undefined) {
+    {
+      throw Error(`createOffsetModel: could not find node by key`);
+    }
+  }
+
+  const start = state.offset;
+
+  if (lexical.$isElementNode(node)) {
+    const childKeys = node.__children;
+    const blockIsEmpty = childKeys.length === 0;
+    const child = blockIsEmpty ? null : $createOffsetChild(state, childKeys, null, nodeMap, offsetMap, blockOffsetSize); // If the prev node was not a block or the block is empty, we should
+    // account for the user being able to selection the block (due to the \n).
+
+    if (!state.prevIsBlock || blockIsEmpty) {
+      state.prevIsBlock = true;
+      state.offset += blockOffsetSize;
+    }
+
+    const offsetNode = $createInternalOffsetNode(child, 'element', start, start, key, parent);
+
+    if (child !== null) {
+      child.parent = offsetNode;
+    }
+
+    const end = state.offset;
+    offsetNode.end = end;
+    offsetMap.set(key, offsetNode);
+    return offsetNode;
+  }
+
+  state.prevIsBlock = false;
+  const isText = lexical.$isTextNode(node); // $FlowFixMe: isText means __text is available
+
+  const length = isText ? node.__text.length : 1;
+  const end = state.offset += length;
+  const offsetNode = $createInternalOffsetNode(null, isText ? 'text' : 'inline', start, end, key, parent);
+  offsetMap.set(key, offsetNode);
+  return offsetNode;
+}
+
+function $createOffsetChild(state, children, parent, nodeMap, offsetMap, blockOffsetSize) {
+  let firstNode = null;
+  let currentNode = null;
+  const childrenLength = children.length;
+
+  for (let i = 0; i < childrenLength; i++) {
+    const childKey = children[i];
+    const offsetNode = $createOffsetNode(state, childKey, parent, nodeMap, offsetMap, blockOffsetSize);
+
+    if (currentNode === null) {
+      firstNode = offsetNode;
+    } else {
+      offsetNode.prev = currentNode;
+      currentNode.next = offsetNode;
+    }
+
+    currentNode = offsetNode;
+  }
+
+  return firstNode;
+}
+
+function $createOffsetView(editor, blockOffsetSize = 1, editorState) {
+  const targetEditorState = editorState || editor._pendingEditorState || editor._editorState;
+  const nodeMap = targetEditorState._nodeMap; // $FlowFixMe: root is always in the Map
+
+  const root = nodeMap.get('root');
+  const offsetMap = new Map();
+  const state = {
+    offset: 0,
+    prevIsBlock: false
+  };
+  const node = $createOffsetChild(state, root.__children, null, nodeMap, offsetMap, blockOffsetSize);
+  return new OffsetView(offsetMap, node, blockOffsetSize);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+
+function syncEvent(binding, event) {
+  const {
+    target
+  } = event;
+  const collabNode = getOrInitCollabNodeFromSharedType(binding, target); // $FlowFixMe: internal field
+
+  const decoratorStateValue = target._lexicalValue; // Check if this event relates to a decorator state change.
+
+  if (decoratorStateValue !== undefined && collabNode instanceof CollabDecoratorNode) {
+    if (target instanceof yjs.Map) {
+      // Sync decorator state value
+      syncYjsDecoratorMapToLexical(binding, collabNode, target, decoratorStateValue, event.keysChanged);
+    } else if (target instanceof yjs.Array && lexical.isDecoratorArray(decoratorStateValue)) {
+      // Sync decorator state value
+      const deltas = event.delta;
+      let offset = 0;
+
+      for (let i = 0; i < deltas.length; i++) {
+        const delta = deltas[i];
+        const retainOp = delta.retain;
+        const deleteOp = delta.delete;
+        const insertOp = delta.insert;
+
+        if (retainOp !== undefined) {
+          offset += retainOp;
+        } else if (deleteOp !== undefined) {
+          mutationFromCollab(() => {
+            const elements = decoratorStateValue._array.slice(offset, offset + deleteOp);
+
+            elements.forEach(element => {
+              if (lexical.isDecoratorArray(element) || lexical.isDecoratorMap(element)) {
+                element.destroy();
+              }
+            });
+            decoratorStateValue.splice(offset, deleteOp);
+          });
+        } else if (insertOp !== undefined) {
+          syncYjsDecoratorArrayValueToLexical(binding, collabNode, target, decoratorStateValue, offset);
+        } else {
+          throw new Error('Not supported');
+        }
+      }
+    }
+
+    return;
+  }
+
+  if (collabNode instanceof CollabElementNode && event instanceof yjs.YTextEvent) {
+    const {
+      keysChanged,
+      childListChanged,
+      delta
+    } = event; // Update
+
+    if (keysChanged.size > 0) {
+      collabNode.syncPropertiesFromYjs(binding, keysChanged);
+    }
+
+    if (childListChanged) {
+      collabNode.applyChildrenYjsDelta(binding, delta);
+      collabNode.syncChildrenFromYjs(binding);
+    }
+  } else if (collabNode instanceof CollabTextNode && event instanceof yjs.YMapEvent) {
+    const {
+      keysChanged
+    } = event; // Update
+
+    if (keysChanged.size > 0) {
+      collabNode.syncPropertiesAndTextFromYjs(binding, keysChanged);
+    }
+  } else if (collabNode instanceof CollabDecoratorNode && event instanceof yjs.YXmlEvent) {
+    const {
+      attributesChanged
+    } = event; // Update
+
+    if (attributesChanged.size > 0) {
+      collabNode.syncPropertiesFromYjs(binding, attributesChanged);
+    }
+  } else {
+    throw new Error('Should never happen');
+  }
+}
+
+function syncYjsChangesToLexical(binding, provider, events) {
+  const editor = binding.editor;
+  const currentEditorState = editor._editorState;
+  editor.update(() => {
+    // $FlowFixMe: this is always true
+    const pendingEditorState = editor._pendingEditorState;
+
+    for (let i = 0; i < events.length; i++) {
+      const event = events[i];
+      syncEvent(binding, event);
+    }
+
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection)) {
+      // We can't use Yjs's cursor position here, as it doesn't always
+      // handle selection recovery correctly – especially on elements that
+      // get moved around or split. So instead, we roll our own solution.
+      if (doesSelectionNeedRecovering(selection)) {
+        const prevSelection = currentEditorState._selection;
+
+        if (lexical.$isRangeSelection(prevSelection)) {
+          const prevOffsetView = $createOffsetView(editor, 0, currentEditorState);
+          const nextOffsetView = $createOffsetView(editor, 0, pendingEditorState);
+          const [start, end] = prevOffsetView.getOffsetsFromSelection(prevSelection);
+          const nextSelection = nextOffsetView.createSelectionFromOffsets(start, end, prevOffsetView);
+
+          if (nextSelection !== null) {
+            lexical.$setSelection(nextSelection);
+          } else {
+            // Fallback is to use the Yjs cursor position
+            syncLocalCursorPosition(binding, provider);
+
+            if (doesSelectionNeedRecovering(selection)) {
+              const root = lexical.$getRoot(); // If there was a collision on the top level paragraph
+              // we need to re-add a paragraph
+
+              if (root.getChildrenSize() === 0) {
+                root.append(lexical.$createParagraphNode());
+              } // Fallback
+
+
+              lexical.$getRoot().selectEnd();
+            }
+          }
+        }
+
+        syncLexicalSelectionToYjs(binding, provider, prevSelection, lexical.$getSelection());
+      } else {
+        syncLocalCursorPosition(binding, provider);
+      }
+    }
+  }, {
+    onUpdate: () => {
+      syncCursorPositions(binding, provider);
+    },
+    skipTransforms: true,
+    tag: 'collaboration'
+  });
+}
+
+function handleNormalizationMergeConflicts(binding, normalizedNodes) {
+  // We handle the merge opperations here
+  const normalizedNodesKeys = Array.from(normalizedNodes);
+  const collabNodeMap = binding.collabNodeMap;
+  const mergedNodes = [];
+
+  for (let i = 0; i < normalizedNodesKeys.length; i++) {
+    const nodeKey = normalizedNodesKeys[i];
+    const lexicalNode = lexical.$getNodeByKey(nodeKey);
+    const collabNode = collabNodeMap.get(nodeKey);
+
+    if (collabNode instanceof CollabTextNode) {
+      if (lexical.$isTextNode(lexicalNode)) {
+        // We mutate the text collab nodes after removing
+        // all the dead nodes first, otherwise offsets break.
+        mergedNodes.push([collabNode, lexicalNode.__text]);
+      } else {
+        const offset = collabNode.getOffset();
+
+        if (offset === -1) {
+          continue;
+        }
+
+        const parent = collabNode._parent;
+        collabNode._normalized = true;
+
+        parent._xmlText.delete(offset, 1);
+
+        collabNodeMap.delete(nodeKey);
+        const parentChildren = parent._children;
+        const index = parentChildren.indexOf(collabNode);
+        parentChildren.splice(index, 1);
+      }
+    }
+  }
+
+  for (let i = 0; i < mergedNodes.length; i++) {
+    const [collabNode, text] = mergedNodes[i];
+    collabNode._text = text;
+  }
+}
+
+function syncLexicalUpdateToYjs(binding, provider, prevEditorState, currEditorState, dirtyElements, dirtyLeaves, normalizedNodes, tags) {
+  syncWithTransaction(binding, () => {
+    currEditorState.read(() => {
+      // We check if the update has come from a origin where the origin
+      // was the collaboration binding previously. This can help us
+      // prevent unecessarily re-diffing and possible re-applying
+      // the same change editor state again. For example, if a user
+      // types a character and we get it, we don't want to then insert
+      // the same character again. The exception to this heuristic is
+      // when we need to handle normalization merge conflicts.
+      if (tags.has('collaboration')) {
+        if (normalizedNodes.size > 0) {
+          handleNormalizationMergeConflicts(binding, normalizedNodes);
+        }
+
+        return;
+      }
+
+      if (dirtyElements.has('root')) {
+        const prevNodeMap = prevEditorState._nodeMap;
+        const nextLexicalRoot = lexical.$getRoot();
+        const collabRoot = binding.root;
+        collabRoot.syncPropertiesFromLexical(binding, nextLexicalRoot, prevNodeMap);
+        collabRoot.syncChildrenFromLexical(binding, nextLexicalRoot, prevNodeMap, dirtyElements, dirtyLeaves);
+      }
+
+      const selection = lexical.$getSelection();
+      const prevSelection = prevEditorState._selection;
+      syncLexicalSelectionToYjs(binding, provider, prevSelection, selection);
+    });
+  });
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function createUndoManager(binding, root) {
+  return new yjs.UndoManager(root, {
+    trackedOrigins: new Set([binding, null])
+  });
+}
+function initLocalState(provider, name, color, focusing) {
+  provider.awareness.setLocalState({
+    anchorPos: null,
+    color,
+    focusPos: null,
+    focusing: focusing,
+    name
+  });
+}
+function setLocalStateFocus(provider, focusing) {
+  const {
+    awareness
+  } = provider;
+  awareness.setLocalState({ ...awareness.getLocalState(),
+    focusing
+  });
+}
+
+exports.createBinding = createBinding;
+exports.createUndoManager = createUndoManager;
+exports.initLocalState = initLocalState;
+exports.setLocalStateFocus = setLocalStateFocus;
+exports.syncCursorPositions = syncCursorPositions;
+exports.syncLexicalUpdateToYjs = syncLexicalUpdateToYjs;
+exports.syncYjsChangesToLexical = syncYjsChangesToLexical;