@datalayer/lexical-loro 0.1.0 → 0.2.1

package/lib/collab/yjs/nodes/CollabElementNode.js

@@ -1,462 +0,0 @@
-import { $createChildrenArray } from '@lexical/offset';
-import { $getNodeByKey, $getNodeByKeyOrThrow, $isDecoratorNode, $isElementNode, $isTextNode, removeFromParent, } from 'lexical';
-import invariant from '../../utils/invariant';
-import { $createCollabNodeFromLexicalNode, $getOrInitCollabNodeFromSharedType, $syncPropertiesFromYjs, createLexicalNodeFromCollabNode, getPositionFromElementAndOffset, spliceString, syncPropertiesFromLexical, } from '../utils/Utils';
-import { CollabDecoratorNode } from './CollabDecoratorNode';
-import { CollabLineBreakNode } from './CollabLineBreakNode';
-import { CollabTextNode } from './CollabTextNode';
-export class CollabElementNode {
-    _key;
-    _children;
-    _xmlText;
-    _type;
-    _parent;
-    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 $isElementNode(node) ? node : null;
-    }
-    getNode() {
-        const node = $getNodeByKey(this._key);
-        return $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;
-        invariant(collabElementNode !== null, 'getOffset: could not find collab element node');
-        return collabElementNode.getChildOffset(this);
-    }
-    syncPropertiesFromYjs(binding, keysChanged) {
-        const lexicalNode = this.getNode();
-        invariant(lexicalNode !== null, 'syncPropertiesFromYjs: could not find element node');
-        $syncPropertiesFromYjs(binding, this._xmlText, lexicalNode, keysChanged);
-    }
-    applyChildrenYjsDelta(binding, deltas) {
-        const children = this._children;
-        let currIndex = 0;
-        let pendingSplitText = null;
-        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 && length === nodeSize) {
-                            // Text node has been deleted.
-                            children.splice(nodeIndex, 1);
-                            // If this was caused by an undo from YJS, there could be dangling text.
-                            const danglingText = spliceString(node._text, offset, delCount - 1, '');
-                            if (danglingText.length > 0) {
-                                if (prevCollabNode instanceof CollabTextNode) {
-                                    // Merge the text node with previous.
-                                    prevCollabNode._text += danglingText;
-                                }
-                                else {
-                                    // No previous text node to merge into, just delete the text.
-                                    this._xmlText.delete(offset, danglingText.length);
-                                }
-                            }
-                        }
-                        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 { node, nodeIndex, length } = getPositionFromElementAndOffset(this, currIndex, false);
-                    const collabNode = $getOrInitCollabNodeFromSharedType(binding, sharedType, this);
-                    if (node instanceof CollabTextNode &&
-                        length > 0 &&
-                        length < node._text.length) {
-                        // Trying to insert in the middle of a text node; split the text.
-                        const text = node._text;
-                        const splitIdx = text.length - length;
-                        node._text = spliceString(text, splitIdx, length, '');
-                        children.splice(nodeIndex + 1, 0, collabNode);
-                        // The insert that triggers the text split might not be a text node. Need to keep a
-                        // reference to the remaining text so that it can be added when we do create one.
-                        pendingSplitText = spliceString(text, 0, splitIdx, '');
-                    }
-                    else {
-                        children.splice(nodeIndex, 0, collabNode);
-                    }
-                    if (pendingSplitText !== null &&
-                        collabNode instanceof CollabTextNode) {
-                        // Found a text node to insert the pending text into.
-                        collabNode._text = pendingSplitText + collabNode._text;
-                        pendingSplitText = null;
-                    }
-                    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();
-        invariant(lexicalNode !== null, 'syncChildrenFromYjs: could not find element node');
-        const key = lexicalNode.__key;
-        const prevLexicalChildrenKeys = $createChildrenArray(lexicalNode, null);
-        const nextLexicalChildrenKeys = [];
-        const lexicalChildrenKeysLength = prevLexicalChildrenKeys.length;
-        const collabChildren = this._children;
-        const collabChildrenLength = collabChildren.length;
-        const collabNodeMap = binding.collabNodeMap;
-        const visitedKeys = new Set();
-        let collabKeys;
-        let writableLexicalNode;
-        let prevIndex = 0;
-        let prevChildNode = null;
-        if (collabChildrenLength !== lexicalChildrenKeysLength) {
-            writableLexicalNode = lexicalNode.getWritable();
-        }
-        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 = $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)) {
-                        invariant(false, 'syncChildrenFromYjs: expected text, element, decorator, or linebreak collab node');
-                    }
-                }
-                nextLexicalChildrenKeys[i] = lexicalChildKey;
-                prevChildNode = collabLexicalChildNode;
-                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)) {
-                    const nodeToRemove = $getNodeByKeyOrThrow(lexicalChildKey);
-                    removeFromParent(nodeToRemove);
-                    i--;
-                    prevIndex++;
-                    continue;
-                }
-                writableLexicalNode = lexicalNode.getWritable();
-                // Create/Replace
-                const lexicalChildNode = createLexicalNodeFromCollabNode(binding, childCollabNode, key);
-                const childKey = lexicalChildNode.__key;
-                collabNodeMap.set(childKey, childCollabNode);
-                nextLexicalChildrenKeys[i] = childKey;
-                if (prevChildNode === null) {
-                    const nextSibling = writableLexicalNode.getFirstChild();
-                    writableLexicalNode.__first = childKey;
-                    if (nextSibling !== null) {
-                        const writableNextSibling = nextSibling.getWritable();
-                        writableNextSibling.__prev = childKey;
-                        lexicalChildNode.__next = writableNextSibling.__key;
-                    }
-                }
-                else {
-                    const writablePrevChildNode = prevChildNode.getWritable();
-                    const nextSibling = prevChildNode.getNextSibling();
-                    writablePrevChildNode.__next = childKey;
-                    lexicalChildNode.__prev = prevChildNode.__key;
-                    if (nextSibling !== null) {
-                        const writableNextSibling = nextSibling.getWritable();
-                        writableNextSibling.__prev = childKey;
-                        lexicalChildNode.__next = writableNextSibling.__key;
-                    }
-                }
-                if (i === collabChildrenLength - 1) {
-                    writableLexicalNode.__last = childKey;
-                }
-                writableLexicalNode.__size++;
-                prevChildNode = lexicalChildNode;
-            }
-        }
-        for (let i = 0; i < lexicalChildrenKeysLength; i++) {
-            const lexicalChildKey = prevLexicalChildrenKeys[i];
-            if (!visitedKeys.has(lexicalChildKey)) {
-                // Remove
-                const lexicalChildNode = $getNodeByKeyOrThrow(lexicalChildKey);
-                const collabNode = binding.collabNodeMap.get(lexicalChildKey);
-                if (collabNode !== undefined) {
-                    collabNode.destroy(binding);
-                }
-                removeFromParent(lexicalChildNode);
-            }
-        }
-    }
-    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 &&
-            $isElementNode(nextChildNode)) {
-            childCollabNode.syncPropertiesFromLexical(binding, nextChildNode, prevNodeMap);
-            childCollabNode.syncChildrenFromLexical(binding, nextChildNode, prevNodeMap, dirtyElements, dirtyLeaves);
-        }
-        else if (childCollabNode instanceof CollabTextNode &&
-            $isTextNode(nextChildNode)) {
-            childCollabNode.syncPropertiesAndTextFromLexical(binding, nextChildNode, prevNodeMap);
-        }
-        else if (childCollabNode instanceof CollabDecoratorNode &&
-            $isDecoratorNode(nextChildNode)) {
-            childCollabNode.syncPropertiesFromLexical(binding, nextChildNode, prevNodeMap);
-        }
-    }
-    syncChildrenFromLexical(binding, nextLexicalNode, prevNodeMap, dirtyElements, dirtyLeaves) {
-        const prevLexicalNode = this.getPrevNode(prevNodeMap);
-        const prevChildren = prevLexicalNode === null
-            ? []
-            : $createChildrenArray(prevLexicalNode, prevNodeMap);
-        const nextChildren = $createChildrenArray(nextLexicalNode, null);
-        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) {
-            invariant(collabNode !== undefined, 'splice: could not find collab element node');
-            this.append(collabNode);
-            return;
-        }
-        const offset = child.getOffset();
-        invariant(offset !== -1, 'splice: expected offset to be greater than zero');
-        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);
-        }
-        if (collabNodeMap.get(this._key) === this) {
-            collabNodeMap.delete(this._key);
-        }
-    }
-}
-export function $createCollabElementNode(xmlText, parent, type) {
-    const collabNode = new CollabElementNode(xmlText, parent, type);
-    xmlText._collabNode = collabNode;
-    return collabNode;
-}

