@liveblocks/client 0.15.0-alpha.1 → 0.15.0-alpha.4

package/lib/esm/index.js

@@ -1,5 +1,3006 @@
-export { LiveObject } from "./LiveObject";
-export { LiveMap } from "./LiveMap";
-export { LiveList } from "./LiveList";
-export { createClient } from "./client";
-export { liveObjectToJson, liveNodeToJson, patchLiveList, patchImmutableObject, patchLiveObject, patchLiveObjectKey, } from "./immutable";
+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 __accessCheck$4 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$4 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _parent, _doc, _id, _parentKey;
+class AbstractCrdt {
+  constructor() {
+    __privateAdd$4(this, _parent, void 0);
+    __privateAdd$4(this, _doc, void 0);
+    __privateAdd$4(this, _id, void 0);
+    __privateAdd$4(this, _parentKey, void 0);
+  }
+  get _doc() {
+    return __privateGet$4(this, _doc);
+  }
+  get roomId() {
+    return __privateGet$4(this, _doc) ? __privateGet$4(this, _doc).roomId : null;
+  }
+  get _id() {
+    return __privateGet$4(this, _id);
+  }
+  get _parent() {
+    return __privateGet$4(this, _parent);
+  }
+  get _parentKey() {
+    return __privateGet$4(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 (__privateGet$4(this, _parent) != null && __privateGet$4(this, _parent) !== parent) {
+      throw new Error("Cannot attach parent if it already exist");
+    }
+    __privateSet$4(this, _parentKey, key);
+    __privateSet$4(this, _parent, parent);
+  }
+  _attach(id, doc) {
+    if (__privateGet$4(this, _id) || __privateGet$4(this, _doc)) {
+      throw new Error("Cannot attach if CRDT is already attached");
+    }
+    doc.addItem(id, this);
+    __privateSet$4(this, _id, id);
+    __privateSet$4(this, _doc, doc);
+  }
+  _detach() {
+    if (__privateGet$4(this, _doc) && __privateGet$4(this, _id)) {
+      __privateGet$4(this, _doc).deleteItem(__privateGet$4(this, _id));
+    }
+    __privateSet$4(this, _parent, void 0);
+    __privateSet$4(this, _doc, void 0);
+  }
+}
+_parent = new WeakMap();
+_doc = new WeakMap();
+_id = new WeakMap();
+_parentKey = new WeakMap();
+
+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}"`);
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _data;
+const _LiveRegister = class extends AbstractCrdt {
+  constructor(data) {
+    super();
+    __privateAdd$3(this, _data, void 0);
+    __privateSet$3(this, _data, data);
+  }
+  get data() {
+    return __privateGet$3(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) {
+    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,
+        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(id, key, crdt, opId, isLocal) {
+    throw new Error("Method not implemented.");
+  }
+  _detachChild(crdt) {
+    throw new Error("Method not implemented.");
+  }
+  _apply(op, isLocal) {
+    return super._apply(op, isLocal);
+  }
+  _getType() {
+    return "LiveRegister";
+  }
+};
+let LiveRegister = _LiveRegister;
+_data = new WeakMap();
+
+var __accessCheck$2 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$2 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _items, _innerIterator;
+const _LiveList = class extends AbstractCrdt {
+  constructor(items = []) {
+    super();
+    __privateAdd$2(this, _items, []);
+    let position = void 0;
+    for (let i = 0; i < items.length; i++) {
+      const newPosition = makePosition(position);
+      const item = selfOrRegister(items[i]);
+      __privateGet$2(this, _items).push([item, newPosition]);
+      position = newPosition;
+    }
+  }
+  static _deserialize([id, item], 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);
+      __privateGet$2(list, _items).push([child, entry[1].parentKey]);
+      __privateGet$2(list, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    }
+    return list;
+  }
+  _serialize(parentId, parentKey, doc) {
+    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(),
+      type: OpType.CreateList,
+      parentId,
+      parentKey
+    };
+    ops.push(op);
+    for (const [value, key] of __privateGet$2(this, _items)) {
+      ops.push(...value._serialize(this._id, key, doc));
+    }
+    return ops;
+  }
+  _indexOfPosition(position) {
+    return __privateGet$2(this, _items).findIndex((item) => item[1] === position);
+  }
+  _attach(id, doc) {
+    super._attach(id, doc);
+    for (const [item, position] of __privateGet$2(this, _items)) {
+      item._attach(doc.generateId(), doc);
+    }
+  }
+  _detach() {
+    super._detach();
+    for (const [value] of __privateGet$2(this, _items)) {
+      value._detach();
+    }
+  }
+  _attachChild(id, key, child, opId, isLocal) {
+    var _a;
+    if (this._doc == null) {
+      throw new Error("Can't attach child if doc is not present");
+    }
+    if (this._doc.getItem(id) !== void 0) {
+      return { modified: false };
+    }
+    child._attach(id, this._doc);
+    child._setParentLink(this, key);
+    const index = __privateGet$2(this, _items).findIndex((entry) => entry[1] === key);
+    let newKey = key;
+    if (index !== -1) {
+      if (isLocal) {
+        let before = __privateGet$2(this, _items)[index] ? __privateGet$2(this, _items)[index][1] : void 0;
+        let after = __privateGet$2(this, _items)[index + 1] ? __privateGet$2(this, _items)[index + 1][1] : void 0;
+        newKey = makePosition(before, after);
+        child._setParentLink(this, newKey);
+      } else {
+        __privateGet$2(this, _items)[index][1] = makePosition(key, (_a = __privateGet$2(this, _items)[index + 1]) == null ? void 0 : _a[1]);
+      }
+    }
+    __privateGet$2(this, _items).push([child, newKey]);
+    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === newKey);
+    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 = __privateGet$2(this, _items).findIndex((item) => item[0] === child);
+      __privateGet$2(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 = __privateGet$2(this, _items).findIndex((entry) => entry[0]._id === child._id);
+    const index = __privateGet$2(this, _items).findIndex((entry) => entry[1] === key);
+    if (index !== -1) {
+      __privateGet$2(this, _items)[index][1] = makePosition(key, (_a = __privateGet$2(this, _items)[index + 1]) == null ? void 0 : _a[1]);
+    }
+    const item = __privateGet$2(this, _items).find((item2) => item2[0] === child);
+    if (item) {
+      item[1] = key;
+    }
+    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[0]._id === child._id);
+    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);
+  }
+  _getType() {
+    return "LiveList";
+  }
+  _toSerializedCrdt() {
+    var _a;
+    return {
+      type: CrdtType.List,
+      parentId: (_a = this._parent) == null ? void 0 : _a._id,
+      parentKey: this._parentKey
+    };
+  }
+  get length() {
+    return __privateGet$2(this, _items).length;
+  }
+  push(element) {
+    return this.insert(element, this.length);
+  }
+  insert(element, index) {
+    if (index < 0 || index > __privateGet$2(this, _items).length) {
+      throw new Error(`Cannot insert list item at index "${index}". index should be between 0 and ${__privateGet$2(this, _items).length}`);
+    }
+    let before = __privateGet$2(this, _items)[index - 1] ? __privateGet$2(this, _items)[index - 1][1] : void 0;
+    let after = __privateGet$2(this, _items)[index] ? __privateGet$2(this, _items)[index][1] : void 0;
+    const position = makePosition(before, after);
+    const value = selfOrRegister(element);
+    value._setParentLink(this, position);
+    __privateGet$2(this, _items).push([value, position]);
+    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === position);
+    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 >= __privateGet$2(this, _items).length) {
+      throw new Error("targetIndex cannot be greater or equal than the list length");
+    }
+    if (index < 0) {
+      throw new Error("index cannot be less than 0");
+    }
+    if (index >= __privateGet$2(this, _items).length) {
+      throw new Error("index cannot be greater or equal than the list length");
+    }
+    let beforePosition = null;
+    let afterPosition = null;
+    if (index < targetIndex) {
+      afterPosition = targetIndex === __privateGet$2(this, _items).length - 1 ? void 0 : __privateGet$2(this, _items)[targetIndex + 1][1];
+      beforePosition = __privateGet$2(this, _items)[targetIndex][1];
+    } else {
+      afterPosition = __privateGet$2(this, _items)[targetIndex][1];
+      beforePosition = targetIndex === 0 ? void 0 : __privateGet$2(this, _items)[targetIndex - 1][1];
+    }
+    const position = makePosition(beforePosition, afterPosition);
+    const item = __privateGet$2(this, _items)[index];
+    const previousPosition = item[1];
+    item[1] = position;
+    item[0]._setParentLink(this, position);
+    __privateGet$2(this, _items).sort((itemA, itemB) => compare(itemA[1], itemB[1]));
+    const newIndex = __privateGet$2(this, _items).findIndex((entry) => entry[1] === position);
+    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 >= __privateGet$2(this, _items).length) {
+      throw new Error(`Cannot delete list item at index "${index}". index should be between 0 and ${__privateGet$2(this, _items).length - 1}`);
+    }
+    const item = __privateGet$2(this, _items)[index];
+    item[0]._detach();
+    __privateGet$2(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) {
+      let ops = [];
+      let reverseOps = [];
+      let updateDelta = [];
+      let i = 0;
+      for (const item of __privateGet$2(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++;
+      }
+      __privateSet$2(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 __privateGet$2(this, _items)) {
+        item[0]._detach();
+      }
+      __privateSet$2(this, _items, []);
+    }
+  }
+  toArray() {
+    return __privateGet$2(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 >= __privateGet$2(this, _items).length) {
+      return void 0;
+    }
+    return selfOrRegisterValue(__privateGet$2(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 __privateGet$2(this, _items).map((entry, i) => callback(selfOrRegisterValue(entry[0]), i));
+  }
+  some(predicate) {
+    return this.toArray().some(predicate);
+  }
+  [Symbol.iterator]() {
+    return new LiveListIterator(__privateGet$2(this, _items));
+  }
+};
+let LiveList = _LiveList;
+_items = new WeakMap();
+class LiveListIterator {
+  constructor(items) {
+    __privateAdd$2(this, _innerIterator, void 0);
+    __privateSet$2(this, _innerIterator, items[Symbol.iterator]());
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const result = __privateGet$2(this, _innerIterator).next();
+    if (result.done) {
+      return {
+        done: true,
+        value: void 0
+      };
+    }
+    return {
+      value: selfOrRegisterValue(result.value[0])
+    };
+  }
+}
+_innerIterator = new WeakMap();
+
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _map$1;
+const _LiveMap = class extends AbstractCrdt {
+  constructor(entries) {
+    super();
+    __privateAdd$1(this, _map$1, void 0);
+    if (entries) {
+      const mappedEntries = [];
+      for (const entry of entries) {
+        const value = selfOrRegister(entry[1]);
+        value._setParentLink(this, entry[0]);
+        mappedEntries.push([entry[0], value]);
+      }
+      __privateSet$1(this, _map$1, new Map(mappedEntries));
+    } else {
+      __privateSet$1(this, _map$1, /* @__PURE__ */ new Map());
+    }
+  }
+  _serialize(parentId, parentKey, doc) {
+    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,
+      parentId,
+      parentKey
+    };
+    ops.push(op);
+    for (const [key, value] of __privateGet$1(this, _map$1)) {
+      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);
+      __privateGet$1(map, _map$1).set(crdt.parentKey, child);
+    }
+    return map;
+  }
+  _attach(id, doc) {
+    super._attach(id, doc);
+    for (const [key, value] of __privateGet$1(this, _map$1)) {
+      if (isCrdt(value)) {
+        value._attach(doc.generateId(), doc);
+      }
+    }
+  }
+  _attachChild(id, key, child, opId, isLocal) {
+    if (this._doc == null) {
+      throw new Error("Can't attach child if doc is not present");
+    }
+    if (this._doc.getItem(id) !== void 0) {
+      return { modified: false };
+    }
+    const previousValue = __privateGet$1(this, _map$1).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);
+    __privateGet$1(this, _map$1).set(key, child);
+    return {
+      modified: {
+        node: this,
+        type: "LiveMap",
+        updates: { [key]: { type: "update" } }
+      },
+      reverse
+    };
+  }
+  _detach() {
+    super._detach();
+    for (const item of __privateGet$1(this, _map$1).values()) {
+      item._detach();
+    }
+  }
+  _detachChild(child) {
+    const reverse = child._serialize(this._id, child._parentKey, this._doc);
+    for (const [key, value] of __privateGet$1(this, _map$1)) {
+      if (value === child) {
+        __privateGet$1(this, _map$1).delete(key);
+      }
+    }
+    child._detach();
+    const storageUpdate = {
+      node: this,
+      type: "LiveMap",
+      updates: { [child._parentKey]: { type: "delete" } }
+    };
+    return { modified: storageUpdate, reverse };
+  }
+  _getType() {
+    return "LiveMap";
+  }
+  _toSerializedCrdt() {
+    var _a;
+    return {
+      type: CrdtType.Map,
+      parentId: (_a = this._parent) == null ? void 0 : _a._id,
+      parentKey: this._parentKey
+    };
+  }
+  get(key) {
+    const value = __privateGet$1(this, _map$1).get(key);
+    if (value == void 0) {
+      return void 0;
+    }
+    return selfOrRegisterValue(value);
+  }
+  set(key, value) {
+    const oldValue = __privateGet$1(this, _map$1).get(key);
+    if (oldValue) {
+      oldValue._detach();
+    }
+    const item = selfOrRegister(value);
+    item._setParentLink(this, key);
+    __privateGet$1(this, _map$1).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 __privateGet$1(this, _map$1).size;
+  }
+  has(key) {
+    return __privateGet$1(this, _map$1).has(key);
+  }
+  delete(key) {
+    const item = __privateGet$1(this, _map$1).get(key);
+    if (item == null) {
+      return false;
+    }
+    item._detach();
+    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);
+    }
+    __privateGet$1(this, _map$1).delete(key);
+    return true;
+  }
+  entries() {
+    const innerIterator = __privateGet$1(this, _map$1).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 __privateGet$1(this, _map$1).keys();
+  }
+  values() {
+    const innerIterator = __privateGet$1(this, _map$1).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);
+    }
+  }
+};
+let LiveMap = _LiveMap;
+_map$1 = new WeakMap();
+
+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 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 mergeStorageUpdates(first, second) {
+  if (!first) {
+    return second;
+  }
+  if (second.type === "LiveObject") {
+    const updates = first.updates;
+    for (const [key, value] of Object.entries(second.updates)) {
+      updates[key] = value;
+    }
+    return __spreadProps$2(__spreadValues$2({}, second), {
+      updates
+    });
+  } else if (second.type === "LiveMap") {
+    const updates = first.updates;
+    for (const [key, value] of Object.entries(second.updates)) {
+      updates[key] = value;
+    }
+    return __spreadProps$2(__spreadValues$2({}, second), {
+      updates
+    });
+  } else if (second.type === "LiveList") {
+    const updates = first.updates;
+    return __spreadProps$2(__spreadValues$2({}, second), {
+      updates: updates.concat(second.updates)
+    });
+  }
+  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;
+  let 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;
+}
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _map, _propToLastUpdate, _applyUpdate, applyUpdate_fn, _applyDeleteObjectKey, applyDeleteObjectKey_fn;
+const _LiveObject = class extends AbstractCrdt {
+  constructor(object = {}) {
+    super();
+    __privateAdd(this, _applyUpdate);
+    __privateAdd(this, _applyDeleteObjectKey);
+    __privateAdd(this, _map, void 0);
+    __privateAdd(this, _propToLastUpdate, /* @__PURE__ */ new Map());
+    for (const key in object) {
+      const value = object[key];
+      if (value instanceof AbstractCrdt) {
+        value._setParentLink(this, key);
+      }
+    }
+    __privateSet(this, _map, new Map(Object.entries(object)));
+  }
+  _serialize(parentId, parentKey, doc) {
+    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(),
+      type: OpType.CreateObject,
+      parentId,
+      parentKey,
+      data: {}
+    };
+    ops.push(op);
+    for (const [key, value] of __privateGet(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);
+      __privateGet(object, _map).set(crdt.parentKey, child);
+    }
+    return object;
+  }
+  _attach(id, doc) {
+    super._attach(id, doc);
+    for (const [key, value] of __privateGet(this, _map)) {
+      if (value instanceof AbstractCrdt) {
+        value._attach(doc.generateId(), doc);
+      }
+    }
+  }
+  _attachChild(id, key, child, opId, isLocal) {
+    if (this._doc == null) {
+      throw new Error("Can't attach child if doc is not present");
+    }
+    if (this._doc.getItem(id) !== void 0) {
+      if (__privateGet(this, _propToLastUpdate).get(key) === opId) {
+        __privateGet(this, _propToLastUpdate).delete(key);
+      }
+      return { modified: false };
+    }
+    if (isLocal) {
+      __privateGet(this, _propToLastUpdate).set(key, opId);
+    } else if (__privateGet(this, _propToLastUpdate).get(key) === void 0) ; else if (__privateGet(this, _propToLastUpdate).get(key) === opId) {
+      __privateGet(this, _propToLastUpdate).delete(key);
+      return { modified: false };
+    } else {
+      return { modified: false };
+    }
+    const previousValue = __privateGet(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 }
+        }
+      ];
+    }
+    __privateGet(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 __privateGet(this, _map)) {
+        if (value === child) {
+          __privateGet(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 __privateGet(this, _map)) {
+      __privateGet(this, _map).delete(key);
+      value._detach();
+    }
+  }
+  _detach() {
+    super._detach();
+    for (const value of __privateGet(this, _map).values()) {
+      if (isCrdt(value)) {
+        value._detach();
+      }
+    }
+  }
+  _apply(op, isLocal) {
+    if (op.type === OpType.UpdateObject) {
+      return __privateMethod(this, _applyUpdate, applyUpdate_fn).call(this, op, isLocal);
+    } else if (op.type === OpType.DeleteObjectKey) {
+      return __privateMethod(this, _applyDeleteObjectKey, applyDeleteObjectKey_fn).call(this, op);
+    }
+    return super._apply(op, isLocal);
+  }
+  _toSerializedCrdt() {
+    var _a;
+    return {
+      type: CrdtType.Object,
+      parentId: (_a = this._parent) == null ? void 0 : _a._id,
+      parentKey: this._parentKey,
+      data: this.toObject()
+    };
+  }
+  _getType() {
+    return "LiveObject";
+  }
+  toObject() {
+    return Object.fromEntries(__privateGet(this, _map));
+  }
+  set(key, value) {
+    this.update({ [key]: value });
+  }
+  get(key) {
+    return __privateGet(this, _map).get(key);
+  }
+  delete(key) {
+    const keyAsString = key;
+    const oldValue = __privateGet(this, _map).get(keyAsString);
+    if (oldValue === void 0) {
+      return;
+    }
+    if (this._doc == null || this._id == null) {
+      if (oldValue instanceof AbstractCrdt) {
+        oldValue._detach();
+      }
+      __privateGet(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
+        }
+      ];
+    }
+    __privateGet(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 = __privateGet(this, _map).get(key);
+        if (oldValue instanceof AbstractCrdt) {
+          oldValue._detach();
+        }
+        const newValue = overrides[key];
+        if (newValue instanceof AbstractCrdt) {
+          newValue._setParentLink(this, key);
+        }
+        __privateGet(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 = __privateGet(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) {
+          __privateGet(this, _propToLastUpdate).set(key, createCrdtOp.opId);
+        }
+        ops.push(...newAttachChildOps);
+      } else {
+        updatedProps[key] = newValue;
+        __privateGet(this, _propToLastUpdate).set(key, opId);
+      }
+      __privateGet(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);
+  }
+};
+let LiveObject = _LiveObject;
+_map = new WeakMap();
+_propToLastUpdate = new WeakMap();
+_applyUpdate = new WeakSet();
+applyUpdate_fn = function(op, isLocal) {
+  let isModified = false;
+  const reverse = [];
+  const reverseUpdate = {
+    type: OpType.UpdateObject,
+    id: this._id,
+    data: {}
+  };
+  reverse.push(reverseUpdate);
+  for (const key in op.data) {
+    const oldValue = __privateGet(this, _map).get(key);
+    if (oldValue instanceof AbstractCrdt) {
+      reverse.push(...oldValue._serialize(this._id, key));
+      oldValue._detach();
+    } else if (oldValue !== void 0) {
+      reverseUpdate.data[key] = oldValue;
+    } else if (oldValue === void 0) {
+      reverse.push({ type: OpType.DeleteObjectKey, id: this._id, key });
+    }
+  }
+  let updateDelta = {};
+  for (const key in op.data) {
+    if (isLocal) {
+      __privateGet(this, _propToLastUpdate).set(key, op.opId);
+    } else if (__privateGet(this, _propToLastUpdate).get(key) == null) {
+      isModified = true;
+    } else if (__privateGet(this, _propToLastUpdate).get(key) === op.opId) {
+      __privateGet(this, _propToLastUpdate).delete(key);
+      continue;
+    } else {
+      continue;
+    }
+    const oldValue = __privateGet(this, _map).get(key);
+    if (isCrdt(oldValue)) {
+      oldValue._detach();
+    }
+    isModified = true;
+    updateDelta[key] = { type: "update" };
+    __privateGet(this, _map).set(key, op.data[key]);
+  }
+  if (Object.keys(reverseUpdate.data).length !== 0) {
+    reverse.unshift(reverseUpdate);
+  }
+  return isModified ? {
+    modified: {
+      node: this,
+      type: "LiveObject",
+      updates: updateDelta
+    },
+    reverse
+  } : { modified: false };
+};
+_applyDeleteObjectKey = new WeakSet();
+applyDeleteObjectKey_fn = function(op) {
+  const key = op.key;
+  if (__privateGet(this, _map).has(key) === false) {
+    return { modified: false };
+  }
+  if (__privateGet(this, _propToLastUpdate).get(key) !== void 0) {
+    return { modified: false };
+  }
+  const oldValue = __privateGet(this, _map).get(key);
+  let reverse = [];
+  if (isCrdt(oldValue)) {
+    reverse = oldValue._serialize(this._id, op.key);
+    oldValue._detach();
+  } else if (oldValue !== void 0) {
+    reverse = [
+      {
+        type: OpType.UpdateObject,
+        id: this._id,
+        data: { [key]: oldValue }
+      }
+    ];
+  }
+  __privateGet(this, _map).delete(key);
+  return {
+    modified: {
+      node: this,
+      type: "LiveObject",
+      updates: { [op.key]: { type: "delete" } }
+    },
+    reverse
+  };
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+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));
+const BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+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(presenceMap) {
+  const array = Object.values(presenceMap);
+  return {
+    get count() {
+      return array.length;
+    },
+    [Symbol.iterator]() {
+      return array[Symbol.iterator]();
+    },
+    map(callback) {
+      return array.map(callback);
+    },
+    toArray() {
+      return array;
+    }
+  };
+}
+function makeStateMachine(state, context, mockedEffects) {
+  const effects = mockedEffects || {
+    async authenticate(auth, createWebSocket) {
+      try {
+        const { token } = await auth(context.room);
+        const parsedToken = parseToken(token);
+        const socket = createWebSocket(token);
+        authenticationSuccess(parsedToken, socket);
+      } 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.room
+    });
+  }
+  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 = []
+  }) {
+    if (others.length > 0) {
+      state.others = makeOthers(state.users);
+      for (const event of others) {
+        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) {
+    const result = {
+      reverse: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false
+      }
+    };
+    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;
+          }
+        }
+        result.reverse.unshift(reverse);
+        result.updates.presence = true;
+      } else {
+        if (isLocal && !op.opId) {
+          op.opId = generateOpId();
+        }
+        const applyOpResult = applyOp(op, isLocal);
+        if (applyOpResult.modified) {
+          result.updates.storageUpdates.set(applyOpResult.modified.node._id, mergeStorageUpdates(result.updates.storageUpdates.get(applyOpResult.modified.node._id), applyOpResult.modified));
+          result.reverse.unshift(...applyOpResult.reverse);
+        }
+      }
+    }
+    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: {
+        const parent = state.items.get(op.parentId);
+        if (parent == null) {
+          return { modified: false };
+        }
+        return parent._attachChild(op.id, op.parentKey, new LiveObject(op.data), op.opId, isLocal);
+      }
+      case OpType.CreateList: {
+        const parent = state.items.get(op.parentId);
+        if (parent == null) {
+          return { modified: false };
+        }
+        return parent._attachChild(op.id, op.parentKey, new LiveList(), op.opId, isLocal);
+      }
+      case OpType.CreateRegister: {
+        const parent = state.items.get(op.parentId);
+        if (parent == null) {
+          return { modified: false };
+        }
+        return parent._attachChild(op.id, op.parentKey, new LiveRegister(op.data), op.opId, isLocal);
+      }
+      case OpType.CreateMap: {
+        const parent = state.items.get(op.parentId);
+        if (parent == null) {
+          return { modified: false };
+        }
+        return parent._attachChild(op.id, op.parentKey, new LiveMap(), op.opId, isLocal);
+      }
+    }
+    return { 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);
+    }
+    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 (user == null) {
+      state.users[message.actor] = {
+        connectionId: message.actor,
+        presence: message.data
+      };
+    } else {
+      state.users[message.actor] = {
+        id: user.id,
+        info: user.info,
+        connectionId: message.actor,
+        presence: __spreadValues$1(__spreadValues$1({}, user.presence), message.data)
+      };
+    }
+    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
+    };
+    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 onMessage(event) {
+    if (event.data === "pong") {
+      clearTimeout(state.timeoutHandles.pongTimeout);
+      return;
+    }
+    const message = JSON.parse(event.data);
+    let subMessages = [];
+    if (Array.isArray(message)) {
+      subMessages = message;
+    } else {
+      subMessages.push(message);
+    }
+    const updates = {
+      storageUpdates: /* @__PURE__ */ new Map(),
+      others: []
+    };
+    for (const subMessage of subMessages) {
+      switch (subMessage.type) {
+        case ServerMessageType.UserJoined: {
+          updates.others.push(onUserJoinedMessage(message));
+          break;
+        }
+        case ServerMessageType.UpdatePresence: {
+          updates.others.push(onUpdatePresenceMessage(subMessage));
+          break;
+        }
+        case ServerMessageType.Event: {
+          onEvent(subMessage);
+          break;
+        }
+        case ServerMessageType.UserLeft: {
+          const event2 = onUserLeftMessage(subMessage);
+          if (event2) {
+            updates.others.push(event2);
+          }
+          break;
+        }
+        case ServerMessageType.RoomState: {
+          updates.others.push(onRoomStateMessage(subMessage));
+          break;
+        }
+        case ServerMessageType.InitialStorageState: {
+          createOrUpdateRootFromMessage(subMessage);
+          applyAndSendOfflineOps();
+          _getInitialStateResolver == null ? void 0 : _getInitialStateResolver();
+          break;
+        }
+        case ServerMessageType.UpdateStorage: {
+          const applyResult = apply(subMessage.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) {
+        if (process.env.NODE_ENV !== "production") {
+          console.error(`Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code})`);
+        }
+        listener(error);
+      }
+    } else if (event.wasClean === false) {
+      state.numberOfRetry++;
+      const delay = getRetryDelay();
+      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);
+    } else {
+      updateConnection({ state: "closed" });
+    }
+  }
+  function updateConnection(connection) {
+    state.connection = connection;
+    for (const listener of state.listeners.connection) {
+      listener(connection.state);
+    }
+  }
+  function getRetryDelay() {
+    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() {
+    if (state.offlineOperations.size === 0) {
+      return;
+    }
+    const messages = [];
+    const ops = Array.from(state.offlineOperations.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;
+  async function getStorage() {
+    if (state.root) {
+      return {
+        root: state.root
+      };
+    }
+    if (_getInitialStatePromise == null) {
+      state.buffer.messages.push({ type: ClientMessageType.FetchStorage });
+      tryFlushing();
+      _getInitialStatePromise = new Promise((resolve) => _getInitialStateResolver = resolve);
+    }
+    await _getInitialStatePromise;
+    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" },
+    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.room,
+    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 = JSON.parse(atob(tokenParts[1]));
+  if (typeof data.actor !== "number") {
+    throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
+  }
+  return data;
+}
+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");
+}
+async function fetchAuthEndpoint(fetch2, endpoint, body) {
+  const res = await fetch2(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+  }
+  let authResponse = null;
+  try {
+    authResponse = await res.json();
+  } catch (er) {
+    throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+  }
+  if (typeof authResponse.token !== "string") {
+    throw new AuthenticationError(`Authentication error. Liveblocks could not parse the response of your authentication "${endpoint}"`);
+  }
+  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
+    }, {
+      room: 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) {
+    let 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 liveObjectToJson(liveObject) {
+  const result = {};
+  const obj = liveObject.toObject();
+  for (const key in obj) {
+    result[key] = liveNodeToJson(obj[key]);
+  }
+  return result;
+}
+function liveMapToJson(map) {
+  const result = {};
+  const obj = Object.fromEntries(map);
+  for (const key in obj) {
+    result[key] = liveNodeToJson(obj[key]);
+  }
+  return result;
+}
+function liveListToJson(value) {
+  return value.toArray().map(liveNodeToJson);
+}
+function liveNodeToJson(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;
+  }
+  return value;
+}
+function isPlainObject(obj) {
+  return 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.delete(i);
+        liveList.insert(anyToCrdt(nextNode), i);
+      }
+      i++;
+    }
+    while (i <= nextEnd) {
+      liveList.insert(anyToCrdt(next[i]), i);
+      i++;
+    }
+    while (i <= prevEnd) {
+      liveList.delete(i);
+      i++;
+    }
+  }
+}
+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");
+        }
+        let newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (((_a = update.updates[key]) == null ? void 0 : _a.type) === "update") {
+            newState[key] = liveNodeToJson(update.node.get(key));
+          } 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 === "insert") {
+            if (listUpdate.index === newState.length) {
+              newState.push(liveNodeToJson(listUpdate.item));
+            } else {
+              newState = [
+                ...newState.slice(0, listUpdate.index),
+                liveNodeToJson(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),
+                liveNodeToJson(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),
+                liveNodeToJson(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");
+        }
+        let newState = Object.assign({}, state);
+        for (const key in update.updates) {
+          if (((_c = update.updates[key]) == null ? void 0 : _c.type) === "update") {
+            newState[key] = liveNodeToJson(update.node.get(key));
+          } 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,
+  liveNodeToJson,
+  patchLiveList,
+  patchImmutableObject,
+  patchLiveObject,
+  patchLiveObjectKey
+};
+
+export { LiveList, LiveMap, LiveObject, createClient, internals };