@liveblocks/client 0.16.13 → 0.16.16

package/shared.js

@@ -122,141 +122,52 @@ function _createForOfIteratorHelperLoose(o, allowArrayLike) {
  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
-var ClientMsgCode, OpCode, CrdtType, ServerMsgCode, WebsocketCloseCodes, OpSource, _emittedDeprecationWarnings = new Set;
-
-function deprecate(message, key) {
- void 0 === key && (key = message), "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
- console.error("DEPRECATION WARNING: " + message)));
-}
-
-function throwUsageError(message) {
- if ("production" !== process.env.NODE_ENV) {
-  var usageError = new Error(message);
-  throw usageError.name = "Usage error", usageError;
- }
-}
-
-function errorIf(condition, message) {
- "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
-}
-
-function assertNever(_value, errmsg) {
- throw new Error(errmsg);
-}
-
-function nn(value, errmsg) {
- return void 0 === errmsg && (errmsg = "Expected value to be non-nullable"), function(condition, errmsg) {
-  if ("production" !== process.env.NODE_ENV && !condition) {
-   var err = new Error(errmsg);
-   throw err.name = "Assertion failure", err;
-  }
- }(null != value, errmsg), value;
-}
+var ServerMsgCode, ClientMsgCode, CrdtType, OpCode, WebsocketCloseCodes;
 
 function isChildCrdt(crdt) {
  return void 0 !== crdt.parentId && void 0 !== crdt.parentKey;
 }
 