package/lib/collab/yjs/nodes/CollabLineBreakNode.d.ts

@@ -1,19 +0,0 @@
-import type { LineBreakNode, NodeKey } from 'lexical';
-import type { Map as YMap } from 'yjs';
-import type { Binding } from '../Bindings';
-import type { CollabElementNode } from './CollabElementNode';
-export declare class CollabLineBreakNode {
-    _map: YMap<unknown>;
-    _key: NodeKey;
-    _parent: CollabElementNode;
-    _type: 'linebreak';
-    constructor(map: YMap<unknown>, parent: CollabElementNode);
-    getNode(): null | LineBreakNode;
-    getKey(): NodeKey;
-    getSharedType(): YMap<unknown>;
-    getType(): string;
-    getSize(): number;
-    getOffset(): number;
-    destroy(binding: Binding): void;
-}
-export declare function $createCollabLineBreakNode(map: YMap<unknown>, parent: CollabElementNode): CollabLineBreakNode;

package/lib/collab/yjs/nodes/CollabLineBreakNode.js

@@ -1,44 +0,0 @@
-import { $getNodeByKey, $isLineBreakNode } from 'lexical';
-export class CollabLineBreakNode {
-    _map;
-    _key;
-    _parent;
-    _type;
-    constructor(map, parent) {
-        this._key = '';
-        this._map = map;
-        this._parent = parent;
-        this._type = 'linebreak';
-    }
-    getNode() {
-        const node = $getNodeByKey(this._key);
-        return $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;
-        if (collabNodeMap.get(this._key) === this) {
-            collabNodeMap.delete(this._key);
-        }
-    }
-}
-export function $createCollabLineBreakNode(map, parent) {
-    const collabNode = new CollabLineBreakNode(map, parent);
-    map._collabNode = collabNode;
-    return collabNode;
-}

