@liveblocks/client 0.16.13 → 0.16.14

package/shared.mjs

@@ -1,39 +1,4 @@
-const _emittedDeprecationWarnings = new Set;
-
-function deprecate(message, key = message) {
- "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
- console.error(`DEPRECATION WARNING: ${message}`)));
-}
-
-function deprecateIf(condition, message, key = message) {
- "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
-}
-
-function throwUsageError(message) {
- if ("production" !== process.env.NODE_ENV) {
-  const 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 = "Expected value to be non-nullable") {
- return function(condition, errmsg) {
-  if ("production" !== process.env.NODE_ENV && !condition) {
-   const err = new Error(errmsg);
-   throw err.name = "Assertion failure", err;
-  }
- }(null != value, errmsg), value;
-}
-
-var ClientMsgCode, OpCode, CrdtType, ServerMsgCode, WebsocketCloseCodes, OpSource;
+var ServerMsgCode, ClientMsgCode, CrdtType, OpCode, WebsocketCloseCodes;
 
 function isRootCrdt(crdt) {
  return crdt.type === CrdtType.OBJECT && !isChildCrdt(crdt);
@@ -43,32 +8,24 @@ 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
- });
-}
-
-!function(ClientMsgCode) {
+!function(ServerMsgCode) {
+ 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";
+}(ServerMsgCode || (ServerMsgCode = {})), function(ClientMsgCode) {
  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";
-}(ClientMsgCode || (ClientMsgCode = {})), function(OpCode) {
+}(ClientMsgCode || (ClientMsgCode = {})), function(CrdtType) {
+ CrdtType[CrdtType.OBJECT = 0] = "OBJECT", CrdtType[CrdtType.LIST = 1] = "LIST", 
+ CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER";
+}(CrdtType || (CrdtType = {})), function(OpCode) {
  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";
-}(OpCode || (OpCode = {})), function(CrdtType) {
- CrdtType[CrdtType.OBJECT = 0] = "OBJECT", CrdtType[CrdtType.LIST = 1] = "LIST", 
- CrdtType[CrdtType.MAP = 2] = "MAP", CrdtType[CrdtType.REGISTER = 3] = "REGISTER";
-}(CrdtType || (CrdtType = {})), function(ServerMsgCode) {
- 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";
-}(ServerMsgCode || (ServerMsgCode = {})), function(WebsocketCloseCodes) {
+}(OpCode || (OpCode = {})), function(WebsocketCloseCodes) {
  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", 
@@ -76,41 +33,9 @@ function HasParent(node, key) {
  WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP", 
  WebsocketCloseCodes[WebsocketCloseCodes.MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM", 
  WebsocketCloseCodes[WebsocketCloseCodes.CLOSE_WITHOUT_RETRY = 4999] = "CLOSE_WITHOUT_RETRY";
-}(WebsocketCloseCodes || (WebsocketCloseCodes = {})), function(OpSource) {
- OpSource[OpSource.UNDOREDO_RECONNECT = 0] = "UNDOREDO_RECONNECT", OpSource[OpSource.REMOTE = 1] = "REMOTE", 
- OpSource[OpSource.ACK = 2] = "ACK";
-}(OpSource || (OpSource = {}));
-
-const NoParent = Object.freeze({
- type: "NoParent"
-});
-
-function Orphaned(oldKey) {
- return Object.freeze({
-  type: "Orphaned",
-  oldKey: oldKey
- });
-}
+}(WebsocketCloseCodes || (WebsocketCloseCodes = {}));
 
 class AbstractCrdt {
- constructor() {
-  this._parent = NoParent;
- }
- _getParentKeyOrThrow() {
-  switch (this.parent.type) {
-  case "HasParent":
-   return this.parent.key;
-
-  case "NoParent":
-   throw new Error("Parent key is missing");
-
-  case "Orphaned":
-   return this.parent.oldKey;
-
-  default:
-   return assertNever(this.parent, "Unknown state");
-  }
- }
  get _doc() {
   return this.__doc;
  }
@@ -120,81 +45,39 @@ class AbstractCrdt {
  get _id() {
   return this.__id;
  }
- get parent() {
-  return this._parent;
- }
- get _parentNode() {
-  switch (this.parent.type) {
-  case "HasParent":
-   return this.parent.node;
-
-  case "NoParent":
-  case "Orphaned":
-   return null;
-
-  default:
-   return assertNever(this.parent, "Unknown state");
-  }
+ get _parent() {
+  return this.__parent;
  }
  get _parentKey() {
-  switch (this.parent.type) {
-  case "HasParent":
-   return this.parent.key;
-
-  case "NoParent":
-   return null;
-
-  case "Orphaned":
-   return this.parent.oldKey;
-
-  default:
-   return assertNever(this.parent, "Unknown state");
-  }
+  return this.__parentKey;
  }
  _apply(op, _isLocal) {
-  return op.type === OpCode.DELETE_CRDT && "HasParent" === this.parent.type ? this.parent.node._detachChild(this) : {
+  return op.type === OpCode.DELETE_CRDT && null != this._parent && null != this._parentKey ? this._parent._detachChild(this) : {
    modified: !1
   };
  }
- _setParentLink(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");
-  }
+ _setParentLink(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;
  }
  _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;
  }
  _detach() {
-  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;
  }
 }
 
+function isJsonArray(data) {
+ return Array.isArray(data);
+}
+
+function isJsonObject(data) {
+ return null !== data && "object" == typeof data && !isJsonArray(data);
+}
+
 class LiveRegister extends AbstractCrdt {
  constructor(data) {
   super(), this._data = data;
@@ -206,27 +89,28 @@ class LiveRegister extends AbstractCrdt {
   const register = new LiveRegister(item.data);
   return register._attach(id, doc), register;
  }
- _serialize(parentId, parentKey, doc) {
+ _serialize(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: OpCode.CREATE_REGISTER,
    opId: null == doc ? void 0 : doc.generateOpId(),
    id: this._id,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: this.data
   } ];
  }
  _toSerializedCrdt() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveRegister if parent is missing");
+  var _a;
   return {
    type: CrdtType.REGISTER,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key,
+   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
+   parentKey: this._parentKey,
    data: this.data
   };
  }
- _attachChild(_op) {
+ _attachChild(_op, _isLocal) {
   throw new Error("Method not implemented.");
  }
  _detachChild(_crdt) {
@@ -238,7 +122,7 @@ class LiveRegister extends 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) {
   const result = [], beforeCodes = posCodes(before);
   for (let i = 0; i < beforeCodes.length; i++) {
    const code = beforeCodes[i];
@@ -252,7 +136,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(before) : null != after ? function(after) {
+ }(before) : null == before && null != after ? function(after) {
   const result = [], afterCodes = posCodes(after);
   for (let i = 0; i < afterCodes.length; i++) {
    const code = afterCodes[i];
@@ -266,7 +150,7 @@ function makePosition(before, after) {
    }
   }
   return pos(result);
- }(after) : pos([ 33 ]);
+ }(after) : pos(makePositionFromCodes(posCodes(before), posCodes(after)));
 }
 
 function makePositionFromCodes(before, after) {
@@ -312,243 +196,114 @@ function comparePosition(posA, posB) {
 class LiveList extends AbstractCrdt {
  constructor(items = []) {
   let position;
-  super(), this._items = [], this._implicitlyDeletedItems = new Set;
+  super(), this._items = [];
   for (let i = 0; i < items.length; i++) {
-   const newPosition = makePosition(position), item = lsonToLiveNode(items[i]);
-   item._setParentLink(this, newPosition), this._items.push(item), position = newPosition;
+   const newPosition = makePosition(position), item = selfOrRegister(items[i]);
+   this._items.push([ item, newPosition ]), position = newPosition;
   }
  }
  static _deserialize([id], parentToChildren, doc) {
-  const list = new LiveList;
+  const list = new LiveList([]);
   list._attach(id, doc);
   const children = parentToChildren.get(id);
   if (null == children) return list;
-  for (const [id, crdt] of children) {
-   const child = deserialize([ id, crdt ], parentToChildren, doc);
-   child._setParentLink(list, crdt.parentKey), list._items.push(child), sortListItem(list._items);
+  for (const entry of children) {
+   const child = deserialize(entry, parentToChildren, doc);
+   child._setParentLink(list, entry[1].parentKey), list._items.push([ child, entry[1].parentKey ]), 
+   list._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
   }
   return list;
  }
- _serialize(parentId, parentKey, doc) {
+ _serialize(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");
   const ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
+   intent: intent,
    type: OpCode.CREATE_LIST,
    parentId: parentId,
    parentKey: parentKey
   };
   ops.push(op);
-  for (const item of this._items) ops.push(...item._serialize(this._id, item._getParentKeyOrThrow(), doc));
+  for (const [value, key] of this._items) ops.push(...value._serialize(this._id, key, doc));
   return ops;
  }
  _indexOfPosition(position) {
-  return this._items.findIndex((item => item._getParentKeyOrThrow() === position));
+  return this._items.findIndex((item => item[1] === position));
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const item of this._items) item._attach(doc.generateId(), doc);
+  for (const [item] of this._items) item._attach(doc.generateId(), doc);
  }
  _detach() {
   super._detach();
-  for (const item of this._items) item._detach();
- }
- _applyRemoteSet(op) {
-  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
-  child._attach(id, this._doc), child._setParentLink(this, key);
-  const deletedId = op.deletedId, existingItemIndex = this._indexOfPosition(key);
-  if (-1 !== existingItemIndex) {
-   const 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;
-    const delta = [ setDelta(existingItemIndex, child) ], deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-    return deleteDelta && delta.push(deleteDelta), {
-     modified: makeUpdate(this, delta),
-     reverse: []
-    };
-   }
-  }
-  {
-   const updates = [], deleteDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-   return deleteDelta && updates.push(deleteDelta), this._items.push(child), sortListItem(this._items), 
-   updates.push(insertDelta(this._indexOfPosition(key), child)), {
-    reverse: [],
-    modified: makeUpdate(this, updates)
-   };
-  }
- }
- _applySetAck(op) {
-  const delta = [], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-  deletedDelta && delta.push(deletedDelta);
-  const indexOfItemWithSamePosition = this._indexOfPosition(op.parentKey), existingItem = this._items.find((item => 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)));
-   const previousIndex = this._items.indexOf(existingItem);
-   existingItem._setParentLink(this, op.parentKey), sortListItem(this._items);
-   const newIndex = this._items.indexOf(existingItem);
-   return newIndex !== previousIndex && delta.push(moveDelta(previousIndex, newIndex, existingItem)), 
-   {
-    modified: delta.length > 0 && makeUpdate(this, delta),
-    reverse: []
-   };
-  }
-  {
-   const 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);
-    const recreatedItemIndex = this._items.indexOf(orphan);
-    return {
-     modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(recreatedItemIndex, orphan) : setDelta(recreatedItemIndex, orphan), ...delta ]),
-     reverse: []
-    };
-   }
-   {
-    const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, op.parentKey);
-    return {
-     modified: makeUpdate(this, [ -1 === indexOfItemWithSamePosition ? insertDelta(newIndex, newItem) : setDelta(newIndex, newItem), ...delta ]),
-     reverse: []
-    };
-   }
-  }
+  for (const [value] of this._items) value._detach();
  }
