@liveblocks/client 0.16.1 → 0.16.4-beta1

package/shared.mjs

@@ -0,0 +1,1947 @@
+var ServerMessageType;
+(function (ServerMessageType) {
+    ServerMessageType[ServerMessageType["UpdatePresence"] = 100] = "UpdatePresence";
+    ServerMessageType[ServerMessageType["UserJoined"] = 101] = "UserJoined";
+    ServerMessageType[ServerMessageType["UserLeft"] = 102] = "UserLeft";
+    ServerMessageType[ServerMessageType["Event"] = 103] = "Event";
+    ServerMessageType[ServerMessageType["RoomState"] = 104] = "RoomState";
+    ServerMessageType[ServerMessageType["InitialStorageState"] = 200] = "InitialStorageState";
+    ServerMessageType[ServerMessageType["UpdateStorage"] = 201] = "UpdateStorage";
+})(ServerMessageType || (ServerMessageType = {}));
+var ClientMessageType;
+(function (ClientMessageType) {
+    ClientMessageType[ClientMessageType["UpdatePresence"] = 100] = "UpdatePresence";
+    ClientMessageType[ClientMessageType["ClientEvent"] = 103] = "ClientEvent";
+    ClientMessageType[ClientMessageType["FetchStorage"] = 200] = "FetchStorage";
+    ClientMessageType[ClientMessageType["UpdateStorage"] = 201] = "UpdateStorage";
+})(ClientMessageType || (ClientMessageType = {}));
+var CrdtType;
+(function (CrdtType) {
+    CrdtType[CrdtType["Object"] = 0] = "Object";
+    CrdtType[CrdtType["List"] = 1] = "List";
+    CrdtType[CrdtType["Map"] = 2] = "Map";
+    CrdtType[CrdtType["Register"] = 3] = "Register";
+})(CrdtType || (CrdtType = {}));
+var OpType;
+(function (OpType) {
+    OpType[OpType["Init"] = 0] = "Init";
+    OpType[OpType["SetParentKey"] = 1] = "SetParentKey";
+    OpType[OpType["CreateList"] = 2] = "CreateList";
+    OpType[OpType["UpdateObject"] = 3] = "UpdateObject";
+    OpType[OpType["CreateObject"] = 4] = "CreateObject";
+    OpType[OpType["DeleteCrdt"] = 5] = "DeleteCrdt";
+    OpType[OpType["DeleteObjectKey"] = 6] = "DeleteObjectKey";
+    OpType[OpType["CreateMap"] = 7] = "CreateMap";
+    OpType[OpType["CreateRegister"] = 8] = "CreateRegister";
+})(OpType || (OpType = {}));
+var WebsocketCloseCodes;
+(function (WebsocketCloseCodes) {
+    WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+    WebsocketCloseCodes[WebsocketCloseCodes["INVALID_MESSAGE_FORMAT"] = 4000] = "INVALID_MESSAGE_FORMAT";
+    WebsocketCloseCodes[WebsocketCloseCodes["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+    WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+    WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+})(WebsocketCloseCodes || (WebsocketCloseCodes = {}));
+
+class AbstractCrdt {
+    /**
+     * @internal
+     */
+    get _doc() {
+        return this.__doc;
+    }
+    get roomId() {
+        return this.__doc ? this.__doc.roomId : null;
+    }
+    /**
+     * @internal
+     */
+    get _id() {
+        return this.__id;
+    }
+    /**
+     * @internal
+     */
+    get _parent() {
+        return this.__parent;
+    }
+    /**
+     * @internal
+     */
+    get _parentKey() {
+        return this.__parentKey;
+    }
+    /**
+     * @internal
+     */
+    _apply(op, _isLocal) {
+        switch (op.type) {
+            case OpType.DeleteCrdt: {
+                if (this._parent != null && this._parentKey != null) {
+                    return this._parent._detachChild(this);
+                }
+                return { modified: false };
+            }
+        }
+        return { modified: false };
+    }
+    /**
+     * @internal
+     */
+    _setParentLink(parent, key) {
+        if (this.__parent != null && this.__parent !== parent) {
+            throw new Error("Cannot attach parent if it already exist");
+        }
+        this.__parentKey = key;
+        this.__parent = parent;
+    }
+    /**
+     * @internal
+     */
+    _attach(id, doc) {
+        if (this.__id || this.__doc) {
+            throw new Error("Cannot attach if CRDT is already attached");
+        }
+        doc.addItem(id, this);
+        this.__id = id;
+        this.__doc = doc;
+    }
+    /**
+     * @internal
+     */
+    _detach() {
+        if (this.__doc && this.__id) {
+            this.__doc.deleteItem(this.__id);
+        }
+        this.__parent = undefined;
+        this.__doc = undefined;
+    }
+}
+
+const min = 32;
+const max = 126;
+function makePosition(before, after) {
+    // No children
+    if (before == null && after == null) {
+        return pos([min + 1]);
+    }
+    // Insert at the end
+    if (before != null && after == null) {
+        return getNextPosition(before);
+    }
+    // Insert at the start
+    if (before == null && after != null) {
+        return getPreviousPosition(after);
+    }
+    return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+}
+function getPreviousPosition(after) {
+    const result = [];
+    const afterCodes = posCodes(after);
+    for (let i = 0; i < afterCodes.length; i++) {
+        const code = afterCodes[i];
+        if (code <= min + 1) {
+            result.push(min);
+            if (afterCodes.length - 1 === i) {
+                result.push(max);
+                break;
+            }
+        }
+        else {
+            result.push(code - 1);
+            break;
+        }
+    }
+    return pos(result);
+}
+function getNextPosition(before) {
+    const result = [];
+    const beforeCodes = posCodes(before);
+    for (let i = 0; i < beforeCodes.length; i++) {
+        const code = beforeCodes[i];
+        if (code === max) {
+            result.push(code);
+            if (beforeCodes.length - 1 === i) {
+                result.push(min + 1);
+                break;
+            }
+        }
+        else {
+            result.push(code + 1);
+            break;
+        }
+    }
+    return pos(result);
+}
+function makePositionFromCodes(before, after) {
+    let index = 0;
+    const result = [];
+    while (true) {
+        const beforeDigit = before[index] || min;
+        const afterDigit = after[index] || max;
+        if (beforeDigit > afterDigit) {
+            throw new Error(`Impossible to generate position between ${before} and ${after}`);
+        }
+        if (beforeDigit === afterDigit) {
+            result.push(beforeDigit);
+            index++;
+            continue;
+        }
+        if (afterDigit - beforeDigit === 1) {
+            result.push(beforeDigit);
+            result.push(...makePositionFromCodes(before.slice(index + 1), []));
+            break;
+        }
+        const mid = (afterDigit + beforeDigit) >> 1;
+        result.push(mid);
+        break;
+    }
+    return result;
+}
+function posCodes(str) {
+    const codes = [];
+    for (let i = 0; i < str.length; i++) {
+        codes.push(str.charCodeAt(i));
+    }
+    return codes;
+}
+function pos(codes) {
+    return String.fromCharCode(...codes);
+}
+function compare(posA, posB) {
+    const aCodes = posCodes(posA);
+    const bCodes = posCodes(posB);
+    const maxLength = Math.max(aCodes.length, bCodes.length);
+    for (let i = 0; i < maxLength; i++) {
+        const a = aCodes[i] == null ? min : aCodes[i];
+        const b = bCodes[i] == null ? min : bCodes[i];
+        if (a === b) {
+            continue;
+        }
+        else {
+            return a - b;
+        }
+    }
+    throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
+}
+
+/**
+ * @internal
+ */
+class LiveRegister extends AbstractCrdt {
+    constructor(data) {
+        super();
+        this._data = data;
+    }
+    get data() {
+        return this._data;
+    }
+    /**
+     * INTERNAL
+     */
+    static _deserialize([id, item], _parentToChildren, doc) {
+        if (item.type !== CrdtType.Register) {
+            throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
+        }
+        const register = new LiveRegister(item.data);
+        register._attach(id, doc);
+        return register;
+    }
+    /**
+     * INTERNAL
+     */
+    _serialize(parentId, parentKey, doc, intent) {
+        if (this._id == null || parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize register if parentId or parentKey is undefined");
+        }
+        return [
+            {
+                type: OpType.CreateRegister,
+                opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
+                id: this._id,
+                intent,
+                parentId,
+                parentKey,
+                data: this.data,
+            },
+        ];
+    }
+    /**
+     * INTERNAL
+     */
+    _toSerializedCrdt() {
+        var _a;
+        return {
+            type: CrdtType.Register,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+            data: this.data,
+        };
+    }
+    _attachChild(_op, _isLocal) {
+        throw new Error("Method not implemented.");
+    }
+    _detachChild(_crdt) {
+        throw new Error("Method not implemented.");
+    }
+    _apply(op, isLocal) {
+        return super._apply(op, isLocal);
+    }
+}
+
+/**
+ * The LiveList class represents an ordered collection of items that is synchronized across clients.
+ */
+class LiveList extends AbstractCrdt {
+    constructor(items = []) {
+        super();
+        this._items = [];
+        let position = undefined;
+        for (let i = 0; i < items.length; i++) {
+            const newPosition = makePosition(position);
+            const item = selfOrRegister(items[i]);
+            this._items.push([item, newPosition]);
+            position = newPosition;
+        }
+    }
+    /**
+     * @internal
+     */
+    static _deserialize([id], parentToChildren, doc) {
+        const list = new LiveList([]);
+        list._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return list;
+        }
+        for (const entry of children) {
+            const child = deserialize(entry, parentToChildren, doc);
+            child._setParentLink(list, entry[1].parentKey);
+            list._items.push([child, entry[1].parentKey]);
+            list._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        }
+        return list;
+    }
+    /**
+     * @internal
+     */
+    _serialize(parentId, parentKey, doc, intent) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        if (parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize list if parentId or parentKey is undefined");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
+            intent,
+            type: OpType.CreateList,
+            parentId,
+            parentKey,
+        };
+        ops.push(op);
+        for (const [value, key] of this._items) {
+            ops.push(...value._serialize(this._id, key, doc));
+        }
+        return ops;
+    }
+    /**
+     * @internal
+     */
+    _indexOfPosition(position) {
+        return this._items.findIndex((item) => item[1] === position);
+    }
+    /**
+     * @internal
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [item] of this._items) {
+            item._attach(doc.generateId(), doc);
+        }
+    }
+    /**
+     * @internal
+     */
+    _detach() {
+        super._detach();
+        for (const [value] of this._items) {
+            value._detach();
+        }
+    }
+    /**
+     * @internal
+     */
+    _attachChild(op, isLocal) {
+        var _a;
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const { id, parentKey, intent } = op;
+        const key = parentKey;
+        const child = creationOpToLiveStructure(op);
+        if (this._doc.getItem(id) !== undefined) {
+            return { modified: false };
+        }
+        child._attach(id, this._doc);
+        child._setParentLink(this, key);
+        const index = this._items.findIndex((entry) => entry[1] === key);
+        let newKey = key;
+        // If there is a conflict
+        if (index !== -1) {
+            if (intent === "set") {
+                const existingItem = this._items[index][0];
+                existingItem._detach();
+                const storageUpdate = {
+                    node: this,
+                    type: "LiveList",
+                    updates: [
+                        {
+                            index,
+                            type: "set",
+                            item: child instanceof LiveRegister ? child.data : child,
+                        },
+                    ],
+                };
+                this._items[index][0] = child;
+                return {
+                    modified: storageUpdate,
+                    reverse: existingItem._serialize(this._id, key, this._doc, "set"),
+                };
+            }
+            else if (isLocal) {
+                // If change is local => assign a temporary position to newly attached child
+                const before = this._items[index] ? this._items[index][1] : undefined;
+                const after = this._items[index + 1]
+                    ? this._items[index + 1][1]
+                    : undefined;
+                newKey = makePosition(before, after);
+                child._setParentLink(this, newKey);
+            }
+            else {
+                // If change is remote => assign a temporary position to existing child until we get the fix from the backend
+                this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) === null || _a === void 0 ? void 0 : _a[1]);
+            }
+        }
+        this._items.push([child, newKey]);
+        this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = this._items.findIndex((entry) => entry[1] === newKey);
+        return {
+            reverse: [{ type: OpType.DeleteCrdt, id }],
+            modified: {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        type: "insert",
+                        item: child instanceof LiveRegister ? child.data : child,
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * @internal
+     */
+    _detachChild(child) {
+        if (child) {
+            const reverse = child._serialize(this._id, child._parentKey, this._doc);
+            const indexToDelete = this._items.findIndex((item) => item[0] === child);
+            this._items.splice(indexToDelete, 1);
+            child._detach();
+            const storageUpdate = {
+                node: this,
+                type: "LiveList",
+                updates: [{ index: indexToDelete, type: "delete" }],
+            };
+            return { modified: storageUpdate, reverse };
+        }
+        return { modified: false };
+    }
+    /**
+     * @internal
+     */
+    _setChildKey(key, child, previousKey) {
+        var _a;
+        child._setParentLink(this, key);
+        const previousIndex = this._items.findIndex((entry) => entry[0]._id === child._id);
+        const index = this._items.findIndex((entry) => entry[1] === key);
+        // Assign a temporary position until we get the fix from the backend
+        if (index !== -1) {
+            this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) === null || _a === void 0 ? void 0 : _a[1]);
+        }
+        const item = this._items.find((item) => item[0] === child);
+        if (item) {
+            item[1] = key;
+        }
+        this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = this._items.findIndex((entry) => entry[0]._id === child._id);
+        const updatesDelta = newIndex === previousIndex
+            ? []
+            : [
+                {
+                    index: newIndex,
+                    item: child instanceof LiveRegister ? child.data : child,
+                    previousIndex: previousIndex,
+                    type: "move",
+                },
+            ];
+        return {
+            modified: {
+                node: this,
+                type: "LiveList",
+                updates: updatesDelta,
+            },
+            reverse: [
+                {
+                    type: OpType.SetParentKey,
+                    id: item === null || item === void 0 ? void 0 : item[0]._id,
+                    parentKey: previousKey,
+                },
+            ],
+        };
+    }
+    /**
+     * @internal
+     */
+    _apply(op, isLocal) {
+        return super._apply(op, isLocal);
+    }
+    /**
+     * @internal
+     */
+    _toSerializedCrdt() {
+        var _a;
+        return {
+            type: CrdtType.List,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+        };
+    }
+    /**
+     * Returns the number of elements.
+     */
+    get length() {
+        return this._items.length;
+    }
+    /**
+     * Adds one element to the end of the LiveList.
+     * @param element The element to add to the end of the LiveList.
+     */
+    push(element) {
+        return this.insert(element, this.length);
+    }
+    /**
+     * Inserts one element at a specified index.
+     * @param element The element to insert.
+     * @param index The index at which you want to insert the element.
+     */
+    insert(element, index) {
+        if (index < 0 || index > this._items.length) {
+            throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`);
+        }
+        const before = this._items[index - 1]
+            ? this._items[index - 1][1]
+            : undefined;
+        const after = this._items[index] ? this._items[index][1] : undefined;
+        const position = makePosition(before, after);
+        const value = selfOrRegister(element);
+        value._setParentLink(this, position);
+        this._items.push([value, position]);
+        this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = this._items.findIndex((entry) => entry[1] === position);
+        if (this._doc && this._id) {
+            const id = this._doc.generateId();
+            value._attach(id, this._doc);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        item: value instanceof LiveRegister ? value.data : value,
+                        type: "insert",
+                    },
+                ],
+            });
+            this._doc.dispatch(value._serialize(this._id, position, this._doc), [{ type: OpType.DeleteCrdt, id }], storageUpdates);
+        }
+    }
+    /**
+     * Move one element from one index to another.
+     * @param index The index of the element to move
+     * @param targetIndex The index where the element should be after moving.
+     */
+    move(index, targetIndex) {
+        if (targetIndex < 0) {
+            throw new Error("targetIndex cannot be less than 0");
+        }
+        if (targetIndex >= this._items.length) {
+            throw new Error("targetIndex cannot be greater or equal than the list length");
+        }
+        if (index < 0) {
+            throw new Error("index cannot be less than 0");
+        }
+        if (index >= this._items.length) {
+            throw new Error("index cannot be greater or equal than the list length");
+        }
+        let beforePosition = null;
+        let afterPosition = null;
+        if (index < targetIndex) {
+            afterPosition =
+                targetIndex === this._items.length - 1
+                    ? undefined
+                    : this._items[targetIndex + 1][1];
+            beforePosition = this._items[targetIndex][1];
+        }
+        else {
+            afterPosition = this._items[targetIndex][1];
+            beforePosition =
+                targetIndex === 0 ? undefined : this._items[targetIndex - 1][1];
+        }
+        const position = makePosition(beforePosition, afterPosition);
+        const item = this._items[index];
+        const previousPosition = item[1];
+        item[1] = position;
+        item[0]._setParentLink(this, position);
+        this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+        const newIndex = this._items.findIndex((entry) => entry[1] === position);
+        if (this._doc && this._id) {
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index: newIndex,
+                        previousIndex: index,
+                        item: item[0],
+                        type: "move",
+                    },
+                ],
+            });
+            this._doc.dispatch([
+                {
+                    type: OpType.SetParentKey,
+                    id: item[0]._id,
+                    opId: this._doc.generateOpId(),
+                    parentKey: position,
+                },
+            ], [
+                {
+                    type: OpType.SetParentKey,
+                    id: item[0]._id,
+                    parentKey: previousPosition,
+                },
+            ], storageUpdates);
+        }
+    }
+    /**
+     * Deletes an element at the specified index
+     * @param index The index of the element to delete
+     */
+    delete(index) {
+        if (index < 0 || index >= this._items.length) {
+            throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
+        }
+        const item = this._items[index];
+        item[0]._detach();
+        this._items.splice(index, 1);
+        if (this._doc) {
+            const childRecordId = item[0]._id;
+            if (childRecordId) {
+                const storageUpdates = new Map();
+                storageUpdates.set(this._id, {
+                    node: this,
+                    type: "LiveList",
+                    updates: [{ index: index, type: "delete" }],
+                });
+                this._doc.dispatch([
+                    {
+                        id: childRecordId,
+                        opId: this._doc.generateOpId(),
+                        type: OpType.DeleteCrdt,
+                    },
+                ], item[0]._serialize(this._id, item[1]), storageUpdates);
+            }
+        }
+    }
+    clear() {
+        if (this._doc) {
+            const ops = [];
+            const reverseOps = [];
+            const updateDelta = [];
+            let i = 0;
+            for (const item of this._items) {
+                item[0]._detach();
+                const childId = item[0]._id;
+                if (childId) {
+                    ops.push({ id: childId, type: OpType.DeleteCrdt });
+                    reverseOps.push(...item[0]._serialize(this._id, item[1]));
+                    updateDelta.push({ index: i, type: "delete" });
+                }
+                i++;
+            }
+            this._items = [];
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: updateDelta,
+            });
+            this._doc.dispatch(ops, reverseOps, storageUpdates);
+        }
+        else {
+            for (const item of this._items) {
+                item[0]._detach();
+            }
+            this._items = [];
+        }
+    }
+    set(index, item) {
+        if (index < 0 || index >= this._items.length) {
+            throw new Error(`Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
+        }
+        const [existingItem, position] = this._items[index];
+        existingItem._detach();
+        const value = selfOrRegister(item);
+        value._setParentLink(this, position);
+        this._items[index][0] = value;
+        if (this._doc && this._id) {
+            const id = this._doc.generateId();
+            value._attach(id, this._doc);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveList",
+                updates: [
+                    {
+                        index,
+                        item: value instanceof LiveRegister ? value.data : value,
+                        type: "set",
+                    },
+                ],
+            });
+            this._doc.dispatch(value._serialize(this._id, position, this._doc, "set"), existingItem._serialize(this._id, position, undefined, "set"), storageUpdates);
+        }
+    }
+    /**
+     * Returns an Array of all the elements in the LiveList.
+     */
+    toArray() {
+        return this._items.map((entry) => selfOrRegisterValue(entry[0]));
+    }
+    /**
+     * Tests whether all elements pass the test implemented by the provided function.
+     * @param predicate Function to test for each element, taking two arguments (the element and its index).
+     * @returns true if the predicate function returns a truthy value for every element. Otherwise, false.
+     */
+    every(predicate) {
+        return this.toArray().every(predicate);
+    }
+    /**
+     * Creates an array with all elements that pass the test implemented by the provided function.
+     * @param predicate Function to test each element of the LiveList. Return a value that coerces to true to keep the element, or to false otherwise.
+     * @returns An array with the elements that pass the test.
+     */
+    filter(predicate) {
+        return this.toArray().filter(predicate);
+    }
+    /**
+     * Returns the first element that satisfies the provided testing function.
+     * @param predicate Function to execute on each value.
+     * @returns The value of the first element in the LiveList that satisfies the provided testing function. Otherwise, undefined is returned.
+     */
+    find(predicate) {
+        return this.toArray().find(predicate);
+    }
+    /**
+     * Returns the index of the first element in the LiveList that satisfies the provided testing function.
+     * @param predicate Function to execute on each value until the function returns true, indicating that the satisfying element was found.
+     * @returns The index of the first element in the LiveList that passes the test. Otherwise, -1.
+     */
+    findIndex(predicate) {
+        return this.toArray().findIndex(predicate);
+    }
+    /**
+     * Executes a provided function once for each element.
+     * @param callbackfn Function to execute on each element.
+     */
+    forEach(callbackfn) {
+        return this.toArray().forEach(callbackfn);
+    }
+    /**
+     * Get the element at the specified index.
+     * @param index The index on the element to get.
+     * @returns The element at the specified index or undefined.
+     */
+    get(index) {
+        if (index < 0 || index >= this._items.length) {
+            return undefined;
+        }
+        return selfOrRegisterValue(this._items[index][0]);
+    }
+    /**
+     * Returns the first index at which a given element can be found in the LiveList, or -1 if it is not present.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index to start the search at.
+     * @returns The first index of the element in the LiveList; -1 if not found.
+     */
+    indexOf(searchElement, fromIndex) {
+        return this.toArray().indexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns the last index at which a given element can be found in the LiveList, or -1 if it is not present. The LiveLsit is searched backwards, starting at fromIndex.
+     * @param searchElement Element to locate.
+     * @param fromIndex The index at which to start searching backwards.
+     * @returns
+     */
+    lastIndexOf(searchElement, fromIndex) {
+        return this.toArray().lastIndexOf(searchElement, fromIndex);
+    }
+    /**
+     * Creates an array populated with the results of calling a provided function on every element.
+     * @param callback Function that is called for every element.
+     * @returns An array with each element being the result of the callback function.
+     */
+    map(callback) {
+        return this._items.map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
+    }
+    /**
+     * Tests whether at least one element in the LiveList passes the test implemented by the provided function.
+     * @param predicate Function to test for each element.
+     * @returns true if the callback function returns a truthy value for at least one element. Otherwise, false.
+     */
+    some(predicate) {
+        return this.toArray().some(predicate);
+    }
+    [Symbol.iterator]() {
+        return new LiveListIterator(this._items);
+    }
+}
+class LiveListIterator {
+    constructor(items) {
+        this._innerIterator = items[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this;
+    }
+    next() {
+        const result = this._innerIterator.next();
+        if (result.done) {
+            return {
+                done: true,
+                value: undefined,
+            };
+        }
+        return {
+            value: selfOrRegisterValue(result.value[0]),
+        };
+    }
+}
+
+/**
+ * The LiveMap class is similar to a JavaScript Map that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveMap extends AbstractCrdt {
+    constructor(entries) {
+        super();
+        if (entries) {
+            const mappedEntries = [];
+            for (const entry of entries) {
+                const value = selfOrRegister(entry[1]);
+                value._setParentLink(this, entry[0]);
+                mappedEntries.push([entry[0], value]);
+            }
+            this._map = new Map(mappedEntries);
+        }
+        else {
+            this._map = new Map();
+        }
+    }
+    /**
+     * @internal
+     */
+    _serialize(parentId, parentKey, doc, intent) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        if (parentId == null || parentKey == null) {
+            throw new Error("Cannot serialize map if parentId or parentKey is undefined");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
+            type: OpType.CreateMap,
+            intent,
+            parentId,
+            parentKey,
+        };
+        ops.push(op);
+        for (const [key, value] of this._map) {
+            ops.push(...value._serialize(this._id, key, doc));
+        }
+        return ops;
+    }
+    /**
+     * @internal
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== CrdtType.Map) {
+            throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
+        }
+        const map = new LiveMap();
+        map._attach(id, doc);
+        const children = parentToChildren.get(id);
+        if (children == null) {
+            return map;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = deserialize(entry, parentToChildren, doc);
+            child._setParentLink(map, crdt.parentKey);
+            map._map.set(crdt.parentKey, child);
+        }
+        return map;
+    }
+    /**
+     * @internal
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [_key, value] of this._map) {
+            if (isCrdt(value)) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _attachChild(op, _isLocal) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const { id, parentKey } = op;
+        const key = parentKey;
+        const child = creationOpToLiveStructure(op);
+        if (this._doc.getItem(id) !== undefined) {
+            return { modified: false };
+        }
+        const previousValue = this._map.get(key);
+        let reverse;
+        if (previousValue) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else {
+            reverse = [{ type: OpType.DeleteCrdt, id }];
+        }
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        this._map.set(key, child);
+        return {
+            modified: {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "update" } },
+            },
+            reverse,
+        };
+    }
+    /**
+     * @internal
+     */
+    _detach() {
+        super._detach();
+        for (const item of this._map.values()) {
+            item._detach();
+        }
+    }
+    /**
+     * @internal
+     */
+    _detachChild(child) {
+        const reverse = child._serialize(this._id, child._parentKey, this._doc);
+        for (const [key, value] of this._map) {
+            if (value === child) {
+                this._map.delete(key);
+            }
+        }
+        child._detach();
+        const storageUpdate = {
+            node: this,
+            type: "LiveMap",
+            updates: { [child._parentKey]: { type: "delete" } },
+        };
+        return { modified: storageUpdate, reverse };
+    }
+    /**
+     * @internal
+     */
+    _toSerializedCrdt() {
+        var _a;
+        return {
+            type: CrdtType.Map,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+        };
+    }
+    /**
+     * Returns a specified element from the LiveMap.
+     * @param key The key of the element to return.
+     * @returns The element associated with the specified key, or undefined if the key can't be found in the LiveMap.
+     */
+    get(key) {
+        const value = this._map.get(key);
+        if (value == undefined) {
+            return undefined;
+        }
+        return selfOrRegisterValue(value);
+    }
+    /**
+     * Adds or updates an element with a specified key and a value.
+     * @param key The key of the element to add. Should be a string.
+     * @param value The value of the element to add. Should be serializable to JSON.
+     */
+    set(key, value) {
+        const oldValue = this._map.get(key);
+        if (oldValue) {
+            oldValue._detach();
+        }
+        const item = selfOrRegister(value);
+        item._setParentLink(this, key);
+        this._map.set(key, item);
+        if (this._doc && this._id) {
+            const id = this._doc.generateId();
+            item._attach(id, this._doc);
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "update" } },
+            });
+            this._doc.dispatch(item._serialize(this._id, key, this._doc), oldValue
+                ? oldValue._serialize(this._id, key)
+                : [{ type: OpType.DeleteCrdt, id }], storageUpdates);
+        }
+    }
+    /**
+     * Returns the number of elements in the LiveMap.
+     */
+    get size() {
+        return this._map.size;
+    }
+    /**
+     * Returns a boolean indicating whether an element with the specified key exists or not.
+     * @param key The key of the element to test for presence.
+     */
+    has(key) {
+        return this._map.has(key);
+    }
+    /**
+     * Removes the specified element by key.
+     * @param key The key of the element to remove.
+     * @returns true if an element existed and has been removed, or false if the element does not exist.
+     */
+    delete(key) {
+        const item = this._map.get(key);
+        if (item == null) {
+            return false;
+        }
+        item._detach();
+        this._map.delete(key);
+        if (this._doc && item._id) {
+            const storageUpdates = new Map();
+            storageUpdates.set(this._id, {
+                node: this,
+                type: "LiveMap",
+                updates: { [key]: { type: "delete" } },
+            });
+            this._doc.dispatch([
+                {
+                    type: OpType.DeleteCrdt,
+                    id: item._id,
+                    opId: this._doc.generateOpId(),
+                },
+            ], item._serialize(this._id, key), storageUpdates);
+        }
+        return true;
+    }
+    /**
+     * Returns a new Iterator object that contains the [key, value] pairs for each element.
+     */
+    entries() {
+        const innerIterator = this._map.entries();
+        return {
+            [Symbol.iterator]: function () {
+                return this;
+            },
+            next() {
+                const iteratorValue = innerIterator.next();
+                if (iteratorValue.done) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                const entry = iteratorValue.value;
+                return {
+                    value: [entry[0], selfOrRegisterValue(iteratorValue.value[1])],
+                };
+            },
+        };
+    }
+    /**
+     * Same function object as the initial value of the entries method.
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * Returns a new Iterator object that contains the keys for each element.
+     */
+    keys() {
+        return this._map.keys();
+    }
+    /**
+     * Returns a new Iterator object that contains the values for each element.
+     */
+    values() {
+        const innerIterator = this._map.values();
+        return {
+            [Symbol.iterator]: function () {
+                return this;
+            },
+            next() {
+                const iteratorValue = innerIterator.next();
+                if (iteratorValue.done) {
+                    return {
+                        done: true,
+                        value: undefined,
+                    };
+                }
+                return {
+                    value: selfOrRegisterValue(iteratorValue.value),
+                };
+            },
+        };
+    }
+    /**
+     * Executes a provided function once per each key/value pair in the Map object, in insertion order.
+     * @param callback Function to execute for each entry in the map.
+     */
+    forEach(callback) {
+        for (const entry of this) {
+            callback(entry[1], entry[0], this);
+        }
+    }
+}
+
+/**
+ * Alternative to JSON.parse() that will not throw in production. If the passed
+ * string cannot be parsed, this will return `undefined`.
+ */
+function parseJson(rawMessage) {
+    try {
+        // eslint-disable-next-line no-restricted-syntax
+        return JSON.parse(rawMessage);
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+function isJsonArray(data) {
+    return Array.isArray(data);
+}
+function isJsonObject(data) {
+    return data !== null && typeof data === "object" && !isJsonArray(data);
+}
+
+// Keeps a set of deprecation messages in memory that it has warned about
+// already. There will be only one deprecation message in the console, no
+// matter how often it gets called.
+const _emittedDeprecationWarnings = new Set();
+/**
+ * Displays a deprecation warning in the dev console. Only in dev mode, and
+ * only once per message/key. In production, this is a no-op.
+ */
+function deprecate(message, key = message) {
+    if (process.env.NODE_ENV !== "production") {
+        if (!_emittedDeprecationWarnings.has(key)) {
+            _emittedDeprecationWarnings.add(key);
+            console.warn(`DEPRECATION WARNING: ${message}`);
+        }
+    }
+}
+/**
+ * Conditionally displays a deprecation warning in the dev
+ * console if the first argument is truthy. Only in dev mode, and
+ * only once per message/key. In production, this is a no-op.
+ */
+function deprecateIf(condition, message, key = message) {
+    if (process.env.NODE_ENV !== "production") {
+        if (condition) {
+            deprecate(message, key);
+        }
+    }
+}
+function remove(array, item) {
+    for (let i = 0; i < array.length; i++) {
+        if (array[i] === item) {
+            array.splice(i, 1);
+            break;
+        }
+    }
+}
+/**
+ * Removes null and undefined values from the array, and reflects this in the
+ * output type.
+ */
+function compact(items) {
+    return items.filter((item) => item != null);
+}
+function creationOpToLiveStructure(op) {
+    switch (op.type) {
+        case OpType.CreateRegister:
+            return new LiveRegister(op.data);
+        case OpType.CreateObject:
+            return new LiveObject(op.data);
+        case OpType.CreateMap:
+            return new LiveMap();
+        case OpType.CreateList:
+            return new LiveList();
+    }
+}
+function isSameNodeOrChildOf(node, parent) {
+    if (node === parent) {
+        return true;
+    }
+    if (node._parent) {
+        return isSameNodeOrChildOf(node._parent, parent);
+    }
+    return false;
+}
+function deserialize(entry, parentToChildren, doc) {
+    switch (entry[1].type) {
+        case CrdtType.Object: {
+            return LiveObject._deserialize(entry, parentToChildren, doc);
+        }
+        case CrdtType.List: {
+            return LiveList._deserialize(entry, parentToChildren, doc);
+        }
+        case CrdtType.Map: {
+            return LiveMap._deserialize(entry, parentToChildren, doc);
+        }
+        case CrdtType.Register: {
+            return LiveRegister._deserialize(entry, parentToChildren, doc);
+        }
+        default: {
+            throw new Error("Unexpected CRDT type");
+        }
+    }
+}
+function isCrdt(obj) {
+    return (obj instanceof LiveObject ||
+        obj instanceof LiveMap ||
+        obj instanceof LiveList ||
+        obj instanceof LiveRegister);
+}
+function selfOrRegisterValue(obj) {
+    if (obj instanceof LiveRegister) {
+        return obj.data;
+    }
+    return obj;
+}
+function selfOrRegister(obj) {
+    if (obj instanceof LiveObject ||
+        obj instanceof LiveMap ||
+        obj instanceof LiveList) {
+        return obj;
+    }
+    else if (obj instanceof LiveRegister) {
+        throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
+    }
+    else {
+        // By now, we've checked that obj isn't a Live storage instance.
+        // Technically what remains here can still be a (1) live data scalar, or
+        // a (2) list of Lson values, or (3) an object with Lson values.
+        //
+        // Of these, (1) is fine, because a live data scalar is also a legal Json
+        // scalar.
+        //
+        // But (2) and (3) are only technically fine if those only contain Json
+        // values. Technically, these can still contain nested Live storage
+        // instances, and we should probably assert that they don't at runtime.
+        //
+        // TypeScript understands this and doesn't let us use `obj` until we do :)
+        //
+        return new LiveRegister(obj);
+        //                          ^^^^^^^
+        //                          TODO: Better to assert than to force-cast here!
+    }
+}
+function getTreesDiffOperations(currentItems, newItems) {
+    const ops = [];
+    currentItems.forEach((_, id) => {
+        if (!newItems.get(id)) {
+            // Delete crdt
+            ops.push({
+                type: OpType.DeleteCrdt,
+                id: id,
+            });
+        }
+    });
+    newItems.forEach((crdt, id) => {
+        const currentCrdt = currentItems.get(id);
+        if (currentCrdt) {
+            if (crdt.type === CrdtType.Object) {
+                if (JSON.stringify(crdt.data) !==
+                    JSON.stringify(currentCrdt.data)) {
+                    ops.push({
+                        type: OpType.UpdateObject,
+                        id: id,
+                        data: crdt.data,
+                    });
+                }
+            }
+            if (crdt.parentKey !== currentCrdt.parentKey) {
+                ops.push({
+                    type: OpType.SetParentKey,
+                    id: id,
+                    parentKey: crdt.parentKey,
+                });
+            }
+        }
+        else {
+            // new Crdt
+            switch (crdt.type) {
+                case CrdtType.Register:
+                    ops.push({
+                        type: OpType.CreateRegister,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case CrdtType.List:
+                    ops.push({
+                        type: OpType.CreateList,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+                case CrdtType.Object:
+                    ops.push({
+                        type: OpType.CreateObject,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data,
+                    });
+                    break;
+                case CrdtType.Map:
+                    ops.push({
+                        type: OpType.CreateMap,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                    });
+                    break;
+            }
+        }
+    });
+    return ops;
+}
+function mergeObjectStorageUpdates(first, second) {
+    const updates = first.updates;
+    for (const [key, value] of entries(second.updates)) {
+        updates[key] = value;
+    }
+    return Object.assign(Object.assign({}, second), { updates: updates });
+}
+function mergeMapStorageUpdates(first, second) {
+    const updates = first.updates;
+    for (const [key, value] of entries(second.updates)) {
+        updates[key] = value;
+    }
+    return Object.assign(Object.assign({}, second), { updates: updates });
+}
+function mergeListStorageUpdates(first, second) {
+    const updates = first.updates;
+    return Object.assign(Object.assign({}, second), { updates: updates.concat(second.updates) });
+}
+// prettier-ignore
+function mergeStorageUpdates(first, second) {
+    if (!first) {
+        return second;
+    }
+    if (first.type === "LiveObject" && second.type === "LiveObject") {
+        return mergeObjectStorageUpdates(first, second);
+    }
+    else if (first.type === "LiveMap" && second.type === "LiveMap") {
+        return mergeMapStorageUpdates(first, second);
+    }
+    else if (first.type === "LiveList" && second.type === "LiveList") {
+        return mergeListStorageUpdates(first, second);
+    }
+    else ;
+    return second;
+}
+function isPlain(value) {
+    const type = typeof value;
+    return (type === "undefined" ||
+        value === null ||
+        type === "string" ||
+        type === "boolean" ||
+        type === "number" ||
+        Array.isArray(value) ||
+        isPlainObject(value));
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null)
+        return true;
+    let baseProto = proto;
+    while (Object.getPrototypeOf(baseProto) !== null) {
+        baseProto = Object.getPrototypeOf(baseProto);
+    }
+    return proto === baseProto;
+}
+function findNonSerializableValue(value, path = "") {
+    if (!isPlain) {
+        return {
+            path: path || "root",
+            value: value,
+        };
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    for (const [key, nestedValue] of Object.entries(value)) {
+        const nestedPath = path ? path + "." + key : key;
+        if (!isPlain(nestedValue)) {
+            return {
+                path: nestedPath,
+                value: nestedValue,
+            };
+        }
+        if (typeof nestedValue === "object") {
+            const nonSerializableNestedValue = findNonSerializableValue(nestedValue, nestedPath);
+            if (nonSerializableNestedValue) {
+                return nonSerializableNestedValue;
+            }
+        }
+    }
+    return false;
+}
+function isTokenValid(token) {
+    const tokenParts = token.split(".");
+    if (tokenParts.length !== 3) {
+        return false;
+    }
+    const data = parseJson(atob(tokenParts[1]));
+    if (data === undefined ||
+        !isJsonObject(data) ||
+        typeof data.exp !== "number") {
+        return false;
+    }
+    const now = Date.now();
+    if (now / 1000 > data.exp - 300) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Drop-in replacement for Object.entries() that retains better types.
+ */
+function entries(obj) {
+    return Object.entries(obj);
+}
+
+/**
+ * The LiveObject class is similar to a JavaScript object that is synchronized on all clients.
+ * Keys should be a string, and values should be serializable to JSON.
+ * If multiple clients update the same property simultaneously, the last modification received by the Liveblocks servers is the winner.
+ */
+class LiveObject extends AbstractCrdt {
+    constructor(object = {}) {
+        super();
+        this._propToLastUpdate = new Map();
+        for (const key in object) {
+            const value = object[key];
+            if (value instanceof AbstractCrdt) {
+                value._setParentLink(this, key);
+            }
+        }
+        this._map = new Map(Object.entries(object));
+    }
+    /**
+     * @internal
+     */
+    _serialize(parentId, parentKey, doc, intent) {
+        if (this._id == null) {
+            throw new Error("Cannot serialize item is not attached");
+        }
+        const ops = [];
+        const op = {
+            id: this._id,
+            opId: doc === null || doc === void 0 ? void 0 : doc.generateOpId(),
+            intent,
+            type: OpType.CreateObject,
+            parentId,
+            parentKey,
+            data: {},
+        };
+        ops.push(op);
+        for (const [key, value] of this._map) {
+            if (value instanceof AbstractCrdt) {
+                ops.push(...value._serialize(this._id, key, doc));
+            }
+            else {
+                op.data[key] = value;
+            }
+        }
+        return ops;
+    }
+    /**
+     * @internal
+     */
+    static _deserialize([id, item], parentToChildren, doc) {
+        if (item.type !== CrdtType.Object) {
+            throw new Error(`Tried to deserialize a record but item type is "${item.type}"`);
+        }
+        const object = new LiveObject(item.data);
+        object._attach(id, doc);
+        return this._deserializeChildren(object, parentToChildren, doc);
+    }
+    /**
+     * @internal
+     */
+    static _deserializeChildren(object, parentToChildren, doc) {
+        const children = parentToChildren.get(object._id);
+        if (children == null) {
+            return object;
+        }
+        for (const entry of children) {
+            const crdt = entry[1];
+            if (crdt.parentKey == null) {
+                throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+            }
+            const child = deserialize(entry, parentToChildren, doc);
+            child._setParentLink(object, crdt.parentKey);
+            object._map.set(crdt.parentKey, child);
+        }
+        return object;
+    }
+    /**
+     * @internal
+     */
+    _attach(id, doc) {
+        super._attach(id, doc);
+        for (const [_key, value] of this._map) {
+            if (value instanceof AbstractCrdt) {
+                value._attach(doc.generateId(), doc);
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _attachChild(op, isLocal) {
+        if (this._doc == null) {
+            throw new Error("Can't attach child if doc is not present");
+        }
+        const { id, parentKey, opId } = op;
+        const key = parentKey;
+        const child = creationOpToLiveStructure(op);
+        if (this._doc.getItem(id) !== undefined) {
+            if (this._propToLastUpdate.get(key) === opId) {
+                // Acknowlegment from local operation
+                this._propToLastUpdate.delete(key);
+            }
+            return { modified: false };
+        }
+        if (isLocal) {
+            this._propToLastUpdate.set(key, opId);
+        }
+        else if (this._propToLastUpdate.get(key) === undefined) ;
+        else if (this._propToLastUpdate.get(key) === opId) {
+            // Acknowlegment from local operation
+            this._propToLastUpdate.delete(key);
+            return { modified: false };
+        }
+        else {
+            // Conflict, ignore remote operation
+            return { modified: false };
+        }
+        const previousValue = this._map.get(key);
+        let reverse;
+        if (isCrdt(previousValue)) {
+            reverse = previousValue._serialize(this._id, key);
+            previousValue._detach();
+        }
+        else if (previousValue === undefined) {
+            reverse = [
+                { type: OpType.DeleteObjectKey, id: this._id, key: key },
+            ];
+        }
+        else {
+            reverse = [
+                {
+                    type: OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: previousValue },
+                },
+            ];
+        }
+        this._map.set(key, child);
+        child._setParentLink(this, key);
+        child._attach(id, this._doc);
+        return {
+            reverse,
+            modified: {
+                node: this,
+                type: "LiveObject",
+                updates: { [key]: { type: "update" } },
+            },
+        };
+    }
+    /**
+     * @internal
+     */
+    _detachChild(child) {
+        if (child) {
+            const reverse = child._serialize(this._id, child._parentKey, this._doc);
+            for (const [key, value] of this._map) {
+                if (value === child) {
+                    this._map.delete(key);
+                }
+            }
+            child._detach();
+            const storageUpdate = {
+                node: this,
+                type: "LiveObject",
+                updates: {
+                    [child._parentKey]: { type: "delete" },
+                },
+            };
+            return { modified: storageUpdate, reverse };
+        }
+        return { modified: false };
+    }
+    /**
+     * @internal
+     */
+    _detachChildren() {
+        for (const [key, value] of this._map) {
+            this._map.delete(key);
+            value._detach();
+        }
+    }
+    /**
+     * @internal
+     */
+    _detach() {
+        super._detach();
+        for (const value of this._map.values()) {
+            if (isCrdt(value)) {
+                value._detach();
+            }
+        }
+    }
+    /**
+     * @internal
+     */
+    _apply(op, isLocal) {
+        if (op.type === OpType.UpdateObject) {
+            return this._applyUpdate(op, isLocal);
+        }
+        else if (op.type === OpType.DeleteObjectKey) {
+            return this._applyDeleteObjectKey(op);
+        }
+        return super._apply(op, isLocal);
+    }
+    /**
+     * @internal
+     */
+    _toSerializedCrdt() {
+        var _a;
+        const data = {};
+        for (const [key, value] of this._map) {
+            if (value instanceof AbstractCrdt === false) {
+                data[key] = value;
+            }
+        }
+        return {
+            type: CrdtType.Object,
+            parentId: (_a = this._parent) === null || _a === void 0 ? void 0 : _a._id,
+            parentKey: this._parentKey,
+            data,
+        };
+    }
+    _applyUpdate(op, isLocal) {
+        let isModified = false;
+        const reverse = [];
+        const reverseUpdate = {
+            type: OpType.UpdateObject,
+            id: this._id,
+            data: {},
+        };
+        reverse.push(reverseUpdate);
+        for (const key in op.data) {
+            const oldValue = this._map.get(key);
+            if (oldValue instanceof AbstractCrdt) {
+                reverse.push(...oldValue._serialize(this._id, key));
+                oldValue._detach();
+            }
+            else if (oldValue !== undefined) {
+                reverseUpdate.data[key] = oldValue;
+            }
+            else if (oldValue === undefined) {
+                reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+            }
+        }
+        const updateDelta = {};
+        for (const key in op.data) {
+            if (isLocal) {
+                this._propToLastUpdate.set(key, op.opId);
+            }
+            else if (this._propToLastUpdate.get(key) == null) {
+                // Not modified localy so we apply update
+                isModified = true;
+            }
+            else if (this._propToLastUpdate.get(key) === op.opId) {
+                // Acknowlegment from local operation
+                this._propToLastUpdate.delete(key);
+                continue;
+            }
+            else {
+                // Conflict, ignore remote operation
+                continue;
+            }
+            const oldValue = this._map.get(key);
+            if (isCrdt(oldValue)) {
+                oldValue._detach();
+            }
+            isModified = true;
+            updateDelta[key] = { type: "update" };
+            this._map.set(key, op.data[key]);
+        }
+        if (Object.keys(reverseUpdate.data).length !== 0) {
+            reverse.unshift(reverseUpdate);
+        }
+        return isModified
+            ? {
+                modified: {
+                    node: this,
+                    type: "LiveObject",
+                    updates: updateDelta,
+                },
+                reverse,
+            }
+            : { modified: false };
+    }
+    _applyDeleteObjectKey(op) {
+        const key = op.key;
+        // If property does not exist, exit without notifying
+        if (this._map.has(key) === false) {
+            return { modified: false };
+        }
+        // If a local operation exists on the same key
+        // prevent flickering by not applying delete op.
+        if (this._propToLastUpdate.get(key) !== undefined) {
+            return { modified: false };
+        }
+        const oldValue = this._map.get(key);
+        let reverse = [];
+        if (isCrdt(oldValue)) {
+            reverse = oldValue._serialize(this._id, op.key);
+            oldValue._detach();
+        }
+        else if (oldValue !== undefined) {
+            reverse = [
+                {
+                    type: OpType.UpdateObject,
+                    id: this._id,
+                    data: { [key]: oldValue },
+                },
+            ];
+        }
+        this._map.delete(key);
+        return {
+            modified: {
+                node: this,
+                type: "LiveObject",
+                updates: { [op.key]: { type: "delete" } },
+            },
+            reverse,
+        };
+    }
+    /**
+     * Transform the LiveObject into a javascript object
+     */
+    toObject() {
+        return Object.fromEntries(this._map);
+    }
+    /**
+     * Adds or updates a property with a specified key and a value.
+     * @param key The key of the property to add
+     * @param value The value of the property to add
+     */
+    set(key, value) {
+        // TODO: Find out why typescript complains
+        this.update({ [key]: value });
+    }
+    /**
+     * Returns a specified property from the LiveObject.
+     * @param key The key of the property to get
+     */
+    get(key) {
+        return this._map.get(key);
+    }
+    /**
+     * Deletes a key from the LiveObject
+     * @param key The key of the property to delete
+     */
+    delete(key) {
+        const keyAsString = key;
+        const oldValue = this._map.get(keyAsString);
+        if (oldValue === undefined) {
+            return;
+        }
+        if (this._doc == null || this._id == null) {
+            if (oldValue instanceof AbstractCrdt) {
+                oldValue._detach();
+            }
+            this._map.delete(keyAsString);
+            return;
+        }
+        let reverse;
+        if (oldValue instanceof AbstractCrdt) {
+            oldValue._detach();
+            reverse = oldValue._serialize(this._id, keyAsString);
+        }
+        else {
+            reverse = [
+                {
+                    type: OpType.UpdateObject,
+                    data: { [keyAsString]: oldValue },
+                    id: this._id,
+                },
+            ];
+        }
+        this._map.delete(keyAsString);
+        const storageUpdates = new Map();
+        storageUpdates.set(this._id, {
+            node: this,
+            type: "LiveObject",
+            updates: { [key]: { type: "delete" } },
+        });
+        this._doc.dispatch([
+            {
+                type: OpType.DeleteObjectKey,
+                key: keyAsString,
+                id: this._id,
+                opId: this._doc.generateOpId(),
+            },
+        ], reverse, storageUpdates);
+    }
+    /**
+     * Adds or updates multiple properties at once with an object.
+     * @param overrides The object used to overrides properties
+     */
+    update(overrides) {
+        if (this._doc == null || this._id == null) {
+            for (const key in overrides) {
+                const oldValue = this._map.get(key);
+                if (oldValue instanceof AbstractCrdt) {
+                    oldValue._detach();
+                }
+                const newValue = overrides[key];
+                if (newValue instanceof AbstractCrdt) {
+                    newValue._setParentLink(this, key);
+                }
+                this._map.set(key, newValue);
+            }
+            return;
+        }
+        const ops = [];
+        const reverseOps = [];
+        const opId = this._doc.generateOpId();
+        const updatedProps = {};
+        const reverseUpdateOp = {
+            id: this._id,
+            type: OpType.UpdateObject,
+            data: {},
+        };
+        const updateDelta = {};
+        for (const key in overrides) {
+            const oldValue = this._map.get(key);
+            if (oldValue instanceof AbstractCrdt) {
+                reverseOps.push(...oldValue._serialize(this._id, key));
+                oldValue._detach();
+            }
+            else if (oldValue === undefined) {
+                reverseOps.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+            }
+            else {
+                reverseUpdateOp.data[key] = oldValue;
+            }
+            const newValue = overrides[key];
+            if (newValue instanceof AbstractCrdt) {
+                newValue._setParentLink(this, key);
+                newValue._attach(this._doc.generateId(), this._doc);
+                const newAttachChildOps = newValue._serialize(this._id, key, this._doc);
+                const createCrdtOp = newAttachChildOps.find((op) => op.parentId === this._id);
+                if (createCrdtOp) {
+                    this._propToLastUpdate.set(key, createCrdtOp.opId);
+                }
+                ops.push(...newAttachChildOps);
+            }
+            else {
+                updatedProps[key] = newValue;
+                this._propToLastUpdate.set(key, opId);
+            }
+            this._map.set(key, newValue);
+            updateDelta[key] = { type: "update" };
+        }
+        if (Object.keys(reverseUpdateOp.data).length !== 0) {
+            reverseOps.unshift(reverseUpdateOp);
+        }
+        if (Object.keys(updatedProps).length !== 0) {
+            ops.unshift({
+                opId,
+                id: this._id,
+                type: OpType.UpdateObject,
+                data: updatedProps,
+            });
+        }
+        const storageUpdates = new Map();
+        storageUpdates.set(this._id, {
+            node: this,
+            type: "LiveObject",
+            updates: updateDelta,
+        });
+        this._doc.dispatch(ops, reverseOps, storageUpdates);
+    }
+}
+
+export { AbstractCrdt as A, ClientMessageType as C, LiveObject as L, OpType as O, ServerMessageType as S, WebsocketCloseCodes as W, isSameNodeOrChildOf as a, LiveList as b, isJsonArray as c, compact as d, isJsonObject as e, LiveMap as f, getTreesDiffOperations as g, LiveRegister as h, isTokenValid as i, findNonSerializableValue as j, deprecate as k, deprecateIf as l, mergeStorageUpdates as m, CrdtType as n, min as o, parseJson as p, max as q, remove as r, makePosition as s, posCodes as t, pos as u, compare as v };