@liveblocks/client 0.17.8 → 0.17.10-debug2

package/index.js

@@ -1,1346 +1,2057 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: !0 });
-var Json = require("./shared.js"),
-  _excluded = ["_hasReceivedInitialPresence"],
-  BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4],
-  BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
+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");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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;
+    }
+}
+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;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+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;
+    }
+    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
+        }
+    });
+    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;
+    }
+}
+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;
+        }
+    }
+    return _arr;
+}
+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 _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 _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]);
+        });
+    }
+    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);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    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];
+        }
+    }
+    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;
+    }
+    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;
+    }
+}
+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;
+    } else {
+        return rhsFn();
+    }
+}
+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;
+        }
+    }
+    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 _ref,
-    users = Object.values(userMap).map(function (user) {
-      return (
-        user._hasReceivedInitialPresence,
-        Json._objectWithoutPropertiesLoose(user, _excluded)
-      );
+    var users = Object.values(userMap).map(function(user) {
+        var _hasReceivedInitialPresence = user._hasReceivedInitialPresence, publicKeys = _objectWithoutProperties(user, [
+            "_hasReceivedInitialPresence"
+        ]);
+        return publicKeys;
     });
-  return (
-    ((_ref = {
-      get count() {
-        return users.length;
-      },
-    })[Symbol.iterator] = function () {
-      return users[Symbol.iterator]();
-    }),
-    (_ref.map = function (callback) {
-      return users.map(callback);
-    }),
-    (_ref.toArray = function () {
-      return users;
-    }),
-    _ref
-  );
+    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];
+    }
+    return;
 }
 function makeStateMachine(state, context, mockedEffects) {
-  var effects = mockedEffects || {
-    authenticate: function (auth, createWebSocket) {
-      var rawToken = state.token,
-        parsedToken = null !== rawToken && Json.parseRoomAuthToken(rawToken);
-      if (!parsedToken || Json.isTokenExpired(parsedToken))
-        return auth(context.roomId)
-          .then(function (_ref2) {
-            var token = _ref2.token;
-            "authenticating" === state.connection.state &&
-              (authenticationSuccess(
-                Json.parseRoomAuthToken(token),
-                createWebSocket(token)
-              ),
-              (state.token = token));
-          })
-          .catch(function (er) {
-            return (function (error) {
-              "production" !== process.env.NODE_ENV &&
-                console.error("Call to authentication endpoint failed", error);
-              (state.token = null),
-                updateConnection({ state: "unavailable" }),
-                state.numberOfRetry++,
-                (state.timeoutHandles.reconnect = effects.scheduleReconnect(
-                  getRetryDelay()
-                ));
-            })(er instanceof Error ? er : new Error(String(er)));
-          });
-      authenticationSuccess(parsedToken, createWebSocket(rawToken));
-    },
-    send: function (messageOrMessages) {
-      if (null == state.socket)
-        throw new Error("Can't send message if socket is null");
-      state.socket.send(JSON.stringify(messageOrMessages));
-    },
-    delayFlush: function (delay) {
-      return setTimeout(tryFlushing, delay);
-    },
-    startHeartbeatInterval: function () {
-      return setInterval(heartbeat, 3e4);
-    },
-    schedulePongTimeout: function () {
-      return setTimeout(pongTimeout, 2e3);
-    },
-    scheduleReconnect: function (delay) {
-      return setTimeout(connect, delay);
-    },
-  };
-  function genericSubscribe(callback) {
-    return (
-      state.listeners.storage.push(callback),
-      function () {
-        return Json.remove(state.listeners.storage, callback);
-      }
-    );
-  }
-  function createOrUpdateRootFromMessage(message) {
-    if (0 === message.items.length)
-      throw new Error("Internal error: cannot load storage without items");
-    var items, _buildRootAndParentTo, root, parentToChildren;
-    for (var _key in (state.root
-      ? (function (items) {
-          if (!state.root) return;
-          var currentItems = new Map();
-          state.items.forEach(function (liveCrdt, id) {
-            currentItems.set(id, liveCrdt._toSerializedCrdt());
-          }),
-            notify(
-              apply(
-                Json.getTreesDiffOperations(currentItems, new Map(items)),
-                !1
-              ).updates
-            );
-        })(message.items)
-      : (state.root =
-          ((items = message.items),
-          (_buildRootAndParentTo = (function (items) {
-            for (
-              var _step2,
-                parentToChildren = new Map(),
-                root = null,
-                _iterator2 = Json._createForOfIteratorHelperLoose(items);
-              !(_step2 = _iterator2()).done;
-
-            ) {
-              var _step2$value = _step2.value,
-                id = _step2$value[0],
-                crdt = _step2$value[1];
-              if (Json.isRootCrdt(crdt)) root = [id, crdt];
-              else {
-                var tuple = [id, crdt],
-                  children = parentToChildren.get(crdt.parentId);
-                null != children
-                  ? children.push(tuple)
-                  : parentToChildren.set(crdt.parentId, [tuple]);
-              }
+    var genericSubscribe = function genericSubscribe(callback) {
+        state.listeners.storage.push(callback);
+        return function() {
+            return _chunkQLMVHHAZjs.remove.call(void 0, state.listeners.storage, callback);
+        };
+    };
+    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);
             }
-            if (null == root) throw new Error("Root can't be null");
-            return [root, parentToChildren];
-          })(items)),
-          (root = _buildRootAndParentTo[0]),
-          (parentToChildren = _buildRootAndParentTo[1]),
-          Json.LiveObject._deserialize(root, parentToChildren, {
+        });
+    };
+    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");
+        }
+        if (state.root) {
+            updateRoot(message.items);
+        } 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,
-          }))),
-    state.defaultStorageRoot))
-      null == state.root.get(_key) &&
-        state.root.set(_key, state.defaultStorageRoot[_key]);
-  }
-  function addItem(id, liveItem) {
-    state.items.set(id, liveItem);
-  }
-  function deleteItem(id) {
-    state.items.delete(id);
-  }
-  function getItem(id) {
-    return state.items.get(id);
-  }
-  function addToUndoStack(historyItem) {
-    var _state$pausedHistory;
-    (state.undoStack.length >= 50 && state.undoStack.shift(),
-    state.isHistoryPaused)
-      ? (_state$pausedHistory = state.pausedHistory).unshift.apply(
-          _state$pausedHistory,
-          historyItem
-        )
-      : (state.undoStack.push(historyItem), onHistoryChange());
-  }
-  function storageDispatch(ops, reverse, storageUpdates) {
-    var _state$batch$ops, _state$batch$reverseO;
-    state.isBatching
-      ? ((_state$batch$ops = state.batch.ops).push.apply(_state$batch$ops, ops),
-        storageUpdates.forEach(function (value, key) {
-          state.batch.updates.storageUpdates.set(
-            key,
-            Json.mergeStorageUpdates(
-              state.batch.updates.storageUpdates.get(key),
-              value
-            )
-          );
-        }),
-        (_state$batch$reverseO = state.batch.reverseOps).push.apply(
-          _state$batch$reverseO,
-          reverse
-        ))
-      : (addToUndoStack(reverse),
-        (state.redoStack = []),
-        dispatch(ops),
-        notify({ storageUpdates: storageUpdates }));
-  }
-  function notify(_ref3) {
-    var _ref3$storageUpdates = _ref3.storageUpdates,
-      storageUpdates =
-        void 0 === _ref3$storageUpdates ? new Map() : _ref3$storageUpdates,
-      _ref3$presence = _ref3.presence,
-      presence = void 0 !== _ref3$presence && _ref3$presence,
-      _ref3$others = _ref3.others,
-      otherEvents = void 0 === _ref3$others ? [] : _ref3$others;
-    if (otherEvents.length > 0) {
-      state.others = makeOthers(state.users);
-      for (
-        var _step3,
-          _iterator3 = Json._createForOfIteratorHelperLoose(otherEvents);
-        !(_step3 = _iterator3()).done;
-
-      )
-        for (
-          var _step4,
-            _event = _step3.value,
-            _iterator4 = Json._createForOfIteratorHelperLoose(
-              state.listeners.others
-            );
-          !(_step4 = _iterator4()).done;
-
-        ) {
-          (0, _step4.value)(state.others, _event);
+            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 (presence)
-      for (
-        var _step5,
-          _iterator5 = Json._createForOfIteratorHelperLoose(
-            state.listeners["my-presence"]
-          );
-        !(_step5 = _iterator5()).done;
-
-      ) {
-        (0, _step5.value)(state.me);
-      }
-    if (storageUpdates.size > 0)
-      for (
-        var _step6,
-          _iterator6 = Json._createForOfIteratorHelperLoose(
-            state.listeners.storage
-          );
-        !(_step6 = _iterator6()).done;
-
-      ) {
-        (0, _step6.value)(Array.from(storageUpdates.values()));
-      }
-  }
-  function getConnectionId() {
-    if (
-      "open" === state.connection.state ||
-      "connecting" === state.connection.state
-    )
-      return state.connection.id;
-    if (null !== state.lastConnectionId) return state.lastConnectionId;
-    throw new Error(
-      "Internal. Tried to get connection id but connection was never open"
-    );
-  }
-  function generateId() {
-    return getConnectionId() + ":" + state.clock++;
-  }
-  function generateOpId() {
-    return getConnectionId() + ":" + state.opClock++;
-  }
-  function apply(item, isLocal) {
-    for (
-      var _step7,
-        result = {
-          reverse: [],
-          updates: { storageUpdates: new Map(), presence: !1 },
-        },
-        createdNodeIds = new Set(),
-        _iterator7 = Json._createForOfIteratorHelperLoose(item);
-      !(_step7 = _iterator7()).done;
-
-    ) {
-      var op = _step7.value;
-      if ("presence" === op.type) {
-        var reverse = { type: "presence", data: {} };
-        for (var _key2 in op.data) reverse.data[_key2] = state.me[_key2];
-        if (
-          ((state.me = Json._extends({}, state.me, op.data)),
-          null == state.buffer.presence)
-        )
-          state.buffer.presence = op.data;
-        else
-          for (var _key3 in op.data)
-            state.buffer.presence[_key3] = op.data[_key3];
-        result.reverse.unshift(reverse), (result.updates.presence = !0);
-      } else {
-        var source = void 0;
-        if ((op.opId || (op.opId = generateOpId()), isLocal))
-          source = Json.OpSource.UNDOREDO_RECONNECT;
-        else
-          source = state.offlineOperations.delete(Json.nn(op.opId))
-            ? Json.OpSource.ACK
-            : Json.OpSource.REMOTE;
-        var applyOpResult = applyOp(op, source);
-        if (applyOpResult.modified) {
-          var _result$reverse,
-            parentId =
-              "HasParent" === applyOpResult.modified.node.parent.type
-                ? Json.nn(
-                    applyOpResult.modified.node.parent.node._id,
-                    "Expected parent node to have an ID"
-                  )
-                : void 0;
-          if (!parentId || !createdNodeIds.has(parentId))
-            result.updates.storageUpdates.set(
-              Json.nn(applyOpResult.modified.node._id),
-              Json.mergeStorageUpdates(
-                result.updates.storageUpdates.get(
-                  Json.nn(applyOpResult.modified.node._id)
-                ),
-                applyOpResult.modified
-              )
-            ),
-              (_result$reverse = result.reverse).unshift.apply(
-                _result$reverse,
-                applyOpResult.reverse
-              );
-          (op.type !== Json.OpCode.CREATE_LIST &&
-            op.type !== Json.OpCode.CREATE_MAP &&
-            op.type !== Json.OpCode.CREATE_OBJECT) ||
-            createdNodeIds.add(Json.nn(applyOpResult.modified.node._id));
-        }
-      }
-    }
-    return result;
-  }
-  function applyOp(op, source) {
-    switch (op.type) {
-      case Json.OpCode.DELETE_OBJECT_KEY:
-      case Json.OpCode.UPDATE_OBJECT:
-      case Json.OpCode.DELETE_CRDT:
-        var item = state.items.get(op.id);
-        return null == item
-          ? { modified: !1 }
-          : item._apply(op, source === Json.OpSource.UNDOREDO_RECONNECT);
-      case Json.OpCode.SET_PARENT_KEY:
-        var _item = state.items.get(op.id);
-        return null == _item
-          ? { modified: !1 }
-          : "HasParent" === _item.parent.type &&
-            Json.isLiveList(_item.parent.node)
-          ? _item.parent.node._setChildKey(op.parentKey, _item, source)
-          : { modified: !1 };
-      case Json.OpCode.CREATE_OBJECT:
-      case Json.OpCode.CREATE_LIST:
-      case Json.OpCode.CREATE_MAP:
-      case Json.OpCode.CREATE_REGISTER:
-        if (void 0 === op.parentId) return { modified: !1 };
-        var parent = state.items.get(op.parentId);
-        return null == parent
-          ? { modified: !1 }
-          : parent._attachChild(op, source);
-    }
-  }
-  function connect() {
-    var _context$polyfills$fe,
-      _context$polyfills,
-      _context$polyfills$We,
-      _context$polyfills2;
-    if (
-      "closed" !== state.connection.state &&
-      "unavailable" !== state.connection.state
-    )
-      return null;
-    var auth = (function (authentication, fetchPolyfill) {
-        if ("public" === authentication.type) {
-          if ("undefined" == typeof window && null == fetchPolyfill)
-            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 ("private" === authentication.type) {
-          if ("undefined" == typeof window && null == fetchPolyfill)
-            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 ("custom" === authentication.type) {
-          return 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;
+        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
             });
-          };
-        }
-        throw new Error("Internal error. Unexpected authentication type");
-      })(
-        context.authentication,
-        null !=
-          (_context$polyfills$fe =
-            null == (_context$polyfills = context.polyfills)
-              ? void 0
-              : _context$polyfills.fetch)
-          ? _context$polyfills$fe
-          : context.fetchPolyfill
-      ),
-      createWebSocket = (function (liveblocksServer, WebSocketPolyfill) {
-        if ("undefined" == typeof window && null == WebSocketPolyfill)
-          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(
-            liveblocksServer + "/?token=" + token + "&version=0.17.8"
-          );
+        }
+    };
+    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
+            }
         };