-function HasParent(node, key) {
- return Object.freeze({
-  type: "HasParent",
-  node: node,
-  key: key
- });
-}
-
-exports.ClientMsgCode = void 0, (ClientMsgCode = exports.ClientMsgCode || (exports.ClientMsgCode = {}))[ClientMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", 
-ClientMsgCode[ClientMsgCode.BROADCAST_EVENT = 103] = "BROADCAST_EVENT", ClientMsgCode[ClientMsgCode.FETCH_STORAGE = 200] = "FETCH_STORAGE", 
-ClientMsgCode[ClientMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE", exports.OpCode = void 0, 
-(OpCode = exports.OpCode || (exports.OpCode = {}))[OpCode.INIT = 0] = "INIT", OpCode[OpCode.SET_PARENT_KEY = 1] = "SET_PARENT_KEY", 
-OpCode[OpCode.CREATE_LIST = 2] = "CREATE_LIST", OpCode[OpCode.UPDATE_OBJECT = 3] = "UPDATE_OBJECT", 
-OpCode[OpCode.CREATE_OBJECT = 4] = "CREATE_OBJECT", OpCode[OpCode.DELETE_CRDT = 5] = "DELETE_CRDT", 
-OpCode[OpCode.DELETE_OBJECT_KEY = 6] = "DELETE_OBJECT_KEY", OpCode[OpCode.CREATE_MAP = 7] = "CREATE_MAP", 
-OpCode[OpCode.CREATE_REGISTER = 8] = "CREATE_REGISTER", exports.CrdtType = void 0, 
-(CrdtType = exports.CrdtType || (exports.CrdtType = {}))[CrdtType.OBJECT = 0] = "OBJECT", 
-CrdtType[CrdtType.LIST = 1] = "LIST", CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER", 
 exports.ServerMsgCode = void 0, (ServerMsgCode = exports.ServerMsgCode || (exports.ServerMsgCode = {}))[ServerMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", 
 ServerMsgCode[ServerMsgCode.USER_JOINED = 101] = "USER_JOINED", ServerMsgCode[ServerMsgCode.USER_LEFT = 102] = "USER_LEFT", 
 ServerMsgCode[ServerMsgCode.BROADCASTED_EVENT = 103] = "BROADCASTED_EVENT", ServerMsgCode[ServerMsgCode.ROOM_STATE = 104] = "ROOM_STATE", 
 ServerMsgCode[ServerMsgCode.INITIAL_STORAGE_STATE = 200] = "INITIAL_STORAGE_STATE", 
-ServerMsgCode[ServerMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE", exports.WebsocketCloseCodes = void 0, 
-(WebsocketCloseCodes = exports.WebsocketCloseCodes || (exports.WebsocketCloseCodes = {}))[WebsocketCloseCodes.CLOSE_ABNORMAL = 1006] = "CLOSE_ABNORMAL", 
+ServerMsgCode[ServerMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE", exports.ClientMsgCode = void 0, 
+(ClientMsgCode = exports.ClientMsgCode || (exports.ClientMsgCode = {}))[ClientMsgCode.UPDATE_PRESENCE = 100] = "UPDATE_PRESENCE", 
+ClientMsgCode[ClientMsgCode.BROADCAST_EVENT = 103] = "BROADCAST_EVENT", ClientMsgCode[ClientMsgCode.FETCH_STORAGE = 200] = "FETCH_STORAGE", 
+ClientMsgCode[ClientMsgCode.UPDATE_STORAGE = 201] = "UPDATE_STORAGE", exports.CrdtType = void 0, 
+(CrdtType = exports.CrdtType || (exports.CrdtType = {}))[CrdtType.OBJECT = 0] = "OBJECT", 
+CrdtType[CrdtType.LIST = 1] = "LIST", CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER", 
+exports.OpCode = void 0, (OpCode = exports.OpCode || (exports.OpCode = {}))[OpCode.INIT = 0] = "INIT", 
+OpCode[OpCode.SET_PARENT_KEY = 1] = "SET_PARENT_KEY", OpCode[OpCode.CREATE_LIST = 2] = "CREATE_LIST", 
+OpCode[OpCode.UPDATE_OBJECT = 3] = "UPDATE_OBJECT", OpCode[OpCode.CREATE_OBJECT = 4] = "CREATE_OBJECT", 
+OpCode[OpCode.DELETE_CRDT = 5] = "DELETE_CRDT", OpCode[OpCode.DELETE_OBJECT_KEY = 6] = "DELETE_OBJECT_KEY", 
+OpCode[OpCode.CREATE_MAP = 7] = "CREATE_MAP", OpCode[OpCode.CREATE_REGISTER = 8] = "CREATE_REGISTER", 
+exports.WebsocketCloseCodes = void 0, (WebsocketCloseCodes = exports.WebsocketCloseCodes || (exports.WebsocketCloseCodes = {}))[WebsocketCloseCodes.CLOSE_ABNORMAL = 1006] = "CLOSE_ABNORMAL", 
 WebsocketCloseCodes[WebsocketCloseCodes.INVALID_MESSAGE_FORMAT = 4e3] = "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.OpSource = void 0, (OpSource = exports.OpSource || (exports.OpSource = {}))[OpSource.UNDOREDO_RECONNECT = 0] = "UNDOREDO_RECONNECT", 
-OpSource[OpSource.REMOTE = 1] = "REMOTE", OpSource[OpSource.ACK = 2] = "ACK";
-
-var NoParent = Object.freeze({
- type: "NoParent"
-});
-
-function Orphaned(oldKey) {
- return Object.freeze({
-  type: "Orphaned",
-  oldKey: oldKey
- });
-}
+WebsocketCloseCodes[WebsocketCloseCodes.CLOSE_WITHOUT_RETRY = 4999] = "CLOSE_WITHOUT_RETRY";
 
-var _Symbol$iterator$1, _Symbol$iterator2, AbstractCrdt = function() {
+var AbstractCrdt = function() {
  function AbstractCrdt() {
-  this.__doc = void 0, this.__id = void 0, this._parent = NoParent;
+  this.__parent = void 0, this.__doc = void 0, this.__id = void 0, this.__parentKey = void 0;
  }
  var _proto = AbstractCrdt.prototype;
- return _proto._getParentKeyOrThrow = function() {
-  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");
-  }
- }, _proto._apply = function(op, _isLocal) {
-  return op.type === exports.OpCode.DELETE_CRDT && "HasParent" === this.parent.type ? this.parent.node._detachChild(this) : {
+ return _proto._apply = function(op, _isLocal) {
+  return op.type === exports.OpCode.DELETE_CRDT && null != this._parent && null != this._parentKey ? this._parent._detachChild(this) : {
    modified: !1
   };
- }, _proto._setParentLink = function(newParentNode, newParentKey) {
-  switch (this.parent.type) {
-  case "HasParent":
-   if (this.parent.node !== newParentNode) throw new Error("Cannot attach parent if it already exist");
-   return void (this._parent = HasParent(newParentNode, newParentKey));
-
-  case "Orphaned":
-  case "NoParent":
-   return void (this._parent = HasParent(newParentNode, newParentKey));
-
-  default:
-   return assertNever(this.parent, "Unknown state");
-  }
+ }, _proto._setParentLink = function(parent, key) {
+  if (null != this.__parent && this.__parent !== parent) throw new Error("Cannot attach parent if it already exist");
+  this.__parentKey = key, this.__parent = parent;
  }, _proto._attach = function(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() {
-  switch (this.__doc && this.__id && this.__doc.deleteItem(this.__id), 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 && this.__id && this.__doc.deleteItem(this.__id), this.__parent = void 0, 
   this.__doc = void 0;
  }, _createClass(AbstractCrdt, [ {
   key: "_doc",
@@ -274,44 +185,31 @@ var _Symbol$iterator$1, _Symbol$iterator2, AbstractCrdt = function() {
    return this.__id;
   }
  }, {
-  key: "parent",
-  get: function() {
-   return this._parent;
-  }
- }, {
-  key: "_parentNode",
+  key: "_parent",
   get: function() {
-   switch (this.parent.type) {
-   case "HasParent":
-    return this.parent.node;
-
-   case "NoParent":
-   case "Orphaned":
-    return null;
-
-   default:
-    return assertNever(this.parent, "Unknown state");
-   }
+   return this.__parent;
   }
  }, {
   key: "_parentKey",
   get: function() {
-   switch (this.parent.type) {
-   case "HasParent":
-    return this.parent.key;
+   return this.__parentKey;
+  }
+ } ]), AbstractCrdt;
+}();
+
+function isJsonScalar(data) {
+ return null === data || "string" == typeof data || "number" == typeof data || "boolean" == typeof data;
+}
 
-   case "NoParent":
-    return null;
+function isJsonArray(data) {
+ return Array.isArray(data);
+}
 
-   case "Orphaned":
-    return this.parent.oldKey;
+function isJsonObject(data) {
+ return !isJsonScalar(data) && !isJsonArray(data);
+}
 
-   default:
-    return assertNever(this.parent, "Unknown state");
-   }
-  }
- } ]), AbstractCrdt;
-}(), LiveRegister = function(_AbstractCrdt) {
+var _Symbol$iterator$1, _Symbol$iterator2, LiveRegister = function(_AbstractCrdt) {
  function LiveRegister(data) {
   var _this;
   return (_this = _AbstractCrdt.call(this) || this)._data = void 0, _this._data = data, 
@@ -322,25 +220,26 @@ var _Symbol$iterator$1, _Symbol$iterator2, AbstractCrdt = function() {
   return register._attach(id, doc), register;
  };
  var _proto = LiveRegister.prototype;
- return _proto._serialize = function(parentId, parentKey, doc) {
+ return _proto._serialize = function(parentId, parentKey, doc, intent) {
   if (null == this._id || null == parentId || null == parentKey) throw new Error("Cannot serialize register if parentId or parentKey is undefined");
   return [ {
    type: exports.OpCode.CREATE_REGISTER,
    opId: null == doc ? void 0 : doc.generateOpId(),
    id: this._id,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: this.data
   } ];
  }, _proto._toSerializedCrdt = function() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveRegister if parent is missing");
+  var _this$_parent;
   return {
    type: exports.CrdtType.REGISTER,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key,
+   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
+   parentKey: this._parentKey,
    data: this.data
   };
- }, _proto._attachChild = function(_op) {
+ }, _proto._attachChild = function(_op, _isLocal) {
   throw new Error("Method not implemented.");
  }, _proto._detachChild = function(_crdt) {
   throw new Error("Method not implemented.");
@@ -355,7 +254,7 @@ var _Symbol$iterator$1, _Symbol$iterator2, AbstractCrdt = function() {
 }(AbstractCrdt);
 
 function makePosition(before, after) {
- return null != before && null != after ? pos(makePositionFromCodes(posCodes(before), posCodes(after))) : null != before ? function(before) {
+ return null == before && null == after ? pos([ 33 ]) : null != before && null == after ? function(before) {
   for (var result = [], beforeCodes = posCodes(before), i = 0; i < beforeCodes.length; i++) {
    var code = beforeCodes[i];
    if (126 !== code) {
@@ -368,7 +267,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(before) : null != after ? function(after) {
+ }(before) : null == before && null != after ? function(after) {
   for (var result = [], afterCodes = posCodes(after), i = 0; i < afterCodes.length; i++) {
    var code = afterCodes[i];
    if (!(code <= 33)) {
@@ -381,7 +280,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(after) : pos([ 33 ]);
+ }(after) : pos(makePositionFromCodes(posCodes(before), posCodes(after)));
 }
 
 function makePositionFromCodes(before, after) {
@@ -425,322 +324,206 @@ var LiveList = function(_AbstractCrdt) {
  function LiveList(items) {
   var _this;
   void 0 === items && (items = []), (_this = _AbstractCrdt.call(this) || this)._items = void 0, 
-  _this._implicitlyDeletedItems = void 0, _this._items = [], _this._implicitlyDeletedItems = new Set;
+  _this._items = [];
   for (var position = void 0, i = 0; i < items.length; i++) {
-   var newPosition = makePosition(position), item = lsonToLiveNode(items[i]);
-   item._setParentLink(_assertThisInitialized(_this), newPosition), _this._items.push(item), 
-   position = newPosition;
+   var newPosition = makePosition(position), item = selfOrRegister(items[i]);
+   _this._items.push([ item, newPosition ]), position = newPosition;
   }
   return _this;
  }
  _inheritsLoose(LiveList, _AbstractCrdt), LiveList._deserialize = function(_ref, parentToChildren, doc) {
-  var id = _ref[0], list = new LiveList;
+  var id = _ref[0], list = new LiveList([]);
   list._attach(id, doc);
   var children = parentToChildren.get(id);
   if (null == children) return list;
   for (var _step, _iterator = _createForOfIteratorHelperLoose(children); !(_step = _iterator()).done; ) {
-   var _step$value = _step.value, _id = _step$value[0], crdt = _step$value[1], child = deserialize([ _id, crdt ], parentToChildren, doc);
-   child._setParentLink(list, crdt.parentKey), list._items.push(child), sortListItem(list._items);
+   var entry = _step.value, 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 comparePosition(itemA[1], itemB[1]);
+   }));
   }
   return list;
  };
  var _proto = LiveList.prototype;
- return _proto._serialize = function(parentId, parentKey, doc) {
+ return _proto._serialize = function(parentId, parentKey, doc, intent) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
+  if (null == parentId || null == parentKey) throw new Error("Cannot serialize list if parentId or parentKey is undefined");
   var ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
+   intent: intent,
    type: exports.OpCode.CREATE_LIST,
    parentId: parentId,
    parentKey: parentKey
   };
   ops.push(op);
   for (var _step2, _iterator2 = _createForOfIteratorHelperLoose(this._items); !(_step2 = _iterator2()).done; ) {
-   var item = _step2.value;
-   ops.push.apply(ops, item._serialize(this._id, item._getParentKeyOrThrow(), doc));
+   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(position) {
   return this._items.findIndex((function(item) {
-   return item._getParentKeyOrThrow() === position;
+   return item[1] === position;
   }));
  }, _proto._attach = function(id, doc) {
   _AbstractCrdt.prototype._attach.call(this, id, doc);
   for (var _step3, _iterator3 = _createForOfIteratorHelperLoose(this._items); !(_step3 = _iterator3()).done; ) {
-   _step3.value._attach(doc.generateId(), doc);
+   _step3.value[0]._attach(doc.generateId(), doc);
   }
  }, _proto._detach = function() {
   _AbstractCrdt.prototype._detach.call(this);
   for (var _step4, _iterator4 = _createForOfIteratorHelperLoose(this._items); !(_step4 = _iterator4()).done; ) {
-   _step4.value._detach();
-  }
- }, _proto._applyRemoteSet = function(op) {
-  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
-  child._attach(id, this._doc), child._setParentLink(this, key);
-  var deletedId = op.deletedId, existingItemIndex = this._indexOfPosition(key);
-  if (-1 !== existingItemIndex) {
-   var existingItem = this._items[existingItemIndex];
-   if (existingItem._id === deletedId) return existingItem._detach(), this._items[existingItemIndex] = child, 
-   {
-    modified: makeUpdate(this, [ setDelta(existingItemIndex, child) ]),
-    reverse: []
-   };
-   this._implicitlyDeletedItems.add(existingItem), this._items[existingItemIndex] = child;
-   var delta = [ setDelta(existingItemIndex, child) ], _deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-   return _deleteDelta && delta.push(_deleteDelta), {
-    modified: makeUpdate(this, delta),
-    reverse: []
-   };
+   _step4.value[0]._detach();
   }
-  var updates = [], _deleteDelta2 = this._detachItemAssociatedToSetOperation(op.deletedId);
-  return _deleteDelta2 && updates.push(_deleteDelta2), this._items.push(child), sortListItem(this._items), 
-  updates.push(insertDelta(this._indexOfPosition(key), child)), {
-   reverse: [],
-   modified: makeUpdate(this, updates)
-  };
- }, _proto._applySetAck = function(op) {
-  var delta = [], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-  deletedDelta && delta.push(deletedDelta);
-  var indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey), existingItem = this._items.find((function(item) {
-   return item._id === op.id;
-  }));
-  if (null != existingItem) {
-   if (existingItem._parentKey === op.parentKey) return delta.length > 0 ? {
-    modified: makeUpdate(this, delta),
-    reverse: []
-   } : {
-    modified: !1
-   };
-   -1 !== indexOfItemWithSamePosition && (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), sortListItem(this._items);
-   var newIndex = this._items.indexOf(existingItem);
-   return newIndex !== previousIndex && delta.push(moveDelta(previousIndex, newIndex, existingItem)), 
-   {
-    modified: delta.length > 0 && makeUpdate(this, delta),
-    reverse: []
-   };
-  }
-  var orphan = nn(this._doc).getItem(op.id);
-  if (orphan && this._implicitlyDeletedItems.has(orphan)) {
-   orphan._setParentLink(this, op.parentKey), this._implicitlyDeletedItems.delete(orphan), 
-   this._items.push(orphan), sortListItem(this._items);
-   var recreatedItemIndex = this._items.indexOf(orphan);
-   return {
-    modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan) ].concat(delta)),
-    reverse: []
-   };
-  }
-  var _this$_createAttachIt = this._createAttachItemAndSort(op, op.parentKey), newItem = _this$_createAttachIt.newItem, _newIndex = _this$_createAttachIt.newIndex;
-  return {
-   modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(_newIndex, newItem) : setDelta(_newIndex, newItem) ].concat(delta)),
-   reverse: []
-  };
- }, _proto._detachItemAssociatedToSetOperation = function(deletedId) {
-  if (null == deletedId || null == this._doc) return null;
-  var deletedItem = this._doc.getItem(deletedId);
-  if (null == deletedItem) return null;
-  var result = this._detachChild(deletedItem);
-  return !1 === result.modified ? null : result.modified.updates[0];
- }, _proto._applyRemoteInsert = function(op) {
+ }, _proto._attachChild = function(op, isLocal) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var key = op.parentKey, existingItemIndex = this._indexOfPosition(key);
-  -1 !== existingItemIndex && this._shiftItemPosition(existingItemIndex, key);
-  var _this$_createAttachIt2 = this._createAttachItemAndSort(op, key), newItem = _this$_createAttachIt2.newItem;
-  return {
-   modified: makeUpdate(this, [ insertDelta(_this$_createAttachIt2.newIndex, newItem) ]),
-   reverse: []
-  };
- }, _proto._applyInsertAck = function(op) {
-  var existingItem = this._items.find((function(item) {
-   return item._id === op.id;
-  })), key = op.parentKey, itemIndexAtPosition = this._indexOfPosition(key);
-  if (existingItem) {
-   if (existingItem._parentKey === key) return {
-    modified: !1
-   };
-   var oldPositionIndex = this._items.indexOf(existingItem);
-   -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key), 
-   existingItem._setParentLink(this, key), sortListItem(this._items);
-   var newIndex = this._indexOfPosition(key);
-   return newIndex === oldPositionIndex ? {
-    modified: !1
-   } : {
-    modified: makeUpdate(this, [ moveDelta(oldPositionIndex, newIndex, existingItem) ]),
-    reverse: []
-   };
-  }
-  var orphan = nn(this._doc).getItem(op.id);
-  if (orphan && this._implicitlyDeletedItems.has(orphan)) return orphan._setParentLink(this, key), 
-  this._implicitlyDeletedItems.delete(orphan), this._items.push(orphan), sortListItem(this._items), 
-  {
-   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(key), orphan) ]),
-   reverse: []
-  };
-  -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key);
-  var _this$_createAttachIt3 = this._createAttachItemAndSort(op, key), newItem = _this$_createAttachIt3.newItem;
-  return {
-   modified: makeUpdate(this, [ insertDelta(_this$_createAttachIt3.newIndex, newItem) ]),
-   reverse: []
-  };
- }, _proto._applyInsertUndoRedo = function(op) {
-  var _this$_doc, id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
-  if (void 0 !== (null == (_this$_doc = this._doc) ? void 0 : _this$_doc.getItem(id))) return {
-   modified: !1
-  };
-  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
-  var existingItemIndex = this._indexOfPosition(key), newKey = key;
-  -1 !== existingItemIndex && (newKey = makePosition(this._items[existingItemIndex] ? this._items[existingItemIndex]._getParentKeyOrThrow() : void 0, this._items[existingItemIndex + 1] ? this._items[existingItemIndex + 1]._getParentKeyOrThrow() : void 0), 
-  child._setParentLink(this, newKey));
-  return this._items.push(child), sortListItem(this._items), {
-   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(newKey), child) ]),
-   reverse: [ {
-    type: exports.OpCode.DELETE_CRDT,
-    id: id
-   } ]
-  };
- }, _proto._applySetUndoRedo = function(op) {
-  var _this$_doc2, id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
-  if (void 0 !== (null == (_this$_doc2 = this._doc) ? void 0 : _this$_doc2.getItem(id))) return {
+  var id = op.id, parentKey = op.parentKey, intent = op.intent, key = parentKey, child = creationOpToLiveStructure(op);
+  if (void 0 !== this._doc.getItem(id)) return {
    modified: !1
   };
-  var indexOfItemWithSameKey = this._indexOfPosition(key);
-  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
-  var newKey = key;
-  if (-1 !== indexOfItemWithSameKey) {
-   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) ], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-   return deletedDelta && delta.push(deletedDelta), {
-    modified: makeUpdate(this, delta),
-    reverse: reverse
-   };
+  child._attach(id, this._doc), child._setParentLink(this, key);
+  var index = this._items.findIndex((function(entry) {
+   return entry[1] === key;
+  })), newKey = key;
+  if (-1 !== index) {
+   if ("set" === intent) {
+    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
+     } ]
+    };
+    return this._items[index][0] = child, {
+     modified: storageUpdate,
+     reverse: existingItem._serialize(this._id, key, this._doc, "set")
+    };
+   }
+   if (isLocal) {
+    var before = this._items[index] ? this._items[index][1] : void 0, after = this._items[index + 1] ? this._items[index + 1][1] : void 0;
+    newKey = makePosition(before, after), child._setParentLink(this, newKey);
+   } else {
+    var _this$_items;
+    this._items[index][1] = makePosition(key, null == (_this$_items = this._items[index + 1]) ? void 0 : _this$_items[1]);
+   }
   }
