@liveblocks/client 0.16.2 → 0.16.4-beta2

package/shared.js

@@ -0,0 +1,2488 @@
+'use strict';
+
+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 _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+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 _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+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(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+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 _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      return function () {
+        if (i >= o.length) return {
+          done: true
+        };
+        return {
+          done: false,
+          value: o[i++]
+        };
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  it = o[Symbol.iterator]();
+  return it.next.bind(it);
+}
+
+exports.ServerMessageType = void 0;
+
+(function (ServerMessageType) {
+  ServerMessageType[ServerMessageType["UpdatePresence"] = 100] = "UpdatePresence";
+  ServerMessageType[ServerMessageType["UserJoined"] = 101] = "UserJoined";
+  ServerMessageType[ServerMessageType["UserLeft"] = 102] = "UserLeft";
+  ServerMessageType[ServerMessageType["Event"] = 103] = "Event";
+  ServerMessageType[ServerMessageType["RoomState"] = 104] = "RoomState";
+  ServerMessageType[ServerMessageType["InitialStorageState"] = 200] = "InitialStorageState";
+  ServerMessageType[ServerMessageType["UpdateStorage"] = 201] = "UpdateStorage";
+})(exports.ServerMessageType || (exports.ServerMessageType = {}));
+
+exports.ClientMessageType = void 0;
+
+(function (ClientMessageType) {
+  ClientMessageType[ClientMessageType["UpdatePresence"] = 100] = "UpdatePresence";
+  ClientMessageType[ClientMessageType["ClientEvent"] = 103] = "ClientEvent";
+  ClientMessageType[ClientMessageType["FetchStorage"] = 200] = "FetchStorage";
+  ClientMessageType[ClientMessageType["UpdateStorage"] = 201] = "UpdateStorage";
+})(exports.ClientMessageType || (exports.ClientMessageType = {}));
+
+exports.CrdtType = void 0;
+
+(function (CrdtType) {
+  CrdtType[CrdtType["Object"] = 0] = "Object";
+  CrdtType[CrdtType["List"] = 1] = "List";
+  CrdtType[CrdtType["Map"] = 2] = "Map";
+  CrdtType[CrdtType["Register"] = 3] = "Register";
+})(exports.CrdtType || (exports.CrdtType = {}));
+
+exports.OpType = void 0;
+
+(function (OpType) {
+  OpType[OpType["Init"] = 0] = "Init";
+  OpType[OpType["SetParentKey"] = 1] = "SetParentKey";
+  OpType[OpType["CreateList"] = 2] = "CreateList";
+  OpType[OpType["UpdateObject"] = 3] = "UpdateObject";
+  OpType[OpType["CreateObject"] = 4] = "CreateObject";
+  OpType[OpType["DeleteCrdt"] = 5] = "DeleteCrdt";
+  OpType[OpType["DeleteObjectKey"] = 6] = "DeleteObjectKey";
+  OpType[OpType["CreateMap"] = 7] = "CreateMap";
+  OpType[OpType["CreateRegister"] = 8] = "CreateRegister";
+})(exports.OpType || (exports.OpType = {}));
+
+exports.WebsocketCloseCodes = void 0;
+
+(function (WebsocketCloseCodes) {
+  WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
+  WebsocketCloseCodes[WebsocketCloseCodes["INVALID_MESSAGE_FORMAT"] = 4000] = "INVALID_MESSAGE_FORMAT";
+  WebsocketCloseCodes[WebsocketCloseCodes["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
+  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
+  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
+  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
+  WebsocketCloseCodes[WebsocketCloseCodes["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
+  WebsocketCloseCodes[WebsocketCloseCodes["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
+})(exports.WebsocketCloseCodes || (exports.WebsocketCloseCodes = {}));
+
+var AbstractCrdt = function () {
+  function AbstractCrdt() {}
+
+  var _proto = AbstractCrdt.prototype;
+
+  _proto._apply = function _apply(op, _isLocal) {
+    switch (op.type) {
+      case exports.OpType.DeleteCrdt:
+        {
+          if (this._parent != null && this._parentKey != null) {
+            return this._parent._detachChild(this);
+          }
+
+          return {
+            modified: false
+          };
+        }
+    }
+
+    return {
+      modified: false
+    };
+  };
+
+  _proto._setParentLink = function _setParentLink(parent, key) {
+    if (this.__parent != null && this.__parent !== parent) {
+      throw new Error("Cannot attach parent if it already exist");
+    }
+
+    this.__parentKey = key;
+    this.__parent = parent;
+  };
+
+  _proto._attach = function _attach(id, doc) {
+    if (this.__id || this.__doc) {
+      throw new Error("Cannot attach if CRDT is already attached");
+    }
+
+    doc.addItem(id, this);
+    this.__id = id;
+    this.__doc = doc;
+  };
+
+  _proto._detach = function _detach() {
+    if (this.__doc && this.__id) {
+      this.__doc.deleteItem(this.__id);
+    }
+
+    this.__parent = undefined;
+    this.__doc = undefined;
+  };
+
+  _createClass(AbstractCrdt, [{
+    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: "_parentKey",
+    get: function get() {
+      return this.__parentKey;
+    }
+  }]);
+
+  return AbstractCrdt;
+}();
+
+var min = 32;
+var max = 126;
+function makePosition(before, after) {
+  if (before == null && after == null) {
+    return pos([min + 1]);
+  }
+
+  if (before != null && after == null) {
+    return getNextPosition(before);
+  }
+
+  if (before == null && after != null) {
+    return getPreviousPosition(after);
+  }
+
+  return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
+}
+
+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 " + before + " and " + after);
+    }
+
+    if (beforeDigit === afterDigit) {
+      result.push(beforeDigit);
+      index++;
+      continue;
+    }
+
+    if (afterDigit - beforeDigit === 1) {
+      result.push(beforeDigit);
+      result.push.apply(result, 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) {
+  return String.fromCharCode.apply(String, codes);
+}
+function compare(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 \"" + posA + "\" and \"" + posB + "\"");
+}
+
+var LiveRegister = function (_AbstractCrdt) {
+  _inheritsLoose(LiveRegister, _AbstractCrdt);
+
+  function LiveRegister(data) {
+    var _this;
+
+    _this = _AbstractCrdt.call(this) || this;
+    _this._data = data;
+    return _this;
+  }
+
+  LiveRegister._deserialize = function _deserialize(_ref, _parentToChildren, doc) {
+    var id = _ref[0],
+        item = _ref[1];
+
+    if (item.type !== exports.CrdtType.Register) {
+      throw new Error("Tried to deserialize a map but item type is \"" + item.type + "\"");
+    }
+
+    var register = new LiveRegister(item.data);
+
+    register._attach(id, doc);
+
+    return register;
+  };
+
+  var _proto = LiveRegister.prototype;
+
+  _proto._serialize = function _serialize(parentId, parentKey, doc, intent) {
+    if (this._id == null || parentId == null || parentKey == null) {
+      throw new Error("Cannot serialize register if parentId or parentKey is undefined");
+    }
+
+    return [{
+      type: exports.OpType.CreateRegister,
+      opId: doc == null ? void 0 : doc.generateOpId(),
+      id: this._id,
+      intent: intent,
+      parentId: parentId,
+      parentKey: parentKey,
+      data: this.data
+    }];
+  };
+
+  _proto._toSerializedCrdt = function _toSerializedCrdt() {
+    var _this$_parent;
+
+    return {
+      type: exports.CrdtType.Register,
+      parentId: (_this$_parent = this._parent) == null ? void 0 : _this$_parent._id,
+      parentKey: this._parentKey,
+      data: this.data
+    };
+  };
+
+  _proto._attachChild = function _attachChild(_op, _isLocal) {
+    throw new Error("Method not implemented.");
+  };
+
+  _proto._detachChild = function _detachChild(_crdt) {
+    throw new Error("Method not implemented.");
+  };
+
+  _proto._apply = function _apply(op, isLocal) {
+    return _AbstractCrdt.prototype._apply.call(this, op, isLocal);
+  };
+
+  _createClass(LiveRegister, [{
+    key: "data",
+    get: function get() {
+      return this._data;
+    }
+  }]);
+
+  return LiveRegister;
+}(AbstractCrdt);
+
+var LiveList = function (_AbstractCrdt) {
+  _inheritsLoose(LiveList, _AbstractCrdt);
+
+  function LiveList(items) {
+    var _this;
+
+    if (items === void 0) {
+      items = [];
+    }
+
+    _this = _AbstractCrdt.call(this) || this;
+    _this._items = [];
+    var position = undefined;
+
+    for (var i = 0; i < items.length; i++) {
+      var newPosition = makePosition(position);
+
+      var _item = selfOrRegister(items[i]);
+
+      _this._items.push([_item, newPosition]);
+
+      position = newPosition;
+    }
+
+    return _this;
+  }
+
+  LiveList._deserialize = function _deserialize(_ref, parentToChildren, doc) {
+    var id = _ref[0];
+    var list = new LiveList([]);
+
+    list._attach(id, doc);
+
+    var children = parentToChildren.get(id);
+
+    if (children == null) {
+      return list;
+    }
+
+    for (var _iterator = _createForOfIteratorHelperLoose(children), _step; !(_step = _iterator()).done;) {
+      var entry = _step.value;
+      var child = deserialize(entry, parentToChildren, doc);
+
+      child._setParentLink(list, entry[1].parentKey);
+
+      list._items.push([child, entry[1].parentKey]);
+
+      list._items.sort(function (itemA, itemB) {
+        return compare(itemA[1], itemB[1]);
+      });
+    }
+
+    return list;
+  };
+
+  var _proto = LiveList.prototype;
+
+  _proto._serialize = function _serialize(parentId, parentKey, doc, intent) {
+    if (this._id == null) {
+      throw new Error("Cannot serialize item is not attached");
+    }
+
+    if (parentId == null || parentKey == null) {
+      throw new Error("Cannot serialize list if parentId or parentKey is undefined");
+    }
+
+    var ops = [];
+    var op = {
+      id: this._id,
+      opId: doc == null ? void 0 : doc.generateOpId(),
+      intent: intent,
+      type: exports.OpType.CreateList,
+      parentId: parentId,
+      parentKey: parentKey
+    };
+    ops.push(op);
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(this._items), _step2; !(_step2 = _iterator2()).done;) {
+      var _step2$value = _step2.value,
+          _value = _step2$value[0],
+          key = _step2$value[1];
+      ops.push.apply(ops, _value._serialize(this._id, key, doc));
+    }
+
+    return ops;
+  };
+
+  _proto._indexOfPosition = function _indexOfPosition(position) {
+    return this._items.findIndex(function (item) {
+      return item[1] === position;
+    });
+  };
+
+  _proto._attach = function _attach(id, doc) {
+    _AbstractCrdt.prototype._attach.call(this, id, doc);
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(this._items), _step3; !(_step3 = _iterator3()).done;) {
+      var _step3$value = _step3.value,
+          _item2 = _step3$value[0];
+
+      _item2._attach(doc.generateId(), doc);
+    }
+  };
+
+  _proto._detach = function _detach() {
+    _AbstractCrdt.prototype._detach.call(this);
+
+    for (var _iterator4 = _createForOfIteratorHelperLoose(this._items), _step4; !(_step4 = _iterator4()).done;) {
+      var _step4$value = _step4.value,
+          _value2 = _step4$value[0];
+
+      _value2._detach();
+    }
+  };
+
+  _proto._attachChild = function _attachChild(op, isLocal) {
+    if (this._doc == null) {
+      throw new Error("Can't attach child if doc is not present");
+    }
+
+    var id = op.id,
+        parentKey = op.parentKey,
+        intent = op.intent;
+    var key = parentKey;
+    var child = creationOpToLiveStructure(op);
+
+    if (this._doc.getItem(id) !== undefined) {
+      return {
+        modified: false
+      };
+    }
+
+    child._attach(id, this._doc);
+
+    child._setParentLink(this, key);
+
+    var index = this._items.findIndex(function (entry) {
+      return entry[1] === key;
+    });
+
+    var newKey = key;
+
+    if (index !== -1) {
+      if (intent === "set") {
+        var existingItem = this._items[index][0];
+
+        existingItem._detach();
+
+        var storageUpdate = {
+          node: this,
+          type: "LiveList",
+          updates: [{
+            index: index,
+            type: "set",
+            item: child instanceof LiveRegister ? child.data : child
+          }]
+        };
+        this._items[index][0] = child;
+        return {
+          modified: storageUpdate,
+          reverse: existingItem._serialize(this._id, key, this._doc, "set")
+        };
+      } else if (isLocal) {
+        var before = this._items[index] ? this._items[index][1] : undefined;
+        var after = this._items[index + 1] ? this._items[index + 1][1] : undefined;
+        newKey = makePosition(before, after);
+
+        child._setParentLink(this, newKey);
+      } else {
+        var _this$_items;
+
+        this._items[index][1] = makePosition(key, (_this$_items = this._items[index + 1]) == null ? void 0 : _this$_items[1]);
+      }
+    }
+
+    this._items.push([child, newKey]);
+
+    this._items.sort(function (itemA, itemB) {
+      return compare(itemA[1], itemB[1]);
+    });
+
+    var newIndex = this._items.findIndex(function (entry) {
+      return entry[1] === newKey;
+    });
+
+    return {
+      reverse: [{
+        type: exports.OpType.DeleteCrdt,
+        id: id
+      }],
+      modified: {
+        node: this,
+        type: "LiveList",
+        updates: [{
+          index: newIndex,
+          type: "insert",
+          item: child instanceof LiveRegister ? child.data : child
+        }]
+      }
+    };
+  };
+
+  _proto._detachChild = function _detachChild(child) {
+    if (child) {
+      var reverse = child._serialize(this._id, child._parentKey, this._doc);
+
+      var indexToDelete = this._items.findIndex(function (item) {
+        return item[0] === child;
+      });
+
+      this._items.splice(indexToDelete, 1);
+
+      child._detach();
+
+      var storageUpdate = {
+        node: this,
+        type: "LiveList",
+        updates: [{
+          index: indexToDelete,
+          type: "delete"
+        }]
+      };
+      return {
+        modified: storageUpdate,
+        reverse: reverse
+      };
+    }
+
+    return {
+      modified: false
+    };
+  };
+
+  _proto._setChildKey = function _setChildKey(key, child, previousKey) {
+    child._setParentLink(this, key);
+
+    var previousIndex = this._items.findIndex(function (entry) {
+      return entry[0]._id === child._id;
+    });
+
+    var index = this._items.findIndex(function (entry) {
+      return entry[1] === key;
+    });
+
+    if (index !== -1) {
+      var _this$_items2;
+
+      this._items[index][1] = makePosition(key, (_this$_items2 = this._items[index + 1]) == null ? void 0 : _this$_items2[1]);
+    }
+
+    var item = this._items.find(function (item) {
+      return item[0] === child;
+    });
+
+    if (item) {
+      item[1] = key;
+    }
+
+    this._items.sort(function (itemA, itemB) {
+      return compare(itemA[1], itemB[1]);
+    });
+
+    var newIndex = this._items.findIndex(function (entry) {
+      return entry[0]._id === child._id;
+    });
+
+    var updatesDelta = newIndex === previousIndex ? [] : [{
+      index: newIndex,
+      item: child instanceof LiveRegister ? child.data : child,
+      previousIndex: previousIndex,
+      type: "move"
+    }];
+    return {
+      modified: {
+        node: this,
+        type: "LiveList",
+        updates: updatesDelta
+      },
+      reverse: [{
+        type: exports.OpType.SetParentKey,
+        id: item == null ? void 0 : item[0]._id,
+        parentKey: previousKey
+      }]
+    };
+  };
+
+  _proto._apply = function _apply(op, isLocal) {
+    return _AbstractCrdt.prototype._apply.call(this, op, isLocal);
+  };
+
+  _proto._toSerializedCrdt = function _toSerializedCrdt() {
+    var _this$_parent;
+
+    return {
+      type: exports.CrdtType.List,
+      parentId: (_this$_parent = this._parent) == null ? void 0 : _this$_parent._id,
+      parentKey: this._parentKey
+    };
+  };
+
+  _proto.push = function push(element) {
+    return this.insert(element, this.length);
+  };
+
+  _proto.insert = function insert(element, index) {
+    if (index < 0 || index > this._items.length) {
+      throw new Error("Cannot insert list item at index \"\x1D" + index + "\". index should be between 0 and " + this._items.length);
+    }
+
+    var before = this._items[index - 1] ? this._items[index - 1][1] : undefined;
+    var after = this._items[index] ? this._items[index][1] : undefined;
+    var position = makePosition(before, after);
+    var value = selfOrRegister(element);
+
+    value._setParentLink(this, position);
+
+    this._items.push([value, position]);
+
+    this._items.sort(function (itemA, itemB) {
+      return compare(itemA[1], itemB[1]);
+    });
+
+    var newIndex = this._items.findIndex(function (entry) {
+      return entry[1] === position;
+    });
+
+    if (this._doc && this._id) {
+      var _id = this._doc.generateId();
+
+      value._attach(_id, this._doc);
+
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveList",
+        updates: [{
+          index: newIndex,
+          item: value instanceof LiveRegister ? value.data : value,
+          type: "insert"
+        }]
+      });
+
+      this._doc.dispatch(value._serialize(this._id, position, this._doc), [{
+        type: exports.OpType.DeleteCrdt,
+        id: _id
+      }], storageUpdates);
+    }
+  };
+
+  _proto.move = 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 ? undefined : this._items[targetIndex + 1][1];
+      beforePosition = this._items[targetIndex][1];
+    } else {
+      afterPosition = this._items[targetIndex][1];
+      beforePosition = targetIndex === 0 ? undefined : this._items[targetIndex - 1][1];
+    }
+
+    var position = makePosition(beforePosition, afterPosition);
+    var item = this._items[index];
+    var previousPosition = item[1];
+    item[1] = position;
+
+    item[0]._setParentLink(this, position);
+
+    this._items.sort(function (itemA, itemB) {
+      return compare(itemA[1], itemB[1]);
+    });
+
+    var newIndex = this._items.findIndex(function (entry) {
+      return entry[1] === position;
+    });
+
+    if (this._doc && this._id) {
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveList",
+        updates: [{
+          index: newIndex,
+          previousIndex: index,
+          item: item[0],
+          type: "move"
+        }]
+      });
+
+      this._doc.dispatch([{
+        type: exports.OpType.SetParentKey,
+        id: item[0]._id,
+        opId: this._doc.generateOpId(),
+        parentKey: position
+      }], [{
+        type: exports.OpType.SetParentKey,
+        id: item[0]._id,
+        parentKey: previousPosition
+      }], storageUpdates);
+    }
+  };
+
+  _proto.delete = function _delete(index) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error("Cannot delete list item at index \"\x1D" + index + "\". index should be between 0 and " + (this._items.length - 1));
+    }
+
+    var item = this._items[index];
+
+    item[0]._detach();
+
+    this._items.splice(index, 1);
+
+    if (this._doc) {
+      var childRecordId = item[0]._id;
+
+      if (childRecordId) {
+        var storageUpdates = new Map();
+        storageUpdates.set(this._id, {
+          node: this,
+          type: "LiveList",
+          updates: [{
+            index: index,
+            type: "delete"
+          }]
+        });
+
+        this._doc.dispatch([{
+          id: childRecordId,
+          opId: this._doc.generateOpId(),
+          type: exports.OpType.DeleteCrdt
+        }], item[0]._serialize(this._id, item[1]), storageUpdates);
+      }
+    }
+  };
+
+  _proto.clear = function clear() {
+    if (this._doc) {
+      var ops = [];
+      var reverseOps = [];
+      var updateDelta = [];
+      var i = 0;
+
+      for (var _iterator5 = _createForOfIteratorHelperLoose(this._items), _step5; !(_step5 = _iterator5()).done;) {
+        var _item3 = _step5.value;
+
+        _item3[0]._detach();
+
+        var childId = _item3[0]._id;
+
+        if (childId) {
+          ops.push({
+            id: childId,
+            type: exports.OpType.DeleteCrdt
+          });
+          reverseOps.push.apply(reverseOps, _item3[0]._serialize(this._id, _item3[1]));
+          updateDelta.push({
+            index: i,
+            type: "delete"
+          });
+        }
+
+        i++;
+      }
+
+      this._items = [];
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveList",
+        updates: updateDelta
+      });
+
+      this._doc.dispatch(ops, reverseOps, storageUpdates);
+    } else {
+      for (var _iterator6 = _createForOfIteratorHelperLoose(this._items), _step6; !(_step6 = _iterator6()).done;) {
+        var _item4 = _step6.value;
+
+        _item4[0]._detach();
+      }
+
+      this._items = [];
+    }
+  };
+
+  _proto.set = function set(index, item) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error("Cannot set list item at index \"\x1D" + index + "\". index should be between 0 and " + (this._items.length - 1));
+    }
+
+    var _this$_items$index = this._items[index],
+        existingItem = _this$_items$index[0],
+        position = _this$_items$index[1];
+
+    existingItem._detach();
+
+    var value = selfOrRegister(item);
+
+    value._setParentLink(this, position);
+
+    this._items[index][0] = value;
+
+    if (this._doc && this._id) {
+      var _id2 = this._doc.generateId();
+
+      value._attach(_id2, this._doc);
+
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveList",
+        updates: [{
+          index: index,
+          item: value instanceof LiveRegister ? value.data : value,
+          type: "set"
+        }]
+      });
+
+      this._doc.dispatch(value._serialize(this._id, position, this._doc, "set"), existingItem._serialize(this._id, position, undefined, "set"), storageUpdates);
+    }
+  };
+
+  _proto.toArray = function toArray() {
+    return this._items.map(function (entry) {
+      return selfOrRegisterValue(entry[0]);
+    });
+  };
+
+  _proto.every = function every(predicate) {
+    return this.toArray().every(predicate);
+  };
+
+  _proto.filter = function filter(predicate) {
+    return this.toArray().filter(predicate);
+  };
+
+  _proto.find = function find(predicate) {
+    return this.toArray().find(predicate);
+  };
+
+  _proto.findIndex = function findIndex(predicate) {
+    return this.toArray().findIndex(predicate);
+  };
+
+  _proto.forEach = function forEach(callbackfn) {
+    return this.toArray().forEach(callbackfn);
+  };
+
+  _proto.get = function get(index) {
+    if (index < 0 || index >= this._items.length) {
+      return undefined;
+    }
+
+    return selfOrRegisterValue(this._items[index][0]);
+  };
+
+  _proto.indexOf = function indexOf(searchElement, fromIndex) {
+    return this.toArray().indexOf(searchElement, fromIndex);
+  };
+
+  _proto.lastIndexOf = function lastIndexOf(searchElement, fromIndex) {
+    return this.toArray().lastIndexOf(searchElement, fromIndex);
+  };
+
+  _proto.map = function map(callback) {
+    return this._items.map(function (entry, i) {
+      return callback(selfOrRegisterValue(entry[0]), i);
+    });
+  };
+
+  _proto.some = function some(predicate) {
+    return this.toArray().some(predicate);
+  };
+
+  _proto[Symbol.iterator] = function () {
+    return new LiveListIterator(this._items);
+  };
+
+  _createClass(LiveList, [{
+    key: "length",
+    get: function get() {
+      return this._items.length;
+    }
+  }]);
+
+  return LiveList;
+}(AbstractCrdt);
+
+var LiveListIterator = function () {
+  function LiveListIterator(items) {
+    this._innerIterator = items[Symbol.iterator]();
+  }
+
+  var _proto2 = LiveListIterator.prototype;
+
+  _proto2[Symbol.iterator] = function () {
+    return this;
+  };
+
+  _proto2.next = function next() {
+    var result = this._innerIterator.next();
+
+    if (result.done) {
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+
+    return {
+      value: selfOrRegisterValue(result.value[0])
+    };
+  };
+
+  return LiveListIterator;
+}();
+
+var LiveMap = function (_AbstractCrdt) {
+  _inheritsLoose(LiveMap, _AbstractCrdt);
+
+  function LiveMap(entries) {
+    var _this;
+
+    _this = _AbstractCrdt.call(this) || this;
+
+    if (entries) {
+      var mappedEntries = [];
+
+      for (var _iterator = _createForOfIteratorHelperLoose(entries), _step; !(_step = _iterator()).done;) {
+        var entry = _step.value;
+
+        var _value = selfOrRegister(entry[1]);
+
+        _value._setParentLink(_assertThisInitialized(_this), entry[0]);
+
+        mappedEntries.push([entry[0], _value]);
+      }
+
+      _this._map = new Map(mappedEntries);
+    } else {
+      _this._map = new Map();
+    }
+
+    return _this;
+  }
+
+  var _proto = LiveMap.prototype;
+
+  _proto._serialize = function _serialize(parentId, parentKey, doc, intent) {
+    if (this._id == null) {
+      throw new Error("Cannot serialize item is not attached");
+    }
+
+    if (parentId == null || parentKey == null) {
+      throw new Error("Cannot serialize map if parentId or parentKey is undefined");
+    }
+
+    var ops = [];
+    var op = {
+      id: this._id,
+      opId: doc == null ? void 0 : doc.generateOpId(),
+      type: exports.OpType.CreateMap,
+      intent: intent,
+      parentId: parentId,
+      parentKey: parentKey
+    };
+    ops.push(op);
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(this._map), _step2; !(_step2 = _iterator2()).done;) {
+      var _step2$value = _step2.value,
+          _key2 = _step2$value[0],
+          _value2 = _step2$value[1];
+      ops.push.apply(ops, _value2._serialize(this._id, _key2, doc));
+    }
+
+    return ops;
+  };
+
+  LiveMap._deserialize = function _deserialize(_ref, parentToChildren, doc) {
+    var id = _ref[0],
+        item = _ref[1];
+
+    if (item.type !== exports.CrdtType.Map) {
+      throw new Error("Tried to deserialize a map but item type is \"" + item.type + "\"");
+    }
+
+    var map = new LiveMap();
+
+    map._attach(id, doc);
+
+    var children = parentToChildren.get(id);
+
+    if (children == null) {
+      return map;
+    }
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(children), _step3; !(_step3 = _iterator3()).done;) {
+      var entry = _step3.value;
+      var crdt = entry[1];
+
+      if (crdt.parentKey == null) {
+        throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+      }
+
+      var child = deserialize(entry, parentToChildren, doc);
+
+      child._setParentLink(map, crdt.parentKey);
+
+      map._map.set(crdt.parentKey, child);
+    }
+
+    return map;
+  };
+
+  _proto._attach = function _attach(id, doc) {
+    _AbstractCrdt.prototype._attach.call(this, id, doc);
+
+    for (var _iterator4 = _createForOfIteratorHelperLoose(this._map), _step4; !(_step4 = _iterator4()).done;) {
+      var _step4$value = _step4.value;
+          _step4$value[0];
+          var _value3 = _step4$value[1];
+
+      if (isCrdt(_value3)) {
+        _value3._attach(doc.generateId(), doc);
+      }
+    }
+  };
+
+  _proto._attachChild = function _attachChild(op, _isLocal) {
+    var _updates;
+
+    if (this._doc == null) {
+      throw new Error("Can't attach child if doc is not present");
+    }
+
+    var id = op.id,
+        parentKey = op.parentKey;
+    var key = parentKey;
+    var child = creationOpToLiveStructure(op);
+
+    if (this._doc.getItem(id) !== undefined) {
+      return {
+        modified: false
+      };
+    }
+
+    var previousValue = this._map.get(key);
+
+    var reverse;
+
+    if (previousValue) {
+      reverse = previousValue._serialize(this._id, key);
+
+      previousValue._detach();
+    } else {
+      reverse = [{
+        type: exports.OpType.DeleteCrdt,
+        id: id
+      }];
+    }
+
+    child._setParentLink(this, key);
+
+    child._attach(id, this._doc);
+
+    this._map.set(key, child);
+
+    return {
+      modified: {
+        node: this,
+        type: "LiveMap",
+        updates: (_updates = {}, _updates[key] = {
+          type: "update"
+        }, _updates)
+      },
+      reverse: reverse
+    };
+  };
+
+  _proto._detach = function _detach() {
+    _AbstractCrdt.prototype._detach.call(this);
+
+    for (var _iterator5 = _createForOfIteratorHelperLoose(this._map.values()), _step5; !(_step5 = _iterator5()).done;) {
+      var item = _step5.value;
+
+      item._detach();
+    }
+  };
+
+  _proto._detachChild = function _detachChild(child) {
+    var _updates2;
+
+    var reverse = child._serialize(this._id, child._parentKey, this._doc);
+
+    for (var _iterator6 = _createForOfIteratorHelperLoose(this._map), _step6; !(_step6 = _iterator6()).done;) {
+      var _step6$value = _step6.value,
+          _key3 = _step6$value[0],
+          _value4 = _step6$value[1];
+
+      if (_value4 === child) {
+        this._map.delete(_key3);
+      }
+    }
+
+    child._detach();
+
+    var storageUpdate = {
+      node: this,
+      type: "LiveMap",
+      updates: (_updates2 = {}, _updates2[child._parentKey] = {
+        type: "delete"
+      }, _updates2)
+    };
+    return {
+      modified: storageUpdate,
+      reverse: reverse
+    };
+  };
+
+  _proto._toSerializedCrdt = function _toSerializedCrdt() {
+    var _this$_parent;
+
+    return {
+      type: exports.CrdtType.Map,
+      parentId: (_this$_parent = this._parent) == null ? void 0 : _this$_parent._id,
+      parentKey: this._parentKey
+    };
+  };
+
+  _proto.get = function get(key) {
+    var value = this._map.get(key);
+
+    if (value == undefined) {
+      return undefined;
+    }
+
+    return selfOrRegisterValue(value);
+  };
+
+  _proto.set = function set(key, value) {
+    var oldValue = this._map.get(key);
+
+    if (oldValue) {
+      oldValue._detach();
+    }
+
+    var item = selfOrRegister(value);
+
+    item._setParentLink(this, key);
+
+    this._map.set(key, item);
+
+    if (this._doc && this._id) {
+      var _updates3;
+
+      var id = this._doc.generateId();
+
+      item._attach(id, this._doc);
+
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveMap",
+        updates: (_updates3 = {}, _updates3[key] = {
+          type: "update"
+        }, _updates3)
+      });
+
+      this._doc.dispatch(item._serialize(this._id, key, this._doc), oldValue ? oldValue._serialize(this._id, key) : [{
+        type: exports.OpType.DeleteCrdt,
+        id: id
+      }], storageUpdates);
+    }
+  };
+
+  _proto.has = function has(key) {
+    return this._map.has(key);
+  };
+
+  _proto.delete = 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 _updates4;
+
+      var storageUpdates = new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveMap",
+        updates: (_updates4 = {}, _updates4[key] = {
+          type: "delete"
+        }, _updates4)
+      });
+
+      this._doc.dispatch([{
+        type: exports.OpType.DeleteCrdt,
+        id: item._id,
+        opId: this._doc.generateOpId()
+      }], item._serialize(this._id, key), storageUpdates);
+    }
+
+    return true;
+  };
+
+  _proto.entries = function entries() {
+    var _ref2;
+
+    var innerIterator = this._map.entries();
+
+    return _ref2 = {}, _ref2[Symbol.iterator] = function () {
+      return this;
+    }, _ref2.next = function next() {
+      var iteratorValue = innerIterator.next();
+
+      if (iteratorValue.done) {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+
+      var entry = iteratorValue.value;
+      return {
+        value: [entry[0], selfOrRegisterValue(iteratorValue.value[1])]
+      };
+    }, _ref2;
+  };
+
+  _proto[Symbol.iterator] = function () {
+    return this.entries();
+  };
+
+  _proto.keys = function keys() {
+    return this._map.keys();
+  };
+
+  _proto.values = function values() {
+    var _ref3;
+
+    var innerIterator = this._map.values();
+
+    return _ref3 = {}, _ref3[Symbol.iterator] = function () {
+      return this;
+    }, _ref3.next = function next() {
+      var iteratorValue = innerIterator.next();
+
+      if (iteratorValue.done) {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+
+      return {
+        value: selfOrRegisterValue(iteratorValue.value)
+      };
+    }, _ref3;
+  };
+
+  _proto.forEach = function forEach(callback) {
+    for (var _iterator7 = _createForOfIteratorHelperLoose(this), _step7; !(_step7 = _iterator7()).done;) {
+      var entry = _step7.value;
+      callback(entry[1], entry[0], this);
+    }
+  };
+
+  _createClass(LiveMap, [{
+    key: "size",
+    get: function get() {
+      return this._map.size;
+    }
+  }]);
+
+  return LiveMap;
+}(AbstractCrdt);
+
+function parseJson(rawMessage) {
+  try {
+    return JSON.parse(rawMessage);
+  } catch (e) {
+    return undefined;
+  }
+}
+function isJsonArray(data) {
+  return Array.isArray(data);
+}
+function isJsonObject(data) {
+  return data !== null && typeof data === "object" && !isJsonArray(data);
+}
+
+var _emittedDeprecationWarnings = new Set();
+
+function deprecate(message, key) {
+  if (key === void 0) {
+    key = message;
+  }
+
+  if (process.env.NODE_ENV !== "production") {
+    if (!_emittedDeprecationWarnings.has(key)) {
+      _emittedDeprecationWarnings.add(key);
+
+      console.warn("DEPRECATION WARNING: " + message);
+    }
+  }
+}
+function deprecateIf(condition, message, key) {
+  if (key === void 0) {
+    key = message;
+  }
+
+  if (process.env.NODE_ENV !== "production") {
+    if (condition) {
+      deprecate(message, key);
+    }
+  }
+}
+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 creationOpToLiveStructure(op) {
+  switch (op.type) {
+    case exports.OpType.CreateRegister:
+      return new LiveRegister(op.data);
+
+    case exports.OpType.CreateObject:
+      return new LiveObject(op.data);
+
+    case exports.OpType.CreateMap:
+      return new LiveMap();
+
+    case exports.OpType.CreateList:
+      return new LiveList();
+  }
+}
+function isSameNodeOrChildOf(node, parent) {
+  if (node === parent) {
+    return true;
+  }
+
+  if (node._parent) {
+    return isSameNodeOrChildOf(node._parent, parent);
+  }
+
+  return false;
+}
+function deserialize(entry, parentToChildren, doc) {
+  switch (entry[1].type) {
+    case exports.CrdtType.Object:
+      {
+        return LiveObject._deserialize(entry, parentToChildren, doc);
+      }
+
+    case exports.CrdtType.List:
+      {
+        return LiveList._deserialize(entry, parentToChildren, doc);
+      }
+
+    case exports.CrdtType.Map:
+      {
+        return LiveMap._deserialize(entry, parentToChildren, doc);
+      }
+
+    case exports.CrdtType.Register:
+      {
+        return LiveRegister._deserialize(entry, parentToChildren, doc);
+      }
+
+    default:
+      {
+        throw new Error("Unexpected CRDT type");
+      }
+  }
+}
+function isCrdt(obj) {
+  return obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList || obj instanceof LiveRegister;
+}
+function selfOrRegisterValue(obj) {
+  if (obj instanceof LiveRegister) {
+    return obj.data;
+  }
+
+  return obj;
+}
+function selfOrRegister(obj) {
+  if (obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList) {
+    return obj;
+  } else if (obj instanceof LiveRegister) {
+    throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
+  } else {
+    return new LiveRegister(obj);
+  }
+}
+function getTreesDiffOperations(currentItems, newItems) {
+  var ops = [];
+  currentItems.forEach(function (_, id) {
+    if (!newItems.get(id)) {
+      ops.push({
+        type: exports.OpType.DeleteCrdt,
+        id: id
+      });
+    }
+  });
+  newItems.forEach(function (crdt, id) {
+    var currentCrdt = currentItems.get(id);
+
+    if (currentCrdt) {
+      if (crdt.type === exports.CrdtType.Object) {
+        if (JSON.stringify(crdt.data) !== JSON.stringify(currentCrdt.data)) {
+          ops.push({
+            type: exports.OpType.UpdateObject,
+            id: id,
+            data: crdt.data
+          });
+        }
+      }
+
+      if (crdt.parentKey !== currentCrdt.parentKey) {
+        ops.push({
+          type: exports.OpType.SetParentKey,
+          id: id,
+          parentKey: crdt.parentKey
+        });
+      }
+    } else {
+      switch (crdt.type) {
+        case exports.CrdtType.Register:
+          ops.push({
+            type: exports.OpType.CreateRegister,
+            id: id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey,
+            data: crdt.data
+          });
+          break;
+
+        case exports.CrdtType.List:
+          ops.push({
+            type: exports.OpType.CreateList,
+            id: id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey
+          });
+          break;
+
+        case exports.CrdtType.Object:
+          ops.push({
+            type: exports.OpType.CreateObject,
+            id: id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey,
+            data: crdt.data
+          });
+          break;
+
+        case exports.CrdtType.Map:
+          ops.push({
+            type: exports.OpType.CreateMap,
+            id: id,
+            parentId: crdt.parentId,
+            parentKey: crdt.parentKey
+          });
+          break;
+      }
+    }
+  });
+  return ops;
+}
+
+function mergeObjectStorageUpdates(first, second) {
+  var updates = first.updates;
+
+  for (var _iterator = _createForOfIteratorHelperLoose(entries(second.updates)), _step; !(_step = _iterator()).done;) {
+    var _step$value = _step.value,
+        _key = _step$value[0],
+        value = _step$value[1];
+    updates[_key] = value;
+  }
+
+  return _extends({}, second, {
+    updates: updates
+  });
+}
+
+function mergeMapStorageUpdates(first, second) {
+  var updates = first.updates;
+
+  for (var _iterator2 = _createForOfIteratorHelperLoose(entries(second.updates)), _step2; !(_step2 = _iterator2()).done;) {
+    var _step2$value = _step2.value,
+        _key2 = _step2$value[0],
+        value = _step2$value[1];
+    updates[_key2] = value;
+  }
+
+  return _extends({}, second, {
+    updates: updates
+  });
+}
+
+function mergeListStorageUpdates(first, second) {
+  var updates = first.updates;
+  return _extends({}, 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;
+  return type === "undefined" || value === null || type === "string" || type === "boolean" || type === "number" || Array.isArray(value) || isPlainObject(value);
+}
+
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  var proto = Object.getPrototypeOf(value);
+  if (proto === null) return true;
+  var baseProto = proto;
+
+  while (Object.getPrototypeOf(baseProto) !== null) {
+    baseProto = Object.getPrototypeOf(baseProto);
+  }
+
+  return proto === baseProto;
+}
+
+function findNonSerializableValue(value, path) {
+  if (path === void 0) {
+    path = "";
+  }
+
+  if (!isPlain) {
+    return {
+      path: path || "root",
+      value: value
+    };
+  }
+
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  for (var _i = 0, _Object$entries = Object.entries(value); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _Object$entries[_i],
+        _key3 = _Object$entries$_i[0],
+        nestedValue = _Object$entries$_i[1];
+    var nestedPath = path ? path + "." + _key3 : _key3;
+
+    if (!isPlain(nestedValue)) {
+      return {
+        path: nestedPath,
+        value: nestedValue
+      };
+    }
+
+    if (typeof nestedValue === "object") {
+      var nonSerializableNestedValue = findNonSerializableValue(nestedValue, nestedPath);
+
+      if (nonSerializableNestedValue) {
+        return nonSerializableNestedValue;
+      }
+    }
+  }
+
+  return false;
+}
+function isTokenValid(token) {
+  var tokenParts = token.split(".");
+
+  if (tokenParts.length !== 3) {
+    return false;
+  }
+
+  var data = parseJson(atob(tokenParts[1]));
+
+  if (data === undefined || !isJsonObject(data) || typeof data.exp !== "number") {
+    return false;
+  }
+
+  var now = Date.now();
+
+  if (now / 1000 > data.exp - 300) {
+    return false;
+  }
+
+  return true;
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+
+var LiveObject = function (_AbstractCrdt) {
+  _inheritsLoose(LiveObject, _AbstractCrdt);
+
+  function LiveObject(object) {
+    var _this;
+
+    if (object === void 0) {
+      object = {};
+    }
+
+    _this = _AbstractCrdt.call(this) || this;
+    _this._propToLastUpdate = new Map();
+
+    for (var key in object) {
+      var value = object[key];
+
+      if (value instanceof AbstractCrdt) {
+        value._setParentLink(_assertThisInitialized(_this), key);
+      }
+    }
+
+    _this._map = new Map(Object.entries(object));
+    return _this;
+  }
+
+  var _proto = LiveObject.prototype;
+
+  _proto._serialize = function _serialize(parentId, parentKey, doc, intent) {
+    if (this._id == null) {
+      throw new Error("Cannot serialize item is not attached");
+    }
+
+    var ops = [];
+    var op = {
+      id: this._id,
+      opId: doc == null ? void 0 : doc.generateOpId(),
+      intent: intent,
+      type: exports.OpType.CreateObject,
+      parentId: parentId,
+      parentKey: parentKey,
+      data: {}
+    };
+    ops.push(op);
+
+    for (var _iterator = _createForOfIteratorHelperLoose(this._map), _step; !(_step = _iterator()).done;) {
+      var _step$value = _step.value,
+          key = _step$value[0],
+          value = _step$value[1];
+
+      if (value instanceof AbstractCrdt) {
+        ops.push.apply(ops, value._serialize(this._id, key, doc));
+      } else {
+        op.data[key] = value;
+      }
+    }
+
+    return ops;
+  };
+
+  LiveObject._deserialize = function _deserialize(_ref, parentToChildren, doc) {
+    var id = _ref[0],
+        item = _ref[1];
+
+    if (item.type !== exports.CrdtType.Object) {
+      throw new Error("Tried to deserialize a record but item type is \"" + item.type + "\"");
+    }
+
+    var object = new LiveObject(item.data);
+
+    object._attach(id, doc);
+
+    return this._deserializeChildren(object, parentToChildren, doc);
+  };
+
+  LiveObject._deserializeChildren = function _deserializeChildren(object, parentToChildren, doc) {
+    var children = parentToChildren.get(object._id);
+
+    if (children == null) {
+      return object;
+    }
+
+    for (var _iterator2 = _createForOfIteratorHelperLoose(children), _step2; !(_step2 = _iterator2()).done;) {
+      var entry = _step2.value;
+      var crdt = entry[1];
+
+      if (crdt.parentKey == null) {
+        throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
+      }
+
+      var child = deserialize(entry, parentToChildren, doc);
+
+      child._setParentLink(object, crdt.parentKey);
+
+      object._map.set(crdt.parentKey, child);
+    }
+
+    return object;
+  };
+
+  _proto._attach = function _attach(id, doc) {
+    _AbstractCrdt.prototype._attach.call(this, id, doc);
+
+    for (var _iterator3 = _createForOfIteratorHelperLoose(this._map), _step3; !(_step3 = _iterator3()).done;) {
+      var _step3$value = _step3.value;
+          _step3$value[0];
+          var value = _step3$value[1];
+
+      if (value instanceof AbstractCrdt) {
+        value._attach(doc.generateId(), doc);
+      }
+    }
+  };
+
+  _proto._attachChild = function _attachChild(op, isLocal) {
+    var _updates;
+
+    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 = creationOpToLiveStructure(op);
+
+    if (this._doc.getItem(id) !== undefined) {
+      if (this._propToLastUpdate.get(key) === opId) {
+        this._propToLastUpdate.delete(key);
+      }
+
+      return {
+        modified: false
+      };
+    }
+
+    if (isLocal) {
+      this._propToLastUpdate.set(key, opId);
+    } else if (this._propToLastUpdate.get(key) === undefined) ; else if (this._propToLastUpdate.get(key) === opId) {
+      this._propToLastUpdate.delete(key);
+
+      return {
+        modified: false
+      };
+    } else {
+      return {
+        modified: false
+      };
+    }
+
+    var previousValue = this._map.get(key);
+
+    var reverse;
+
+    if (isCrdt(previousValue)) {
+      reverse = previousValue._serialize(this._id, key);
+
+      previousValue._detach();
+    } else if (previousValue === undefined) {
+      reverse = [{
+        type: exports.OpType.DeleteObjectKey,
+        id: this._id,
+        key: key
+      }];
+    } else {
+      var _data;
+
+      reverse = [{
+        type: exports.OpType.UpdateObject,
+        id: this._id,
+        data: (_data = {}, _data[key] = previousValue, _data)
+      }];
+    }
+
+    this._map.set(key, child);
+
+    child._setParentLink(this, key);
+
+    child._attach(id, this._doc);
+
+    return {
+      reverse: reverse,
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: (_updates = {}, _updates[key] = {
+          type: "update"
+        }, _updates)
+      }
+    };
+  };
+
+  _proto._detachChild = function _detachChild(child) {
+    if (child) {
+      var _updates2;
+
+      var reverse = child._serialize(this._id, child._parentKey, this._doc);
+
+      for (var _iterator4 = _createForOfIteratorHelperLoose(this._map), _step4; !(_step4 = _iterator4()).done;) {
+        var _step4$value = _step4.value,
+            key = _step4$value[0],
+            value = _step4$value[1];
+
+        if (value === child) {
+          this._map.delete(key);
+        }
+      }
+
+      child._detach();
+
+      var storageUpdate = {
+        node: this,
+        type: "LiveObject",
+        updates: (_updates2 = {}, _updates2[child._parentKey] = {
+          type: "delete"
+        }, _updates2)
+      };
+      return {
+        modified: storageUpdate,
+        reverse: reverse
+      };
+    }
+
+    return {
+      modified: false
+    };
+  };
+
+  _proto._detachChildren = function _detachChildren() {
+    for (var _iterator5 = _createForOfIteratorHelperLoose(this._map), _step5; !(_step5 = _iterator5()).done;) {
+      var _step5$value = _step5.value,
+          key = _step5$value[0],
+          value = _step5$value[1];
+
+      this._map.delete(key);
+
+      value._detach();
+    }
+  };
+
+  _proto._detach = function _detach() {
+    _AbstractCrdt.prototype._detach.call(this);
+
+    for (var _iterator6 = _createForOfIteratorHelperLoose(this._map.values()), _step6; !(_step6 = _iterator6()).done;) {
+      var value = _step6.value;
+
+      if (isCrdt(value)) {
+        value._detach();
+      }
+    }
+  };
+
+  _proto._apply = function _apply(op, isLocal) {
+    if (op.type === exports.OpType.UpdateObject) {
+      return this._applyUpdate(op, isLocal);
+    } else if (op.type === exports.OpType.DeleteObjectKey) {
+      return this._applyDeleteObjectKey(op);
+    }
+
+    return _AbstractCrdt.prototype._apply.call(this, op, isLocal);
+  };
+
+  _proto._toSerializedCrdt = function _toSerializedCrdt() {
+    var _this$_parent;
+
+    var data = {};
+
+    for (var _iterator7 = _createForOfIteratorHelperLoose(this._map), _step7; !(_step7 = _iterator7()).done;) {
+      var _step7$value = _step7.value,
+          key = _step7$value[0],
+          value = _step7$value[1];
+
+      if (value instanceof AbstractCrdt === false) {
+        data[key] = value;
+      }
+    }
+
+    return {
+      type: exports.CrdtType.Object,
+      parentId: (_this$_parent = this._parent) == null ? void 0 : _this$_parent._id,
+      parentKey: this._parentKey,
+      data: data
+    };
+  };
+
+  _proto._applyUpdate = function _applyUpdate(op, isLocal) {
+    var isModified = false;
+    var reverse = [];
+    var reverseUpdate = {
+      type: exports.OpType.UpdateObject,
+      id: this._id,
+      data: {}
+    };
+    reverse.push(reverseUpdate);
+
+    for (var key in op.data) {
+      var oldValue = this._map.get(key);
+
+      if (oldValue instanceof AbstractCrdt) {
+        reverse.push.apply(reverse, oldValue._serialize(this._id, key));
+
+        oldValue._detach();
+      } else if (oldValue !== undefined) {
+        reverseUpdate.data[key] = oldValue;
+      } else if (oldValue === undefined) {
+        reverse.push({
+          type: exports.OpType.DeleteObjectKey,
+          id: this._id,
+          key: key
+        });
+      }
+    }
+
+    var updateDelta = {};
+
+    for (var _key2 in op.data) {
+      if (isLocal) {
+        this._propToLastUpdate.set(_key2, op.opId);
+      } else if (this._propToLastUpdate.get(_key2) == null) {
+        isModified = true;
+      } else if (this._propToLastUpdate.get(_key2) === op.opId) {
+        this._propToLastUpdate.delete(_key2);
+
+        continue;
+      } else {
+        continue;
+      }
+
+      var _oldValue = this._map.get(_key2);
+
+      if (isCrdt(_oldValue)) {
+        _oldValue._detach();
+      }
+
+      isModified = true;
+      updateDelta[_key2] = {
+        type: "update"
+      };
+
+      this._map.set(_key2, op.data[_key2]);
+    }
+
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+      reverse.unshift(reverseUpdate);
+    }
+
+    return isModified ? {
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: updateDelta
+      },
+      reverse: reverse
+    } : {
+      modified: false
+    };
+  };
+
+  _proto._applyDeleteObjectKey = function _applyDeleteObjectKey(op) {
+    var _updates3;
+
+    var key = op.key;
+
+    if (this._map.has(key) === false) {
+      return {
+        modified: false
+      };
+    }
+
+    if (this._propToLastUpdate.get(key) !== undefined) {
+      return {
+        modified: false
+      };
+    }
+
+    var oldValue = this._map.get(key);
+
+    var reverse = [];
+
+    if (isCrdt(oldValue)) {
+      reverse = oldValue._serialize(this._id, op.key);
+
+      oldValue._detach();
+    } else if (oldValue !== undefined) {
+      var _data2;
+
+      reverse = [{
+        type: exports.OpType.UpdateObject,
+        id: this._id,
+        data: (_data2 = {}, _data2[key] = oldValue, _data2)
+      }];
+    }
+
+    this._map.delete(key);
+
+    return {
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: (_updates3 = {}, _updates3[op.key] = {
+          type: "delete"
+        }, _updates3)
+      },
+      reverse: reverse
+    };
+  };
+
+  _proto.toObject = function toObject() {
+    return Object.fromEntries(this._map);
+  };
+
+  _proto.set = function set(key, value) {
+    var _this$update;
+
+    this.update((_this$update = {}, _this$update[key] = value, _this$update));
+  };
+
+  _proto.get = function get(key) {
+    return this._map.get(key);
+  };
+
+  _proto.delete = function _delete(key) {
+    var _updates4;
+
+    var keyAsString = key;
+
+    var oldValue = this._map.get(keyAsString);
+
+    if (oldValue === undefined) {
+      return;
+    }
+
+    if (this._doc == null || this._id == null) {
+      if (oldValue instanceof AbstractCrdt) {
+        oldValue._detach();
+      }
+
+      this._map.delete(keyAsString);
+
+      return;
+    }
+
+    var reverse;
+
+    if (oldValue instanceof AbstractCrdt) {
+      oldValue._detach();
+
+      reverse = oldValue._serialize(this._id, keyAsString);
+    } else {
+      var _data3;
+
+      reverse = [{
+        type: exports.OpType.UpdateObject,
+        data: (_data3 = {}, _data3[keyAsString] = oldValue, _data3),
+        id: this._id
+      }];
+    }
+
+    this._map.delete(keyAsString);
+
+    var storageUpdates = new Map();
+    storageUpdates.set(this._id, {
+      node: this,
+      type: "LiveObject",
+      updates: (_updates4 = {}, _updates4[key] = {
+        type: "delete"
+      }, _updates4)
+    });
+
+    this._doc.dispatch([{
+      type: exports.OpType.DeleteObjectKey,
+      key: keyAsString,
+      id: this._id,
+      opId: this._doc.generateOpId()
+    }], reverse, storageUpdates);
+  };
+
+  _proto.update = function update(overrides) {
+    var _this2 = this;
+
+    if (this._doc == null || this._id == null) {
+      for (var key in overrides) {
+        var oldValue = this._map.get(key);
+
+        if (oldValue instanceof AbstractCrdt) {
+          oldValue._detach();
+        }
+
+        var newValue = overrides[key];
+
+        if (newValue instanceof AbstractCrdt) {
+          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: exports.OpType.UpdateObject,
+      data: {}
+    };
+    var updateDelta = {};
+
+    for (var _key3 in overrides) {
+      var _oldValue2 = this._map.get(_key3);
+
+      if (_oldValue2 instanceof AbstractCrdt) {
+        reverseOps.push.apply(reverseOps, _oldValue2._serialize(this._id, _key3));
+
+        _oldValue2._detach();
+      } else if (_oldValue2 === undefined) {
+        reverseOps.push({
+          type: exports.OpType.DeleteObjectKey,
+          id: this._id,
+          key: _key3
+        });
+      } else {
+        reverseUpdateOp.data[_key3] = _oldValue2;
+      }
+
+      var _newValue = overrides[_key3];
+
+      if (_newValue instanceof AbstractCrdt) {
+        _newValue._setParentLink(this, _key3);
+
+        _newValue._attach(this._doc.generateId(), this._doc);
+
+        var newAttachChildOps = _newValue._serialize(this._id, _key3, this._doc);
+
+        var createCrdtOp = newAttachChildOps.find(function (op) {
+          return op.parentId === _this2._id;
+        });
+
+        if (createCrdtOp) {
+          this._propToLastUpdate.set(_key3, createCrdtOp.opId);
+        }
+
+        ops.push.apply(ops, newAttachChildOps);
+      } else {
+        updatedProps[_key3] = _newValue;
+
+        this._propToLastUpdate.set(_key3, opId);
+      }
+
+      this._map.set(_key3, _newValue);
+
+      updateDelta[_key3] = {
+        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: exports.OpType.UpdateObject,
+        data: updatedProps
+      });
+    }
+
+    var storageUpdates = new Map();
+    storageUpdates.set(this._id, {
+      node: this,
+      type: "LiveObject",
+      updates: updateDelta
+    });
+
+    this._doc.dispatch(ops, reverseOps, storageUpdates);
+  };
+
+  return LiveObject;
+}(AbstractCrdt);
+
+exports.AbstractCrdt = AbstractCrdt;
+exports.LiveList = LiveList;
+exports.LiveMap = LiveMap;
+exports.LiveObject = LiveObject;
+exports.LiveRegister = LiveRegister;
+exports._createForOfIteratorHelperLoose = _createForOfIteratorHelperLoose;
+exports._extends = _extends;
+exports._inheritsLoose = _inheritsLoose;
+exports._objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose;
+exports._wrapNativeSuper = _wrapNativeSuper;
+exports.compact = compact;
+exports.compare = compare;
+exports.deprecate = deprecate;
+exports.deprecateIf = deprecateIf;
+exports.findNonSerializableValue = findNonSerializableValue;
+exports.getTreesDiffOperations = getTreesDiffOperations;
+exports.isJsonArray = isJsonArray;
+exports.isJsonObject = isJsonObject;
+exports.isSameNodeOrChildOf = isSameNodeOrChildOf;
+exports.isTokenValid = isTokenValid;
+exports.makePosition = makePosition;
+exports.max = max;
+exports.mergeStorageUpdates = mergeStorageUpdates;
+exports.min = min;
+exports.parseJson = parseJson;
+exports.pos = pos;
+exports.posCodes = posCodes;
+exports.remove = remove;