- _detachItemAssociatedToSetOperation(deletedId) {
-  if (null == deletedId || null == this._doc) return null;
-  const deletedItem = this._doc.getItem(deletedId);
-  if (null == deletedItem) return null;
-  const result = this._detachChild(deletedItem);
-  return !1 === result.modified ? null : result.modified.updates[0];
- }
- _applyRemoteInsert(op) {
+ _attachChild(op, isLocal) {
+  var _a;
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const key = op.parentKey, existingItemIndex = this._indexOfPosition(key);
-  -1 !== existingItemIndex && this._shiftItemPosition(existingItemIndex, key);
-  const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, key);
-  return {
-   modified: makeUpdate(this, [ insertDelta(newIndex, newItem) ]),
-   reverse: []
+  const {id: id, parentKey: parentKey, intent: intent} = op, key = parentKey, child = creationOpToLiveStructure(op);
+  if (void 0 !== this._doc.getItem(id)) return {
+   modified: !1
   };
- }
- _applyInsertAck(op) {
-  const existingItem = this._items.find((item => item._id === op.id)), key = op.parentKey, itemIndexAtPosition = this._indexOfPosition(key);
-  if (existingItem) {
-   if (existingItem._parentKey === key) return {
-    modified: !1
-   };
-   {
-    const oldPositionIndex = this._items.indexOf(existingItem);
-    -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key), 
-    existingItem._setParentLink(this, key), sortListItem(this._items);
-    const newIndex = this._indexOfPosition(key);
-    return newIndex === oldPositionIndex ? {
-     modified: !1
-    } : {
-     modified: makeUpdate(this, [ moveDelta(oldPositionIndex, newIndex, existingItem) ]),
-     reverse: []
-    };
-   }
-  }
-  {
-   const orphan = nn(this._doc).getItem(op.id);
-   if (orphan && this._implicitlyDeletedItems.has(orphan)) {
-    orphan._setParentLink(this, key), this._implicitlyDeletedItems.delete(orphan), this._items.push(orphan), 
-    sortListItem(this._items);
-    return {
-     modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(key), orphan) ]),
-     reverse: []
+  child._attach(id, this._doc), child._setParentLink(this, key);
+  const index = this._items.findIndex((entry => entry[1] === key));
+  let newKey = key;
+  if (-1 !== index) {
+   if ("set" === intent) {
+    const existingItem = this._items[index][0];
+    existingItem._detach();
+    const storageUpdate = {
+     node: this,
+     type: "LiveList",
+     updates: [ {
+      index: index,
+      type: "set",
+      item: child instanceof LiveRegister ? child.data : child
+     } ]
     };
-   }
-   {
-    -1 !== itemIndexAtPosition && this._shiftItemPosition(itemIndexAtPosition, key);
-    const {newItem: newItem, newIndex: newIndex} = this._createAttachItemAndSort(op, key);
-    return {
-     modified: makeUpdate(this, [ insertDelta(newIndex, newItem) ]),
-     reverse: []
+    return this._items[index][0] = child, {
+     modified: storageUpdate,
+     reverse: existingItem._serialize(this._id, key, this._doc, "set")
     };
    }
+   if (isLocal) {
+    const 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 this._items[index][1] = makePosition(key, null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a[1]);
   }
- }
- _applyInsertUndoRedo(op) {
-  var _a;
-  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
-  if (void 0 !== (null === (_a = this._doc) || void 0 === _a ? void 0 : _a.getItem(id))) return {
-   modified: !1
-  };
-  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
-  const existingItemIndex = this._indexOfPosition(key);
-  let newKey = key;
-  if (-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);
-  }
-  this._items.push(child), sortListItem(this._items);
+  this._items.push([ child, newKey ]), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
+  const newIndex = this._items.findIndex((entry => entry[1] === newKey));
   return {
-   modified: makeUpdate(this, [ insertDelta(this._indexOfPosition(newKey), child) ]),
    reverse: [ {
     type: OpCode.DELETE_CRDT,
     id: id
-   } ]
-  };
- }
- _applySetUndoRedo(op) {
-  var _a;
-  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
-  if (void 0 !== (null === (_a = this._doc) || void 0 === _a ? void 0 : _a.getItem(id))) return {
-   modified: !1
+   } ],
+   modified: {
+    node: this,
+    type: "LiveList",
+    updates: [ {
+     index: newIndex,
+     type: "insert",
+     item: child instanceof LiveRegister ? child.data : child
+    } ]
+   }
   };
