@gwakko/shared-websocket 0.1.0

package/dist/chunk-TNEMKPGP.js

@@ -0,0 +1,737 @@
+// src/utils/disposable.ts
+if (typeof Symbol.dispose === "undefined") {
+  Symbol.dispose = /* @__PURE__ */ Symbol("Symbol.dispose");
+}
+
+// src/utils/id.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+
+// src/MessageBus.ts
+var MessageBus = class {
+  constructor(channelName, tabId) {
+    this.tabId = tabId;
+    this.channel = new BroadcastChannel(channelName);
+    this.channel.onmessage = (ev) => {
+      this.handleMessage(ev.data);
+    };
+  }
+  tabId;
+  channel;
+  listeners = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  subscribe(topic, fn) {
+    const wrapper = (msg) => {
+      if (msg.source !== this.tabId) fn(msg.data);
+    };
+    this.addListener(topic, wrapper);
+    return () => this.removeListener(topic, wrapper);
+  }
+  publish(topic, data) {
+    this.postMessage({ topic, type: "publish", data });
+  }
+  broadcast(topic, data) {
+    const msg = this.createMessage(topic, "broadcast", data);
+    this.channel.postMessage(msg);
+    this.handleMessage(msg);
+  }
+  async request(topic, data, timeout = 5e3) {
+    const msg = this.createMessage(topic, "request", data);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(msg.id);
+        reject(new Error(`MessageBus.request: timeout for topic "${topic}"`));
+      }, timeout);
+      this.pendingRequests.set(msg.id, { resolve, reject, timer });
+      this.channel.postMessage(msg);
+    });
+  }
+  respond(topic, fn) {
+    const wrapper = async (msg) => {
+      if (msg.type !== "request" || msg.source === this.tabId) return;
+      const result = await fn(msg.data);
+      this.postMessage({ topic, type: "response", data: { requestId: msg.id, result } });
+    };
+    this.addListener(topic, wrapper);
+    return () => this.removeListener(topic, wrapper);
+  }
+  handleMessage(msg) {
+    if (msg.type === "response") {
+      const payload = msg.data;
+      const pending = this.pendingRequests.get(payload.requestId);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(payload.requestId);
+        pending.resolve(payload.result);
+        return;
+      }
+    }
+    const listeners = this.listeners.get(msg.topic);
+    if (listeners) {
+      for (const fn of listeners) fn(msg);
+    }
+  }
+  postMessage(partial) {
+    this.channel.postMessage(this.createMessage(partial.topic, partial.type, partial.data));
+  }
+  createMessage(topic, type, data) {
+    return { id: generateId(), source: this.tabId, topic, type, data, timestamp: Date.now() };
+  }
+  addListener(topic, fn) {
+    let set = this.listeners.get(topic);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(topic, set);
+    }
+    set.add(fn);
+  }
+  removeListener(topic, fn) {
+    this.listeners.get(topic)?.delete(fn);
+  }
+  [Symbol.dispose]() {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("MessageBus disposed"));
+    }
+    this.pendingRequests.clear();
+    this.listeners.clear();
+    this.channel.close();
+  }
+};
+
+// src/TabCoordinator.ts
+var TabCoordinator = class {
+  constructor(bus, tabId, options = {}) {
+    this.bus = bus;
+    this.tabId = tabId;
+    this.electionTimeout = options.electionTimeout ?? 200;
+    this.heartbeatInterval = options.heartbeatInterval ?? 2e3;
+    this.leaderTimeout = options.leaderTimeout ?? 5e3;
+    this.cleanups.push(
+      this.bus.subscribe("coord:election", () => {
+        if (this._isLeader) {
+          this.bus.publish("coord:reject", { tabId: this.tabId });
+        }
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("coord:heartbeat", () => {
+        this.lastHeartbeat = Date.now();
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("coord:abdicate", () => {
+        if (!this._isLeader && !this.disposed) {
+          this.elect();
+        }
+      })
+    );
+  }
+  bus;
+  tabId;
+  _isLeader = false;
+  heartbeatTimer = null;
+  leaderCheckTimer = null;
+  lastHeartbeat = 0;
+  disposed = false;
+  onBecomeLeaderFns = /* @__PURE__ */ new Set();
+  onLoseLeadershipFns = /* @__PURE__ */ new Set();
+  cleanups = [];
+  electionTimeout;
+  heartbeatInterval;
+  leaderTimeout;
+  get isLeader() {
+    return this._isLeader;
+  }
+  async elect() {
+    if (this.disposed) return;
+    return new Promise((resolve) => {
+      let rejected = false;
+      const unsub = this.bus.subscribe("coord:reject", () => {
+        rejected = true;
+        unsub();
+        this.startLeaderCheck();
+        resolve();
+      });
+      this.bus.publish("coord:election", { tabId: this.tabId });
+      setTimeout(() => {
+        unsub();
+        if (!rejected && !this.disposed) {
+          this.becomeLeader();
+        }
+        resolve();
+      }, this.electionTimeout);
+    });
+  }
+  abdicate() {
+    if (!this._isLeader) return;
+    this._isLeader = false;
+    this.stopHeartbeat();
+    this.bus.publish("coord:abdicate", { tabId: this.tabId });
+    for (const fn of this.onLoseLeadershipFns) fn();
+  }
+  onBecomeLeader(fn) {
+    this.onBecomeLeaderFns.add(fn);
+    return () => this.onBecomeLeaderFns.delete(fn);
+  }
+  onLoseLeadership(fn) {
+    this.onLoseLeadershipFns.add(fn);
+    return () => this.onLoseLeadershipFns.delete(fn);
+  }
+  becomeLeader() {
+    this._isLeader = true;
+    this.stopLeaderCheck();
+    this.startHeartbeat();
+    for (const fn of this.onBecomeLeaderFns) fn();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.bus.publish("coord:heartbeat", { tabId: this.tabId });
+    }, this.heartbeatInterval);
+    this.bus.publish("coord:heartbeat", { tabId: this.tabId });
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  startLeaderCheck() {
+    this.stopLeaderCheck();
+    this.lastHeartbeat = Date.now();
+    this.leaderCheckTimer = setInterval(() => {
+      if (Date.now() - this.lastHeartbeat > this.leaderTimeout && !this.disposed) {
+        this.stopLeaderCheck();
+        this.elect();
+      }
+    }, 1e3);
+  }
+  stopLeaderCheck() {
+    if (this.leaderCheckTimer) {
+      clearInterval(this.leaderCheckTimer);
+      this.leaderCheckTimer = null;
+    }
+  }
+  [Symbol.dispose]() {
+    this.disposed = true;
+    if (this._isLeader) {
+      this.abdicate();
+    }
+    this.stopHeartbeat();
+    this.stopLeaderCheck();
+    for (const unsub of this.cleanups) unsub();
+    this.cleanups = [];
+    this.onBecomeLeaderFns.clear();
+    this.onLoseLeadershipFns.clear();
+  }
+};
+
+// src/utils/backoff.ts
+function* backoff(base = 1e3, max = 3e4) {
+  let delay = base;
+  while (true) {
+    const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+    yield Math.min(delay + jitter, max);
+    delay = Math.min(delay * 2, max);
+  }
+}
+
+// src/SharedSocket.ts
+var SharedSocket = class {
+  constructor(url, options = {}) {
+    this.url = url;
+    this.opts = {
+      protocols: options.protocols ?? [],
+      reconnect: options.reconnect ?? true,
+      reconnectMaxDelay: options.reconnectMaxDelay ?? 3e4,
+      heartbeatInterval: options.heartbeatInterval ?? 3e4,
+      sendBuffer: options.sendBuffer ?? 100,
+      auth: options.auth
+    };
+  }
+  url;
+  ws = null;
+  _state = "closed";
+  buffer = [];
+  disposed = false;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  onMessageFns = /* @__PURE__ */ new Set();
+  onStateChangeFns = /* @__PURE__ */ new Set();
+  opts;
+  get state() {
+    return this._state;
+  }
+  async connect() {
+    if (this.disposed) return;
+    this.setState("connecting");
+    let connectUrl = this.url;
+    if (this.opts.auth) {
+      const token = await this.opts.auth();
+      const sep = connectUrl.includes("?") ? "&" : "?";
+      connectUrl = `${connectUrl}${sep}token=${encodeURIComponent(token)}`;
+    }
+    this.ws = new WebSocket(connectUrl, this.opts.protocols);
+    this.ws.onopen = () => {
+      this.setState("connected");
+      this.flushBuffer();
+      this.startHeartbeat();
+    };
+    this.ws.onmessage = (ev) => {
+      let data;
+      try {
+        data = JSON.parse(ev.data);
+      } catch {
+        data = ev.data;
+      }
+      for (const fn of this.onMessageFns) fn(data);
+    };
+    this.ws.onclose = () => {
+      this.stopHeartbeat();
+      if (!this.disposed && this.opts.reconnect) {
+        this.reconnect();
+      } else {
+        this.setState("closed");
+      }
+    };
+    this.ws.onerror = () => {
+    };
+  }
+  disconnect() {
+    this.disposed = true;
+    this.stopHeartbeat();
+    this.clearReconnect();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onmessage = null;
+      this.ws.onerror = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close(1e3, "client disconnect");
+      }
+      this.ws = null;
+    }
+    this.setState("closed");
+  }
+  send(data) {
+    if (this._state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+    } else if (this._state === "reconnecting" || this._state === "connecting") {
+      if (this.buffer.length < this.opts.sendBuffer) {
+        this.buffer.push(data);
+      }
+    }
+  }
+  onMessage(fn) {
+    this.onMessageFns.add(fn);
+    return () => this.onMessageFns.delete(fn);
+  }
+  onStateChange(fn) {
+    this.onStateChangeFns.add(fn);
+    return () => this.onStateChangeFns.delete(fn);
+  }
+  reconnect() {
+    this.setState("reconnecting");
+    const gen = backoff(1e3, this.opts.reconnectMaxDelay);
+    const attempt = () => {
+      if (this.disposed) return;
+      const delay = gen.next().value;
+      this.reconnectTimer = setTimeout(() => {
+        if (!this.disposed) this.connect();
+      }, delay);
+    };
+    attempt();
+  }
+  flushBuffer() {
+    const pending = this.buffer.splice(0);
+    for (const item of pending) {
+      this.send(item);
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, this.opts.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  clearReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  setState(state) {
+    this._state = state;
+    for (const fn of this.onStateChangeFns) fn(state);
+  }
+  [Symbol.dispose]() {
+    this.disconnect();
+    this.onMessageFns.clear();
+    this.onStateChangeFns.clear();
+    this.buffer = [];
+  }
+};
+
+// src/WorkerSocket.ts
+var WorkerSocket = class {
+  constructor(url, options = {}) {
+    this.url = url;
+    this.options = options;
+  }
+  url;
+  options;
+  worker = null;
+  _state = "closed";
+  onMessageFns = /* @__PURE__ */ new Set();
+  onStateChangeFns = /* @__PURE__ */ new Set();
+  get state() {
+    return this._state;
+  }
+  connect() {
+    const workerUrl = this.options.workerUrl ?? this.createWorkerBlob();
+    this.worker = new Worker(workerUrl, { type: "module" });
+    this.worker.onmessage = (ev) => {
+      const msg = ev.data;
+      switch (msg.type) {
+        case "state":
+          this._state = msg.state;
+          for (const fn of this.onStateChangeFns) fn(msg.state);
+          break;
+        case "message":
+          for (const fn of this.onMessageFns) fn(msg.data);
+          break;
+        case "open":
+          break;
+        case "close":
+          break;
+        case "error":
+          console.error("WorkerSocket error:", msg.message);
+          break;
+      }
+    };
+    this.worker.postMessage({
+      type: "connect",
+      url: this.url,
+      protocols: this.options.protocols ?? [],
+      reconnect: this.options.reconnect ?? true,
+      reconnectMaxDelay: this.options.reconnectMaxDelay ?? 3e4,
+      heartbeatInterval: this.options.heartbeatInterval ?? 3e4,
+      bufferSize: this.options.sendBuffer ?? 100
+    });
+  }
+  send(data) {
+    this.worker?.postMessage({ type: "send", data });
+  }
+  disconnect() {
+    this.worker?.postMessage({ type: "disconnect" });
+    setTimeout(() => {
+      this.worker?.terminate();
+      this.worker = null;
+    }, 100);
+    this._state = "closed";
+  }
+  onMessage(fn) {
+    this.onMessageFns.add(fn);
+    return () => this.onMessageFns.delete(fn);
+  }
+  onStateChange(fn) {
+    this.onStateChangeFns.add(fn);
+    return () => this.onStateChangeFns.delete(fn);
+  }
+  createWorkerBlob() {
+    const code = `
+      let ws = null, state = 'closed', buffer = [], disposed = false;
+      let heartbeatTimer = null, reconnectTimer = null;
+      let url = '', protocols = [], shouldReconnect = true;
+      let maxDelay = 30000, hbInterval = 30000, maxBuf = 100, delay = 1000;
+
+      function setState(s) { state = s; self.postMessage({ type: 'state', state: s }); }
+      function connect() {
+        if (disposed) return;
+        setState('connecting');
+        ws = new WebSocket(url, protocols);
+        ws.onopen = () => { setState('connected'); delay = 1000; self.postMessage({ type: 'open' }); flush(); startHB(); };
+        ws.onmessage = (e) => { let d; try { d = JSON.parse(e.data); } catch { d = e.data; } self.postMessage({ type: 'message', data: d }); };
+        ws.onclose = (e) => { stopHB(); self.postMessage({ type: 'close', code: e.code, reason: e.reason }); if (!disposed && shouldReconnect && e.code !== 1000) reconnect(); else setState('closed'); };
+        ws.onerror = () => { self.postMessage({ type: 'error', message: 'error' }); };
+      }
+      function send(d) { if (state === 'connected' && ws?.readyState === 1) ws.send(JSON.stringify(d)); else if (buffer.length < maxBuf) buffer.push(d); }
+      function flush() { const p = buffer.splice(0); p.forEach(send); }
+      function startHB() { stopHB(); heartbeatTimer = setInterval(() => { if (ws?.readyState === 1) ws.send('{"type":"ping"}'); }, hbInterval); }
+      function stopHB() { if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; } }
+      function reconnect() { setState('reconnecting'); const j = delay * 0.25 * (Math.random() * 2 - 1); reconnectTimer = setTimeout(() => { if (!disposed) connect(); }, Math.min(delay + j, maxDelay)); delay = Math.min(delay * 2, maxDelay); }
+      self.onmessage = (e) => {
+        const c = e.data;
+        if (c.type === 'connect') { url = c.url; protocols = c.protocols || []; shouldReconnect = c.reconnect ?? true; maxDelay = c.reconnectMaxDelay || 30000; hbInterval = c.heartbeatInterval || 30000; maxBuf = c.bufferSize || 100; connect(); }
+        if (c.type === 'send') send(c.data);
+        if (c.type === 'disconnect') { disposed = true; stopHB(); if (reconnectTimer) clearTimeout(reconnectTimer); if (ws) { ws.onclose = null; if (ws.readyState < 2) ws.close(1000); ws = null; } buffer = []; setState('closed'); }
+      };
+    `;
+    const blob = new Blob([code], { type: "application/javascript" });
+    return new URL(URL.createObjectURL(blob));
+  }
+  [Symbol.dispose]() {
+    this.disconnect();
+    this.onMessageFns.clear();
+    this.onStateChangeFns.clear();
+  }
+};
+
+// src/SubscriptionManager.ts
+var SubscriptionManager = class {
+  handlers = /* @__PURE__ */ new Map();
+  lastMessages = /* @__PURE__ */ new Map();
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return () => set.delete(handler);
+  }
+  once(event, handler) {
+    const wrapper = (data) => {
+      unsub();
+      handler(data);
+    };
+    const unsub = this.on(event, wrapper);
+    return unsub;
+  }
+  off(event, handler) {
+    if (handler) {
+      this.handlers.get(event)?.delete(handler);
+    } else {
+      this.handlers.delete(event);
+    }
+  }
+  emit(event, data) {
+    this.lastMessages.set(event, data);
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const fn of set) fn(data);
+    }
+  }
+  getLastMessage(event) {
+    return this.lastMessages.get(event);
+  }
+  async *stream(event, signal) {
+    const queue = [];
+    let resolve = null;
+    let done = false;
+    const unsub = this.on(event, (data) => {
+      queue.push(data);
+      resolve?.();
+    });
+    const onAbort = () => {
+      done = true;
+      resolve?.();
+    };
+    signal?.addEventListener("abort", onAbort);
+    try {
+      while (!done) {
+        if (queue.length > 0) {
+          yield queue.shift();
+        } else {
+          await new Promise((r) => {
+            resolve = r;
+          });
+          resolve = null;
+        }
+      }
+    } finally {
+      unsub();
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  offAll() {
+    this.handlers.clear();
+    this.lastMessages.clear();
+  }
+  [Symbol.dispose]() {
+    this.offAll();
+  }
+};
+
+// src/SharedWebSocket.ts
+var SharedWebSocket = class {
+  constructor(url, options = {}) {
+    this.url = url;
+    this.options = options;
+    this.tabId = generateId();
+    this.bus = new MessageBus("shared-ws", this.tabId);
+    this.coordinator = new TabCoordinator(this.bus, this.tabId, {
+      electionTimeout: options.electionTimeout,
+      heartbeatInterval: options.leaderHeartbeat,
+      leaderTimeout: options.leaderTimeout
+    });
+    this.cleanups.push(
+      this.bus.subscribe("ws:message", (msg) => {
+        this.subs.emit(msg.event, msg.data);
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("ws:send", (msg) => {
+        if (this.coordinator.isLeader && this.socket) {
+          this.socket.send({ event: msg.event, data: msg.data });
+        }
+      })
+    );
+    this.cleanups.push(
+      this.bus.subscribe("ws:sync", (msg) => {
+        this.syncStore.set(msg.key, msg.value);
+        this.subs.emit(`sync:${msg.key}`, msg.value);
+      })
+    );
+    this.coordinator.onBecomeLeader(() => this.onBecomeLeader());
+    this.coordinator.onLoseLeadership(() => this.onLoseLeadership());
+    if (typeof window !== "undefined") {
+      const onBeforeUnload = () => this[Symbol.dispose]();
+      window.addEventListener("beforeunload", onBeforeUnload);
+      this.cleanups.push(() => window.removeEventListener("beforeunload", onBeforeUnload));
+    }
+  }
+  url;
+  options;
+  bus;
+  coordinator;
+  socket = null;
+  subs = new SubscriptionManager();
+  syncStore = /* @__PURE__ */ new Map();
+  tabId;
+  cleanups = [];
+  disposed = false;
+  get connected() {
+    return this.socket?.state === "connected" || !this.coordinator.isLeader;
+  }
+  get tabRole() {
+    return this.coordinator.isLeader ? "leader" : "follower";
+  }
+  /** Start leader election and connect. */
+  async connect() {
+    await this.coordinator.elect();
+  }
+  /** Subscribe to server events (works in ALL tabs). */
+  on(event, handler) {
+    return this.subs.on(event, handler);
+  }
+  once(event, handler) {
+    return this.subs.once(event, handler);
+  }
+  off(event, handler) {
+    this.subs.off(event, handler);
+  }
+  /** Async generator for consuming events. */
+  stream(event, signal) {
+    return this.subs.stream(event, signal);
+  }
+  /** Send message to server (auto-routed through leader). */
+  send(event, data) {
+    if (this.coordinator.isLeader && this.socket) {
+      this.socket.send({ event, data });
+    } else {
+      this.bus.publish("ws:send", { event, data });
+    }
+  }
+  /** Request/response through server via leader. */
+  async request(event, data, timeout = 5e3) {
+    return this.bus.request("ws:request", { event, data }, timeout);
+  }
+  /** Sync state across tabs (no server roundtrip). */
+  sync(key, value) {
+    this.syncStore.set(key, value);
+    this.bus.broadcast("ws:sync", { key, value });
+  }
+  getSync(key) {
+    return this.syncStore.get(key);
+  }
+  onSync(key, fn) {
+    return this.subs.on(`sync:${key}`, fn);
+  }
+  disconnect() {
+    this[Symbol.dispose]();
+  }
+  createSocket() {
+    const socketOptions = {
+      protocols: this.options.protocols,
+      reconnect: this.options.reconnect,
+      reconnectMaxDelay: this.options.reconnectMaxDelay,
+      heartbeatInterval: this.options.heartbeatInterval,
+      sendBuffer: this.options.sendBuffer
+    };
+    if (this.options.useWorker) {
+      return new WorkerSocket(this.url, {
+        ...socketOptions,
+        workerUrl: this.options.workerUrl
+      });
+    }
+    return new SharedSocket(this.url, {
+      ...socketOptions,
+      auth: this.options.auth
+    });
+  }
+  onBecomeLeader() {
+    this.socket = this.createSocket();
+    this.socket.onMessage((data) => {
+      const event = data?.event ?? "message";
+      const payload = data?.data ?? data;
+      this.bus.broadcast("ws:message", { event, data: payload });
+    });
+    this.cleanups.push(
+      this.bus.respond("ws:request", async (req) => {
+        return new Promise((resolve) => {
+          const unsub = this.socket.onMessage((response) => {
+            if (response?.event === req.event || response?.requestId) {
+              unsub();
+              resolve(response?.data ?? response);
+            }
+          });
+          this.socket.send({ event: req.event, data: req.data });
+        });
+      })
+    );
+    this.socket.connect();
+  }
+  onLoseLeadership() {
+    if (this.socket) {
+      this.socket[Symbol.dispose]();
+      this.socket = null;
+    }
+  }
+  [Symbol.dispose]() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.coordinator[Symbol.dispose]();
+    if (this.socket) {
+      this.socket[Symbol.dispose]();
+      this.socket = null;
+    }
+    for (const unsub of this.cleanups) unsub();
+    this.cleanups = [];
+    this.subs[Symbol.dispose]();
+    this.bus[Symbol.dispose]();
+    this.syncStore.clear();
+  }
+};
+
+export {
+  MessageBus,
+  TabCoordinator,
+  SharedSocket,
+  WorkerSocket,
+  SubscriptionManager,
+  SharedWebSocket
+};
+//# sourceMappingURL=chunk-TNEMKPGP.js.map