@liveblocks/client 0.17.11 → 0.18.0-beta2

package/index.js

@@ -1,2057 +1,1584 @@
-"use strict";
-function _arrayLikeToArray(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _arrayWithHoles(arr) {
-    if (Array.isArray(arr)) return arr;
-}
-function _arrayWithoutHoles(arr) {
-    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
-}
-function _assertThisInitialized(self) {
-    if (self === void 0) {
-        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkRS4TQ2LTjs = require('./chunk-RS4TQ2LT.js');
+
+// src/EventSource.ts
+function makeEventSource() {
+  const _onetimeObservers = /* @__PURE__ */ new Set();
+  const _observers = /* @__PURE__ */ new Set();
+  function subscribe(callback) {
+    _observers.add(callback);
+    return () => _observers.delete(callback);
+  }
+  function subscribeOnce(callback) {
+    _onetimeObservers.add(callback);
+    return () => _onetimeObservers.delete(callback);
+  }
+  function notify(event) {
+    _onetimeObservers.forEach((callback) => callback(event));
+    _onetimeObservers.clear();
+    _observers.forEach((callback) => callback(event));
+  }
+  function clear() {
+    _onetimeObservers.clear();
+    _observers.clear();
+  }
+  return {
+    notify,
+    subscribe,
+    subscribeOnce,
+    clear,
+    observable: {
+      subscribe,
+      subscribeOnce
     }
-    return self;
+  };
 }
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
+
+// src/ImmutableRef.ts
+function merge(target, patch) {
+  let updated = false;
+  const newValue = _chunkRS4TQ2LTjs.__spreadValues.call(void 0, {}, target);
+  Object.keys(patch).forEach((k) => {
+    const key = k;
+    const val = patch[key];
+    if (newValue[key] !== val) {
+      if (val === void 0) {
+        delete newValue[key];
+      } else {
+        newValue[key] = val;
+      }
+      updated = true;
     }
+  });
+  return updated ? newValue : target;
 }
-function isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
+var ImmutableRef = class {
+  constructor() {
+    this._ev = makeEventSource();
+  }
+  get didInvalidate() {
+    return this._ev.observable;
+  }
+  invalidate() {
+    if (this._cache !== void 0) {
+      this._cache = void 0;
+      this._ev.notify();
     }
-}
-function _construct(Parent, args, Class) {
-    if (isNativeReflectConstruct()) {
-        _construct = Reflect.construct;
-    } else {
-        _construct = function _construct(Parent, args, Class) {
-            var a = [
-                null
-            ];
-            a.push.apply(a, args);
-            var Constructor = Function.bind.apply(Parent, a);
-            var instance = new Constructor();
-            if (Class) _setPrototypeOf(instance, Class.prototype);
-            return instance;
-        };
+  }
+  get current() {
+    var _a;
+    return (_a = this._cache) != null ? _a : this._cache = this._toImmutable();
+  }
+};
+
+// src/MeRef.ts
+var MeRef = class extends ImmutableRef {
+  constructor(initialPresence) {
+    super();
+    this._me = _chunkRS4TQ2LTjs.freeze.call(void 0, _chunkRS4TQ2LTjs.compactObject.call(void 0, initialPresence));
+  }
+  _toImmutable() {
+    return this._me;
+  }
+  patch(patch) {
+    const oldMe = this._me;
+    const newMe = merge(oldMe, patch);
+    if (oldMe !== newMe) {
+      this._me = _chunkRS4TQ2LTjs.freeze.call(void 0, newMe);
+      this.invalidate();
     }
-    return _construct.apply(null, arguments);
+  }
+};
+
+// src/OthersRef.ts
+function makeUser(conn, presence) {
+  return _chunkRS4TQ2LTjs.freeze.call(void 0, _chunkRS4TQ2LTjs.compactObject.call(void 0, _chunkRS4TQ2LTjs.__spreadProps.call(void 0, _chunkRS4TQ2LTjs.__spreadValues.call(void 0, {}, conn), { presence })));
 }
-function _defineProperty(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
+var OthersRef = class extends ImmutableRef {
+  constructor() {
+    super();
+    this._connections = {};
+    this._presences = {};
+    this._users = {};
+  }
+  _toImmutable() {
+    const users = _chunkRS4TQ2LTjs.compact.call(void 0, 
+      Object.keys(this._presences).map(
+        (connectionId) => this.getUser(Number(connectionId))
+      )
+    );
+    return _chunkRS4TQ2LTjs.asArrayWithLegacyMethods.call(void 0, users);
+  }
+  clearOthers() {
+    this._connections = {};
+    this._presences = {};
+    this._users = {};
+    this.invalidate();
+  }
+  _getUser(connectionId) {
+    const conn = this._connections[connectionId];
+    const presence = this._presences[connectionId];
+    if (conn !== void 0 && presence !== void 0) {
+      return makeUser(conn, presence);
     }
-    return obj;
-}
-function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
-        return o.__proto__ || Object.getPrototypeOf(o);
-    };
-    return _getPrototypeOf(o);
-}
-function _inherits(subClass, superClass) {
-    if (typeof superClass !== "function" && superClass !== null) {
-        throw new TypeError("Super expression must either be null or a function");
-    }
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            writable: true,
-            configurable: true
-        }
+    return void 0;
+  }
+  getUser(connectionId) {
+    const cachedUser = this._users[connectionId];
+    if (cachedUser) {
+      return cachedUser;
+    }
+    const computedUser = this._getUser(connectionId);
+    if (computedUser) {
+      this._users[connectionId] = computedUser;
+      return computedUser;
+    }
+    return void 0;
+  }
+  _invalidateUser(connectionId) {
+    if (this._users[connectionId] !== void 0) {
+      delete this._users[connectionId];
+    }
+    this.invalidate();
+  }
+  setConnection(connectionId, metaUserId, metaUserInfo) {
+    this._connections[connectionId] = _chunkRS4TQ2LTjs.freeze.call(void 0, {
+      connectionId,
+      id: metaUserId,
+      info: metaUserInfo
     });
-    if (superClass) _setPrototypeOf(subClass, superClass);
-}
-function _instanceof(left, right) {
-    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
-        return !!right[Symbol.hasInstance](left);
-    } else {
-        return left instanceof right;
+    if (this._presences[connectionId] !== void 0) {
+      this._invalidateUser(connectionId);
     }
-}
-function _isNativeFunction(fn) {
-    return Function.toString.call(fn).indexOf("[native code]") !== -1;
-}
-function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _iterableToArrayLimit(arr, i) {
-    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-    if (_i == null) return;
-    var _arr = [];
-    var _n = true;
-    var _d = false;
-    var _s, _e;
-    try {
-        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
-            _arr.push(_s.value);
-            if (i && _arr.length === i) break;
-        }
-    } catch (err) {
-        _d = true;
-        _e = err;
-    } finally{
-        try {
-            if (!_n && _i["return"] != null) _i["return"]();
-        } finally{
-            if (_d) throw _e;
-        }
+  }
+  removeConnection(connectionId) {
+    delete this._connections[connectionId];
+    delete this._presences[connectionId];
+    this._invalidateUser(connectionId);
+  }
+  setOther(connectionId, presence) {
+    this._presences[connectionId] = _chunkRS4TQ2LTjs.freeze.call(void 0, _chunkRS4TQ2LTjs.compactObject.call(void 0, presence));
+    if (this._connections[connectionId] !== void 0) {
+      this._invalidateUser(connectionId);
+    }
+  }
+  patchOther(connectionId, patch) {
+    const oldPresence = this._presences[connectionId];
+    if (oldPresence === void 0) {
+      return;
     }
-    return _arr;
+    const newPresence = merge(oldPresence, patch);
+    if (oldPresence !== newPresence) {
+      this._presences[connectionId] = _chunkRS4TQ2LTjs.freeze.call(void 0, newPresence);
+      this._invalidateUser(connectionId);
+    }
+  }
+};
+
+// src/ValueRef.ts
+var ValueRef = class extends ImmutableRef {
+  constructor(initialValue) {
+    super();
+    this._value = _chunkRS4TQ2LTjs.freeze.call(void 0, _chunkRS4TQ2LTjs.compactObject.call(void 0, initialValue));
+  }
+  _toImmutable() {
+    return this._value;
+  }
+  set(newValue) {
+    this._value = _chunkRS4TQ2LTjs.freeze.call(void 0, newValue);
+    this.invalidate();
+  }
+};
+var DerivedRef = class extends ImmutableRef {
+  constructor(otherRefs, transformFn) {
+    super();
+    this._refs = otherRefs;
+    this._refs.forEach((ref) => {
+      ref.didInvalidate.subscribe(() => this.invalidate());
+    });
+    this._transform = transformFn;
+  }
+  _toImmutable() {
+    return this._transform(this._refs[0].current, this._refs[1].current);
+  }
+};
+
+// src/room.ts
+var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
+var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
+var HEARTBEAT_INTERVAL = 3e4;
+var PONG_TIMEOUT = 2e3;
+function makeIdFactory(connectionId) {
+  let count = 0;
+  return () => `${connectionId}:${count++}`;
 }
-function _nonIterableRest() {
-    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function log(..._params) {
+  return;
 }
-function _nonIterableSpread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+function isConnectionSelfAware(connection) {
+  return connection.state === "open" || connection.state === "connecting";
 }
-function _objectSpread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _defineProperty(target, key, source[key]);
+function makeStateMachine(state, config, mockedEffects) {
+  const pool = {
+    roomId: config.roomId,
+    getNode: (id) => state.nodes.get(id),
+    addNode: (id, node) => void state.nodes.set(id, node),
+    deleteNode: (id) => void state.nodes.delete(id),
+    generateId: () => `${getConnectionId()}:${state.clock++}`,
+    generateOpId: () => `${getConnectionId()}:${state.opClock++}`,
+    dispatch(ops, reverse, storageUpdates) {
+      const activeBatch = state.activeBatch;
+      if (activeBatch) {
+        activeBatch.ops.push(...ops);
+        storageUpdates.forEach((value, key) => {
+          activeBatch.updates.storageUpdates.set(
+            key,
+            _chunkRS4TQ2LTjs.mergeStorageUpdates.call(void 0, 
+              activeBatch.updates.storageUpdates.get(key),
+              value
+            )
+          );
         });
+        activeBatch.reverseOps.push(...reverse);
+      } else {
+        addToUndoStack(reverse);
+        state.redoStack = [];
+        dispatchOps(ops);
+        notify({ storageUpdates });
+      }
     }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        if (enumerableOnly) {
-            symbols = symbols.filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-            });
-        }
-        keys.push.apply(keys, symbols);
+  };
+  const eventHub = {
+    customEvent: makeEventSource(),
+    me: makeEventSource(),
+    others: makeEventSource(),
+    error: makeEventSource(),
+    connection: makeEventSource(),
+    storage: makeEventSource(),
+    history: makeEventSource(),
+    storageDidLoad: makeEventSource()
+  };
+  const effects = mockedEffects || {
+    authenticate(auth, createWebSocket) {
+      const rawToken = state.token;
+      const parsedToken = rawToken !== null && _chunkRS4TQ2LTjs.parseRoomAuthToken.call(void 0, rawToken);
+      if (parsedToken && !_chunkRS4TQ2LTjs.isTokenExpired.call(void 0, parsedToken)) {
+        const socket = createWebSocket(rawToken);
+        authenticationSuccess(parsedToken, socket);
+      } else {
+        return auth(config.roomId).then(({ token }) => {
+          if (state.connection.current.state !== "authenticating") {
+            return;
+          }
+          const parsedToken2 = _chunkRS4TQ2LTjs.parseRoomAuthToken.call(void 0, token);
+          const socket = createWebSocket(token);
+          authenticationSuccess(parsedToken2, socket);
+          state.token = token;
+        }).catch(
+          (er) => authenticationFailure(
+            er instanceof Error ? er : new Error(String(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);
     }
-    return keys;
-}
-function _objectSpreadProps(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  };
+  const self = new DerivedRef(
+    [state.connection, state.me],
+    (conn, me) => isConnectionSelfAware(conn) ? {
+      connectionId: conn.id,
+      id: conn.userId,
+      info: conn.userInfo,
+      presence: me
+    } : null
+  );
+  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 {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
+      state.root = load(message.items);
     }
-    return target;
-}
-function _objectWithoutProperties(source, excluded) {
-    if (source == null) return {};
-    var target = _objectWithoutPropertiesLoose(source, excluded);
-    var key, i;
-    if (Object.getOwnPropertySymbols) {
-        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceSymbolKeys.length; i++){
-            key = sourceSymbolKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
+    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 [id, crdt] of items) {
+      if (_chunkRS4TQ2LTjs.isRootCrdt.call(void 0, crdt)) {
+        root = [id, crdt];
+      } else {
+        const tuple = [id, crdt];
+        const children = parentToChildren.get(crdt.parentId);
+        if (children != null) {
+          children.push(tuple);
+        } else {
+          parentToChildren.set(crdt.parentId, [tuple]);
         }
+      }
     }
-    return target;
-}
-function _objectWithoutPropertiesLoose(source, excluded) {
-    if (source == null) return {};
-    var target = {};
-    var sourceKeys = Object.keys(source);
-    var key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-function _possibleConstructorReturn(self, call) {
-    if (call && (_typeof(call) === "object" || typeof call === "function")) {
-        return call;
+    if (root == null) {
+      throw new Error("Root can't be null");
     }
-    return _assertThisInitialized(self);
-}
-function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
-    };
-    return _setPrototypeOf(o, p);
-}
-function _slicedToArray(arr, i) {
-    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
-}
-function _toConsumableArray(arr) {
-    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
-}
-var _typeof = function(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-};
-function _unsupportedIterableToArray(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
-}
-function _wrapNativeSuper(Class) {
-    var _cache = typeof Map === "function" ? new Map() : undefined;
-    _wrapNativeSuper = function _wrapNativeSuper(Class) {
-        if (Class === null || !_isNativeFunction(Class)) return Class;
-        if (typeof Class !== "function") {
-            throw new TypeError("Super expression must either be null or a function");
-        }
-        if (typeof _cache !== "undefined") {
-            if (_cache.has(Class)) return _cache.get(Class);
-            _cache.set(Class, Wrapper);
-        }
-        function Wrapper() {
-            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
-        }
-        Wrapper.prototype = Object.create(Class.prototype, {
-            constructor: {
-                value: Wrapper,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            }
-        });
-        return _setPrototypeOf(Wrapper, Class);
-    };
-    return _wrapNativeSuper(Class);
-}
-function _isNativeReflectConstruct() {
-    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
-    if (Reflect.construct.sham) return false;
-    if (typeof Proxy === "function") return true;
-    try {
-        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
-        return true;
-    } catch (e) {
-        return false;
+    return [root, parentToChildren];
+  }
+  function updateRoot(items) {
+    if (!state.root) {
+      return;
     }
-}
-function _createSuper(Derived) {
-    var hasNativeReflectConstruct = _isNativeReflectConstruct();
-    return function _createSuperInternal() {
-        var Super = _getPrototypeOf(Derived), result;
-        if (hasNativeReflectConstruct) {
-            var NewTarget = _getPrototypeOf(this).constructor;
-            result = Reflect.construct(Super, arguments, NewTarget);
-        } else {
-            result = Super.apply(this, arguments);
-        }
-        return _possibleConstructorReturn(this, result);
-    };
-}
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _nullishCoalesce(lhs, rhsFn) {
-    if (lhs != null) {
-        return lhs;
+    const currentItems = /* @__PURE__ */ new Map();
+    state.nodes.forEach((node, id) => {
+      currentItems.set(id, node._serialize());
+    });
+    const ops = _chunkRS4TQ2LTjs.getTreesDiffOperations.call(void 0, currentItems, new Map(items));
+    const result = apply(ops, false);
+    notify(result.updates);
+  }
+  function load(items) {
+    const [root, parentToChildren] = buildRootAndParentToChildren(items);
+    return _chunkRS4TQ2LTjs.LiveObject._deserialize(root, parentToChildren, pool);
+  }
+  function addToUndoStack(historyItem) {
+    if (state.undoStack.length >= 50) {
+      state.undoStack.shift();
+    }
+    if (state.isHistoryPaused) {
+      state.pausedHistory.unshift(...historyItem);
     } else {
-        return rhsFn();
+      state.undoStack.push(historyItem);
+      onHistoryChange();
     }
-}
-function _optionalChain(ops) {
-    var lastAccessLHS = undefined;
-    var value = ops[0];
-    var i = 1;
-    while(i < ops.length){
-        var op = ops[i];
-        var fn = ops[i + 1];
-        i += 2;
-        if ((op === "optionalAccess" || op === "optionalCall") && value == null) {
-            return undefined;
-        }
-        if (op === "access" || op === "optionalAccess") {
-            lastAccessLHS = value;
-            value = fn(value);
-        } else if (op === "call" || op === "optionalCall") {
-            var _value;
-            value = fn(function() {
-                for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
-                    args[_key] = arguments[_key];
-                }
-                return (_value = value).call.apply(_value, [
-                    lastAccessLHS
-                ].concat(_toConsumableArray(args)));
-            });
-            lastAccessLHS = undefined;
-        }
+  }
+  function notify({
+    storageUpdates = /* @__PURE__ */ new Map(),
+    presence = false,
+    others: otherEvents = []
+  }) {
+    if (otherEvents.length > 0) {
+      const others = state.others.current;
+      for (const event of otherEvents) {
+        eventHub.others.notify({ others, event });
+      }
     }
-    return value;
-}
-var _chunkQLMVHHAZjs = require("./chunk-QLMVHHAZ.js");
-// src/room.ts
-var BACKOFF_RETRY_DELAYS = [
-    250,
-    500,
-    1e3,
-    2e3,
-    4e3,
-    8e3,
-    1e4
-];
-var BACKOFF_RETRY_DELAYS_SLOW = [
-    2e3,
-    3e4,
-    6e4,
-    3e5
-];
-var HEARTBEAT_INTERVAL = 3e4;
-var PONG_TIMEOUT = 2e3;
-function makeIdFactory(connectionId) {
-    var count = 0;
-    return function() {
-        return "".concat(connectionId, ":").concat(count++);
-    };
-}
-function makeOthers(userMap) {
-    var users = Object.values(userMap).map(function(user) {
-        var _hasReceivedInitialPresence = user._hasReceivedInitialPresence, publicKeys = _objectWithoutProperties(user, [
-            "_hasReceivedInitialPresence"
-        ]);
-        return publicKeys;
-    });
-    var _obj;
-    return _obj = {
-        get count () {
-            return users.length;
-        }
-    }, _defineProperty(_obj, Symbol.iterator, function() {
-        return users[Symbol.iterator]();
-    }), _defineProperty(_obj, "map", function map(callback) {
-        return users.map(callback);
-    }), _defineProperty(_obj, "toArray", function toArray() {
-        return users;
-    }), _obj;
-}
-function log() {
-    for(var _len = arguments.length, _params = new Array(_len), _key = 0; _key < _len; _key++){
-        _params[_key] = arguments[_key];
+    if (presence) {
+      eventHub.me.notify(state.me.current);
     }
-    return;
-}
-function makeStateMachine(state, context, mockedEffects) {
-    var genericSubscribe = function genericSubscribe(callback) {
-        state.listeners.storage.push(callback);
-        return function() {
-            return _chunkQLMVHHAZjs.remove.call(void 0, state.listeners.storage, callback);
+    if (storageUpdates.size > 0) {
+      const updates = Array.from(storageUpdates.values());
+      eventHub.storage.notify(updates);
+    }
+  }
+  function getConnectionId() {
+    const conn = state.connection.current;
+    if (isConnectionSelfAware(conn)) {
+      return conn.id;
+    } else if (state.lastConnectionId !== null) {
+      return state.lastConnectionId;
+    }
+    throw new Error(
+      "Internal. Tried to get connection id but connection was never open"
+    );
+  }
+  function apply(item, isLocal) {
+    const result = {
+      reverse: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false
+      }
+    };
+    const createdNodeIds = /* @__PURE__ */ new Set();
+    for (const op of item) {
+      if (op.type === "presence") {
+        const reverse = {
+          type: "presence",
+          data: {}
         };
-    };
-    var subscribeToLiveStructureDeeply = function subscribeToLiveStructureDeeply(node, callback) {
-        return genericSubscribe(function(updates) {
-            var relatedUpdates = updates.filter(function(update) {
-                return _chunkQLMVHHAZjs.isSameNodeOrChildOf.call(void 0, update.node, node);
-            });
-            if (relatedUpdates.length > 0) {
-                callback(relatedUpdates);
-            }
-        });
-    };
-    var subscribeToLiveStructureShallowly = function subscribeToLiveStructureShallowly(node, callback) {
-        return genericSubscribe(function(updates) {
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = updates[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var update = _step.value;
-                    if (update.node._id === node._id) {
-                        callback(update.node);
-                    }
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-        });
-    };
-    var createOrUpdateRootFromMessage = function createOrUpdateRootFromMessage(message) {
-        if (message.items.length === 0) {
-            throw new Error("Internal error: cannot load storage without items");
+        for (const key in op.data) {
+          reverse.data[key] = state.me.current[key];
         }
-        if (state.root) {
-            updateRoot(message.items);
+        state.me.patch(op.data);
+        if (state.buffer.me == null) {
+          state.buffer.me = { type: "partial", data: op.data };
         } else {
-            state.root = load(message.items);
-        }
-        for(var key in state.defaultStorageRoot){
-            if (state.root.get(key) == null) {
-                state.root.set(key, state.defaultStorageRoot[key]);
-            }
-        }
-    };
-    var buildRootAndParentToChildren = function buildRootAndParentToChildren(items) {
-        var parentToChildren = /* @__PURE__ */ new Map();
-        var root = null;
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var _value = _slicedToArray(_step.value, 2), id = _value[0], crdt = _value[1];
-                if (_chunkQLMVHHAZjs.isRootCrdt.call(void 0, crdt)) {
-                    root = [
-                        id,
-                        crdt
-                    ];
-                } else {
-                    var tuple = [
-                        id,
-                        crdt
-                    ];
-                    var children = parentToChildren.get(crdt.parentId);
-                    if (children != null) {
-                        children.push(tuple);
-                    } else {
-                        parentToChildren.set(crdt.parentId, [
-                            tuple
-                        ]);
-                    }
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        if (root == null) {
-            throw new Error("Root can't be null");
-        }
-        return [
-            root,
-            parentToChildren
-        ];
-    };
-    var updateRoot = function updateRoot(items) {
-        if (!state.root) {
-            return;
-        }
-        var currentItems = /* @__PURE__ */ new Map();
-        state.items.forEach(function(liveCrdt, id) {
-            currentItems.set(id, liveCrdt._toSerializedCrdt());
-        });
-        var ops = _chunkQLMVHHAZjs.getTreesDiffOperations.call(void 0, currentItems, new Map(items));
-        var result = apply(ops, false);
-        notify(result.updates);
-    };
-    var load = function load(items) {
-        var ref = _slicedToArray(buildRootAndParentToChildren(items), 2), root = ref[0], parentToChildren = ref[1];
-        return _chunkQLMVHHAZjs.LiveObject._deserialize(root, parentToChildren, {
-            getItem: getItem,
-            addItem: addItem,
-            deleteItem: deleteItem,
-            generateId: generateId,
-            generateOpId: generateOpId,
-            dispatch: storageDispatch,
-            roomId: context.roomId
-        });
-    };
-    var addItem = function addItem(id, liveItem) {
-        state.items.set(id, liveItem);
-    };
-    var deleteItem = function deleteItem(id) {
-        state.items.delete(id);
-    };
-    var getItem = function getItem(id) {
-        return state.items.get(id);
-    };
-    var addToUndoStack = function addToUndoStack(historyItem) {
-        if (state.undoStack.length >= 50) {
-            state.undoStack.shift();
-        }
-        if (state.isHistoryPaused) {
-            var _pausedHistory;
-            (_pausedHistory = state.pausedHistory).unshift.apply(_pausedHistory, _toConsumableArray(historyItem));
-        } else {
-            state.undoStack.push(historyItem);
-            onHistoryChange();
-        }
-    };
-    var storageDispatch = function storageDispatch(ops, reverse, storageUpdates) {
-        if (state.isBatching) {
-            var _ops, _reverseOps;
-            (_ops = state.batch.ops).push.apply(_ops, _toConsumableArray(ops));
-            storageUpdates.forEach(function(value, key) {
-                state.batch.updates.storageUpdates.set(key, _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, state.batch.updates.storageUpdates.get(key), value));
-            });
-            (_reverseOps = state.batch.reverseOps).push.apply(_reverseOps, _toConsumableArray(reverse));
-        } else {
-            addToUndoStack(reverse);
-            state.redoStack = [];
-            dispatch(ops);
-            notify({
-                storageUpdates: storageUpdates
-            });
-        }
-    };
-    var notify = function notify(param) {
-        var _storageUpdates = param.storageUpdates, storageUpdates = _storageUpdates === void 0 ? /* @__PURE__ */ new Map() : _storageUpdates, _presence = param.presence, presence = _presence === void 0 ? false : _presence, tmp = param.others, otherEvents = tmp === void 0 ? [] : tmp;
-        if (otherEvents.length > 0) {
-            state.others = makeOthers(state.users);
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = otherEvents[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var event = _step.value;
-                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                    try {
-                        for(var _iterator1 = state.listeners.others[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
-                            var listener = _step1.value;
-                            listener(state.others, event);
-                        }
-                    } catch (err) {
-                        _didIteratorError1 = true;
-                        _iteratorError1 = err;
-                    } finally{
-                        try {
-                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                                _iterator1.return();
-                            }
-                        } finally{
-                            if (_didIteratorError1) {
-                                throw _iteratorError1;
-                            }
-                        }
-                    }
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-        }
-        if (presence) {
-            var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
-            try {
-                for(var _iterator2 = state.listeners["my-presence"][Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
-                    var listener1 = _step2.value;
-                    listener1(state.me);
-                }
-            } catch (err) {
-                _didIteratorError2 = true;
-                _iteratorError2 = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                        _iterator2.return();
-                    }
-                } finally{
-                    if (_didIteratorError2) {
-                        throw _iteratorError2;
-                    }
-                }
-            }
-        }
-        if (storageUpdates.size > 0) {
-            var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
-            try {
-                for(var _iterator3 = state.listeners.storage[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
-                    var subscriber = _step3.value;
-                    subscriber(Array.from(storageUpdates.values()));
-                }
-            } catch (err) {
-                _didIteratorError3 = true;
-                _iteratorError3 = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-                        _iterator3.return();
-                    }
-                } finally{
-                    if (_didIteratorError3) {
-                        throw _iteratorError3;
-                    }
-                }
-            }
-        }
-    };
-    var getConnectionId = 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");
-    };
-    var generateId = function generateId() {
-        return "".concat(getConnectionId(), ":").concat(state.clock++);
-    };
-    var generateOpId = function generateOpId() {
-        return "".concat(getConnectionId(), ":").concat(state.opClock++);
-    };
-    var apply = function apply(item, isLocal) {
-        var result = {
-            reverse: [],
-            updates: {
-                storageUpdates: /* @__PURE__ */ new Map(),
-                presence: false
-            }
-        };
-        var createdNodeIds = /* @__PURE__ */ new Set();
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = item[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var op = _step.value;
-                if (op.type === "presence") {
-                    var reverse = {
-                        type: "presence",
-                        data: {}
-                    };
-                    for(var key in op.data){
-                        reverse.data[key] = state.me[key];
-                    }
-                    state.me = _objectSpread({}, state.me, op.data);
-                    if (state.buffer.presence == null) {
-                        state.buffer.presence = {
-                            type: "partial",
-                            data: op.data
-                        };
-                    } else {
-                        for(var key1 in op.data){
-                            state.buffer.presence.data[key1] = op.data[key1];
-                        }
-                    }
-                    result.reverse.unshift(reverse);
-                    result.updates.presence = true;
-                } else {
-                    var source = void 0;
-                    if (!op.opId) {
-                        op.opId = generateOpId();
-                    }
-                    if (isLocal) {
-                        source = 0 /* UNDOREDO_RECONNECT */ ;
-                    } else {
-                        var deleted = state.offlineOperations.delete(_chunkQLMVHHAZjs.nn.call(void 0, op.opId));
-                        source = deleted ? 2 /* ACK */  : 1 /* REMOTE */ ;
-                    }
-                    var applyOpResult = applyOp(op, source);
-                    if (applyOpResult.modified) {
-                        var parentId = applyOpResult.modified.node.parent.type === "HasParent" ? _chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node.parent.node._id, "Expected parent node to have an ID") : void 0;
-                        if (!parentId || !createdNodeIds.has(parentId)) {
-                            var _reverse;
-                            result.updates.storageUpdates.set(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id), _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, result.updates.storageUpdates.get(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id)), applyOpResult.modified));
-                            (_reverse = result.reverse).unshift.apply(_reverse, _toConsumableArray(applyOpResult.reverse));
-                        }
-                        if (op.type === 2 /* CREATE_LIST */  || op.type === 7 /* CREATE_MAP */  || op.type === 4 /* CREATE_OBJECT */ ) {
-                            createdNodeIds.add(_chunkQLMVHHAZjs.nn.call(void 0, applyOpResult.modified.node._id));
-                        }
-                    }
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        return result;
-    };
-    var applyOp = function applyOp(op, source) {
-        switch(op.type){
-            case 6 /* DELETE_OBJECT_KEY */ :
-            case 3 /* UPDATE_OBJECT */ :
-            case 5 /* DELETE_CRDT */ :
-                {
-                    var item = state.items.get(op.id);
-                    if (item == null) {
-                        return {
-                            modified: false
-                        };
-                    }
-                    return item._apply(op, source === 0 /* UNDOREDO_RECONNECT */ );
-                }
-            case 1 /* SET_PARENT_KEY */ :
-                {
-                    var item1 = state.items.get(op.id);
-                    if (item1 == null) {
-                        return {
-                            modified: false
-                        };
-                    }
-                    if (item1.parent.type === "HasParent" && _chunkQLMVHHAZjs.isLiveList.call(void 0, item1.parent.node)) {
-                        return item1.parent.node._setChildKey(op.parentKey, item1, source);
-                    }
-                    return {
-                        modified: false
-                    };
-                }
-            case 4 /* CREATE_OBJECT */ :
-            case 2 /* CREATE_LIST */ :
-            case 7 /* CREATE_MAP */ :
-            case 8 /* CREATE_REGISTER */ :
-                {
-                    if (op.parentId === void 0) {
-                        return {
-                            modified: false
-                        };
-                    }
-                    var parent = state.items.get(op.parentId);
-                    if (parent == null) {
-                        return {
-                            modified: false
-                        };
-                    }
-                    return parent._attachChild(op, source);
-                }
-        }
-    };
-    var subscribe = function subscribe(first, second, options) {
-        if (second === void 0 || typeof first === "function") {
-            if (typeof first === "function") {
-                var storageCallback = first;
-                return genericSubscribe(storageCallback);
-            } else {
-                throw new Error("Please specify a listener callback");
-            }
-        }
-        if (_chunkQLMVHHAZjs.isLiveNode.call(void 0, first)) {
-            var node = first;
-            if (_optionalChain([
-                options,
-                "optionalAccess",
-                function(_) {
-                    return _.isDeep;
-                }
-            ])) {
-                var storageCallback1 = second;
-                return subscribeToLiveStructureDeeply(node, storageCallback1);
-            } else {
-                var nodeCallback = second;
-                return subscribeToLiveStructureShallowly(node, nodeCallback);
-            }
-        }
-        if (!_chunkQLMVHHAZjs.isRoomEventName.call(void 0, first)) {
-            throw new Error('"'.concat(first, '" is not a valid event name'));
-        }
-        var eventName = first;
-        var eventListener = second;
-        state.listeners[eventName].push(eventListener);
-        return function() {
-            var callbacks = state.listeners[eventName];
-            _chunkQLMVHHAZjs.remove.call(void 0, callbacks, eventListener);
-        };
-    };
-    var getConnectionState = function getConnectionState() {
-        return state.connection.state;
-    };
-    var getSelf = 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;
-    };
-    var connect = function connect() {
-        if (state.connection.state !== "closed" && state.connection.state !== "unavailable") {
-            return null;
-        }
-        var auth = prepareAuthEndpoint(context.authentication, _nullishCoalesce(_optionalChain([
-            context,
-            "access",
-            function(_2) {
-                return _2.polyfills;
-            },
-            "optionalAccess",
-            function(_3) {
-                return _3.fetch;
-            }
-        ]), function() {
-            return context.fetchPolyfill;
-        }));
-        var createWebSocket = prepareCreateWebSocket(context.liveblocksServer, _nullishCoalesce(_optionalChain([
-            context,
-            "access",
-            function(_4) {
-                return _4.polyfills;
-            },
-            "optionalAccess",
-            function(_5) {
-                return _5.WebSocket;
-            }
-        ]), function() {
-            return context.WebSocketPolyfill;
-        }));
-        updateConnection({
-            state: "authenticating"
-        });
-        effects.authenticate(auth, createWebSocket);
-    };
-    var updatePresence = function updatePresence(overrides, options) {
-        var oldValues = {};
-        if (state.buffer.presence == null) {
-            state.buffer.presence = {
-                type: "partial",
-                data: {}
-            };
-        }
-        for(var key in overrides){
-            var overrideValue = overrides[key];
-            if (overrideValue === void 0) {
-                continue;
-            }
-            state.buffer.presence.data[key] = overrideValue;
-            oldValues[key] = state.me[key];
-        }
-        state.me = _objectSpread({}, state.me, overrides);
-        if (state.isBatching) {
-            if (_optionalChain([
-                options,
-                "optionalAccess",
-                function(_6) {
-                    return _6.addToHistory;
-                }
-            ])) {
-                state.batch.reverseOps.push({
-                    type: "presence",
-                    data: oldValues
-                });
-            }
-            state.batch.updates.presence = true;
+          for (const key in op.data) {
+            state.buffer.me.data[key] = op.data[key];
+          }
+        }
+        result.reverse.unshift(reverse);
+        result.updates.presence = true;
+      } else {
+        let source;
+        if (!op.opId) {
+          op.opId = pool.generateOpId();
+        }
+        if (isLocal) {
+          source = 0 /* UNDOREDO_RECONNECT */;
         } else {
-            tryFlushing();
-            if (_optionalChain([
-                options,
-                "optionalAccess",
-                function(_7) {
-                    return _7.addToHistory;
-                }
-            ])) {
-                addToUndoStack([
-                    {
-                        type: "presence",
-                        data: oldValues
-                    }
-                ]);
-            }
-            notify({
-                presence: true
-            });
-        }
-    };
-    var authenticationSuccess = 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;
-    };
-    var authenticationFailure = function authenticationFailure(error) {
-        if (process.env.NODE_ENV !== "production") {
-            console.error("Call to authentication endpoint failed", error);
-        }
-        state.token = null;
-        updateConnection({
-            state: "unavailable"
+          const deleted = state.offlineOperations.delete(_chunkRS4TQ2LTjs.nn.call(void 0, op.opId));
+          source = deleted ? 2 /* ACK */ : 1 /* REMOTE */;
+        }
+        const applyOpResult = applyOp(op, source);
+        if (applyOpResult.modified) {
+          const parentId = applyOpResult.modified.node.parent.type === "HasParent" ? _chunkRS4TQ2LTjs.nn.call(void 0, 
+            applyOpResult.modified.node.parent.node._id,
+            "Expected parent node to have an ID"
+          ) : void 0;
+          if (!parentId || !createdNodeIds.has(parentId)) {
+            result.updates.storageUpdates.set(
+              _chunkRS4TQ2LTjs.nn.call(void 0, applyOpResult.modified.node._id),
+              _chunkRS4TQ2LTjs.mergeStorageUpdates.call(void 0, 
+                result.updates.storageUpdates.get(
+                  _chunkRS4TQ2LTjs.nn.call(void 0, applyOpResult.modified.node._id)
+                ),
+                applyOpResult.modified
+              )
+            );
+            result.reverse.unshift(...applyOpResult.reverse);
+          }
+          if (op.type === 2 /* CREATE_LIST */ || op.type === 7 /* CREATE_MAP */ || op.type === 4 /* CREATE_OBJECT */) {
+            createdNodeIds.add(_chunkRS4TQ2LTjs.nn.call(void 0, applyOpResult.modified.node._id));
+          }
+        }
+      }
+    }
+    return result;
+  }
+  function applyOp(op, source) {
+    switch (op.type) {
+      case 6 /* DELETE_OBJECT_KEY */:
+      case 3 /* UPDATE_OBJECT */:
+      case 5 /* DELETE_CRDT */: {
+        const node = state.nodes.get(op.id);
+        if (node == null) {
+          return { modified: false };
+        }
+        return node._apply(op, source === 0 /* UNDOREDO_RECONNECT */);
+      }
+      case 1 /* SET_PARENT_KEY */: {
+        const node = state.nodes.get(op.id);
+        if (node == null) {
+          return { modified: false };
+        }
+        if (node.parent.type === "HasParent" && _chunkRS4TQ2LTjs.isLiveList.call(void 0, node.parent.node)) {
+          return node.parent.node._setChildKey(op.parentKey, node, source);
+        }
+        return { modified: false };
+      }
+      case 4 /* CREATE_OBJECT */:
+      case 2 /* CREATE_LIST */:
+      case 7 /* CREATE_MAP */:
+      case 8 /* CREATE_REGISTER */: {
+        if (op.parentId === void 0) {
+          return { modified: false };
+        }
+        const parentNode = state.nodes.get(op.parentId);
+        if (parentNode == null) {
+          return { modified: false };
+        }
+        return parentNode._attachChild(op, source);
+      }
+    }
+  }
+  function subscribeToLiveStructureDeeply(node, callback) {
+    return eventHub.storage.subscribe((updates) => {
+      const relatedUpdates = updates.filter(
+        (update) => _chunkRS4TQ2LTjs.isSameNodeOrChildOf.call(void 0, update.node, node)
+      );
+      if (relatedUpdates.length > 0) {
+        callback(relatedUpdates);
+      }
+    });
+  }
+  function subscribeToLiveStructureShallowly(node, callback) {
+    return eventHub.storage.subscribe((updates) => {
+      for (const update of updates) {
+        if (update.node._id === node._id) {
+          callback(update.node);
+        }
+      }
+    });
+  }
+  function subscribe(first, second, options) {
+    if (typeof first === "string" && _chunkRS4TQ2LTjs.isRoomEventName.call(void 0, first)) {
+      if (typeof second !== "function") {
+        throw new Error("Second argument must be a callback function");
+      }
+      const callback = second;
+      switch (first) {
+        case "event":
+          return eventHub.customEvent.subscribe(
+            callback
+          );
+        case "my-presence":
+          return eventHub.me.subscribe(callback);
+        case "others": {
+          const cb = callback;
+          return eventHub.others.subscribe(
+            ({ others, event }) => cb(others, event)
+          );
+        }
+        case "error":
+          return eventHub.error.subscribe(callback);
+        case "connection":
+          return eventHub.connection.subscribe(
+            callback
+          );
+        case "storage":
+          return eventHub.storage.subscribe(
+            callback
+          );
+        case "history":
+          return eventHub.history.subscribe(callback);
+        default:
+          return _chunkRS4TQ2LTjs.assertNever.call(void 0, first, "Unknown event");
+      }
+    }
+    if (second === void 0 || typeof first === "function") {
+      if (typeof first === "function") {
+        const storageCallback = first;
+        return eventHub.storage.subscribe(storageCallback);
+      } else {
+        throw new Error("Please specify a listener callback");
+      }
+    }
+    if (_chunkRS4TQ2LTjs.isLiveNode.call(void 0, first)) {
+      const node = first;
+      if (options == null ? void 0 : options.isDeep) {
+        const storageCallback = second;
+        return subscribeToLiveStructureDeeply(node, storageCallback);
+      } else {
+        const nodeCallback = second;
+        return subscribeToLiveStructureShallowly(node, nodeCallback);
+      }
+    }
+    throw new Error(`"${first}" is not a valid event name`);
+  }
+  function getConnectionState() {
+    return state.connection.current.state;
+  }
+  function connect() {
+    var _a, _b, _c, _d;
+    if (state.connection.current.state !== "closed" && state.connection.current.state !== "unavailable") {
+      return null;
+    }
+    const auth = prepareAuthEndpoint(
+      config.authentication,
+      (_b = (_a = config.polyfills) == null ? void 0 : _a.fetch) != null ? _b : config.fetchPolyfill
+    );
+    const createWebSocket = prepareCreateWebSocket(
+      config.liveblocksServer,
+      (_d = (_c = config.polyfills) == null ? void 0 : _c.WebSocket) != null ? _d : config.WebSocketPolyfill
+    );
+    updateConnection({ state: "authenticating" });
+    effects.authenticate(auth, createWebSocket);
+  }
+  function updatePresence(patch, options) {
+    const oldValues = {};
+    if (state.buffer.me == null) {
+      state.buffer.me = {
+        type: "partial",
+        data: {}
+      };
+    }
+    for (const key in patch) {
+      const overrideValue = patch[key];
+      if (overrideValue === void 0) {
+        continue;
+      }
+      state.buffer.me.data[key] = overrideValue;
+      oldValues[key] = state.me.current[key];
+    }
+    state.me.patch(patch);
+    if (state.activeBatch) {
+      if (options == null ? void 0 : options.addToHistory) {
+        state.activeBatch.reverseOps.push({
+          type: "presence",
+          data: oldValues
         });
-        state.numberOfRetry++;
-        state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
-    };
-    var onVisibilityChange = function onVisibilityChange(visibilityState) {
-        if (visibilityState === "visible" && state.connection.state === "open") {
-            log("Heartbeat after visibility change");
-            heartbeat();
-        }
-    };
-    var onUpdatePresenceMessage = function onUpdatePresenceMessage(message) {
-        var user = state.users[message.actor];
-        if (message.targetActor === void 0 && user != null && !user._hasReceivedInitialPresence) {
-            return void 0;
-        }
-        if (user == null) {
-            state.users[message.actor] = {
-                connectionId: message.actor,
-                presence: message.data,
-                id: void 0,
-                info: void 0,
-                _hasReceivedInitialPresence: true
-            };
-        } else {
-            state.users[message.actor] = {
-                id: user.id,
-                info: user.info,
-                connectionId: message.actor,
-                presence: _objectSpread({}, user.presence, message.data),
-                _hasReceivedInitialPresence: true
-            };
-        }
-        return {
-            type: "update",
-            updates: message.data,
-            user: state.users[message.actor]
-        };
-    };
-    var onUserLeftMessage = function onUserLeftMessage(message) {
-        var userLeftMessage = message;
-        var user = state.users[userLeftMessage.actor];
-        if (user) {
-            delete state.users[userLeftMessage.actor];
-            return {
-                type: "leave",
-                user: user
-            };
-        }
-        return null;
-    };
-    var onRoomStateMessage = function onRoomStateMessage(message) {
-        var newUsers = {};
-        for(var key in message.users){
-            var connectionId = Number.parseInt(key);
-            var user = message.users[key];
-            newUsers[connectionId] = {
-                connectionId: connectionId,
-                info: user.info,
-                id: user.id
-            };
-        }
-        state.users = newUsers;
-        return {
-            type: "reset"
-        };
-    };
-    var onNavigatorOnline = function onNavigatorOnline() {
-        if (state.connection.state === "unavailable") {
-            log("Try to reconnect after connectivity change");
-            reconnect();
-        }
-    };
-    var onEvent = function onEvent(message) {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.event[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener({
-                    connectionId: message.actor,
-                    event: message.event
-                });
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    };
-    var onHistoryChange = function onHistoryChange() {
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.history[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener({
-                    canUndo: canUndo(),
-                    canRedo: canRedo()
-                });
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    };
-    var onUserJoinedMessage = function onUserJoinedMessage(message) {
-        state.users[message.actor] = {
+      }
+      state.activeBatch.updates.presence = true;
+    } else {
+      tryFlushing();
+      if (options == null ? void 0 : options.addToHistory) {
+        addToUndoStack([{ type: "presence", data: oldValues }]);
+      }
+      notify({ presence: true });
+    }
+  }
+  function authenticationSuccess(token, socket) {
+    socket.addEventListener("message", onMessage);
+    socket.addEventListener("open", onOpen);
+    socket.addEventListener("close", onClose);
+    socket.addEventListener("error", onError);
+    updateConnection({
+      state: "connecting",
+      id: token.actor,
+      userInfo: token.info,
+      userId: token.id
+    });
+    state.idFactory = makeIdFactory(token.actor);
+    state.socket = socket;
+  }
+  function authenticationFailure(error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.error("Call to authentication endpoint failed", error);
+    }
+    state.token = null;
+    updateConnection({ state: "unavailable" });
+    state.numberOfRetry++;
+    state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
+  }
+  function onVisibilityChange(visibilityState) {
+    if (visibilityState === "visible" && state.connection.current.state === "open") {
+      log("Heartbeat after visibility change");
+      heartbeat();
+    }
+  }
+  function onUpdatePresenceMessage(message) {
+    if (message.targetActor !== void 0) {
+      const oldUser = state.others.getUser(message.actor);
+      state.others.setOther(message.actor, message.data);
+      const newUser = state.others.getUser(message.actor);
+      if (oldUser === void 0 && newUser !== void 0) {
+        return { type: "enter", user: newUser };
+      }
+    } else {
+      state.others.patchOther(message.actor, message.data), message;
+    }
+    const user = state.others.getUser(message.actor);
+    if (user) {
+      return {
+        type: "update",
+        updates: message.data,
+        user
+      };
+    } else {
+      return void 0;
+    }
+  }
+  function onUserLeftMessage(message) {
+    const user = state.others.getUser(message.actor);
+    if (user) {
+      state.others.removeConnection(message.actor);
+      return { type: "leave", user };
+    }
+    return null;
+  }
+  function onRoomStateMessage(message) {
+    for (const key in message.users) {
+      const user = message.users[key];
+      const connectionId = Number(key);
+      state.others.setConnection(connectionId, user.id, user.info);
+    }
+    return { type: "reset" };
+  }
+  function onNavigatorOnline() {
+    if (state.connection.current.state === "unavailable") {
+      log("Try to reconnect after connectivity change");
+      reconnect();
+    }
+  }
+  function onHistoryChange() {
+    eventHub.history.notify({ canUndo: canUndo(), canRedo: canRedo() });
+  }
+  function onUserJoinedMessage(message) {
+    state.others.setConnection(message.actor, message.id, message.info);
+    state.buffer.messages.push({
+      type: 100 /* UPDATE_PRESENCE */,
+      data: state.me.current,
+      targetActor: message.actor
+    });
+    tryFlushing();
+    const user = state.others.getUser(message.actor);
+    return user ? { type: "enter", user } : void 0;
+  }
+  function parseServerMessage(data) {
+    if (!_chunkRS4TQ2LTjs.isJsonObject.call(void 0, data)) {
+      return null;
+    }
+    return data;
+  }
+  function parseServerMessages(text) {
+    const data = _chunkRS4TQ2LTjs.tryParseJson.call(void 0, text);
+    if (data === void 0) {
+      return null;
+    } else if (_chunkRS4TQ2LTjs.isJsonArray.call(void 0, data)) {
+      return _chunkRS4TQ2LTjs.compact.call(void 0, data.map((item) => parseServerMessage(item)));
+    } else {
+      return _chunkRS4TQ2LTjs.compact.call(void 0, [parseServerMessage(data)]);
+    }
+  }
+  function onMessage(event) {
+    if (event.data === "pong") {
+      clearTimeout(state.timeoutHandles.pongTimeout);
+      return;
+    }
+    const messages = parseServerMessages(event.data);
+    if (messages === null || messages.length === 0) {
+      return;
+    }
+    const updates = {
+      storageUpdates: /* @__PURE__ */ new Map(),
+      others: []
+    };
+    for (const message of messages) {
+      switch (message.type) {
+        case 101 /* USER_JOINED */: {
+          const userJoinedUpdate = onUserJoinedMessage(message);
+          if (userJoinedUpdate) {
+            updates.others.push(userJoinedUpdate);
+          }
+          break;
+        }
+        case 100 /* UPDATE_PRESENCE */: {
+          const othersPresenceUpdate = onUpdatePresenceMessage(message);
+          if (othersPresenceUpdate) {
+            updates.others.push(othersPresenceUpdate);
+          }
+          break;
+        }
+        case 103 /* BROADCASTED_EVENT */: {
+          eventHub.customEvent.notify({
             connectionId: message.actor,
-            info: message.info,
-            id: message.id,
-            _hasReceivedInitialPresence: true
-        };
-        if (state.me) {
-            state.buffer.messages.push({
-                type: 100 /* UPDATE_PRESENCE */ ,
-                data: state.me,
-                targetActor: message.actor
-            });
-            tryFlushing();
-        }
-        return {
-            type: "enter",
-            user: state.users[message.actor]
-        };
-    };
-    var parseServerMessage = function parseServerMessage(data) {
-        if (!_chunkQLMVHHAZjs.isJsonObject.call(void 0, data)) {
-            return null;
-        }
-        return data;
-    };
-    var parseServerMessages = function parseServerMessages(text) {
-        var data = _chunkQLMVHHAZjs.tryParseJson.call(void 0, text);
-        if (data === void 0) {
-            return null;
-        } else if (_chunkQLMVHHAZjs.isJsonArray.call(void 0, data)) {
-            return _chunkQLMVHHAZjs.compact.call(void 0, data.map(function(item) {
-                return parseServerMessage(item);
-            }));
-        } else {
-            return _chunkQLMVHHAZjs.compact.call(void 0, [
-                parseServerMessage(data)
-            ]);
-        }
-    };
-    var onMessage = function onMessage(event) {
-        if (event.data === "pong") {
-            clearTimeout(state.timeoutHandles.pongTimeout);
-            return;
-        }
-        var messages = parseServerMessages(event.data);
-        if (messages === null || messages.length === 0) {
-            return;
-        }
-        var updates = {
-            storageUpdates: /* @__PURE__ */ new Map(),
-            others: []
-        };
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = messages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var message = _step.value;
-                switch(message.type){
-                    case 101 /* USER_JOINED */ :
-                        {
-                            updates.others.push(onUserJoinedMessage(message));
-                            break;
-                        }
-                    case 100 /* UPDATE_PRESENCE */ :
-                        {
-                            var othersPresenceUpdate = onUpdatePresenceMessage(message);
-                            if (othersPresenceUpdate) {
-                                updates.others.push(othersPresenceUpdate);
-                            }
-                            break;
-                        }
-                    case 103 /* BROADCASTED_EVENT */ :
-                        {
-                            onEvent(message);
-                            break;
-                        }
-                    case 102 /* USER_LEFT */ :
-                        {
-                            var event2 = onUserLeftMessage(message);
-                            if (event2) {
-                                updates.others.push(event2);
-                            }
-                            break;
-                        }
-                    case 104 /* ROOM_STATE */ :
-                        {
-                            updates.others.push(onRoomStateMessage(message));
-                            break;
-                        }
-                    case 200 /* INITIAL_STORAGE_STATE */ :
-                        {
-                            var offlineOps = new Map(state.offlineOperations);
-                            createOrUpdateRootFromMessage(message);
-                            applyAndSendOfflineOps(offlineOps);
-                            _optionalChain([
-                                _getInitialStateResolver,
-                                "optionalCall",
-                                function(_8) {
-                                    return _8();
-                                }
-                            ]);
-                            break;
-                        }
-                    case 201 /* UPDATE_STORAGE */ :
-                        {
-                            var applyResult = apply(message.ops, false);
-                            applyResult.updates.storageUpdates.forEach(function(value, key) {
-                                updates.storageUpdates.set(key, _chunkQLMVHHAZjs.mergeStorageUpdates.call(void 0, updates.storageUpdates.get(key), value));
-                            });
-                            break;
-                        }
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        notify(updates);
-    };
-    var onClose = 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"
-            });
-            var error = new LiveblocksError(event.reason, event.code);
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = state.listeners.error[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var listener = _step.value;
-                    listener(error);
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-            var delay = getRetryDelay(true);
-            state.numberOfRetry++;
-            if (process.env.NODE_ENV !== "production") {
-                console.error("Connection to Liveblocks websocket server closed. Reason: ".concat(error.message, " (code: ").concat(error.code, "). Retrying in ").concat(delay, "ms."));
-            }
-            updateConnection({
-                state: "unavailable"
-            });
-            state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-        } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */ ) {
-            updateConnection({
-                state: "closed"
-            });
-        } else {
-            var delay1 = getRetryDelay();
-            state.numberOfRetry++;
-            if (process.env.NODE_ENV !== "production") {
-                console.warn("Connection to Liveblocks websocket server closed (code: ".concat(event.code, "). Retrying in ").concat(delay1, "ms."));
-            }
-            updateConnection({
-                state: "unavailable"
-            });
-            state.timeoutHandles.reconnect = effects.scheduleReconnect(delay1);
-        }
-    };
-    var updateConnection = function updateConnection(connection) {
-        state.connection = connection;
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state.listeners.connection[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var listener = _step.value;
-                listener(connection.state);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    };
-    var getRetryDelay = function getRetryDelay() {
-        var slow = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
-        if (slow) {
-            return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
-        }
-        return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
-    };
-    var onError = function onError() {};
-    var onOpen = function onOpen() {
-        clearInterval(state.intervalHandles.heartbeat);
-        state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
-        if (state.connection.state === "connecting") {
-            updateConnection(_objectSpreadProps(_objectSpread({}, state.connection), {
-                state: "open"
-            }));
-            state.numberOfRetry = 0;
-            if (state.lastConnectionId !== void 0) {
-                state.buffer.presence = {
-                    type: "full",
-                    data: state.me
-                };
-                tryFlushing();
-            }
-            state.lastConnectionId = state.connection.id;
-            if (state.root) {
-                state.buffer.messages.push({
-                    type: 200 /* FETCH_STORAGE */ 
-                });
-            }
-            tryFlushing();
-        } else {}
-    };
-    var heartbeat = 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");
-        }
-    };
-    var pongTimeout = function pongTimeout() {
-        log("Pong timeout. Trying to reconnect.");
-        reconnect();
-    };
-    var 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();
-    };
-    var applyAndSendOfflineOps = function applyAndSendOfflineOps(offlineOps) {
-        if (offlineOps.size === 0) {
-            return;
-        }
-        var messages = [];
-        var ops = Array.from(offlineOps.values());
-        var result = apply(ops, true);
-        messages.push({
-            type: 201 /* UPDATE_STORAGE */ ,
-            ops: ops
-        });
-        notify(result.updates);
-        effects.send(messages);
-    };
-    var tryFlushing = function tryFlushing() {
-        var storageOps = state.buffer.storageOperations;
-        if (storageOps.length > 0) {
-            storageOps.forEach(function(op) {
-                state.offlineOperations.set(_chunkQLMVHHAZjs.nn.call(void 0, op.opId), op);
-            });
-        }
-        if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
-            state.buffer.storageOperations = [];
-            return;
-        }
-        var now = Date.now();
-        var elapsedTime = now - state.lastFlushTime;
-        if (elapsedTime > context.throttleDelay) {
-            var 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));
-        }
-    };
-    var flushDataToMessages = function flushDataToMessages(state2) {
-        var messages = [];
-        if (state2.buffer.presence) {
-            messages.push(state2.buffer.presence.type === "full" ? {
-                type: 100 /* UPDATE_PRESENCE */ ,
-                targetActor: -1,
-                data: state2.buffer.presence.data
-            } : {
-                type: 100 /* UPDATE_PRESENCE */ ,
-                data: state2.buffer.presence.data
-            });
-        }
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = state2.buffer.messages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var event = _step.value;
-                messages.push(event);
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        if (state2.buffer.storageOperations.length > 0) {
-            messages.push({
-                type: 201 /* UPDATE_STORAGE */ ,
-                ops: state2.buffer.storageOperations
-            });
-        }
-        return messages;
-    };
-    var disconnect = 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();
-    };
-    var clearListeners = function clearListeners() {
-        for(var key in state.listeners){
-            state.listeners[key] = [];
-        }
-    };
-    var getPresence = function getPresence() {
-        return state.me;
-    };
-    var getOthers = function getOthers() {
-        return state.others;
-    };
-    var broadcastEvent = function broadcastEvent(event) {
-        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
-            shouldQueueEventIfNotReady: false
+            event: message.event
+          });
+          break;
+        }
+        case 102 /* USER_LEFT */: {
+          const event2 = onUserLeftMessage(message);
+          if (event2) {
+            updates.others.push(event2);
+          }
+          break;
+        }
+        case 104 /* ROOM_STATE */: {
+          updates.others.push(onRoomStateMessage(message));
+          break;
+        }
+        case 200 /* INITIAL_STORAGE_STATE */: {
+          const offlineOps = new Map(state.offlineOperations);
+          createOrUpdateRootFromMessage(message);
+          applyAndSendOfflineOps(offlineOps);
+          _getInitialStateResolver == null ? void 0 : _getInitialStateResolver();
+          eventHub.storageDidLoad.notify();
+          break;
+        }
+        case 201 /* UPDATE_STORAGE */: {
+          const applyResult = apply(message.ops, false);
+          applyResult.updates.storageUpdates.forEach((value, key) => {
+            updates.storageUpdates.set(
+              key,
+              _chunkRS4TQ2LTjs.mergeStorageUpdates.call(void 0, 
+                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.others.clearOthers();
+    notify({ others: [{ type: "reset" }] });
+    if (event.code >= 4e3 && event.code <= 4100) {
+      updateConnection({ state: "failed" });
+      const error = new LiveblocksError(event.reason, event.code);
+      eventHub.error.notify(error);
+      const delay = getRetryDelay(true);
+      state.numberOfRetry++;
+      if (process.env.NODE_ENV !== "production") {
+        console.error(
+          `Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code}). Retrying in ${delay}ms.`
+        );
+      }
+      updateConnection({ state: "unavailable" });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+    } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */) {
+      updateConnection({ state: "closed" });
+    } else {
+      const delay = getRetryDelay();
+      state.numberOfRetry++;
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(
+          `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`
+        );
+      }
+      updateConnection({ state: "unavailable" });
+      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+    }
+  }
+  function updateConnection(connection) {
+    state.connection.set(connection);
+    eventHub.connection.notify(connection.state);
+  }
+  function getRetryDelay(slow = false) {
+    if (slow) {
+      return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
+    }
+    return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length ? state.numberOfRetry : BACKOFF_RETRY_DELAYS.length - 1];
+  }
+  function onError() {
+  }
+  function onOpen() {
+    clearInterval(state.intervalHandles.heartbeat);
+    state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
+    if (state.connection.current.state === "connecting") {
+      updateConnection(_chunkRS4TQ2LTjs.__spreadProps.call(void 0, _chunkRS4TQ2LTjs.__spreadValues.call(void 0, {}, state.connection.current), { state: "open" }));
+      state.numberOfRetry = 0;
+      if (state.lastConnectionId !== void 0) {
+        state.buffer.me = {
+          type: "full",
+          data: state.me.current
         };
-        if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
-            return;
-        }
-        state.buffer.messages.push({
-            type: 103 /* BROADCAST_EVENT */ ,
-            event: event
-        });
-        tryFlushing();
-    };
-    var dispatch = function dispatch(ops) {
-        var _storageOperations;
-        (_storageOperations = state.buffer.storageOperations).push.apply(_storageOperations, _toConsumableArray(ops));
         tryFlushing();
-    };
-    var getStorage = function getStorage() {
-        if (state.root) {
-            return new Promise(function(resolve) {
-                return resolve({
-                    root: state.root
-                });
-            });
-        }
-        if (_getInitialStatePromise == null) {
-            state.buffer.messages.push({
-                type: 200 /* FETCH_STORAGE */ 
-            });
-            tryFlushing();
-            _getInitialStatePromise = new Promise(function(resolve) {
-                return _getInitialStateResolver = resolve;
-            });
-        }
-        return _getInitialStatePromise.then(function() {
-            return {
-                root: _chunkQLMVHHAZjs.nn.call(void 0, state.root)
-            };
+      }
+      state.lastConnectionId = state.connection.current.id;
+      if (state.root) {
+        state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      }
+      tryFlushing();
+    } else {
+    }
+  }
+  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() {
+    log("Pong timeout. Trying to reconnect.");
+    reconnect();
+  }
+  function reconnect() {
+    if (state.socket) {
+      state.socket.removeEventListener("open", onOpen);
+      state.socket.removeEventListener("message", onMessage);
+      state.socket.removeEventListener("close", onClose);
+      state.socket.removeEventListener("error", onError);
+      state.socket.close();
+      state.socket = null;
+    }
+    updateConnection({ state: "unavailable" });
+    clearTimeout(state.timeoutHandles.pongTimeout);
+    if (state.timeoutHandles.flush) {
+      clearTimeout(state.timeoutHandles.flush);
+    }
+    clearTimeout(state.timeoutHandles.reconnect);
+    clearInterval(state.intervalHandles.heartbeat);
+    connect();
+  }
+  function applyAndSendOfflineOps(offlineOps) {
+    if (offlineOps.size === 0) {
+      return;
+    }
+    const messages = [];
+    const ops = Array.from(offlineOps.values());
+    const result = apply(ops, true);
+    messages.push({
+      type: 201 /* UPDATE_STORAGE */,
+      ops
+    });
+    notify(result.updates);
+    effects.send(messages);
+  }
+  function tryFlushing() {
+    const storageOps = state.buffer.storageOperations;
+    if (storageOps.length > 0) {
+      storageOps.forEach((op) => {
+        state.offlineOperations.set(_chunkRS4TQ2LTjs.nn.call(void 0, 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 > config.throttleDelay) {
+      const messages = flushDataToMessages(state);
+      if (messages.length === 0) {
+        return;
+      }
+      effects.send(messages);
+      state.buffer = {
+        messages: [],
+        storageOperations: [],
+        me: null
+      };
+      state.lastFlushTime = now;
+    } else {
+      if (state.timeoutHandles.flush != null) {
+        clearTimeout(state.timeoutHandles.flush);
+      }
+      state.timeoutHandles.flush = effects.delayFlush(
+        config.throttleDelay - (now - state.lastFlushTime)
+      );
+    }
+  }
+  function flushDataToMessages(state2) {
+    const messages = [];
+    if (state2.buffer.me) {
+      messages.push(
+        state2.buffer.me.type === "full" ? {
+          type: 100 /* UPDATE_PRESENCE */,
+          targetActor: -1,
+          data: state2.buffer.me.data
+        } : {
+          type: 100 /* UPDATE_PRESENCE */,
+          data: state2.buffer.me.data
+        }
+      );
+    }
+    for (const event of state2.buffer.messages) {
+      messages.push(event);
+    }
+    if (state2.buffer.storageOperations.length > 0) {
+      messages.push({
+        type: 201 /* UPDATE_STORAGE */,
+        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.others.clearOthers();
+    notify({ others: [{ type: "reset" }] });
+    Object.values(eventHub).forEach((eventSource) => eventSource.clear());
+  }
+  function getPresence() {
+    return state.me.current;
+  }
+  function getOthers() {
+    return state.others.current;
+  }
+  function broadcastEvent(event, options = {
+    shouldQueueEventIfNotReady: false
+  }) {
+    if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
+      return;
+    }
+    state.buffer.messages.push({
+      type: 103 /* BROADCAST_EVENT */,
+      event
+    });
+    tryFlushing();
+  }
+  function dispatchOps(ops) {
+    state.buffer.storageOperations.push(...ops);
+    tryFlushing();
+  }
+  let _getInitialStatePromise = null;
+  let _getInitialStateResolver = null;
+  function startLoadingStorage() {
+    if (_getInitialStatePromise == null) {
+      state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
+      tryFlushing();
+      _getInitialStatePromise = new Promise(
+        (resolve) => _getInitialStateResolver = resolve
+      );
+    }
+    return _getInitialStatePromise;
+  }
+  function getStorageSnapshot() {
+    const root = state.root;
+    if (root !== void 0) {
+      return root;
+    } else {
+      startLoadingStorage();
+      return null;
+    }
+  }
+  function getStorage() {
+    return _chunkRS4TQ2LTjs.__async.call(void 0, this, null, function* () {
+      if (state.root) {
+        return Promise.resolve({
+          root: state.root
         });
+      }
+      yield startLoadingStorage();
+      return {
+        root: _chunkRS4TQ2LTjs.nn.call(void 0, state.root)
+      };
+    });
+  }
+  function undo() {
+    if (state.activeBatch) {
+      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);
+    onHistoryChange();
+    for (const op of historyItem) {
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+    tryFlushing();
+  }
+  function canUndo() {
+    return state.undoStack.length > 0;
+  }
+  function redo() {
+    if (state.activeBatch) {
+      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);
+    onHistoryChange();
+    for (const op of historyItem) {
+      if (op.type !== "presence") {
+        state.buffer.storageOperations.push(op);
+      }
+    }
+    tryFlushing();
+  }
+  function canRedo() {
+    return state.redoStack.length > 0;
+  }
+  function batch(callback) {
+    if (state.activeBatch) {
+      return callback();
+    }
+    state.activeBatch = {
+      ops: [],
+      updates: {
+        storageUpdates: /* @__PURE__ */ new Map(),
+        presence: false,
+        others: []
+      },
+      reverseOps: []
     };
-    var undo = function undo() {
-        if (state.isBatching) {
-            throw new Error("undo is not allowed during a batch");
-        }
-        var historyItem = state.undoStack.pop();
-        if (historyItem == null) {
-            return;
-        }
-        state.isHistoryPaused = false;
-        var result = apply(historyItem, true);
-        notify(result.updates);
-        state.redoStack.push(result.reverse);
-        onHistoryChange();
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = historyItem[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var op = _step.value;
-                if (op.type !== "presence") {
-                    state.buffer.storageOperations.push(op);
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        tryFlushing();
-    };
-    var canUndo = function canUndo() {
-        return state.undoStack.length > 0;
-    };
-    var redo = function redo() {
-        if (state.isBatching) {
-            throw new Error("redo is not allowed during a batch");
-        }
-        var historyItem = state.redoStack.pop();
-        if (historyItem == null) {
-            return;
-        }
-        state.isHistoryPaused = false;
-        var result = apply(historyItem, true);
-        notify(result.updates);
-        state.undoStack.push(result.reverse);
-        onHistoryChange();
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for(var _iterator = historyItem[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                var op = _step.value;
-                if (op.type !== "presence") {
-                    state.buffer.storageOperations.push(op);
-                }
-            }
-        } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        } finally{
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            } finally{
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-        tryFlushing();
-    };
-    var canRedo = function canRedo() {
-        return state.redoStack.length > 0;
-    };
-    var batch = 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();
-        }
-    };
-    var pauseHistory = function pauseHistory() {
-        state.pausedHistory = [];
-        state.isHistoryPaused = true;
-    };
-    var resumeHistory = function resumeHistory() {
-        state.isHistoryPaused = false;
-        if (state.pausedHistory.length > 0) {
-            addToUndoStack(state.pausedHistory);
-        }
-        state.pausedHistory = [];
-    };
-    var simulateSocketClose = function simulateSocketClose() {
-        if (state.socket) {
-            state.socket = null;
-        }
-    };
-    var simulateSendCloseEvent = function simulateSendCloseEvent(event) {
-        onClose(event);
-    };
-    var effects = mockedEffects || {
-        authenticate: function authenticate(auth, createWebSocket) {
-            var rawToken = state.token;
-            var parsedToken = rawToken !== null && _chunkQLMVHHAZjs.parseRoomAuthToken.call(void 0, rawToken);
-            if (parsedToken && !_chunkQLMVHHAZjs.isTokenExpired.call(void 0, parsedToken)) {
-                var socket = createWebSocket(rawToken);
-                authenticationSuccess(parsedToken, socket);
-            } else {
-                return auth(context.roomId).then(function(param) {
-                    var token = param.token;
-                    if (state.connection.state !== "authenticating") {
-                        return;
-                    }
-                    var parsedToken2 = _chunkQLMVHHAZjs.parseRoomAuthToken.call(void 0, token);
-                    var socket = createWebSocket(token);
-                    authenticationSuccess(parsedToken2, socket);
-                    state.token = token;
-                }).catch(function(er) {
-                    return authenticationFailure(_instanceof(er, Error) ? er : new Error(String(er)));
-                });
-            }
-        },
-        send: function send(messageOrMessages) {
-            if (state.socket == null) {
-                throw new Error("Can't send message if socket is null");
-            }
-            state.socket.send(JSON.stringify(messageOrMessages));
-        },
-        delayFlush: function delayFlush(delay) {
-            return setTimeout(tryFlushing, delay);
-        },
-        startHeartbeatInterval: function startHeartbeatInterval() {
-            return setInterval(heartbeat, HEARTBEAT_INTERVAL);
-        },
-        schedulePongTimeout: function schedulePongTimeout() {
-            return setTimeout(pongTimeout, PONG_TIMEOUT);
-        },
-        scheduleReconnect: function scheduleReconnect(delay) {
-            return setTimeout(connect, delay);
-        }
-    };
-    var _getInitialStatePromise = null;
-    var _getInitialStateResolver = null;
-    return {
-        onClose: onClose,
-        onMessage: onMessage,
-        authenticationSuccess: authenticationSuccess,
-        heartbeat: heartbeat,
-        onNavigatorOnline: onNavigatorOnline,
-        simulateSocketClose: simulateSocketClose,
-        simulateSendCloseEvent: simulateSendCloseEvent,
-        onVisibilityChange: onVisibilityChange,
-        getUndoStack: function() {
-            return state.undoStack;
-        },
-        getItemsCount: function() {
-            return state.items.size;
-        },
-        connect: connect,
-        disconnect: disconnect,
-        subscribe: subscribe,
-        updatePresence: updatePresence,
-        broadcastEvent: broadcastEvent,
-        batch: batch,
-        undo: undo,
-        redo: redo,
-        canUndo: canUndo,
-        canRedo: canRedo,
-        pauseHistory: pauseHistory,
-        resumeHistory: resumeHistory,
-        getStorage: getStorage,
-        selectors: {
-            getConnectionState: getConnectionState,
-            getSelf: getSelf,
-            getPresence: getPresence,
-            getOthers: getOthers
-        }
-    };
+    try {
+      return callback();
+    } finally {
+      const currentBatch = state.activeBatch;
+      state.activeBatch = null;
+      if (currentBatch.reverseOps.length > 0) {
+        addToUndoStack(currentBatch.reverseOps);
+      }
+      if (currentBatch.ops.length > 0) {
+        state.redoStack = [];
+      }
+      if (currentBatch.ops.length > 0) {
+        dispatchOps(currentBatch.ops);
+      }
+      notify(currentBatch.updates);
+      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 = null;
+    }
+  }
+  function simulateSendCloseEvent(event) {
+    onClose(event);
+  }
+  return {
+    onClose,
+    onMessage,
+    authenticationSuccess,
+    heartbeat,
+    onNavigatorOnline,
+    simulateSocketClose,
+    simulateSendCloseEvent,
+    onVisibilityChange,
+    getUndoStack: () => state.undoStack,
+    getItemsCount: () => state.nodes.size,
+    connect,
+    disconnect,
+    subscribe,
+    updatePresence,
+    broadcastEvent,
+    batch,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    pauseHistory,
+    resumeHistory,
+    getStorage,
+    getStorageSnapshot,
+    events: {
+      customEvent: eventHub.customEvent.observable,
+      others: eventHub.others.observable,
+      me: eventHub.me.observable,
+      error: eventHub.error.observable,
+      connection: eventHub.connection.observable,
+      storage: eventHub.storage.observable,
+      history: eventHub.history.observable,
+      storageDidLoad: eventHub.storageDidLoad.observable
+    },
+    getConnectionState,
+    isSelfAware: () => isConnectionSelfAware(state.connection.current),
+    getSelf: () => self.current,
+    getPresence,
+    getOthers
+  };
 }
 function defaultState(initialPresence, initialStorage) {
-    return {
-        connection: {
-            state: "closed"
-        },
-        token: null,
-        lastConnectionId: null,
-        socket: null,
-        listeners: {
-            event: [],
-            others: [],
-            "my-presence": [],
-            error: [],
-            connection: [],
-            storage: [],
-            history: []
-        },
-        numberOfRetry: 0,
-        lastFlushTime: 0,
-        timeoutHandles: {
-            flush: null,
-            reconnect: 0,
-            pongTimeout: 0
-        },
-        buffer: {
-            presence: {
-                type: "full",
-                data: initialPresence == null ? {} : initialPresence
-            },
-            messages: [],
-            storageOperations: []
-        },
-        intervalHandles: {
-            heartbeat: 0
-        },
-        me: initialPresence == null ? {} : initialPresence,
-        users: {},
-        others: makeOthers({}),
-        defaultStorageRoot: initialStorage,
-        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()
-    };
+  const others = new OthersRef();
+  const connection = new ValueRef({ state: "closed" });
+  return {
+    token: null,
+    lastConnectionId: null,
+    socket: null,
+    numberOfRetry: 0,
+    lastFlushTime: 0,
+    timeoutHandles: {
+      flush: null,
+      reconnect: 0,
+      pongTimeout: 0
+    },
+    buffer: {
+      me: {
+        type: "full",
+        data: initialPresence
+      },
+      messages: [],
+      storageOperations: []
+    },
+    intervalHandles: {
+      heartbeat: 0
+    },
+    connection,
+    me: new MeRef(initialPresence),
+    others,
+    defaultStorageRoot: initialStorage,
+    idFactory: null,
+    clock: 0,
+    opClock: 0,
+    nodes: /* @__PURE__ */ new Map(),
+    root: void 0,
+    undoStack: [],
+    redoStack: [],
+    isHistoryPaused: false,
+    pausedHistory: [],
+    activeBatch: null,
+    offlineOperations: /* @__PURE__ */ new Map()
+  };
 }
-function createRoom(options, context) {
-    var initialPresence = _nullishCoalesce(options.initialPresence, function() {
-        return options.defaultPresence;
-    });
-    var initialStorage = _nullishCoalesce(options.initialStorage, function() {
-        return options.defaultStorageRoot;
-    });
-    var state = defaultState(typeof initialPresence === "function" ? initialPresence(context.roomId) : initialPresence, typeof initialStorage === "function" ? initialStorage(context.roomId) : initialStorage);
-    var machine = makeStateMachine(state, context);
-    var room = {
-        id: context.roomId,
-        getConnectionState: machine.selectors.getConnectionState,
-        getSelf: machine.selectors.getSelf,
-        subscribe: machine.subscribe,
-        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,
-            canUndo: machine.canUndo,
-            canRedo: machine.canRedo,
-            pause: machine.pauseHistory,
-            resume: machine.resumeHistory
-        },
-        __INTERNAL_DO_NOT_USE: {
-            simulateCloseWebsocket: machine.simulateSocketClose,
-            simulateSendCloseEvent: machine.simulateSendCloseEvent
-        }
-    };
-    return {
-        connect: machine.connect,
-        disconnect: machine.disconnect,
-        onNavigatorOnline: machine.onNavigatorOnline,
-        onVisibilityChange: machine.onVisibilityChange,
-        room: room
-    };
+function createRoom(options, config) {
+  const { initialPresence, initialStorage } = options;
+  const state = defaultState(
+    typeof initialPresence === "function" ? initialPresence(config.roomId) : initialPresence,
+    typeof initialStorage === "function" ? initialStorage(config.roomId) : initialStorage
+  );
+  const machine = makeStateMachine(
+    state,
+    config
+  );
+  const room = {
+    id: config.roomId,
+    getConnectionState: machine.getConnectionState,
+    isSelfAware: machine.isSelfAware,
+    getSelf: machine.getSelf,
+    subscribe: machine.subscribe,
+    getPresence: machine.getPresence,
+    updatePresence: machine.updatePresence,
+    getOthers: machine.getOthers,
+    broadcastEvent: machine.broadcastEvent,
+    getStorage: machine.getStorage,
+    getStorageSnapshot: machine.getStorageSnapshot,
+    events: machine.events,
+    batch: machine.batch,
+    history: {
+      undo: machine.undo,
+      redo: machine.redo,
+      canUndo: machine.canUndo,
+      canRedo: machine.canRedo,
+      pause: machine.pauseHistory,
+      resume: machine.resumeHistory
+    },
+    __INTERNAL_DO_NOT_USE: {
+      simulateCloseWebsocket: machine.simulateSocketClose,
+      simulateSendCloseEvent: machine.simulateSendCloseEvent
+    }
+  };
+  return {
+    connect: machine.connect,
+    disconnect: machine.disconnect,
+    onNavigatorOnline: machine.onNavigatorOnline,
+    onVisibilityChange: machine.onVisibilityChange,
+    room
+  };
 }
-var LiveblocksError = /*#__PURE__*/ function(Error1) {
-    _inherits(LiveblocksError, Error1);
-    var _super = _createSuper(LiveblocksError);
-    function LiveblocksError(message, code) {
-        _classCallCheck(this, LiveblocksError);
-        var _this;
-        _this = _super.call(this, message);
-        _this.code = code;
-        return _this;
-    }
-    return LiveblocksError;
-}(_wrapNativeSuper(Error));
+var LiveblocksError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
 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.");
-    }
-    var ws = WebSocketPolyfill || WebSocket;
-    return function(token) {
-        return new ws("".concat(liveblocksServer, "/?token=").concat(token, "&version=").concat(true ? "0.17.11" : "dev"));
-    };
+  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}&version=${true ? "0.18.0-beta2" : "dev"}`
+    );
+  };
 }
 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 function(room) {
-            return fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-                room: 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 function(room) {
-            return fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-                room: room
-            });
-        };
+  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."
+      );
     }
-    if (authentication.type === "custom") {
-        var authWithResponseValidation = function(room) {
-            return authentication.callback(room).then(function(response) {
-                if (!response || !response.token) {
-                    throw new Error('Authentication error. We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }');
-                }
-                return response;
-            });
-        };
-        return authWithResponseValidation;
+    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."
+      );
     }
-    throw new Error("Internal error. Unexpected authentication type");
+    return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+      room
+    });
+  }
+  if (authentication.type === "custom") {
+    return (room) => _chunkRS4TQ2LTjs.__async.call(void 0, this, null, function* () {
+      const response = yield authentication.callback(room);
+      if (!response || !response.token) {
+        throw new Error(
+          'Authentication error. We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
+        );
+      }
+      return response;
+    });
+  }
+  throw new Error("Internal error. Unexpected authentication type");
 }
 function fetchAuthEndpoint(fetch2, endpoint, body) {
-    return fetch2(endpoint, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-    }).then(function(res) {
-        if (!res.ok) {
-            throw new AuthenticationError("Expected a status 200 but got ".concat(res.status, ' when doing a POST request on "').concat(endpoint, '"'));
-        }
-        return res.json().catch(function(er) {
-            throw new AuthenticationError('Expected a JSON response when doing a POST request on "'.concat(endpoint, '". ').concat(er));
-        });
-    }).then(function(data) {
-        if (!_chunkQLMVHHAZjs.isPlainObject.call(void 0, data) || typeof data.token !== "string") {
-            throw new AuthenticationError('Expected a JSON response of the form `{ token: "..." }` when doing a POST request on "'.concat(endpoint, '", but got ').concat(JSON.stringify(data)));
-        }
-        var token = data.token;
-        return {
-            token: token
-        };
+  return _chunkRS4TQ2LTjs.__async.call(void 0, this, null, function* () {
+    const res = yield fetch2(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
     });
+    if (!res.ok) {
+      throw new AuthenticationError(
+        `Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`
+      );
+    }
+    let data;
+    try {
+      data = yield res.json();
+    } catch (er) {
+      throw new AuthenticationError(
+        `Expected a JSON response when doing a POST request on "${endpoint}". ${er}`
+      );
+    }
+    if (!_chunkRS4TQ2LTjs.isPlainObject.call(void 0, data) || typeof data.token !== "string") {
+      throw new AuthenticationError(
+        `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
+          data
+        )}`
+      );
+    }
+    const { token } = data;
+    return { token };
+  });
 }
-var AuthenticationError = /*#__PURE__*/ function(Error1) {
-    _inherits(AuthenticationError, Error1);
-    var _super = _createSuper(AuthenticationError);
-    function AuthenticationError(message) {
-        _classCallCheck(this, AuthenticationError);
-        return _super.call(this, message);
-    }
-    return AuthenticationError;
-}(_wrapNativeSuper(Error));
+var AuthenticationError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
 // src/client.ts
 function createClient(options) {
-    var getRoom = function getRoom(roomId) {
-        var internalRoom = rooms.get(roomId);
-        return internalRoom ? internalRoom.room : null;
-    };
-    var enter = function enter(roomId) {
-        var options2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
-        var internalRoom = rooms.get(roomId);
-        if (internalRoom) {
-            return internalRoom.room;
-        }
-        _chunkQLMVHHAZjs.errorIf.call(void 0, options2.defaultPresence, "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP");
-        _chunkQLMVHHAZjs.errorIf.call(void 0, options2.defaultStorageRoot, "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP");
-        internalRoom = createRoom({
-            initialPresence: options2.initialPresence,
-            initialStorage: options2.initialStorage,
-            defaultPresence: options2.defaultPresence,
-            defaultStorageRoot: options2.defaultStorageRoot
-        }, {
-            roomId: roomId,
-            throttleDelay: throttleDelay,
-            polyfills: clientOptions.polyfills,
-            WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-            fetchPolyfill: clientOptions.fetchPolyfill,
-            liveblocksServer: _optionalChain([
-                clientOptions,
-                "optionalAccess",
-                function(_9) {
-                    return _9.liveblocksServer;
-                }
-            ]) || "wss://api.liveblocks.io/v6",
-            authentication: prepareAuthentication(clientOptions, roomId)
-        });
-        rooms.set(roomId, internalRoom);
-        if (!options2.DO_NOT_USE_withoutConnecting) {
-            if (typeof atob == "undefined") {
-                if (_optionalChain([
-                    clientOptions,
-                    "access",
-                    function(_10) {
-                        return _10.polyfills;
-                    },
-                    "optionalAccess",
-                    function(_11) {
-                        return _11.atob;
-                    }
-                ]) == void 0) {
-                    throw new Error("You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill");
-                }
-                global.atob = clientOptions.polyfills.atob;
-            }
-            internalRoom.connect();
-        }
-        return internalRoom.room;
-    };
-    var leave = function leave(roomId) {
-        var room = rooms.get(roomId);
-        if (room) {
-            room.disconnect();
-            rooms.delete(roomId);
-        }
-    };
-    var clientOptions = options;
-    var throttleDelay = getThrottleDelayFromOptions(options);
-    var rooms = /* @__PURE__ */ new Map();
-    if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
-        window.addEventListener("online", function() {
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = rooms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var _value = _slicedToArray(_step.value, 2), room = _value[1];
-                    room.onNavigatorOnline();
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-        });
+  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) {
+    var _a, _b;
+    let internalRoom = rooms.get(roomId);
+    if (internalRoom) {
+      return internalRoom.room;
     }
-    if (typeof document !== "undefined") {
-        document.addEventListener("visibilitychange", function() {
-            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-            try {
-                for(var _iterator = rooms[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var _value = _slicedToArray(_step.value, 2), room = _value[1];
-                    room.onVisibilityChange(document.visibilityState);
-                }
-            } catch (err) {
-                _didIteratorError = true;
-                _iteratorError = err;
-            } finally{
-                try {
-                    if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                    }
-                } finally{
-                    if (_didIteratorError) {
-                        throw _iteratorError;
-                    }
-                }
-            }
-        });
+    _chunkRS4TQ2LTjs.deprecateIf.call(void 0, 
+      options2.initialPresence == null,
+      "Please provide an initial presence value for the current user when entering the room."
+    );
+    internalRoom = createRoom(
+      {
+        initialPresence: (_a = options2.initialPresence) != null ? _a : {},
+        initialStorage: options2.initialStorage
+      },
+      {
+        roomId,
+        throttleDelay,
+        polyfills: clientOptions.polyfills,
+        WebSocketPolyfill: clientOptions.WebSocketPolyfill,
+        fetchPolyfill: clientOptions.fetchPolyfill,
+        liveblocksServer: (clientOptions == null ? void 0 : clientOptions.liveblocksServer) || "wss://api.liveblocks.io/v6",
+        authentication: prepareAuthentication(clientOptions, roomId)
+      }
+    );
+    rooms.set(
+      roomId,
+      internalRoom
+    );
+    if (!options2.DO_NOT_USE_withoutConnecting) {
+      if (typeof atob == "undefined") {
+        if (((_b = clientOptions.polyfills) == null ? void 0 : _b.atob) == void 0) {
+          throw new Error(
+            "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
+          );
+        }
+        global.atob = clientOptions.polyfills.atob;
+      }
+      internalRoom.connect();
     }
-    return {
-        getRoom: getRoom,
-        enter: enter,
-        leave: leave
-    };
+    return internalRoom.room;
+  }
+  function leave(roomId) {
+    const room = rooms.get(roomId);
+    if (room) {
+      room.disconnect();
+      rooms.delete(roomId);
+    }
+  }
+  if (typeof window !== "undefined" && typeof window.addEventListener !== "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;
+  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, roomId) {
-    var publicApiKey = clientOptions.publicApiKey, authEndpoint = clientOptions.authEndpoint;
-    if (authEndpoint !== void 0 && publicApiKey !== void 0) {
-        throw new Error("You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
-    }
-    if (typeof publicApiKey === "string") {
-        if (publicApiKey.startsWith("sk_")) {
-            throw new Error("Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey");
-        } else if (!publicApiKey.startsWith("pk_")) {
-            throw new Error("Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey");
-        }
-        return {
-            type: "public",
-            publicApiKey: publicApiKey,
-            url: buildLiveblocksPublicAuthorizeEndpoint(clientOptions, roomId)
-        };
+  const { publicApiKey, authEndpoint } = clientOptions;
+  if (authEndpoint !== void 0 && publicApiKey !== void 0) {
+    throw new Error(
+      "You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+    );
+  }
+  if (typeof publicApiKey === "string") {
+    if (publicApiKey.startsWith("sk_")) {
+      throw new Error(
+        "Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
+    } else if (!publicApiKey.startsWith("pk_")) {
+      throw new Error(
+        "Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
+      );
     }
-    if (typeof authEndpoint === "string") {
-        return {
-            type: "private",
-            url: authEndpoint
-        };
-    } else if (typeof authEndpoint === "function") {
-        return {
-            type: "custom",
-            callback: authEndpoint
-        };
-    } else if (authEndpoint !== void 0) {
-        throw new Error("authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint");
-    }
-    throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
+    return {
+      type: "public",
+      publicApiKey,
+      url: buildLiveblocksPublicAuthorizeEndpoint(clientOptions, roomId)
+    };
+  }
+  if (typeof authEndpoint === "string") {
+    return {
+      type: "private",
+      url: authEndpoint
+    };
+  } else if (typeof authEndpoint === "function") {
+    return {
+      type: "custom",
+      callback: authEndpoint
+    };
+  } else if (authEndpoint !== void 0) {
+    throw new Error(
+      "authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint"
+    );
+  }
+  throw new Error(
+    "Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
+  );
 }
 function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
-    if (options.publicAuthorizeEndpoint) {
-        return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
+  if (options.publicAuthorizeEndpoint) {
+    return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
+  }
+  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
+    roomId
+  )}/public/authorize`;
+}
+
+// src/shallow.ts
+function shallowArray(xs, ys) {
+  if (xs.length !== ys.length) {
+    return false;
+  }
+  for (let i = 0; i < xs.length; i++) {
+    if (!Object.is(xs[i], ys[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function shallowObj(objA, objB) {
+  if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null || Object.prototype.toString.call(objA) !== "[object Object]" || Object.prototype.toString.call(objB) !== "[object Object]") {
+    return false;
+  }
+  const keysA = Object.keys(objA);
+  if (keysA.length !== Object.keys(objB).length) {
+    return false;
+  }
+  return keysA.every(
+    (key) => Object.prototype.hasOwnProperty.call(objB, key) && Object.is(objA[key], objB[key])
+  );
+}
+function shallow(a, b) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  const isArrayA = Array.isArray(a);
+  const isArrayB = Array.isArray(b);
+  if (isArrayA || isArrayB) {
+    if (!isArrayA || !isArrayB) {
+      return false;
     }
-    return "https://api.liveblocks.io/v2/rooms/".concat(encodeURIComponent(roomId), "/public/authorize");
+    return shallowArray(a, b);
+  }
+  return shallowObj(a, b);
 }
-exports.LiveList = _chunkQLMVHHAZjs.LiveList;
-exports.LiveMap = _chunkQLMVHHAZjs.LiveMap;
-exports.LiveObject = _chunkQLMVHHAZjs.LiveObject;
-exports.createClient = createClient;
+
+
+
+
+
+
+exports.LiveList = _chunkRS4TQ2LTjs.LiveList; exports.LiveMap = _chunkRS4TQ2LTjs.LiveMap; exports.LiveObject = _chunkRS4TQ2LTjs.LiveObject; exports.createClient = createClient; exports.shallow = shallow;