-  this._items.push(child), sortListItem(this._items), this._detachItemAssociatedToSetOperation(op.deletedId);
-  var newIndex = this._indexOfPosition(newKey);
+  this._items.push([ child, newKey ]), this._items.sort((function(itemA, itemB) {
+   return comparePosition(itemA[1], itemB[1]);
+  }));
+  var newIndex = this._items.findIndex((function(entry) {
+   return entry[1] === newKey;
+  }));
   return {
    reverse: [ {
     type: exports.OpCode.DELETE_CRDT,
     id: id
    } ],
-   modified: makeUpdate(this, [ insertDelta(newIndex, child) ])
+   modified: {
+    node: this,
+    type: "LiveList",
+    updates: [ {
+     index: newIndex,
+     type: "insert",
+     item: child instanceof LiveRegister ? child.data : child
+    } ]
+   }
   };
- }, _proto._attachChild = function(op, source) {
-  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  if ("set" === op.intent) {
-   if (source === exports.OpSource.REMOTE) return this._applyRemoteSet(op);
-   if (source === exports.OpSource.UNDOREDO_RECONNECT) return this._applySetUndoRedo(op);
-   if (source === exports.OpSource.ACK) return this._applySetAck(op);
-  }
-  return source === exports.OpSource.REMOTE ? this._applyRemoteInsert(op) : source === exports.OpSource.ACK ? this._applyInsertAck(op) : this._applyInsertUndoRedo(op);
  }, _proto._detachChild = function(child) {
   if (child) {
-   var parentKey = nn(child._parentKey), reverse = child._serialize(nn(this._id), parentKey, this._doc), indexToDelete = this._items.indexOf(child);
+   var reverse = child._serialize(this._id, child._parentKey, this._doc), indexToDelete = this._items.findIndex((function(item) {
+    return item[0] === child;
+   }));
    return this._items.splice(indexToDelete, 1), child._detach(), {
-    modified: makeUpdate(this, [ deleteDelta(indexToDelete) ]),
+    modified: {
+     node: this,
+     type: "LiveList",
+     updates: [ {
+      index: indexToDelete,
+      type: "delete"
+     } ]
+    },
     reverse: reverse
    };
   }
   return {
    modified: !1
   };
- }, _proto._applySetChildKeyRemote = function(newKey, child) {
-  if (this._implicitlyDeletedItems.has(child)) return this._implicitlyDeletedItems.delete(child), 
-  child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
-  {
-   modified: makeUpdate(this, [ insertDelta(this._items.indexOf(child), child) ]),
-   reverse: []
-  };
-  if (newKey === child._parentKey) return {
-   modified: !1
-  };
-  var _this$_items, existingItemIndex = this._indexOfPosition(newKey);
-  if (-1 === existingItemIndex) {
-   var previousIndex = this._items.indexOf(child);
-   child._setParentLink(this, newKey), sortListItem(this._items);
-   var _newIndex4 = this._items.indexOf(child);
-   return _newIndex4 === previousIndex ? {
-    modified: !1
-   } : {
-    modified: makeUpdate(this, [ moveDelta(previousIndex, _newIndex4, child) ]),
-    reverse: []
-   };
-  }
-  this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items = this._items[existingItemIndex + 1]) ? void 0 : _this$_items._getParentKeyOrThrow()));
-  var _previousIndex = this._items.indexOf(child);
-  child._setParentLink(this, newKey), sortListItem(this._items);
-  var _newIndex5 = this._items.indexOf(child);
-  return _newIndex5 === _previousIndex ? {
-   modified: !1
-  } : {
-   modified: makeUpdate(this, [ moveDelta(_previousIndex, _newIndex5, child) ]),
-   reverse: []
-  };
- }, _proto._applySetChildKeyAck = function(newKey, child) {
-  var previousKey = nn(child._parentKey);
-  if (this._implicitlyDeletedItems.has(child)) {
-   var _this$_items2, existingItemIndex = this._indexOfPosition(newKey);
-   if (this._implicitlyDeletedItems.delete(child), -1 !== existingItemIndex) this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items2 = this._items[existingItemIndex + 1]) ? void 0 : _this$_items2._getParentKeyOrThrow()));
-   return child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
-   {
-    modified: !1
-   };
-  }
-  if (newKey === previousKey) return {
-   modified: !1
-  };
-  var _this$_items3, previousIndex = this._items.indexOf(child), _existingItemIndex = this._indexOfPosition(newKey);
-  -1 !== _existingItemIndex && this._items[_existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items3 = this._items[_existingItemIndex + 1]) ? void 0 : _this$_items3._getParentKeyOrThrow())), 
-  child._setParentLink(this, newKey), sortListItem(this._items);
-  var newIndex = this._items.indexOf(child);
-  return previousIndex === newIndex ? {
-   modified: !1
-  } : {
-   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
-   reverse: []
-  };
- }, _proto._applySetChildKeyUndoRedo = function(newKey, child) {
-  var _this$_items4, previousKey = nn(child._parentKey), previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
-  -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null == (_this$_items4 = this._items[existingItemIndex + 1]) ? void 0 : _this$_items4._getParentKeyOrThrow()));
-  child._setParentLink(this, newKey), sortListItem(this._items);
-  var newIndex = this._items.indexOf(child);
-  return previousIndex === newIndex ? {
-   modified: !1
-  } : {
-   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+ }, _proto._setChildKey = function(key, child, previousKey) {
+  child._setParentLink(this, key);
+  var _this$_items2, previousIndex = this._items.findIndex((function(entry) {
+   return entry[0]._id === child._id;
+  })), index = this._items.findIndex((function(entry) {
+   return entry[1] === key;
+  }));
+  -1 !== index && (this._items[index][1] = makePosition(key, null == (_this$_items2 = this._items[index + 1]) ? void 0 : _this$_items2[1]));
+  var item = this._items.find((function(item) {
+   return item[0] === child;
+  }));
+  item && (item[1] = key), this._items.sort((function(itemA, itemB) {
+   return comparePosition(itemA[1], itemB[1]);
+  }));
+  var newIndex = this._items.findIndex((function(entry) {
+   return entry[0]._id === child._id;
+  }));
+  return {
+   modified: {
+    node: this,
+    type: "LiveList",
+    updates: newIndex === previousIndex ? [] : [ {
+     index: newIndex,
+     item: child instanceof LiveRegister ? child.data : child,
+     previousIndex: previousIndex,
+     type: "move"
+    } ]
+   },
    reverse: [ {
     type: exports.OpCode.SET_PARENT_KEY,
-    id: nn(child._id),
+    id: null == item ? void 0 : item[0]._id,
     parentKey: previousKey
    } ]
   };
- }, _proto._setChildKey = function(newKey, child, source) {
-  return source === exports.OpSource.REMOTE ? this._applySetChildKeyRemote(newKey, child) : source === exports.OpSource.ACK ? this._applySetChildKeyAck(newKey, child) : this._applySetChildKeyUndoRedo(newKey, child);
  }, _proto._apply = function(op, isLocal) {
   return _AbstractCrdt.prototype._apply.call(this, op, isLocal);
  }, _proto._toSerializedCrdt = function() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveList if parent is missing");
