@liveblocks/client 0.15.10 → 0.16.0

package/lib/esm/index.js

@@ -46,48 +46,23 @@ var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
   return WebsocketCloseCodes2;
 })(WebsocketCloseCodes || {});
 
-var __accessCheck$4 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$4 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _parent, _doc, _id, _parentKey;
 class AbstractCrdt {
-  constructor() {
-    __privateAdd$4(this, _parent, void 0);
-    __privateAdd$4(this, _doc, void 0);
-    __privateAdd$4(this, _id, void 0);
-    __privateAdd$4(this, _parentKey, void 0);
-  }
   get _doc() {
-    return __privateGet$4(this, _doc);
+    return this.__doc;
   }
   get roomId() {
-    return __privateGet$4(this, _doc) ? __privateGet$4(this, _doc).roomId : null;
+    return this.__doc ? this.__doc.roomId : null;
   }
   get _id() {
-    return __privateGet$4(this, _id);
+    return this.__id;
   }
   get _parent() {
-    return __privateGet$4(this, _parent);
+    return this.__parent;
   }
   get _parentKey() {
-    return __privateGet$4(this, _parentKey);
+    return this.__parentKey;
   }
-  _apply(op, isLocal) {
+  _apply(op, _isLocal) {
     switch (op.type) {
       case OpType.DeleteCrdt: {
         if (this._parent != null && this._parentKey != null) {
@@ -99,32 +74,28 @@ class AbstractCrdt {
     return { modified: false };
   }
   _setParentLink(parent, key) {
-    if (__privateGet$4(this, _parent) != null && __privateGet$4(this, _parent) !== parent) {
+    if (this.__parent != null && this.__parent !== parent) {
       throw new Error("Cannot attach parent if it already exist");
     }
-    __privateSet$4(this, _parentKey, key);
-    __privateSet$4(this, _parent, parent);
+    this.__parentKey = key;
+    this.__parent = parent;
   }
   _attach(id, doc) {
-    if (__privateGet$4(this, _id) || __privateGet$4(this, _doc)) {
+    if (this.__id || this.__doc) {
       throw new Error("Cannot attach if CRDT is already attached");
     }
     doc.addItem(id, this);
-    __privateSet$4(this, _id, id);
-    __privateSet$4(this, _doc, doc);
+    this.__id = id;
+    this.__doc = doc;
   }
   _detach() {
-    if (__privateGet$4(this, _doc) && __privateGet$4(this, _id)) {
-      __privateGet$4(this, _doc).deleteItem(__privateGet$4(this, _id));
+    if (this.__doc && this.__id) {
+      this.__doc.deleteItem(this.__id);
     }
-    __privateSet$4(this, _parent, void 0);
-    __privateSet$4(this, _doc, void 0);
+    this.__parent = void 0;
+    this.__doc = void 0;
   }
 }
-_parent = new WeakMap();
-_doc = new WeakMap();
-_id = new WeakMap();
-_parentKey = new WeakMap();
 
 const min = 32;
 const max = 126;
@@ -227,43 +198,23 @@ function compare(posA, posB) {
   throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
 }
 
-var __accessCheck$3 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$3 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$3 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _data;
-const _LiveRegister = class extends AbstractCrdt {
+class LiveRegister extends AbstractCrdt {
   constructor(data) {
     super();
-    __privateAdd$3(this, _data, void 0);
-    __privateSet$3(this, _data, data);
+    this._data = data;
   }
   get data() {
-    return __privateGet$3(this, _data);
+    return this._data;
   }
-  static _deserialize([id, item], parentToChildren, doc) {
+  static _deserialize([id, item], _parentToChildren, doc) {
     if (item.type !== CrdtType.Register) {
       throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
     }
-    const register = new _LiveRegister(item.data);
+    const register = new LiveRegister(item.data);
     register._attach(id, doc);
     return register;
   }
-  _serialize(parentId, parentKey, doc) {
+  _serialize(parentId, parentKey, doc, intent) {
     if (this._id == null || parentId == null || parentKey == null) {
       throw new Error("Cannot serialize register if parentId or parentKey is undefined");
     }
@@ -272,6 +223,7 @@ const _LiveRegister = class extends AbstractCrdt {
         type: OpType.CreateRegister,
         opId: doc == null ? void 0 : doc.generateOpId(),
         id: this._id,
+        intent,
         parentId,
         parentKey,
         data: this.data
@@ -287,52 +239,31 @@ const _LiveRegister = class extends AbstractCrdt {
       data: this.data
     };
   }
-  _attachChild(id, key, crdt, opId, isLocal) {
+  _attachChild(_op, _isLocal) {
     throw new Error("Method not implemented.");
   }
-  _detachChild(crdt) {
+  _detachChild(_crdt) {
     throw new Error("Method not implemented.");
   }
   _apply(op, isLocal) {
     return super._apply(op, isLocal);
   }
-};
-let LiveRegister = _LiveRegister;
-_data = new WeakMap();
+}
 
-var __accessCheck$2 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$2(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$2 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$2 = (obj, member, value, setter) => {
-  __accessCheck$2(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _items, _innerIterator;
-const _LiveList = class extends AbstractCrdt {
+class LiveList extends AbstractCrdt {
   constructor(items = []) {
     super();
-    __privateAdd$2(this, _items, []);
+    this._items = [];
     let position = void 0;
     for (let i = 0; i < items.length; i++) {
       const newPosition = makePosition(position);
       const item = selfOrRegister(items[i]);
-      __privateGet$2(this, _items).push([item, newPosition]);
+      this._items.push([item, newPosition]);
       position = newPosition;
     }
   }
-  static _deserialize([id, item], parentToChildren, doc) {
-    const list = new _LiveList([]);
+  static _deserialize([id], parentToChildren, doc) {
+    const list = new LiveList([]);
     list._attach(id, doc);
     const children = parentToChildren.get(id);
     if (children == null) {
@@ -341,12 +272,12 @@ const _LiveList = class extends AbstractCrdt {
     for (const entry of children) {
       const child = deserialize(entry, parentToChildren, doc);
       child._setParentLink(list, entry[1].parentKey);
-      __privateGet$2(list, _items).push([child, entry[1].parentKey]);
-      __privateGet$2(list, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+      list._items.push([child, entry[1].parentKey]);
+      list._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
     }
     return list;
   }
-  _serialize(parentId, parentKey, doc) {
+  _serialize(parentId, parentKey, doc, intent) {
     if (this._id == null) {
       throw new Error("Cannot serialize item is not attached");
     }
@@ -357,56 +288,79 @@ const _LiveList = class extends AbstractCrdt {
     const op = {
       id: this._id,
       opId: doc == null ? void 0 : doc.generateOpId(),
+      intent,
       type: OpType.CreateList,
       parentId,
       parentKey
     };
     ops.push(op);
-    for (const [value, key] of __privateGet$2(this, _items)) {
+    for (const [value, key] of this._items) {
       ops.push(...value._serialize(this._id, key, doc));
     }
     return ops;
   }
   _indexOfPosition(position) {
-    return __privateGet$2(this, _items).findIndex((item) => item[1] === position);
+    return this._items.findIndex((item) => item[1] === position);
   }
   _attach(id, doc) {
     super._attach(id, doc);
-    for (const [item, position] of __privateGet$2(this, _items)) {
+    for (const [item] of this._items) {
       item._attach(doc.generateId(), doc);
     }
   }
   _detach() {
     super._detach();
-    for (const [value] of __privateGet$2(this, _items)) {
+    for (const [value] of this._items) {
       value._detach();
     }
   }
-  _attachChild(id, key, child, opId, isLocal) {
+  _attachChild(op, isLocal) {
     var _a;
     if (this._doc == null) {
       throw new Error("Can't attach child if doc is not present");
     }
+    const { id, parentKey, intent } = op;
+    const key = parentKey;
+    const child = creationOpToLiveStructure(op);
     if (this._doc.getItem(id) !== void 0) {
       return { modified: false };
     }
     child._attach(id, this._doc);
     child._setParentLink(this, key);
-    const index = __privateGet$2(this, _items).findIndex((entry) => entry[1] === key);
+    const index = this._items.findIndex((entry) => entry[1] === key);
     let newKey = key;
     if (index !== -1) {
-      if (isLocal) {
-        let before = __privateGet$2(this, _items)[index] ? __privateGet$2(this, _items)[index][1] : void 0;
-        let after = __privateGet$2(this, _items)[index + 1] ? __privateGet$2(this, _items)[index + 1][1] : void 0;
+      if (intent === "set") {
+        const existingItem = this._items[index][0];
+        existingItem._detach();
+        const storageUpdate = {
+          node: this,
+          type: "LiveList",
+          updates: [
+            {
+              index,
+              type: "set",
+              item: child instanceof LiveRegister ? child.data : child
+            }
+          ]
+        };
+        this._items[index][0] = child;
+        return {
+          modified: storageUpdate,
+          reverse: existingItem._serialize(this._id, key, this._doc, "set")
+        };
+      } else if (isLocal) {
+        const before = this._items[index] ? this._items[index][1] : void 0;
+        const after = this._items[index + 1] ? this._items[index + 1][1] : void 0;
         newKey = makePosition(before, after);
         child._setParentLink(this, newKey);
       } else {
-        __privateGet$2(this, _items)[index][1] = makePosition(key, (_a = __privateGet$2(this, _items)[index + 1]) == null ? void 0 : _a[1]);
+        this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) == null ? void 0 : _a[1]);
       }
     }
-    __privateGet$2(this, _items).push([child, newKey]);
-    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
-    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === newKey);
+    this._items.push([child, newKey]);
+    this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = this._items.findIndex((entry) => entry[1] === newKey);
     return {
       reverse: [{ type: OpType.DeleteCrdt, id }],
       modified: {
@@ -425,8 +379,8 @@ const _LiveList = class extends AbstractCrdt {
   _detachChild(child) {
     if (child) {
       const reverse = child._serialize(this._id, child._parentKey, this._doc);
-      const indexToDelete = __privateGet$2(this, _items).findIndex((item) => item[0] === child);
-      __privateGet$2(this, _items).splice(indexToDelete, 1);
+      const indexToDelete = this._items.findIndex((item) => item[0] === child);
+      this._items.splice(indexToDelete, 1);
       child._detach();
       const storageUpdate = {
         node: this,
@@ -440,17 +394,17 @@ const _LiveList = class extends AbstractCrdt {
   _setChildKey(key, child, previousKey) {
     var _a;
     child._setParentLink(this, key);
-    const previousIndex = __privateGet$2(this, _items).findIndex((entry) => entry[0]._id === child._id);
-    const index = __privateGet$2(this, _items).findIndex((entry) => entry[1] === key);
+    const previousIndex = this._items.findIndex((entry) => entry[0]._id === child._id);
+    const index = this._items.findIndex((entry) => entry[1] === key);
     if (index !== -1) {
-      __privateGet$2(this, _items)[index][1] = makePosition(key, (_a = __privateGet$2(this, _items)[index + 1]) == null ? void 0 : _a[1]);
+      this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) == null ? void 0 : _a[1]);
     }
-    const item = __privateGet$2(this, _items).find((item2) => item2[0] === child);
+    const item = this._items.find((item2) => item2[0] === child);
     if (item) {
       item[1] = key;
     }
-    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
-    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[0]._id === child._id);
+    this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = this._items.findIndex((entry) => entry[0]._id === child._id);
     const updatesDelta = newIndex === previousIndex ? [] : [
       {
         index: newIndex,
@@ -486,23 +440,23 @@ const _LiveList = class extends AbstractCrdt {
     };
   }
   get length() {
-    return __privateGet$2(this, _items).length;
+    return this._items.length;
   }
   push(element) {
     return this.insert(element, this.length);
   }
   insert(element, index) {
-    if (index < 0 || index > __privateGet$2(this, _items).length) {
-      throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${__privateGet$2(this, _items).length}`);
+    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}`);
     }
-    let before = __privateGet$2(this, _items)[index - 1] ? __privateGet$2(this, _items)[index - 1][1] : void 0;
-    let after = __privateGet$2(this, _items)[index] ? __privateGet$2(this, _items)[index][1] : void 0;
+    const before = this._items[index - 1] ? this._items[index - 1][1] : void 0;
+    const after = this._items[index] ? this._items[index][1] : void 0;
     const position = makePosition(before, after);
     const value = selfOrRegister(element);
     value._setParentLink(this, position);
-    __privateGet$2(this, _items).push([value, position]);
-    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
-    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === position);
+    this._items.push([value, position]);
+    this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = this._items.findIndex((entry) => entry[1] === position);
     if (this._doc && this._id) {
       const id = this._doc.generateId();
       value._attach(id, this._doc);
@@ -525,31 +479,31 @@ const _LiveList = class extends AbstractCrdt {
     if (targetIndex < 0) {
       throw new Error("targetIndex cannot be less than 0");
     }
-    if (targetIndex >= __privateGet$2(this, _items).length) {
+    if (targetIndex >= this._items.length) {
       throw new Error("targetIndex cannot be greater or equal than the list length");
     }
     if (index < 0) {
       throw new Error("index cannot be less than 0");
     }
-    if (index >= __privateGet$2(this, _items).length) {
+    if (index >= this._items.length) {
       throw new Error("index cannot be greater or equal than the list length");
     }
     let beforePosition = null;
     let afterPosition = null;
     if (index < targetIndex) {
-      afterPosition = targetIndex === __privateGet$2(this, _items).length - 1 ? void 0 : __privateGet$2(this, _items)[targetIndex + 1][1];
-      beforePosition = __privateGet$2(this, _items)[targetIndex][1];
+      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1][1];
+      beforePosition = this._items[targetIndex][1];
     } else {
-      afterPosition = __privateGet$2(this, _items)[targetIndex][1];
-      beforePosition = targetIndex === 0 ? void 0 : __privateGet$2(this, _items)[targetIndex - 1][1];
+      afterPosition = this._items[targetIndex][1];
+      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1][1];
     }
     const position = makePosition(beforePosition, afterPosition);
-    const item = __privateGet$2(this, _items)[index];
+    const item = this._items[index];
     const previousPosition = item[1];
     item[1] = position;
     item[0]._setParentLink(this, position);
-    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
-    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === position);
+    this._items.sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = this._items.findIndex((entry) => entry[1] === position);
     if (this._doc && this._id) {
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, {
@@ -581,12 +535,12 @@ const _LiveList = class extends AbstractCrdt {
     }
   }
   delete(index) {
-    if (index < 0 || index >= __privateGet$2(this, _items).length) {
-      throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${__privateGet$2(this, _items).length - 1}`);
+    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 = __privateGet$2(this, _items)[index];
+    const item = this._items[index];
     item[0]._detach();
-    __privateGet$2(this, _items).splice(index, 1);
+    this._items.splice(index, 1);
     if (this._doc) {
       const childRecordId = item[0]._id;
       if (childRecordId) {
@@ -608,11 +562,11 @@ const _LiveList = class extends AbstractCrdt {
   }
   clear() {
     if (this._doc) {
-      let ops = [];
-      let reverseOps = [];
-      let updateDelta = [];
+      const ops = [];
+      const reverseOps = [];
+      const updateDelta = [];
       let i = 0;
-      for (const item of __privateGet$2(this, _items)) {
+      for (const item of this._items) {
         item[0]._detach();
         const childId = item[0]._id;
         if (childId) {
@@ -622,7 +576,7 @@ const _LiveList = class extends AbstractCrdt {
         }
         i++;
       }
-      __privateSet$2(this, _items, []);
+      this._items = [];
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, {
         node: this,
@@ -631,14 +585,41 @@ const _LiveList = class extends AbstractCrdt {
       });
       this._doc.dispatch(ops, reverseOps, storageUpdates);
     } else {
-      for (const item of __privateGet$2(this, _items)) {
+      for (const item of this._items) {
         item[0]._detach();
       }
-      __privateSet$2(this, _items, []);
+      this._items = [];
+    }
+  }
+  set(index, item) {
+    if (index < 0 || index >= this._items.length) {
+      throw new Error(`Cannot set list item at index "${index}". index should be between 0 and ${this._items.length - 1}`);
+    }
+    const [existingItem, position] = this._items[index];
+    existingItem._detach();
+    const value = selfOrRegister(item);
+    value._setParentLink(this, position);
+    this._items[index][0] = value;
+    if (this._doc && this._id) {
+      const id = this._doc.generateId();
+      value._attach(id, this._doc);
+      const storageUpdates = /* @__PURE__ */ new Map();
+      storageUpdates.set(this._id, {
+        node: this,
+        type: "LiveList",
+        updates: [
+          {
+            index,
+            item: value instanceof LiveRegister ? value.data : value,
+            type: "set"
+          }
+        ]
+      });
+      this._doc.dispatch(value._serialize(this._id, position, this._doc, "set"), existingItem._serialize(this._id, position, void 0, "set"), storageUpdates);
     }
   }
   toArray() {
-    return __privateGet$2(this, _items).map((entry) => selfOrRegisterValue(entry[0]));
+    return this._items.map((entry) => selfOrRegisterValue(entry[0]));
   }
   every(predicate) {
     return this.toArray().every(predicate);
@@ -656,10 +637,10 @@ const _LiveList = class extends AbstractCrdt {
     return this.toArray().forEach(callbackfn);
   }
   get(index) {
-    if (index < 0 || index >= __privateGet$2(this, _items).length) {
+    if (index < 0 || index >= this._items.length) {
       return void 0;
     }
-    return selfOrRegisterValue(__privateGet$2(this, _items)[index][0]);
+    return selfOrRegisterValue(this._items[index][0]);
   }
   indexOf(searchElement, fromIndex) {
     return this.toArray().indexOf(searchElement, fromIndex);
@@ -668,27 +649,24 @@ const _LiveList = class extends AbstractCrdt {
     return this.toArray().lastIndexOf(searchElement, fromIndex);
   }
   map(callback) {
-    return __privateGet$2(this, _items).map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
+    return this._items.map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
   }
   some(predicate) {
     return this.toArray().some(predicate);
   }
   [Symbol.iterator]() {
-    return new LiveListIterator(__privateGet$2(this, _items));
+    return new LiveListIterator(this._items);
   }
-};
-let LiveList = _LiveList;
-_items = new WeakMap();
+}
 class LiveListIterator {
   constructor(items) {
-    __privateAdd$2(this, _innerIterator, void 0);
-    __privateSet$2(this, _innerIterator, items[Symbol.iterator]());
+    this._innerIterator = items[Symbol.iterator]();
   }
   [Symbol.iterator]() {
     return this;
   }
   next() {
-    const result = __privateGet$2(this, _innerIterator).next();
+    const result = this._innerIterator.next();
     if (result.done) {
       return {
         done: true,
@@ -700,31 +678,10 @@ class LiveListIterator {
     };
   }
 }
-_innerIterator = new WeakMap();
 
-var __accessCheck$1 = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet$1 = (obj, member, getter) => {
-  __accessCheck$1(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd$1 = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet$1 = (obj, member, value, setter) => {
-  __accessCheck$1(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var _map$1;
-const _LiveMap = class extends AbstractCrdt {
+class LiveMap extends AbstractCrdt {
   constructor(entries) {
     super();
-    __privateAdd$1(this, _map$1, void 0);
     if (entries) {
       const mappedEntries = [];
       for (const entry of entries) {
@@ -732,12 +689,12 @@ const _LiveMap = class extends AbstractCrdt {
         value._setParentLink(this, entry[0]);
         mappedEntries.push([entry[0], value]);
       }
-      __privateSet$1(this, _map$1, new Map(mappedEntries));
+      this._map = new Map(mappedEntries);
     } else {
-      __privateSet$1(this, _map$1, /* @__PURE__ */ new Map());
+      this._map = /* @__PURE__ */ new Map();
     }
   }
-  _serialize(parentId, parentKey, doc) {
+  _serialize(parentId, parentKey, doc, intent) {
     if (this._id == null) {
       throw new Error("Cannot serialize item is not attached");
     }
@@ -749,11 +706,12 @@ const _LiveMap = class extends AbstractCrdt {
       id: this._id,
       opId: doc == null ? void 0 : doc.generateOpId(),
       type: OpType.CreateMap,
+      intent,
       parentId,
       parentKey
     };
     ops.push(op);
-    for (const [key, value] of __privateGet$1(this, _map$1)) {
+    for (const [key, value] of this._map) {
       ops.push(...value._serialize(this._id, key, doc));
     }
     return ops;
@@ -762,7 +720,7 @@ const _LiveMap = class extends AbstractCrdt {
     if (item.type !== CrdtType.Map) {
       throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
     }
-    const map = new _LiveMap();
+    const map = new LiveMap();
     map._attach(id, doc);
     const children = parentToChildren.get(id);
     if (children == null) {
@@ -775,26 +733,29 @@ const _LiveMap = class extends AbstractCrdt {
       }
       const child = deserialize(entry, parentToChildren, doc);
       child._setParentLink(map, crdt.parentKey);
-      __privateGet$1(map, _map$1).set(crdt.parentKey, child);
+      map._map.set(crdt.parentKey, child);
     }
     return map;
   }
   _attach(id, doc) {
     super._attach(id, doc);
-    for (const [key, value] of __privateGet$1(this, _map$1)) {
+    for (const [_key, value] of this._map) {
       if (isCrdt(value)) {
         value._attach(doc.generateId(), doc);
       }
     }
   }
-  _attachChild(id, key, child, opId, isLocal) {
+  _attachChild(op, _isLocal) {
     if (this._doc == null) {
       throw new Error("Can't attach child if doc is not present");
     }
+    const { id, parentKey } = op;
+    const key = parentKey;
+    const child = creationOpToLiveStructure(op);
     if (this._doc.getItem(id) !== void 0) {
       return { modified: false };
     }
-    const previousValue = __privateGet$1(this, _map$1).get(key);
+    const previousValue = this._map.get(key);
     let reverse;
     if (previousValue) {
       reverse = previousValue._serialize(this._id, key);
@@ -804,7 +765,7 @@ const _LiveMap = class extends AbstractCrdt {
     }
     child._setParentLink(this, key);
     child._attach(id, this._doc);
-    __privateGet$1(this, _map$1).set(key, child);
+    this._map.set(key, child);
     return {
       modified: {
         node: this,
@@ -816,15 +777,15 @@ const _LiveMap = class extends AbstractCrdt {
   }
   _detach() {
     super._detach();
-    for (const item of __privateGet$1(this, _map$1).values()) {
+    for (const item of this._map.values()) {
       item._detach();
     }
   }
   _detachChild(child) {
     const reverse = child._serialize(this._id, child._parentKey, this._doc);
-    for (const [key, value] of __privateGet$1(this, _map$1)) {
+    for (const [key, value] of this._map) {
       if (value === child) {
-        __privateGet$1(this, _map$1).delete(key);
+        this._map.delete(key);
       }
     }
     child._detach();
@@ -844,20 +805,20 @@ const _LiveMap = class extends AbstractCrdt {
     };
   }
   get(key) {
-    const value = __privateGet$1(this, _map$1).get(key);
+    const value = this._map.get(key);
     if (value == void 0) {
       return void 0;
     }
     return selfOrRegisterValue(value);
   }
   set(key, value) {
-    const oldValue = __privateGet$1(this, _map$1).get(key);
+    const oldValue = this._map.get(key);
     if (oldValue) {
       oldValue._detach();
     }
     const item = selfOrRegister(value);
     item._setParentLink(this, key);
-    __privateGet$1(this, _map$1).set(key, item);
+    this._map.set(key, item);
     if (this._doc && this._id) {
       const id = this._doc.generateId();
       item._attach(id, this._doc);
@@ -871,18 +832,18 @@ const _LiveMap = class extends AbstractCrdt {
     }
   }
   get size() {
-    return __privateGet$1(this, _map$1).size;
+    return this._map.size;
   }
   has(key) {
-    return __privateGet$1(this, _map$1).has(key);
+    return this._map.has(key);
   }
   delete(key) {
-    const item = __privateGet$1(this, _map$1).get(key);
+    const item = this._map.get(key);
     if (item == null) {
       return false;
     }
     item._detach();
-    __privateGet$1(this, _map$1).delete(key);
+    this._map.delete(key);
     if (this._doc && item._id) {
       const storageUpdates = /* @__PURE__ */ new Map();
       storageUpdates.set(this._id, {
@@ -901,7 +862,7 @@ const _LiveMap = class extends AbstractCrdt {
     return true;
   }
   entries() {
-    const innerIterator = __privateGet$1(this, _map$1).entries();
+    const innerIterator = this._map.entries();
     return {
       [Symbol.iterator]: function() {
         return this;
@@ -925,10 +886,10 @@ const _LiveMap = class extends AbstractCrdt {
     return this.entries();
   }
   keys() {
-    return __privateGet$1(this, _map$1).keys();
+    return this._map.keys();
   }
   values() {
-    const innerIterator = __privateGet$1(this, _map$1).values();
+    const innerIterator = this._map.values();
     return {
       [Symbol.iterator]: function() {
         return this;
@@ -952,9 +913,7 @@ const _LiveMap = class extends AbstractCrdt {
       callback(entry[1], entry[0], this);
     }
   }
-};
-let LiveMap = _LiveMap;
-_map$1 = new WeakMap();
+}
 
 var __defProp$2 = Object.defineProperty;
 var __defProps$2 = Object.defineProperties;
@@ -983,6 +942,18 @@ function remove(array, item) {
     }
   }
 }
+function creationOpToLiveStructure(op) {
+  switch (op.type) {
+    case OpType.CreateRegister:
+      return new LiveRegister(op.data);
+    case OpType.CreateObject:
+      return new LiveObject(op.data);
+    case OpType.CreateMap:
+      return new LiveMap();
+    case OpType.CreateList:
+      return new LiveList();
+  }
+}
 function isSameNodeOrChildOf(node, parent) {
   if (node === parent) {
     return true;
@@ -1099,32 +1070,41 @@ function getTreesDiffOperations(currentItems, newItems) {
   });
   return ops;
 }
+function mergeObjectStorageUpdates(first, second) {
+  const updates = first.updates;
+  for (const [key, value] of entries(second.updates)) {
+    updates[key] = value;
+  }
+  return __spreadProps$2(__spreadValues$2({}, second), {
+    updates
+  });
+}
+function mergeMapStorageUpdates(first, second) {
+  const updates = first.updates;
+  for (const [key, value] of entries(second.updates)) {
+    updates[key] = value;
+  }
+  return __spreadProps$2(__spreadValues$2({}, second), {
+    updates
+  });
+}
+function mergeListStorageUpdates(first, second) {
+  const updates = first.updates;
+  return __spreadProps$2(__spreadValues$2({}, second), {
+    updates: updates.concat(second.updates)
+  });
+}
 function mergeStorageUpdates(first, second) {
   if (!first) {
     return second;
   }
-  if (second.type === "LiveObject") {
-    const updates = first.updates;
-    for (const [key, value] of Object.entries(second.updates)) {
-      updates[key] = value;
-    }
-    return __spreadProps$2(__spreadValues$2({}, second), {
-      updates
-    });
-  } else if (second.type === "LiveMap") {
-    const updates = first.updates;
-    for (const [key, value] of Object.entries(second.updates)) {
-      updates[key] = value;
-    }
-    return __spreadProps$2(__spreadValues$2({}, second), {
-      updates
-    });
-  } else if (second.type === "LiveList") {
-    const updates = first.updates;
-    return __spreadProps$2(__spreadValues$2({}, second), {
-      updates: updates.concat(second.updates)
-    });
-  }
+  if (first.type === "LiveObject" && second.type === "LiveObject") {
+    return mergeObjectStorageUpdates(first, second);
+  } else if (first.type === "LiveMap" && second.type === "LiveMap") {
+    return mergeMapStorageUpdates(first, second);
+  } else if (first.type === "LiveList" && second.type === "LiveList") {
+    return mergeListStorageUpdates(first, second);
+  } else ;
   return second;
 }
 function isPlain(value) {
@@ -1134,7 +1114,7 @@ function isPlain(value) {
 function isPlainObject$1(value) {
   if (typeof value !== "object" || value === null)
     return false;
-  let proto = Object.getPrototypeOf(value);
+  const proto = Object.getPrototypeOf(value);
   if (proto === null)
     return true;
   let baseProto = proto;
@@ -1170,46 +1150,41 @@ function findNonSerializableValue(value, path = "") {
   }
   return false;
 }
+function isTokenValid(token) {
+  if (token === null) {
+    return false;
+  }
+  const tokenParts = token.split(".");
+  if (tokenParts.length !== 3) {
+    return false;
+  }
+  const data = JSON.parse(atob(tokenParts[1]));
+  if (typeof data.exp !== "number") {
+    return false;
+  }
+  const now = Date.now();
+  if (now / 1e3 > data.exp - 300) {
+    return false;
+  }
+  return true;
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
 
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
-};
-var __privateMethod = (obj, member, method) => {
-  __accessCheck(obj, member, "access private method");
-  return method;
-};
-var _map, _propToLastUpdate, _applyUpdate, applyUpdate_fn, _applyDeleteObjectKey, applyDeleteObjectKey_fn;
-const _LiveObject = class extends AbstractCrdt {
+class LiveObject extends AbstractCrdt {
   constructor(object = {}) {
     super();
-    __privateAdd(this, _applyUpdate);
-    __privateAdd(this, _applyDeleteObjectKey);
-    __privateAdd(this, _map, void 0);
-    __privateAdd(this, _propToLastUpdate, /* @__PURE__ */ new Map());
+    this._propToLastUpdate = /* @__PURE__ */ new Map();
     for (const key in object) {
       const value = object[key];
       if (value instanceof AbstractCrdt) {
         value._setParentLink(this, key);
       }
     }
-    __privateSet(this, _map, new Map(Object.entries(object)));
+    this._map = new Map(Object.entries(object));
   }
-  _serialize(parentId, parentKey, doc) {
+  _serialize(parentId, parentKey, doc, intent) {
     if (this._id == null) {
       throw new Error("Cannot serialize item is not attached");
     }
@@ -1217,13 +1192,14 @@ const _LiveObject = class extends AbstractCrdt {
     const op = {
       id: this._id,
       opId: doc == null ? void 0 : doc.generateOpId(),
+      intent,
       type: OpType.CreateObject,
       parentId,
       parentKey,
       data: {}
     };
     ops.push(op);
-    for (const [key, value] of __privateGet(this, _map)) {
+    for (const [key, value] of this._map) {
       if (value instanceof AbstractCrdt) {
         ops.push(...value._serialize(this._id, key, doc));
       } else {
@@ -1236,7 +1212,7 @@ const _LiveObject = class extends AbstractCrdt {
     if (item.type !== CrdtType.Object) {
       throw new Error(`Tried to deserialize a record but item type is "${item.type}"`);
     }
-    const object = new _LiveObject(item.data);
+    const object = new LiveObject(item.data);
     object._attach(id, doc);
     return this._deserializeChildren(object, parentToChildren, doc);
   }
@@ -1252,37 +1228,40 @@ const _LiveObject = class extends AbstractCrdt {
       }
       const child = deserialize(entry, parentToChildren, doc);
       child._setParentLink(object, crdt.parentKey);
-      __privateGet(object, _map).set(crdt.parentKey, child);
+      object._map.set(crdt.parentKey, child);
     }
     return object;
   }
   _attach(id, doc) {
     super._attach(id, doc);
-    for (const [key, value] of __privateGet(this, _map)) {
+    for (const [_key, value] of this._map) {
       if (value instanceof AbstractCrdt) {
         value._attach(doc.generateId(), doc);
       }
     }
   }
-  _attachChild(id, key, child, opId, isLocal) {
+  _attachChild(op, isLocal) {
     if (this._doc == null) {
       throw new Error("Can't attach child if doc is not present");
     }
+    const { id, parentKey, opId } = op;
+    const key = parentKey;
+    const child = creationOpToLiveStructure(op);
     if (this._doc.getItem(id) !== void 0) {
-      if (__privateGet(this, _propToLastUpdate).get(key) === opId) {
-        __privateGet(this, _propToLastUpdate).delete(key);
+      if (this._propToLastUpdate.get(key) === opId) {
+        this._propToLastUpdate.delete(key);
       }
       return { modified: false };
     }
     if (isLocal) {
-      __privateGet(this, _propToLastUpdate).set(key, opId);
-    } else if (__privateGet(this, _propToLastUpdate).get(key) === void 0) ; else if (__privateGet(this, _propToLastUpdate).get(key) === opId) {
-      __privateGet(this, _propToLastUpdate).delete(key);
+      this._propToLastUpdate.set(key, opId);
+    } else if (this._propToLastUpdate.get(key) === void 0) ; else if (this._propToLastUpdate.get(key) === opId) {
+      this._propToLastUpdate.delete(key);
       return { modified: false };
     } else {
       return { modified: false };
     }
-    const previousValue = __privateGet(this, _map).get(key);
+    const previousValue = this._map.get(key);
     let reverse;
     if (isCrdt(previousValue)) {
       reverse = previousValue._serialize(this._id, key);
@@ -1300,7 +1279,7 @@ const _LiveObject = class extends AbstractCrdt {
         }
       ];
     }
-    __privateGet(this, _map).set(key, child);
+    this._map.set(key, child);
     child._setParentLink(this, key);
     child._attach(id, this._doc);
     return {
@@ -1315,9 +1294,9 @@ const _LiveObject = class extends AbstractCrdt {
   _detachChild(child) {
     if (child) {
       const reverse = child._serialize(this._id, child._parentKey, this._doc);
-      for (const [key, value] of __privateGet(this, _map)) {
+      for (const [key, value] of this._map) {
         if (value === child) {
-          __privateGet(this, _map).delete(key);
+          this._map.delete(key);
         }
       }
       child._detach();
@@ -1333,14 +1312,14 @@ const _LiveObject = class extends AbstractCrdt {
     return { modified: false };
   }
   _detachChildren() {
-    for (const [key, value] of __privateGet(this, _map)) {
-      __privateGet(this, _map).delete(key);
+    for (const [key, value] of this._map) {
+      this._map.delete(key);
       value._detach();
     }
   }
   _detach() {
     super._detach();
-    for (const value of __privateGet(this, _map).values()) {
+    for (const value of this._map.values()) {
       if (isCrdt(value)) {
         value._detach();
       }
@@ -1348,33 +1327,123 @@ const _LiveObject = class extends AbstractCrdt {
   }
   _apply(op, isLocal) {
     if (op.type === OpType.UpdateObject) {
-      return __privateMethod(this, _applyUpdate, applyUpdate_fn).call(this, op, isLocal);
+      return this._applyUpdate(op, isLocal);
     } else if (op.type === OpType.DeleteObjectKey) {
-      return __privateMethod(this, _applyDeleteObjectKey, applyDeleteObjectKey_fn).call(this, op);
+      return this._applyDeleteObjectKey(op);
     }
     return super._apply(op, isLocal);
   }
   _toSerializedCrdt() {
     var _a;
+    const data = {};
+    for (const [key, value] of this._map) {
+      if (value instanceof AbstractCrdt === false) {
+        data[key] = value;
+      }
+    }
     return {
       type: CrdtType.Object,
       parentId: (_a = this._parent) == null ? void 0 : _a._id,
       parentKey: this._parentKey,
-      data: this.toObject()
+      data
+    };
+  }
+  _applyUpdate(op, isLocal) {
+    let isModified = false;
+    const reverse = [];
+    const reverseUpdate = {
+      type: OpType.UpdateObject,
+      id: this._id,
+      data: {}
+    };
+    reverse.push(reverseUpdate);
+    for (const key in op.data) {
+      const oldValue = this._map.get(key);
+      if (oldValue instanceof AbstractCrdt) {
+        reverse.push(...oldValue._serialize(this._id, key));
+        oldValue._detach();
+      } else if (oldValue !== void 0) {
+        reverseUpdate.data[key] = oldValue;
+      } else if (oldValue === void 0) {
+        reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+      }
+    }
+    const updateDelta = {};
+    for (const key in op.data) {
+      if (isLocal) {
+        this._propToLastUpdate.set(key, op.opId);
+      } else if (this._propToLastUpdate.get(key) == null) {
+        isModified = true;
+      } else if (this._propToLastUpdate.get(key) === op.opId) {
+        this._propToLastUpdate.delete(key);
+        continue;
+      } else {
+        continue;
+      }
+      const oldValue = this._map.get(key);
+      if (isCrdt(oldValue)) {
+        oldValue._detach();
+      }
+      isModified = true;
+      updateDelta[key] = { type: "update" };
+      this._map.set(key, op.data[key]);
+    }
+    if (Object.keys(reverseUpdate.data).length !== 0) {
+      reverse.unshift(reverseUpdate);
+    }
+    return isModified ? {
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: updateDelta
+      },
+      reverse
+    } : { modified: false };
+  }
+  _applyDeleteObjectKey(op) {
+    const key = op.key;
+    if (this._map.has(key) === false) {
+      return { modified: false };
+    }
+    if (this._propToLastUpdate.get(key) !== void 0) {
+      return { modified: false };
+    }
+    const oldValue = this._map.get(key);
+    let reverse = [];
+    if (isCrdt(oldValue)) {
+      reverse = oldValue._serialize(this._id, op.key);
+      oldValue._detach();
+    } else if (oldValue !== void 0) {
+      reverse = [
+        {
+          type: OpType.UpdateObject,
+          id: this._id,
+          data: { [key]: oldValue }
+        }
+      ];
+    }
+    this._map.delete(key);
+    return {
+      modified: {
+        node: this,
+        type: "LiveObject",
+        updates: { [op.key]: { type: "delete" } }
+      },
+      reverse
     };
   }
   toObject() {
-    return Object.fromEntries(__privateGet(this, _map));
+    return Object.fromEntries(this._map);
   }
   set(key, value) {
     this.update({ [key]: value });
   }
   get(key) {
-    return __privateGet(this, _map).get(key);
+    return this._map.get(key);
   }
   delete(key) {
     const keyAsString = key;
-    const oldValue = __privateGet(this, _map).get(keyAsString);
+    const oldValue = this._map.get(keyAsString);
     if (oldValue === void 0) {
       return;
     }
@@ -1382,7 +1451,7 @@ const _LiveObject = class extends AbstractCrdt {
       if (oldValue instanceof AbstractCrdt) {
         oldValue._detach();
       }
-      __privateGet(this, _map).delete(keyAsString);
+      this._map.delete(keyAsString);
       return;
     }
     let reverse;
@@ -1398,7 +1467,7 @@ const _LiveObject = class extends AbstractCrdt {
         }
       ];
     }
-    __privateGet(this, _map).delete(keyAsString);
+    this._map.delete(keyAsString);
     const storageUpdates = /* @__PURE__ */ new Map();
     storageUpdates.set(this._id, {
       node: this,
@@ -1417,7 +1486,7 @@ const _LiveObject = class extends AbstractCrdt {
   update(overrides) {
     if (this._doc == null || this._id == null) {
       for (const key in overrides) {
-        const oldValue = __privateGet(this, _map).get(key);
+        const oldValue = this._map.get(key);
         if (oldValue instanceof AbstractCrdt) {
           oldValue._detach();
         }
@@ -1425,7 +1494,7 @@ const _LiveObject = class extends AbstractCrdt {
         if (newValue instanceof AbstractCrdt) {
           newValue._setParentLink(this, key);
         }
-        __privateGet(this, _map).set(key, newValue);
+        this._map.set(key, newValue);
       }
       return;
     }
@@ -1440,7 +1509,7 @@ const _LiveObject = class extends AbstractCrdt {
     };
     const updateDelta = {};
     for (const key in overrides) {
-      const oldValue = __privateGet(this, _map).get(key);
+      const oldValue = this._map.get(key);
       if (oldValue instanceof AbstractCrdt) {
         reverseOps.push(...oldValue._serialize(this._id, key));
         oldValue._detach();
@@ -1456,14 +1525,14 @@ const _LiveObject = class extends AbstractCrdt {
         const newAttachChildOps = newValue._serialize(this._id, key, this._doc);
         const createCrdtOp = newAttachChildOps.find((op) => op.parentId === this._id);
         if (createCrdtOp) {
-          __privateGet(this, _propToLastUpdate).set(key, createCrdtOp.opId);
+          this._propToLastUpdate.set(key, createCrdtOp.opId);
         }
         ops.push(...newAttachChildOps);
       } else {
         updatedProps[key] = newValue;
-        __privateGet(this, _propToLastUpdate).set(key, opId);
+        this._propToLastUpdate.set(key, opId);
       }
-      __privateGet(this, _map).set(key, newValue);
+      this._map.set(key, newValue);
       updateDelta[key] = { type: "update" };
     }
     if (Object.keys(reverseUpdateOp.data).length !== 0) {
@@ -1485,96 +1554,7 @@ const _LiveObject = class extends AbstractCrdt {
     });
     this._doc.dispatch(ops, reverseOps, storageUpdates);
   }
-};
-let LiveObject = _LiveObject;
-_map = new WeakMap();
-_propToLastUpdate = new WeakMap();
-_applyUpdate = new WeakSet();
-applyUpdate_fn = function(op, isLocal) {
-  let isModified = false;
-  const reverse = [];
-  const reverseUpdate = {
-    type: OpType.UpdateObject,
-    id: this._id,
-    data: {}
-  };
-  reverse.push(reverseUpdate);
-  for (const key in op.data) {
-    const oldValue = __privateGet(this, _map).get(key);
-    if (oldValue instanceof AbstractCrdt) {
-      reverse.push(...oldValue._serialize(this._id, key));
-      oldValue._detach();
-    } else if (oldValue !== void 0) {
-      reverseUpdate.data[key] = oldValue;
-    } else if (oldValue === void 0) {
-      reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
-    }
-  }
-  let updateDelta = {};
-  for (const key in op.data) {
-    if (isLocal) {
-      __privateGet(this, _propToLastUpdate).set(key, op.opId);
-    } else if (__privateGet(this, _propToLastUpdate).get(key) == null) {
-      isModified = true;
-    } else if (__privateGet(this, _propToLastUpdate).get(key) === op.opId) {
-      __privateGet(this, _propToLastUpdate).delete(key);
-      continue;
-    } else {
-      continue;
-    }
-    const oldValue = __privateGet(this, _map).get(key);
-    if (isCrdt(oldValue)) {
-      oldValue._detach();
-    }
-    isModified = true;
-    updateDelta[key] = { type: "update" };
-    __privateGet(this, _map).set(key, op.data[key]);
-  }
-  if (Object.keys(reverseUpdate.data).length !== 0) {
-    reverse.unshift(reverseUpdate);
-  }
-  return isModified ? {
-    modified: {
-      node: this,
-      type: "LiveObject",
-      updates: updateDelta
-    },
-    reverse
-  } : { modified: false };
-};
-_applyDeleteObjectKey = new WeakSet();
-applyDeleteObjectKey_fn = function(op) {
-  const key = op.key;
-  if (__privateGet(this, _map).has(key) === false) {
-    return { modified: false };
-  }
-  if (__privateGet(this, _propToLastUpdate).get(key) !== void 0) {
-    return { modified: false };
-  }
-  const oldValue = __privateGet(this, _map).get(key);
-  let reverse = [];
-  if (isCrdt(oldValue)) {
-    reverse = oldValue._serialize(this._id, op.key);
-    oldValue._detach();
-  } else if (oldValue !== void 0) {
-    reverse = [
-      {
-        type: OpType.UpdateObject,
-        id: this._id,
-        data: { [key]: oldValue }
-      }
-    ];
-  }
-  __privateGet(this, _map).delete(key);
-  return {
-    modified: {
-      node: this,
-      type: "LiveObject",
-      updates: { [op.key]: { type: "delete" } }
-    },
-    reverse
-  };
-};
+}
 
 var __defProp$1 = Object.defineProperty;
 var __defProps$1 = Object.defineProperties;
@@ -1618,37 +1598,44 @@ function makeIdFactory(connectionId) {
   let count = 0;
   return () => `${connectionId}:${count++}`;
 }
-function makeOthers(presenceMap) {
-  const array = Object.values(presenceMap).map((presence) => {
-    const _a = presence, publicKeys = __objRest(_a, ["_hasReceivedInitialPresence"]);
+function makeOthers(userMap) {
+  const users = Object.values(userMap).map((user) => {
+    const _a = user, publicKeys = __objRest(_a, ["_hasReceivedInitialPresence"]);
     return publicKeys;
   });
   return {
     get count() {
-      return array.length;
+      return users.length;
     },
     [Symbol.iterator]() {
-      return array[Symbol.iterator]();
+      return users[Symbol.iterator]();
     },
     map(callback) {
-      return array.map(callback);
+      return users.map(callback);
     },
     toArray() {
-      return array;
+      return users;
     }
   };
 }
 function makeStateMachine(state, context, mockedEffects) {
   const effects = mockedEffects || {
     authenticate(auth, createWebSocket) {
-      return auth(context.room).then(({ token }) => {
-        if (state.connection.state !== "authenticating") {
-          return;
-        }
-        const parsedToken = parseToken(token);
-        const socket = createWebSocket(token);
+      if (isTokenValid(state.token)) {
+        const parsedToken = parseToken(state.token);
+        const socket = createWebSocket(state.token);
         authenticationSuccess(parsedToken, socket);
-      }).catch((er) => authenticationFailure(er));
+      } else {
+        return auth(context.room).then(({ token }) => {
+          if (state.connection.state !== "authenticating") {
+            return;
+          }
+          const parsedToken = parseToken(token);
+          const socket = createWebSocket(token);
+          authenticationSuccess(parsedToken, socket);
+          state.token = token;
+        }).catch((er) => authenticationFailure(er));
+      }
     },
     send(messageOrMessages) {
       if (state.socket == null) {
@@ -1785,12 +1772,12 @@ function makeStateMachine(state, context, mockedEffects) {
   function notify({
     storageUpdates = /* @__PURE__ */ new Map(),
     presence = false,
-    others = []
+    others: otherEvents = []
   }) {
-    if (others.length > 0) {
+    if (otherEvents.length > 0) {
       state.others = makeOthers(state.users);
-      for (const event of others) {
-        for (const listener of state.listeners["others"]) {
+      for (const event of otherEvents) {
+        for (const listener of state.listeners.others) {
           listener(state.others, event);
         }
       }
@@ -1889,33 +1876,15 @@ function makeStateMachine(state, context, mockedEffects) {
         }
         return { modified: false };
       }
-      case OpType.CreateObject: {
-        const parent = state.items.get(op.parentId);
-        if (parent == null) {
-          return { modified: false };
-        }
-        return parent._attachChild(op.id, op.parentKey, new LiveObject(op.data), op.opId, isLocal);
-      }
-      case OpType.CreateList: {
-        const parent = state.items.get(op.parentId);
-        if (parent == null) {
-          return { modified: false };
-        }
-        return parent._attachChild(op.id, op.parentKey, new LiveList(), op.opId, isLocal);
-      }
+      case OpType.CreateObject:
+      case OpType.CreateList:
+      case OpType.CreateMap:
       case OpType.CreateRegister: {
         const parent = state.items.get(op.parentId);
         if (parent == null) {
           return { modified: false };
         }
-        return parent._attachChild(op.id, op.parentKey, new LiveRegister(op.data), op.opId, isLocal);
-      }
-      case OpType.CreateMap: {
-        const parent = state.items.get(op.parentId);
-        if (parent == null) {
-          return { modified: false };
-        }
-        return parent._attachChild(op.id, op.parentKey, new LiveMap(), op.opId, isLocal);
+        return parent._attachChild(op, isLocal);
       }
     }
     return { modified: false };
@@ -2006,6 +1975,7 @@ See v0.13 release notes for more information.
     if (process.env.NODE_ENV !== "production") {
       console.error("Call to authentication endpoint failed", error);
     }
+    state.token = null;
     updateConnection({ state: "unavailable" });
     state.numberOfRetry++;
     state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
@@ -2136,8 +2106,9 @@ See v0.13 release notes for more information.
           break;
         }
         case ServerMessageType.InitialStorageState: {
+          const offlineOps = new Map(state.offlineOperations);
           createOrUpdateRootFromMessage(subMessage);
-          applyAndSendOfflineOps();
+          applyAndSendOfflineOps(offlineOps);
           _getInitialStateResolver == null ? void 0 : _getInitialStateResolver();
           break;
         }
@@ -2249,12 +2220,12 @@ See v0.13 release notes for more information.
     clearInterval(state.intervalHandles.heartbeat);
     connect();
   }
-  function applyAndSendOfflineOps() {
-    if (state.offlineOperations.size === 0) {
+  function applyAndSendOfflineOps(offlineOps) {
+    if (offlineOps.size === 0) {
       return;
     }
     const messages = [];
-    const ops = Array.from(state.offlineOperations.values());
+    const ops = Array.from(offlineOps.values());
     const result = apply(ops, true);
     messages.push({
       type: ClientMessageType.UpdateStorage,
@@ -2504,6 +2475,7 @@ See v0.13 release notes for more information.
 function defaultState(me, defaultStorageRoot) {
   return {
     connection: { state: "closed" },
+    token: null,
     lastConnectionId: null,
     socket: null,
     listeners: {
@@ -2696,7 +2668,7 @@ function createClient(options) {
     return internalRoom.room;
   }
   function leave(roomId) {
-    let room = rooms.get(roomId);
+    const room = rooms.get(roomId);
     if (room) {
       room.disconnect();
       rooms.delete(roomId);
@@ -2771,26 +2743,30 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-function liveObjectToJson(liveObject) {
+function lsonObjectToJson(obj) {
   const result = {};
-  const obj = liveObject.toObject();
   for (const key in obj) {
-    result[key] = liveNodeToJson(obj[key]);
+    result[key] = lsonToJson(obj[key]);
   }
   return result;
 }
+function liveObjectToJson(liveObject) {
+  return lsonObjectToJson(liveObject.toObject());
+}
 function liveMapToJson(map) {
   const result = {};
-  const obj = Object.fromEntries(map);
-  for (const key in obj) {
-    result[key] = liveNodeToJson(obj[key]);
+  for (const [key, value] of map.entries()) {
+    result[key] = lsonToJson(value);
   }
   return result;
 }
+function lsonListToJson(value) {
+  return value.map(lsonToJson);
+}
 function liveListToJson(value) {
-  return value.toArray().map(liveNodeToJson);
+  return lsonListToJson(value.toArray());
 }
-function liveNodeToJson(value) {
+function lsonToJson(value) {
   if (value instanceof LiveObject) {
     return liveObjectToJson(value);
   } else if (value instanceof LiveList) {
@@ -2799,11 +2775,18 @@ function liveNodeToJson(value) {
     return liveMapToJson(value);
   } else if (value instanceof LiveRegister) {
     return value.data;
+  } else if (value instanceof AbstractCrdt) {
+    throw new Error("Unhandled subclass of AbstractCrdt encountered");
+  }
+  if (Array.isArray(value)) {
+    return lsonListToJson(value);
+  } else if (isPlainObject(value)) {
+    return lsonObjectToJson(value);
   }
   return value;
 }
 function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
+  return obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
 }
 function anyToCrdt(obj) {
   if (obj == null) {
@@ -2869,8 +2852,7 @@ function patchLiveList(liveList, prev, next) {
       if (liveListNode instanceof LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode)) {
         patchLiveObject(liveListNode, prevNode, nextNode);
       } else {
-        liveList.delete(i);
-        liveList.insert(anyToCrdt(nextNode), i);
+        liveList.set(i, anyToCrdt(nextNode));
       }
       i++;
     }
@@ -2878,9 +2860,10 @@ function patchLiveList(liveList, prev, next) {
       liveList.insert(anyToCrdt(next[i]), i);
       i++;
     }
-    while (i <= prevEnd) {
+    let localI = i;
+    while (localI <= prevEnd) {
       liveList.delete(i);
-      i++;
+      localI++;
     }
   }
 }
@@ -2950,10 +2933,10 @@ function patchImmutableNode(state, path, update) {
         if (typeof state !== "object") {
           throw new Error("Internal: received update on LiveObject but state was not an object");
         }
-        let newState = Object.assign({}, state);
+        const newState = Object.assign({}, state);
         for (const key in update.updates) {
           if (((_a = update.updates[key]) == null ? void 0 : _a.type) === "update") {
-            newState[key] = liveNodeToJson(update.node.get(key));
+            newState[key] = lsonToJson(update.node.get(key));
           } else if (((_b = update.updates[key]) == null ? void 0 : _b.type) === "delete") {
             delete newState[key];
           }
@@ -2966,13 +2949,15 @@ function patchImmutableNode(state, path, update) {
         }
         let newState = state.map((x) => x);
         for (const listUpdate of update.updates) {
-          if (listUpdate.type === "insert") {
+          if (listUpdate.type === "set") {
+            newState = newState.map((item, index) => index === listUpdate.index ? listUpdate.item : item);
+          } else if (listUpdate.type === "insert") {
             if (listUpdate.index === newState.length) {
-              newState.push(liveNodeToJson(listUpdate.item));
+              newState.push(lsonToJson(listUpdate.item));
             } else {
               newState = [
                 ...newState.slice(0, listUpdate.index),
-                liveNodeToJson(listUpdate.item),
+                lsonToJson(listUpdate.item),
                 ...newState.slice(listUpdate.index)
               ];
             }
@@ -2982,7 +2967,7 @@ function patchImmutableNode(state, path, update) {
             if (listUpdate.previousIndex > listUpdate.index) {
               newState = [
                 ...newState.slice(0, listUpdate.index),
-                liveNodeToJson(listUpdate.item),
+                lsonToJson(listUpdate.item),
                 ...newState.slice(listUpdate.index, listUpdate.previousIndex),
                 ...newState.slice(listUpdate.previousIndex + 1)
               ];
@@ -2990,7 +2975,7 @@ function patchImmutableNode(state, path, update) {
               newState = [
                 ...newState.slice(0, listUpdate.previousIndex),
                 ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
-                liveNodeToJson(listUpdate.item),
+                lsonToJson(listUpdate.item),
                 ...newState.slice(listUpdate.index + 1)
               ];
             }
@@ -3002,10 +2987,10 @@ function patchImmutableNode(state, path, update) {
         if (typeof state !== "object") {
           throw new Error("Internal: received update on LiveMap but state was not an object");
         }
-        let newState = Object.assign({}, state);
+        const newState = Object.assign({}, state);
         for (const key in update.updates) {
           if (((_c = update.updates[key]) == null ? void 0 : _c.type) === "update") {
-            newState[key] = liveNodeToJson(update.node.get(key));
+            newState[key] = lsonToJson(update.node.get(key));
           } else if (((_d = update.updates[key]) == null ? void 0 : _d.type) === "delete") {
             delete newState[key];
           }
@@ -3027,7 +3012,7 @@ function patchImmutableNode(state, path, update) {
 
 const internals = {
   liveObjectToJson,
-  liveNodeToJson,
+  lsonToJson,
   patchLiveList,
   patchImmutableObject,
   patchLiveObject,