package/lib/collab/yjs/nodes/CollabTextNode.d.ts

@@ -1,25 +0,0 @@
-import type { NodeKey, NodeMap, TextNode } from 'lexical';
-import type { Map as YMap } from 'yjs';
-import type { Binding } from '../Bindings';
-import type { CollabElementNode } from './CollabElementNode';
-export declare class CollabTextNode {
-    _map: YMap<unknown>;
-    _key: NodeKey;
-    _parent: CollabElementNode;
-    _text: string;
-    _type: string;
-    _normalized: boolean;
-    constructor(map: YMap<unknown>, text: string, parent: CollabElementNode, type: string);
-    getPrevNode(nodeMap: null | NodeMap): null | TextNode;
-    getNode(): null | TextNode;
-    getSharedType(): YMap<unknown>;
-    getType(): string;
-    getKey(): NodeKey;
-    getSize(): number;
-    getOffset(): number;
-    spliceText(index: number, delCount: number, newText: string): void;
-    syncPropertiesAndTextFromLexical(binding: Binding, nextLexicalNode: TextNode, prevNodeMap: null | NodeMap): void;
-    syncPropertiesAndTextFromYjs(binding: Binding, keysChanged: null | Set<string>): void;
-    destroy(binding: Binding): void;
-}
-export declare function $createCollabTextNode(map: YMap<unknown>, text: string, parent: CollabElementNode, type: string): CollabTextNode;

package/lib/collab/yjs/nodes/CollabTextNode.js

@@ -1,103 +0,0 @@
-import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, } from 'lexical';
-import invariant from '../../utils/invariant';
-import simpleDiffWithCursor from '../../utils/simpleDiffWithCursor';
-import { $syncPropertiesFromYjs, syncPropertiesFromLexical } from '../utils/Utils';
-function $diffTextContentAndApplyDelta(collabNode, key, prevText, nextText) {
-    const selection = $getSelection();
-    let cursorOffset = nextText.length;
-    if ($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);
-}
-export class CollabTextNode {
-    _map;
-    _key;
-    _parent;
-    _text;
-    _type;
-    _normalized;
-    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 $isTextNode(node) ? node : null;
-    }
-    getNode() {
-        const node = $getNodeByKey(this._key);
-        return $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();
-        invariant(lexicalNode !== null, 'syncPropertiesAndTextFromYjs: could not find decorator node');
-        $syncPropertiesFromYjs(binding, this._map, lexicalNode, keysChanged);
-        const collabText = this._text;
-        if (lexicalNode.__text !== collabText) {
-            lexicalNode.setTextContent(collabText);
-        }
-    }
-    destroy(binding) {
-        const collabNodeMap = binding.collabNodeMap;
-        if (collabNodeMap.get(this._key) === this) {
-            collabNodeMap.delete(this._key);
-        }
-    }
-}
-export function $createCollabTextNode(map, text, parent, type) {
-    const collabNode = new CollabTextNode(map, text, parent, type);
-    map._collabNode = collabNode;
-    return collabNode;
-}