@liveblocks/client 0.16.3 → 0.16.4-beta1

package/esm/index.js

@@ -1,3068 +0,0 @@
-var ServerMessageType = /* @__PURE__ */ ((ServerMessageType2) => {
-  ServerMessageType2[ServerMessageType2["UpdatePresence"] = 100] = "UpdatePresence";
-  ServerMessageType2[ServerMessageType2["UserJoined"] = 101] = "UserJoined";
-  ServerMessageType2[ServerMessageType2["UserLeft"] = 102] = "UserLeft";
-  ServerMessageType2[ServerMessageType2["Event"] = 103] = "Event";
-  ServerMessageType2[ServerMessageType2["RoomState"] = 104] = "RoomState";
-  ServerMessageType2[ServerMessageType2["InitialStorageState"] = 200] = "InitialStorageState";
-  ServerMessageType2[ServerMessageType2["UpdateStorage"] = 201] = "UpdateStorage";
-  return ServerMessageType2;
-})(ServerMessageType || {});
-var ClientMessageType = /* @__PURE__ */ ((ClientMessageType2) => {
-  ClientMessageType2[ClientMessageType2["UpdatePresence"] = 100] = "UpdatePresence";
-  ClientMessageType2[ClientMessageType2["ClientEvent"] = 103] = "ClientEvent";
-  ClientMessageType2[ClientMessageType2["FetchStorage"] = 200] = "FetchStorage";
-  ClientMessageType2[ClientMessageType2["UpdateStorage"] = 201] = "UpdateStorage";
-  return ClientMessageType2;
-})(ClientMessageType || {});
-var CrdtType = /* @__PURE__ */ ((CrdtType2) => {
-  CrdtType2[CrdtType2["Object"] = 0] = "Object";
-  CrdtType2[CrdtType2["List"] = 1] = "List";
-  CrdtType2[CrdtType2["Map"] = 2] = "Map";
-  CrdtType2[CrdtType2["Register"] = 3] = "Register";
-  return CrdtType2;
-})(CrdtType || {});
-var OpType = /* @__PURE__ */ ((OpType2) => {
-  OpType2[OpType2["Init"] = 0] = "Init";
-  OpType2[OpType2["SetParentKey"] = 1] = "SetParentKey";
-  OpType2[OpType2["CreateList"] = 2] = "CreateList";
-  OpType2[OpType2["UpdateObject"] = 3] = "UpdateObject";
-  OpType2[OpType2["CreateObject"] = 4] = "CreateObject";
-  OpType2[OpType2["DeleteCrdt"] = 5] = "DeleteCrdt";
-  OpType2[OpType2["DeleteObjectKey"] = 6] = "DeleteObjectKey";
-  OpType2[OpType2["CreateMap"] = 7] = "CreateMap";
-  OpType2[OpType2["CreateRegister"] = 8] = "CreateRegister";
-  return OpType2;
-})(OpType || {});
-var WebsocketCloseCodes = /* @__PURE__ */ ((WebsocketCloseCodes2) => {
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_ABNORMAL"] = 1006] = "CLOSE_ABNORMAL";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["INVALID_MESSAGE_FORMAT"] = 4e3] = "INVALID_MESSAGE_FORMAT";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["NOT_ALLOWED"] = 4001] = "NOT_ALLOWED";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_SECONDS"] = 4002] = "MAX_NUMBER_OF_MESSAGES_PER_SECONDS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS"] = 4003] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP"] = 4004] = "MAX_NUMBER_OF_MESSAGES_PER_DAY_PER_APP";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM"] = 4005] = "MAX_NUMBER_OF_CONCURRENT_CONNECTIONS_PER_ROOM";
-  WebsocketCloseCodes2[WebsocketCloseCodes2["CLOSE_WITHOUT_RETRY"] = 4999] = "CLOSE_WITHOUT_RETRY";
-  return WebsocketCloseCodes2;
-})(WebsocketCloseCodes || {});
-
-class AbstractCrdt {
-  get _doc() {
-    return this.__doc;
-  }
-  get roomId() {
-    return this.__doc ? this.__doc.roomId : null;
-  }
-  get _id() {
-    return this.__id;
-  }
-  get _parent() {
-    return this.__parent;
-  }
-  get _parentKey() {
-    return this.__parentKey;
-  }
-  _apply(op, _isLocal) {
-    switch (op.type) {
-      case OpType.DeleteCrdt: {
-        if (this._parent != null && this._parentKey != null) {
-          return this._parent._detachChild(this);
-        }
-        return { modified: false };
-      }
-    }
-    return { modified: false };
-  }
-  _setParentLink(parent, key) {
-    if (this.__parent != null && this.__parent !== parent) {
-      throw new Error("Cannot attach parent if it already exist");
-    }
-    this.__parentKey = key;
-    this.__parent = parent;
-  }
-  _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() {
-    if (this.__doc && this.__id) {
-      this.__doc.deleteItem(this.__id);
-    }
-    this.__parent = void 0;
-    this.__doc = void 0;
-  }
-}
-
-const min = 32;
-const max = 126;
-function makePosition(before, after) {
-  if (before == null && after == null) {
-    return pos([min + 1]);
-  }
-  if (before != null && after == null) {
-    return getNextPosition(before);
-  }
-  if (before == null && after != null) {
-    return getPreviousPosition(after);
-  }
-  return pos(makePositionFromCodes(posCodes(before), posCodes(after)));
-}
-function getPreviousPosition(after) {
-  const result = [];
-  const afterCodes = posCodes(after);
-  for (let i = 0; i < afterCodes.length; i++) {
-    const code = afterCodes[i];
-    if (code <= min + 1) {
-      result.push(min);
-      if (afterCodes.length - 1 === i) {
-        result.push(max);
-        break;
-      }
-    } else {
-      result.push(code - 1);
-      break;
-    }
-  }
-  return pos(result);
-}
-function getNextPosition(before) {
-  const result = [];
-  const beforeCodes = posCodes(before);
-  for (let i = 0; i < beforeCodes.length; i++) {
-    const code = beforeCodes[i];
-    if (code === max) {
-      result.push(code);
-      if (beforeCodes.length - 1 === i) {
-        result.push(min + 1);
-        break;
-      }
-    } else {
-      result.push(code + 1);
-      break;
-    }
-  }
-  return pos(result);
-}
-function makePositionFromCodes(before, after) {
-  let index = 0;
-  const result = [];
-  while (true) {
-    const beforeDigit = before[index] || min;
-    const afterDigit = after[index] || max;
-    if (beforeDigit > afterDigit) {
-      throw new Error(`Impossible to generate position between ${before} and ${after}`);
-    }
-    if (beforeDigit === afterDigit) {
-      result.push(beforeDigit);
-      index++;
-      continue;
-    }
-    if (afterDigit - beforeDigit === 1) {
-      result.push(beforeDigit);
-      result.push(...makePositionFromCodes(before.slice(index + 1), []));
-      break;
-    }
-    const mid = afterDigit + beforeDigit >> 1;
-    result.push(mid);
-    break;
-  }
-  return result;
-}
-function posCodes(str) {
-  const codes = [];
-  for (let i = 0; i < str.length; i++) {
-    codes.push(str.charCodeAt(i));
-  }
-  return codes;
-}
-function pos(codes) {
-  return String.fromCharCode(...codes);
-}
-function compare(posA, posB) {
-  const aCodes = posCodes(posA);
-  const bCodes = posCodes(posB);
-  const maxLength = Math.max(aCodes.length, bCodes.length);
-  for (let i = 0; i < maxLength; i++) {
-    const a = aCodes[i] == null ? min : aCodes[i];
-    const b = bCodes[i] == null ? min : bCodes[i];
-    if (a === b) {
-      continue;
-    } else {
-      return a - b;
-    }
-  }
-  throw new Error(`Impossible to compare similar position "${posA}" and "${posB}"`);
-}
-
-class LiveRegister extends AbstractCrdt {
-  constructor(data) {
-    super();
-    this._data = data;
-  }
-  get data() {
-    return this._data;
-  }
-  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);
-    register._attach(id, doc);
-    return register;
-  }
-  _serialize(parentId, parentKey, doc, intent) {
-    if (this._id == null || parentId == null || parentKey == null) {
-      throw new Error("Cannot serialize register if parentId or parentKey is undefined");
-    }
-    return [
-      {
-        type: OpType.CreateRegister,
-        opId: doc == null ? void 0 : doc.generateOpId(),
-        id: this._id,
-        intent,
-        parentId,
-        parentKey,
-        data: this.data
-      }
-    ];
-  }
-  _toSerializedCrdt() {
-    var _a;
-    return {
-      type: CrdtType.Register,
-      parentId: (_a = this._parent) == null ? void 0 : _a._id,
-      parentKey: this._parentKey,
-      data: this.data
-    };
-  }
-  _attachChild(_op, _isLocal) {
-    throw new Error("Method not implemented.");
-  }
-  _detachChild(_crdt) {
-    throw new Error("Method not implemented.");
-  }
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
-  }
-}
-
-class LiveList extends AbstractCrdt {
-  constructor(items = []) {
-    super();
-    this._items = [];
-    let position = void 0;
-    for (let i = 0; i < items.length; i++) {
-      const newPosition = makePosition(position);
-      const item = selfOrRegister(items[i]);
-      this._items.push([item, newPosition]);
-      position = newPosition;
-    }
-  }
-  static _deserialize([id], parentToChildren, doc) {
-    const list = new LiveList([]);
-    list._attach(id, doc);
-    const children = parentToChildren.get(id);
-    if (children == null) {
-      return list;
-    }
-    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) => compare(itemA[1], itemB[1]));
-    }
-    return list;
-  }
-  _serialize(parentId, parentKey, doc, intent) {
-    if (this._id == null) {
-      throw new Error("Cannot serialize item is not attached");
-    }
-    if (parentId == null || parentKey == null) {
-      throw new Error("Cannot serialize list if parentId or parentKey is undefined");
-    }
-    const ops = [];
-    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 this._items) {
-      ops.push(...value._serialize(this._id, key, doc));
-    }
-    return ops;
-  }
-  _indexOfPosition(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);
-    }
-  }
-  _detach() {
-    super._detach();
-    for (const [value] of this._items) {
-      value._detach();
-    }
-  }
-  _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 = this._items.findIndex((entry) => entry[1] === key);
-    let newKey = key;
-    if (index !== -1) {
-      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 {
-        this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) == null ? void 0 : _a[1]);
-      }
-    }
-    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: {
-        node: this,
-        type: "LiveList",
-        updates: [
-          {
-            index: newIndex,
-            type: "insert",
-            item: child instanceof LiveRegister ? child.data : child
-          }
-        ]
-      }
-    };
-  }
-  _detachChild(child) {
-    if (child) {
-      const reverse = child._serialize(this._id, child._parentKey, this._doc);
-      const indexToDelete = this._items.findIndex((item) => item[0] === child);
-      this._items.splice(indexToDelete, 1);
-      child._detach();
-      const storageUpdate = {
-        node: this,
-        type: "LiveList",
-        updates: [{ index: indexToDelete, type: "delete" }]
-      };
-      return { modified: storageUpdate, reverse };
-    }
-    return { modified: false };
-  }
-  _setChildKey(key, child, previousKey) {
-    var _a;
-    child._setParentLink(this, key);
-    const previousIndex = this._items.findIndex((entry) => entry[0]._id === child._id);
-    const index = this._items.findIndex((entry) => entry[1] === key);
-    if (index !== -1) {
-      this._items[index][1] = makePosition(key, (_a = this._items[index + 1]) == null ? void 0 : _a[1]);
-    }
-    const item = this._items.find((item2) => item2[0] === child);
-    if (item) {
-      item[1] = key;
-    }
-    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,
-        item: child instanceof LiveRegister ? child.data : child,
-        previousIndex,
-        type: "move"
-      }
-    ];
-    return {
-      modified: {
-        node: this,
-        type: "LiveList",
-        updates: updatesDelta
-      },
-      reverse: [
-        {
-          type: OpType.SetParentKey,
-          id: item == null ? void 0 : item[0]._id,
-          parentKey: previousKey
-        }
-      ]
-    };
-  }
-  _apply(op, isLocal) {
-    return super._apply(op, isLocal);
-  }
-  _toSerializedCrdt() {
-    var _a;
-    return {
-      type: CrdtType.List,
-      parentId: (_a = this._parent) == null ? void 0 : _a._id,
-      parentKey: this._parentKey
-    };
-  }
-  get length() {
-    return this._items.length;
-  }
-  push(element) {
-    return this.insert(element, this.length);
-  }
-  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 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);
-    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);
-      const storageUpdates = /* @__PURE__ */ 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: OpType.DeleteCrdt, id }], storageUpdates);
-    }
-  }
-  move(index, targetIndex) {
-    if (targetIndex < 0) {
-      throw new Error("targetIndex cannot be less than 0");
-    }
-    if (targetIndex >= this._items.length) {
-      throw new Error("targetIndex cannot be greater or equal than the list length");
-    }
-    if (index < 0) {
-      throw new Error("index cannot be less than 0");
-    }
-    if (index >= this._items.length) {
-      throw new Error("index cannot be greater or equal than the list length");
-    }
-    let beforePosition = null;
-    let afterPosition = null;
-    if (index < targetIndex) {
-      afterPosition = targetIndex === this._items.length - 1 ? void 0 : this._items[targetIndex + 1][1];
-      beforePosition = this._items[targetIndex][1];
-    } else {
-      afterPosition = this._items[targetIndex][1];
-      beforePosition = targetIndex === 0 ? void 0 : this._items[targetIndex - 1][1];
-    }
-    const position = makePosition(beforePosition, afterPosition);
-    const item = this._items[index];
-    const previousPosition = item[1];
-    item[1] = position;
-    item[0]._setParentLink(this, 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, {
-        node: this,
-        type: "LiveList",
-        updates: [
-          {
-            index: newIndex,
-            previousIndex: index,
-            item: item[0],
-            type: "move"
-          }
-        ]
-      });
-      this._doc.dispatch([
-        {
-          type: OpType.SetParentKey,
-          id: item[0]._id,
-          opId: this._doc.generateOpId(),
-          parentKey: position
-        }
-      ], [
-        {
-          type: OpType.SetParentKey,
-          id: item[0]._id,
-          parentKey: previousPosition
-        }
-      ], storageUpdates);
-    }
-  }
-  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];
-    item[0]._detach();
-    this._items.splice(index, 1);
-    if (this._doc) {
-      const childRecordId = item[0]._id;
-      if (childRecordId) {
-        const storageUpdates = /* @__PURE__ */ new Map();
-        storageUpdates.set(this._id, {
-          node: this,
-          type: "LiveList",
-          updates: [{ index, type: "delete" }]
-        });
-        this._doc.dispatch([
-          {
-            id: childRecordId,
-            opId: this._doc.generateOpId(),
-            type: OpType.DeleteCrdt
-          }
-        ], item[0]._serialize(this._id, item[1]), storageUpdates);
-      }
-    }
-  }
-  clear() {
-    if (this._doc) {
-      const ops = [];
-      const reverseOps = [];
-      const updateDelta = [];
-      let i = 0;
-      for (const item of this._items) {
-        item[0]._detach();
-        const childId = item[0]._id;
-        if (childId) {
-          ops.push({ id: childId, type: OpType.DeleteCrdt });
-          reverseOps.push(...item[0]._serialize(this._id, item[1]));
-          updateDelta.push({ index: i, type: "delete" });
-        }
-        i++;
-      }
-      this._items = [];
-      const storageUpdates = /* @__PURE__ */ new Map();
-      storageUpdates.set(this._id, {
-        node: this,
-        type: "LiveList",
-        updates: updateDelta
-      });
-      this._doc.dispatch(ops, reverseOps, storageUpdates);
-    } else {
-      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, 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 this._items.map((entry) => selfOrRegisterValue(entry[0]));
-  }
-  every(predicate) {
-    return this.toArray().every(predicate);
-  }
-  filter(predicate) {
-    return this.toArray().filter(predicate);
-  }
-  find(predicate) {
-    return this.toArray().find(predicate);
-  }
-  findIndex(predicate) {
-    return this.toArray().findIndex(predicate);
-  }
-  forEach(callbackfn) {
-    return this.toArray().forEach(callbackfn);
-  }
-  get(index) {
-    if (index < 0 || index >= this._items.length) {
-      return void 0;
-    }
-    return selfOrRegisterValue(this._items[index][0]);
-  }
-  indexOf(searchElement, fromIndex) {
-    return this.toArray().indexOf(searchElement, fromIndex);
-  }
-  lastIndexOf(searchElement, fromIndex) {
-    return this.toArray().lastIndexOf(searchElement, fromIndex);
-  }
-  map(callback) {
-    return this._items.map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
-  }
-  some(predicate) {
-    return this.toArray().some(predicate);
-  }
-  [Symbol.iterator]() {
-    return new LiveListIterator(this._items);
-  }
-}
-class LiveListIterator {
-  constructor(items) {
-    this._innerIterator = items[Symbol.iterator]();
-  }
-  [Symbol.iterator]() {
-    return this;
-  }
-  next() {
-    const result = this._innerIterator.next();
-    if (result.done) {
-      return {
-        done: true,
-        value: void 0
-      };
-    }
-    return {
-      value: selfOrRegisterValue(result.value[0])
-    };
-  }
-}
-
-class LiveMap extends AbstractCrdt {
-  constructor(entries) {
-    super();
-    if (entries) {
-      const mappedEntries = [];
-      for (const entry of entries) {
-        const value = selfOrRegister(entry[1]);
-        value._setParentLink(this, entry[0]);
-        mappedEntries.push([entry[0], value]);
-      }
-      this._map = new Map(mappedEntries);
-    } else {
-      this._map = /* @__PURE__ */ new Map();
-    }
-  }
-  _serialize(parentId, parentKey, doc, intent) {
-    if (this._id == null) {
-      throw new Error("Cannot serialize item is not attached");
-    }
-    if (parentId == null || parentKey == null) {
-      throw new Error("Cannot serialize map if parentId or parentKey is undefined");
-    }
-    const ops = [];
-    const op = {
-      id: this._id,
-      opId: doc == null ? void 0 : doc.generateOpId(),
-      type: OpType.CreateMap,
-      intent,
-      parentId,
-      parentKey
-    };
-    ops.push(op);
-    for (const [key, value] of this._map) {
-      ops.push(...value._serialize(this._id, key, doc));
-    }
-    return ops;
-  }
-  static _deserialize([id, item], parentToChildren, doc) {
-    if (item.type !== CrdtType.Map) {
-      throw new Error(`Tried to deserialize a map but item type is "${item.type}"`);
-    }
-    const map = new LiveMap();
-    map._attach(id, doc);
-    const children = parentToChildren.get(id);
-    if (children == null) {
-      return map;
-    }
-    for (const entry of children) {
-      const crdt = entry[1];
-      if (crdt.parentKey == null) {
-        throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
-      }
-      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) {
-      if (isCrdt(value)) {
-        value._attach(doc.generateId(), doc);
-      }
-    }
-  }
-  _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 = this._map.get(key);
-    let reverse;
-    if (previousValue) {
-      reverse = previousValue._serialize(this._id, key);
-      previousValue._detach();
-    } else {
-      reverse = [{ type: OpType.DeleteCrdt, id }];
-    }
-    child._setParentLink(this, key);
-    child._attach(id, this._doc);
-    this._map.set(key, child);
-    return {
-      modified: {
-        node: this,
-        type: "LiveMap",
-        updates: { [key]: { type: "update" } }
-      },
-      reverse
-    };
-  }
-  _detach() {
-    super._detach();
-    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 this._map) {
-      if (value === child) {
-        this._map.delete(key);
-      }
-    }
-    child._detach();
-    const storageUpdate = {
-      node: this,
-      type: "LiveMap",
-      updates: { [child._parentKey]: { type: "delete" } }
-    };
-    return { modified: storageUpdate, reverse };
-  }
-  _toSerializedCrdt() {
-    var _a;
-    return {
-      type: CrdtType.Map,
-      parentId: (_a = this._parent) == null ? void 0 : _a._id,
-      parentKey: this._parentKey
-    };
-  }
-  get(key) {
-    const value = this._map.get(key);
-    if (value == void 0) {
-      return void 0;
-    }
-    return selfOrRegisterValue(value);
-  }
-  set(key, value) {
-    const oldValue = this._map.get(key);
-    if (oldValue) {
-      oldValue._detach();
-    }
-    const item = selfOrRegister(value);
-    item._setParentLink(this, key);
-    this._map.set(key, item);
-    if (this._doc && this._id) {
-      const id = this._doc.generateId();
-      item._attach(id, this._doc);
-      const storageUpdates = /* @__PURE__ */ new Map();
-      storageUpdates.set(this._id, {
-        node: this,
-        type: "LiveMap",
-        updates: { [key]: { type: "update" } }
-      });
-      this._doc.dispatch(item._serialize(this._id, key, this._doc), oldValue ? oldValue._serialize(this._id, key) : [{ type: OpType.DeleteCrdt, id }], storageUpdates);
-    }
-  }
-  get size() {
-    return this._map.size;
-  }
-  has(key) {
-    return this._map.has(key);
-  }
-  delete(key) {
-    const item = this._map.get(key);
-    if (item == null) {
-      return false;
-    }
-    item._detach();
-    this._map.delete(key);
-    if (this._doc && item._id) {
-      const storageUpdates = /* @__PURE__ */ new Map();
-      storageUpdates.set(this._id, {
-        node: this,
-        type: "LiveMap",
-        updates: { [key]: { type: "delete" } }
-      });
-      this._doc.dispatch([
-        {
-          type: OpType.DeleteCrdt,
-          id: item._id,
-          opId: this._doc.generateOpId()
-        }
-      ], item._serialize(this._id, key), storageUpdates);
-    }
-    return true;
-  }
-  entries() {
-    const innerIterator = this._map.entries();
-    return {
-      [Symbol.iterator]: function() {
-        return this;
-      },
-      next() {
-        const iteratorValue = innerIterator.next();
-        if (iteratorValue.done) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        const entry = iteratorValue.value;
-        return {
-          value: [entry[0], selfOrRegisterValue(iteratorValue.value[1])]
-        };
-      }
-    };
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  keys() {
-    return this._map.keys();
-  }
-  values() {
-    const innerIterator = this._map.values();
-    return {
-      [Symbol.iterator]: function() {
-        return this;
-      },
-      next() {
-        const iteratorValue = innerIterator.next();
-        if (iteratorValue.done) {
-          return {
-            done: true,
-            value: void 0
-          };
-        }
-        return {
-          value: selfOrRegisterValue(iteratorValue.value)
-        };
-      }
-    };
-  }
-  forEach(callback) {
-    for (const entry of this) {
-      callback(entry[1], entry[0], this);
-    }
-  }
-}
-
-function parseJson(rawMessage) {
-  try {
-    return JSON.parse(rawMessage);
-  } catch (e) {
-    return void 0;
-  }
-}
-function isJsonArray(data) {
-  return Array.isArray(data);
-}
-function isJsonObject(data) {
-  return data !== null && typeof data === "object" && !isJsonArray(data);
-}
-
-var __defProp$2 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$2.call(b, prop))
-      __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(b)) {
-      if (__propIsEnum$2.call(b, prop))
-        __defNormalProp$2(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-function remove(array, item) {
-  for (let i = 0; i < array.length; i++) {
-    if (array[i] === item) {
-      array.splice(i, 1);
-      break;
-    }
-  }
-}
-function compact(items) {
-  return items.filter((item) => item != null);
-}
-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;
-  }
-  if (node._parent) {
-    return isSameNodeOrChildOf(node._parent, parent);
-  }
-  return false;
-}
-function deserialize(entry, parentToChildren, doc) {
-  switch (entry[1].type) {
-    case CrdtType.Object: {
-      return LiveObject._deserialize(entry, parentToChildren, doc);
-    }
-    case CrdtType.List: {
-      return LiveList._deserialize(entry, parentToChildren, doc);
-    }
-    case CrdtType.Map: {
-      return LiveMap._deserialize(entry, parentToChildren, doc);
-    }
-    case CrdtType.Register: {
-      return LiveRegister._deserialize(entry, parentToChildren, doc);
-    }
-    default: {
-      throw new Error("Unexpected CRDT type");
-    }
-  }
-}
-function isCrdt(obj) {
-  return obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList || obj instanceof LiveRegister;
-}
-function selfOrRegisterValue(obj) {
-  if (obj instanceof LiveRegister) {
-    return obj.data;
-  }
-  return obj;
-}
-function selfOrRegister(obj) {
-  if (obj instanceof LiveObject || obj instanceof LiveMap || obj instanceof LiveList) {
-    return obj;
-  } else if (obj instanceof LiveRegister) {
-    throw new Error("Internal error. LiveRegister should not be created from selfOrRegister");
-  } else {
-    return new LiveRegister(obj);
-  }
-}
-function getTreesDiffOperations(currentItems, newItems) {
-  const ops = [];
-  currentItems.forEach((_, id) => {
-    if (!newItems.get(id)) {
-      ops.push({
-        type: OpType.DeleteCrdt,
-        id
-      });
-    }
-  });
-  newItems.forEach((crdt, id) => {
-    const currentCrdt = currentItems.get(id);
-    if (currentCrdt) {
-      if (crdt.type === CrdtType.Object) {
-        if (JSON.stringify(crdt.data) !== JSON.stringify(currentCrdt.data)) {
-          ops.push({
-            type: OpType.UpdateObject,
-            id,
-            data: crdt.data
-          });
-        }
-      }
-      if (crdt.parentKey !== currentCrdt.parentKey) {
-        ops.push({
-          type: OpType.SetParentKey,
-          id,
-          parentKey: crdt.parentKey
-        });
-      }
-    } else {
-      switch (crdt.type) {
-        case CrdtType.Register:
-          ops.push({
-            type: OpType.CreateRegister,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey,
-            data: crdt.data
-          });
-          break;
-        case CrdtType.List:
-          ops.push({
-            type: OpType.CreateList,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey
-          });
-          break;
-        case CrdtType.Object:
-          ops.push({
-            type: OpType.CreateObject,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey,
-            data: crdt.data
-          });
-          break;
-        case CrdtType.Map:
-          ops.push({
-            type: OpType.CreateMap,
-            id,
-            parentId: crdt.parentId,
-            parentKey: crdt.parentKey
-          });
-          break;
-      }
-    }
-  });
-  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 (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) {
-  const type = typeof value;
-  return type === "undefined" || value === null || type === "string" || type === "boolean" || type === "number" || Array.isArray(value) || isPlainObject$1(value);
-}
-function isPlainObject$1(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  if (proto === null)
-    return true;
-  let baseProto = proto;
-  while (Object.getPrototypeOf(baseProto) !== null) {
-    baseProto = Object.getPrototypeOf(baseProto);
-  }
-  return proto === baseProto;
-}
-function findNonSerializableValue(value, path = "") {
-  if (!isPlain) {
-    return {
-      path: path || "root",
-      value
-    };
-  }
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  for (const [key, nestedValue] of Object.entries(value)) {
-    const nestedPath = path ? path + "." + key : key;
-    if (!isPlain(nestedValue)) {
-      return {
-        path: nestedPath,
-        value: nestedValue
-      };
-    }
-    if (typeof nestedValue === "object") {
-      const nonSerializableNestedValue = findNonSerializableValue(nestedValue, nestedPath);
-      if (nonSerializableNestedValue) {
-        return nonSerializableNestedValue;
-      }
-    }
-  }
-  return false;
-}
-function isTokenValid(token) {
-  const tokenParts = token.split(".");
-  if (tokenParts.length !== 3) {
-    return false;
-  }
-  const data = parseJson(atob(tokenParts[1]));
-  if (data === void 0 || !isJsonObject(data) || 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);
-}
-
-class LiveObject extends AbstractCrdt {
-  constructor(object = {}) {
-    super();
-    this._propToLastUpdate = /* @__PURE__ */ new Map();
-    for (const key in object) {
-      const value = object[key];
-      if (value instanceof AbstractCrdt) {
-        value._setParentLink(this, key);
-      }
-    }
-    this._map = new Map(Object.entries(object));
-  }
-  _serialize(parentId, parentKey, doc, intent) {
-    if (this._id == null) {
-      throw new Error("Cannot serialize item is not attached");
-    }
-    const ops = [];
-    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 this._map) {
-      if (value instanceof AbstractCrdt) {
-        ops.push(...value._serialize(this._id, key, doc));
-      } else {
-        op.data[key] = value;
-      }
-    }
-    return ops;
-  }
-  static _deserialize([id, item], parentToChildren, doc) {
-    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);
-    object._attach(id, doc);
-    return this._deserializeChildren(object, parentToChildren, doc);
-  }
-  static _deserializeChildren(object, parentToChildren, doc) {
-    const children = parentToChildren.get(object._id);
-    if (children == null) {
-      return object;
-    }
-    for (const entry of children) {
-      const crdt = entry[1];
-      if (crdt.parentKey == null) {
-        throw new Error("Tried to deserialize a crdt but it does not have a parentKey and is not the root");
-      }
-      const child = deserialize(entry, parentToChildren, doc);
-      child._setParentLink(object, crdt.parentKey);
-      object._map.set(crdt.parentKey, child);
-    }
-    return object;
-  }
-  _attach(id, doc) {
-    super._attach(id, doc);
-    for (const [_key, value] of this._map) {
-      if (value instanceof AbstractCrdt) {
-        value._attach(doc.generateId(), doc);
-      }
-    }
-  }
-  _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 (this._propToLastUpdate.get(key) === opId) {
-        this._propToLastUpdate.delete(key);
-      }
-      return { modified: false };
-    }
-    if (isLocal) {
-      this._propToLastUpdate.set(key, opId);
-    } else if (this._propToLastUpdate.get(key) === void 0) ; else if (this._propToLastUpdate.get(key) === opId) {
-      this._propToLastUpdate.delete(key);
-      return { modified: false };
-    } else {
-      return { modified: false };
-    }
-    const previousValue = this._map.get(key);
-    let reverse;
-    if (isCrdt(previousValue)) {
-      reverse = previousValue._serialize(this._id, key);
-      previousValue._detach();
-    } else if (previousValue === void 0) {
-      reverse = [
-        { type: OpType.DeleteObjectKey, id: this._id, key }
-      ];
-    } else {
-      reverse = [
-        {
-          type: OpType.UpdateObject,
-          id: this._id,
-          data: { [key]: previousValue }
-        }
-      ];
-    }
-    this._map.set(key, child);
-    child._setParentLink(this, key);
-    child._attach(id, this._doc);
-    return {
-      reverse,
-      modified: {
-        node: this,
-        type: "LiveObject",
-        updates: { [key]: { type: "update" } }
-      }
-    };
-  }
-  _detachChild(child) {
-    if (child) {
-      const reverse = child._serialize(this._id, child._parentKey, this._doc);
-      for (const [key, value] of this._map) {
-        if (value === child) {
-          this._map.delete(key);
-        }
-      }
-      child._detach();
-      const storageUpdate = {
-        node: this,
-        type: "LiveObject",
-        updates: {
-          [child._parentKey]: { type: "delete" }
-        }
-      };
-      return { modified: storageUpdate, reverse };
-    }
-    return { modified: false };
-  }
-  _detachChildren() {
-    for (const [key, value] of this._map) {
-      this._map.delete(key);
-      value._detach();
-    }
-  }
-  _detach() {
-    super._detach();
-    for (const value of this._map.values()) {
-      if (isCrdt(value)) {
-        value._detach();
-      }
-    }
-  }
-  _apply(op, isLocal) {
-    if (op.type === OpType.UpdateObject) {
-      return this._applyUpdate(op, isLocal);
-    } else if (op.type === OpType.DeleteObjectKey) {
-      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
-    };
-  }
-  _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(this._map);
-  }
-  set(key, value) {
-    this.update({ [key]: value });
-  }
-  get(key) {
-    return this._map.get(key);
-  }
-  delete(key) {
-    const keyAsString = key;
-    const oldValue = this._map.get(keyAsString);
-    if (oldValue === void 0) {
-      return;
-    }
-    if (this._doc == null || this._id == null) {
-      if (oldValue instanceof AbstractCrdt) {
-        oldValue._detach();
-      }
-      this._map.delete(keyAsString);
-      return;
-    }
-    let reverse;
-    if (oldValue instanceof AbstractCrdt) {
-      oldValue._detach();
-      reverse = oldValue._serialize(this._id, keyAsString);
-    } else {
-      reverse = [
-        {
-          type: OpType.UpdateObject,
-          data: { [keyAsString]: oldValue },
-          id: this._id
-        }
-      ];
-    }
-    this._map.delete(keyAsString);
-    const storageUpdates = /* @__PURE__ */ new Map();
-    storageUpdates.set(this._id, {
-      node: this,
-      type: "LiveObject",
-      updates: { [key]: { type: "delete" } }
-    });
-    this._doc.dispatch([
-      {
-        type: OpType.DeleteObjectKey,
-        key: keyAsString,
-        id: this._id,
-        opId: this._doc.generateOpId()
-      }
-    ], reverse, storageUpdates);
-  }
-  update(overrides) {
-    if (this._doc == null || this._id == null) {
-      for (const key in overrides) {
-        const oldValue = this._map.get(key);
-        if (oldValue instanceof AbstractCrdt) {
-          oldValue._detach();
-        }
-        const newValue = overrides[key];
-        if (newValue instanceof AbstractCrdt) {
-          newValue._setParentLink(this, key);
-        }
-        this._map.set(key, newValue);
-      }
-      return;
-    }
-    const ops = [];
-    const reverseOps = [];
-    const opId = this._doc.generateOpId();
-    const updatedProps = {};
-    const reverseUpdateOp = {
-      id: this._id,
-      type: OpType.UpdateObject,
-      data: {}
-    };
-    const updateDelta = {};
-    for (const key in overrides) {
-      const oldValue = this._map.get(key);
-      if (oldValue instanceof AbstractCrdt) {
-        reverseOps.push(...oldValue._serialize(this._id, key));
-        oldValue._detach();
-      } else if (oldValue === void 0) {
-        reverseOps.push({ type: OpType.DeleteObjectKey, id: this._id, key });
-      } else {
-        reverseUpdateOp.data[key] = oldValue;
-      }
-      const newValue = overrides[key];
-      if (newValue instanceof AbstractCrdt) {
-        newValue._setParentLink(this, key);
-        newValue._attach(this._doc.generateId(), this._doc);
-        const newAttachChildOps = newValue._serialize(this._id, key, this._doc);
-        const createCrdtOp = newAttachChildOps.find((op) => op.parentId === this._id);
-        if (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" };
-    }
-    if (Object.keys(reverseUpdateOp.data).length !== 0) {
-      reverseOps.unshift(reverseUpdateOp);
-    }
-    if (Object.keys(updatedProps).length !== 0) {
-      ops.unshift({
-        opId,
-        id: this._id,
-        type: OpType.UpdateObject,
-        data: updatedProps
-      });
-    }
-    const storageUpdates = /* @__PURE__ */ new Map();
-    storageUpdates.set(this._id, {
-      node: this,
-      type: "LiveObject",
-      updates: updateDelta
-    });
-    this._doc.dispatch(ops, reverseOps, storageUpdates);
-  }
-}
-
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-const BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
-const BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
-const HEARTBEAT_INTERVAL = 3e4;
-const PONG_TIMEOUT = 2e3;
-function isValidRoomEventType(value) {
-  return value === "my-presence" || value === "others" || value === "event" || value === "error" || value === "connection";
-}
-function makeIdFactory(connectionId) {
-  let count = 0;
-  return () => `${connectionId}:${count++}`;
-}
-function makeOthers(userMap) {
-  const users = Object.values(userMap).map((user) => {
-    const _a = user, publicKeys = __objRest(_a, ["_hasReceivedInitialPresence"]);
-    return publicKeys;
-  });
-  return {
-    get count() {
-      return users.length;
-    },
-    [Symbol.iterator]() {
-      return users[Symbol.iterator]();
-    },
-    map(callback) {
-      return users.map(callback);
-    },
-    toArray() {
-      return users;
-    }
-  };
-}
-function makeStateMachine(state, context, mockedEffects) {
-  const effects = mockedEffects || {
-    authenticate(auth, createWebSocket) {
-      const token = state.token;
-      if (token && isTokenValid(token)) {
-        const parsedToken = parseToken(token);
-        const socket = createWebSocket(token);
-        authenticationSuccess(parsedToken, socket);
-      } else {
-        return auth(context.roomId).then(({ token: token2 }) => {
-          if (state.connection.state !== "authenticating") {
-            return;
-          }
-          const parsedToken = parseToken(token2);
-          const socket = createWebSocket(token2);
-          authenticationSuccess(parsedToken, socket);
-          state.token = token2;
-        }).catch((er) => authenticationFailure(er));
-      }
-    },
-    send(messageOrMessages) {
-      if (state.socket == null) {
-        throw new Error("Can't send message if socket is null");
-      }
-      state.socket.send(JSON.stringify(messageOrMessages));
-    },
-    delayFlush(delay) {
-      return setTimeout(tryFlushing, delay);
-    },
-    startHeartbeatInterval() {
-      return setInterval(heartbeat, HEARTBEAT_INTERVAL);
-    },
-    schedulePongTimeout() {
-      return setTimeout(pongTimeout, PONG_TIMEOUT);
-    },
-    scheduleReconnect(delay) {
-      return setTimeout(connect, delay);
-    }
-  };
-  function genericSubscribe(callback) {
-    state.listeners.storage.push(callback);
-    return () => remove(state.listeners.storage, callback);
-  }
-  function crdtSubscribe(crdt, innerCallback, options) {
-    const cb = (updates) => {
-      const relatedUpdates = [];
-      for (const update of updates) {
-        if ((options == null ? void 0 : options.isDeep) && isSameNodeOrChildOf(update.node, crdt)) {
-          relatedUpdates.push(update);
-        } else if (update.node._id === crdt._id) {
-          innerCallback(update.node);
-        }
-      }
-      if ((options == null ? void 0 : options.isDeep) && relatedUpdates.length > 0) {
-        innerCallback(relatedUpdates);
-      }
-    };
-    return genericSubscribe(cb);
-  }
-  function createOrUpdateRootFromMessage(message) {
-    if (message.items.length === 0) {
-      throw new Error("Internal error: cannot load storage without items");
-    }
-    if (state.root) {
-      updateRoot(message.items);
-    } else {
-      state.root = load(message.items);
-    }
-    for (const key in state.defaultStorageRoot) {
-      if (state.root.get(key) == null) {
-        state.root.set(key, state.defaultStorageRoot[key]);
-      }
-    }
-  }
-  function buildRootAndParentToChildren(items) {
-    const parentToChildren = /* @__PURE__ */ new Map();
-    let root = null;
-    for (const tuple of items) {
-      const parentId = tuple[1].parentId;
-      if (parentId == null) {
-        root = tuple;
-      } else {
-        const children = parentToChildren.get(parentId);
-        if (children != null) {
-          children.push(tuple);
-        } else {
-          parentToChildren.set(parentId, [tuple]);
-        }
-      }
-    }
-    if (root == null) {
-      throw new Error("Root can't be null");
-    }
-    return [root, parentToChildren];
-  }
-  function updateRoot(items) {
-    if (!state.root) {
-      return;
-    }
-    const currentItems = /* @__PURE__ */ new Map();
-    state.items.forEach((liveCrdt, id) => {
-      currentItems.set(id, liveCrdt._toSerializedCrdt());
-    });
-    const ops = getTreesDiffOperations(currentItems, new Map(items));
-    const result = apply(ops, false);
-    notify(result.updates);
-  }
-  function load(items) {
-    const [root, parentToChildren] = buildRootAndParentToChildren(items);
-    return LiveObject._deserialize(root, parentToChildren, {
-      getItem,
-      addItem,
-      deleteItem,
-      generateId,
-      generateOpId,
-      dispatch: storageDispatch,
-      roomId: context.roomId
-    });
-  }
-  function addItem(id, item) {
-    state.items.set(id, item);
-  }
-  function deleteItem(id) {
-    state.items.delete(id);
-  }
-  function getItem(id) {
-    return state.items.get(id);
-  }
-  function addToUndoStack(historyItem) {
-    if (state.undoStack.length >= 50) {
-      state.undoStack.shift();
-    }
-    if (state.isHistoryPaused) {
-      state.pausedHistory.unshift(...historyItem);
-    } else {
-      state.undoStack.push(historyItem);
-    }
-  }
-  function storageDispatch(ops, reverse, storageUpdates) {
-    if (state.isBatching) {
-      state.batch.ops.push(...ops);
-      storageUpdates.forEach((value, key) => {
-        state.batch.updates.storageUpdates.set(key, mergeStorageUpdates(state.batch.updates.storageUpdates.get(key), value));
-      });
-      state.batch.reverseOps.push(...reverse);
-    } else {
-      addToUndoStack(reverse);
-      state.redoStack = [];
-      dispatch(ops);
-      notify({ storageUpdates });
-    }
-  }
-  function notify({
-    storageUpdates = /* @__PURE__ */ new Map(),
-    presence = false,
-    others: otherEvents = []
-  }) {
-    if (otherEvents.length > 0) {
-      state.others = makeOthers(state.users);
-      for (const event of otherEvents) {
-        for (const listener of state.listeners.others) {
-          listener(state.others, event);
-        }
-      }
-    }
-    if (presence) {
-      for (const listener of state.listeners["my-presence"]) {
-        listener(state.me);
-      }
-    }
-    if (storageUpdates.size > 0) {
-      for (const subscriber of state.listeners.storage) {
-        subscriber(Array.from(storageUpdates.values()));
-      }
-    }
-  }
-  function getConnectionId() {
-    if (state.connection.state === "open" || state.connection.state === "connecting") {
-      return state.connection.id;
-    } else if (state.lastConnectionId !== null) {
-      return state.lastConnectionId;
-    }
-    throw new Error("Internal. Tried to get connection id but connection was never open");
-  }
-  function generateId() {
-    return `${getConnectionId()}:${state.clock++}`;
-  }
-  function generateOpId() {
-    return `${getConnectionId()}:${state.opClock++}`;
-  }
-  function apply(item, isLocal) {
-    var _a;
-    const result = {
-      reverse: [],
-      updates: {
-        storageUpdates: /* @__PURE__ */ new Map(),
-        presence: false
-      }
-    };
-    const createdNodeIds = /* @__PURE__ */ new Set();
-    for (const op of item) {
-      if (op.type === "presence") {
-        const reverse = {
-          type: "presence",
-          data: {}
-        };
-        for (const key in op.data) {
-          reverse.data[key] = state.me[key];
-        }
-        state.me = __spreadValues$1(__spreadValues$1({}, state.me), op.data);
-        if (state.buffer.presence == null) {
-          state.buffer.presence = op.data;
-        } else {
-          for (const key in op.data) {
-            state.buffer.presence[key] = op.data[key];
-          }
-        }
-        result.reverse.unshift(reverse);
-        result.updates.presence = true;
-      } else {
-        if (isLocal && !op.opId) {
-          op.opId = generateOpId();
-        }
-        const applyOpResult = applyOp(op, isLocal);
-        if (applyOpResult.modified) {
-          const parentId = (_a = applyOpResult.modified.node._parent) == null ? void 0 : _a._id;
-          if (!createdNodeIds.has(parentId)) {
-            result.updates.storageUpdates.set(applyOpResult.modified.node._id, mergeStorageUpdates(result.updates.storageUpdates.get(applyOpResult.modified.node._id), applyOpResult.modified));
-            result.reverse.unshift(...applyOpResult.reverse);
-          }
-          if (op.type === OpType.CreateList || op.type === OpType.CreateMap || op.type === OpType.CreateObject) {
-            createdNodeIds.add(applyOpResult.modified.node._id);
-          }
-        }
-      }
-    }
-    return result;
-  }
-  function applyOp(op, isLocal) {
-    if (op.opId) {
-      state.offlineOperations.delete(op.opId);
-    }
-    switch (op.type) {
-      case OpType.DeleteObjectKey:
-      case OpType.UpdateObject:
-      case OpType.DeleteCrdt: {
-        const item = state.items.get(op.id);
-        if (item == null) {
-          return { modified: false };
-        }
-        return item._apply(op, isLocal);
-      }
-      case OpType.SetParentKey: {
-        const item = state.items.get(op.id);
-        if (item == null) {
-          return { modified: false };
-        }
-        if (item._parent instanceof LiveList) {
-          const previousKey = item._parentKey;
-          if (previousKey === op.parentKey) {
-            return { modified: false };
-          } else {
-            return item._parent._setChildKey(op.parentKey, item, previousKey);
-          }
-        }
-        return { modified: false };
-      }
-      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, isLocal);
-      }
-    }
-    return { modified: false };
-  }
-  function subscribe(firstParam, listener, options) {
-    if (firstParam instanceof AbstractCrdt) {
-      return crdtSubscribe(firstParam, listener, options);
-    } else if (typeof firstParam === "function") {
-      return genericSubscribe(firstParam);
-    } else if (!isValidRoomEventType(firstParam)) {
-      throw new Error(`"${firstParam}" is not a valid event name`);
-    }
-    state.listeners[firstParam].push(listener);
-    return () => {
-      const callbacks = state.listeners[firstParam];
-      remove(callbacks, listener);
-    };
-  }
-  function unsubscribe(event, callback) {
-    console.warn(`unsubscribe is depreacted and will be removed in a future version.
-use the callback returned by subscribe instead.
-See v0.13 release notes for more information.
-`);
-    if (!isValidRoomEventType(event)) {
-      throw new Error(`"${event}" is not a valid event name`);
-    }
-    const callbacks = state.listeners[event];
-    remove(callbacks, callback);
-  }
-  function getConnectionState() {
-    return state.connection.state;
-  }
-  function getSelf() {
-    return state.connection.state === "open" || state.connection.state === "connecting" ? {
-      connectionId: state.connection.id,
-      id: state.connection.userId,
-      info: state.connection.userInfo,
-      presence: getPresence()
-    } : null;
-  }
-  function connect() {
-    if (state.connection.state !== "closed" && state.connection.state !== "unavailable") {
-      return null;
-    }
-    const auth = prepareAuthEndpoint(context.authentication, context.fetchPolyfill);
-    const createWebSocket = prepareCreateWebSocket(context.liveblocksServer, context.WebSocketPolyfill);
-    updateConnection({ state: "authenticating" });
-    effects.authenticate(auth, createWebSocket);
-  }
-  function updatePresence(overrides, options) {
-    const oldValues = {};
-    if (state.buffer.presence == null) {
-      state.buffer.presence = {};
-    }
-    for (const key in overrides) {
-      state.buffer.presence[key] = overrides[key];
-      oldValues[key] = state.me[key];
-    }
-    state.me = __spreadValues$1(__spreadValues$1({}, state.me), overrides);
-    if (state.isBatching) {
-      if (options == null ? void 0 : options.addToHistory) {
-        state.batch.reverseOps.push({ type: "presence", data: oldValues });
-      }
-      state.batch.updates.presence = true;
-    } else {
-      tryFlushing();
-      if (options == null ? void 0 : options.addToHistory) {
-        addToUndoStack([{ type: "presence", data: oldValues }]);
-      }
-      notify({ presence: true });
-    }
-  }
-  function authenticationSuccess(token, socket) {
-    socket.addEventListener("message", onMessage);
-    socket.addEventListener("open", onOpen);
-    socket.addEventListener("close", onClose);
-    socket.addEventListener("error", onError);
-    updateConnection({
-      state: "connecting",
-      id: token.actor,
-      userInfo: token.info,
-      userId: token.id
-    });
-    state.idFactory = makeIdFactory(token.actor);
-    state.socket = socket;
-  }
-  function authenticationFailure(error) {
-    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());
-  }
-  function onVisibilityChange(visibilityState) {
-    if (visibilityState === "visible" && state.connection.state === "open") {
-      heartbeat();
-    }
-  }
-  function onUpdatePresenceMessage(message) {
-    const user = state.users[message.actor];
-    if (message.targetActor === void 0 && user != null && !user._hasReceivedInitialPresence) {
-      return void 0;
-    }
-    if (user == null) {
-      state.users[message.actor] = {
-        connectionId: message.actor,
-        presence: message.data,
-        _hasReceivedInitialPresence: true
-      };
-    } else {
-      state.users[message.actor] = {
-        id: user.id,
-        info: user.info,
-        connectionId: message.actor,
-        presence: __spreadValues$1(__spreadValues$1({}, user.presence), message.data),
-        _hasReceivedInitialPresence: true
-      };
-    }
-    return {
-      type: "update",
-      updates: message.data,
-      user: state.users[message.actor]
-    };
-  }
-  function onUserLeftMessage(message) {
-    const userLeftMessage = message;
-    const user = state.users[userLeftMessage.actor];
-    if (user) {
-      delete state.users[userLeftMessage.actor];
-      return { type: "leave", user };
-    }
-    return null;
-  }
-  function onRoomStateMessage(message) {
-    const newUsers = {};
-    for (const key in message.users) {
-      const connectionId = Number.parseInt(key);
-      const user = message.users[key];
-      newUsers[connectionId] = {
-        connectionId,
-        info: user.info,
-        id: user.id
-      };
-    }
-    state.users = newUsers;
-    return { type: "reset" };
-  }
-  function onNavigatorOnline() {
-    if (state.connection.state === "unavailable") {
-      reconnect();
-    }
-  }
-  function onEvent(message) {
-    for (const listener of state.listeners.event) {
-      listener({ connectionId: message.actor, event: message.event });
-    }
-  }
-  function onUserJoinedMessage(message) {
-    state.users[message.actor] = {
-      connectionId: message.actor,
-      info: message.info,
-      id: message.id,
-      _hasReceivedInitialPresence: true
-    };
-    if (state.me) {
-      state.buffer.messages.push({
-        type: ClientMessageType.UpdatePresence,
-        data: state.me,
-        targetActor: message.actor
-      });
-      tryFlushing();
-    }
-    return { type: "enter", user: state.users[message.actor] };
-  }
-  function parseServerMessage(data) {
-    if (!isJsonObject(data)) {
-      return null;
-    }
-    return data;
-  }
-  function parseServerMessages(text) {
-    const data = parseJson(text);
-    if (data === void 0) {
-      return null;
-    } else if (isJsonArray(data)) {
-      return compact(data.map((item) => parseServerMessage(item)));
-    } else {
-      return compact([parseServerMessage(data)]);
-    }
-  }
-  function onMessage(event) {
-    if (event.data === "pong") {
-      clearTimeout(state.timeoutHandles.pongTimeout);
-      return;
-    }
-    const messages = parseServerMessages(event.data);
-    if (messages === null || messages.length === 0) {
-      return;
-    }
-    const updates = {
-      storageUpdates: /* @__PURE__ */ new Map(),
-      others: []
-    };
-    for (const message of messages) {
-      switch (message.type) {
-        case ServerMessageType.UserJoined: {
-          updates.others.push(onUserJoinedMessage(message));
-          break;
-        }
-        case ServerMessageType.UpdatePresence: {
-          const othersPresenceUpdate = onUpdatePresenceMessage(message);
-          if (othersPresenceUpdate) {
-            updates.others.push(othersPresenceUpdate);
-          }
-          break;
-        }
-        case ServerMessageType.Event: {
-          onEvent(message);
-          break;
-        }
-        case ServerMessageType.UserLeft: {
-          const event2 = onUserLeftMessage(message);
-          if (event2) {
-            updates.others.push(event2);
-          }
-          break;
-        }
-        case ServerMessageType.RoomState: {
-          updates.others.push(onRoomStateMessage(message));
-          break;
-        }
-        case ServerMessageType.InitialStorageState: {
-          const offlineOps = new Map(state.offlineOperations);
-          createOrUpdateRootFromMessage(message);
-          applyAndSendOfflineOps(offlineOps);
-          _getInitialStateResolver == null ? void 0 : _getInitialStateResolver();
-          break;
-        }
-        case ServerMessageType.UpdateStorage: {
-          const applyResult = apply(message.ops, false);
-          applyResult.updates.storageUpdates.forEach((value, key) => {
-            updates.storageUpdates.set(key, mergeStorageUpdates(updates.storageUpdates.get(key), value));
-          });
-          break;
-        }
-      }
-    }
-    notify(updates);
-  }
-  function onClose(event) {
-    state.socket = null;
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    clearInterval(state.intervalHandles.heartbeat);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    state.users = {};
-    notify({ others: [{ type: "reset" }] });
-    if (event.code >= 4e3 && event.code <= 4100) {
-      updateConnection({ state: "failed" });
-      const error = new LiveblocksError(event.reason, event.code);
-      for (const listener of state.listeners.error) {
-        listener(error);
-      }
-      const delay = getRetryDelay(true);
-      state.numberOfRetry++;
-      if (process.env.NODE_ENV !== "production") {
-        console.error(`Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code}). Retrying in ${delay}ms.`);
-      }
-      updateConnection({ state: "unavailable" });
-      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-    } else if (event.code === WebsocketCloseCodes.CLOSE_WITHOUT_RETRY) {
-      updateConnection({ state: "closed" });
-    } else {
-      const delay = getRetryDelay();
-      state.numberOfRetry++;
-      if (process.env.NODE_ENV !== "production") {
-        console.warn(`Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`);
-      }
-      updateConnection({ state: "unavailable" });
-      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-    }
-  }
-  function updateConnection(connection) {
-    state.connection = connection;
-    for (const listener of state.listeners.connection) {
-      listener(connection.state);
-    }
-  }
-  function getRetryDelay(slow = false) {
-    if (slow) {
-      return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
-    }
-    return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
-  }
-  function onError() {
-  }
-  function onOpen() {
-    clearInterval(state.intervalHandles.heartbeat);
-    state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
-    if (state.connection.state === "connecting") {
-      updateConnection(__spreadProps$1(__spreadValues$1({}, state.connection), { state: "open" }));
-      state.numberOfRetry = 0;
-      if (state.lastConnectionId !== void 0) {
-        state.buffer.presence = state.me;
-        tryFlushing();
-      }
-      state.lastConnectionId = state.connection.id;
-      if (state.root) {
-        state.buffer.messages.push({ type: ClientMessageType.FetchStorage });
-      }
-      tryFlushing();
-    }
-  }
-  function heartbeat() {
-    if (state.socket == null) {
-      return;
-    }
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-    if (state.socket.readyState === state.socket.OPEN) {
-      state.socket.send("ping");
-    }
-  }
-  function pongTimeout() {
-    reconnect();
-  }
-  function reconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
-    }
-    updateConnection({ state: "unavailable" });
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    clearInterval(state.intervalHandles.heartbeat);
-    connect();
-  }
-  function applyAndSendOfflineOps(offlineOps) {
-    if (offlineOps.size === 0) {
-      return;
-    }
-    const messages = [];
-    const ops = Array.from(offlineOps.values());
-    const result = apply(ops, true);
-    messages.push({
-      type: ClientMessageType.UpdateStorage,
-      ops
-    });
-    notify(result.updates);
-    effects.send(messages);
-  }
-  function tryFlushing() {
-    const storageOps = state.buffer.storageOperations;
-    if (storageOps.length > 0) {
-      storageOps.forEach((op) => {
-        state.offlineOperations.set(op.opId, op);
-      });
-    }
-    if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
-      state.buffer.storageOperations = [];
-      return;
-    }
-    const now = Date.now();
-    const elapsedTime = now - state.lastFlushTime;
-    if (elapsedTime > context.throttleDelay) {
-      const messages = flushDataToMessages(state);
-      if (messages.length === 0) {
-        return;
-      }
-      effects.send(messages);
-      state.buffer = {
-        messages: [],
-        storageOperations: [],
-        presence: null
-      };
-      state.lastFlushTime = now;
-    } else {
-      if (state.timeoutHandles.flush != null) {
-        clearTimeout(state.timeoutHandles.flush);
-      }
-      state.timeoutHandles.flush = effects.delayFlush(context.throttleDelay - (now - state.lastFlushTime));
-    }
-  }
-  function flushDataToMessages(state2) {
-    const messages = [];
-    if (state2.buffer.presence) {
-      messages.push({
-        type: ClientMessageType.UpdatePresence,
-        data: state2.buffer.presence
-      });
-    }
-    for (const event of state2.buffer.messages) {
-      messages.push(event);
-    }
-    if (state2.buffer.storageOperations.length > 0) {
-      messages.push({
-        type: ClientMessageType.UpdateStorage,
-        ops: state2.buffer.storageOperations
-      });
-    }
-    return messages;
-  }
-  function disconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
-    }
-    updateConnection({ state: "closed" });
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    clearInterval(state.intervalHandles.heartbeat);
-    state.users = {};
-    notify({ others: [{ type: "reset" }] });
-    clearListeners();
-  }
-  function clearListeners() {
-    for (const key in state.listeners) {
-      state.listeners[key] = [];
-    }
-  }
-  function getPresence() {
-    return state.me;
-  }
-  function getOthers() {
-    return state.others;
-  }
-  function broadcastEvent(event, options = {
-    shouldQueueEventIfNotReady: false
-  }) {
-    if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
-      return;
-    }
-    state.buffer.messages.push({
-      type: ClientMessageType.ClientEvent,
-      event
-    });
-    tryFlushing();
-  }
-  function dispatch(ops) {
-    state.buffer.storageOperations.push(...ops);
-    tryFlushing();
-  }
-  let _getInitialStatePromise = null;
-  let _getInitialStateResolver = null;
-  function getStorage() {
-    if (state.root) {
-      return new Promise((resolve) => resolve({
-        root: state.root
-      }));
-    }
-    if (_getInitialStatePromise == null) {
-      state.buffer.messages.push({ type: ClientMessageType.FetchStorage });
-      tryFlushing();
-      _getInitialStatePromise = new Promise((resolve) => _getInitialStateResolver = resolve);
-    }
-    return _getInitialStatePromise.then(() => {
-      return {
-        root: state.root
-      };
-    });
-  }
-  function undo() {
-    if (state.isBatching) {
-      throw new Error("undo is not allowed during a batch");
-    }
-    const historyItem = state.undoStack.pop();
-    if (historyItem == null) {
-      return;
-    }
-    state.isHistoryPaused = false;
-    const result = apply(historyItem, true);
-    notify(result.updates);
-    state.redoStack.push(result.reverse);
-    for (const op of historyItem) {
-      if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
-      }
-    }
-    tryFlushing();
-  }
-  function redo() {
-    if (state.isBatching) {
-      throw new Error("redo is not allowed during a batch");
-    }
-    const historyItem = state.redoStack.pop();
-    if (historyItem == null) {
-      return;
-    }
-    state.isHistoryPaused = false;
-    const result = apply(historyItem, true);
-    notify(result.updates);
-    state.undoStack.push(result.reverse);
-    for (const op of historyItem) {
-      if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
-      }
-    }
-    tryFlushing();
-  }
-  function batch(callback) {
-    if (state.isBatching) {
-      throw new Error("batch should not be called during a batch");
-    }
-    state.isBatching = true;
-    try {
-      callback();
-    } finally {
-      state.isBatching = false;
-      if (state.batch.reverseOps.length > 0) {
-        addToUndoStack(state.batch.reverseOps);
-      }
-      if (state.batch.ops.length > 0) {
-        state.redoStack = [];
-      }
-      if (state.batch.ops.length > 0) {
-        dispatch(state.batch.ops);
-      }
-      notify(state.batch.updates);
-      state.batch = {
-        ops: [],
-        reverseOps: [],
-        updates: {
-          others: [],
-          storageUpdates: /* @__PURE__ */ new Map(),
-          presence: false
-        }
-      };
-      tryFlushing();
-    }
-  }
-  function pauseHistory() {
-    state.pausedHistory = [];
-    state.isHistoryPaused = true;
-  }
-  function resumeHistory() {
-    state.isHistoryPaused = false;
-    if (state.pausedHistory.length > 0) {
-      addToUndoStack(state.pausedHistory);
-    }
-    state.pausedHistory = [];
-  }
-  function simulateSocketClose() {
-    if (state.socket) {
-      state.socket.close();
-    }
-  }
-  function simulateSendCloseEvent(event) {
-    if (state.socket) {
-      onClose(event);
-    }
-  }
-  return {
-    onClose,
-    onMessage,
-    authenticationSuccess,
-    heartbeat,
-    onNavigatorOnline,
-    simulateSocketClose,
-    simulateSendCloseEvent,
-    onVisibilityChange,
-    getUndoStack: () => state.undoStack,
-    getItemsCount: () => state.items.size,
-    connect,
-    disconnect,
-    subscribe,
-    unsubscribe,
-    updatePresence,
-    broadcastEvent,
-    batch,
-    undo,
-    redo,
-    pauseHistory,
-    resumeHistory,
-    getStorage,
-    selectors: {
-      getConnectionState,
-      getSelf,
-      getPresence,
-      getOthers
-    }
-  };
-}
-function defaultState(me, defaultStorageRoot) {
-  return {
-    connection: { state: "closed" },
-    token: null,
-    lastConnectionId: null,
-    socket: null,
-    listeners: {
-      event: [],
-      others: [],
-      "my-presence": [],
-      error: [],
-      connection: [],
-      storage: []
-    },
-    numberOfRetry: 0,
-    lastFlushTime: 0,
-    timeoutHandles: {
-      flush: null,
-      reconnect: 0,
-      pongTimeout: 0
-    },
-    buffer: {
-      presence: me == null ? {} : me,
-      messages: [],
-      storageOperations: []
-    },
-    intervalHandles: {
-      heartbeat: 0
-    },
-    me: me == null ? {} : me,
-    users: {},
-    others: makeOthers({}),
-    defaultStorageRoot,
-    idFactory: null,
-    clock: 0,
-    opClock: 0,
-    items: /* @__PURE__ */ new Map(),
-    root: void 0,
-    undoStack: [],
-    redoStack: [],
-    isHistoryPaused: false,
-    pausedHistory: [],
-    isBatching: false,
-    batch: {
-      ops: [],
-      updates: {
-        storageUpdates: /* @__PURE__ */ new Map(),
-        presence: false,
-        others: []
-      },
-      reverseOps: []
-    },
-    offlineOperations: /* @__PURE__ */ new Map()
-  };
-}
-function createRoom(options, context) {
-  const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
-  const machine = makeStateMachine(state, context);
-  const room = {
-    id: context.roomId,
-    getConnectionState: machine.selectors.getConnectionState,
-    getSelf: machine.selectors.getSelf,
-    subscribe: machine.subscribe,
-    unsubscribe: machine.unsubscribe,
-    getPresence: machine.selectors.getPresence,
-    updatePresence: machine.updatePresence,
-    getOthers: machine.selectors.getOthers,
-    broadcastEvent: machine.broadcastEvent,
-    getStorage: machine.getStorage,
-    batch: machine.batch,
-    history: {
-      undo: machine.undo,
-      redo: machine.redo,
-      pause: machine.pauseHistory,
-      resume: machine.resumeHistory
-    },
-    internalDevTools: {
-      closeWebsocket: machine.simulateSocketClose,
-      sendCloseEvent: machine.simulateSendCloseEvent
-    }
-  };
-  return {
-    connect: machine.connect,
-    disconnect: machine.disconnect,
-    onNavigatorOnline: machine.onNavigatorOnline,
-    onVisibilityChange: machine.onVisibilityChange,
-    room
-  };
-}
-class LiveblocksError extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-  }
-}
-function parseToken(token) {
-  const tokenParts = token.split(".");
-  if (tokenParts.length !== 3) {
-    throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
-  }
-  const data = parseJson(atob(tokenParts[1]));
-  if (data !== void 0 && isJsonObject(data) && typeof data.actor === "number" && (data.id === void 0 || typeof data.id === "string")) {
-    return {
-      actor: data.actor,
-      id: data.id,
-      info: data.info
-    };
-  }
-  throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
-}
-function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
-  if (typeof window === "undefined" && WebSocketPolyfill == null) {
-    throw new Error("To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill.");
-  }
-  const ws = WebSocketPolyfill || WebSocket;
-  return (token) => {
-    return new ws(`${liveblocksServer}/?token=${token}`);
-  };
-}
-function prepareAuthEndpoint(authentication, fetchPolyfill) {
-  if (authentication.type === "public") {
-    if (typeof window === "undefined" && fetchPolyfill == null) {
-      throw new Error("To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill.");
-    }
-    return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-      room,
-      publicApiKey: authentication.publicApiKey
-    });
-  }
-  if (authentication.type === "private") {
-    if (typeof window === "undefined" && fetchPolyfill == null) {
-      throw new Error("To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill.");
-    }
-    return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-      room
-    });
-  }
-  if (authentication.type === "custom") {
-    return authentication.callback;
-  }
-  throw new Error("Internal error. Unexpected authentication type");
-}
-function fetchAuthEndpoint(fetch2, endpoint, body) {
-  return fetch2(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body)
-  }).then((res) => {
-    if (!res.ok) {
-      throw new AuthenticationError(`Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`);
-    }
-    return res.json().catch((er) => {
-      throw new AuthenticationError(`Expected a json when doing a POST request on "${endpoint}". ${er}`);
-    });
-  }).then((authResponse) => {
-    if (typeof authResponse.token !== "string") {
-      throw new AuthenticationError(`Expected a json with a string token when doing a POST request on "${endpoint}", but got ${JSON.stringify(authResponse)}`);
-    }
-    return authResponse;
-  });
-}
-class AuthenticationError extends Error {
-  constructor(message) {
-    super(message);
-  }
-}
-
-function createClient(options) {
-  const clientOptions = options;
-  const throttleDelay = getThrottleDelayFromOptions(options);
-  const rooms = /* @__PURE__ */ new Map();
-  function getRoom(roomId) {
-    const internalRoom = rooms.get(roomId);
-    return internalRoom ? internalRoom.room : null;
-  }
-  function enter(roomId, options2 = {}) {
-    let internalRoom = rooms.get(roomId);
-    if (internalRoom) {
-      return internalRoom.room;
-    }
-    internalRoom = createRoom({
-      defaultPresence: options2.defaultPresence,
-      defaultStorageRoot: options2.defaultStorageRoot
-    }, {
-      roomId,
-      throttleDelay,
-      WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-      fetchPolyfill: clientOptions.fetchPolyfill,
-      liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
-      authentication: prepareAuthentication(clientOptions)
-    });
-    rooms.set(roomId, internalRoom);
-    if (!options2.DO_NOT_USE_withoutConnecting) {
-      internalRoom.connect();
-    }
-    return internalRoom.room;
-  }
-  function leave(roomId) {
-    const room = rooms.get(roomId);
-    if (room) {
-      room.disconnect();
-      rooms.delete(roomId);
-    }
-  }
-  if (typeof window !== "undefined") {
-    window.addEventListener("online", () => {
-      for (const [, room] of rooms) {
-        room.onNavigatorOnline();
-      }
-    });
-  }
-  if (typeof document !== "undefined") {
-    document.addEventListener("visibilitychange", () => {
-      for (const [, room] of rooms) {
-        room.onVisibilityChange(document.visibilityState);
-      }
-    });
-  }
-  return {
-    getRoom,
-    enter,
-    leave
-  };
-}
-function getThrottleDelayFromOptions(options) {
-  if (options.throttle === void 0) {
-    return 100;
-  }
-  if (typeof options.throttle !== "number" || options.throttle < 80 || options.throttle > 1e3) {
-    throw new Error("throttle should be a number between 80 and 1000.");
-  }
-  return options.throttle;
-}
-function prepareAuthentication(clientOptions) {
-  if (typeof clientOptions.publicApiKey === "string") {
-    return {
-      type: "public",
-      publicApiKey: clientOptions.publicApiKey,
-      url: clientOptions.publicAuthorizeEndpoint || "https://liveblocks.io/api/public/authorize"
-    };
-  } else if (typeof clientOptions.authEndpoint === "string") {
-    return {
-      type: "private",
-      url: clientOptions.authEndpoint
-    };
-  } else if (typeof clientOptions.authEndpoint === "function") {
-    return {
-      type: "custom",
-      callback: clientOptions.authEndpoint
-    };
-  }
-  throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
-}
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-function lsonObjectToJson(obj) {
-  const result = {};
-  for (const key in obj) {
-    const val = obj[key];
-    if (val !== void 0) {
-      result[key] = lsonToJson(val);
-    }
-  }
-  return result;
-}
-function liveObjectToJson(liveObject) {
-  return lsonObjectToJson(liveObject.toObject());
-}
-function liveMapToJson(map) {
-  const result = {};
-  for (const [key, value] of map.entries()) {
-    result[key] = lsonToJson(value);
-  }
-  return result;
-}
-function lsonListToJson(value) {
-  return value.map(lsonToJson);
-}
-function liveListToJson(value) {
-  return lsonListToJson(value.toArray());
-}
-function lsonToJson(value) {
-  if (value instanceof LiveObject) {
-    return liveObjectToJson(value);
-  } else if (value instanceof LiveList) {
-    return liveListToJson(value);
-  } else if (value instanceof LiveMap) {
-    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 obj !== null && Object.prototype.toString.call(obj) === "[object Object]";
-}
-function anyToCrdt(obj) {
-  if (obj == null) {
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return new LiveList(obj.map(anyToCrdt));
-  }
-  if (isPlainObject(obj)) {
-    const init = {};
-    for (const key in obj) {
-      init[key] = anyToCrdt(obj[key]);
-    }
-    return new LiveObject(init);
-  }
-  return obj;
-}
-function patchLiveList(liveList, prev, next) {
-  let i = 0;
-  let prevEnd = prev.length - 1;
-  let nextEnd = next.length - 1;
-  let prevNode = prev[0];
-  let nextNode = next[0];
-  outer: {
-    while (prevNode === nextNode) {
-      ++i;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[i];
-      nextNode = next[i];
-    }
-    prevNode = prev[prevEnd];
-    nextNode = next[nextEnd];
-    while (prevNode === nextNode) {
-      prevEnd--;
-      nextEnd--;
-      if (i > prevEnd || i > nextEnd) {
-        break outer;
-      }
-      prevNode = prev[prevEnd];
-      nextNode = next[nextEnd];
-    }
-  }
-  if (i > prevEnd) {
-    if (i <= nextEnd) {
-      while (i <= nextEnd) {
-        liveList.insert(anyToCrdt(next[i]), i);
-        i++;
-      }
-    }
-  } else if (i > nextEnd) {
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
-  } else {
-    while (i <= prevEnd && i <= nextEnd) {
-      prevNode = prev[i];
-      nextNode = next[i];
-      const liveListNode = liveList.get(i);
-      if (liveListNode instanceof LiveObject && isPlainObject(prevNode) && isPlainObject(nextNode)) {
-        patchLiveObject(liveListNode, prevNode, nextNode);
-      } else {
-        liveList.set(i, anyToCrdt(nextNode));
-      }
-      i++;
-    }
-    while (i <= nextEnd) {
-      liveList.insert(anyToCrdt(next[i]), i);
-      i++;
-    }
-    let localI = i;
-    while (localI <= prevEnd) {
-      liveList.delete(i);
-      localI++;
-    }
-  }
-}
-function patchLiveObjectKey(liveObject, key, prev, next) {
-  if (process.env.NODE_ENV !== "production") {
-    const nonSerializableValue = findNonSerializableValue(next);
-    if (nonSerializableValue) {
-      console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.
-Only serializable value can be synced with Liveblocks.`);
-      return;
-    }
-  }
-  const value = liveObject.get(key);
-  if (next === void 0) {
-    liveObject.delete(key);
-  } else if (value === void 0) {
-    liveObject.set(key, anyToCrdt(next));
-  } else if (prev === next) {
-    return;
-  } else if (value instanceof LiveList && Array.isArray(prev) && Array.isArray(next)) {
-    patchLiveList(value, prev, next);
-  } else if (value instanceof LiveObject && isPlainObject(prev) && isPlainObject(next)) {
-    patchLiveObject(value, prev, next);
-  } else {
-    liveObject.set(key, anyToCrdt(next));
-  }
-}
-function patchLiveObject(root, prev, next) {
-  const updates = {};
-  for (const key in next) {
-    patchLiveObjectKey(root, key, prev[key], next[key]);
-  }
-  for (const key in prev) {
-    if (next[key] === void 0) {
-      root.delete(key);
-    }
-  }
-  if (Object.keys(updates).length > 0) {
-    root.update(updates);
-  }
-}
-function getParentsPath(node) {
-  const path = [];
-  while (node._parentKey != null && node._parent != null) {
-    if (node._parent instanceof LiveList) {
-      path.push(node._parent._indexOfPosition(node._parentKey));
-    } else {
-      path.push(node._parentKey);
-    }
-    node = node._parent;
-  }
-  return path;
-}
-function patchImmutableObject(state, updates) {
-  return updates.reduce((state2, update) => patchImmutableObjectWithUpdate(state2, update), state);
-}
-function patchImmutableObjectWithUpdate(state, update) {
-  const path = getParentsPath(update.node);
-  return patchImmutableNode(state, path, update);
-}
-function patchImmutableNode(state, path, update) {
-  var _a, _b, _c, _d;
-  const pathItem = path.pop();
-  if (pathItem === void 0) {
-    switch (update.type) {
-      case "LiveObject": {
-        if (typeof state !== "object") {
-          throw new Error("Internal: received update on LiveObject but state was not an object");
-        }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (((_a = update.updates[key]) == null ? void 0 : _a.type) === "update") {
-            const val = update.node.get(key);
-            if (val !== void 0) {
-              newState[key] = lsonToJson(val);
-            }
-          } else if (((_b = update.updates[key]) == null ? void 0 : _b.type) === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-      case "LiveList": {
-        if (Array.isArray(state) === false) {
-          throw new Error("Internal: received update on LiveList but state was not an array");
-        }
-        let newState = state.map((x) => x);
-        for (const listUpdate of update.updates) {
-          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(lsonToJson(listUpdate.item));
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index)
-              ];
-            }
-          } else if (listUpdate.type === "delete") {
-            newState.splice(listUpdate.index, 1);
-          } else if (listUpdate.type === "move") {
-            if (listUpdate.previousIndex > listUpdate.index) {
-              newState = [
-                ...newState.slice(0, listUpdate.index),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
-                ...newState.slice(listUpdate.previousIndex + 1)
-              ];
-            } else {
-              newState = [
-                ...newState.slice(0, listUpdate.previousIndex),
-                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
-                lsonToJson(listUpdate.item),
-                ...newState.slice(listUpdate.index + 1)
-              ];
-            }
-          }
-        }
-        return newState;
-      }
-      case "LiveMap": {
-        if (typeof state !== "object") {
-          throw new Error("Internal: received update on LiveMap but state was not an object");
-        }
-        const newState = Object.assign({}, state);
-        for (const key in update.updates) {
-          if (((_c = update.updates[key]) == null ? void 0 : _c.type) === "update") {
-            newState[key] = lsonToJson(update.node.get(key));
-          } else if (((_d = update.updates[key]) == null ? void 0 : _d.type) === "delete") {
-            delete newState[key];
-          }
-        }
-        return newState;
-      }
-    }
-  }
-  if (Array.isArray(state)) {
-    const newArray = [...state];
-    newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
-    return newArray;
-  } else {
-    return __spreadProps(__spreadValues({}, state), {
-      [pathItem]: patchImmutableNode(state[pathItem], path, update)
-    });
-  }
-}
-
-const internals = {
-  liveObjectToJson,
-  lsonToJson,
-  patchLiveList,
-  patchImmutableObject,
-  patchLiveObject,
-  patchLiveObjectKey
-};
-
-export { LiveList, LiveMap, LiveObject, createClient, internals };