-      })(
-        context.liveblocksServer,
-        null !=
-          (_context$polyfills$We =
-            null == (_context$polyfills2 = context.polyfills)
-              ? void 0
-              : _context$polyfills2.WebSocket)
-          ? _context$polyfills$We
-          : context.WebSocketPolyfill
-      );
-    updateConnection({ state: "authenticating" }),
-      effects.authenticate(auth, createWebSocket);
-  }
-  function authenticationSuccess(token, socket) {
-    var connectionId, count;
-    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 =
-        ((connectionId = token.actor),
-        (count = 0),
-        function () {
-          return connectionId + ":" + count++;
-        })),
-      (state.socket = socket);
-  }
-  function onUpdatePresenceMessage(message) {
-    var user = state.users[message.actor];
-    if (
-      void 0 !== message.targetActor ||
-      null == user ||
-      user._hasReceivedInitialPresence
-    )
-      return (
-        (state.users[message.actor] =
-          null == user
-            ? {
+        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;
+        } 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"
+        });
+        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: !0,
-              }
-            : {
+                _hasReceivedInitialPresence: true
+            };
+        } else {
+            state.users[message.actor] = {
                 id: user.id,
                 info: user.info,
                 connectionId: message.actor,
-                presence: Json._extends({}, user.presence, message.data),
-                _hasReceivedInitialPresence: !0,
-              }),
-        {
-          type: "update",
-          updates: message.data,
-          user: state.users[message.actor],
-        }
-      );
-  }
-  function onUserLeftMessage(message) {
-    var userLeftMessage = message,
-      user = state.users[userLeftMessage.actor];
-    return user
-      ? (delete state.users[userLeftMessage.actor],
-        { type: "leave", user: user })
-      : null;
-  }
-  function onRoomStateMessage(message) {
-    var newUsers = {};
-    for (var _key5 in message.users) {
-      var _connectionId = Number.parseInt(_key5),
-        user = message.users[_key5];
-      newUsers[_connectionId] = {
-        connectionId: _connectionId,
-        info: user.info,
-        id: user.id,
-      };
-    }
-    return (state.users = newUsers), { type: "reset" };
-  }
-  function onEvent(message) {
-    for (
-      var _step8,
-        _iterator8 = Json._createForOfIteratorHelperLoose(
-          state.listeners.event
-        );
-      !(_step8 = _iterator8()).done;
-
-    ) {
-      (0, _step8.value)({ connectionId: message.actor, event: message.event });
-    }
-  }
-  function onHistoryChange() {
-    for (
-      var _step9,
-        _iterator9 = Json._createForOfIteratorHelperLoose(
-          state.listeners.history
-        );
-      !(_step9 = _iterator9()).done;
-
-    ) {
-      (0, _step9.value)({ canUndo: canUndo(), canRedo: canRedo() });
-    }
-  }
-  function onUserJoinedMessage(message) {
-    return (
-      (state.users[message.actor] = {
-        connectionId: message.actor,
-        info: message.info,
-        id: message.id,
-        _hasReceivedInitialPresence: !0,
-      }),
-      state.me &&
-        (state.buffer.messages.push({
-          type: Json.ClientMsgCode.UPDATE_PRESENCE,
-          data: state.me,
-          targetActor: message.actor,
-        }),
-        tryFlushing()),
-      { type: "enter", user: state.users[message.actor] }
-    );
-  }
-  function parseServerMessage(data) {
-    return Json.isJsonObject(data) ? data : null;
-  }
-  function onMessage(event) {
-    if ("pong" !== event.data) {
-      var text,
-        data,
-        messages =
-          ((text = event.data),
-          void 0 === (data = Json.tryParseJson(text))
-            ? null
-            : Json.isJsonArray(data)
-            ? Json.compact(
-                data.map(function (item) {
-                  return parseServerMessage(item);
-                })
-              )
-            : Json.compact([parseServerMessage(data)]));
-      if (null !== messages && 0 !== messages.length) {
-        for (
-          var _step10,
-            updates = { storageUpdates: new Map(), others: [] },
-            _iterator10 = Json._createForOfIteratorHelperLoose(messages);
-          !(_step10 = _iterator10()).done;
-
-        ) {
-          var message = _step10.value;
-          switch (message.type) {
-            case Json.ServerMsgCode.USER_JOINED:
-              updates.others.push(onUserJoinedMessage(message));
-              break;
-            case Json.ServerMsgCode.UPDATE_PRESENCE:
-              var othersPresenceUpdate = onUpdatePresenceMessage(message);
-              othersPresenceUpdate && updates.others.push(othersPresenceUpdate);
-              break;
-            case Json.ServerMsgCode.BROADCASTED_EVENT:
-              onEvent(message);
-              break;
-            case Json.ServerMsgCode.USER_LEFT:
-              var _event2 = onUserLeftMessage(message);
-              _event2 && updates.others.push(_event2);
-              break;
-            case Json.ServerMsgCode.ROOM_STATE:
-              updates.others.push(onRoomStateMessage(message));
-              break;
-            case Json.ServerMsgCode.INITIAL_STORAGE_STATE:
-              var offlineOps = new Map(state.offlineOperations);
-              createOrUpdateRootFromMessage(message),
-                applyAndSendOfflineOps(offlineOps),
-                null == _getInitialStateResolver || _getInitialStateResolver();
-              break;
-            case Json.ServerMsgCode.UPDATE_STORAGE:
-              apply(message.ops, !1).updates.storageUpdates.forEach(function (
-                value,
-                key
-              ) {
-                updates.storageUpdates.set(
-                  key,
-                  Json.mergeStorageUpdates(
-                    updates.storageUpdates.get(key),
-                    value
-                  )
-                );
-              });
-          }
+                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] = {
+            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);
-      }
-    } else clearTimeout(state.timeoutHandles.pongTimeout);
-  }
-  function onClose(event) {
-    if (
-      ((state.socket = null),
-      clearTimeout(state.timeoutHandles.pongTimeout),
-      clearInterval(state.intervalHandles.heartbeat),
-      state.timeoutHandles.flush && clearTimeout(state.timeoutHandles.flush),
-      clearTimeout(state.timeoutHandles.reconnect),
-      (state.users = {}),
-      notify({ others: [{ type: "reset" }] }),
-      event.code >= 4e3 && event.code <= 4100)
-    ) {
-      updateConnection({ state: "failed" });
-      for (
-        var _step11,
-          error = new LiveblocksError(event.reason, event.code),
-          _iterator11 = Json._createForOfIteratorHelperLoose(
-            state.listeners.error
-          );
-        !(_step11 = _iterator11()).done;
-
-      ) {
-        (0, _step11.value)(error);
-      }
-      var _delay = getRetryDelay(!0);
-      state.numberOfRetry++,
-        "production" !== process.env.NODE_ENV &&
-          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 === Json.WebsocketCloseCodes.CLOSE_WITHOUT_RETRY)
-      updateConnection({ state: "closed" });
-    else {
-      var _delay2 = getRetryDelay();
-      state.numberOfRetry++,
-        "production" !== process.env.NODE_ENV &&
-          console.warn(
-            "Connection to Liveblocks websocket server closed (code: " +
-              event.code +
-              "). Retrying in " +
-              _delay2 +
-              "ms."
-          ),
-        updateConnection({ state: "unavailable" }),
-        (state.timeoutHandles.reconnect = effects.scheduleReconnect(_delay2));
-    }
-  }
-  function updateConnection(connection) {
-    state.connection = connection;
-    for (
-      var _step12,
-        _iterator12 = Json._createForOfIteratorHelperLoose(
-          state.listeners.connection
-        );
-      !(_step12 = _iterator12()).done;
-
-    ) {
-      (0, _step12.value)(connection.state);
-    }
-  }
-  function getRetryDelay(slow) {
-    return (
-      void 0 === slow && (slow = !1),
-      slow
-        ? BACKOFF_RETRY_DELAYS_SLOW[
-            state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length
-              ? state.numberOfRetry
-              : BACKOFF_RETRY_DELAYS_SLOW.length - 1
-          ]
-        : 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()),
-      "connecting" === state.connection.state &&
-        (updateConnection(
-          Json._extends({}, state.connection, { state: "open" })
-        ),
-        (state.numberOfRetry = 0),
-        void 0 !== state.lastConnectionId &&
-          ((state.buffer.presence = state.me), tryFlushing()),
-        (state.lastConnectionId = state.connection.id),
-        state.root &&
-          state.buffer.messages.push({
-            type: Json.ClientMsgCode.FETCH_STORAGE,
-          }),
-        tryFlushing());
-  }
-  function heartbeat() {
-    null != state.socket &&
-      (clearTimeout(state.timeoutHandles.pongTimeout),
-      (state.timeoutHandles.pongTimeout = effects.schedulePongTimeout()),
-      state.socket.readyState === state.socket.OPEN &&
-        state.socket.send("ping"));
-  }
-  function pongTimeout() {
-    reconnect();
-  }
-  function reconnect() {
-    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),
-      state.timeoutHandles.flush && clearTimeout(state.timeoutHandles.flush),
-      clearTimeout(state.timeoutHandles.reconnect),
-      clearInterval(state.intervalHandles.heartbeat),
-      connect();
-  }
-  function applyAndSendOfflineOps(offlineOps) {
-    if (0 !== offlineOps.size) {
-      var messages = [],
-        ops = Array.from(offlineOps.values()),
-        result = apply(ops, !0);
-      messages.push({ type: Json.ClientMsgCode.UPDATE_STORAGE, ops: ops }),
-        notify(result.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);
-    }
-  }
-  function tryFlushing() {
-    var storageOps = state.buffer.storageOperations;
-    if (
-      (storageOps.length > 0 &&
-        storageOps.forEach(function (op) {
-          state.offlineOperations.set(Json.nn(op.opId), op);
-        }),
-      null != state.socket && state.socket.readyState === state.socket.OPEN)
-    ) {
-      var now = Date.now();
-      if (now - state.lastFlushTime > context.throttleDelay) {
-        var _messages = (function (state) {
-          var messages = [];
-          state.buffer.presence &&
-            messages.push({
-              type: Json.ClientMsgCode.UPDATE_PRESENCE,
-              data: state.buffer.presence,
+    };
+    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);
             });
-          for (
-            var _step13,
-              _iterator13 = Json._createForOfIteratorHelperLoose(
-                state.buffer.messages
-              );
-            !(_step13 = _iterator13()).done;
-
-          ) {
-            var _event3 = _step13.value;
-            messages.push(_event3);
-          }
-          state.buffer.storageOperations.length > 0 &&
+        }
+        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: Json.ClientMsgCode.UPDATE_STORAGE,
-              ops: state.buffer.storageOperations,
+                type: 201 /* UPDATE_STORAGE */ ,
+                ops: state2.buffer.storageOperations
             });
