@liveblocks/client 0.17.8 → 0.17.9

package/chunk-QLMVHHAZ.js

@@ -0,0 +1,3592 @@
+"use strict";
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function _get(target, property, receiver) {
+            var base = _superPropBase(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _superPropBase(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _getPrototypeOf(object);
+        if (object === null) break;
+    }
+    return object;
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _optionalChain(ops) {
+    var lastAccessLHS = undefined;
+    var value = ops[0];
+    var i = 1;
+    while(i < ops.length){
+        var op = ops[i];
+        var fn = ops[i + 1];
+        i += 2;
+        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
+            return undefined;
+        }
+        if (op === "access" || op === "optionalAccess") {
+            lastAccessLHS = value;
+            value = fn(value);
+        } else if (op === "call" || op === "optionalCall") {
+            var _value;
+            value = fn(function() {
+                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                    args[_key] = arguments[_key];
+                }
+                return (_value = value).call.apply(_value, [
+                    lastAccessLHS
+                ].concat(_toConsumableArray(args)));
+            });
+            lastAccessLHS = undefined;
+        }
+    }
+    return value;
+} // src/deprecation.ts
+var _emittedDeprecationWarnings = /* @__PURE__ */ new Set();
+function deprecate(message) {
+    var key = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : message;
+    if (process.env.NODE_ENV !== "production") {
+        if (!_emittedDeprecationWarnings.has(key)) {
+            _emittedDeprecationWarnings.add(key);
+            console.error("DEPRECATION WARNING: ".concat(message));
+        }
+    }
+}
+function deprecateIf(condition, message) {
+    var key = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : message;
+    if (process.env.NODE_ENV !== "production") {
+        if (condition) {
+            deprecate(message, key);
+        }
+    }
+}
+function throwUsageError(message) {
+    if (process.env.NODE_ENV !== "production") {
+        var usageError = new Error(message);
+        usageError.name = "Usage error";
+        throw usageError;
+    }
+}
+function errorIf(condition, message) {
+    if (process.env.NODE_ENV !== "production") {
+        if (condition) {
+            throwUsageError(message);
+        }
+    }
+}
+// src/assert.ts
+function assertNever(_value, errmsg) {
+    throw new Error(errmsg);
+}
+function assert(condition, errmsg) {
+    if (process.env.NODE_ENV !== "production" && !condition) {
+        var err = new Error(errmsg);
+        err.name = "Assertion failure";
+        throw err;
+    }
+}
+function nn(value) {
+    var errmsg = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "Expected value to be non-nullable";
+    assert(value != null, errmsg);
+    return value;
+}
+// src/types/ClientMsg.ts
+var ClientMsgCode = /* @__PURE__ */ function(ClientMsgCode2) {
+    ClientMsgCode2[ClientMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
+    ClientMsgCode2[ClientMsgCode2["BROADCAST_EVENT"] = 103] = "BROADCAST_EVENT";
+    ClientMsgCode2[ClientMsgCode2["FETCH_STORAGE"] = 200] = "FETCH_STORAGE";
+    ClientMsgCode2[ClientMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
+    return ClientMsgCode2;
+}(ClientMsgCode || {});
+// src/types/Op.ts
+var OpCode = /* @__PURE__ */ function(OpCode2) {
+    OpCode2[OpCode2["INIT"] = 0] = "INIT";
+    OpCode2[OpCode2["SET_PARENT_KEY"] = 1] = "SET_PARENT_KEY";
+    OpCode2[OpCode2["CREATE_LIST"] = 2] = "CREATE_LIST";
+    OpCode2[OpCode2["UPDATE_OBJECT"] = 3] = "UPDATE_OBJECT";
+    OpCode2[OpCode2["CREATE_OBJECT"] = 4] = "CREATE_OBJECT";
+    OpCode2[OpCode2["DELETE_CRDT"] = 5] = "DELETE_CRDT";
+    OpCode2[OpCode2["DELETE_OBJECT_KEY"] = 6] = "DELETE_OBJECT_KEY";
+    OpCode2[OpCode2["CREATE_MAP"] = 7] = "CREATE_MAP";
+    OpCode2[OpCode2["CREATE_REGISTER"] = 8] = "CREATE_REGISTER";
+    return OpCode2;
+}(OpCode || {});
+// src/types/SerializedCrdt.ts
+var CrdtType = /* @__PURE__ */ function(CrdtType2) {
+    CrdtType2[CrdtType2["OBJECT"] = 0] = "OBJECT";
+    CrdtType2[CrdtType2["LIST"] = 1] = "LIST";
+    CrdtType2[CrdtType2["MAP"] = 2] = "MAP";
+    CrdtType2[CrdtType2["REGISTER"] = 3] = "REGISTER";
+    return CrdtType2;
+}(CrdtType || {});
+function isRootCrdt(crdt) {
+    return crdt.type === 0 /* OBJECT */  && !isChildCrdt(crdt);
+}
+function isChildCrdt(crdt) {
+    return crdt.parentId !== void 0 && crdt.parentKey !== void 0;
+}
+// src/types/ServerMsg.ts
+var ServerMsgCode = /* @__PURE__ */ function(ServerMsgCode2) {
+    ServerMsgCode2[ServerMsgCode2["UPDATE_PRESENCE"] = 100] = "UPDATE_PRESENCE";
+    ServerMsgCode2[ServerMsgCode2["USER_JOINED"] = 101] = "USER_JOINED";
+    ServerMsgCode2[ServerMsgCode2["USER_LEFT"] = 102] = "USER_LEFT";
+    ServerMsgCode2[ServerMsgCode2["BROADCASTED_EVENT"] = 103] = "BROADCASTED_EVENT";
+    ServerMsgCode2[ServerMsgCode2["ROOM_STATE"] = 104] = "ROOM_STATE";
+    ServerMsgCode2[ServerMsgCode2["INITIAL_STORAGE_STATE"] = 200] = "INITIAL_STORAGE_STATE";
+    ServerMsgCode2[ServerMsgCode2["UPDATE_STORAGE"] = 201] = "UPDATE_STORAGE";
+    return ServerMsgCode2;
+}(ServerMsgCode || {});
+// src/types/index.ts
+function isRoomEventName(value) {
+    return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection" || value === "history";
+}
+var WebsocketCloseCodes = /* @__PURE__ */ function(WebsocketCloseCodes2) {
+    WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+    WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+    return WebsocketCloseCodes2;
+}(WebsocketCloseCodes || {});
+// src/position.ts
+var min = 32;
+var max = 126;
+function makePosition(before, after) {
+    if (before != null && after != null) {
+        return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+    } else if (before != null) {
+        return getNextPosition(before);
+    } else if (after != null) {
+        return getPreviousPosition(after);
+    }
+    return pos([
+        min + 1
+    ]);
+}
+function getPreviousPosition(after) {
+    var result = [];
+    var afterCodes = posCodes(after);
+    for(var i = 0; i < afterCodes.length; i++){
+        var 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) {
+    var result = [];
+    var beforeCodes = posCodes(before);
+    for(var i = 0; i < beforeCodes.length; i++){
+        var 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) {
+    var index = 0;
+    var result = [];
+    while(true){
+        var beforeDigit = before[index] || min;
+        var afterDigit = after[index] || max;
+        if (beforeDigit > afterDigit) {
+            throw new Error("Impossible to generate position between ".concat(before, " and ").concat(after));
+        }
+        if (beforeDigit === afterDigit) {
+            result.push(beforeDigit);
+            index++;
+            continue;
+        }
+        if (afterDigit - beforeDigit === 1) {
+            var _result;
+            result.push(beforeDigit);
+            (_result = result).push.apply(_result, _toConsumableArray(makePositionFromCodes(before.slice(index + 1), [])));
+            break;
+        }
+        var mid = afterDigit + beforeDigit >> 1;
+        result.push(mid);
+        break;
+    }
+    return result;
+}
+function posCodes(str) {
+    var codes = [];
+    for(var i = 0; i < str.length; i++){
+        codes.push(str.charCodeAt(i));
+    }
+    return codes;
+}
+function pos(codes) {
+    var _String;
+    return (_String = String).fromCharCode.apply(_String, _toConsumableArray(codes));
+}
+function comparePosition(posA, posB) {
+    var aCodes = posCodes(posA);
+    var bCodes = posCodes(posB);
+    var maxLength = Math.max(aCodes.length, bCodes.length);
+    for(var i = 0; i < maxLength; i++){
+        var a = aCodes[i] == null ? min : aCodes[i];
+        var b = bCodes[i] == null ? min : bCodes[i];
+        if (a === b) {
+            continue;
+        } else {
+            return a - b;
+        }
+    }
+    throw new Error('Impossible to compare similar position "'.concat(posA, '" and "').concat(posB, '"'));
+}
+// src/AbstractCrdt.ts
+function crdtAsLiveNode(value) {
+    return value;
+}
+function HasParent(node, key) {
+    return Object.freeze({
+        type: "HasParent",
+        node: node,
+        key: key
+    });
+}
+var NoParent = Object.freeze({
+    type: "NoParent"
+});
+function Orphaned(oldKey) {
+    return Object.freeze({
+        type: "Orphaned",
+        oldKey: oldKey
+    });
+}
+var AbstractCrdt = /*#__PURE__*/ function() {
+    function AbstractCrdt() {
+        _classCallCheck(this, AbstractCrdt);
+        this._parent = NoParent;
+    }
+    _createClass(AbstractCrdt, [
+        {
+            key: "_getParentKeyOrThrow",
+            value: function _getParentKeyOrThrow() {
+                switch(this.parent.type){
+                    case "HasParent":
+                        return this.parent.key;
+                    case "NoParent":
+                        throw new Error("Parent key is missing");
+                    case "Orphaned":
+                        return this.parent.oldKey;
+                    default:
+                        return assertNever(this.parent, "Unknown state");
+                }
+            }
+        },
+        {
+            key: "_doc",
+            get: function get() {
+                return this.__doc;
+            }
+        },
+        {
+            key: "roomId",
+            get: function get() {
+                return this.__doc ? this.__doc.roomId : null;
+            }
+        },
+        {
+            key: "_id",
+            get: function get() {
+                return this.__id;
+            }
+        },
+        {
+            key: "parent",
+            get: function get() {
+                return this._parent;
+            }
+        },
+        {
+            key: "_parentNode",
+            get: function get() {
+                switch(this.parent.type){
+                    case "HasParent":
+                        return this.parent.node;
+                    case "NoParent":
+                        return null;
+                    case "Orphaned":
+                        return null;
+                    default:
+                        return assertNever(this.parent, "Unknown state");
+                }
+            }
+        },
+        {
+            key: "_parentKey",
+            get: function get() {
+                switch(this.parent.type){
+                    case "HasParent":
+                        return this.parent.key;
+                    case "NoParent":
+                        return null;
+                    case "Orphaned":
+                        return this.parent.oldKey;
+                    default:
+                        return assertNever(this.parent, "Unknown state");
+                }
+            }
+        },
+        {
+            key: "_apply",
+            value: function _apply(op, _isLocal) {
+                switch(op.type){
+                    case 5 /* DELETE_CRDT */ :
+                        {
+                            if (this.parent.type === "HasParent") {
+                                return this.parent.node._detachChild(crdtAsLiveNode(this));
+                            }
+                            return {
+                                modified: false
+                            };
+                        }
+                }
+                return {
+                    modified: false
+                };
+            }
+        },
+        {
+            key: "_setParentLink",
+            value: function _setParentLink(newParentNode, newParentKey) {
+                switch(this.parent.type){
+                    case "HasParent":
+                        if (this.parent.node !== newParentNode) {
+                            throw new Error("Cannot attach parent if it already exist");
+                        } else {
+                            this._parent = HasParent(newParentNode, newParentKey);
+                            return;
+                        }
+                    case "Orphaned":
+                    case "NoParent":
+                        {
+                            this._parent = HasParent(newParentNode, newParentKey);
+                            return;
+                        }
+                    default:
+                        return assertNever(this.parent, "Unknown state");
+                }
+            }
+        },
+        {
+            key: "_attach",
+            value: function _attach(id, doc) {
+                if (this.__id || this.__doc) {
+                    throw new Error("Cannot attach if CRDT is already attached");
+                }
+                doc.addItem(id, crdtAsLiveNode(this));
+                this.__id = id;
+                this.__doc = doc;
+            }
+        },
+        {
+            key: "_detach",
+            value: function _detach() {
+                if (this.__doc && this.__id) {
+                    this.__doc.deleteItem(this.__id);
+                }
+                switch(this.parent.type){
+                    case "HasParent":
+                        {
+                            this._parent = Orphaned(this.parent.key);
+                            break;
+                        }
+                    case "NoParent":
+                        {
+                            this._parent = NoParent;
+                            break;
+                        }
+                    case "Orphaned":
+                        {
+                            this._parent = Orphaned(this.parent.oldKey);
+                            break;
+                        }
+                    default:
+                        assertNever(this.parent, "Unknown state");
+                }
+                this.__doc = void 0;
+            }
+        }
+    ]);
+    return AbstractCrdt;
+}();
+// src/LiveRegister.ts
+var LiveRegister = /*#__PURE__*/ function(AbstractCrdt) {
+    _inherits(LiveRegister, AbstractCrdt);
+    var _super = _createSuper(LiveRegister);
+    function LiveRegister(data) {
+        _classCallCheck(this, LiveRegister);
+        var _this;
+        _this = _super.call(this);
+        _this._data = data;
+        return _this;
+    }
+    _createClass(LiveRegister, [
+        {
+            key: "data",
+            get: function get() {
+                return this._data;
+            }
+        },
+        {
+            key: "_serialize",
+            value: function _serialize(parentId, parentKey, doc) {
+                if (this._id == null || parentId == null || parentKey == null) {
+                    throw new Error("Cannot serialize register if parentId or parentKey is undefined");
+                }
+                return [
+                    {
+                        type: 8 /* CREATE_REGISTER */ ,
+                        opId: _optionalChain([
+                            doc,
+                            "optionalAccess",
+                            function(_2) {
+                                return _2.generateOpId;
+                            },
+                            "call",
+                            function(_3) {
+                                return _3();
+                            }
+                        ]),
+                        id: this._id,
+                        parentId: parentId,
+                        parentKey: parentKey,
+                        data: this.data
+                    }
+                ];
+            }
+        },
+        {
+            key: "_toSerializedCrdt",
+            value: function _toSerializedCrdt() {
+                if (this.parent.type !== "HasParent") {
+                    throw new Error("Cannot serialize LiveRegister if parent is missing");
+                }
+                return {
+                    type: 3 /* REGISTER */ ,
+                    parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+                    parentKey: this.parent.key,
+                    data: this.data
+                };
+            }
+        },
+        {
+            key: "_attachChild",
+            value: function _attachChild(_op) {
+                throw new Error("Method not implemented.");
+            }
+        },
+        {
+            key: "_detachChild",
+            value: function _detachChild(_crdt) {
+                throw new Error("Method not implemented.");
+            }
+        },
+        {
+            key: "_apply",
+            value: function _apply(op, isLocal) {
+                return _get(_getPrototypeOf(LiveRegister.prototype), "_apply", this).call(this, op, isLocal);
+            }
+        }
+    ], [
+        {
+            key: "_deserialize",
+            value: function _deserialize(param, _parentToChildren, doc) {
+                var _param = _slicedToArray(param, 2), id = _param[0], item = _param[1];
+                var register = new LiveRegister(item.data);
+                register._attach(id, doc);
+                return register;
+            }
+        }
+    ]);
+    return LiveRegister;
+}(AbstractCrdt);
+// src/LiveMap.ts
+var LiveMap = /*#__PURE__*/ function(AbstractCrdt) {
+    _inherits(LiveMap, AbstractCrdt);
+    var _super = _createSuper(LiveMap);
+    function LiveMap(entries2) {
+        _classCallCheck(this, LiveMap);
+        var _this;
+        _this = _super.call(this);
+        errorIf(entries2 === null, "Support for calling `new LiveMap(null)` will be removed in @liveblocks/client 0.18. Please call as `new LiveMap()`, or `new LiveMap([])`.");
+        _this.unacknowledgedSet = /* @__PURE__ */ new Map();
+        if (entries2) {
+            var mappedEntries = [];
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = entries2[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var entry = _step.value;
+                    var value = lsonToLiveNode(entry[1]);
+                    value._setParentLink(_assertThisInitialized(_this), entry[0]);
+                    mappedEntries.push([
+                        entry[0],
+                        value
+                    ]);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            _this._map = new Map(mappedEntries);
+        } else {
+            _this._map = /* @__PURE__ */ new Map();
+        }
+        return _this;
+    }
+    _createClass(LiveMap, [
+        {
+            key: "_serialize",
+            value: function _serialize(parentId, parentKey, doc) {
+                if (this._id == null) {
+                    throw new Error("Cannot serialize item is not attached");
+                }
+                var ops = [];
+                var op = {
+                    id: this._id,
+                    opId: _optionalChain([
+                        doc,
+                        "optionalAccess",
+                        function(_4) {
+                            return _4.generateOpId;
+                        },
+                        "call",
+                        function(_5) {
+                            return _5();
+                        }
+                    ]),
+                    type: 7 /* CREATE_MAP */ ,
+                    parentId: parentId,
+                    parentKey: parentKey
+                };
+                ops.push(op);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                        var _ops;
+                        (_ops = ops).push.apply(_ops, _toConsumableArray(value._serialize(this._id, key, doc)));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return ops;
+            }
+        },
+        {
+            key: "_attach",
+            value: function _attach(id, doc) {
+                _get(_getPrototypeOf(LiveMap.prototype), "_attach", this).call(this, id, doc);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), _key = _value[0], value = _value[1];
+                        if (isLiveNode(value)) {
+                            value._attach(doc.generateId(), doc);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_attachChild",
+            value: function _attachChild(op, source) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                var id = op.id, parentKey = op.parentKey, opId = op.opId;
+                var key = parentKey;
+                var child = creationOpToLiveNode(op);
+                if (this._doc.getItem(id) !== void 0) {
+                    return {
+                        modified: false
+                    };
+                }
+                if (source === 2 /* ACK */ ) {
+                    var lastUpdateOpId = this.unacknowledgedSet.get(key);
+                    if (lastUpdateOpId === opId) {
+                        this.unacknowledgedSet.delete(key);
+                        return {
+                            modified: false
+                        };
+                    } else if (lastUpdateOpId != null) {
+                        return {
+                            modified: false
+                        };
+                    }
+                } else if (source === 1 /* REMOTE */ ) {
+                    this.unacknowledgedSet.delete(key);
+                }
+                var previousValue = this._map.get(key);
+                var reverse;
+                if (previousValue) {
+                    var thisId = nn(this._id);
+                    reverse = previousValue._serialize(thisId, key);
+                    previousValue._detach();
+                } else {
+                    reverse = [
+                        {
+                            type: 5 /* DELETE_CRDT */ ,
+                            id: id
+                        }
+                    ];
+                }
+                child._setParentLink(this, key);
+                child._attach(id, this._doc);
+                this._map.set(key, child);
+                return {
+                    modified: {
+                        node: this,
+                        type: "LiveMap",
+                        updates: _defineProperty({}, key, {
+                            type: "update"
+                        })
+                    },
+                    reverse: reverse
+                };
+            }
+        },
+        {
+            key: "_detach",
+            value: function _detach() {
+                _get(_getPrototypeOf(LiveMap.prototype), "_detach", this).call(this);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var item = _step.value;
+                        item._detach();
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_detachChild",
+            value: function _detachChild(child) {
+                var id = nn(this._id);
+                var parentKey = nn(child._parentKey);
+                var reverse = child._serialize(id, parentKey, this._doc);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                        if (value === child) {
+                            this._map.delete(key);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                child._detach();
+                var storageUpdate = {
+                    node: this,
+                    type: "LiveMap",
+                    updates: _defineProperty({}, parentKey, {
+                        type: "delete"
+                    })
+                };
+                return {
+                    modified: storageUpdate,
+                    reverse: reverse
+                };
+            }
+        },
+        {
+            key: "_toSerializedCrdt",
+            value: function _toSerializedCrdt() {
+                if (this.parent.type !== "HasParent") {
+                    throw new Error("Cannot serialize LiveMap if parent is missing");
+                }
+                return {
+                    type: 2 /* MAP */ ,
+                    parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+                    parentKey: this.parent.key
+                };
+            }
+        },
+        {
+            key: "get",
+            value: function get(key) {
+                var value = this._map.get(key);
+                if (value == void 0) {
+                    return void 0;
+                }
+                return liveNodeToLson(value);
+            }
+        },
+        {
+            key: "set",
+            value: function set(key, value) {
+                var oldValue = this._map.get(key);
+                if (oldValue) {
+                    oldValue._detach();
+                }
+                var item = lsonToLiveNode(value);
+                item._setParentLink(this, key);
+                this._map.set(key, item);
+                if (this._doc && this._id) {
+                    var id = this._doc.generateId();
+                    item._attach(id, this._doc);
+                    var storageUpdates = /* @__PURE__ */ new Map();
+                    storageUpdates.set(this._id, {
+                        node: this,
+                        type: "LiveMap",
+                        updates: _defineProperty({}, key, {
+                            type: "update"
+                        })
+                    });
+                    var ops = item._serialize(this._id, key, this._doc);
+                    this.unacknowledgedSet.set(key, nn(ops[0].opId));
+                    this._doc.dispatch(item._serialize(this._id, key, this._doc), oldValue ? oldValue._serialize(this._id, key) : [
+                        {
+                            type: 5 /* DELETE_CRDT */ ,
+                            id: id
+                        }
+                    ], storageUpdates);
+                }
+            }
+        },
+        {
+            key: "size",
+            get: function get() {
+                return this._map.size;
+            }
+        },
+        {
+            key: "has",
+            value: function has(key) {
+                return this._map.has(key);
+            }
+        },
+        {
+            key: "delete",
+            value: function _delete(key) {
+                var item = this._map.get(key);
+                if (item == null) {
+                    return false;
+                }
+                item._detach();
+                this._map.delete(key);
+                if (this._doc && item._id) {
+                    var thisId = nn(this._id);
+                    var storageUpdates = /* @__PURE__ */ new Map();
+                    storageUpdates.set(thisId, {
+                        node: this,
+                        type: "LiveMap",
+                        updates: _defineProperty({}, key, {
+                            type: "delete"
+                        })
+                    });
+                    this._doc.dispatch([
+                        {
+                            type: 5 /* DELETE_CRDT */ ,
+                            id: item._id,
+                            opId: this._doc.generateOpId()
+                        }
+                    ], item._serialize(thisId, key), storageUpdates);
+                }
+                return true;
+            }
+        },
+        {
+            key: "entries",
+            value: function entries() {
+                var innerIterator = this._map.entries();
+                var _obj;
+                return _obj = {}, _defineProperty(_obj, Symbol.iterator, function() {
+                    return this;
+                }), _defineProperty(_obj, "next", function next() {
+                    var iteratorValue = innerIterator.next();
+                    if (iteratorValue.done) {
+                        return {
+                            done: true,
+                            value: void 0
+                        };
+                    }
+                    var entry = iteratorValue.value;
+                    var key = entry[0];
+                    var value = liveNodeToLson(iteratorValue.value[1]);
+                    return {
+                        value: [
+                            key,
+                            value
+                        ]
+                    };
+                }), _obj;
+            }
+        },
+        {
+            key: Symbol.iterator,
+            value: function value() {
+                return this.entries();
+            }
+        },
+        {
+            key: "keys",
+            value: function keys() {
+                return this._map.keys();
+            }
+        },
+        {
+            key: "values",
+            value: function values() {
+                var innerIterator = this._map.values();
+                var _obj;
+                return _obj = {}, _defineProperty(_obj, Symbol.iterator, function() {
+                    return this;
+                }), _defineProperty(_obj, "next", function next() {
+                    var iteratorValue = innerIterator.next();
+                    if (iteratorValue.done) {
+                        return {
+                            done: true,
+                            value: void 0
+                        };
+                    }
+                    var value = liveNodeToLson(iteratorValue.value);
+                    return {
+                        value: value
+                    };
+                }), _obj;
+            }
+        },
+        {
+            key: "forEach",
+            value: function forEach(callback) {
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var entry = _step.value;
+                        callback(entry[1], entry[0], this);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        }
+    ], [
+        {
+            key: "_deserialize",
+            value: function _deserialize(param, parentToChildren, doc) {
+                var _param = _slicedToArray(param, 2), id = _param[0], _item = _param[1];
+                var map = new LiveMap();
+                map._attach(id, doc);
+                var children = parentToChildren.get(id);
+                if (children == null) {
+                    return map;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), id2 = _value[0], crdt = _value[1];
+                        var child = deserialize([
+                            id2,
+                            crdt
+                        ], parentToChildren, doc);
+                        child._setParentLink(map, crdt.parentKey);
+                        map._map.set(crdt.parentKey, child);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return map;
+            }
+        }
+    ]);
+    return LiveMap;
+}(AbstractCrdt);
+// src/LiveObject.ts
+var LiveObject = /*#__PURE__*/ function(AbstractCrdt) {
+    _inherits(LiveObject, AbstractCrdt);
+    var _super = _createSuper(LiveObject);
+    function LiveObject() {
+        var obj = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        _classCallCheck(this, LiveObject);
+        var _this;
+        _this = _super.call(this);
+        _this._propToLastUpdate = /* @__PURE__ */ new Map();
+        for(var key in obj){
+            var value = obj[key];
+            if (value === void 0) {
+                continue;
+            } else if (isLiveNode(value)) {
+                value._setParentLink(_assertThisInitialized(_this), key);
+            }
+        }
+        _this._map = new Map(Object.entries(obj));
+        return _this;
+    }
+    _createClass(LiveObject, [
+        {
+            key: "_serialize",
+            value: function _serialize(parentId, parentKey, doc) {
+                if (this._id == null) {
+                    throw new Error("Cannot serialize item is not attached");
+                }
+                var opId = _optionalChain([
+                    doc,
+                    "optionalAccess",
+                    function(_6) {
+                        return _6.generateOpId;
+                    },
+                    "call",
+                    function(_7) {
+                        return _7();
+                    }
+                ]);
+                var ops = [];
+                var op = parentId !== void 0 && parentKey !== void 0 ? {
+                    type: 4 /* CREATE_OBJECT */ ,
+                    id: this._id,
+                    opId: opId,
+                    parentId: parentId,
+                    parentKey: parentKey,
+                    data: {}
+                } : {
+                    type: 4 /* CREATE_OBJECT */ ,
+                    id: this._id,
+                    opId: opId,
+                    data: {}
+                };
+                ops.push(op);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                        if (isLiveNode(value)) {
+                            var _ops;
+                            (_ops = ops).push.apply(_ops, _toConsumableArray(value._serialize(this._id, key, doc)));
+                        } else {
+                            op.data[key] = value;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return ops;
+            }
+        },
+        {
+            key: "_attach",
+            value: function _attach(id, doc) {
+                _get(_getPrototypeOf(LiveObject.prototype), "_attach", this).call(this, id, doc);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), _key = _value[0], value = _value[1];
+                        if (isLiveNode(value)) {
+                            value._attach(doc.generateId(), doc);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_attachChild",
+            value: function _attachChild(op, source) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                var id = op.id, opId = op.opId, key = op.parentKey;
+                var child = creationOpToLson(op);
+                if (this._doc.getItem(id) !== void 0) {
+                    if (this._propToLastUpdate.get(key) === opId) {
+                        this._propToLastUpdate.delete(key);
+                    }
+                    return {
+                        modified: false
+                    };
+                }
+                if (source === 0 /* UNDOREDO_RECONNECT */ ) {
+                    this._propToLastUpdate.set(key, nn(opId));
+                } else if (this._propToLastUpdate.get(key) === void 0) {} else if (this._propToLastUpdate.get(key) === opId) {
+                    this._propToLastUpdate.delete(key);
+                    return {
+                        modified: false
+                    };
+                } else {
+                    return {
+                        modified: false
+                    };
+                }
+                var thisId = nn(this._id);
+                var previousValue = this._map.get(key);
+                var reverse;
+                if (isLiveNode(previousValue)) {
+                    reverse = previousValue._serialize(thisId, key);
+                    previousValue._detach();
+                } else if (previousValue === void 0) {
+                    reverse = [
+                        {
+                            type: 6 /* DELETE_OBJECT_KEY */ ,
+                            id: thisId,
+                            key: key
+                        }
+                    ];
+                } else {
+                    reverse = [
+                        {
+                            type: 3 /* UPDATE_OBJECT */ ,
+                            id: thisId,
+                            data: _defineProperty({}, key, previousValue)
+                        }
+                    ];
+                }
+                this._map.set(key, child);
+                if (isLiveStructure(child)) {
+                    child._setParentLink(this, key);
+                    child._attach(id, this._doc);
+                }
+                return {
+                    reverse: reverse,
+                    modified: {
+                        node: this,
+                        type: "LiveObject",
+                        updates: _defineProperty({}, key, {
+                            type: "update"
+                        })
+                    }
+                };
+            }
+        },
+        {
+            key: "_detachChild",
+            value: function _detachChild(child) {
+                if (child) {
+                    var id = nn(this._id);
+                    var parentKey = nn(child._parentKey);
+                    var reverse = child._serialize(id, parentKey, this._doc);
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                            if (value === child) {
+                                this._map.delete(key);
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    child._detach();
+                    var storageUpdate = {
+                        node: this,
+                        type: "LiveObject",
+                        updates: _defineProperty({}, parentKey, {
+                            type: "delete"
+                        })
+                    };
+                    return {
+                        modified: storageUpdate,
+                        reverse: reverse
+                    };
+                }
+                return {
+                    modified: false
+                };
+            }
+        },
+        {
+            key: "_detach",
+            value: function _detach() {
+                _get(_getPrototypeOf(LiveObject.prototype), "_detach", this).call(this);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map.values()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var value = _step.value;
+                        if (isLiveNode(value)) {
+                            value._detach();
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_apply",
+            value: function _apply(op, isLocal) {
+                if (op.type === 3 /* UPDATE_OBJECT */ ) {
+                    return this._applyUpdate(op, isLocal);
+                } else if (op.type === 6 /* DELETE_OBJECT_KEY */ ) {
+                    return this._applyDeleteObjectKey(op);
+                }
+                return _get(_getPrototypeOf(LiveObject.prototype), "_apply", this).call(this, op, isLocal);
+            }
+        },
+        {
+            key: "_toSerializedCrdt",
+            value: function _toSerializedCrdt() {
+                var data = {};
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._map[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+                        if (!isLiveNode(value)) {
+                            data[key] = value;
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                if (this.parent.type === "HasParent" && this.parent.node._id) {
+                    return {
+                        type: 0 /* OBJECT */ ,
+                        parentId: this.parent.node._id,
+                        parentKey: this.parent.key,
+                        data: data
+                    };
+                } else {
+                    return {
+                        type: 0 /* OBJECT */ ,
+                        data: data
+                    };
+                }
+            }
+        },
+        {
+            key: "_applyUpdate",
+            value: function _applyUpdate(op, isLocal) {
+                var isModified = false;
+                var id = nn(this._id);
+                var reverse = [];
+                var reverseUpdate = {
+                    type: 3 /* UPDATE_OBJECT */ ,
+                    id: id,
+                    data: {}
+                };
+                reverse.push(reverseUpdate);
+                for(var key in op.data){
+                    var oldValue = this._map.get(key);
+                    if (isLiveNode(oldValue)) {
+                        var _reverse;
+                        (_reverse = reverse).push.apply(_reverse, _toConsumableArray(oldValue._serialize(id, key)));
+                        oldValue._detach();
+                    } else if (oldValue !== void 0) {
+                        reverseUpdate.data[key] = oldValue;
+                    } else if (oldValue === void 0) {
+                        reverse.push({
+                            type: 6 /* DELETE_OBJECT_KEY */ ,
+                            id: id,
+                            key: key
+                        });
+                    }
+                }
+                var updateDelta = {};
+                for(var key1 in op.data){
+                    var value = op.data[key1];
+                    if (value === void 0) {
+                        continue;
+                    }
+                    if (isLocal) {
+                        this._propToLastUpdate.set(key1, nn(op.opId));
+                    } else if (this._propToLastUpdate.get(key1) == null) {
+                        isModified = true;
+                    } else if (this._propToLastUpdate.get(key1) === op.opId) {
+                        this._propToLastUpdate.delete(key1);
+                        continue;
+                    } else {
+                        continue;
+                    }
+                    var oldValue1 = this._map.get(key1);
+                    if (isLiveNode(oldValue1)) {
+                        oldValue1._detach();
+                    }
+                    isModified = true;
+                    updateDelta[key1] = {
+                        type: "update"
+                    };
+                    this._map.set(key1, value);
+                }
+                if (Object.keys(reverseUpdate.data).length !== 0) {
+                    reverse.unshift(reverseUpdate);
+                }
+                return isModified ? {
+                    modified: {
+                        node: this,
+                        type: "LiveObject",
+                        updates: updateDelta
+                    },
+                    reverse: reverse
+                } : {
+                    modified: false
+                };
+            }
+        },
+        {
+            key: "_applyDeleteObjectKey",
+            value: function _applyDeleteObjectKey(op) {
+                var key = op.key;
+                if (this._map.has(key) === false) {
+                    return {
+                        modified: false
+                    };
+                }
+                if (this._propToLastUpdate.get(key) !== void 0) {
+                    return {
+                        modified: false
+                    };
+                }
+                var oldValue = this._map.get(key);
+                var id = nn(this._id);
+                var reverse = [];
+                if (isLiveNode(oldValue)) {
+                    reverse = oldValue._serialize(id, op.key);
+                    oldValue._detach();
+                } else if (oldValue !== void 0) {
+                    reverse = [
+                        {
+                            type: 3 /* UPDATE_OBJECT */ ,
+                            id: id,
+                            data: _defineProperty({}, key, oldValue)
+                        }
+                    ];
+                }
+                this._map.delete(key);
+                return {
+                    modified: {
+                        node: this,
+                        type: "LiveObject",
+                        updates: _defineProperty({}, op.key, {
+                            type: "delete"
+                        })
+                    },
+                    reverse: reverse
+                };
+            }
+        },
+        {
+            key: "toObject",
+            value: function toObject() {
+                return fromEntries(this._map);
+            }
+        },
+        {
+            key: "set",
+            value: function set(key, value) {
+                this.update(_defineProperty({}, key, value));
+            }
+        },
+        {
+            key: "get",
+            value: function get(key) {
+                return this._map.get(key);
+            }
+        },
+        {
+            key: "delete",
+            value: function _delete(key) {
+                var keyAsString = key;
+                var oldValue = this._map.get(keyAsString);
+                if (oldValue === void 0) {
+                    return;
+                }
+                if (this._doc == null || this._id == null) {
+                    if (isLiveNode(oldValue)) {
+                        oldValue._detach();
+                    }
+                    this._map.delete(keyAsString);
+                    return;
+                }
+                var reverse;
+                if (isLiveNode(oldValue)) {
+                    oldValue._detach();
+                    reverse = oldValue._serialize(this._id, keyAsString);
+                } else {
+                    reverse = [
+                        {
+                            type: 3 /* UPDATE_OBJECT */ ,
+                            data: _defineProperty({}, keyAsString, oldValue),
+                            id: this._id
+                        }
+                    ];
+                }
+                this._map.delete(keyAsString);
+                var storageUpdates = /* @__PURE__ */ new Map();
+                storageUpdates.set(this._id, {
+                    node: this,
+                    type: "LiveObject",
+                    updates: _defineProperty({}, key, {
+                        type: "delete"
+                    })
+                });
+                this._doc.dispatch([
+                    {
+                        type: 6 /* DELETE_OBJECT_KEY */ ,
+                        key: keyAsString,
+                        id: this._id,
+                        opId: this._doc.generateOpId()
+                    }
+                ], reverse, storageUpdates);
+            }
+        },
+        {
+            key: "update",
+            value: function update(overrides) {
+                var _this = this;
+                if (this._doc == null || this._id == null) {
+                    for(var key in overrides){
+                        var newValue = overrides[key];
+                        if (newValue === void 0) {
+                            continue;
+                        }
+                        var oldValue = this._map.get(key);
+                        if (isLiveNode(oldValue)) {
+                            oldValue._detach();
+                        }
+                        if (isLiveNode(newValue)) {
+                            newValue._setParentLink(this, key);
+                        }
+                        this._map.set(key, newValue);
+                    }
+                    return;
+                }
+                var ops = [];
+                var reverseOps = [];
+                var opId = this._doc.generateOpId();
+                var updatedProps = {};
+                var reverseUpdateOp = {
+                    id: this._id,
+                    type: 3 /* UPDATE_OBJECT */ ,
+                    data: {}
+                };
+                var updateDelta = {};
+                for(var key1 in overrides){
+                    var newValue1 = overrides[key1];
+                    if (newValue1 === void 0) {
+                        continue;
+                    }
+                    var oldValue1 = this._map.get(key1);
+                    if (isLiveNode(oldValue1)) {
+                        var _reverseOps;
+                        (_reverseOps = reverseOps).push.apply(_reverseOps, _toConsumableArray(oldValue1._serialize(this._id, key1)));
+                        oldValue1._detach();
+                    } else if (oldValue1 === void 0) {
+                        reverseOps.push({
+                            type: 6 /* DELETE_OBJECT_KEY */ ,
+                            id: this._id,
+                            key: key1
+                        });
+                    } else {
+                        reverseUpdateOp.data[key1] = oldValue1;
+                    }
+                    if (isLiveNode(newValue1)) {
+                        var _ops;
+                        newValue1._setParentLink(this, key1);
+                        newValue1._attach(this._doc.generateId(), this._doc);
+                        var newAttachChildOps = newValue1._serialize(this._id, key1, this._doc);
+                        var createCrdtOp = newAttachChildOps.find(function(op) {
+                            return op.parentId === _this._id;
+                        });
+                        if (createCrdtOp) {
+                            this._propToLastUpdate.set(key1, nn(createCrdtOp.opId));
+                        }
+                        (_ops = ops).push.apply(_ops, _toConsumableArray(newAttachChildOps));
+                    } else {
+                        updatedProps[key1] = newValue1;
+                        this._propToLastUpdate.set(key1, opId);
+                    }
+                    this._map.set(key1, newValue1);
+                    updateDelta[key1] = {
+                        type: "update"
+                    };
+                }
+                if (Object.keys(reverseUpdateOp.data).length !== 0) {
+                    reverseOps.unshift(reverseUpdateOp);
+                }
+                if (Object.keys(updatedProps).length !== 0) {
+                    ops.unshift({
+                        opId: opId,
+                        id: this._id,
+                        type: 3 /* UPDATE_OBJECT */ ,
+                        data: updatedProps
+                    });
+                }
+                var storageUpdates = /* @__PURE__ */ new Map();
+                storageUpdates.set(this._id, {
+                    node: this,
+                    type: "LiveObject",
+                    updates: updateDelta
+                });
+                this._doc.dispatch(ops, reverseOps, storageUpdates);
+            }
+        }
+    ], [
+        {
+            key: "_deserialize",
+            value: function _deserialize(param, parentToChildren, doc) {
+                var _param = _slicedToArray(param, 2), id = _param[0], item = _param[1];
+                var liveObj = new LiveObject(item.data);
+                liveObj._attach(id, doc);
+                return this._deserializeChildren(liveObj, parentToChildren, doc);
+            }
+        },
+        {
+            key: "_deserializeChildren",
+            value: function _deserializeChildren(liveObj, parentToChildren, doc) {
+                var children = parentToChildren.get(nn(liveObj._id));
+                if (children == null) {
+                    return liveObj;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), id = _value[0], crdt = _value[1];
+                        var child = deserializeToLson([
+                            id,
+                            crdt
+                        ], parentToChildren, doc);
+                        if (isLiveStructure(child)) {
+                            child._setParentLink(liveObj, crdt.parentKey);
+                        }
+                        liveObj._map.set(crdt.parentKey, child);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return liveObj;
+            }
+        }
+    ]);
+    return LiveObject;
+}(AbstractCrdt);
+// src/utils.ts
+function remove(array, item) {
+    for(var i = 0; i < array.length; i++){
+        if (array[i] === item) {
+            array.splice(i, 1);
+            break;
+        }
+    }
+}
+function compact(items) {
+    return items.filter(function(item) {
+        return item != null;
+    });
+}
+function creationOpToLiveNode(op) {
+    return lsonToLiveNode(creationOpToLson(op));
+}
+function creationOpToLson(op) {
+    switch(op.type){
+        case 8 /* CREATE_REGISTER */ :
+            return op.data;
+        case 4 /* CREATE_OBJECT */ :
+            return new LiveObject(op.data);
+        case 7 /* CREATE_MAP */ :
+            return new LiveMap();
+        case 2 /* CREATE_LIST */ :
+            return new LiveList();
+        default:
+            return assertNever(op, "Unknown creation Op");
+    }
+}
+function isSameNodeOrChildOf(node, parent) {
+    if (node === parent) {
+        return true;
+    }
+    if (node.parent.type === "HasParent") {
+        return isSameNodeOrChildOf(node.parent.node, parent);
+    }
+    return false;
+}
+function deserialize(param, parentToChildren, doc) {
+    var _param = _slicedToArray(param, 2), id = _param[0], crdt = _param[1];
+    switch(crdt.type){
+        case 0 /* OBJECT */ :
+            {
+                return LiveObject._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 1 /* LIST */ :
+            {
+                return LiveList._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 2 /* MAP */ :
+            {
+                return LiveMap._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 3 /* REGISTER */ :
+            {
+                return LiveRegister._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        default:
+            {
+                throw new Error("Unexpected CRDT type");
+            }
+    }
+}
+function deserializeToLson(param, parentToChildren, doc) {
+    var _param = _slicedToArray(param, 2), id = _param[0], crdt = _param[1];
+    switch(crdt.type){
+        case 0 /* OBJECT */ :
+            {
+                return LiveObject._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 1 /* LIST */ :
+            {
+                return LiveList._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 2 /* MAP */ :
+            {
+                return LiveMap._deserialize([
+                    id,
+                    crdt
+                ], parentToChildren, doc);
+            }
+        case 3 /* REGISTER */ :
+            {
+                return crdt.data;
+            }
+        default:
+            {
+                throw new Error("Unexpected CRDT type");
+            }
+    }
+}
+function isLiveStructure(value) {
+    return isLiveList(value) || isLiveMap(value) || isLiveObject(value);
+}
+function isLiveNode(value) {
+    return isLiveStructure(value) || isLiveRegister(value);
+}
+function isLiveList(value) {
+    return _instanceof(value, LiveList);
+}
+function isLiveMap(value) {
+    return _instanceof(value, LiveMap);
+}
+function isLiveObject(value) {
+    return _instanceof(value, LiveObject);
+}
+function isLiveRegister(value) {
+    return _instanceof(value, LiveRegister);
+}
+function liveNodeToLson(obj) {
+    if (_instanceof(obj, LiveRegister)) {
+        return obj.data;
+    } else if (_instanceof(obj, LiveList) || _instanceof(obj, LiveMap) || _instanceof(obj, LiveObject)) {
+        return obj;
+    } else {
+        return assertNever(obj, "Unknown AbstractCrdt");
+    }
+}
+function lsonToLiveNode(value) {
+    if (_instanceof(value, LiveObject) || _instanceof(value, LiveMap) || _instanceof(value, LiveList)) {
+        return value;
+    } else {
+        return new LiveRegister(value);
+    }
+}
+function getTreesDiffOperations(currentItems, newItems) {
+    var ops = [];
+    currentItems.forEach(function(_, id) {
+        if (!newItems.get(id)) {
+            ops.push({
+                type: 5 /* DELETE_CRDT */ ,
+                id: id
+            });
+        }
+    });
+    newItems.forEach(function(crdt, id) {
+        var currentCrdt = currentItems.get(id);
+        if (currentCrdt) {
+            if (crdt.type === 0 /* OBJECT */ ) {
+                if (currentCrdt.type !== 0 /* OBJECT */  || JSON.stringify(crdt.data) !== JSON.stringify(currentCrdt.data)) {
+                    ops.push({
+                        type: 3 /* UPDATE_OBJECT */ ,
+                        id: id,
+                        data: crdt.data
+                    });
+                }
+            }
+            if (crdt.parentKey !== currentCrdt.parentKey) {
+                ops.push({
+                    type: 1 /* SET_PARENT_KEY */ ,
+                    id: id,
+                    parentKey: nn(crdt.parentKey, "Parent key must not be missing")
+                });
+            }
+        } else {
+            switch(crdt.type){
+                case 3 /* REGISTER */ :
+                    ops.push({
+                        type: 8 /* CREATE_REGISTER */ ,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data
+                    });
+                    break;
+                case 1 /* LIST */ :
+                    ops.push({
+                        type: 2 /* CREATE_LIST */ ,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey
+                    });
+                    break;
+                case 0 /* OBJECT */ :
+                    ops.push(crdt.parentId ? {
+                        type: 4 /* CREATE_OBJECT */ ,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey,
+                        data: crdt.data
+                    } : {
+                        type: 4 /* CREATE_OBJECT */ ,
+                        id: id,
+                        data: crdt.data
+                    });
+                    break;
+                case 2 /* MAP */ :
+                    ops.push({
+                        type: 7 /* CREATE_MAP */ ,
+                        id: id,
+                        parentId: crdt.parentId,
+                        parentKey: crdt.parentKey
+                    });
+                    break;
+            }
+        }
+    });
+    return ops;
+}
+function mergeObjectStorageUpdates(first, second) {
+    var updates = first.updates;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = entries(second.updates)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            updates[key] = value;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return _objectSpreadProps(_objectSpread({}, second), {
+        updates: updates
+    });
+}
+function mergeMapStorageUpdates(first, second) {
+    var updates = first.updates;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = entries(second.updates)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], value = _value[1];
+            updates[key] = value;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return _objectSpreadProps(_objectSpread({}, second), {
+        updates: updates
+    });
+}
+function mergeListStorageUpdates(first, second) {
+    var updates = first.updates;
+    return _objectSpreadProps(_objectSpread({}, second), {
+        updates: updates.concat(second.updates)
+    });
+}
+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) {
+    var type = typeof value === "undefined" ? "undefined" : _typeof(value);
+    return value === void 0 || value === null || type === "string" || type === "boolean" || type === "number" || Array.isArray(value) || isPlainObject(value);
+}
+function isPlainObject(blob) {
+    return blob !== null && typeof blob === "object" && Object.prototype.toString.call(blob) === "[object Object]";
+}
+function findNonSerializableValue(value) {
+    var path = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+    if (!isPlain) {
+        return {
+            path: path || "root",
+            value: value
+        };
+    }
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(value)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], nestedValue = _value[1];
+            var nestedPath = path ? path + "." + key : key;
+            if (!isPlain(nestedValue)) {
+                return {
+                    path: nestedPath,
+                    value: nestedValue
+                };
+            }
+            if (typeof nestedValue === "object") {
+                var nonSerializableNestedValue = findNonSerializableValue(nestedValue, nestedPath);
+                if (nonSerializableNestedValue) {
+                    return nonSerializableNestedValue;
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return false;
+}
+function fromEntries(iterable) {
+    var obj = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = iterable[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _value = _slicedToArray(_step.value, 2), key = _value[0], val = _value[1];
+            obj[key] = val;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return obj;
+}
+function entries(obj) {
+    return Object.entries(obj);
+}
+function tryParseJson(rawMessage) {
+    try {
+        return JSON.parse(rawMessage);
+    } catch (e) {
+        return void 0;
+    }
+}
+function b64decode(b64value) {
+    try {
+        var formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
+        var decodedValue = decodeURIComponent(atob(formattedValue).split("").map(function(c) {
+            return "%" + ("00" + c.charCodeAt(0).toString(16)).slice(-2);
+        }).join(""));
+        return decodedValue;
+    } catch (err) {
+        return atob(b64value);
+    }
+}
+// src/LiveList.ts
+function compareNodePosition(itemA, itemB) {
+    return comparePosition(itemA._getParentKeyOrThrow(), itemB._getParentKeyOrThrow());
+}
+var LiveList = /*#__PURE__*/ function(AbstractCrdt) {
+    _inherits(LiveList, AbstractCrdt);
+    var _super = _createSuper(LiveList);
+    function LiveList() {
+        var items = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : [];
+        _classCallCheck(this, LiveList);
+        var _this;
+        _this = _super.call(this);
+        _this._items = [];
+        _this._implicitlyDeletedItems = /* @__PURE__ */ new Set();
+        _this._unacknowledgedSets = /* @__PURE__ */ new Map();
+        var position = void 0;
+        for(var i = 0; i < items.length; i++){
+            var newPosition = makePosition(position);
+            var item = lsonToLiveNode(items[i]);
+            item._setParentLink(_assertThisInitialized(_this), newPosition);
+            _this._items.push(item);
+            position = newPosition;
+        }
+        return _this;
+    }
+    _createClass(LiveList, [
+        {
+            key: "_serialize",
+            value: function _serialize(parentId, parentKey, doc) {
+                if (this._id == null) {
+                    throw new Error("Cannot serialize item is not attached");
+                }
+                var ops = [];
+                var op = {
+                    id: this._id,
+                    opId: _optionalChain([
+                        doc,
+                        "optionalAccess",
+                        function(_8) {
+                            return _8.generateOpId;
+                        },
+                        "call",
+                        function(_9) {
+                            return _9();
+                        }
+                    ]),
+                    type: 2 /* CREATE_LIST */ ,
+                    parentId: parentId,
+                    parentKey: parentKey
+                };
+                ops.push(op);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var item = _step.value;
+                        var _ops;
+                        (_ops = ops).push.apply(_ops, _toConsumableArray(item._serialize(this._id, item._getParentKeyOrThrow(), doc)));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return ops;
+            }
+        },
+        {
+            key: "_insertAndSort",
+            value: function _insertAndSort(item) {
+                this._items.push(item);
+                this._sortItems();
+            }
+        },
+        {
+            key: "_sortItems",
+            value: function _sortItems() {
+                this._items.sort(compareNodePosition);
+            }
+        },
+        {
+            key: "_indexOfPosition",
+            value: function _indexOfPosition(position) {
+                return this._items.findIndex(function(item) {
+                    return item._getParentKeyOrThrow() === position;
+                });
+            }
+        },
+        {
+            key: "_attach",
+            value: function _attach(id, doc) {
+                _get(_getPrototypeOf(LiveList.prototype), "_attach", this).call(this, id, doc);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var item = _step.value;
+                        item._attach(doc.generateId(), doc);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_detach",
+            value: function _detach() {
+                _get(_getPrototypeOf(LiveList.prototype), "_detach", this).call(this);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = this._items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var item = _step.value;
+                        item._detach();
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_applySetRemote",
+            value: function _applySetRemote(op) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                var id = op.id, key = op.parentKey;
+                var child = creationOpToLiveNode(op);
+                child._attach(id, this._doc);
+                child._setParentLink(this, key);
+                var deletedId = op.deletedId;
+                var indexOfItemWithSamePosition = this._indexOfPosition(key);
+                if (indexOfItemWithSamePosition !== -1) {
+                    var itemWithSamePosition = this._items[indexOfItemWithSamePosition];
+                    if (itemWithSamePosition._id === deletedId) {
+                        itemWithSamePosition._detach();
+                        this._items[indexOfItemWithSamePosition] = child;
+                        return {
+                            modified: makeUpdate(this, [
+                                setDelta(indexOfItemWithSamePosition, child)
+                            ]),
+                            reverse: []
+                        };
+                    } else {
+                        this._implicitlyDeletedItems.add(itemWithSamePosition);
+                        this._items[indexOfItemWithSamePosition] = child;
+                        var delta = [
+                            setDelta(indexOfItemWithSamePosition, child)
+                        ];
+                        var deleteDelta2 = this._detachItemAssociatedToSetOperation(op.deletedId);
+                        if (deleteDelta2) {
+                            delta.push(deleteDelta2);
+                        }
+                        return {
+                            modified: makeUpdate(this, delta),
+                            reverse: []
+                        };
+                    }
+                } else {
+                    var updates = [];
+                    var deleteDelta21 = this._detachItemAssociatedToSetOperation(op.deletedId);
+                    if (deleteDelta21) {
+                        updates.push(deleteDelta21);
+                    }
+                    this._insertAndSort(child);
+                    updates.push(insertDelta(this._indexOfPosition(key), child));
+                    return {
+                        reverse: [],
+                        modified: makeUpdate(this, updates)
+                    };
+                }
+            }
+        },
+        {
+            key: "_applySetAck",
+            value: function _applySetAck(op) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                var delta = [];
+                var deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+                if (deletedDelta) {
+                    delta.push(deletedDelta);
+                }
+                var unacknowledgedOpId = this._unacknowledgedSets.get(op.parentKey);
+                if (unacknowledgedOpId != null) {
+                    if (unacknowledgedOpId !== op.opId) {
+                        return delta.length === 0 ? {
+                            modified: false
+                        } : {
+                            modified: makeUpdate(this, delta),
+                            reverse: []
+                        };
+                    } else {
+                        this._unacknowledgedSets.delete(op.parentKey);
+                    }
+                }
+                var indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey);
+                var existingItem = this._items.find(function(item) {
+                    return item._id === op.id;
+                });
+                if (existingItem != null) {
+                    if (existingItem._parentKey === op.parentKey) {
+                        return {
+                            modified: delta.length > 0 ? makeUpdate(this, delta) : false,
+                            reverse: []
+                        };
+                    }
+                    if (indexOfItemWithSamePosition !== -1) {
+                        this._implicitlyDeletedItems.add(this._items[indexOfItemWithSamePosition]);
+                        this._items.splice(indexOfItemWithSamePosition, 1);
+                        delta.push(deleteDelta(indexOfItemWithSamePosition));
+                    }
+                    var previousIndex = this._items.indexOf(existingItem);
+                    existingItem._setParentLink(this, op.parentKey);
+                    this._sortItems();
+                    var newIndex = this._items.indexOf(existingItem);
+                    if (newIndex !== previousIndex) {
+                        delta.push(moveDelta(previousIndex, newIndex, existingItem));
+                    }
+                    return {
+                        modified: delta.length > 0 ? makeUpdate(this, delta) : false,
+                        reverse: []
+                    };
+                } else {
+                    var orphan = this._doc.getItem(op.id);
+                    if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+                        orphan._setParentLink(this, op.parentKey);
+                        this._implicitlyDeletedItems.delete(orphan);
+                        this._insertAndSort(orphan);
+                        var recreatedItemIndex = this._items.indexOf(orphan);
+                        return {
+                            modified: makeUpdate(this, [
+                                indexOfItemWithSamePosition === -1 ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan)
+                            ].concat(_toConsumableArray(delta))),
+                            reverse: []
+                        };
+                    } else {
+                        if (indexOfItemWithSamePosition !== -1) {
+                            this._items.splice(indexOfItemWithSamePosition, 1);
+                        }
+                        var ref = this._createAttachItemAndSort(op, op.parentKey), newItem = ref.newItem, newIndex1 = ref.newIndex;
+                        return {
+                            modified: makeUpdate(this, [
+                                indexOfItemWithSamePosition === -1 ? insertDelta(newIndex1, newItem) : setDelta(newIndex1, newItem)
+                            ].concat(_toConsumableArray(delta))),
+                            reverse: []
+                        };
+                    }
+                }
+            }
+        },
+        {
+            key: "_detachItemAssociatedToSetOperation",
+            value: function _detachItemAssociatedToSetOperation(deletedId) {
+                if (deletedId == null || this._doc == null) {
+                    return null;
+                }
+                var deletedItem = this._doc.getItem(deletedId);
+                if (deletedItem == null) {
+                    return null;
+                }
+                var result = this._detachChild(deletedItem);
+                if (result.modified === false) {
+                    return null;
+                }
+                return result.modified.updates[0];
+            }
+        },
+        {
+            key: "_applyRemoteInsert",
+            value: function _applyRemoteInsert(op) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                var key = op.parentKey;
+                var existingItemIndex = this._indexOfPosition(key);
+                if (existingItemIndex !== -1) {
+                    this._shiftItemPosition(existingItemIndex, key);
+                }
+                var ref = this._createAttachItemAndSort(op, key), newItem = ref.newItem, newIndex = ref.newIndex;
+                return {
+                    modified: makeUpdate(this, [
+                        insertDelta(newIndex, newItem)
+                    ]),
+                    reverse: []
+                };
+            }
+        },
+        {
+            key: "_applyInsertAck",
+            value: function _applyInsertAck(op) {
+                var existingItem = this._items.find(function(item) {
+                    return item._id === op.id;
+                });
+                var key = op.parentKey;
+                var itemIndexAtPosition = this._indexOfPosition(key);
+                if (existingItem) {
+                    if (existingItem._parentKey === key) {
+                        return {
+                            modified: false
+                        };
+                    } else {
+                        var oldPositionIndex = this._items.indexOf(existingItem);
+                        if (itemIndexAtPosition !== -1) {
+                            this._shiftItemPosition(itemIndexAtPosition, key);
+                        }
+                        existingItem._setParentLink(this, key);
+                        this._sortItems();
+                        var newIndex = this._indexOfPosition(key);
+                        if (newIndex === oldPositionIndex) {
+                            return {
+                                modified: false
+                            };
+                        }
+                        return {
+                            modified: makeUpdate(this, [
+                                moveDelta(oldPositionIndex, newIndex, existingItem)
+                            ]),
+                            reverse: []
+                        };
+                    }
+                } else {
+                    var orphan = nn(this._doc).getItem(op.id);
+                    if (orphan && this._implicitlyDeletedItems.has(orphan)) {
+                        orphan._setParentLink(this, key);
+                        this._implicitlyDeletedItems.delete(orphan);
+                        this._insertAndSort(orphan);
+                        var newIndex1 = this._indexOfPosition(key);
+                        return {
+                            modified: makeUpdate(this, [
+                                insertDelta(newIndex1, orphan)
+                            ]),
+                            reverse: []
+                        };
+                    } else {
+                        if (itemIndexAtPosition !== -1) {
+                            this._shiftItemPosition(itemIndexAtPosition, key);
+                        }
+                        var ref = this._createAttachItemAndSort(op, key), newItem = ref.newItem, newIndex2 = ref.newIndex;
+                        return {
+                            modified: makeUpdate(this, [
+                                insertDelta(newIndex2, newItem)
+                            ]),
+                            reverse: []
+                        };
+                    }
+                }
+            }
+        },
+        {
+            key: "_applyInsertUndoRedo",
+            value: function _applyInsertUndoRedo(op) {
+                var id = op.id, key = op.parentKey;
+                var child = creationOpToLiveNode(op);
+                if (_optionalChain([
+                    this,
+                    "access",
+                    function(_10) {
+                        return _10._doc;
+                    },
+                    "optionalAccess",
+                    function(_11) {
+                        return _11.getItem;
+                    },
+                    "call",
+                    function(_12) {
+                        return _12(id);
+                    }
+                ]) !== void 0) {
+                    return {
+                        modified: false
+                    };
+                }
+                child._attach(id, nn(this._doc));
+                child._setParentLink(this, key);
+                var existingItemIndex = this._indexOfPosition(key);
+                var newKey = key;
+                if (existingItemIndex !== -1) {
+                    var before = this._items[existingItemIndex] ? this._items[existingItemIndex]._getParentKeyOrThrow() : void 0;
+                    var after = this._items[existingItemIndex + 1] ? this._items[existingItemIndex + 1]._getParentKeyOrThrow() : void 0;
+                    newKey = makePosition(before, after);
+                    child._setParentLink(this, newKey);
+                }
+                this._insertAndSort(child);
+                var newIndex = this._indexOfPosition(newKey);
+                return {
+                    modified: makeUpdate(this, [
+                        insertDelta(newIndex, child)
+                    ]),
+                    reverse: [
+                        {
+                            type: 5 /* DELETE_CRDT */ ,
+                            id: id
+                        }
+                    ]
+                };
+            }
+        },
+        {
+            key: "_applySetUndoRedo",
+            value: function _applySetUndoRedo(op) {
+                var id = op.id, key = op.parentKey;
+                var child = creationOpToLiveNode(op);
+                if (_optionalChain([
+                    this,
+                    "access",
+                    function(_13) {
+                        return _13._doc;
+                    },
+                    "optionalAccess",
+                    function(_14) {
+                        return _14.getItem;
+                    },
+                    "call",
+                    function(_15) {
+                        return _15(id);
+                    }
+                ]) !== void 0) {
+                    return {
+                        modified: false
+                    };
+                }
+                this._unacknowledgedSets.set(key, nn(op.opId));
+                var indexOfItemWithSameKey = this._indexOfPosition(key);
+                child._attach(id, nn(this._doc));
+                child._setParentLink(this, key);
+                var newKey = key;
+                if (indexOfItemWithSameKey !== -1) {
+                    var existingItem = this._items[indexOfItemWithSameKey];
+                    existingItem._detach();
+                    this._items[indexOfItemWithSameKey] = child;
+                    var reverse = existingItem._serialize(nn(this._id), key, this._doc);
+                    addIntentAndDeletedIdToOperation(reverse, op.id);
+                    var delta = [
+                        setDelta(indexOfItemWithSameKey, child)
+                    ];
+                    var deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
+                    if (deletedDelta) {
+                        delta.push(deletedDelta);
+                    }
+                    return {
+                        modified: makeUpdate(this, delta),
+                        reverse: reverse
+                    };
+                } else {
+                    this._insertAndSort(child);
+                    this._detachItemAssociatedToSetOperation(op.deletedId);
+                    var newIndex = this._indexOfPosition(newKey);
+                    return {
+                        reverse: [
+                            {
+                                type: 5 /* DELETE_CRDT */ ,
+                                id: id
+                            }
+                        ],
+                        modified: makeUpdate(this, [
+                            insertDelta(newIndex, child)
+                        ])
+                    };
+                }
+            }
+        },
+        {
+            key: "_attachChild",
+            value: function _attachChild(op, source) {
+                if (this._doc == null) {
+                    throw new Error("Can't attach child if doc is not present");
+                }
+                if (op.intent === "set") {
+                    if (source === 1 /* REMOTE */ ) {
+                        return this._applySetRemote(op);
+                    }
+                    if (source === 0 /* UNDOREDO_RECONNECT */ ) {
+                        return this._applySetUndoRedo(op);
+                    }
+                    if (source === 2 /* ACK */ ) {
+                        return this._applySetAck(op);
+                    }
+                }
+                if (source === 1 /* REMOTE */ ) {
+                    return this._applyRemoteInsert(op);
+                } else if (source === 2 /* ACK */ ) {
+                    return this._applyInsertAck(op);
+                } else {
+                    return this._applyInsertUndoRedo(op);
+                }
+            }
+        },
+        {
+            key: "_detachChild",
+            value: function _detachChild(child) {
+                if (child) {
+                    var parentKey = nn(child._parentKey);
+                    var reverse = child._serialize(nn(this._id), parentKey, this._doc);
+                    var indexToDelete = this._items.indexOf(child);
+                    if (indexToDelete === -1) {
+                        return {
+                            modified: false
+                        };
+                    }
+                    this._items.splice(indexToDelete, 1);
+                    child._detach();
+                    return {
+                        modified: makeUpdate(this, [
+                            deleteDelta(indexToDelete)
+                        ]),
+                        reverse: reverse
+                    };
+                }
+                return {
+                    modified: false
+                };
+            }
+        },
+        {
+            key: "_applySetChildKeyRemote",
+            value: function _applySetChildKeyRemote(newKey, child) {
+                if (this._implicitlyDeletedItems.has(child)) {
+                    this._implicitlyDeletedItems.delete(child);
+                    child._setParentLink(this, newKey);
+                    this._insertAndSort(child);
+                    var newIndex = this._items.indexOf(child);
+                    return {
+                        modified: makeUpdate(this, [
+                            insertDelta(newIndex, child)
+                        ]),
+                        reverse: []
+                    };
+                }
+                var previousKey = child._parentKey;
+                if (newKey === previousKey) {
+                    return {
+                        modified: false
+                    };
+                }
+                var existingItemIndex = this._indexOfPosition(newKey);
+                if (existingItemIndex === -1) {
+                    var previousIndex = this._items.indexOf(child);
+                    child._setParentLink(this, newKey);
+                    this._sortItems();
+                    var newIndex1 = this._items.indexOf(child);
+                    if (newIndex1 === previousIndex) {
+                        return {
+                            modified: false
+                        };
+                    }
+                    return {
+                        modified: makeUpdate(this, [
+                            moveDelta(previousIndex, newIndex1, child)
+                        ]),
+                        reverse: []
+                    };
+                } else {
+                    this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, _optionalChain([
+                        this,
+                        "access",
+                        function(_16) {
+                            return _16._items;
+                        },
+                        "access",
+                        function(_17) {
+                            return _17[existingItemIndex + 1];
+                        },
+                        "optionalAccess",
+                        function(_18) {
+                            return _18._getParentKeyOrThrow;
+                        },
+                        "call",
+                        function(_19) {
+                            return _19();
+                        }
+                    ])));
+                    var previousIndex1 = this._items.indexOf(child);
+                    child._setParentLink(this, newKey);
+                    this._sortItems();
+                    var newIndex2 = this._items.indexOf(child);
+                    if (newIndex2 === previousIndex1) {
+                        return {
+                            modified: false
+                        };
+                    }
+                    return {
+                        modified: makeUpdate(this, [
+                            moveDelta(previousIndex1, newIndex2, child)
+                        ]),
+                        reverse: []
+                    };
+                }
+            }
+        },
+        {
+            key: "_applySetChildKeyAck",
+            value: function _applySetChildKeyAck(newKey, child) {
+                var previousKey = nn(child._parentKey);
+                if (this._implicitlyDeletedItems.has(child)) {
+                    var existingItemIndex = this._indexOfPosition(newKey);
+                    this._implicitlyDeletedItems.delete(child);
+                    if (existingItemIndex !== -1) {
+                        this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, _optionalChain([
+                            this,
+                            "access",
+                            function(_20) {
+                                return _20._items;
+                            },
+                            "access",
+                            function(_21) {
+                                return _21[existingItemIndex + 1];
+                            },
+                            "optionalAccess",
+                            function(_22) {
+                                return _22._getParentKeyOrThrow;
+                            },
+                            "call",
+                            function(_23) {
+                                return _23();
+                            }
+                        ])));
+                    }
+                    child._setParentLink(this, newKey);
+                    this._insertAndSort(child);
+                    return {
+                        modified: false
+                    };
+                } else {
+                    if (newKey === previousKey) {
+                        return {
+                            modified: false
+                        };
+                    }
+                    var previousIndex = this._items.indexOf(child);
+                    var existingItemIndex1 = this._indexOfPosition(newKey);
+                    if (existingItemIndex1 !== -1) {
+                        this._items[existingItemIndex1]._setParentLink(this, makePosition(newKey, _optionalChain([
+                            this,
+                            "access",
+                            function(_24) {
+                                return _24._items;
+                            },
+                            "access",
+                            function(_25) {
+                                return _25[existingItemIndex1 + 1];
+                            },
+                            "optionalAccess",
+                            function(_26) {
+                                return _26._getParentKeyOrThrow;
+                            },
+                            "call",
+                            function(_27) {
+                                return _27();
+                            }
+                        ])));
+                    }
+                    child._setParentLink(this, newKey);
+                    this._sortItems();
+                    var newIndex = this._items.indexOf(child);
+                    if (previousIndex === newIndex) {
+                        return {
+                            modified: false
+                        };
+                    } else {
+                        return {
+                            modified: makeUpdate(this, [
+                                moveDelta(previousIndex, newIndex, child)
+                            ]),
+                            reverse: []
+                        };
+                    }
+                }
+            }
+        },
+        {
+            key: "_applySetChildKeyUndoRedo",
+            value: function _applySetChildKeyUndoRedo(newKey, child) {
+                var previousKey = nn(child._parentKey);
+                var previousIndex = this._items.indexOf(child);
+                var existingItemIndex = this._indexOfPosition(newKey);
+                if (existingItemIndex !== -1) {
+                    this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, _optionalChain([
+                        this,
+                        "access",
+                        function(_28) {
+                            return _28._items;
+                        },
+                        "access",
+                        function(_29) {
+                            return _29[existingItemIndex + 1];
+                        },
+                        "optionalAccess",
+                        function(_30) {
+                            return _30._getParentKeyOrThrow;
+                        },
+                        "call",
+                        function(_31) {
+                            return _31();
+                        }
+                    ])));
+                }
+                child._setParentLink(this, newKey);
+                this._sortItems();
+                var newIndex = this._items.indexOf(child);
+                if (previousIndex === newIndex) {
+                    return {
+                        modified: false
+                    };
+                }
+                return {
+                    modified: makeUpdate(this, [
+                        moveDelta(previousIndex, newIndex, child)
+                    ]),
+                    reverse: [
+                        {
+                            type: 1 /* SET_PARENT_KEY */ ,
+                            id: nn(child._id),
+                            parentKey: previousKey
+                        }
+                    ]
+                };
+            }
+        },
+        {
+            key: "_setChildKey",
+            value: function _setChildKey(newKey, child, source) {
+                if (source === 1 /* REMOTE */ ) {
+                    return this._applySetChildKeyRemote(newKey, child);
+                } else if (source === 2 /* ACK */ ) {
+                    return this._applySetChildKeyAck(newKey, child);
+                } else {
+                    return this._applySetChildKeyUndoRedo(newKey, child);
+                }
+            }
+        },
+        {
+            key: "_apply",
+            value: function _apply(op, isLocal) {
+                return _get(_getPrototypeOf(LiveList.prototype), "_apply", this).call(this, op, isLocal);
+            }
+        },
+        {
+            key: "_toSerializedCrdt",
+            value: function _toSerializedCrdt() {
+                if (this.parent.type !== "HasParent") {
+                    throw new Error("Cannot serialize LiveList if parent is missing");
+                }
+                return {
+                    type: 1 /* LIST */ ,
+                    parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
+                    parentKey: this.parent.key
+                };
+            }
+        },
+        {
+            key: "length",
+            get: function get() {
+                return this._items.length;
+            }
+        },
+        {
+            key: "push",
+            value: function push(element) {
+                return this.insert(element, this.length);
+            }
+        },
+        {
+            key: "insert",
+            value: function insert(element, index) {
+                if (index < 0 || index > this._items.length) {
+                    throw new Error('Cannot insert list item at index "\x1d'.concat(index, '". index should be between 0 and ').concat(this._items.length));
+                }
+                var before = this._items[index - 1] ? this._items[index - 1]._getParentKeyOrThrow() : void 0;
+                var after = this._items[index] ? this._items[index]._getParentKeyOrThrow() : void 0;
+                var position = makePosition(before, after);
+                var value = lsonToLiveNode(element);
+                value._setParentLink(this, position);
+                this._insertAndSort(value);
+                if (this._doc && this._id) {
+                    var id = this._doc.generateId();
+                    value._attach(id, this._doc);
+                    this._doc.dispatch(value._serialize(this._id, position, this._doc), [
+                        {
+                            type: 5 /* DELETE_CRDT */ ,
+                            id: id
+                        }
+                    ], /* @__PURE__ */ new Map([
+                        [
+                            this._id,
+                            makeUpdate(this, [
+                                insertDelta(index, value)
+                            ])
+                        ]
+                    ]));
+                }
+            }
+        },
+        {
+            key: "move",
+            value: function 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");
+                }
+                var beforePosition = null;
+                var afterPosition = null;
+                if (index < targetIndex) {
+                    afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._getParentKeyOrThrow();
+                    beforePosition = this._items[targetIndex]._getParentKeyOrThrow();
+                } else {
+                    afterPosition = this._items[targetIndex]._getParentKeyOrThrow();
+                    beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1]._getParentKeyOrThrow();
+                }
+                var position = makePosition(beforePosition, afterPosition);
+                var item = this._items[index];
+                var previousPosition = item._getParentKeyOrThrow();
+                item._setParentLink(this, position);
+                this._sortItems();
+                if (this._doc && this._id) {
+                    var storageUpdates = /* @__PURE__ */ new Map([
+                        [
+                            this._id,
+                            makeUpdate(this, [
+                                moveDelta(index, targetIndex, item)
+                            ])
+                        ]
+                    ]);
+                    this._doc.dispatch([
+                        {
+                            type: 1 /* SET_PARENT_KEY */ ,
+                            id: nn(item._id),
+                            opId: this._doc.generateOpId(),
+                            parentKey: position
+                        }
+                    ], [
+                        {
+                            type: 1 /* SET_PARENT_KEY */ ,
+                            id: nn(item._id),
+                            parentKey: previousPosition
+                        }
+                    ], storageUpdates);
+                }
+            }
+        },
+        {
+            key: "delete",
+            value: function _delete(index) {
+                if (index < 0 || index >= this._items.length) {
+                    throw new Error('Cannot delete list item at index "\x1d'.concat(index, '". index should be between 0 and ').concat(this._items.length - 1));
+                }
+                var item = this._items[index];
+                item._detach();
+                this._items.splice(index, 1);
+                if (this._doc) {
+                    var childRecordId = item._id;
+                    if (childRecordId) {
+                        var storageUpdates = /* @__PURE__ */ new Map();
+                        storageUpdates.set(nn(this._id), makeUpdate(this, [
+                            deleteDelta(index)
+                        ]));
+                        this._doc.dispatch([
+                            {
+                                id: childRecordId,
+                                opId: this._doc.generateOpId(),
+                                type: 5 /* DELETE_CRDT */ 
+                            }
+                        ], item._serialize(nn(this._id), item._getParentKeyOrThrow()), storageUpdates);
+                    }
+                }
+            }
+        },
+        {
+            key: "clear",
+            value: function clear() {
+                if (this._doc) {
+                    var ops = [];
+                    var reverseOps = [];
+                    var updateDelta = [];
+                    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(var _iterator = this._items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            var item = _step.value;
+                            item._detach();
+                            var childId = item._id;
+                            if (childId) {
+                                var _reverseOps;
+                                ops.push({
+                                    type: 5 /* DELETE_CRDT */ ,
+                                    id: childId,
+                                    opId: this._doc.generateOpId()
+                                });
+                                (_reverseOps = reverseOps).push.apply(_reverseOps, _toConsumableArray(item._serialize(nn(this._id), item._getParentKeyOrThrow())));
+                                updateDelta.push(deleteDelta(0));
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    this._items = [];
+                    var storageUpdates = /* @__PURE__ */ new Map();
+                    storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta));
+                    this._doc.dispatch(ops, reverseOps, storageUpdates);
+                } else {
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = this._items[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var item1 = _step1.value;
+                            item1._detach();
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                    this._items = [];
+                }
+            }
+        },
+        {
+            key: "set",
+            value: function set(index, item) {
+                if (index < 0 || index >= this._items.length) {
+                    throw new Error('Cannot set list item at index "\x1d'.concat(index, '". index should be between 0 and ').concat(this._items.length - 1));
+                }
+                var existingItem = this._items[index];
+                var position = existingItem._getParentKeyOrThrow();
+                var existingId = existingItem._id;
+                existingItem._detach();
+                var value = lsonToLiveNode(item);
+                value._setParentLink(this, position);
+                this._items[index] = value;
+                if (this._doc && this._id) {
+                    var id = this._doc.generateId();
+                    value._attach(id, this._doc);
+                    var storageUpdates = /* @__PURE__ */ new Map();
+                    storageUpdates.set(this._id, makeUpdate(this, [
+                        setDelta(index, value)
+                    ]));
+                    var ops = value._serialize(this._id, position, this._doc);
+                    addIntentAndDeletedIdToOperation(ops, existingId);
+                    this._unacknowledgedSets.set(position, nn(ops[0].opId));
+                    var reverseOps = existingItem._serialize(this._id, position, void 0);
+                    addIntentAndDeletedIdToOperation(reverseOps, id);
+                    this._doc.dispatch(ops, reverseOps, storageUpdates);
+                }
+            }
+        },
+        {
+            key: "toArray",
+            value: function toArray() {
+                return this._items.map(function(entry) {
+                    return liveNodeToLson(entry);
+                });
+            }
+        },
+        {
+            key: "every",
+            value: function every(predicate) {
+                return this.toArray().every(predicate);
+            }
+        },
+        {
+            key: "filter",
+            value: function filter(predicate) {
+                return this.toArray().filter(predicate);
+            }
+        },
+        {
+            key: "find",
+            value: function find(predicate) {
+                return this.toArray().find(predicate);
+            }
+        },
+        {
+            key: "findIndex",
+            value: function findIndex(predicate) {
+                return this.toArray().findIndex(predicate);
+            }
+        },
+        {
+            key: "forEach",
+            value: function forEach(callbackfn) {
+                return this.toArray().forEach(callbackfn);
+            }
+        },
+        {
+            key: "get",
+            value: function get(index) {
+                if (index < 0 || index >= this._items.length) {
+                    return void 0;
+                }
+                return liveNodeToLson(this._items[index]);
+            }
+        },
+        {
+            key: "indexOf",
+            value: function indexOf(searchElement, fromIndex) {
+                return this.toArray().indexOf(searchElement, fromIndex);
+            }
+        },
+        {
+            key: "lastIndexOf",
+            value: function lastIndexOf(searchElement, fromIndex) {
+                return this.toArray().lastIndexOf(searchElement, fromIndex);
+            }
+        },
+        {
+            key: "map",
+            value: function map(callback) {
+                return this._items.map(function(entry, i) {
+                    return callback(liveNodeToLson(entry), i);
+                });
+            }
+        },
+        {
+            key: "some",
+            value: function some(predicate) {
+                return this.toArray().some(predicate);
+            }
+        },
+        {
+            key: Symbol.iterator,
+            value: function value() {
+                return new LiveListIterator(this._items);
+            }
+        },
+        {
+            key: "_createAttachItemAndSort",
+            value: function _createAttachItemAndSort(op, key) {
+                var newItem = creationOpToLiveNode(op);
+                newItem._attach(op.id, nn(this._doc));
+                newItem._setParentLink(this, key);
+                this._insertAndSort(newItem);
+                var newIndex = this._indexOfPosition(key);
+                return {
+                    newItem: newItem,
+                    newIndex: newIndex
+                };
+            }
+        },
+        {
+            key: "_shiftItemPosition",
+            value: function _shiftItemPosition(index, key) {
+                var shiftedPosition = makePosition(key, this._items.length > index + 1 ? _optionalChain([
+                    this,
+                    "access",
+                    function(_32) {
+                        return _32._items;
+                    },
+                    "access",
+                    function(_33) {
+                        return _33[index + 1];
+                    },
+                    "optionalAccess",
+                    function(_34) {
+                        return _34._getParentKeyOrThrow;
+                    },
+                    "call",
+                    function(_35) {
+                        return _35();
+                    }
+                ]) : void 0);
+                this._items[index]._setParentLink(this, shiftedPosition);
+            }
+        }
+    ], [
+        {
+            key: "_deserialize",
+            value: function _deserialize(param, parentToChildren, doc) {
+                var _param = _slicedToArray(param, 1), id = _param[0];
+                var list = new LiveList();
+                list._attach(id, doc);
+                var children = parentToChildren.get(id);
+                if (children == null) {
+                    return list;
+                }
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _value = _slicedToArray(_step.value, 2), id2 = _value[0], crdt = _value[1];
+                        var child = deserialize([
+                            id2,
+                            crdt
+                        ], parentToChildren, doc);
+                        child._setParentLink(list, crdt.parentKey);
+                        list._insertAndSort(child);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                return list;
+            }
+        }
+    ]);
+    return LiveList;
+}(AbstractCrdt);
+var LiveListIterator = /*#__PURE__*/ function() {
+    function LiveListIterator(items) {
+        _classCallCheck(this, LiveListIterator);
+        this._innerIterator = items[Symbol.iterator]();
+    }
+    _createClass(LiveListIterator, [
+        {
+            key: Symbol.iterator,
+            value: function value() {
+                return this;
+            }
+        },
+        {
+            key: "next",
+            value: function next() {
+                var result = this._innerIterator.next();
+                if (result.done) {
+                    return {
+                        done: true,
+                        value: void 0
+                    };
+                }
+                var value = liveNodeToLson(result.value);
+                return {
+                    value: value
+                };
+            }
+        }
+    ]);
+    return LiveListIterator;
+}();
+function makeUpdate(liveList, deltaUpdates) {
+    return {
+        node: liveList,
+        type: "LiveList",
+        updates: deltaUpdates
+    };
+}
+function setDelta(index, item) {
+    return {
+        index: index,
+        type: "set",
+        item: _instanceof(item, LiveRegister) ? item.data : item
+    };
+}
+function deleteDelta(index) {
+    return {
+        index: index,
+        type: "delete"
+    };
+}
+function insertDelta(index, item) {
+    return {
+        index: index,
+        type: "insert",
+        item: _instanceof(item, LiveRegister) ? item.data : item
+    };
+}
+function moveDelta(previousIndex, index, item) {
+    return {
+        index: index,
+        type: "move",
+        previousIndex: previousIndex,
+        item: _instanceof(item, LiveRegister) ? item.data : item
+    };
+}
+function addIntentAndDeletedIdToOperation(ops, deletedId) {
+    if (ops.length === 0) {
+        throw new Error("Internal error. Serialized LiveStructure should have at least 1 operation");
+    }
+    var firstOp = ops[0];
+    firstOp.intent = "set";
+    firstOp.deletedId = deletedId;
+}
+// src/AuthToken.ts
+var SCOPES = [
+    "websocket:presence",
+    "websocket:storage",
+    "room:read",
+    "room:write",
+    "rooms:read",
+    "rooms:write"
+];
+function hasJwtMeta(data) {
+    if (!isPlainObject(data)) {
+        return false;
+    }
+    var iat = data.iat, exp = data.exp;
+    return typeof iat === "number" && typeof exp === "number";
+}
+function isTokenExpired(token) {
+    var now = Date.now() / 1e3;
+    return now > token.exp - 300 || now < token.iat + 300;
+}
+function isScope(value) {
+    return SCOPES.includes(value);
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every(function(i) {
+        return typeof i === "string";
+    });
+}
+function isAppOnlyAuthToken(data) {
+    return typeof data.appId === "string" && data.roomId === void 0 && isStringList(data.scopes);
+}
+function isRoomAuthToken(data) {
+    return typeof data.appId === "string" && typeof data.roomId === "string" && typeof data.actor === "number" && (data.id === void 0 || typeof data.id === "string") && isStringList(data.scopes) && (data.maxConnectionsPerRoom === void 0 || typeof data.maxConnectionsPerRoom === "number");
+}
+function isAuthToken(data) {
+    return isAppOnlyAuthToken(data) || isRoomAuthToken(data);
+}
+function parseJwtToken(token) {
+    var tokenParts = token.split(".");
+    if (tokenParts.length !== 3) {
+        throw new Error("Authentication error: invalid JWT token");
+    }
+    var data = tryParseJson(b64decode(tokenParts[1]));
+    if (data && hasJwtMeta(data)) {
+        return data;
+    } else {
+        throw new Error("Authentication error: missing JWT metadata");
+    }
+}
+function parseRoomAuthToken(tokenString) {
+    var data = parseJwtToken(tokenString);
+    if (data && isRoomAuthToken(data)) {
+        var _legacyField = data.maxConnections, token = _objectWithoutProperties(data, [
+            "maxConnections"
+        ]);
+        return token;
+    } else {
+        throw new Error("Authentication error: we expected a room token but did not get one. Hint: if you are using a callback, ensure the room is passed when creating the token. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientCallback");
+    }
+}
+// src/types/Json.ts
+function isJsonScalar(data) {
+    return data === null || typeof data === "string" || typeof data === "number" || typeof data === "boolean";
+}
+function isJsonArray(data) {
+    return Array.isArray(data);
+}
+function isJsonObject(data) {
+    return !isJsonScalar(data) && !isJsonArray(data);
+}
+exports.deprecate = deprecate;
+exports.deprecateIf = deprecateIf;
+exports.throwUsageError = throwUsageError;
+exports.errorIf = errorIf;
+exports.assertNever = assertNever;
+exports.nn = nn;
+exports.ClientMsgCode = ClientMsgCode;
+exports.OpCode = OpCode;
+exports.CrdtType = CrdtType;
+exports.isRootCrdt = isRootCrdt;
+exports.isChildCrdt = isChildCrdt;
+exports.ServerMsgCode = ServerMsgCode;
+exports.isRoomEventName = isRoomEventName;
+exports.WebsocketCloseCodes = WebsocketCloseCodes;
+exports.LiveRegister = LiveRegister;
+exports.makePosition = makePosition;
+exports.comparePosition = comparePosition;
+exports.LiveList = LiveList;
+exports.LiveMap = LiveMap;
+exports.LiveObject = LiveObject;
+exports.remove = remove;
+exports.compact = compact;
+exports.isSameNodeOrChildOf = isSameNodeOrChildOf;
+exports.isLiveNode = isLiveNode;
+exports.isLiveList = isLiveList;
+exports.isLiveObject = isLiveObject;
+exports.getTreesDiffOperations = getTreesDiffOperations;
+exports.mergeStorageUpdates = mergeStorageUpdates;
+exports.isPlainObject = isPlainObject;
+exports.findNonSerializableValue = findNonSerializableValue;
+exports.tryParseJson = tryParseJson;
+exports.b64decode = b64decode;
+exports.isTokenExpired = isTokenExpired;
+exports.isScope = isScope;
+exports.isAppOnlyAuthToken = isAppOnlyAuthToken;
+exports.isRoomAuthToken = isRoomAuthToken;
+exports.isAuthToken = isAuthToken;
+exports.parseRoomAuthToken = parseRoomAuthToken;
+exports.isJsonScalar = isJsonScalar;
+exports.isJsonArray = isJsonArray;
+exports.isJsonObject = isJsonObject;