-  const indexOfItemWithSameKey = this._indexOfPosition(key);
-  child._attach(id, nn(this._doc)), child._setParentLink(this, key);
-  const newKey = key;
-  if (-1 !== indexOfItemWithSameKey) {
-   const existingItem = this._items[indexOfItemWithSameKey];
-   existingItem._detach(), this._items[indexOfItemWithSameKey] = child;
-   const reverse = existingItem._serialize(nn(this._id), key, this._doc);
-   addIntentAndDeletedIdToOperation(reverse, op.id);
-   const delta = [ setDelta(indexOfItemWithSameKey, child) ], deletedDelta = this._detachItemAssociatedToSetOperation(op.deletedId);
-   return deletedDelta && delta.push(deletedDelta), {
-    modified: makeUpdate(this, delta),
-    reverse: reverse
-   };
-  }
-  {
-   this._items.push(child), sortListItem(this._items), this._detachItemAssociatedToSetOperation(op.deletedId);
-   const newIndex = this._indexOfPosition(newKey);
-   return {
-    reverse: [ {
-     type: OpCode.DELETE_CRDT,
-     id: id
-    } ],
-    modified: makeUpdate(this, [ insertDelta(newIndex, child) ])
-   };
-  }
- }
- _attachChild(op, source) {
-  if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  if ("set" === op.intent) {
-   if (source === OpSource.REMOTE) return this._applyRemoteSet(op);
-   if (source === OpSource.UNDOREDO_RECONNECT) return this._applySetUndoRedo(op);
-   if (source === OpSource.ACK) return this._applySetAck(op);
-  }
-  return source === OpSource.REMOTE ? this._applyRemoteInsert(op) : source === OpSource.ACK ? this._applyInsertAck(op) : this._applyInsertUndoRedo(op);
  }
  _detachChild(child) {
   if (child) {
-   const parentKey = nn(child._parentKey), reverse = child._serialize(nn(this._id), parentKey, this._doc), indexToDelete = this._items.indexOf(child);
-   return this._items.splice(indexToDelete, 1), child._detach(), {
-    modified: makeUpdate(this, [ deleteDelta(indexToDelete) ]),
+   const reverse = child._serialize(this._id, child._parentKey, this._doc), indexToDelete = this._items.findIndex((item => item[0] === child));
+   this._items.splice(indexToDelete, 1), child._detach();
+   return {
+    modified: {
+     node: this,
+     type: "LiveList",
+     updates: [ {
+      index: indexToDelete,
+      type: "delete"
+     } ]
+    },
     reverse: reverse
    };
   }
@@ -556,100 +311,41 @@ class LiveList extends AbstractCrdt {
    modified: !1
   };
  }
- _applySetChildKeyRemote(newKey, child) {
-  var _a;
-  if (this._implicitlyDeletedItems.has(child)) {
-   this._implicitlyDeletedItems.delete(child), child._setParentLink(this, newKey), 
-   this._items.push(child), sortListItem(this._items);
-   return {
-    modified: makeUpdate(this, [ insertDelta(this._items.indexOf(child), child) ]),
-    reverse: []
-   };
-  }
-  if (newKey === child._parentKey) return {
-   modified: !1
-  };
-  const existingItemIndex = this._indexOfPosition(newKey);
-  if (-1 === existingItemIndex) {
-   const previousIndex = this._items.indexOf(child);
-   child._setParentLink(this, newKey), sortListItem(this._items);
-   const newIndex = this._items.indexOf(child);
-   return newIndex === previousIndex ? {
-    modified: !1
-   } : {
-    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
-    reverse: []
-   };
-  }
-  {
-   this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow()));
-   const previousIndex = this._items.indexOf(child);
-   child._setParentLink(this, newKey), sortListItem(this._items);
-   const newIndex = this._items.indexOf(child);
-   return newIndex === previousIndex ? {
-    modified: !1
-   } : {
-    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
-    reverse: []
-   };
-  }
- }
- _applySetChildKeyAck(newKey, child) {
-  var _a, _b;
-  const previousKey = nn(child._parentKey);
-  if (this._implicitlyDeletedItems.has(child)) {
-   const existingItemIndex = this._indexOfPosition(newKey);
-   return this._implicitlyDeletedItems.delete(child), -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow())), 
-   child._setParentLink(this, newKey), this._items.push(child), sortListItem(this._items), 
-   {
-    modified: !1
-   };
-  }
-  {
-   if (newKey === previousKey) return {
-    modified: !1
-   };
-   const previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
-   -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_b = this._items[existingItemIndex + 1]) || void 0 === _b ? void 0 : _b._getParentKeyOrThrow())), 
-   child._setParentLink(this, newKey), sortListItem(this._items);
-   const newIndex = this._items.indexOf(child);
-   return previousIndex === newIndex ? {
-    modified: !1
-   } : {
-    modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
-    reverse: []
-   };
-  }
- }
- _applySetChildKeyUndoRedo(newKey, child) {
+ _setChildKey(key, child, previousKey) {
   var _a;
-  const previousKey = nn(child._parentKey), previousIndex = this._items.indexOf(child), existingItemIndex = this._indexOfPosition(newKey);
-  -1 !== existingItemIndex && this._items[existingItemIndex]._setParentLink(this, makePosition(newKey, null === (_a = this._items[existingItemIndex + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow())), 
-  child._setParentLink(this, newKey), sortListItem(this._items);
-  const newIndex = this._items.indexOf(child);
-  return previousIndex === newIndex ? {
-   modified: !1
-  } : {
-   modified: makeUpdate(this, [ moveDelta(previousIndex, newIndex, child) ]),
+  child._setParentLink(this, key);
+  const previousIndex = this._items.findIndex((entry => entry[0]._id === child._id)), index = this._items.findIndex((entry => entry[1] === key));
+  -1 !== index && (this._items[index][1] = makePosition(key, null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a[1]));
+  const item = this._items.find((item => item[0] === child));
+  item && (item[1] = key), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
+  const newIndex = this._items.findIndex((entry => 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: OpCode.SET_PARENT_KEY,
-    id: nn(child._id),
+    id: null == item ? void 0 : item[0]._id,
     parentKey: previousKey
    } ]
   };
  }
- _setChildKey(newKey, child, source) {
-  return source === OpSource.REMOTE ? this._applySetChildKeyRemote(newKey, child) : source === OpSource.ACK ? this._applySetChildKeyAck(newKey, child) : this._applySetChildKeyUndoRedo(newKey, child);
- }
  _apply(op, isLocal) {
   return super._apply(op, isLocal);
  }
  _toSerializedCrdt() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveList if parent is missing");
+  var _a;
   return {
    type: CrdtType.LIST,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key
+   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
+   parentKey: this._parentKey
   };
  }
  get length() {
@@ -660,14 +356,25 @@ class LiveList extends AbstractCrdt {
  }
  insert(element, index) {
   if (index < 0 || index > this._items.length) throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${this._items.length}`);
-  const 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) {
+  const 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(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
+  const newIndex = this._items.findIndex((entry => entry[1] === position));
+  if (this._doc && this._id) {
    const id = this._doc.generateId();
-   value._attach(id, this._doc), this._doc.dispatch(value._serialize(this._id, position, this._doc), [ {
+   value._attach(id, this._doc);
+   const storageUpdates = new Map;
+   storageUpdates.set(this._id, {
+    node: this,
+    type: "LiveList",
+    updates: [ {
+     index: newIndex,
+     item: value instanceof LiveRegister ? value.data : value,
+     type: "insert"
+    } ]
+   }), this._doc.dispatch(value._serialize(this._id, position, this._doc), [ {
     type: OpCode.DELETE_CRDT,
     id: id
-   } ], new Map([ [ this._id, makeUpdate(this, [ insertDelta(index, value) ]) ] ]));
+   } ], storageUpdates);
   }
  }
  move(index, targetIndex) {
@@ -676,20 +383,31 @@ class LiveList extends 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");
   let 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());
-  const position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item._getParentKeyOrThrow();
-  if (item._setParentLink(this, position), sortListItem(this._items), this._doc && this._id) {
-   const 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]);
+  const position = makePosition(beforePosition, afterPosition), item = this._items[index], previousPosition = item[1];
+  item[1] = position, item[0]._setParentLink(this, position), this._items.sort(((itemA, itemB) => comparePosition(itemA[1], itemB[1])));
+  const newIndex = this._items.findIndex((entry => entry[1] === position));
+  if (this._doc && this._id) {
+   const storageUpdates = new Map;
+   storageUpdates.set(this._id, {
+    node: this,
+    type: "LiveList",
+    updates: [ {
+     index: newIndex,
+     previousIndex: index,
+     item: item[0],
+     type: "move"
+    } ]
+   }), this._doc.dispatch([ {
     type: OpCode.SET_PARENT_KEY,
-    id: nn(item._id),
+    id: item[0]._id,
     opId: this._doc.generateOpId(),
     parentKey: position
    } ], [ {
     type: OpCode.SET_PARENT_KEY,
-    id: nn(item._id),
+    id: item[0]._id,
     parentKey: previousPosition
    } ], storageUpdates);
   }
@@ -697,15 +415,22 @@ class LiveList extends AbstractCrdt {
  delete(index) {
   if (index < 0 || index >= this._items.length) throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
   const item = this._items[index];
-  if (item._detach(), this._items.splice(index, 1), this._doc) {
-   const childRecordId = item._id;
+  if (item[0]._detach(), this._items.splice(index, 1), this._doc) {
+   const childRecordId = item[0]._id;
    if (childRecordId) {
     const 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: OpCode.DELETE_CRDT
-    } ], item._serialize(nn(this._id), item._getParentKeyOrThrow()), storageUpdates);
+    } ], item[0]._serialize(this._id, item[1]), storageUpdates);
    }
   }
  }
@@ -714,41 +439,50 @@ class LiveList extends AbstractCrdt {
    const ops = [], reverseOps = [], updateDelta = [];
    let i = 0;
    for (const item of this._items) {
-    item._detach();
-    const childId = item._id;
+    item[0]._detach();
+    const childId = item[0]._id;
     childId && (ops.push({
-     type: OpCode.DELETE_CRDT,
      id: childId,
-     opId: this._doc.generateOpId()
-    }), reverseOps.push(...item._serialize(nn(this._id), item._getParentKeyOrThrow())), 
-    updateDelta.push(deleteDelta(i))), i++;
+     type: OpCode.DELETE_CRDT
+    }), reverseOps.push(...item[0]._serialize(this._id, item[1])), updateDelta.push({
+     index: i,
+     type: "delete"
+    })), i++;
    }
    this._items = [];
    const 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 (const item of this._items) item._detach();
+   for (const item of this._items) item[0]._detach();
    this._items = [];
   }
  }
  set(index, item) {
   if (index < 0 || index >= this._items.length) throw new Error(`Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
-  const existingItem = this._items[index], position = existingItem._getParentKeyOrThrow(), existingId = existingItem._id;
+  const [existingItem, position] = this._items[index];
   existingItem._detach();
-  const value = lsonToLiveNode(item);
-  if (value._setParentLink(this, position), this._items[index] = value, this._doc && this._id) {
+  const value = selfOrRegister(item);
+  if (value._setParentLink(this, position), this._items[index][0] = value, this._doc && this._id) {
    const id = this._doc.generateId();
    value._attach(id, this._doc);
    const storageUpdates = new Map;
-   storageUpdates.set(this._id, makeUpdate(this, [ setDelta(index, value) ]));
-   const ops = value._serialize(this._id, position, this._doc);
-   addIntentAndDeletedIdToOperation(ops, existingId);
-   const 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);
   }
  }
  toArray() {
-  return this._items.map((entry => liveNodeToLson(entry)));
+  return this._items.map((entry => selfOrRegisterValue(entry[0])));
  }
  every(predicate) {
   return this.toArray().every(predicate);
@@ -766,7 +500,7 @@ class LiveList extends AbstractCrdt {
   return this.toArray().forEach(callbackfn);
  }
  get(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]);
  }
  indexOf(searchElement, fromIndex) {
   return this.toArray().indexOf(searchElement, fromIndex);
@@ -775,7 +509,7 @@ class LiveList extends AbstractCrdt {
   return this.toArray().lastIndexOf(searchElement, fromIndex);
  }
  map(callback) {
-  return this._items.map(((entry, i) => callback(liveNodeToLson(entry), i)));
+  return this._items.map(((entry, i) => callback(selfOrRegisterValue(entry[0]), i)));
  }
  some(predicate) {
   return this.toArray().some(predicate);
@@ -783,20 +517,6 @@ class LiveList extends AbstractCrdt {
  [Symbol.iterator]() {
   return new LiveListIterator(this._items);
  }
- _createAttachItemAndSort(op, key) {
-  const newItem = creationOpToLiveNode(op);
-  newItem._attach(op.id, nn(this._doc)), newItem._setParentLink(this, key), this._items.push(newItem), 
-  sortListItem(this._items);
-  return {
-   newItem: newItem,
-   newIndex: this._indexOfPosition(key)
-  };
- }
- _shiftItemPosition(index, key) {
-  var _a;
-  const shiftedPosition = makePosition(key, this._items.length > index + 1 ? null === (_a = this._items[index + 1]) || void 0 === _a ? void 0 : _a._getParentKeyOrThrow() : void 0);
-  this._items[index]._setParentLink(this, shiftedPosition);
- }
 }
 
 class LiveListIterator {
@@ -808,85 +528,57 @@ class LiveListIterator {
  }
  next() {
   const result = this._innerIterator.next();
-  if (result.done) return {
+  return result.done ? {
    done: !0,
    value: void 0
-  };
-  return {
-   value: liveNodeToLson(result.value)
+  } : {
+   value: selfOrRegisterValue(result.value[0])
   };
  }
 }
 
-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
- };
-}
-
-function deleteDelta(index) {
- return {
-  index: index,
-  type: "delete"
- };
-}
+const _emittedDeprecationWarnings = new Set;
 
-function insertDelta(index, item) {
- return {
-  index: index,
-  type: "insert",
-  item: item instanceof LiveRegister ? item.data : item
- };
+function deprecate(message, key = message) {
+ "production" !== process.env.NODE_ENV && (_emittedDeprecationWarnings.has(key) || (_emittedDeprecationWarnings.add(key), 
+ console.error(`DEPRECATION WARNING: ${message}`)));
 }
 
-function moveDelta(previousIndex, index, item) {
- return {
-  index: index,
-  type: "move",
-  previousIndex: previousIndex,
-  item: item instanceof LiveRegister ? item.data : item
- };
+function deprecateIf(condition, message, key = message) {
+ "production" !== process.env.NODE_ENV && condition && deprecate(message, key);
 }
 
-function sortListItem(items) {
- items.sort(((itemA, itemB) => comparePosition(itemA._getParentKeyOrThrow(), itemB._getParentKeyOrThrow())));
+function throwUsageError(message) {
+ if ("production" !== process.env.NODE_ENV) {
+  const usageError = new Error(message);
+  throw usageError.name = "Usage error", usageError;
+ }
 }
 
-function addIntentAndDeletedIdToOperation(ops, deletedId) {
- if (0 === ops.length) throw new Error("Internal error. Serialized LiveStructure should have at least 1 operation");
- const firstOp = ops[0];
- if (firstOp.type !== OpCode.CREATE_LIST && firstOp.type !== OpCode.CREATE_OBJECT && firstOp.type !== OpCode.CREATE_REGISTER && firstOp.type !== OpCode.CREATE_MAP) throw new Error("Internal error. Serialized LiveStructure first op should be CreateOp");
- firstOp.intent = "set", firstOp.deletedId = deletedId;
+function errorIf(condition, message) {
+ "production" !== process.env.NODE_ENV && condition && throwUsageError(message);
 }
 
 class LiveMap extends AbstractCrdt {
  constructor(entries) {
-  if (super(), 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 (super(), 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) {
    const mappedEntries = [];
    for (const entry of entries) {
-    const value = lsonToLiveNode(entry[1]);
+    const value = selfOrRegister(entry[1]);
     value._setParentLink(this, entry[0]), mappedEntries.push([ entry[0], value ]);
    }
    this._map = new Map(mappedEntries);
   } else this._map = new Map;
  }
- _serialize(parentId, parentKey, doc) {
+ _serialize(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");
   const ops = [], op = {
    id: this._id,
    opId: null == doc ? void 0 : doc.generateOpId(),
    type: OpCode.CREATE_MAP,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey
   };
@@ -899,32 +591,30 @@ class LiveMap extends AbstractCrdt {
   map._attach(id, doc);
   const children = parentToChildren.get(id);
   if (null == children) return map;
-  for (const [id, crdt] of children) {
-   const child = deserialize([ id, crdt ], parentToChildren, doc);
+  for (const entry of children) {
+   const 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");
+   const child = deserialize(entry, parentToChildren, doc);
    child._setParentLink(map, crdt.parentKey), map._map.set(crdt.parentKey, child);
   }
   return map;
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const [_key, value] of this._map) isLiveNode(value) && value._attach(doc.generateId(), doc);
+  for (const [_key, value] of this._map) isCrdt(value) && value._attach(doc.generateId(), doc);
  }
- _attachChild(op) {
+ _attachChild(op, _isLocal) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, parentKey: key} = op, child = creationOpToLiveNode(op);
+  const {id: id, parentKey: parentKey} = op, key = parentKey, child = creationOpToLiveStructure(op);
   if (void 0 !== this._doc.getItem(id)) return {
    modified: !1
   };
   const previousValue = this._map.get(key);
   let reverse;
-  if (previousValue) {
-   const 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: 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,
@@ -943,7 +633,7 @@ class LiveMap extends AbstractCrdt {
   for (const item of this._map.values()) item._detach();
  }
  _detachChild(child) {
-  const id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc);
+  const reverse = child._serialize(this._id, child._parentKey, this._doc);
   for (const [key, value] of this._map) value === child && this._map.delete(key);
   child._detach();
   return {
@@ -951,7 +641,7 @@ class LiveMap extends AbstractCrdt {
     node: this,
     type: "LiveMap",
     updates: {
-     [parentKey]: {
+     [child._parentKey]: {
       type: "delete"
      }
     }
@@ -960,21 +650,21 @@ class LiveMap extends AbstractCrdt {
   };
  }
  _toSerializedCrdt() {
-  if ("HasParent" !== this.parent.type) throw new Error("Cannot serialize LiveMap if parent is missing");
+  var _a;
   return {
    type: CrdtType.MAP,
-   parentId: nn(this.parent.node._id, "Parent node expected to have ID"),
-   parentKey: this.parent.key
+   parentId: null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id,
+   parentKey: this._parentKey
   };
  }
  get(key) {
   const value = this._map.get(key);
-  if (null != value) return liveNodeToLson(value);
+  if (null != value) return selfOrRegisterValue(value);
  }
  set(key, value) {
   const oldValue = this._map.get(key);
   oldValue && oldValue._detach();
-  const item = lsonToLiveNode(value);
+  const item = selfOrRegister(value);
   if (item._setParentLink(this, key), this._map.set(key, item), this._doc && this._id) {
    const id = this._doc.generateId();
    item._attach(id, this._doc);
@@ -1003,8 +693,8 @@ class LiveMap extends AbstractCrdt {
   const item = this._map.get(key);
   if (null == item) return !1;
   if (item._detach(), this._map.delete(key), this._doc && item._id) {
-   const thisId = nn(this._id), storageUpdates = new Map;
-   storageUpdates.set(thisId, {
+   const storageUpdates = new Map;
+   storageUpdates.set(this._id, {
     node: this,
     type: "LiveMap",
     updates: {
@@ -1016,14 +706,14 @@ class LiveMap extends AbstractCrdt {
     type: OpCode.DELETE_CRDT,
     id: item._id,
     opId: this._doc.generateOpId()
-   } ], item._serialize(thisId, key), storageUpdates);
+   } ], item._serialize(this._id, key), storageUpdates);
   }
   return !0;
  }
  entries() {
   const innerIterator = this._map.entries();
   return {
-   [Symbol.iterator]() {
+   [Symbol.iterator]: function() {
     return this;
    },
    next() {
@@ -1033,7 +723,7 @@ class LiveMap extends AbstractCrdt {
      value: void 0
     };
     return {
-     value: [ iteratorValue.value[0], liveNodeToLson(iteratorValue.value[1]) ]
+     value: [ iteratorValue.value[0], selfOrRegisterValue(iteratorValue.value[1]) ]
     };
    }
   };
@@ -1047,17 +737,16 @@ class LiveMap extends AbstractCrdt {
  values() {
   const innerIterator = this._map.values();
   return {
-   [Symbol.iterator]() {
+   [Symbol.iterator]: function() {
     return this;
    },
    next() {
     const iteratorValue = innerIterator.next();
-    if (iteratorValue.done) return {
+    return iteratorValue.done ? {
      done: !0,
      value: void 0
-    };
-    return {
-     value: liveNodeToLson(iteratorValue.value)
+    } : {
+     value: selfOrRegisterValue(iteratorValue.value)
     };
    }
   };
@@ -1067,12 +756,8 @@ class LiveMap extends AbstractCrdt {
  }
 }
 
-function isJsonArray(data) {
- return Array.isArray(data);
-}
-
-function isJsonObject(data) {
- return null !== data && "object" == typeof data && !isJsonArray(data);
+function assertNever(_value, errmsg) {
+ throw new Error(errmsg);
 }
 
 function remove(array, item) {
@@ -1086,7 +771,7 @@ function compact(items) {
  return items.filter((item => null != item));
 }
 
-function creationOpToLiveNode(op) {
+function creationOpToLiveStructure(op) {
  switch (op.type) {
  case OpCode.CREATE_REGISTER:
   return new LiveRegister(op.data);
@@ -1099,14 +784,11 @@ function creationOpToLiveNode(op) {
 
  case OpCode.CREATE_LIST:
   return new LiveList;
-
- default:
-  return assertNever(0, "Unknown creation Op");
  }
 }
 
 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);
 }
 
 function deserialize([id, crdt], parentToChildren, doc) {
@@ -1128,28 +810,18 @@ function deserialize([id, crdt], 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 isLiveList(value) {
- return value instanceof LiveList;
-}
-
-function isLiveObject(value) {
- return value instanceof LiveObject;
+function isCrdt(obj) {
+ return obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList || obj instanceof LiveRegister;
 }
 
-function liveNodeToLson(obj) {
- return obj instanceof LiveRegister ? obj.data : obj instanceof LiveList || obj instanceof LiveMap || obj instanceof LiveObject ? obj : assertNever(0, "Unknown AbstractCrdt");
+function selfOrRegisterValue(obj) {
+ return obj instanceof LiveRegister ? obj.data : obj;
 }
 
-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 getTreesDiffOperations(currentItems, newItems) {
@@ -1168,7 +840,7 @@ function getTreesDiffOperations(currentItems, newItems) {
   })), crdt.parentKey !== currentCrdt.parentKey && ops.push({
    type: OpCode.SET_PARENT_KEY,
    id: id,
-   parentKey: nn(crdt.parentKey, "Parent key must not be missing")
+   parentKey: crdt.parentKey
   }); else switch (crdt.type) {
   case CrdtType.REGISTER:
    ops.push({
@@ -1303,16 +975,17 @@ class LiveObject extends AbstractCrdt {
   super(), this._propToLastUpdate = new Map;
   for (const key in obj) {
    const value = obj[key];
-   isLiveNode(value) && value._setParentLink(this, key);
+   value instanceof AbstractCrdt && value._setParentLink(this, key);
   }
   this._map = new Map(Object.entries(obj));
  }
- _serialize(parentId, parentKey, doc) {
+ _serialize(parentId, parentKey, doc, intent) {
   if (null == this._id) throw new Error("Cannot serialize item is not attached");
   const opId = null == doc ? void 0 : doc.generateOpId(), ops = [], op = void 0 !== parentId && void 0 !== parentKey ? {
    type: OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
+   intent: intent,
    parentId: parentId,
    parentKey: parentKey,
    data: {}
@@ -1320,10 +993,11 @@ class LiveObject extends AbstractCrdt {
    type: OpCode.CREATE_OBJECT,
    id: this._id,
    opId: opId,
+   intent: intent,
    data: {}
   };
   ops.push(op);
-  for (const [key, value] of this._map) isLiveNode(value) ? ops.push(...value._serialize(this._id, key, doc)) : op.data[key] = value;
+  for (const [key, value] of this._map) value instanceof AbstractCrdt ? ops.push(...value._serialize(this._id, key, doc)) : op.data[key] = value;
   return ops;
  }
  static _deserialize([id, item], parentToChildren, doc) {
@@ -1331,41 +1005,43 @@ class LiveObject extends AbstractCrdt {
   return liveObj._attach(id, doc), this._deserializeChildren(liveObj, parentToChildren, doc);
  }
  static _deserializeChildren(liveObj, parentToChildren, doc) {
-  const children = parentToChildren.get(nn(liveObj._id));
+  const children = parentToChildren.get(liveObj._id);
   if (null == children) return liveObj;
-  for (const [id, crdt] of children) {
-   const child = deserialize([ id, crdt ], parentToChildren, doc);
+  for (const entry of children) {
+   const 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");
+   const child = deserialize(entry, parentToChildren, doc);
    child._setParentLink(liveObj, crdt.parentKey), liveObj._map.set(crdt.parentKey, child);
   }
   return liveObj;
  }
  _attach(id, doc) {
   super._attach(id, doc);
-  for (const [_key, value] of this._map) isLiveNode(value) && value._attach(doc.generateId(), doc);
+  for (const [_key, value] of this._map) value instanceof AbstractCrdt && value._attach(doc.generateId(), doc);
  }
- _attachChild(op, source) {
+ _attachChild(op, isLocal) {
   if (null == this._doc) throw new Error("Can't attach child if doc is not present");
-  const {id: id, opId: opId, parentKey: key} = op, child = creationOpToLiveNode(op);
+  const {id: id, parentKey: parentKey, opId: opId} = op, 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 === 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
   };
-  const thisId = nn(this._id), previousValue = this._map.get(key);
+  const previousValue = this._map.get(key);
   let reverse;
-  return isLiveNode(previousValue) ? (reverse = previousValue._serialize(thisId, key), 
+  return isCrdt(previousValue) ? (reverse = previousValue._serialize(this._id, key), 
   previousValue._detach()) : reverse = void 0 === previousValue ? [ {
    type: OpCode.DELETE_OBJECT_KEY,
-   id: thisId,
+   id: this._id,
    key: key
   } ] : [ {
    type: OpCode.UPDATE_OBJECT,
-   id: thisId,
+   id: this._id,
    data: {
     [key]: previousValue
    }
@@ -1385,7 +1061,7 @@ class LiveObject extends AbstractCrdt {
  }
  _detachChild(child) {
   if (child) {
-   const id = nn(this._id), parentKey = nn(child._parentKey), reverse = child._serialize(id, parentKey, this._doc);
+   const reverse = child._serialize(this._id, child._parentKey, this._doc);
    for (const [key, value] of this._map) value === child && this._map.delete(key);
    child._detach();
    return {
@@ -1393,7 +1069,7 @@ class LiveObject extends AbstractCrdt {
      node: this,
      type: "LiveObject",
      updates: {
-      [parentKey]: {
+      [child._parentKey]: {
        type: "delete"
       }
      }
@@ -1405,20 +1081,24 @@ class LiveObject extends AbstractCrdt {
    modified: !1
   };
  }
+ _detachChildren() {
+  for (const [key, value] of this._map) this._map.delete(key), value._detach();
+ }
  _detach() {
   super._detach();
-  for (const value of this._map.values()) isLiveNode(value) && value._detach();
+  for (const value of this._map.values()) isCrdt(value) && value._detach();
  }
  _apply(op, isLocal) {
   return op.type === OpCode.UPDATE_OBJECT ? this._applyUpdate(op, isLocal) : op.type === OpCode.DELETE_OBJECT_KEY ? this._applyDeleteObjectKey(op) : super._apply(op, isLocal);
  }
  _toSerializedCrdt() {
+  var _a;
   const data = {};
-  for (const [key, value] of this._map) isLiveNode(value) || (data[key] = value);
-  return "HasParent" === this.parent.type && this.parent.node._id ? {
+  for (const [key, value] of this._map) value instanceof AbstractCrdt == !1 && (data[key] = value);
+  return void 0 !== (null === (_a = this._parent) || void 0 === _a ? void 0 : _a._id) && void 0 !== this._parentKey ? {
    type: CrdtType.OBJECT,
-   parentId: this.parent.node._id,
-   parentKey: this.parent.key,
+   parentId: this._parent._id,
+   parentKey: this._parentKey,
    data: data
   } : {
    type: CrdtType.OBJECT,
@@ -1427,23 +1107,24 @@ class LiveObject extends AbstractCrdt {
  }
  _applyUpdate(op, isLocal) {
   let isModified = !1;
-  const id = nn(this._id), reverse = [], reverseUpdate = {
+  const reverse = [], reverseUpdate = {
    type: OpCode.UPDATE_OBJECT,
-   id: id,
+   id: this._id,
    data: {}
   };
   reverse.push(reverseUpdate);
   for (const key in op.data) {
    const oldValue = this._map.get(key);
-   isLiveNode(oldValue) ? (reverse.push(...oldValue._serialize(id, key)), oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
+   oldValue instanceof AbstractCrdt ? (reverse.push(...oldValue._serialize(this._id, key)), 
+   oldValue._detach()) : void 0 !== oldValue ? reverseUpdate.data[key] = oldValue : void 0 === oldValue && reverse.push({
     type: OpCode.DELETE_OBJECT_KEY,
-    id: id,
+    id: this._id,
     key: key
    });
   }
   const updateDelta = {};
   for (const key in op.data) {
-   if (isLocal) this._propToLastUpdate.set(key, nn(op.opId)); else {
+   if (isLocal) this._propToLastUpdate.set(key, op.opId); else {
     if (null != this._propToLastUpdate.get(key)) {
      if (this._propToLastUpdate.get(key) === op.opId) {
       this._propToLastUpdate.delete(key);
@@ -1454,7 +1135,7 @@ class LiveObject extends AbstractCrdt {
     isModified = !0;
    }
    const oldValue = this._map.get(key);
-   isLiveNode(oldValue) && oldValue._detach(), isModified = !0, updateDelta[key] = {
+   isCrdt(oldValue) && oldValue._detach(), isModified = !0, updateDelta[key] = {
     type: "update"
    }, this._map.set(key, op.data[key]);
   }
@@ -1478,11 +1159,11 @@ class LiveObject extends AbstractCrdt {
   if (void 0 !== this._propToLastUpdate.get(key)) return {
    modified: !1
   };
-  const oldValue = this._map.get(key), id = nn(this._id);
+  const oldValue = this._map.get(key);
   let reverse = [];
-  return isLiveNode(oldValue) ? (reverse = oldValue._serialize(id, op.key), oldValue._detach()) : void 0 !== oldValue && (reverse = [ {
+  return isCrdt(oldValue) ? (reverse = oldValue._serialize(this._id, op.key), oldValue._detach()) : void 0 !== oldValue && (reverse = [ {
    type: OpCode.UPDATE_OBJECT,
-   id: id,
+   id: this._id,
    data: {
     [key]: oldValue
    }
@@ -1517,10 +1198,10 @@ class LiveObject extends AbstractCrdt {
  delete(key) {
   const keyAsString = key, oldValue = this._map.get(keyAsString);
   if (void 0 === oldValue) return;
-  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);
   let reverse;
-  isLiveNode(oldValue) ? (oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString)) : reverse = [ {
+  oldValue instanceof AbstractCrdt ? (oldValue._detach(), reverse = oldValue._serialize(this._id, keyAsString)) : reverse = [ {
    type: OpCode.UPDATE_OBJECT,
    data: {
     [keyAsString]: oldValue
@@ -1547,9 +1228,9 @@ class LiveObject extends AbstractCrdt {
   if (null == this._doc || null == this._id) {
    for (const key in overrides) {
     const oldValue = this._map.get(key);
-    isLiveNode(oldValue) && oldValue._detach();
+    oldValue instanceof AbstractCrdt && oldValue._detach();
     const 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);
    }
    return;
   }
@@ -1560,17 +1241,17 @@ class LiveObject extends AbstractCrdt {
   }, updateDelta = {};
   for (const key in overrides) {
    const oldValue = this._map.get(key);
-   isLiveNode(oldValue) ? (reverseOps.push(...oldValue._serialize(this._id, key)), 
+   oldValue instanceof AbstractCrdt ? (reverseOps.push(...oldValue._serialize(this._id, key)), 
    oldValue._detach()) : void 0 === oldValue ? reverseOps.push({
     type: OpCode.DELETE_OBJECT_KEY,
     id: this._id,
     key: key
    }) : reverseUpdateOp.data[key] = oldValue;
    const newValue = overrides[key];
-   if (isLiveNode(newValue)) {
+   if (newValue instanceof AbstractCrdt) {
     newValue._setParentLink(this, key), newValue._attach(this._doc.generateId(), this._doc);
     const newAttachChildOps = newValue._serialize(this._id, key, this._doc), createCrdtOp = newAttachChildOps.find((op => op.parentId === this._id));
-    createCrdtOp && this._propToLastUpdate.set(key, nn(createCrdtOp.opId)), ops.push(...newAttachChildOps);
+    createCrdtOp && this._propToLastUpdate.set(key, createCrdtOp.opId), ops.push(...newAttachChildOps);
    } else updatedProps[key] = newValue, this._propToLastUpdate.set(key, opId);
    this._map.set(key, newValue), updateDelta[key] = {
     type: "update"
@@ -1592,4 +1273,4 @@ class LiveObject extends AbstractCrdt {
  }
 }
 
-export { makePosition as A, CrdtType as B, ClientMsgCode as C, isChildCrdt as D, LiveObject as L, OpSource as O, ServerMsgCode as S, WebsocketCloseCodes as W, isTokenValid as a, isSameNodeOrChildOf as b, OpCode as c, isLiveList as d, isJsonArray as e, compact as f, getTreesDiffOperations as g, b64decode as h, isLiveNode as i, isJsonObject as j, isRootCrdt as k, errorIf as l, mergeStorageUpdates as m, nn as n, LiveList as o, LiveMap as p, LiveRegister as q, remove as r, findNonSerializableValue as s, tryParseJson as t, isLiveObject as u, assertNever as v, deprecate as w, deprecateIf as x, throwUsageError as y, comparePosition as z };
+export { AbstractCrdt as A, ClientMsgCode as C, LiveObject as L, OpCode as O, ServerMsgCode as S, WebsocketCloseCodes as W, isSameNodeOrChildOf as a, LiveList as b, isJsonArray as c, compact as d, b64decode as e, isJsonObject as f, getTreesDiffOperations as g, isRootCrdt as h, isTokenValid as i, deprecateIf as j, LiveMap as k, LiveRegister as l, mergeStorageUpdates as m, findNonSerializableValue as n, deprecate as o, errorIf as p, throwUsageError as q, remove as r, CrdtType as s, tryParseJson as t, comparePosition as u, makePosition as v, isChildCrdt as w, assertNever as x };