-          return messages;
-        })(state);
-        if (0 === _messages.length) return;
-        effects.send(_messages),
-          (state.buffer = {
-            messages: [],
-            storageOperations: [],
-            presence: null,
-          }),
-          (state.lastFlushTime = now);
-      } else
-        null != state.timeoutHandles.flush &&
-          clearTimeout(state.timeoutHandles.flush),
-          (state.timeoutHandles.flush = effects.delayFlush(
-            context.throttleDelay - (now - state.lastFlushTime)
-          ));
-    } else state.buffer.storageOperations = [];
-  }
-  function getPresence() {
-    return state.me;
-  }
-  function dispatch(ops) {
-    var _state$buffer$storage;
-    (_state$buffer$storage = state.buffer.storageOperations).push.apply(
-      _state$buffer$storage,
-      ops
-    ),
-      tryFlushing();
-  }
-  var _getInitialStatePromise = null,
-    _getInitialStateResolver = null;
-  function canUndo() {
-    return state.undoStack.length > 0;
-  }
-  function canRedo() {
-    return state.redoStack.length > 0;
-  }
-  return {
-    onClose: onClose,
-    onMessage: onMessage,
-    authenticationSuccess: authenticationSuccess,
-    heartbeat: heartbeat,
-    onNavigatorOnline: function () {
-      "unavailable" === state.connection.state && reconnect();
-    },
-    simulateSocketClose: function () {
-      state.socket && (state.socket = null);
-    },
-    simulateSendCloseEvent: function (event) {
-      onClose(event);
-    },
-    onVisibilityChange: function (visibilityState) {
-      "visible" === visibilityState &&
-        "open" === state.connection.state &&
-        heartbeat();
-    },
-    getUndoStack: function () {
-      return state.undoStack;
-    },
-    getItemsCount: function () {
-      return state.items.size;
-    },
-    connect: connect,
-    disconnect: function () {
-      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" }),
-        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" }] }),
-        (function () {
-          for (var _key6 in state.listeners) state.listeners[_key6] = [];
-        })();
-    },
-    subscribe: function (first, second, options) {
-      if (void 0 === second || "function" == typeof first) {
-        if ("function" == typeof first) return genericSubscribe(first);
-        throw new Error("Please specify a listener callback");
-      }
-      if (Json.isLiveNode(first)) {
-        var _node = first;
-        return null != options && options.isDeep
-          ? ((node = _node),
-            (callback = second),
-            genericSubscribe(function (updates) {
-              var relatedUpdates = updates.filter(function (update) {
-                return Json.isSameNodeOrChildOf(update.node, node);
-              });
-              relatedUpdates.length > 0 && callback(relatedUpdates);
-            }))
-          : (function (node, callback) {
-              return genericSubscribe(function (updates) {
-                for (
-                  var _step,
-                    _iterator = Json._createForOfIteratorHelperLoose(updates);
-                  !(_step = _iterator()).done;
-
-                ) {
-                  var update = _step.value;
-                  update.node._id === node._id && callback(update.node);
+        }
+        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"
                 }
-              });
-            })(_node, second);
-      }
-      var node, callback;
-      if (!Json.isRoomEventName(first))
-        throw new Error('"' + first + '" is not a valid event name');
-      var eventName = first,
-        eventListener = second;
-      return (
-        state.listeners[eventName].push(eventListener),
-        function () {
-          var callbacks = state.listeners[eventName];
-          Json.remove(callbacks, eventListener);
-        }
-      );
-    },
-    updatePresence: function (overrides, options) {
-      var oldValues = {};
-      for (var _key4 in (null == state.buffer.presence &&
-        (state.buffer.presence = {}),
-      overrides)) {
-        var overrideValue = overrides[_key4];
-        void 0 !== overrideValue &&
-          ((state.buffer.presence[_key4] = overrideValue),
-          (oldValues[_key4] = state.me[_key4]));
-      }
-      (state.me = Json._extends({}, state.me, overrides)),
-        state.isBatching
-          ? (null != options &&
-              options.addToHistory &&
-              state.batch.reverseOps.push({
-                type: "presence",
-                data: oldValues,
-              }),
-            (state.batch.updates.presence = !0))
-          : (tryFlushing(),
-            null != options &&
-              options.addToHistory &&
-              addToUndoStack([{ type: "presence", data: oldValues }]),
-            notify({ presence: !0 }));
-    },
-    broadcastEvent: function (event, options) {
-      void 0 === options && (options = { shouldQueueEventIfNotReady: !1 }),
-        (null == state.socket && 0 == options.shouldQueueEventIfNotReady) ||
-          (state.buffer.messages.push({
-            type: Json.ClientMsgCode.BROADCAST_EVENT,
-            event: event,
-          }),
-          tryFlushing());
-    },
-    batch: function (callback) {
-      if (state.isBatching)
-        throw new Error("batch should not be called during a batch");
-      state.isBatching = !0;
-      try {
-        callback();
-      } finally {
-        (state.isBatching = !1),
-          state.batch.reverseOps.length > 0 &&
-            addToUndoStack(state.batch.reverseOps),
-          state.batch.ops.length > 0 && (state.redoStack = []),
-          state.batch.ops.length > 0 && dispatch(state.batch.ops),
-          notify(state.batch.updates),
-          (state.batch = {
-            ops: [],
-            reverseOps: [],
-            updates: { others: [], storageUpdates: new Map(), presence: !1 },
-          }),
-          tryFlushing();
-      }
-    },
-    undo: function () {
-      if (state.isBatching)
-        throw new Error("undo is not allowed during a batch");
-      var historyItem = state.undoStack.pop();
-      if (null != historyItem) {
-        state.isHistoryPaused = !1;
-        var result = apply(historyItem, !0);
-        notify(result.updates),
-          state.redoStack.push(result.reverse),
-          onHistoryChange();
-        for (
-          var _step14,
-            _iterator14 = Json._createForOfIteratorHelperLoose(historyItem);
-          !(_step14 = _iterator14()).done;
-
-        ) {
-          var op = _step14.value;
-          "presence" !== op.type && state.buffer.storageOperations.push(op);
+            ]
+        });
+        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
+        };
+        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();
-      }
-    },
-    redo: function () {
-      if (state.isBatching)
-        throw new Error("redo is not allowed during a batch");
-      var historyItem = state.redoStack.pop();
-      if (null != historyItem) {
-        state.isHistoryPaused = !1;
-        var result = apply(historyItem, !0);
-        notify(result.updates),
-          state.undoStack.push(result.reverse),
-          onHistoryChange();
-        for (
-          var _step15,
-            _iterator15 = Json._createForOfIteratorHelperLoose(historyItem);
-          !(_step15 = _iterator15()).done;
-
-        ) {
-          var op = _step15.value;
-          "presence" !== op.type && state.buffer.storageOperations.push(op);
+    };
+    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)
+            };
+        });
+    };
+    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();
-      }
-    },
-    canUndo: canUndo,
-    canRedo: canRedo,
-    pauseHistory: function () {
-      (state.pausedHistory = []), (state.isHistoryPaused = !0);
-    },
-    resumeHistory: function () {
-      (state.isHistoryPaused = !1),
-        state.pausedHistory.length > 0 && addToUndoStack(state.pausedHistory),
-        (state.pausedHistory = []);
-    },
-    getStorage: function () {
-      return state.root
-        ? new Promise(function (resolve) {
-            return resolve({ root: state.root });
-          })
-        : (null == _getInitialStatePromise &&
-            (state.buffer.messages.push({
-              type: Json.ClientMsgCode.FETCH_STORAGE,
-            }),
-            tryFlushing(),
-            (_getInitialStatePromise = new Promise(function (resolve) {
-              return (_getInitialStateResolver = resolve);
-            }))),
-          _getInitialStatePromise.then(function () {
-            return { root: Json.nn(state.root) };
-          }));
-    },
-    selectors: {
-      getConnectionState: function () {
-        return state.connection.state;
-      },
-      getSelf: function () {
-        return "open" === state.connection.state ||
-          "connecting" === state.connection.state
-          ? {
-              connectionId: state.connection.id,
-              id: state.connection.userId,
-              info: state.connection.userInfo,
-              presence: getPresence(),
+    };
+    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);
+                }
             }
