npm - @liveblocks/client - Versions diffs - 0.16.4-beta2 → 0.16.6 - Mend

@liveblocks/client 0.16.4-beta2 → 0.16.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/index.mjs CHANGED Viewed

@@ -1,1641 +1,807 @@
-import { A as AbstractCrdt, r as remove, S as ServerMessageType, m as mergeStorageUpdates, W as WebsocketCloseCodes, C as ClientMessageType, i as isTokenValid, a as isSameNodeOrChildOf, L as LiveObject, g as getTreesDiffOperations, O as OpType, b as LiveList, p as parseJson, c as isJsonArray, d as compact, e as isJsonObject, f as LiveMap, h as LiveRegister, j as findNonSerializableValue } from './shared.mjs';
-export { b as LiveList, f as LiveMap, L as LiveObject } from './shared.mjs';
+import { A as AbstractCrdt, r as remove, S as ServerMessageType, m as mergeStorageUpdates, W as WebsocketCloseCodes, C as ClientMessageType, i as isTokenValid, a as isSameNodeOrChildOf, L as LiveObject, g as getTreesDiffOperations, O as OpType, b as LiveList, p as parseJson, c as isJsonArray, d as compact, e as isJsonObject, f as deprecateIf } from "./shared.mjs";
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation.
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-function __rest(s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-}
+export { b as LiveList, h as LiveMap, L as LiveObject } from "./shared.mjs";
+const BACKOFF_RETRY_DELAYS = [ 250, 500, 1e3, 2e3, 4e3, 8e3, 1e4 ], BACKOFF_RETRY_DELAYS_SLOW = [ 2e3, 3e4, 6e4, 3e5 ];
-const BACKOFF_RETRY_DELAYS = [250, 500, 1000, 2000, 4000, 8000, 10000];
-const BACKOFF_RETRY_DELAYS_SLOW = [2000, 30000, 60000, 300000];
-const HEARTBEAT_INTERVAL = 30000;
-// const WAKE_UP_CHECK_INTERVAL = 2000;
-const PONG_TIMEOUT = 2000;
 function isValidRoomEventType(value) {
-    return (value === "my-presence" ||
-        value === "others" ||
-        value === "event" ||
-        value === "error" ||
-        value === "connection");
-}
-function makeIdFactory(connectionId) {
-    let count = 0;
-    return () => `${connectionId}:${count++}`;
+ return "my-presence" === value || "others" === value || "event" === value || "error" === value || "connection" === value;
 }
 function makeOthers(userMap) {
-    const users = Object.values(userMap).map((user) => {
-        const publicKeys = __rest(user, ["_hasReceivedInitialPresence"]);
-        return publicKeys;
-    });
-    return {
-        get count() {
-            return users.length;
-        },
-        [Symbol.iterator]() {
-            return users[Symbol.iterator]();
-        },
-        map(callback) {
-            return users.map(callback);
-        },
-        toArray() {
-            return users;
-        },
-    };
+ const users = Object.values(userMap).map((user => function(s, e) {
+  var t = {};
+  for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0 && (t[p] = s[p]);
+  if (null != s && "function" == typeof Object.getOwnPropertySymbols) {
+   var i = 0;
+   for (p = Object.getOwnPropertySymbols(s); i < p.length; i++) e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
+  }
+  return t;
+ }(user, [ "_hasReceivedInitialPresence" ])));
+ return {
+  get count() {
+   return users.length;
+  },
+  [Symbol.iterator]: () => users[Symbol.iterator](),
+  map: callback => users.map(callback),
+  toArray: () => users
+ };
 }
 function makeStateMachine(state, context, mockedEffects) {
-    const effects = mockedEffects || {
-        authenticate(auth, createWebSocket) {
-            const token = state.token;
-            if (token && isTokenValid(token)) {
-                const parsedToken = parseToken(token);
-                const socket = createWebSocket(token);
-                authenticationSuccess(parsedToken, socket);
-            }
-            else {
-                return auth(context.roomId)
-                    .then(({ token }) => {
-                    if (state.connection.state !== "authenticating") {
-                        return;
-                    }
-                    const parsedToken = parseToken(token);
-                    const socket = createWebSocket(token);
-                    authenticationSuccess(parsedToken, socket);
-                    state.token = token;
-                })
-                    .catch((er) => authenticationFailure(er));
-            }
-        },
-        send(messageOrMessages) {
-            if (state.socket == null) {
-                throw new Error("Can't send message if socket is null");
-            }
-            state.socket.send(JSON.stringify(messageOrMessages));
-        },
-        delayFlush(delay) {
-            return setTimeout(tryFlushing, delay);
-        },
-        startHeartbeatInterval() {
-            return setInterval(heartbeat, HEARTBEAT_INTERVAL);
-        },
-        schedulePongTimeout() {
-            return setTimeout(pongTimeout, PONG_TIMEOUT);
-        },
-        scheduleReconnect(delay) {
-            return setTimeout(connect, delay);
-        },
+ const effects = mockedEffects || {
+  authenticate(auth, createWebSocket) {
+   const token = state.token;
+   if (!token || !isTokenValid(token)) return auth(context.roomId).then((({token: token}) => {
+    if ("authenticating" !== state.connection.state) return;
+    authenticationSuccess(parseToken(token), createWebSocket(token)), state.token = token;
+   })).catch((er => 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)));
+   authenticationSuccess(parseToken(token), createWebSocket(token));
+  },
+  send(messageOrMessages) {
+   if (null == state.socket) throw new Error("Can't send message if socket is null");
+   state.socket.send(JSON.stringify(messageOrMessages));
+  },
+  delayFlush: delay => setTimeout(tryFlushing, delay),
+  startHeartbeatInterval: () => setInterval(heartbeat, 3e4),
+  schedulePongTimeout: () => setTimeout(pongTimeout, 2e3),
+  scheduleReconnect: delay => setTimeout(connect, delay)
+ };
+ function genericSubscribe(callback) {
+  return state.listeners.storage.push(callback), () => remove(state.listeners.storage, callback);
+ }
+ function createOrUpdateRootFromMessage(message) {
+  if (0 === message.items.length) throw new Error("Internal error: cannot load storage without items");
+  state.root ? function(items) {
+   if (!state.root) return;
+   const currentItems = new Map;
+   state.items.forEach(((liveCrdt, id) => {
+    currentItems.set(id, liveCrdt._toSerializedCrdt());
+   }));
+   const ops = getTreesDiffOperations(currentItems, new Map(items));
+   notify(apply(ops, !1).updates);
+  }(message.items) : state.root = function(items) {
+   const [root, parentToChildren] = function(items) {
+    const parentToChildren = new Map;
+    let root = null;
+    for (const tuple of items) {
+     const parentId = tuple[1].parentId;
+     if (null == parentId) root = tuple; else {
+      const children = parentToChildren.get(parentId);
+      null != children ? children.push(tuple) : parentToChildren.set(parentId, [ tuple ]);
+     }
+    }
+    if (null == root) throw new Error("Root can't be null");
+    return [ root, parentToChildren ];
+   }(items);
+   return LiveObject._deserialize(root, parentToChildren, {
+    getItem: getItem,
+    addItem: addItem,
+    deleteItem: deleteItem,
+    generateId: generateId,
+    generateOpId: generateOpId,
+    dispatch: storageDispatch,
+    roomId: context.roomId
+   });
+  }(message.items);
+  for (const key in state.defaultStorageRoot) null == state.root.get(key) && state.root.set(key, state.defaultStorageRoot[key]);
+ }
+ function addItem(id, item) {
+  state.items.set(id, item);
+ }
+ function deleteItem(id) {
+  state.items.delete(id);
+ }
+ function getItem(id) {
+  return state.items.get(id);
+ }
+ function addToUndoStack(historyItem) {
+  state.undoStack.length >= 50 && state.undoStack.shift(), state.isHistoryPaused ? state.pausedHistory.unshift(...historyItem) : state.undoStack.push(historyItem);
+ }
+ function storageDispatch(ops, reverse, storageUpdates) {
+  state.isBatching ? (state.batch.ops.push(...ops), storageUpdates.forEach(((value, key) => {
+   state.batch.updates.storageUpdates.set(key, mergeStorageUpdates(state.batch.updates.storageUpdates.get(key), value));
+  })), state.batch.reverseOps.push(...reverse)) : (addToUndoStack(reverse), state.redoStack = [],
+  dispatch(ops), notify({
+   storageUpdates: storageUpdates
+  }));
+ }
+ function notify({storageUpdates: storageUpdates = new Map, presence: presence = !1, others: otherEvents = []}) {
+  if (otherEvents.length > 0) {
+   state.others = makeOthers(state.users);
+   for (const event of otherEvents) for (const listener of state.listeners.others) listener(state.others, event);
+  }
+  if (presence) for (const listener of state.listeners["my-presence"]) listener(state.me);
+  if (storageUpdates.size > 0) for (const subscriber of state.listeners.storage) subscriber(Array.from(storageUpdates.values()));
+ }
+ function getConnectionId() {
+  if ("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) {
+  var _a;
+  const result = {
+   reverse: [],
+   updates: {
+    storageUpdates: new Map,
+    presence: !1
+   }
+  }, createdNodeIds = new Set;
+  for (const op of item) if ("presence" === op.type) {
+   const reverse = {
+    type: "presence",
+    data: {}
+   };
+   for (const key in op.data) reverse.data[key] = state.me[key];
+   if (state.me = Object.assign(Object.assign({}, state.me), op.data), null == state.buffer.presence) state.buffer.presence = op.data; else for (const key in op.data) state.buffer.presence[key] = op.data[key];
+   result.reverse.unshift(reverse), result.updates.presence = !0;
+  } else {
+   isLocal && !op.opId && (op.opId = generateOpId());
+   const applyOpResult = applyOp(op, isLocal);
+   if (applyOpResult.modified) {
+    const parentId = null === (_a = applyOpResult.modified.node._parent) || void 0 === _a ? void 0 : _a._id;
+    createdNodeIds.has(parentId) || (result.updates.storageUpdates.set(applyOpResult.modified.node._id, mergeStorageUpdates(result.updates.storageUpdates.get(applyOpResult.modified.node._id), applyOpResult.modified)),
+    result.reverse.unshift(...applyOpResult.reverse)), op.type !== OpType.CreateList && op.type !== OpType.CreateMap && op.type !== OpType.CreateObject || createdNodeIds.add(applyOpResult.modified.node._id);
+   }
+  }
+  return result;
+ }
+ function applyOp(op, isLocal) {
+  switch (op.opId && state.offlineOperations.delete(op.opId), op.type) {
+  case OpType.DeleteObjectKey:
+  case OpType.UpdateObject:
+  case OpType.DeleteCrdt:
+   {
+    const item = state.items.get(op.id);
+    return null == item ? {
+     modified: !1
+    } : item._apply(op, isLocal);
+   }
+  case OpType.SetParentKey:
+   {
+    const item = state.items.get(op.id);
+    if (null == item) return {
+     modified: !1
     };
-    function genericSubscribe(callback) {
-        state.listeners.storage.push(callback);
-        return () => remove(state.listeners.storage, callback);
-    }
-    function crdtSubscribe(crdt, innerCallback, options) {
-        const cb = (updates) => {
-            const relatedUpdates = [];
-            for (const update of updates) {
-                if ((options === null || options === void 0 ? void 0 : options.isDeep) && isSameNodeOrChildOf(update.node, crdt)) {
-                    relatedUpdates.push(update);
-                }
-                else if (update.node._id === crdt._id) {
-                    innerCallback(update.node);
-                }
-            }
-            if ((options === null || options === void 0 ? void 0 : options.isDeep) && relatedUpdates.length > 0) {
-                innerCallback(relatedUpdates);
-            }
-        };
-        return genericSubscribe(cb);
-    }
-    function createOrUpdateRootFromMessage(message) {
-        if (message.items.length === 0) {
-            throw new Error("Internal error: cannot load storage without items");
-        }
-        if (state.root) {
-            updateRoot(message.items);
-        }
-        else {
-            state.root = load(message.items);
-        }
-        for (const key in state.defaultStorageRoot) {
-            if (state.root.get(key) == null) {
-                state.root.set(key, state.defaultStorageRoot[key]);
-            }
-        }
-    }
-    function buildRootAndParentToChildren(items) {
-        const parentToChildren = new Map();
-        let root = null;
-        for (const tuple of items) {
-            const parentId = tuple[1].parentId;
-            if (parentId == null) {
-                root = tuple;
-            }
-            else {
-                const children = parentToChildren.get(parentId);
-                if (children != null) {
-                    children.push(tuple);
-                }
-                else {
-                    parentToChildren.set(parentId, [tuple]);
-                }
-            }
-        }
-        if (root == null) {
-            throw new Error("Root can't be null");
-        }
-        return [root, parentToChildren];
-    }
-    function updateRoot(items) {
-        if (!state.root) {
-            return;
-        }
-        const currentItems = new Map();
-        state.items.forEach((liveCrdt, id) => {
-            currentItems.set(id, liveCrdt._toSerializedCrdt());
-        });
-        // Get operations that represent the diff between 2 states.
-        const ops = getTreesDiffOperations(currentItems, new Map(items));
-        const result = apply(ops, false);
-        notify(result.updates);
-    }
-    function load(items) {
-        const [root, parentToChildren] = buildRootAndParentToChildren(items);
-        return LiveObject._deserialize(root, parentToChildren, {
-            getItem,
-            addItem,
-            deleteItem,
-            generateId,
-            generateOpId,
-            dispatch: storageDispatch,
-            roomId: context.roomId,
-        });
-    }
-    function addItem(id, item) {
-        state.items.set(id, item);
-    }
-    function deleteItem(id) {
-        state.items.delete(id);
-    }
-    function getItem(id) {
-        return state.items.get(id);
-    }
-    function addToUndoStack(historyItem) {
-        // If undo stack is too large, we remove the older item
-        if (state.undoStack.length >= 50) {
-            state.undoStack.shift();
-        }
-        if (state.isHistoryPaused) {
-            state.pausedHistory.unshift(...historyItem);
-        }
-        else {
-            state.undoStack.push(historyItem);
-        }
-    }
-    function storageDispatch(ops, reverse, storageUpdates) {
-        if (state.isBatching) {
-            state.batch.ops.push(...ops);
-            storageUpdates.forEach((value, key) => {
-                state.batch.updates.storageUpdates.set(key, mergeStorageUpdates(state.batch.updates.storageUpdates.get(key), // FIXME
-                value));
-            });
-            state.batch.reverseOps.push(...reverse);
-        }
-        else {
-            addToUndoStack(reverse);
-            state.redoStack = [];
-            dispatch(ops);
-            notify({ storageUpdates: storageUpdates });
-        }
-    }
-    function notify({ storageUpdates = new Map(), presence = false, others: otherEvents = [], }) {
-        if (otherEvents.length > 0) {
-            state.others = makeOthers(state.users);
-            for (const event of otherEvents) {
-                for (const listener of state.listeners.others) {
-                    listener(state.others, event);
-                }
-            }
-        }
-        if (presence) {
-            for (const listener of state.listeners["my-presence"]) {
-                listener(state.me);
-            }
-        }
-        if (storageUpdates.size > 0) {
-            for (const subscriber of state.listeners.storage) {
-                subscriber(Array.from(storageUpdates.values()));
-            }
-        }
-    }
-    function getConnectionId() {
-        if (state.connection.state === "open" ||
-            state.connection.state === "connecting") {
-            return state.connection.id;
-        }
-        else if (state.lastConnectionId !== null) {
-            return state.lastConnectionId;
-        }
-        throw new Error("Internal. Tried to get connection id but connection was never open");
-    }
-    function generateId() {
-        return `${getConnectionId()}:${state.clock++}`;
-    }
-    function generateOpId() {
-        return `${getConnectionId()}:${state.opClock++}`;
-    }
-    function apply(item, isLocal) {
-        var _a;
-        const result = {
-            reverse: [],
-            updates: {
-                storageUpdates: new Map(),
-                presence: false,
-            },
-        };
-        const createdNodeIds = new Set();
-        for (const op of item) {
-            if (op.type === "presence") {
-                const reverse = {
-                    type: "presence",
-                    data: {},
-                };
-                for (const key in op.data) {
-                    reverse.data[key] = state.me[key];
-                }
-                state.me = Object.assign(Object.assign({}, state.me), op.data);
-                if (state.buffer.presence == null) {
-                    state.buffer.presence = op.data;
-                }
-                else {
-                    for (const key in op.data) {
-                        state.buffer.presence[key] = op.data[key];
-                    }
-                }
-                result.reverse.unshift(reverse);
-                result.updates.presence = true;
-            }
-            else {
-                // Ops applied after undo/redo don't have an opId.
-                if (isLocal && !op.opId) {
-                    op.opId = generateOpId();
-                }
-                const applyOpResult = applyOp(op, isLocal);
-                if (applyOpResult.modified) {
-                    const parentId = (_a = applyOpResult.modified.node._parent) === null || _a === void 0 ? void 0 : _a._id;
-                    // If the parent was created in the same batch, we don't want to notify
-                    // storage updates for the children.
-                    if (!createdNodeIds.has(parentId)) {
-                        result.updates.storageUpdates.set(applyOpResult.modified.node._id, mergeStorageUpdates(result.updates.storageUpdates.get(applyOpResult.modified.node._id), // FIXME
-                        applyOpResult.modified));
-                        result.reverse.unshift(...applyOpResult.reverse);
-                    }
-                    if (op.type === OpType.CreateList ||
-                        op.type === OpType.CreateMap ||
-                        op.type === OpType.CreateObject) {
-                        createdNodeIds.add(applyOpResult.modified.node._id);
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    function applyOp(op, isLocal) {
-        if (op.opId) {
-            state.offlineOperations.delete(op.opId);
-        }
-        switch (op.type) {
-            case OpType.DeleteObjectKey:
-            case OpType.UpdateObject:
-            case OpType.DeleteCrdt: {
-                const item = state.items.get(op.id);
-                if (item == null) {
-                    return { modified: false };
-                }
-                return item._apply(op, isLocal);
-            }
-            case OpType.SetParentKey: {
-                const item = state.items.get(op.id);
-                if (item == null) {
-                    return { modified: false };
-                }
-                if (item._parent instanceof LiveList) {
-                    const previousKey = item._parentKey;
-                    if (previousKey === op.parentKey) {
-                        return { modified: false };
-                    }
-                    else {
-                        return item._parent._setChildKey(op.parentKey, item, previousKey);
-                    }
-                }
-                return { modified: false };
-            }
-            case OpType.CreateObject:
-            case OpType.CreateList:
-            case OpType.CreateMap:
-            case OpType.CreateRegister: {
-                const parent = state.items.get(op.parentId);
-                if (parent == null) {
-                    return { modified: false };
-                }
-                return parent._attachChild(op, isLocal);
-            }
-        }
-    }
-    function subscribe(firstParam, listener, options) {
-        if (firstParam instanceof AbstractCrdt) {
-            return crdtSubscribe(firstParam, listener, options);
-        }
-        else if (typeof firstParam === "function") {
-            return genericSubscribe(firstParam);
-        }
-        else if (!isValidRoomEventType(firstParam)) {
-            throw new Error(`"${firstParam}" is not a valid event name`);
-        }
-        state.listeners[firstParam].push(listener);
-        return () => {
-            const callbacks = state.listeners[firstParam];
-            remove(callbacks, listener);
-        };
-    }
-    function unsubscribe(event, callback) {
-        console.warn(`unsubscribe is depreacted and will be removed in a future version.
-use the callback returned by subscribe instead.
-See v0.13 release notes for more information.
-`);
-        if (!isValidRoomEventType(event)) {
-            throw new Error(`"${event}" is not a valid event name`);
-        }
-        const callbacks = state.listeners[event];
-        remove(callbacks, callback);
-    }
-    function getConnectionState() {
-        return state.connection.state;
-    }
-    function getSelf() {
-        return state.connection.state === "open" ||
-            state.connection.state === "connecting"
-            ? {
-                connectionId: state.connection.id,
-                id: state.connection.userId,
-                info: state.connection.userInfo,
-                presence: getPresence(),
-            }
-            : null;
-    }
-    function connect() {
-        if (state.connection.state !== "closed" &&
-            state.connection.state !== "unavailable") {
-            return null;
-        }
-        const auth = prepareAuthEndpoint(context.authentication, context.fetchPolyfill);
-        const createWebSocket = prepareCreateWebSocket(context.liveblocksServer, context.WebSocketPolyfill);
-        updateConnection({ state: "authenticating" });
-        effects.authenticate(auth, createWebSocket);
-    }
-    function updatePresence(overrides, options) {
-        const oldValues = {};
-        if (state.buffer.presence == null) {
-            state.buffer.presence = {};
-        }
-        for (const key in overrides) {
-            state.buffer.presence[key] = overrides[key];
-            oldValues[key] = state.me[key];
-        }
-        state.me = Object.assign(Object.assign({}, state.me), overrides);
-        if (state.isBatching) {
-            if (options === null || options === void 0 ? void 0 : options.addToHistory) {
-                state.batch.reverseOps.push({ type: "presence", data: oldValues });
-            }
-            state.batch.updates.presence = true;
-        }
-        else {
-            tryFlushing();
-            if (options === null || options === void 0 ? void 0 : options.addToHistory) {
-                addToUndoStack([{ type: "presence", data: oldValues }]);
-            }
-            notify({ presence: true });
-        }
-    }
-    function authenticationSuccess(token, socket) {
-        socket.addEventListener("message", onMessage);
-        socket.addEventListener("open", onOpen);
-        socket.addEventListener("close", onClose);
-        socket.addEventListener("error", onError);
-        updateConnection({
-            state: "connecting",
-            id: token.actor,
-            userInfo: token.info,
-            userId: token.id,
-        });
-        state.idFactory = makeIdFactory(token.actor);
-        state.socket = socket;
-    }
-    function authenticationFailure(error) {
-        if (process.env.NODE_ENV !== "production") {
-            console.error("Call to authentication endpoint failed", error);
-        }
-        state.token = null;
-        updateConnection({ state: "unavailable" });
-        state.numberOfRetry++;
-        state.timeoutHandles.reconnect = effects.scheduleReconnect(getRetryDelay());
-    }
-    function onVisibilityChange(visibilityState) {
-        if (visibilityState === "visible" && state.connection.state === "open") {
-            heartbeat();
-        }
-    }
-    function onUpdatePresenceMessage(message) {
-        const user = state.users[message.actor];
-        // If the other user initial presence hasn't been received yet, we discard the presence update.
-        // The initial presence update message contains the property "targetActor".
-        if (message.targetActor === undefined &&
-            user != null &&
-            !user._hasReceivedInitialPresence) {
-            return undefined;
-        }
-        if (user == null) {
-            state.users[message.actor] = {
-                connectionId: message.actor,
-                presence: message.data,
-                _hasReceivedInitialPresence: true,
-            };
-        }
-        else {
-            state.users[message.actor] = {
-                id: user.id,
-                info: user.info,
-                connectionId: message.actor,
-                presence: Object.assign(Object.assign({}, user.presence), message.data),
-                _hasReceivedInitialPresence: true,
-            };
-        }
-        return {
-            type: "update",
-            updates: message.data,
-            user: state.users[message.actor],
-        };
-    }
-    function onUserLeftMessage(message) {
-        const userLeftMessage = message;
-        const user = state.users[userLeftMessage.actor];
-        if (user) {
-            delete state.users[userLeftMessage.actor];
-            return { type: "leave", user };
-        }
-        return null;
-    }
-    function onRoomStateMessage(message) {
-        const newUsers = {};
-        for (const key in message.users) {
-            const connectionId = Number.parseInt(key);
-            const user = message.users[key];
-            newUsers[connectionId] = {
-                connectionId,
-                info: user.info,
-                id: user.id,
-            };
-        }
-        state.users = newUsers;
-        return { type: "reset" };
-    }
-    function onNavigatorOnline() {
-        if (state.connection.state === "unavailable") {
-            reconnect();
-        }
-    }
-    function onEvent(message) {
-        for (const listener of state.listeners.event) {
-            listener({ connectionId: message.actor, event: message.event });
-        }
-    }
-    function onUserJoinedMessage(message) {
-        state.users[message.actor] = {
-            connectionId: message.actor,
-            info: message.info,
-            id: message.id,
-            _hasReceivedInitialPresence: true,
-        };
-        if (state.me) {
-            // Send current presence to new user
-            // TODO: Consider storing it on the backend
-            state.buffer.messages.push({
-                type: ClientMessageType.UpdatePresence,
-                data: state.me,
-                targetActor: message.actor,
-            });
-            tryFlushing();
-        }
-        return { type: "enter", user: state.users[message.actor] };
-    }
-    function parseServerMessage(data) {
-        if (!isJsonObject(data)) {
-            return null;
-        }
-        return data;
-        //          ^^^^^^^^^^^^^^^^ FIXME: Properly validate incoming external data instead!
-    }
-    function parseServerMessages(text) {
-        const data = parseJson(text);
-        if (data === undefined) {
-            return null;
-        }
-        else if (isJsonArray(data)) {
-            return compact(data.map((item) => parseServerMessage(item)));
-        }
-        else {
-            return compact([parseServerMessage(data)]);
-        }
-    }
-    function onMessage(event) {
-        if (event.data === "pong") {
-            clearTimeout(state.timeoutHandles.pongTimeout);
-            return;
-        }
-        const messages = parseServerMessages(event.data);
-        if (messages === null || messages.length === 0) {
-            // Unknown incoming message... ignore it
-            return;
-        }
-        const updates = {
-            storageUpdates: new Map(),
-            others: [],
-        };
-        for (const message of messages) {
-            switch (message.type) {
-                case ServerMessageType.UserJoined: {
-                    updates.others.push(onUserJoinedMessage(message));
-                    break;
-                }
-                case ServerMessageType.UpdatePresence: {
-                    const othersPresenceUpdate = onUpdatePresenceMessage(message);
-                    if (othersPresenceUpdate) {
-                        updates.others.push(othersPresenceUpdate);
-                    }
-                    break;
-                }
-                case ServerMessageType.Event: {
-                    onEvent(message);
-                    break;
-                }
-                case ServerMessageType.UserLeft: {
-                    const event = onUserLeftMessage(message);
-                    if (event) {
-                        updates.others.push(event);
-                    }
-                    break;
-                }
-                case ServerMessageType.RoomState: {
-                    updates.others.push(onRoomStateMessage(message));
-                    break;
-                }
-                case ServerMessageType.InitialStorageState: {
-                    // createOrUpdateRootFromMessage function could add ops to offlineOperations.
-                    // Client shouldn't resend these ops as part of the offline ops sending after reconnect.
-                    const offlineOps = new Map(state.offlineOperations);
-                    createOrUpdateRootFromMessage(message);
-                    applyAndSendOfflineOps(offlineOps);
-                    _getInitialStateResolver === null || _getInitialStateResolver === void 0 ? void 0 : _getInitialStateResolver();
-                    break;
-                }
-                case ServerMessageType.UpdateStorage: {
-                    const applyResult = apply(message.ops, false);
-                    applyResult.updates.storageUpdates.forEach((value, key) => {
-                        updates.storageUpdates.set(key, mergeStorageUpdates(updates.storageUpdates.get(key), // FIXME
-                        value));
-                    });
-                    break;
-                }
-            }
-        }
-        notify(updates);
-    }
-    // function onWakeUp() {
-    //   // Sometimes, the browser can put the webpage on pause (computer is on sleep mode for example)
-    //   // The client will not know that the server has probably close the connection even if the readyState is Open
-    //   // One way to detect this kind of pause is to ensure that a setInterval is not taking more than the delay it was configured with
-    //   if (state.connection.state === "open") {
-    //     log("Try to reconnect after laptop wake up");
-    //     reconnect();
-    //   }
-    // }
-    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 >= 4000 && event.code <= 4100) {
-            updateConnection({ state: "failed" });
-            const error = new LiveblocksError(event.reason, event.code);
-            for (const listener of state.listeners.error) {
-                listener(error);
-            }
-            const delay = getRetryDelay(true);
-            state.numberOfRetry++;
-            if (process.env.NODE_ENV !== "production") {
-                console.error(`Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code}). Retrying in ${delay}ms.`);
-            }
-            updateConnection({ state: "unavailable" });
-            state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-        }
-        else if (event.code === WebsocketCloseCodes.CLOSE_WITHOUT_RETRY) {
-            updateConnection({ state: "closed" });
-        }
-        else {
-            const delay = getRetryDelay();
-            state.numberOfRetry++;
-            if (process.env.NODE_ENV !== "production") {
-                console.warn(`Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`);
-            }
-            updateConnection({ state: "unavailable" });
-            state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-        }
-    }
-    function updateConnection(connection) {
-        state.connection = connection;
-        for (const listener of state.listeners.connection) {
-            listener(connection.state);
-        }
-    }
-    function getRetryDelay(slow = false) {
-        if (slow) {
-            return BACKOFF_RETRY_DELAYS_SLOW[state.numberOfRetry < BACKOFF_RETRY_DELAYS_SLOW.length
-                ? state.numberOfRetry
-                : BACKOFF_RETRY_DELAYS_SLOW.length - 1];
-        }
-        return BACKOFF_RETRY_DELAYS[state.numberOfRetry < BACKOFF_RETRY_DELAYS.length
-            ? state.numberOfRetry
-            : BACKOFF_RETRY_DELAYS.length - 1];
-    }
-    function onError() { }
-    function onOpen() {
-        clearInterval(state.intervalHandles.heartbeat);
-        state.intervalHandles.heartbeat = effects.startHeartbeatInterval();
-        if (state.connection.state === "connecting") {
-            updateConnection(Object.assign(Object.assign({}, state.connection), { state: "open" }));
-            state.numberOfRetry = 0;
-            // Re-broadcast the user presence during a reconnect.
-            if (state.lastConnectionId !== undefined) {
-                state.buffer.presence = state.me;
-                tryFlushing();
-            }
-            state.lastConnectionId = state.connection.id;
-            if (state.root) {
-                state.buffer.messages.push({ type: ClientMessageType.FetchStorage });
-            }
-            tryFlushing();
-        }
-    }
-    function heartbeat() {
-        if (state.socket == null) {
-            // Should never happen, because we clear the pong timeout when the connection is dropped explictly
-            return;
-        }
-        clearTimeout(state.timeoutHandles.pongTimeout);
-        state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-        if (state.socket.readyState === state.socket.OPEN) {
-            state.socket.send("ping");
-        }
-    }
-    function pongTimeout() {
-        reconnect();
-    }
-    function reconnect() {
-        if (state.socket) {
-            state.socket.removeEventListener("open", onOpen);
-            state.socket.removeEventListener("message", onMessage);
-            state.socket.removeEventListener("close", onClose);
-            state.socket.removeEventListener("error", onError);
-            state.socket.close();
-            state.socket = null;
-        }
-        updateConnection({ state: "unavailable" });
-        clearTimeout(state.timeoutHandles.pongTimeout);
-        if (state.timeoutHandles.flush) {
-            clearTimeout(state.timeoutHandles.flush);
-        }
-        clearTimeout(state.timeoutHandles.reconnect);
-        clearInterval(state.intervalHandles.heartbeat);
-        connect();
-    }
-    function applyAndSendOfflineOps(offlineOps) {
-        if (offlineOps.size === 0) {
-            return;
-        }
-        const messages = [];
-        const ops = Array.from(offlineOps.values());
-        const result = apply(ops, true);
-        messages.push({
-            type: ClientMessageType.UpdateStorage,
-            ops: ops,
-        });
-        notify(result.updates);
-        effects.send(messages);
-    }
-    function tryFlushing() {
-        const storageOps = state.buffer.storageOperations;
-        if (storageOps.length > 0) {
-            storageOps.forEach((op) => {
-                state.offlineOperations.set(op.opId, op);
-            });
-        }
-        if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
-            state.buffer.storageOperations = [];
-            return;
-        }
-        const now = Date.now();
-        const elapsedTime = now - state.lastFlushTime;
-        if (elapsedTime > context.throttleDelay) {
-            const messages = flushDataToMessages(state);
-            if (messages.length === 0) {
-                return;
-            }
-            effects.send(messages);
-            state.buffer = {
-                messages: [],
-                storageOperations: [],
-                presence: null,
-            };
-            state.lastFlushTime = now;
-        }
-        else {
-            if (state.timeoutHandles.flush != null) {
-                clearTimeout(state.timeoutHandles.flush);
-            }
-            state.timeoutHandles.flush = effects.delayFlush(context.throttleDelay - (now - state.lastFlushTime));
-        }
-    }
-    function flushDataToMessages(state) {
-        const messages = [];
-        if (state.buffer.presence) {
-            messages.push({
-                type: ClientMessageType.UpdatePresence,
-                data: state.buffer.presence,
-            });
-        }
-        for (const event of state.buffer.messages) {
-            messages.push(event);
-        }
-        if (state.buffer.storageOperations.length > 0) {
-            messages.push({
-                type: ClientMessageType.UpdateStorage,
-                ops: state.buffer.storageOperations,
-            });
-        }
-        return messages;
-    }
-    function disconnect() {
-        if (state.socket) {
-            state.socket.removeEventListener("open", onOpen);
-            state.socket.removeEventListener("message", onMessage);
-            state.socket.removeEventListener("close", onClose);
-            state.socket.removeEventListener("error", onError);
-            state.socket.close();
-            state.socket = null;
-        }
-        updateConnection({ state: "closed" });
-        if (state.timeoutHandles.flush) {
-            clearTimeout(state.timeoutHandles.flush);
-        }
-        clearTimeout(state.timeoutHandles.reconnect);
-        clearTimeout(state.timeoutHandles.pongTimeout);
-        clearInterval(state.intervalHandles.heartbeat);
-        state.users = {};
-        notify({ others: [{ type: "reset" }] });
-        clearListeners();
-    }
-    function clearListeners() {
-        for (const key in state.listeners) {
-            state.listeners[key] = [];
-        }
-    }
-    function getPresence() {
-        return state.me;
-    }
-    function getOthers() {
-        return state.others;
-    }
-    function broadcastEvent(event, options = {
-        shouldQueueEventIfNotReady: false,
-    }) {
-        if (state.socket == null && options.shouldQueueEventIfNotReady == false) {
-            return;
-        }
-        state.buffer.messages.push({
-            type: ClientMessageType.ClientEvent,
-            event,
-        });
-        tryFlushing();
-    }
-    function dispatch(ops) {
-        state.buffer.storageOperations.push(...ops);
-        tryFlushing();
-    }
-    let _getInitialStatePromise = null;
-    let _getInitialStateResolver = null;
-    function getStorage() {
-        if (state.root) {
-            return new Promise((resolve) => resolve({
-                root: state.root,
-            }));
-        }
-        if (_getInitialStatePromise == null) {
-            state.buffer.messages.push({ type: ClientMessageType.FetchStorage });
-            tryFlushing();
-            _getInitialStatePromise = new Promise((resolve) => (_getInitialStateResolver = resolve));
-        }
-        return _getInitialStatePromise.then(() => {
-            return {
-                root: state.root,
-            };
-        });
-    }
-    function undo() {
-        if (state.isBatching) {
-            throw new Error("undo is not allowed during a batch");
-        }
-        const historyItem = state.undoStack.pop();
-        if (historyItem == null) {
-            return;
-        }
-        state.isHistoryPaused = false;
-        const result = apply(historyItem, true);
-        notify(result.updates);
-        state.redoStack.push(result.reverse);
-        for (const op of historyItem) {
-            if (op.type !== "presence") {
-                state.buffer.storageOperations.push(op);
-            }
-        }
-        tryFlushing();
-    }
-    function redo() {
-        if (state.isBatching) {
-            throw new Error("redo is not allowed during a batch");
-        }
-        const historyItem = state.redoStack.pop();
-        if (historyItem == null) {
-            return;
-        }
-        state.isHistoryPaused = false;
-        const result = apply(historyItem, true);
-        notify(result.updates);
-        state.undoStack.push(result.reverse);
-        for (const op of historyItem) {
-            if (op.type !== "presence") {
-                state.buffer.storageOperations.push(op);
-            }
-        }
-        tryFlushing();
-    }
-    function batch(callback) {
-        if (state.isBatching) {
-            throw new Error("batch should not be called during a batch");
-        }
-        state.isBatching = true;
-        try {
-            callback();
-        }
-        finally {
-            state.isBatching = false;
-            if (state.batch.reverseOps.length > 0) {
-                addToUndoStack(state.batch.reverseOps);
-            }
-            if (state.batch.ops.length > 0) {
-                // Only clear the redo stack if something has changed during a batch
-                // Clear the redo stack because batch is always called from a local operation
-                state.redoStack = [];
-            }
-            if (state.batch.ops.length > 0) {
-                dispatch(state.batch.ops);
-            }
-            notify(state.batch.updates);
-            state.batch = {
-                ops: [],
-                reverseOps: [],
-                updates: {
-                    others: [],
-                    storageUpdates: new Map(),
-                    presence: false,
-                },
-            };
-            tryFlushing();
-        }
-    }
-    function pauseHistory() {
-        state.pausedHistory = [];
-        state.isHistoryPaused = true;
-    }
-    function resumeHistory() {
-        state.isHistoryPaused = false;
-        if (state.pausedHistory.length > 0) {
-            addToUndoStack(state.pausedHistory);
-        }
-        state.pausedHistory = [];
-    }
-    function simulateSocketClose() {
-        if (state.socket) {
-            state.socket.close();
-        }
-    }
-    function simulateSendCloseEvent(event) {
-        if (state.socket) {
-            onClose(event);
-        }
+    if (item._parent instanceof LiveList) {
+     const previousKey = item._parentKey;
+     return previousKey === op.parentKey ? {
+      modified: !1
+     } : item._parent._setChildKey(op.parentKey, item, previousKey);
     }
     return {
-        // Internal
-        onClose,
-        onMessage,
-        authenticationSuccess,
-        heartbeat,
-        onNavigatorOnline,
-        // Internal dev tools
-        simulateSocketClose,
-        simulateSendCloseEvent,
-        // onWakeUp,
-        onVisibilityChange,
-        getUndoStack: () => state.undoStack,
-        getItemsCount: () => state.items.size,
-        // Core
-        connect,
-        disconnect,
-        subscribe,
-        unsubscribe,
-        // Presence
-        updatePresence,
-        broadcastEvent,
-        batch,
-        undo,
-        redo,
-        pauseHistory,
-        resumeHistory,
-        getStorage,
-        selectors: {
-            // Core
-            getConnectionState,
-            getSelf,
-            // Presence
-            getPresence,
-            getOthers,
-        },
-    };
-}
-function defaultState(me, defaultStorageRoot) {
-    return {
-        connection: { state: "closed" },
-        token: null,
-        lastConnectionId: null,
-        socket: null,
-        listeners: {
-            event: [],
-            others: [],
-            "my-presence": [],
-            error: [],
-            connection: [],
-            storage: [],
-        },
-        numberOfRetry: 0,
-        lastFlushTime: 0,
-        timeoutHandles: {
-            flush: null,
-            reconnect: 0,
-            pongTimeout: 0,
-        },
-        buffer: {
-            presence: me == null ? {} : me,
-            messages: [],
-            storageOperations: [],
-        },
-        intervalHandles: {
-            heartbeat: 0,
-        },
-        me: me == null ? {} : me,
-        users: {},
-        others: makeOthers({}),
-        defaultStorageRoot,
-        idFactory: null,
-        // Storage
-        clock: 0,
-        opClock: 0,
-        items: new Map(),
-        root: undefined,
-        undoStack: [],
-        redoStack: [],
-        isHistoryPaused: false,
-        pausedHistory: [],
-        isBatching: false,
-        batch: {
-            ops: [],
-            updates: {
-                storageUpdates: new Map(),
-                presence: false,
-                others: [],
-            },
-            reverseOps: [],
-        },
-        offlineOperations: new Map(),
+     modified: !1
     };
+   }
+  case OpType.CreateObject:
+  case OpType.CreateList:
+  case OpType.CreateMap:
+  case OpType.CreateRegister:
+   {
+    const parent = state.items.get(op.parentId);
+    return null == parent ? {
+     modified: !1
+    } : parent._attachChild(op, isLocal);
+   }
+  }
+ }
+ function connect() {
+  if ("closed" !== state.connection.state && "unavailable" !== state.connection.state) return null;
+  const 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 room => 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 room => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
+     room: room
+    });
+   }
+   if ("custom" === authentication.type) return authentication.callback;
+   throw new Error("Internal error. Unexpected authentication type");
+  }(context.authentication, 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.");
+   const ws = WebSocketPolyfill || WebSocket;
+   return token => new ws(`${liveblocksServer}/?token=${token}`);
+  }(context.liveblocksServer, context.WebSocketPolyfill);
+  updateConnection({
+   state: "authenticating"
+  }), effects.authenticate(auth, createWebSocket);
+ }
+ 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 = function(connectionId) {
+   let count = 0;
+   return () => `${connectionId}:${count++}`;
+  }(token.actor), state.socket = socket;
+ }
+ function onUpdatePresenceMessage(message) {
+  const user = state.users[message.actor];
+  if (void 0 !== message.targetActor || null == user || user._hasReceivedInitialPresence) return state.users[message.actor] = null == user ? {
+   connectionId: message.actor,
+   presence: message.data,
+   _hasReceivedInitialPresence: !0
+  } : {
+   id: user.id,
+   info: user.info,
+   connectionId: message.actor,
+   presence: Object.assign(Object.assign({}, user.presence), message.data),
+   _hasReceivedInitialPresence: !0
+  }, {
+   type: "update",
+   updates: message.data,
+   user: state.users[message.actor]
+  };
+ }
+ function onUserLeftMessage(message) {
+  const userLeftMessage = message, user = state.users[userLeftMessage.actor];
+  return user ? (delete state.users[userLeftMessage.actor], {
+   type: "leave",
+   user: user
+  }) : null;
+ }
+ function onRoomStateMessage(message) {
+  const newUsers = {};
+  for (const key in message.users) {
+   const connectionId = Number.parseInt(key), user = message.users[key];
+   newUsers[connectionId] = {
+    connectionId: connectionId,
+    info: user.info,
+    id: user.id
+   };
+  }
+  return state.users = newUsers, {
+   type: "reset"
+  };
+ }
+ function onEvent(message) {
+  for (const listener of state.listeners.event) listener({
+   connectionId: message.actor,
+   event: message.event
+  });
+ }
+ 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: ClientMessageType.UpdatePresence,
+   data: state.me,
+   targetActor: message.actor
+  }), tryFlushing()), {
+   type: "enter",
+   user: state.users[message.actor]
+  };
+ }
+ function parseServerMessage(data) {
+  return isJsonObject(data) ? data : null;
+ }
+ function onMessage(event) {
+  if ("pong" === event.data) return void clearTimeout(state.timeoutHandles.pongTimeout);
+  const messages = function(text) {
+   const data = parseJson(text);
+   return void 0 === data ? null : isJsonArray(data) ? compact(data.map((item => parseServerMessage(item)))) : compact([ parseServerMessage(data) ]);
+  }(event.data);
+  if (null === messages || 0 === messages.length) return;
+  const updates = {
+   storageUpdates: new Map,
+   others: []
+  };
+  for (const message of messages) switch (message.type) {
+  case ServerMessageType.UserJoined:
+   updates.others.push(onUserJoinedMessage(message));
+   break;
+  case ServerMessageType.UpdatePresence:
+   {
+    const othersPresenceUpdate = onUpdatePresenceMessage(message);
+    othersPresenceUpdate && updates.others.push(othersPresenceUpdate);
+    break;
+   }
+  case ServerMessageType.Event:
+   onEvent(message);
+   break;
+  case ServerMessageType.UserLeft:
+   {
+    const event = onUserLeftMessage(message);
+    event && updates.others.push(event);
+    break;
+   }
+  case ServerMessageType.RoomState:
+   updates.others.push(onRoomStateMessage(message));
+   break;
+  case ServerMessageType.InitialStorageState:
+   {
+    const offlineOps = new Map(state.offlineOperations);
+    createOrUpdateRootFromMessage(message), applyAndSendOfflineOps(offlineOps), null == _getInitialStateResolver || _getInitialStateResolver();
+    break;
+   }
+  case ServerMessageType.UpdateStorage:
+   apply(message.ops, !1).updates.storageUpdates.forEach(((value, key) => {
+    updates.storageUpdates.set(key, mergeStorageUpdates(updates.storageUpdates.get(key), value));
+   }));
+   break;
+  }
+  notify(updates);
+ }
+ 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"
+   });
+   const error = new LiveblocksError(event.reason, event.code);
+   for (const listener of state.listeners.error) listener(error);
+   const 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 === WebsocketCloseCodes.CLOSE_WITHOUT_RETRY) updateConnection({
+   state: "closed"
+  }); else {
+   const delay = getRetryDelay();
+   state.numberOfRetry++, "production" !== process.env.NODE_ENV && console.warn(`Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`),
+   updateConnection({
+    state: "unavailable"
+   }), state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
+  }
+ }
+ function updateConnection(connection) {
+  state.connection = connection;
+  for (const listener of state.listeners.connection) listener(connection.state);
+ }
+ function getRetryDelay(slow = !1) {
+  return 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(Object.assign(Object.assign({}, 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: ClientMessageType.FetchStorage
+  }), 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) return;
+  const messages = [], ops = Array.from(offlineOps.values()), result = apply(ops, !0);
+  messages.push({
+   type: ClientMessageType.UpdateStorage,
+   ops: ops
+  }), notify(result.updates), effects.send(messages);
+ }
+ function tryFlushing() {
+  const storageOps = state.buffer.storageOperations;
+  if (storageOps.length > 0 && storageOps.forEach((op => {
+   state.offlineOperations.set(op.opId, op);
+  })), null == state.socket || state.socket.readyState !== state.socket.OPEN) return void (state.buffer.storageOperations = []);
+  const now = Date.now();
+  if (now - state.lastFlushTime > context.throttleDelay) {
+   const messages = function(state) {
+    const messages = [];
+    state.buffer.presence && messages.push({
+     type: ClientMessageType.UpdatePresence,
+     data: state.buffer.presence
+    });
+    for (const event of state.buffer.messages) messages.push(event);
+    state.buffer.storageOperations.length > 0 && messages.push({
+     type: ClientMessageType.UpdateStorage,
+     ops: state.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));
+ }
+ function getPresence() {
+  return state.me;
+ }
+ function dispatch(ops) {
+  state.buffer.storageOperations.push(...ops), tryFlushing();
+ }
+ let _getInitialStatePromise = null, _getInitialStateResolver = null;
+ return {
+  onClose: onClose,
+  onMessage: onMessage,
+  authenticationSuccess: authenticationSuccess,
+  heartbeat: heartbeat,
+  onNavigatorOnline: function() {
+   "unavailable" === state.connection.state && reconnect();
+  },
+  simulateSocketClose: function() {
+   state.socket && state.socket.close();
+  },
+  simulateSendCloseEvent: function(event) {
+   state.socket && onClose(event);
+  },
+  onVisibilityChange: function(visibilityState) {
+   "visible" === visibilityState && "open" === state.connection.state && heartbeat();
+  },
+  getUndoStack: () => state.undoStack,
+  getItemsCount: () => 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 (const key in state.listeners) state.listeners[key] = [];
+   }();
+  },
+  subscribe: function(firstParam, listener, options) {
+   if (firstParam instanceof AbstractCrdt) return function(crdt, innerCallback, options) {
+    return genericSubscribe((updates => {
+     const relatedUpdates = [];
+     for (const update of updates) (null == options ? void 0 : options.isDeep) && isSameNodeOrChildOf(update.node, crdt) ? relatedUpdates.push(update) : update.node._id === crdt._id && innerCallback(update.node);
+     (null == options ? void 0 : options.isDeep) && relatedUpdates.length > 0 && innerCallback(relatedUpdates);
+    }));
+   }(firstParam, listener, options);
+   if ("function" == typeof firstParam) return genericSubscribe(firstParam);
+   if (!isValidRoomEventType(firstParam)) throw new Error(`"${firstParam}" is not a valid event name`);
+   return state.listeners[firstParam].push(listener), () => {
+    const callbacks = state.listeners[firstParam];
+    remove(callbacks, listener);
+   };
+  },
+  unsubscribe: function(event, callback) {
+   if (console.warn("unsubscribe is depreacted and will be removed in a future version.\nuse the callback returned by subscribe instead.\nSee v0.13 release notes for more information.\n"),
+   !isValidRoomEventType(event)) throw new Error(`"${event}" is not a valid event name`);
+   const callbacks = state.listeners[event];
+   remove(callbacks, callback);
+  },
+  updatePresence: function(overrides, options) {
+   const oldValues = {};
+   null == state.buffer.presence && (state.buffer.presence = {});
+   for (const key in overrides) state.buffer.presence[key] = overrides[key], oldValues[key] = state.me[key];
+   state.me = Object.assign(Object.assign({}, state.me), overrides), state.isBatching ? ((null == options ? void 0 : options.addToHistory) && state.batch.reverseOps.push({
+    type: "presence",
+    data: oldValues
+   }), state.batch.updates.presence = !0) : (tryFlushing(), (null == options ? void 0 : options.addToHistory) && addToUndoStack([ {
+    type: "presence",
+    data: oldValues
+   } ]), notify({
+    presence: !0
+   }));
+  },
+  broadcastEvent: function(event, options = {
+   shouldQueueEventIfNotReady: !1
+  }) {
+   null == state.socket && 0 == options.shouldQueueEventIfNotReady || (state.buffer.messages.push({
+    type: ClientMessageType.ClientEvent,
+    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");
+   const historyItem = state.undoStack.pop();
+   if (null == historyItem) return;
+   state.isHistoryPaused = !1;
+   const result = apply(historyItem, !0);
+   notify(result.updates), state.redoStack.push(result.reverse);
+   for (const op of historyItem) "presence" !== op.type && state.buffer.storageOperations.push(op);
+   tryFlushing();
+  },
+  redo: function() {
+   if (state.isBatching) throw new Error("redo is not allowed during a batch");
+   const historyItem = state.redoStack.pop();
+   if (null == historyItem) return;
+   state.isHistoryPaused = !1;
+   const result = apply(historyItem, !0);
+   notify(result.updates), state.undoStack.push(result.reverse);
+   for (const op of historyItem) "presence" !== op.type && state.buffer.storageOperations.push(op);
+   tryFlushing();
+  },
+  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((resolve => resolve({
+    root: state.root
+   }))) : (null == _getInitialStatePromise && (state.buffer.messages.push({
+    type: ClientMessageType.FetchStorage
+   }), tryFlushing(), _getInitialStatePromise = new Promise((resolve => _getInitialStateResolver = resolve))),
+   _getInitialStatePromise.then((() => ({
+    root: 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()
+    } : null;
+   },
+   getPresence: getPresence,
+   getOthers: function() {
+    return state.others;
+   }
+  }
+ };
 }
 function createRoom(options, context) {
-    const state = defaultState(options.defaultPresence, options.defaultStorageRoot);
-    const machine = makeStateMachine(state, context);
-    const room = {
-        id: context.roomId,
-        /////////////
-        // Core    //
-        /////////////
-        getConnectionState: machine.selectors.getConnectionState,
-        getSelf: machine.selectors.getSelf,
-        // FIXME: There's a type issue here. The types of subscribe and
-        // machine.subscribe are incompatible somewhere.
-        // TODO: Figure out exactly what's wrong here!
-        subscribe: machine.subscribe,
-        unsubscribe: machine.unsubscribe,
-        //////////////
-        // Presence //
-        //////////////
-        getPresence: machine.selectors.getPresence,
-        updatePresence: machine.updatePresence,
-        getOthers: machine.selectors.getOthers,
-        broadcastEvent: machine.broadcastEvent,
-        getStorage: machine.getStorage,
-        batch: machine.batch,
-        history: {
-            undo: machine.undo,
-            redo: machine.redo,
-            pause: machine.pauseHistory,
-            resume: machine.resumeHistory,
-        },
-        // @ts-ignore
-        internalDevTools: {
-            closeWebsocket: machine.simulateSocketClose,
-            sendCloseEvent: machine.simulateSendCloseEvent,
-        },
-    };
-    return {
-        connect: machine.connect,
-        disconnect: machine.disconnect,
-        onNavigatorOnline: machine.onNavigatorOnline,
-        onVisibilityChange: machine.onVisibilityChange,
-        room,
-    };
+ var _a, _b;
+ const initialPresence = null !== (_a = options.initialPresence) && void 0 !== _a ? _a : options.defaultPresence, initialStorage = null !== (_b = options.initialStorage) && void 0 !== _b ? _b : options.defaultStorageRoot, machine = makeStateMachine(function(initialPresence, initialStorage) {
+  return {
+   connection: {
+    state: "closed"
+   },
+   token: null,
+   lastConnectionId: null,
+   socket: null,
+   listeners: {
+    event: [],
+    others: [],
+    "my-presence": [],
+    error: [],
+    connection: [],
+    storage: []
+   },
+   numberOfRetry: 0,
+   lastFlushTime: 0,
+   timeoutHandles: {
+    flush: null,
+    reconnect: 0,
+    pongTimeout: 0
+   },
+   buffer: {
+    presence: null == initialPresence ? {} : 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: {
+    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,
+  unsubscribe: machine.unsubscribe,
+  getPresence: machine.selectors.getPresence,
+  updatePresence: machine.updatePresence,
+  getOthers: machine.selectors.getOthers,
+  broadcastEvent: machine.broadcastEvent,
+  getStorage: machine.getStorage,
+  batch: machine.batch,
+  history: {
+   undo: machine.undo,
+   redo: machine.redo,
+   pause: machine.pauseHistory,
+   resume: machine.resumeHistory
+  },
+  internalDevTools: {
+   closeWebsocket: machine.simulateSocketClose,
+   sendCloseEvent: machine.simulateSendCloseEvent
+  }
+ };
+ return {
+  connect: machine.connect,
+  disconnect: machine.disconnect,
+  onNavigatorOnline: machine.onNavigatorOnline,
+  onVisibilityChange: machine.onVisibilityChange,
+  room: room
+ };
 }
 class LiveblocksError extends Error {
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-    }
+ constructor(message, code) {
+  super(message), this.code = code;
+ }
 }
 function parseToken(token) {
-    const tokenParts = token.split(".");
-    if (tokenParts.length !== 3) {
-        throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
-    }
-    const data = parseJson(atob(tokenParts[1]));
-    if (data !== undefined &&
-        isJsonObject(data) &&
-        typeof data.actor === "number" &&
-        (data.id === undefined || typeof data.id === "string")) {
-        return {
-            actor: data.actor,
-            id: data.id,
-            info: data.info,
-        };
-    }
-    throw new Error(`Authentication error. Liveblocks could not parse the response of your authentication endpoint`);
-}
-function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
-    if (typeof window === "undefined" && WebSocketPolyfill == null) {
-        throw new Error("To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill.");
-    }
-    const ws = WebSocketPolyfill || WebSocket;
-    return (token) => {
-        return new ws(`${liveblocksServer}/?token=${token}`);
-    };
-}
-function prepareAuthEndpoint(authentication, fetchPolyfill) {
-    if (authentication.type === "public") {
-        if (typeof window === "undefined" && fetchPolyfill == null) {
-            throw new Error("To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill.");
-        }
-        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-            room,
-            publicApiKey: authentication.publicApiKey,
-        });
-    }
-    if (authentication.type === "private") {
-        if (typeof window === "undefined" && fetchPolyfill == null) {
-            throw new Error("To use Liveblocks client in a non-dom environment with a url as auth endpoint, you need to provide a fetch polyfill.");
-        }
-        return (room) => fetchAuthEndpoint(fetchPolyfill || fetch, authentication.url, {
-            room,
-        });
-    }
-    if (authentication.type === "custom") {
-        return authentication.callback;
-    }
-    throw new Error("Internal error. Unexpected authentication type");
+ const tokenParts = token.split(".");
+ if (3 !== tokenParts.length) throw new Error("Authentication error. Liveblocks could not parse the response of your authentication endpoint");
+ const data = parseJson(atob(tokenParts[1]));
+ if (void 0 !== data && isJsonObject(data) && "number" == typeof data.actor && (void 0 === data.id || "string" == typeof data.id)) return {
+  actor: data.actor,
+  id: data.id,
+  info: data.info
+ };
+ throw new Error("Authentication error. Liveblocks could not parse the response of your authentication endpoint");
 }
 function fetchAuthEndpoint(fetch, endpoint, body) {
-    return fetch(endpoint, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-    })
-        .then((res) => {
-        if (!res.ok) {
-            throw new AuthenticationError(`Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`);
-        }
-        return res.json().catch((er) => {
-            throw new AuthenticationError(`Expected a json when doing a POST request on "${endpoint}". ${er}`);
-        });
-    })
-        .then((authResponse) => {
-        if (typeof authResponse.token !== "string") {
-            throw new AuthenticationError(`Expected a json with a string token when doing a POST request on "${endpoint}", but got ${JSON.stringify(authResponse)}`);
-        }
-        return authResponse;
-    });
+ return fetch(endpoint, {
+  method: "POST",
+  headers: {
+   "Content-Type": "application/json"
+  },
+  body: JSON.stringify(body)
+ }).then((res => {
+  if (!res.ok) throw new AuthenticationError(`Expected a status 200 but got ${res.status} when doing a POST request on "${endpoint}"`);
+  return res.json().catch((er => {
+   throw new AuthenticationError(`Expected a json when doing a POST request on "${endpoint}". ${er}`);
+  }));
+ })).then((authResponse => {
+  if ("string" != typeof authResponse.token) throw new AuthenticationError(`Expected a json with a string token when doing a POST request on "${endpoint}", but got ${JSON.stringify(authResponse)}`);
+  return authResponse;
+ }));
 }
 class AuthenticationError extends Error {
-    constructor(message) {
-        super(message);
-    }
+ constructor(message) {
+  super(message);
+ }
 }
-/**
- * Create a client that will be responsible to communicate with liveblocks servers.
- *
- * @example
- * const client = createClient({
- *   authEndpoint: "/api/auth"
- * });
- *
- * // It's also possible to use a function to call your authentication endpoint.
- * // Useful to add additional headers or use an API wrapper (like Firebase functions)
- * const client = createClient({
- *   authEndpoint: async (room) => {
- *     const response = await fetch("/api/auth", {
- *       method: "POST",
- *       headers: {
- *          Authentication: "token",
- *          "Content-Type": "application/json"
- *       },
- *       body: JSON.stringify({ room })
- *     });
- *
- *     return await response.json();
- *   }
- * });
- */
 function createClient(options) {
-    const clientOptions = options;
-    const throttleDelay = getThrottleDelayFromOptions(options);
-    const rooms = new Map();
-    function getRoom(roomId) {
-        const internalRoom = rooms.get(roomId);
-        return internalRoom ? internalRoom.room : null;
-    }
-    function enter(roomId, options = {}) {
-        let internalRoom = rooms.get(roomId);
-        if (internalRoom) {
-            return internalRoom.room;
-        }
-        internalRoom = createRoom({
-            defaultPresence: options.defaultPresence,
-            defaultStorageRoot: options.defaultStorageRoot,
-        }, {
-            roomId,
-            throttleDelay,
-            WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-            fetchPolyfill: clientOptions.fetchPolyfill,
-            liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
-            authentication: prepareAuthentication(clientOptions),
-        });
-        rooms.set(roomId, internalRoom);
-        if (!options.DO_NOT_USE_withoutConnecting) {
-            internalRoom.connect();
-        }
-        return internalRoom.room;
-    }
-    function leave(roomId) {
-        const room = rooms.get(roomId);
-        if (room) {
-            room.disconnect();
-            rooms.delete(roomId);
-        }
-    }
-    if (typeof window !== "undefined") {
-        // TODO: Expose a way to clear these
-        window.addEventListener("online", () => {
-            for (const [, room] of rooms) {
-                room.onNavigatorOnline();
-            }
-        });
-    }
-    if (typeof document !== "undefined") {
-        document.addEventListener("visibilitychange", () => {
-            for (const [, room] of rooms) {
-                room.onVisibilityChange(document.visibilityState);
-            }
-        });
-    }
-    return {
-        getRoom,
-        enter,
-        leave,
-    };
-}
-function getThrottleDelayFromOptions(options) {
-    if (options.throttle === undefined) {
-        return 100;
-    }
-    if (typeof options.throttle !== "number" ||
-        options.throttle < 80 ||
-        options.throttle > 1000) {
-        throw new Error("throttle should be a number between 80 and 1000.");
-    }
-    return options.throttle;
-}
-function prepareAuthentication(clientOptions) {
-    // TODO: throw descriptive errors for invalid options
-    if (typeof clientOptions.publicApiKey === "string") {
-        return {
-            type: "public",
-            publicApiKey: clientOptions.publicApiKey,
-            url: clientOptions.publicAuthorizeEndpoint ||
-                "https://liveblocks.io/api/public/authorize",
-        };
-    }
-    else if (typeof clientOptions.authEndpoint === "string") {
-        return {
-            type: "private",
-            url: clientOptions.authEndpoint,
-        };
-    }
-    else if (typeof clientOptions.authEndpoint === "function") {
-        return {
-            type: "custom",
-            callback: clientOptions.authEndpoint,
-        };
-    }
-    throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
+ const 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 && window.addEventListener("online", (() => {
+  for (const [, room] of rooms) room.onNavigatorOnline();
+ })), "undefined" != typeof document && document.addEventListener("visibilitychange", (() => {
+  for (const [, room] of rooms) room.onVisibilityChange(document.visibilityState);
+ })), {
+  getRoom: function(roomId) {
+   const internalRoom = rooms.get(roomId);
+   return internalRoom ? internalRoom.room : null;
+  },
+  enter: function(roomId, options = {}) {
+   let internalRoom = rooms.get(roomId);
+   return internalRoom || (deprecateIf(options.defaultPresence, "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP", "defaultPresence"),
+   deprecateIf(options.defaultStorageRoot, "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP", "defaultStorageRoot"),
+   internalRoom = createRoom({
+    initialPresence: options.initialPresence,
+    initialStorage: options.initialStorage,
+    defaultPresence: options.defaultPresence,
+    defaultStorageRoot: options.defaultStorageRoot
+   }, {
+    roomId: roomId,
+    throttleDelay: throttleDelay,
+    WebSocketPolyfill: clientOptions.WebSocketPolyfill,
+    fetchPolyfill: clientOptions.fetchPolyfill,
+    liveblocksServer: clientOptions.liveblocksServer || "wss://liveblocks.net/v5",
+    authentication: prepareAuthentication(clientOptions)
+   }), rooms.set(roomId, internalRoom), options.DO_NOT_USE_withoutConnecting || internalRoom.connect()),
+   internalRoom.room;
+  },
+  leave: function(roomId) {
+   const room = rooms.get(roomId);
+   room && (room.disconnect(), rooms.delete(roomId));
+  }
+ };
 }
-function lsonObjectToJson(obj) {
-    const result = {};
-    for (const key in obj) {
-        const val = obj[key];
-        if (val !== undefined) {
-            result[key] = lsonToJson(val);
-        }
-    }
-    return result;
-}
-function liveObjectToJson(liveObject) {
-    return lsonObjectToJson(liveObject.toObject());
-}
-function liveMapToJson(map) {
-    const result = {};
-    for (const [key, value] of map.entries()) {
-        result[key] = lsonToJson(value);
-    }
-    return result;
-}
-function lsonListToJson(value) {
-    return value.map(lsonToJson);
-}
-function liveListToJson(value) {
-    return lsonListToJson(value.toArray());
-}
-function lsonToJson(value) {
-    //                                     ^^^^^^^^^^^^
-    //                                     FIXME: Remove me later. This requires the
-    //                                     addition of a concrete LiveStructure type first.
-    // Check for LiveStructure datastructures first
-    if (value instanceof LiveObject) {
-        return liveObjectToJson(value);
-    }
-    else if (value instanceof LiveList) {
-        return liveListToJson(value);
-    }
-    else if (value instanceof LiveMap) {
-        return liveMapToJson(value);
-    }
-    else if (value instanceof LiveRegister) {
-        return value.data;
-    }
-    else if (value instanceof AbstractCrdt) {
-        // This code path should never be taken
-        throw new Error("Unhandled subclass of AbstractCrdt encountered");
-    }
-    // Then for composite Lson values
-    if (Array.isArray(value)) {
-        return lsonListToJson(value);
-    }
-    else if (isPlainObject(value)) {
-        return lsonObjectToJson(value);
-    }
-    // Finally, if value is an LsonScalar, then it's also a valid JsonScalar
-    return value;
-}
-function isPlainObject(obj) {
-    return (obj !== null && Object.prototype.toString.call(obj) === "[object Object]");
-}
-function anyToCrdt(obj) {
-    //                              ^^^ AbstractCrdt?
-    if (obj == null) {
-        return obj;
-    }
-    if (Array.isArray(obj)) {
-        return new LiveList(obj.map(anyToCrdt));
-    }
-    if (isPlainObject(obj)) {
-        const init = {};
-        for (const key in obj) {
-            init[key] = anyToCrdt(obj[key]);
-        }
-        return new LiveObject(init);
-    }
-    return obj;
-}
-function patchLiveList(liveList, prev, next) {
-    let i = 0;
-    let prevEnd = prev.length - 1;
-    let nextEnd = next.length - 1;
-    let prevNode = prev[0];
-    let nextNode = next[0];
-    /**
-     * For A,B,C => A,B,C,D
-     * i = 3, prevEnd = 2, nextEnd = 3
-     *
-     * For A,B,C => B,C
-     * i = 2, prevEnd = 2, nextEnd = 1
-     *
-     * For B,C => A,B,C
-     * i = 0, pre
-     */
-    outer: {
-        while (prevNode === nextNode) {
-            ++i;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[i];
-            nextNode = next[i];
-        }
-        prevNode = prev[prevEnd];
-        nextNode = next[nextEnd];
-        while (prevNode === nextNode) {
-            prevEnd--;
-            nextEnd--;
-            if (i > prevEnd || i > nextEnd) {
-                break outer;
-            }
-            prevNode = prev[prevEnd];
-            nextNode = next[nextEnd];
-        }
-    }
-    if (i > prevEnd) {
-        if (i <= nextEnd) {
-            while (i <= nextEnd) {
-                liveList.insert(anyToCrdt(next[i]), i);
-                i++;
-            }
-        }
-    }
-    else if (i > nextEnd) {
-        let localI = i;
-        while (localI <= prevEnd) {
-            liveList.delete(i);
-            localI++;
-        }
-    }
-    else {
-        while (i <= prevEnd && i <= nextEnd) {
-            prevNode = prev[i];
-            nextNode = next[i];
-            const liveListNode = liveList.get(i);
-            if (liveListNode instanceof LiveObject &&
-                isPlainObject(prevNode) &&
-                isPlainObject(nextNode)) {
-                patchLiveObject(liveListNode, prevNode, nextNode);
-            }
-            else {
-                liveList.set(i, anyToCrdt(nextNode));
-            }
-            i++;
-        }
-        while (i <= nextEnd) {
-            liveList.insert(anyToCrdt(next[i]), i);
-            i++;
-        }
-        let localI = i;
-        while (localI <= prevEnd) {
-            liveList.delete(i);
-            localI++;
-        }
-    }
-}
-function patchLiveObjectKey(liveObject, key, prev, next) {
-    if (process.env.NODE_ENV !== "production") {
-        const nonSerializableValue = findNonSerializableValue(next);
-        if (nonSerializableValue) {
-            console.error(`New state path: '${nonSerializableValue.path}' value: '${nonSerializableValue.value}' is not serializable.\nOnly serializable value can be synced with Liveblocks.`);
-            return;
-        }
-    }
-    const value = liveObject.get(key);
-    if (next === undefined) {
-        liveObject.delete(key);
-    }
-    else if (value === undefined) {
-        liveObject.set(key, anyToCrdt(next));
-    }
-    else if (prev === next) {
-        return;
-    }
-    else if (value instanceof LiveList &&
-        Array.isArray(prev) &&
-        Array.isArray(next)) {
-        patchLiveList(value, prev, next);
-    }
-    else if (value instanceof LiveObject &&
-        isPlainObject(prev) &&
-        isPlainObject(next)) {
-        patchLiveObject(value, prev, next);
-    }
-    else {
-        liveObject.set(key, anyToCrdt(next));
-    }
-}
-function patchLiveObject(root, prev, next) {
-    const updates = {};
-    for (const key in next) {
-        patchLiveObjectKey(root, key, prev[key], next[key]);
-    }
-    for (const key in prev) {
-        if (next[key] === undefined) {
-            root.delete(key);
-        }
-    }
-    if (Object.keys(updates).length > 0) {
-        root.update(updates);
-    }
-}
-function getParentsPath(node) {
-    const path = [];
-    while (node._parentKey != null && node._parent != null) {
-        if (node._parent instanceof LiveList) {
-            path.push(node._parent._indexOfPosition(node._parentKey));
-        }
-        else {
-            path.push(node._parentKey);
-        }
-        node = node._parent;
-    }
-    return path;
-}
-function patchImmutableObject(state, updates) {
-    return updates.reduce((state, update) => patchImmutableObjectWithUpdate(state, update), state);
-}
-function patchImmutableObjectWithUpdate(state, update) {
-    const path = getParentsPath(update.node);
-    return patchImmutableNode(state, path, update);
-}
-function patchImmutableNode(state, path, update) {
-    var _a, _b, _c, _d;
-    const pathItem = path.pop();
-    if (pathItem === undefined) {
-        switch (update.type) {
-            case "LiveObject": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveObject but state was not an object");
-                }
-                const newState = Object.assign({}, state);
-                for (const key in update.updates) {
-                    if (((_a = update.updates[key]) === null || _a === void 0 ? void 0 : _a.type) === "update") {
-                        const val = update.node.get(key);
-                        if (val !== undefined) {
-                            newState[key] = lsonToJson(val);
-                        }
-                    }
-                    else if (((_b = update.updates[key]) === null || _b === void 0 ? void 0 : _b.type) === "delete") {
-                        delete newState[key];
-                    }
-                }
-                return newState;
-            }
-            case "LiveList": {
-                if (Array.isArray(state) === false) {
-                    throw new Error("Internal: received update on LiveList but state was not an array");
-                }
-                let newState = state.map((x) => x);
-                for (const listUpdate of update.updates) {
-                    if (listUpdate.type === "set") {
-                        newState = newState.map((item, index) => index === listUpdate.index ? listUpdate.item : item);
-                    }
-                    else if (listUpdate.type === "insert") {
-                        if (listUpdate.index === newState.length) {
-                            newState.push(lsonToJson(listUpdate.item));
-                        }
-                        else {
-                            newState = [
-                                ...newState.slice(0, listUpdate.index),
-                                lsonToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index),
-                            ];
-                        }
-                    }
-                    else if (listUpdate.type === "delete") {
-                        newState.splice(listUpdate.index, 1);
-                    }
-                    else if (listUpdate.type === "move") {
-                        if (listUpdate.previousIndex > listUpdate.index) {
-                            newState = [
-                                ...newState.slice(0, listUpdate.index),
-                                lsonToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index, listUpdate.previousIndex),
-                                ...newState.slice(listUpdate.previousIndex + 1),
-                            ];
-                        }
-                        else {
-                            newState = [
-                                ...newState.slice(0, listUpdate.previousIndex),
-                                ...newState.slice(listUpdate.previousIndex + 1, listUpdate.index + 1),
-                                lsonToJson(listUpdate.item),
-                                ...newState.slice(listUpdate.index + 1),
-                            ];
-                        }
-                    }
-                }
-                return newState;
-            }
-            case "LiveMap": {
-                if (typeof state !== "object") {
-                    throw new Error("Internal: received update on LiveMap but state was not an object");
-                }
-                const newState = Object.assign({}, state);
-                for (const key in update.updates) {
-                    if (((_c = update.updates[key]) === null || _c === void 0 ? void 0 : _c.type) === "update") {
-                        newState[key] = lsonToJson(update.node.get(key));
-                    }
-                    else if (((_d = update.updates[key]) === null || _d === void 0 ? void 0 : _d.type) === "delete") {
-                        delete newState[key];
-                    }
-                }
-                return newState;
-            }
-        }
-    }
-    if (Array.isArray(state)) {
-        const newArray = [...state];
-        newArray[pathItem] = patchImmutableNode(state[pathItem], path, update);
-        return newArray;
-    }
-    else {
-        return Object.assign(Object.assign({}, state), { [pathItem]: patchImmutableNode(state[pathItem], path, update) });
-    }
+function prepareAuthentication(clientOptions) {
+ if ("string" == typeof clientOptions.publicApiKey) return {
+  type: "public",
+  publicApiKey: clientOptions.publicApiKey,
+  url: clientOptions.publicAuthorizeEndpoint || "https://liveblocks.io/api/public/authorize"
+ };
+ if ("string" == typeof clientOptions.authEndpoint) return {
+  type: "private",
+  url: clientOptions.authEndpoint
+ };
+ if ("function" == typeof clientOptions.authEndpoint) return {
+  type: "custom",
+  callback: clientOptions.authEndpoint
+ };
+ throw new Error("Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient");
 }
-/**
- * @internal
- */
-const internals = {
-    liveObjectToJson,
-    lsonToJson,
-    patchLiveList,
-    patchImmutableObject,
-    patchLiveObject,
-    patchLiveObjectKey,
-};
-export { createClient, internals };
+export { createClient };