+  var _this$_parent;
   return {
    type: exports.CrdtType.LIST,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key
+   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
+   parentKey: this._parentKey
   };
  }, _proto.push = function(element) {
   return this.insert(element, this.length);
  }, _proto.insert = function(element, index) {
   if (index < 0 || index > this._items.length) throw new Error('Cannot insert list item at index "' + index + '". index should be between 0 and ' + this._items.length);
-  var position = makePosition(this._items[index - 1] ? this._items[index - 1]._getParentKeyOrThrow() : void 0, this._items[index] ? this._items[index]._getParentKeyOrThrow() : void 0), value = lsonToLiveNode(element);
-  if (value._setParentLink(this, position), this._items.push(value), sortListItem(this._items), 
-  this._doc && this._id) {
+  var position = makePosition(this._items[index - 1] ? this._items[index - 1][1] : void 0, this._items[index] ? this._items[index][1] : void 0), value = selfOrRegister(element);
+  value._setParentLink(this, position), this._items.push([ value, position ]), this._items.sort((function(itemA, itemB) {
+   return comparePosition(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), this._doc.dispatch(value._serialize(this._id, position, this._doc), [ {
+   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.OpCode.DELETE_CRDT,
     id: id
-   } ], new Map([ [ this._id, makeUpdate(this, [ insertDelta(index, value) ]) ] ]));
+   } ], storageUpdates);
   }
  }, _proto.move = function(index, targetIndex) {
   if (targetIndex < 0) throw new Error("targetIndex cannot be less than 0");
@@ -748,77 +531,108 @@ var LiveList = function(_AbstractCrdt) {
   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, afterPosition = null;
-  index < targetIndex ? (afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1]._getParentKeyOrThrow(), 
-  beforePosition = this._items[targetIndex]._getParentKeyOrThrow()) : (afterPosition = this._items[targetIndex]._getParentKeyOrThrow(), 
-  beforePosition = 0 === targetIndex ? void 0 : this._items[targetIndex - 1]._getParentKeyOrThrow());
-  var position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item._getParentKeyOrThrow();
-  if (item._setParentLink(this, position), sortListItem(this._items), this._doc && this._id) {
-   var storageUpdates = new Map([ [ this._id, makeUpdate(this, [ moveDelta(index, targetIndex, item) ]) ] ]);
-   this._doc.dispatch([ {
+  index < targetIndex ? (afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1][1], 
+  beforePosition = this._items[targetIndex][1]) : (afterPosition = this._items[targetIndex][1], 
+  beforePosition = 0 === targetIndex ? void 0 : this._items[targetIndex - 1][1]);
+  var position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item[1];
+  item[1] = position, item[0]._setParentLink(this, position), this._items.sort((function(itemA, itemB) {
+   return comparePosition(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.OpCode.SET_PARENT_KEY,
-    id: nn(item._id),
+    id: item[0]._id,
     opId: this._doc.generateOpId(),
     parentKey: position
    } ], [ {
     type: exports.OpCode.SET_PARENT_KEY,
-    id: nn(item._id),
+    id: item[0]._id,
     parentKey: previousPosition
    } ], storageUpdates);
   }
  }, _proto.delete = function(index) {
   if (index < 0 || index >= this._items.length) throw new Error('Cannot delete list item at index "' + index + '". index should be between 0 and ' + (this._items.length - 1));
   var item = this._items[index];
-  if (item._detach(), this._items.splice(index, 1), this._doc) {
-   var childRecordId = item._id;
+  if (item[0]._detach(), this._items.splice(index, 1), this._doc) {
+   var childRecordId = item[0]._id;
    if (childRecordId) {
     var storageUpdates = new Map;
-    storageUpdates.set(nn(this._id), makeUpdate(this, [ deleteDelta(index) ])), this._doc.dispatch([ {
+    storageUpdates.set(this._id, {
+     node: this,
+     type: "LiveList",
+     updates: [ {
+      index: index,
+      type: "delete"
+     } ]
+    }), this._doc.dispatch([ {
      id: childRecordId,
      opId: this._doc.generateOpId(),
      type: exports.OpCode.DELETE_CRDT
-    } ], item._serialize(nn(this._id), item._getParentKeyOrThrow()), storageUpdates);
+    } ], item[0]._serialize(this._id, item[1]), storageUpdates);
    }
   }
  }, _proto.clear = function() {
   if (this._doc) {
    for (var _step5, ops = [], reverseOps = [], updateDelta = [], i = 0, _iterator5 = _createForOfIteratorHelperLoose(this._items); !(_step5 = _iterator5()).done; ) {
     var item = _step5.value;
-    item._detach();
-    var childId = item._id;
+    item[0]._detach();
+    var childId = item[0]._id;
     childId && (ops.push({
-     type: exports.OpCode.DELETE_CRDT,
      id: childId,
-     opId: this._doc.generateOpId()
-    }), reverseOps.push.apply(reverseOps, item._serialize(nn(this._id), item._getParentKeyOrThrow())), 
-    updateDelta.push(deleteDelta(i))), i++;
+     type: exports.OpCode.DELETE_CRDT
+    }), reverseOps.push.apply(reverseOps, item[0]._serialize(this._id, item[1])), updateDelta.push({
+     index: i,
+     type: "delete"
+    })), i++;
    }
    this._items = [];
    var storageUpdates = new Map;
-   storageUpdates.set(nn(this._id), makeUpdate(this, updateDelta)), this._doc.dispatch(ops, reverseOps, storageUpdates);
+   storageUpdates.set(this._id, {
+    node: this,
+    type: "LiveList",
+    updates: updateDelta
+   }), this._doc.dispatch(ops, reverseOps, storageUpdates);
   } else {
    for (var _step6, _iterator6 = _createForOfIteratorHelperLoose(this._items); !(_step6 = _iterator6()).done; ) {
-    _step6.value._detach();
+    _step6.value[0]._detach();
    }
    this._items = [];
   }
  }, _proto.set = function(index, item) {
   if (index < 0 || index >= this._items.length) throw new Error('Cannot set list item at index "' + index + '". index should be between 0 and ' + (this._items.length - 1));
-  var existingItem = this._items[index], position = existingItem._getParentKeyOrThrow(), existingId = existingItem._id;
+  var _this$_items$index = this._items[index], existingItem = _this$_items$index[0], position = _this$_items$index[1];
   existingItem._detach();
-  var value = lsonToLiveNode(item);
-  if (value._setParentLink(this, position), this._items[index] = value, this._doc && this._id) {
+  var value = selfOrRegister(item);
+  if (value._setParentLink(this, position), this._items[index][0] = value, this._doc && this._id) {
    var id = this._doc.generateId();
    value._attach(id, this._doc);
    var storageUpdates = new Map;
-   storageUpdates.set(this._id, makeUpdate(this, [ setDelta(index, value) ]));
-   var ops = value._serialize(this._id, position, this._doc);
-   addIntentAndDeletedIdToOperation(ops, existingId);
-   var reverseOps = existingItem._serialize(this._id, position, void 0);
-   addIntentAndDeletedIdToOperation(reverseOps, id), this._doc.dispatch(ops, reverseOps, storageUpdates);
+   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, void 0, "set"), storageUpdates);
   }
  }, _proto.toArray = function() {
   return this._items.map((function(entry) {
-   return liveNodeToLson(entry);
+   return selfOrRegisterValue(entry[0]);
   }));
  }, _proto.every = function(predicate) {
   return this.toArray().every(predicate);
@@ -831,29 +645,19 @@ var LiveList = function(_AbstractCrdt) {
  }, _proto.forEach = function(callbackfn) {
   return this.toArray().forEach(callbackfn);
  }, _proto.get = function(index) {
-  if (!(index < 0 || index >= this._items.length)) return liveNodeToLson(this._items[index]);
+  if (!(index < 0 || index >= this._items.length)) return selfOrRegisterValue(this._items[index][0]);
  }, _proto.indexOf = function(searchElement, fromIndex) {
   return this.toArray().indexOf(searchElement, fromIndex);
  }, _proto.lastIndexOf = function(searchElement, fromIndex) {
   return this.toArray().lastIndexOf(searchElement, fromIndex);
  }, _proto.map = function(callback) {
   return this._items.map((function(entry, i) {
-   return callback(liveNodeToLson(entry), i);
+   return callback(selfOrRegisterValue(entry[0]), i);
   }));
  }, _proto.some = function(predicate) {
   return this.toArray().some(predicate);
  }, _proto[_Symbol$iterator$1] = function() {
   return new LiveListIterator(this._items);
- }, _proto._createAttachItemAndSort = function(op, key) {
-  var newItem = creationOpToLiveNode(op);
-  return newItem._attach(op.id, nn(this._doc)), newItem._setParentLink(this, key), 
-  this._items.push(newItem), sortListItem(this._items), {
-   newItem: newItem,
-   newIndex: this._indexOfPosition(key)
-  };
- }, _proto._shiftItemPosition = function(index, key) {
-  var _this$_items5, shiftedPosition = makePosition(key, this._items.length > index + 1 ? null == (_this$_items5 = this._items[index + 1]) ? void 0 : _this$_items5._getParentKeyOrThrow() : void 0);
-  this._items[index]._setParentLink(this, shiftedPosition);
  }, _createClass(LiveList, [ {
   key: "length",
   get: function() {
@@ -877,62 +681,25 @@ var _Symbol$iterator, LiveListIterator = function() {
    done: !0,
    value: void 0
   } : {
-   value: liveNodeToLson(result.value)
+   value: selfOrRegisterValue(result.value[0])
   };
  }, LiveListIterator;
-}();
-
-function makeUpdate(liveList, deltaUpdates) {
- return {
-  node: liveList,
-  type: "LiveList",
-  updates: deltaUpdates
- };
-}
-
-function setDelta(index, item) {
- return {
-  index: index,
-  type: "set",
-  item: item instanceof LiveRegister ? item.data : item
- };
-}
+}(), _emittedDeprecationWarnings = new Set;
 
-function deleteDelta(index) {
- return {
-  index: index,
-  type: "delete"
- };
-}
-
-function insertDelta(index, item) {
- return {
-  index: index,
-  type: "insert",
-  item: item instanceof LiveRegister ? item.data : item
- };
-}
-
-function moveDelta(previousIndex, index, item) {
- return {
-  index: index,
-  type: "move",
-  previousIndex: previousIndex,
-  item: item instanceof LiveRegister ? item.data : item
- };
+function deprecate(message, key) {
+ void 0 === key && (key = message), "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
+ console.error("DEPRECATION WARNING: " + message)));
 }
 
-function sortListItem(items) {
- items.sort((function(itemA, itemB) {
-  return comparePosition(itemA._getParentKeyOrThrow(), itemB._getParentKeyOrThrow());
- }));
+function deprecateIf(condition, message, key) {
+ void 0 === key && (key = message), "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
 }
 
-function addIntentAndDeletedIdToOperation(ops, deletedId) {
- if (0 === ops.length) throw new Error("Internal error. Serialized LiveStructure should have at least 1 operation");
- var firstOp = ops[0];
- if (firstOp.type !== exports.OpCode.CREATE_LIST && firstOp.type !== exports.OpCode.CREATE_OBJECT && firstOp.type !== exports.OpCode.CREATE_REGISTER && firstOp.type !== exports.OpCode.CREATE_MAP) throw new Error("Internal error. Serialized LiveStructure first op should be CreateOp");
- firstOp.intent = "set", firstOp.deletedId = deletedId;
+function throwUsageError(message) {
+ if ("production" !== process.env.NODE_ENV) {
+  var usageError = new Error(message);
+  throw usageError.name = "Usage error", usageError;
+ }
 }
 
 _Symbol$iterator = Symbol.iterator;
@@ -940,10 +707,10 @@ _Symbol$iterator = Symbol.iterator;
 var LiveMap = function(_AbstractCrdt) {
  function LiveMap(entries) {
   var _this;
-  if ((_this = _AbstractCrdt.call(this) || this)._map = void 0, errorIf(null === entries, "Support for calling `new LiveMap(null)` will be removed in @liveblocks/client 0.18. Please call as `new LiveMap()`, or `new LiveMap([])`."), 
+  if ((_this = _AbstractCrdt.call(this) || this)._map = void 0, deprecateIf(null === entries, "Support for calling `new LiveMap(null)` will be removed in @liveblocks/client 0.18. Please call as `new LiveMap()`, or `new LiveMap([])`."), 
   entries) {
    for (var _step, mappedEntries = [], _iterator = _createForOfIteratorHelperLoose(entries); !(_step = _iterator()).done; ) {
-    var entry = _step.value, _value = lsonToLiveNode(entry[1]);
+    var entry = _step.value, _value = selfOrRegister(entry[1]);
     _value._setParentLink(_assertThisInitialized(_this), entry[0]), mappedEntries.push([ entry[0], _value ]);
    }
    _this._map = new Map(mappedEntries);
@@ -952,12 +719,14 @@ var LiveMap = function(_AbstractCrdt) {
  }
  _inheritsLoose(LiveMap, _AbstractCrdt);
  var _proto = LiveMap.prototype;
- return _proto._serialize = function(parentId, parentKey, doc) {
+ return _proto._serialize = function(parentId, parentKey, doc, intent) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
+  if (null == parentId || null == parentKey) throw new Error("Cannot serialize map if parentId or parentKey is undefined");
   var ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
    type: exports.OpCode.CREATE_MAP,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey
   };
@@ -975,7 +744,9 @@ var LiveMap = function(_AbstractCrdt) {
   var children = parentToChildren.get(id);
   if (null == children) return map;
   for (var _step3, _iterator3 = _createForOfIteratorHelperLoose(children); !(_step3 = _iterator3()).done; ) {
-   var _step3$value = _step3.value, _id = _step3$value[0], crdt = _step3$value[1], child = deserialize([ _id, crdt ], parentToChildren, doc);
+   var entry = _step3.value, crdt = entry[1];
+   if (null == crdt.parentKey) 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;
@@ -985,24 +756,20 @@ var LiveMap = function(_AbstractCrdt) {
    var _step4$value = _step4.value;
    _step4$value[0];
    var _value3 = _step4$value[1];
-   isLiveNode(_value3) && _value3._attach(doc.generateId(), doc);
+   isCrdt(_value3) && _value3._attach(doc.generateId(), doc);
   }
- }, _proto._attachChild = function(op) {
+ }, _proto._attachChild = function(op, _isLocal) {
   var _updates;
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, key = op.parentKey, child = creationOpToLiveNode(op);
+  var id = op.id, key = op.parentKey, child = creationOpToLiveStructure(op);
   if (void 0 !== this._doc.getItem(id)) return {
    modified: !1
   };
   var reverse, previousValue = this._map.get(key);
-  if (previousValue) {
-   var thisId = nn(this._id);
-   reverse = previousValue._serialize(thisId, key), previousValue._detach();
-  } else reverse = [ {
+  return previousValue ? (reverse = previousValue._serialize(this._id, key), previousValue._detach()) : reverse = [ {
    type: exports.OpCode.DELETE_CRDT,
    id: id
-  } ];
-  return child._setParentLink(this, key), child._attach(id, this._doc), this._map.set(key, child), 
+  } ], child._setParentLink(this, key), child._attach(id, this._doc), this._map.set(key, child), 
   {
    modified: {
     node: this,
@@ -1019,7 +786,7 @@ var LiveMap = function(_AbstractCrdt) {
    _step5.value._detach();
   }
  }, _proto._detachChild = function(child) {
-  for (var _updates2, _step6, id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc), _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
+  for (var _updates2, _step6, reverse = child._serialize(this._id, child._parentKey, this._doc), _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
    var _step6$value = _step6.value, _key3 = _step6$value[0];
    _step6$value[1] === child && this._map.delete(_key3);
   }
@@ -1027,26 +794,26 @@ var LiveMap = function(_AbstractCrdt) {
    modified: {
     node: this,
     type: "LiveMap",
-    updates: (_updates2 = {}, _updates2[parentKey] = {
+    updates: (_updates2 = {}, _updates2[child._parentKey] = {
      type: "delete"
     }, _updates2)
    },
    reverse: reverse
   };
  }, _proto._toSerializedCrdt = function() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveMap if parent is missing");
+  var _this$_parent;
   return {
    type: exports.CrdtType.MAP,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key
+   parentId: null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id,
+   parentKey: this._parentKey
   };
  }, _proto.get = function(key) {
   var value = this._map.get(key);
-  if (null != value) return liveNodeToLson(value);
+  if (null != value) return selfOrRegisterValue(value);
  }, _proto.set = function(key, value) {
   var oldValue = this._map.get(key);
   oldValue && oldValue._detach();
-  var item = lsonToLiveNode(value);
+  var item = selfOrRegister(value);
   if (item._setParentLink(this, key), this._map.set(key, item), this._doc && this._id) {
    var _updates3, id = this._doc.generateId();
    item._attach(id, this._doc);
@@ -1068,8 +835,8 @@ var LiveMap = function(_AbstractCrdt) {
   var item = this._map.get(key);
   if (null == item) return !1;
   if (item._detach(), this._map.delete(key), this._doc && item._id) {
-   var _updates4, thisId = nn(this._id), storageUpdates = new Map;
-   storageUpdates.set(thisId, {
+   var _updates4, storageUpdates = new Map;
+   storageUpdates.set(this._id, {
     node: this,
     type: "LiveMap",
     updates: (_updates4 = {}, _updates4[key] = {
@@ -1079,7 +846,7 @@ var LiveMap = function(_AbstractCrdt) {
     type: exports.OpCode.DELETE_CRDT,
     id: item._id,
     opId: this._doc.generateOpId()
-   } ], item._serialize(thisId, key), storageUpdates);
+   } ], item._serialize(this._id, key), storageUpdates);
   }
   return !0;
  }, _proto.entries = function() {
@@ -1092,7 +859,7 @@ var LiveMap = function(_AbstractCrdt) {
     done: !0,
     value: void 0
    } : {
-    value: [ iteratorValue.value[0], liveNodeToLson(iteratorValue.value[1]) ]
+    value: [ iteratorValue.value[0], selfOrRegisterValue(iteratorValue.value[1]) ]
    };
   }, _ref2;
  }, _proto[_Symbol$iterator] = function() {
@@ -1109,7 +876,7 @@ var LiveMap = function(_AbstractCrdt) {
     done: !0,
     value: void 0
    } : {
-    value: liveNodeToLson(iteratorValue.value)
+    value: selfOrRegisterValue(iteratorValue.value)
    };
   }, _ref3;
  }, _proto.forEach = function(callback) {
@@ -1125,15 +892,7 @@ var LiveMap = function(_AbstractCrdt) {
  } ]), LiveMap;
 }(AbstractCrdt);
 
-function isJsonArray(data) {
- return Array.isArray(data);
-}
-
-function isJsonObject(data) {
- return null !== data && "object" == typeof data && !isJsonArray(data);
-}
-
-function creationOpToLiveNode(op) {
+function creationOpToLiveStructure(op) {
  switch (op.type) {
  case exports.OpCode.CREATE_REGISTER:
   return new LiveRegister(op.data);
@@ -1146,9 +905,6 @@ function creationOpToLiveNode(op) {
 
  case exports.OpCode.CREATE_LIST:
   return new LiveList;
-
- default:
-  return assertNever(0, "Unknown creation Op");
  }
 }
 
@@ -1172,40 +928,27 @@ function deserialize(_ref, parentToChildren, doc) {
  }
 }
 
-function isLiveNode(value) {
- return isLiveList(value) || function(value) {
-  return value instanceof LiveMap;
- }(value) || isLiveObject(value) || function(value) {
-  return value instanceof LiveRegister;
- }(value);
+function isCrdt(obj) {
+ return obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList || obj instanceof LiveRegister;
 }
 
-function isLiveList(value) {
- return value instanceof LiveList;
+function selfOrRegisterValue(obj) {
+ return obj instanceof LiveRegister ? obj.data : obj;
 }
 
-function isLiveObject(value) {
- return value instanceof LiveObject;
-}
-
-function liveNodeToLson(obj) {
- return obj instanceof LiveRegister ? obj.data : obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject ? obj : assertNever(0, "Unknown AbstractCrdt");
-}
-
-function lsonToLiveNode(value) {
- return value instanceof LiveObject || value instanceof LiveMap || value instanceof LiveList ? value : new LiveRegister(value);
+function selfOrRegister(obj) {
+ if (obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList) return obj;
+ if (obj instanceof LiveRegister) throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
+ return new LiveRegister(obj);
 }
 
 function isPlain(value) {
  var type = typeof value;
- return "undefined" === type || null === value || "string" === type || "boolean" === type || "number" === type || Array.isArray(value) || function(value) {
-  if ("object" != typeof value || null === value) return !1;
-  var proto = Object.getPrototypeOf(value);
-  if (null === proto) return !0;
-  var baseProto = proto;
-  for (;null !== Object.getPrototypeOf(baseProto); ) baseProto = Object.getPrototypeOf(baseProto);
-  return proto === baseProto;
- }(value);
+ return "undefined" === type || null === value || "string" === type || "boolean" === type || "number" === type || Array.isArray(value) || isPlainObject(value);
+}
+
+function isPlainObject(blob) {
+ return null !== blob && "object" == typeof blob && "[object Object]" === Object.prototype.toString.call(blob);
 }
 
 function entries(obj) {
@@ -1226,18 +969,19 @@ var LiveObject = function(_AbstractCrdt) {
   for (var key in void 0 === obj && (obj = {}), (_this = _AbstractCrdt.call(this) || this)._map = void 0, 
   _this._propToLastUpdate = void 0, _this._propToLastUpdate = new Map, obj) {
    var value = obj[key];
-   isLiveNode(value) && value._setParentLink(_assertThisInitialized(_this), key);
+   value instanceof AbstractCrdt && value._setParentLink(_assertThisInitialized(_this), key);
   }
   return _this._map = new Map(Object.entries(obj)), _this;
  }
  _inheritsLoose(LiveObject, _AbstractCrdt);
  var _proto = LiveObject.prototype;
- return _proto._serialize = function(parentId, parentKey, doc) {
+ return _proto._serialize = function(parentId, parentKey, doc, intent) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
   var opId = null == doc ? void 0 : doc.generateOpId(), ops = [], op = void 0 !== parentId && void 0 !== parentKey ? {
    type: exports.OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: {}
@@ -1245,22 +989,25 @@ var LiveObject = function(_AbstractCrdt) {
    type: exports.OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
+   intent: intent,
    data: {}
   };
   ops.push(op);
   for (var _step, _iterator = _createForOfIteratorHelperLoose(this._map); !(_step = _iterator()).done; ) {
    var _step$value = _step.value, key = _step$value[0], value = _step$value[1];
-   isLiveNode(value) ? ops.push.apply(ops, value._serialize(this._id, key, doc)) : op.data[key] = value;
+   value instanceof AbstractCrdt ? ops.push.apply(ops, value._serialize(this._id, key, doc)) : op.data[key] = value;
   }
   return ops;
  }, LiveObject._deserialize = function(_ref, parentToChildren, doc) {
   var id = _ref[0], liveObj = new LiveObject(_ref[1].data);
   return liveObj._attach(id, doc), this._deserializeChildren(liveObj, parentToChildren, doc);
  }, LiveObject._deserializeChildren = function(liveObj, parentToChildren, doc) {
-  var children = parentToChildren.get(nn(liveObj._id));
+  var children = parentToChildren.get(liveObj._id);
   if (null == children) return liveObj;
   for (var _step2, _iterator2 = _createForOfIteratorHelperLoose(children); !(_step2 = _iterator2()).done; ) {
-   var _step2$value = _step2.value, id = _step2$value[0], crdt = _step2$value[1], child = deserialize([ id, crdt ], parentToChildren, doc);
+   var entry = _step2.value, crdt = entry[1];
+   if (null == crdt.parentKey) 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(liveObj, crdt.parentKey), liveObj._map.set(crdt.parentKey, child);
   }
   return liveObj;
@@ -1270,33 +1017,32 @@ var LiveObject = function(_AbstractCrdt) {
    var _step3$value = _step3.value;
    _step3$value[0];
    var value = _step3$value[1];
-   isLiveNode(value) && value._attach(doc.generateId(), doc);
+   value instanceof AbstractCrdt && value._attach(doc.generateId(), doc);
   }
- }, _proto._attachChild = function(op, source) {
+ }, _proto._attachChild = function(op, isLocal) {
   var _updates;
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  var id = op.id, opId = op.opId, key = op.parentKey, child = creationOpToLiveNode(op);
+  var id = op.id, parentKey = op.parentKey, opId = op.opId, key = parentKey, child = creationOpToLiveStructure(op);
   if (void 0 !== this._doc.getItem(id)) return this._propToLastUpdate.get(key) === opId && this._propToLastUpdate.delete(key), 
   {
    modified: !1
   };
-  if (source === exports.OpSource.UNDOREDO_RECONNECT) this._propToLastUpdate.set(key, nn(opId)); else if (void 0 !== this._propToLastUpdate.get(key)) return this._propToLastUpdate.get(key) === opId ? (this._propToLastUpdate.delete(key), 
+  if (isLocal) this._propToLastUpdate.set(key, opId); else if (void 0 !== this._propToLastUpdate.get(key)) return this._propToLastUpdate.get(key) === opId ? (this._propToLastUpdate.delete(key), 
   {
    modified: !1
   }) : {
    modified: !1
   };
-  var reverse, thisId = nn(this._id), previousValue = this._map.get(key);
-  if (isLiveNode(previousValue)) reverse = previousValue._serialize(thisId, key), 
-  previousValue._detach(); else if (void 0 === previousValue) reverse = [ {
+  var reverse, previousValue = this._map.get(key);
+  if (isCrdt(previousValue)) reverse = previousValue._serialize(this._id, key), previousValue._detach(); else if (void 0 === previousValue) reverse = [ {
    type: exports.OpCode.DELETE_OBJECT_KEY,
-   id: thisId,
+   id: this._id,
    key: key
   } ]; else {
    var _data;
    reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
-    id: thisId,
+    id: this._id,
     data: (_data = {}, _data[key] = previousValue, _data)
    } ];
   }
@@ -1313,7 +1059,7 @@ var LiveObject = function(_AbstractCrdt) {
   };
  }, _proto._detachChild = function(child) {
   if (child) {
-   for (var _updates2, _step4, id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc), _iterator4 = _createForOfIteratorHelperLoose(this._map); !(_step4 = _iterator4()).done; ) {
+   for (var _updates2, _step4, reverse = child._serialize(this._id, child._parentKey, this._doc), _iterator4 = _createForOfIteratorHelperLoose(this._map); !(_step4 = _iterator4()).done; ) {
     var _step4$value = _step4.value, key = _step4$value[0];
     _step4$value[1] === child && this._map.delete(key);
    }
@@ -1321,7 +1067,7 @@ var LiveObject = function(_AbstractCrdt) {
     modified: {
      node: this,
      type: "LiveObject",
-     updates: (_updates2 = {}, _updates2[parentKey] = {
+     updates: (_updates2 = {}, _updates2[child._parentKey] = {
       type: "delete"
      }, _updates2)
     },
@@ -1331,46 +1077,51 @@ var LiveObject = function(_AbstractCrdt) {
   return {
    modified: !1
   };
+ }, _proto._detachChildren = function() {
+  for (var _step5, _iterator5 = _createForOfIteratorHelperLoose(this._map); !(_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() {
   _AbstractCrdt.prototype._detach.call(this);
-  for (var _step5, _iterator5 = _createForOfIteratorHelperLoose(this._map.values()); !(_step5 = _iterator5()).done; ) {
-   var value = _step5.value;
-   isLiveNode(value) && value._detach();
+  for (var _step6, _iterator6 = _createForOfIteratorHelperLoose(this._map.values()); !(_step6 = _iterator6()).done; ) {
+   var value = _step6.value;
+   isCrdt(value) && value._detach();
   }
  }, _proto._apply = function(op, isLocal) {
   return op.type === exports.OpCode.UPDATE_OBJECT ? this._applyUpdate(op, isLocal) : op.type === exports.OpCode.DELETE_OBJECT_KEY ? this._applyDeleteObjectKey(op) : _AbstractCrdt.prototype._apply.call(this, op, isLocal);
  }, _proto._toSerializedCrdt = function() {
-  for (var _step6, data = {}, _iterator6 = _createForOfIteratorHelperLoose(this._map); !(_step6 = _iterator6()).done; ) {
-   var _step6$value = _step6.value, key = _step6$value[0], value = _step6$value[1];
-   isLiveNode(value) || (data[key] = value);
+  for (var _this$_parent, _step7, data = {}, _iterator7 = _createForOfIteratorHelperLoose(this._map); !(_step7 = _iterator7()).done; ) {
+   var _step7$value = _step7.value, key = _step7$value[0], value = _step7$value[1];
+   value instanceof AbstractCrdt == !1 && (data[key] = value);
   }
-  return "HasParent" === this.parent.type && this.parent.node._id ? {
+  return void 0 !== (null == (_this$_parent = this._parent) ? void 0 : _this$_parent._id) && void 0 !== this._parentKey ? {
    type: exports.CrdtType.OBJECT,
-   parentId: this.parent.node._id,
-   parentKey: this.parent.key,
+   parentId: this._parent._id,
+   parentKey: this._parentKey,
    data: data
   } : {
    type: exports.CrdtType.OBJECT,
    data: data
   };
  }, _proto._applyUpdate = function(op, isLocal) {
-  var isModified = !1, id = nn(this._id), reverse = [], reverseUpdate = {
+  var isModified = !1, reverse = [], reverseUpdate = {
    type: exports.OpCode.UPDATE_OBJECT,
-   id: id,
+   id: this._id,
    data: {}
   };
   for (var key in reverse.push(reverseUpdate), op.data) {
    var oldValue = this._map.get(key);
-   isLiveNode(oldValue) ? (reverse.push.apply(reverse, oldValue._serialize(id, key)), 
+   oldValue instanceof AbstractCrdt ? (reverse.push.apply(reverse, oldValue._serialize(this._id, key)), 
    oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
     type: exports.OpCode.DELETE_OBJECT_KEY,
-    id: id,
+    id: this._id,
     key: key
    });
   }
   var updateDelta = {};
   for (var _key2 in op.data) {
-   if (isLocal) this._propToLastUpdate.set(_key2, nn(op.opId)); else {
+   if (isLocal) this._propToLastUpdate.set(_key2, op.opId); else {
     if (null != this._propToLastUpdate.get(_key2)) {
      if (this._propToLastUpdate.get(_key2) === op.opId) {
       this._propToLastUpdate.delete(_key2);
@@ -1381,7 +1132,7 @@ var LiveObject = function(_AbstractCrdt) {
     isModified = !0;
    }
    var _oldValue = this._map.get(_key2);
-   isLiveNode(_oldValue) && _oldValue._detach(), isModified = !0, updateDelta[_key2] = {
+   isCrdt(_oldValue) && _oldValue._detach(), isModified = !0, updateDelta[_key2] = {
     type: "update"
    }, this._map.set(_key2, op.data[_key2]);
   }
@@ -1404,12 +1155,12 @@ var LiveObject = function(_AbstractCrdt) {
   if (void 0 !== this._propToLastUpdate.get(key)) return {
    modified: !1
   };
-  var oldValue = this._map.get(key), id = nn(this._id), reverse = [];
-  if (isLiveNode(oldValue)) reverse = oldValue._serialize(id, op.key), oldValue._detach(); else if (void 0 !== oldValue) {
+  var oldValue = this._map.get(key), reverse = [];
+  if (isCrdt(oldValue)) reverse = oldValue._serialize(this._id, op.key), oldValue._detach(); else if (void 0 !== oldValue) {
    var _data2;
    reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
-    id: id,
+    id: this._id,
     data: (_data2 = {}, _data2[key] = oldValue, _data2)
    } ];
   }
@@ -1439,10 +1190,10 @@ var LiveObject = function(_AbstractCrdt) {
  }, _proto.delete = function(key) {
   var _updates4, keyAsString = key, oldValue = this._map.get(keyAsString);
   if (void 0 !== oldValue) {
-   if (null == this._doc || null == this._id) return isLiveNode(oldValue) && oldValue._detach(), 
+   if (null == this._doc || null == this._id) return oldValue instanceof AbstractCrdt && oldValue._detach(), 
    void this._map.delete(keyAsString);
    var reverse, _data3;
-   if (isLiveNode(oldValue)) oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString); else reverse = [ {
+   if (oldValue instanceof AbstractCrdt) oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString); else reverse = [ {
     type: exports.OpCode.UPDATE_OBJECT,
     data: (_data3 = {}, _data3[keyAsString] = oldValue, _data3),
     id: this._id
@@ -1472,19 +1223,19 @@ var LiveObject = function(_AbstractCrdt) {
    }, updateDelta = {};
    for (var _key3 in overrides) {
     var _oldValue2 = this._map.get(_key3);
-    isLiveNode(_oldValue2) ? (reverseOps.push.apply(reverseOps, _oldValue2._serialize(this._id, _key3)), 
+    _oldValue2 instanceof AbstractCrdt ? (reverseOps.push.apply(reverseOps, _oldValue2._serialize(this._id, _key3)), 
     _oldValue2._detach()) : void 0 === _oldValue2 ? reverseOps.push({
      type: exports.OpCode.DELETE_OBJECT_KEY,
      id: this._id,
      key: _key3
     }) : reverseUpdateOp.data[_key3] = _oldValue2;
     var _newValue = overrides[_key3];
-    if (isLiveNode(_newValue)) {
+    if (_newValue instanceof AbstractCrdt) {
      _newValue._setParentLink(this, _key3), _newValue._attach(this._doc.generateId(), this._doc);
      var newAttachChildOps = _newValue._serialize(this._id, _key3, this._doc), createCrdtOp = newAttachChildOps.find((function(op) {
       return op.parentId === _this2._id;
      }));
-     createCrdtOp && this._propToLastUpdate.set(_key3, nn(createCrdtOp.opId)), ops.push.apply(ops, newAttachChildOps);
+     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"
@@ -1505,22 +1256,23 @@ var LiveObject = function(_AbstractCrdt) {
    }), this._doc.dispatch(ops, reverseOps, storageUpdates);
   } else for (var key in overrides) {
    var oldValue = this._map.get(key);
-   isLiveNode(oldValue) && oldValue._detach();
+   oldValue instanceof AbstractCrdt && oldValue._detach();
    var newValue = overrides[key];
-   isLiveNode(newValue) && newValue._setParentLink(this, key), this._map.set(key, newValue);
+   newValue instanceof AbstractCrdt && newValue._setParentLink(this, key), this._map.set(key, newValue);
   }
  }, LiveObject;
 }(AbstractCrdt);
 
-exports.LiveList = LiveList, exports.LiveMap = LiveMap, exports.LiveObject = LiveObject, 
-exports.LiveRegister = LiveRegister, exports._createForOfIteratorHelperLoose = _createForOfIteratorHelperLoose, 
+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 = function(source, excluded) {
  if (null == source) return {};
  var key, i, target = {}, sourceKeys = Object.keys(source);
  for (i = 0; i < sourceKeys.length; i++) key = sourceKeys[i], excluded.indexOf(key) >= 0 || (target[key] = source[key]);
  return target;
-}, exports._wrapNativeSuper = _wrapNativeSuper, exports.assertNever = assertNever, 
-exports.b64decode = function(b64value) {
+}, exports._wrapNativeSuper = _wrapNativeSuper, exports.assertNever = function(_value, errmsg) {
+ throw new Error(errmsg);
+}, exports.b64decode = function(b64value) {
  try {
   var formattedValue = b64value.replace(/-/g, "+").replace(/_/g, "/");
   return decodeURIComponent(atob(formattedValue).split("").map((function(c) {
@@ -1533,9 +1285,10 @@ exports.b64decode = function(b64value) {
  return items.filter((function(item) {
   return null != item;
  }));
-}, exports.comparePosition = comparePosition, exports.deprecate = deprecate, exports.deprecateIf = function(condition, message, key) {
- void 0 === key && (key = message), "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
-}, exports.errorIf = errorIf, exports.findNonSerializableValue = function findNonSerializableValue(value, path) {
+}, exports.comparePosition = comparePosition, exports.deprecate = deprecate, exports.deprecateIf = deprecateIf, 
+exports.errorIf = function(condition, message) {
+ "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
+}, exports.findNonSerializableValue = function findNonSerializableValue(value, path) {
  if (void 0 === path && (path = ""), !isPlain) return {
   path: path || "root",
   value: value
@@ -1569,7 +1322,7 @@ exports.b64decode = function(b64value) {
   })), crdt.parentKey !== currentCrdt.parentKey && ops.push({
    type: exports.OpCode.SET_PARENT_KEY,
    id: id,
-   parentKey: nn(crdt.parentKey, "Parent key must not be missing")
+   parentKey: crdt.parentKey
   }); else switch (crdt.type) {
   case exports.CrdtType.REGISTER:
    ops.push({
@@ -1614,11 +1367,10 @@ exports.b64decode = function(b64value) {
   }
  })), ops;
 }, exports.isChildCrdt = isChildCrdt, exports.isJsonArray = isJsonArray, exports.isJsonObject = isJsonObject, 
-exports.isLiveList = isLiveList, exports.isLiveNode = isLiveNode, exports.isLiveObject = isLiveObject, 
-exports.isRootCrdt = function(crdt) {
+exports.isJsonScalar = isJsonScalar, exports.isPlainObject = isPlainObject, exports.isRootCrdt = function(crdt) {
  return crdt.type === exports.CrdtType.OBJECT && !isChildCrdt(crdt);
 }, exports.isSameNodeOrChildOf = function isSameNodeOrChildOf(node, parent) {
- return node === parent || "HasParent" === node.parent.type && isSameNodeOrChildOf(node.parent.node, parent);
+ return node === parent || !!node._parent && isSameNodeOrChildOf(node._parent, parent);
 }, exports.isTokenValid = function(token) {
  var tokenParts = token.split(".");
  if (3 !== tokenParts.length) return !1;
@@ -1646,7 +1398,7 @@ exports.isRootCrdt = function(crdt) {
    updates: first.updates.concat(second.updates)
   });
  }(first, second) : second : second;
-}, exports.nn = nn, exports.remove = function(array, item) {
+}, exports.remove = function(array, item) {
  for (var i = 0; i < array.length; i++) if (array[i] === item) {
   array.splice(i, 1);
   break;