-          : null;
-      },
-      getPresence: getPresence,
-      getOthers: function () {
-        return state.others;
-      },
-    },
-  };
+        } 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
+        }
+    };
 }
-function createRoom(options, context) {
-  var _options$initialPrese,
-    _options$initialStora,
-    initialPresence =
-      null != (_options$initialPrese = options.initialPresence)
-        ? _options$initialPrese
-        : options.defaultPresence,
-    initialStorage =
-      null != (_options$initialStora = options.initialStorage)
-        ? _options$initialStora
-        : options.defaultStorageRoot,
-    machine = makeStateMachine(
-      (function (initialPresence, initialStorage) {
-        return {
-          connection: { state: "closed" },
-          token: null,
-          lastConnectionId: null,
-          socket: null,
-          listeners: {
+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: null == initialPresence ? {} : initialPresence,
+            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: null == initialPresence ? {} : initialPresence,
-          users: {},
-          others: makeOthers({}),
-          defaultStorageRoot: initialStorage,
-          idFactory: null,
-          clock: 0,
-          opClock: 0,
-          items: new Map(),
-          root: void 0,
-          undoStack: [],
-          redoStack: [],
-          isHistoryPaused: !1,
-          pausedHistory: [],
-          isBatching: !1,
-          batch: {
+            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: new Map(), presence: !1, others: [] },
-            reverseOps: [],
-          },
-          offlineOperations: new Map(),
-        };
-      })(
-        "function" == typeof initialPresence
-          ? initialPresence(context.roomId)
-          : initialPresence,
-        "function" == typeof initialStorage
-          ? initialStorage(context.roomId)
-          : initialStorage
-      ),
-      context
-    ),
-    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,
-  };
+            updates: {
+                storageUpdates: /* @__PURE__ */ new Map(),
+                presence: false,
+                others: []
+            },
+            reverseOps: []
+        },
+        offlineOperations: /* @__PURE__ */ new Map()
+    };
 }
