@liveblocks/client 0.17.11-debug2 → 0.18.0-beta1

package/index.mjs

@@ -1,1364 +1,8 @@
-import {
-  LiveList,
-  LiveMap,
-  LiveObject,
-  compact,
-  errorIf,
-  getTreesDiffOperations,
-  isJsonArray,
-  isJsonObject,
-  isLiveList,
-  isLiveNode,
-  isPlainObject,
-  isRoomEventName,
-  isRootCrdt,
-  isSameNodeOrChildOf,
-  isTokenExpired,
-  mergeStorageUpdates,
-  nn,
-  parseRoomAuthToken,
-  remove,
-  tryParseJson
-} from "./chunk-ATVOU6HF.mjs";
+import mod from "./index.js";
 
-// src/room.ts
-var BACKOFF_RETRY_DELAYS = [250, 500, 1e3, 2e3, 4e3, 8e3, 1e4];
-var BACKOFF_RETRY_DELAYS_SLOW = [2e3, 3e4, 6e4, 3e5];
-var HEARTBEAT_INTERVAL = 3e4;
-var PONG_TIMEOUT = 2e3;
-function makeIdFactory(connectionId) {
-  let count = 0;
-  return () => `${connectionId}:${count++}`;
-}
-function makeOthers(userMap) {
-  const users = Object.values(userMap).map((user) => {
-    const { _hasReceivedInitialPresence, ...publicKeys } = user;
-    return publicKeys;
-  });
-  return {
-    get count() {
-      return users.length;
-    },
-    [Symbol.iterator]() {
-      return users[Symbol.iterator]();
-    },
-    map(callback) {
-      return users.map(callback);
-    },
-    toArray() {
-      return users;
-    }
-  };
-}
-function log(..._params) {
-  return;
-}
-function makeStateMachine(state, context, mockedEffects) {
-  const effects = mockedEffects || {
-    authenticate(auth, createWebSocket) {
-      const rawToken = state.token;
-      const parsedToken = rawToken !== null && parseRoomAuthToken(rawToken);
-      if (parsedToken && !isTokenExpired(parsedToken)) {
-        const socket = createWebSocket(rawToken);
-        authenticationSuccess(parsedToken, socket);
-      } else {
-        return auth(context.roomId).then(({ token }) => {
-          if (state.connection.state !== "authenticating") {
-            return;
-          }
-          const parsedToken2 = parseRoomAuthToken(token);
-          const socket = createWebSocket(token);
-          authenticationSuccess(parsedToken2, socket);
-          state.token = token;
-        }).catch(
-          (er) => authenticationFailure(
-            er instanceof Error ? er : new Error(String(er))
-          )
-        );
-      }
-    },
-    send(messageOrMessages) {
-      if (state.socket == null) {
-        throw new Error("Can't send message if socket is null");
-      }
-      state.socket.send(JSON.stringify(messageOrMessages));
-    },
-    delayFlush(delay) {
-      return setTimeout(tryFlushing, delay);
-    },
-    startHeartbeatInterval() {
-      return setInterval(heartbeat, HEARTBEAT_INTERVAL);
-    },
-    schedulePongTimeout() {
-      return setTimeout(pongTimeout, PONG_TIMEOUT);
-    },
-    scheduleReconnect(delay) {
-      return setTimeout(connect, delay);
-    }
-  };
-  function genericSubscribe(callback) {
-    state.listeners.storage.push(callback);
-    return () => remove(state.listeners.storage, callback);
-  }
-  function subscribeToLiveStructureDeeply(node, callback) {
-    return genericSubscribe((updates) => {
-      const relatedUpdates = updates.filter(
-        (update) => isSameNodeOrChildOf(update.node, node)
-      );
-      if (relatedUpdates.length > 0) {
-        callback(relatedUpdates);
-      }
-    });
-  }
-  function subscribeToLiveStructureShallowly(node, callback) {
-    return genericSubscribe((updates) => {
-      for (const update of updates) {
-        if (update.node._id === node._id) {
-          callback(update.node);
-        }
-      }
-    });
-  }
-  function createOrUpdateRootFromMessage(message) {
-    if (message.items.length === 0) {
-      throw new Error("Internal error: cannot load storage without items");
-    }
-    if (state.root) {
-      updateRoot(message.items);
-    } else {
-      state.root = load(message.items);
-    }
-    for (const key in state.defaultStorageRoot) {
-      if (state.root.get(key) == null) {
-        state.root.set(key, state.defaultStorageRoot[key]);
-      }
-    }
-  }
-  function buildRootAndParentToChildren(items) {
-    const parentToChildren = /* @__PURE__ */ new Map();
-    let root = null;
-    for (const [id, crdt] of items) {
-      if (isRootCrdt(crdt)) {
-        root = [id, crdt];
-      } else {
-        const tuple = [id, crdt];
-        const children = parentToChildren.get(crdt.parentId);
-        if (children != null) {
-          children.push(tuple);
-        } else {
-          parentToChildren.set(crdt.parentId, [tuple]);
-        }
-      }
-    }
-    if (root == null) {
-      throw new Error("Root can't be null");
-    }
-    return [root, parentToChildren];
-  }
-  function updateRoot(items) {
-    if (!state.root) {
-      return;
-    }
-    const currentItems = /* @__PURE__ */ new Map();
-    state.items.forEach((liveCrdt, id) => {
-      currentItems.set(id, liveCrdt._toSerializedCrdt());
-    });
-    const ops = getTreesDiffOperations(currentItems, new Map(items));
-    const result = apply(ops, false);
-    notify(result.updates);
-  }
-  function load(items) {
-    const [root, parentToChildren] = buildRootAndParentToChildren(items);
-    return LiveObject._deserialize(root, parentToChildren, {
-      getItem,
-      addItem,
-      deleteItem,
-      generateId,
-      generateOpId,
-      dispatch: storageDispatch,
-      roomId: context.roomId
-    });
-  }
-  function addItem(id, liveItem) {
-    state.items.set(id, liveItem);
-  }
-  function deleteItem(id) {
-    state.items.delete(id);
-  }
-  function getItem(id) {
-    return state.items.get(id);
-  }
-  function addToUndoStack(historyItem) {
-    if (state.undoStack.length >= 50) {
-      state.undoStack.shift();
-    }
-    if (state.isHistoryPaused) {
-      state.pausedHistory.unshift(...historyItem);
-    } else {
-      state.undoStack.push(historyItem);
-      onHistoryChange();
-    }
-  }
-  function storageDispatch(ops, reverse, storageUpdates) {
-    if (state.isBatching) {
-      state.batch.ops.push(...ops);
-      storageUpdates.forEach((value, key) => {
-        state.batch.updates.storageUpdates.set(
-          key,
-          mergeStorageUpdates(
-            state.batch.updates.storageUpdates.get(key),
-            value
-          )
-        );
-      });
-      state.batch.reverseOps.push(...reverse);
-    } else {
-      addToUndoStack(reverse);
-      state.redoStack = [];
-      dispatch(ops);
-      notify({ storageUpdates });
-    }
-  }
-  function notify({
-    storageUpdates = /* @__PURE__ */ new Map(),
-    presence = false,
-    others: otherEvents = []
-  }) {
-    if (otherEvents.length > 0) {
-      state.others = makeOthers(state.users);
-      for (const event of otherEvents) {
-        for (const listener of state.listeners.others) {
-          listener(state.others, event);
-        }
-      }
-    }
-    if (presence) {
-      for (const listener of state.listeners["my-presence"]) {
-        listener(state.me);
-      }
-    }
-    if (storageUpdates.size > 0) {
-      for (const subscriber of state.listeners.storage) {
-        subscriber(Array.from(storageUpdates.values()));
-      }
-    }
-  }
-  function getConnectionId() {
-    if (state.connection.state === "open" || state.connection.state === "connecting") {
-      return state.connection.id;
-    } else if (state.lastConnectionId !== null) {
-      return state.lastConnectionId;
-    }
-    throw new Error(
-      "Internal. Tried to get connection id but connection was never open"
-    );
-  }
-  function generateId() {
-    return `${getConnectionId()}:${state.clock++}`;
-  }
-  function generateOpId() {
-    return `${getConnectionId()}:${state.opClock++}`;
-  }
-  function apply(item, isLocal) {
-    const result = {
-      reverse: [],
-      updates: {
-        storageUpdates: /* @__PURE__ */ new Map(),
-        presence: false
-      }
-    };
-    const createdNodeIds = /* @__PURE__ */ new Set();
-    for (const op of item) {
-      if (op.type === "presence") {
-        const reverse = {
-          type: "presence",
-          data: {}
-        };
-        for (const key in op.data) {
-          reverse.data[key] = state.me[key];
-        }
-        state.me = { ...state.me, ...op.data };
-        if (state.buffer.presence == null) {
-          state.buffer.presence = { type: "partial", data: op.data };
-        } else {
-          for (const key in op.data) {
-            state.buffer.presence.data[key] = op.data[key];
-          }
-        }
-        result.reverse.unshift(reverse);
-        result.updates.presence = true;
-      } else {
-        let source;
-        if (!op.opId) {
-          op.opId = generateOpId();
-        }
-        if (isLocal) {
-          source = 0 /* UNDOREDO_RECONNECT */;
-        } else {
-          const deleted = state.offlineOperations.delete(nn(op.opId));
-          source = deleted ? 2 /* ACK */ : 1 /* REMOTE */;
-        }
-        const applyOpResult = applyOp(op, source);
-        if (applyOpResult.modified) {
-          const parentId = applyOpResult.modified.node.parent.type === "HasParent" ? nn(
-            applyOpResult.modified.node.parent.node._id,
-            "Expected parent node to have an ID"
-          ) : void 0;
-          if (!parentId || !createdNodeIds.has(parentId)) {
-            result.updates.storageUpdates.set(
-              nn(applyOpResult.modified.node._id),
-              mergeStorageUpdates(
-                result.updates.storageUpdates.get(
-                  nn(applyOpResult.modified.node._id)
-                ),
-                applyOpResult.modified
-              )
-            );
-            result.reverse.unshift(...applyOpResult.reverse);
-          }
-          if (op.type === 2 /* CREATE_LIST */ || op.type === 7 /* CREATE_MAP */ || op.type === 4 /* CREATE_OBJECT */) {
-            createdNodeIds.add(nn(applyOpResult.modified.node._id));
-          }
-        }
-      }
-    }
-    return result;
-  }
-  function applyOp(op, source) {
-    switch (op.type) {
-      case 6 /* DELETE_OBJECT_KEY */:
-      case 3 /* UPDATE_OBJECT */:
-      case 5 /* DELETE_CRDT */: {
-        const item = state.items.get(op.id);
-        if (item == null) {
-          return { modified: false };
-        }
-        return item._apply(op, source === 0 /* UNDOREDO_RECONNECT */);
-      }
-      case 1 /* SET_PARENT_KEY */: {
-        const item = state.items.get(op.id);
-        if (item == null) {
-          return { modified: false };
-        }
-        if (item.parent.type === "HasParent" && isLiveList(item.parent.node)) {
-          return item.parent.node._setChildKey(op.parentKey, item, source);
-        }
-        return { modified: false };
-      }
-      case 4 /* CREATE_OBJECT */:
-      case 2 /* CREATE_LIST */:
-      case 7 /* CREATE_MAP */:
-      case 8 /* CREATE_REGISTER */: {
-        if (op.parentId === void 0) {
-          return { modified: false };
-        }
-        const parent = state.items.get(op.parentId);
-        if (parent == null) {
-          return { modified: false };
-        }
-        return parent._attachChild(op, source);
-      }
-    }
-  }
-  function subscribe(first, second, options) {
-    if (second === void 0 || typeof first === "function") {
-      if (typeof first === "function") {
-        const storageCallback = first;
-        return genericSubscribe(storageCallback);
-      } else {
-        throw new Error("Please specify a listener callback");
-      }
-    }
-    if (isLiveNode(first)) {
-      const node = first;
-      if (options?.isDeep) {
-        const storageCallback = second;
-        return subscribeToLiveStructureDeeply(node, storageCallback);
-      } else {
-        const nodeCallback = second;
-        return subscribeToLiveStructureShallowly(node, nodeCallback);
-      }
-    }
-    if (!isRoomEventName(first)) {
-      throw new Error(`"${first}" is not a valid event name`);
-    }
-    const eventName = first;
-    const eventListener = second;
-    state.listeners[eventName].push(eventListener);
-    return () => {
-      const callbacks = state.listeners[eventName];
-      remove(callbacks, eventListener);
-    };
-  }
-  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.polyfills?.fetch ?? context.fetchPolyfill
-    );
-    const createWebSocket = prepareCreateWebSocket(
-      context.liveblocksServer,
-      context.polyfills?.WebSocket ?? context.WebSocketPolyfill
-    );
-    updateConnection({ state: "authenticating" });
-    effects.authenticate(auth, createWebSocket);
-  }
-  function updatePresence(overrides, options) {
-    const oldValues = {};
-    if (state.buffer.presence == null) {
-      state.buffer.presence = {
-        type: "partial",
-        data: {}
-      };
-    }
-    for (const key in overrides) {
-      const overrideValue = overrides[key];
-      if (overrideValue === void 0) {
-        continue;
-      }
-      state.buffer.presence.data[key] = overrideValue;
-      oldValues[key] = state.me[key];
-    }
-    state.me = { ...state.me, ...overrides };
-    if (state.isBatching) {
-      if (options?.addToHistory) {
-        state.batch.reverseOps.push({ type: "presence", data: oldValues });
-      }
-      state.batch.updates.presence = true;
-    } else {
-      tryFlushing();
-      if (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") {
-      log("Heartbeat after visibility change");
-      heartbeat();
-    }
-  }
-  function onUpdatePresenceMessage(message) {
-    const user = state.users[message.actor];
-    if (message.targetActor === void 0 && user != null && !user._hasReceivedInitialPresence) {
-      return void 0;
-    }
-    if (user == null) {
-      state.users[message.actor] = {
-        connectionId: message.actor,
-        presence: message.data,
-        id: void 0,
-        info: void 0,
-        _hasReceivedInitialPresence: true
-      };
-    } else {
-      state.users[message.actor] = {
-        id: user.id,
-        info: user.info,
-        connectionId: message.actor,
-        presence: {
-          ...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") {
-      log("Try to reconnect after connectivity change");
-      reconnect();
-    }
-  }
-  function onEvent(message) {
-    for (const listener of state.listeners.event) {
-      listener({ connectionId: message.actor, event: message.event });
-    }
-  }
-  function onHistoryChange() {
-    for (const listener of state.listeners.history) {
-      listener({ canUndo: canUndo(), canRedo: canRedo() });
-    }
-  }
-  function onUserJoinedMessage(message) {
-    state.users[message.actor] = {
-      connectionId: message.actor,
-      info: message.info,
-      id: message.id,
-      _hasReceivedInitialPresence: true
-    };
-    if (state.me) {
-      state.buffer.messages.push({
-        type: 100 /* UPDATE_PRESENCE */,
-        data: state.me,
-        targetActor: message.actor
-      });
-      tryFlushing();
-    }
-    return { type: "enter", user: state.users[message.actor] };
-  }
-  function parseServerMessage(data) {
-    if (!isJsonObject(data)) {
-      return null;
-    }
-    return data;
-  }
-  function parseServerMessages(text) {
-    const data = tryParseJson(text);
-    if (data === void 0) {
-      return null;
-    } else if (isJsonArray(data)) {
-      return compact(data.map((item) => parseServerMessage(item)));
-    } else {
-      return compact([parseServerMessage(data)]);
-    }
-  }
-  function onMessage(event) {
-    if (event.data === "pong") {
-      clearTimeout(state.timeoutHandles.pongTimeout);
-      return;
-    }
-    const messages = parseServerMessages(event.data);
-    if (messages === null || messages.length === 0) {
-      return;
-    }
-    const updates = {
-      storageUpdates: /* @__PURE__ */ new Map(),
-      others: []
-    };
-    for (const message of messages) {
-      switch (message.type) {
-        case 101 /* USER_JOINED */: {
-          updates.others.push(onUserJoinedMessage(message));
-          break;
-        }
-        case 100 /* UPDATE_PRESENCE */: {
-          const othersPresenceUpdate = onUpdatePresenceMessage(message);
-          if (othersPresenceUpdate) {
-            updates.others.push(othersPresenceUpdate);
-          }
-          break;
-        }
-        case 103 /* BROADCASTED_EVENT */: {
-          onEvent(message);
-          break;
-        }
-        case 102 /* USER_LEFT */: {
-          const event2 = onUserLeftMessage(message);
-          if (event2) {
-            updates.others.push(event2);
-          }
-          break;
-        }
-        case 104 /* ROOM_STATE */: {
-          updates.others.push(onRoomStateMessage(message));
-          break;
-        }
-        case 200 /* INITIAL_STORAGE_STATE */: {
-          const offlineOps = new Map(state.offlineOperations);
-          createOrUpdateRootFromMessage(message);
-          applyAndSendOfflineOps(offlineOps);
-          _getInitialStateResolver?.();
-          break;
-        }
-        case 201 /* UPDATE_STORAGE */: {
-          const applyResult = apply(message.ops, false);
-          applyResult.updates.storageUpdates.forEach((value, key) => {
-            updates.storageUpdates.set(
-              key,
-              mergeStorageUpdates(
-                updates.storageUpdates.get(key),
-                value
-              )
-            );
-          });
-          break;
-        }
-      }
-    }
-    notify(updates);
-  }
-  function onClose(event) {
-    state.socket = null;
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    clearInterval(state.intervalHandles.heartbeat);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    state.users = {};
-    notify({ others: [{ type: "reset" }] });
-    if (event.code >= 4e3 && event.code <= 4100) {
-      updateConnection({ state: "failed" });
-      const error = new LiveblocksError(event.reason, event.code);
-      for (const listener of state.listeners.error) {
-        listener(error);
-      }
-      const delay = getRetryDelay(true);
-      state.numberOfRetry++;
-      if (process.env.NODE_ENV !== "production") {
-        console.error(
-          `Connection to Liveblocks websocket server closed. Reason: ${error.message} (code: ${error.code}). Retrying in ${delay}ms.`
-        );
-      }
-      updateConnection({ state: "unavailable" });
-      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-    } else if (event.code === 4999 /* CLOSE_WITHOUT_RETRY */) {
-      updateConnection({ state: "closed" });
-    } else {
-      const delay = getRetryDelay();
-      state.numberOfRetry++;
-      if (process.env.NODE_ENV !== "production") {
-        console.warn(
-          `Connection to Liveblocks websocket server closed (code: ${event.code}). Retrying in ${delay}ms.`
-        );
-      }
-      updateConnection({ state: "unavailable" });
-      state.timeoutHandles.reconnect = effects.scheduleReconnect(delay);
-    }
-  }
-  function updateConnection(connection) {
-    state.connection = 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({ ...state.connection, state: "open" });
-      state.numberOfRetry = 0;
-      if (state.lastConnectionId !== void 0) {
-        state.buffer.presence = {
-          type: "full",
-          data: state.me
-        };
-        tryFlushing();
-      }
-      state.lastConnectionId = state.connection.id;
-      if (state.root) {
-        state.buffer.messages.push({ type: 200 /* FETCH_STORAGE */ });
-      }
-      tryFlushing();
-    } else {
-    }
-  }
-  function heartbeat() {
-    if (state.socket == null) {
-      return;
-    }
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    state.timeoutHandles.pongTimeout = effects.schedulePongTimeout();
-    if (state.socket.readyState === state.socket.OPEN) {
-      state.socket.send("ping");
-    }
-  }
-  function pongTimeout() {
-    log("Pong timeout. Trying to reconnect.");
-    reconnect();
-  }
-  function reconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
-    }
-    updateConnection({ state: "unavailable" });
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    clearInterval(state.intervalHandles.heartbeat);
-    connect();
-  }
-  function applyAndSendOfflineOps(offlineOps) {
-    if (offlineOps.size === 0) {
-      return;
-    }
-    const messages = [];
-    const ops = Array.from(offlineOps.values());
-    const result = apply(ops, true);
-    messages.push({
-      type: 201 /* UPDATE_STORAGE */,
-      ops
-    });
-    notify(result.updates);
-    effects.send(messages);
-  }
-  function tryFlushing() {
-    const storageOps = state.buffer.storageOperations;
-    if (storageOps.length > 0) {
-      storageOps.forEach((op) => {
-        state.offlineOperations.set(nn(op.opId), op);
-      });
-    }
-    if (state.socket == null || state.socket.readyState !== state.socket.OPEN) {
-      state.buffer.storageOperations = [];
-      return;
-    }
-    const now = Date.now();
-    const elapsedTime = now - state.lastFlushTime;
-    if (elapsedTime > context.throttleDelay) {
-      const messages = flushDataToMessages(state);
-      if (messages.length === 0) {
-        return;
-      }
-      effects.send(messages);
-      state.buffer = {
-        messages: [],
-        storageOperations: [],
-        presence: null
-      };
-      state.lastFlushTime = now;
-    } else {
-      if (state.timeoutHandles.flush != null) {
-        clearTimeout(state.timeoutHandles.flush);
-      }
-      state.timeoutHandles.flush = effects.delayFlush(
-        context.throttleDelay - (now - state.lastFlushTime)
-      );
-    }
-  }
-  function flushDataToMessages(state2) {
-    const messages = [];
-    if (state2.buffer.presence) {
-      messages.push(
-        state2.buffer.presence.type === "full" ? {
-          type: 100 /* UPDATE_PRESENCE */,
-          targetActor: -1,
-          data: state2.buffer.presence.data
-        } : {
-          type: 100 /* UPDATE_PRESENCE */,
-          data: state2.buffer.presence.data
-        }
-      );
-    }
-    for (const event of state2.buffer.messages) {
-      messages.push(event);
-    }
-    if (state2.buffer.storageOperations.length > 0) {
-      messages.push({
-        type: 201 /* UPDATE_STORAGE */,
-        ops: state2.buffer.storageOperations
-      });
-    }
-    return messages;
-  }
-  function disconnect() {
-    if (state.socket) {
-      state.socket.removeEventListener("open", onOpen);
-      state.socket.removeEventListener("message", onMessage);
-      state.socket.removeEventListener("close", onClose);
-      state.socket.removeEventListener("error", onError);
-      state.socket.close();
-      state.socket = null;
-    }
-    updateConnection({ state: "closed" });
-    if (state.timeoutHandles.flush) {
-      clearTimeout(state.timeoutHandles.flush);
-    }
-    clearTimeout(state.timeoutHandles.reconnect);
-    clearTimeout(state.timeoutHandles.pongTimeout);
-    clearInterval(state.intervalHandles.heartbeat);
-    state.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: 103 /* BROADCAST_EVENT */,
-      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: 200 /* FETCH_STORAGE */ });
-      tryFlushing();
-      _getInitialStatePromise = new Promise(
-        (resolve) => _getInitialStateResolver = resolve
-      );
-    }
-    return _getInitialStatePromise.then(() => {
-      return {
-        root: nn(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);
-    onHistoryChange();
-    for (const op of historyItem) {
-      if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
-      }
-    }
-    tryFlushing();
-  }
-  function canUndo() {
-    return state.undoStack.length > 0;
-  }
-  function redo() {
-    if (state.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);
-    onHistoryChange();
-    for (const op of historyItem) {
-      if (op.type !== "presence") {
-        state.buffer.storageOperations.push(op);
-      }
-    }
-    tryFlushing();
-  }
-  function canRedo() {
-    return state.redoStack.length > 0;
-  }
-  function batch(callback) {
-    if (state.isBatching) {
-      throw new Error("batch should not be called during a batch");
-    }
-    state.isBatching = true;
-    try {
-      callback();
-    } finally {
-      state.isBatching = false;
-      if (state.batch.reverseOps.length > 0) {
-        addToUndoStack(state.batch.reverseOps);
-      }
-      if (state.batch.ops.length > 0) {
-        state.redoStack = [];
-      }
-      if (state.batch.ops.length > 0) {
-        dispatch(state.batch.ops);
-      }
-      notify(state.batch.updates);
-      state.batch = {
-        ops: [],
-        reverseOps: [],
-        updates: {
-          others: [],
-          storageUpdates: /* @__PURE__ */ new Map(),
-          presence: false
-        }
-      };
-      tryFlushing();
-    }
-  }
-  function pauseHistory() {
-    state.pausedHistory = [];
-    state.isHistoryPaused = true;
-  }
-  function resumeHistory() {
-    state.isHistoryPaused = false;
-    if (state.pausedHistory.length > 0) {
-      addToUndoStack(state.pausedHistory);
-    }
-    state.pausedHistory = [];
-  }
-  function simulateSocketClose() {
-    if (state.socket) {
-      state.socket = null;
-    }
-  }
-  function simulateSendCloseEvent(event) {
-    onClose(event);
-  }
-  return {
-    onClose,
-    onMessage,
-    authenticationSuccess,
-    heartbeat,
-    onNavigatorOnline,
-    simulateSocketClose,
-    simulateSendCloseEvent,
-    onVisibilityChange,
-    getUndoStack: () => state.undoStack,
-    getItemsCount: () => state.items.size,
-    connect,
-    disconnect,
-    subscribe,
-    updatePresence,
-    broadcastEvent,
-    batch,
-    undo,
-    redo,
-    canUndo,
-    canRedo,
-    pauseHistory,
-    resumeHistory,
-    getStorage,
-    selectors: {
-      getConnectionState,
-      getSelf,
-      getPresence,
-      getOthers
-    }
-  };
-}
-function defaultState(initialPresence, initialStorage) {
-  return {
-    connection: { state: "closed" },
-    token: null,
-    lastConnectionId: null,
-    socket: null,
-    listeners: {
-      event: [],
-      others: [],
-      "my-presence": [],
-      error: [],
-      connection: [],
-      storage: [],
-      history: []
-    },
-    numberOfRetry: 0,
-    lastFlushTime: 0,
-    timeoutHandles: {
-      flush: null,
-      reconnect: 0,
-      pongTimeout: 0
-    },
-    buffer: {
-      presence: {
-        type: "full",
-        data: initialPresence == null ? {} : initialPresence
-      },
-      messages: [],
-      storageOperations: []
-    },
-    intervalHandles: {
-      heartbeat: 0
-    },
-    me: initialPresence == null ? {} : initialPresence,
-    users: {},
-    others: makeOthers({}),
-    defaultStorageRoot: initialStorage,
-    idFactory: null,
-    clock: 0,
-    opClock: 0,
-    items: /* @__PURE__ */ new Map(),
-    root: void 0,
-    undoStack: [],
-    redoStack: [],
-    isHistoryPaused: false,
-    pausedHistory: [],
-    isBatching: false,
-    batch: {
-      ops: [],
-      updates: {
-        storageUpdates: /* @__PURE__ */ new Map(),
-        presence: false,
-        others: []
-      },
-      reverseOps: []
-    },
-    offlineOperations: /* @__PURE__ */ new Map()
-  };
-}
-function createRoom(options, context) {
-  const initialPresence = options.initialPresence ?? options.defaultPresence;
-  const initialStorage = options.initialStorage ?? options.defaultStorageRoot;
-  const state = defaultState(
-    typeof initialPresence === "function" ? initialPresence(context.roomId) : initialPresence,
-    typeof initialStorage === "function" ? initialStorage(context.roomId) : initialStorage
-  );
-  const machine = makeStateMachine(
-    state,
-    context
-  );
-  const room = {
-    id: context.roomId,
-    getConnectionState: machine.selectors.getConnectionState,
-    getSelf: machine.selectors.getSelf,
-    subscribe: machine.subscribe,
-    getPresence: machine.selectors.getPresence,
-    updatePresence: machine.updatePresence,
-    getOthers: machine.selectors.getOthers,
-    broadcastEvent: machine.broadcastEvent,
-    getStorage: machine.getStorage,
-    batch: machine.batch,
-    history: {
-      undo: machine.undo,
-      redo: machine.redo,
-      canUndo: machine.canUndo,
-      canRedo: machine.canRedo,
-      pause: machine.pauseHistory,
-      resume: machine.resumeHistory
-    },
-    __INTERNAL_DO_NOT_USE: {
-      simulateCloseWebsocket: machine.simulateSocketClose,
-      simulateSendCloseEvent: machine.simulateSendCloseEvent
-    }
-  };
-  return {
-    connect: machine.connect,
-    disconnect: machine.disconnect,
-    onNavigatorOnline: machine.onNavigatorOnline,
-    onVisibilityChange: machine.onVisibilityChange,
-    room
-  };
-}
-var LiveblocksError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-  }
-};
-function prepareCreateWebSocket(liveblocksServer, WebSocketPolyfill) {
-  if (typeof window === "undefined" && WebSocketPolyfill == null) {
-    throw new Error(
-      "To use Liveblocks client in a non-dom environment, you need to provide a WebSocket polyfill."
-    );
-  }
-  const ws = WebSocketPolyfill || WebSocket;
-  return (token) => {
-    return new ws(
-      `${liveblocksServer}/?token=${token}&version=${true ? "0.17.11-debug2" : "dev"}`
-    );
-  };
-}
-function prepareAuthEndpoint(authentication, fetchPolyfill) {
-  if (authentication.type === "public") {
-    if (typeof window === "undefined" && fetchPolyfill == null) {
-      throw new Error(
-        "To use Liveblocks client in a non-dom environment with a publicApiKey, you need to provide a fetch polyfill."
-      );
-    }
-    return (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") {
-    const authWithResponseValidation = (room) => {
-      return authentication.callback(room).then((response) => {
-        if (!response || !response.token) {
-          throw new Error(
-            'Authentication error. We expect the authentication callback to return a token, but it does not. Hint: the return value should look like: { token: "..." }'
-          );
-        }
-        return response;
-      });
-    };
-    return authWithResponseValidation;
-  }
-  throw new Error("Internal error. Unexpected authentication type");
-}
-function fetchAuthEndpoint(fetch2, endpoint, body) {
-  return fetch2(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    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 response when doing a POST request on "${endpoint}". ${er}`
-      );
-    });
-  }).then((data) => {
-    if (!isPlainObject(data) || typeof data.token !== "string") {
-      throw new AuthenticationError(
-        `Expected a JSON response of the form \`{ token: "..." }\` when doing a POST request on "${endpoint}", but got ${JSON.stringify(
-          data
-        )}`
-      );
-    }
-    const { token } = data;
-    return { token };
-  });
-}
-var AuthenticationError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
-
-// src/client.ts
-function createClient(options) {
-  const clientOptions = options;
-  const throttleDelay = getThrottleDelayFromOptions(options);
-  const rooms = /* @__PURE__ */ new Map();
-  function getRoom(roomId) {
-    const internalRoom = rooms.get(roomId);
-    return internalRoom ? internalRoom.room : null;
-  }
-  function enter(roomId, options2 = {}) {
-    let internalRoom = rooms.get(roomId);
-    if (internalRoom) {
-      return internalRoom.room;
-    }
-    errorIf(
-      options2.defaultPresence,
-      "Argument `defaultPresence` will be removed in @liveblocks/client 0.18. Please use `initialPresence` instead. For more info, see https://bit.ly/3Niy5aP"
-    );
-    errorIf(
-      options2.defaultStorageRoot,
-      "Argument `defaultStorageRoot` will be removed in @liveblocks/client 0.18. Please use `initialStorage` instead. For more info, see https://bit.ly/3Niy5aP"
-    );
-    internalRoom = createRoom(
-      {
-        initialPresence: options2.initialPresence,
-        initialStorage: options2.initialStorage,
-        defaultPresence: options2.defaultPresence,
-        defaultStorageRoot: options2.defaultStorageRoot
-      },
-      {
-        roomId,
-        throttleDelay,
-        polyfills: clientOptions.polyfills,
-        WebSocketPolyfill: clientOptions.WebSocketPolyfill,
-        fetchPolyfill: clientOptions.fetchPolyfill,
-        liveblocksServer: clientOptions?.liveblocksServer || "wss://api.liveblocks.io/v6",
-        authentication: prepareAuthentication(clientOptions, roomId)
-      }
-    );
-    rooms.set(
-      roomId,
-      internalRoom
-    );
-    if (!options2.DO_NOT_USE_withoutConnecting) {
-      if (typeof atob == "undefined") {
-        if (clientOptions.polyfills?.atob == void 0) {
-          throw new Error(
-            "You need to polyfill atob to use the client in your environment. Please follow the instructions at https://liveblocks.io/docs/errors/liveblocks-client/atob-polyfill"
-          );
-        }
-        global.atob = clientOptions.polyfills.atob;
-      }
-      internalRoom.connect();
-    }
-    return internalRoom.room;
-  }
-  function leave(roomId) {
-    const room = rooms.get(roomId);
-    if (room) {
-      room.disconnect();
-      rooms.delete(roomId);
-    }
-  }
-  if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
-    window.addEventListener("online", () => {
-      for (const [, room] of rooms) {
-        room.onNavigatorOnline();
-      }
-    });
-  }
-  if (typeof document !== "undefined") {
-    document.addEventListener("visibilitychange", () => {
-      for (const [, room] of rooms) {
-        room.onVisibilityChange(document.visibilityState);
-      }
-    });
-  }
-  return {
-    getRoom,
-    enter,
-    leave
-  };
-}
-function getThrottleDelayFromOptions(options) {
-  if (options.throttle === void 0) {
-    return 100;
-  }
-  if (typeof options.throttle !== "number" || options.throttle < 80 || options.throttle > 1e3) {
-    throw new Error("throttle should be a number between 80 and 1000.");
-  }
-  return options.throttle;
-}
-function prepareAuthentication(clientOptions, roomId) {
-  const { publicApiKey, authEndpoint } = clientOptions;
-  if (authEndpoint !== void 0 && publicApiKey !== void 0) {
-    throw new Error(
-      "You cannot use both publicApiKey and authEndpoint. Please use either publicApiKey or authEndpoint, but not both. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
-    );
-  }
-  if (typeof publicApiKey === "string") {
-    if (publicApiKey.startsWith("sk_")) {
-      throw new Error(
-        "Invalid publicApiKey. You are using the secret key which is not supported. Please use the public key instead. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
-      );
-    } else if (!publicApiKey.startsWith("pk_")) {
-      throw new Error(
-        "Invalid key. Please use the public key format: pk_<public key>. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientPublicKey"
-      );
-    }
-    return {
-      type: "public",
-      publicApiKey,
-      url: buildLiveblocksPublicAuthorizeEndpoint(clientOptions, roomId)
-    };
-  }
-  if (typeof authEndpoint === "string") {
-    return {
-      type: "private",
-      url: authEndpoint
-    };
-  } else if (typeof authEndpoint === "function") {
-    return {
-      type: "custom",
-      callback: authEndpoint
-    };
-  } else if (authEndpoint !== void 0) {
-    throw new Error(
-      "authEndpoint must be a string or a function. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClientAuthEndpoint"
-    );
-  }
-  throw new Error(
-    "Invalid Liveblocks client options. For more information: https://liveblocks.io/docs/api-reference/liveblocks-client#createClient"
-  );
-}
-function buildLiveblocksPublicAuthorizeEndpoint(options, roomId) {
-  if (options.publicAuthorizeEndpoint) {
-    return options.publicAuthorizeEndpoint.replace("{roomId}", roomId);
-  }
-  return `https://api.liveblocks.io/v2/rooms/${encodeURIComponent(
-    roomId
-  )}/public/authorize`;
-}
-export {
-  LiveList,
-  LiveMap,
-  LiveObject,
-  createClient
-};
+export default mod;
+export const LiveList = mod.LiveList;
+export const LiveMap = mod.LiveMap;
+export const LiveObject = mod.LiveObject;
+export const createClient = mod.createClient;
+export const shallow = mod.shallow;