-var LiveblocksError = (function (_Error) {
-  function LiveblocksError(message, code) {
-    return _Error.call(this, message) || this;
-  }
-  return Json._inheritsLoose(LiveblocksError, _Error), LiveblocksError;
-})(Json._wrapNativeSuper(Error));
-function fetchAuthEndpoint(fetch, endpoint, body) {
-  return fetch(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 " +
-            res.status +
-            ' when doing a POST request on "' +
-            endpoint +
-            '"'
-        );
-      return res.json().catch(function (er) {
-        throw new AuthenticationError(
-          'Expected a JSON response when doing a POST request on "' +
-            endpoint +
-            '". ' +
-            er
-        );
-      });
-    })
-    .then(function (data) {
-      if (!Json.isPlainObject(data) || "string" != typeof data.token)
-        throw new AuthenticationError(
-          'Expected a JSON response of the form `{ token: "..." }` when doing a POST request on "' +
-            endpoint +
-            '", but got ' +
-            JSON.stringify(data)
-        );
-      return { token: data.token };
+function createRoom(options, context) {
+    var initialPresence = _nullishCoalesce(options.initialPresence, function() {
+        return options.defaultPresence;
     });
-}
-var AuthenticationError = (function (_Error2) {
-  function AuthenticationError(message) {
-    return _Error2.call(this, message) || this;
-  }
-  return Json._inheritsLoose(AuthenticationError, _Error2), AuthenticationError;
-})(Json._wrapNativeSuper(Error));
-function prepareAuthentication(clientOptions) {
-  var publicApiKey = clientOptions.publicApiKey,
-    authEndpoint = clientOptions.authEndpoint;
-  if (void 0 !== authEndpoint && void 0 !== publicApiKey)
-    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 ("string" == typeof publicApiKey) {
-    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"
-      );
-    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"
-      );
+    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 {
-      type: "public",
-      publicApiKey: publicApiKey,
-      url:
-        clientOptions.publicAuthorizeEndpoint ||
-        "https://liveblocks.io/api/public/authorize",
-    };
-  }
-  if ("string" == typeof authEndpoint)
-    return { type: "private", url: authEndpoint };
-  if ("function" == typeof authEndpoint)
-    return { type: "custom", callback: authEndpoint };
-  if (void 0 !== authEndpoint)
-    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"
-  );
+        connect: machine.connect,
+        disconnect: machine.disconnect,
+        onNavigatorOnline: machine.onNavigatorOnline,
+        onVisibilityChange: machine.onVisibilityChange,
+        room: room
+    };
 }
-(exports.LiveList = Json.LiveList),
-  (exports.LiveMap = Json.LiveMap),
-  (exports.LiveObject = Json.LiveObject),
-  (exports.createClient = function (options) {
-    var clientOptions = options,
-      throttleDelay = (function (options) {
-        if (void 0 === options.throttle) return 100;
-        if (
-          "number" != typeof options.throttle ||
-          options.throttle < 80 ||
-          options.throttle > 1e3
-        )
-          throw new Error("throttle should be a number between 80 and 1000.");
-        return options.throttle;
-      })(options),
-      rooms = new Map();
-    return (
-      "undefined" != typeof window &&
-        void 0 !== window.addEventListener &&
-        window.addEventListener("online", function () {
-          for (
-            var _step, _iterator = Json._createForOfIteratorHelperLoose(rooms);
-            !(_step = _iterator()).done;
-
-          ) {
-            _step.value[1].onNavigatorOnline();
-          }
-        }),
-      "undefined" != typeof document &&
-        document.addEventListener("visibilitychange", function () {
-          for (
-            var _step2,
-              _iterator2 = Json._createForOfIteratorHelperLoose(rooms);
-            !(_step2 = _iterator2()).done;
-
-          ) {
-            _step2.value[1].onVisibilityChange(document.visibilityState);
-          }
-        }),
-      {
-        getRoom: function (roomId) {
-          var internalRoom = rooms.get(roomId);
-          return internalRoom ? internalRoom.room : null;
+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));
+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.10-debug2" : "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 === "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;
+    }
+    throw new Error("Internal error. Unexpected authentication type");
+}
+function fetchAuthEndpoint(fetch2, endpoint, body) {
+    return fetch2(endpoint, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json"
         },
-        enter: function (roomId, options) {
-          void 0 === options && (options = {});
-          var internalRoom = rooms.get(roomId);
-          if (internalRoom) return internalRoom.room;
-          if (
-            (Json.errorIf(
-              options.defaultPresence,
-              "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP"
-            ),
-            Json.errorIf(
-              options.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: options.initialPresence,
-                initialStorage: options.initialStorage,
-                defaultPresence: options.defaultPresence,
-                defaultStorageRoot: options.defaultStorageRoot,
-              },
-              {
-                roomId: roomId,
-                throttleDelay: throttleDelay,
-                polyfills: clientOptions.polyfills,
-                WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-                fetchPolyfill: clientOptions.fetchPolyfill,
-                liveblocksServer:
-                  (null == clientOptions
-                    ? void 0
-                    : clientOptions.liveblocksServer) ||
-                  "wss://liveblocks.net/v6",
-                authentication: prepareAuthentication(clientOptions),
-              }
-            )),
-            rooms.set(roomId, internalRoom),
-            !options.DO_NOT_USE_withoutConnecting)
-          ) {
-            if ("undefined" == typeof atob) {
-              var _clientOptions$polyfi;
-              if (
-                null ==
-                (null == (_clientOptions$polyfi = clientOptions.polyfills)
-                  ? void 0
-                  : _clientOptions$polyfi.atob)
-              )
-                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;
+        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
+        };
+    });
+}
+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));
+// 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;
-        },
-        leave: function (roomId) {
-          var room = rooms.get(roomId);
-          room && (room.disconnect(), rooms.delete(roomId));
-        },
-      }
-    );
-  });
+        }
+        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;
+                    }
+                }
+            }
+        });
+    }
+    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;
+                    }
+                }
+            }
+        });
+    }
+    return {
+        getRoom: getRoom,
+        enter: enter,
+        leave: leave
+    };
+}
+function getThrottleDelayFromOptions(options) {
+    if (options.throttle === void 0) {
+        return 100;
+    }
+    if (typeof options.throttle !== "number" || options.throttle < 80 || options.throttle > 1e3) {
+        throw new Error("throttle should be a number between 80 and 1000.");
+    }
+    return options.throttle;
+}
+function prepareAuthentication(clientOptions, 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)
+        };
+    }
+    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);
+    }
+    return "https://api.liveblocks.io/v2/rooms/".concat(encodeURIComponent(roomId), "/public/authorize");
+}
+exports.LiveList = _chunkQLMVHHAZjs.LiveList;
+exports.LiveMap = _chunkQLMVHHAZjs.LiveMap;
+exports.LiveObject = _chunkQLMVHHAZjs.LiveObject;
+exports.createClient = createClient;