live-quiz 0.1.0

package/dist/participant.js

@@ -0,0 +1,1772 @@
+var Z = Object.defineProperty;
+var ee = (n, e, t) => e in n ? Z(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var A = (n, e, t) => ee(n, typeof e != "symbol" ? e + "" : e, t);
+let j = () => ({
+  emit(n, ...e) {
+    for (let t = this.events[n] || [], s = 0, i = t.length; s < i; s++)
+      t[s](...e);
+  },
+  events: {},
+  on(n, e) {
+    var t;
+    return ((t = this.events)[n] || (t[n] = [])).push(e), () => {
+      var s;
+      this.events[n] = (s = this.events[n]) == null ? void 0 : s.filter((i) => e !== i);
+    };
+  }
+});
+class x extends Error {
+  constructor(e, t) {
+    e instanceof Error ? (super(e.message), this.cause = e) : super(e), this.reason = t, this.name = "ReasonError";
+  }
+}
+class G extends x {
+  constructor(e) {
+    super("Rejected", e), this.name = "SubscriptionRejectedError";
+  }
+}
+class te extends x {
+  constructor(e) {
+    super(e || "Timed out to receive subscription ack"), this.name = "SubscriptionTimeoutError";
+  }
+}
+class v extends x {
+  constructor(e, t) {
+    t ? super(e, t) : super("Disconnected", e), this.name = "DisconnectedError";
+  }
+}
+class se extends v {
+  constructor(e) {
+    super(e, "stale_connection"), this.name = "StaleConnectionError";
+  }
+}
+function W(n) {
+  return n ? `{${Object.keys(n).sort().filter((t) => n[t] !== void 0).map((t) => {
+    let s = JSON.stringify(n[t]);
+    return `${JSON.stringify(t)}:${s}`;
+  }).join(",")}}` : "";
+}
+class ie {
+  constructor(e) {
+    this.channel = e, this.listeners = [];
+  }
+  watch() {
+    this.listeners.push(
+      this.channel.on("presence", (e) => {
+        if (e.type === "info") {
+          this._state || (this._state = this.stateFromInfo(e));
+          return;
+        }
+        this._state && (e.type === "join" ? this._state[e.id] = e.info : e.type === "leave" && delete this._state[e.id]);
+      })
+    );
+  }
+  // Reset the state to make sure the fresh one is
+  // requested the next time info() is called
+  reset() {
+    delete this._state;
+  }
+  dispose() {
+    delete this._info, delete this._state, this.listeners.forEach((e) => e()), this.listeners.length = 0;
+  }
+  async join(e, t) {
+    if (!this._info)
+      return this._info = { id: String(e), info: t }, this.channel.perform("$presence:join", this._info);
+  }
+  async leave() {
+    if (!this._info) return;
+    let e = await this.channel.perform("$presence:leave");
+    return delete this._info, e;
+  }
+  async info() {
+    return this._state ? this._state : (this._promise || (this._promise = this._sync()), await this._promise, this._state);
+  }
+  async _sync() {
+    this.watch();
+    try {
+      let e = await this.channel.perform("$presence:info", {});
+      return this._state = this.stateFromInfo(e), this._state;
+    } finally {
+      delete this._promise;
+    }
+  }
+  stateFromInfo(e) {
+    return e.records ? e.records.reduce((t, { id: s, info: i }) => (t[s] = i, t), {}) : {};
+  }
+}
+const q = Symbol("state");
+class J {
+  // Unique channel identifier
+  // static identifier = ''
+  constructor(e = {}) {
+    this.emitter = j(), this.params = Object.freeze(e), this.presence = new ie(this), this.initialConnect = !0, this[q] = "idle";
+  }
+  get identifier() {
+    return this._identifier ? this._identifier : (this._identifier = W({
+      channel: this.channelId,
+      ...this.params
+    }), this._identifier);
+  }
+  get channelId() {
+    return this.constructor.identifier;
+  }
+  get state() {
+    return this[q];
+  }
+  attached(e) {
+    if (this.receiver) {
+      if (this.receiver !== e)
+        throw Error("Already connected to a different receiver");
+      return !1;
+    }
+    return this.receiver = e, !0;
+  }
+  connecting() {
+    this[q] = "connecting";
+  }
+  connected() {
+    if (this.state === "connected" || this.state === "closed") return;
+    this[q] = "connected";
+    let e = !1;
+    this.initialConnect ? (this.initialConnect = !1, this.emit("connect", { reconnect: !1, restored: e })) : this.emit("connect", { reconnect: !0, restored: e });
+  }
+  restored() {
+    if (this.state === "connected") throw Error("Already connected");
+    this[q] = "connected";
+    let e = !0, t = !0;
+    this.initialConnect = !1, this.emit("connect", { reconnect: t, restored: e });
+  }
+  disconnected(e) {
+    this.state === "disconnected" || this.state === "closed" || (this[q] = "disconnected", this.presence.reset(), this.emit("disconnect", e));
+  }
+  closed(e) {
+    this.state !== "closed" && (this[q] = "closed", delete this.receiver, this.initialConnect = !0, this.presence.dispose(), this.emit("close", e));
+  }
+  disconnect() {
+    this.state === "idle" || this.state === "closed" || this.receiver.unsubscribe(this);
+  }
+  async perform(e, t) {
+    if (this.state === "idle" || this.state === "closed")
+      throw Error("Channel is not subscribed");
+    return this.receiver.perform(this.identifier, e, t);
+  }
+  async send(e) {
+    return this.perform(void 0, e);
+  }
+  async whisper(e) {
+    try {
+      await this.perform("$whisper", e);
+    } catch (t) {
+      let s = this.receiver ? this.receiver.logger : null;
+      s && s.warn("whisper failed: ", t);
+    }
+  }
+  receive(e, t) {
+    this.emit("message", e, t);
+  }
+  on(e, t) {
+    return this.emitter.on(e, t);
+  }
+  once(e, t) {
+    let s = this.emitter.on(e, (...i) => {
+      s(), t(...i);
+    });
+    return s;
+  }
+  emit(e, ...t) {
+    return this.emitter.emit(e, ...t);
+  }
+  ensureSubscribed() {
+    return this.state === "connected" ? Promise.resolve() : this.state === "closed" ? Promise.reject(Error("Channel is unsubscribed")) : this.pendingSubscribe();
+  }
+  // This promise resolves when subscription is confirmed
+  // and rejects when rejected or closed.
+  // It ignores disconnect events.
+  pendingSubscribe() {
+    return this._pendingSubscribe ? this._pendingSubscribe : (this._pendingSubscribe = new Promise((e, t) => {
+      let s = [() => delete this._pendingSubscribe];
+      s.push(
+        this.on("connect", () => {
+          s.forEach((i) => i()), e();
+        })
+      ), s.push(
+        this.on("close", (i) => {
+          s.forEach((r) => r()), t(
+            i || new x(
+              "Channel was disconnected before subscribing",
+              "canceled"
+            )
+          );
+        })
+      );
+    }), this._pendingSubscribe);
+  }
+}
+class ne {
+  constructor(e) {
+    this.id = e, this.intent = "unsubscribed", this.state = "idle", this.channels = [], this.disposed = !1, this._pendings = [];
+  }
+  add(e) {
+    this.channels.includes(e) || this.channels.push(e);
+  }
+  remove(e) {
+    let t = this.channels.indexOf(e);
+    t > -1 && this.channels.splice(t, 1);
+  }
+  notify(e, ...t) {
+    this.state = e === "restored" ? "connected" : e, t.length === 1 ? this.channels.forEach((s) => s[e](t[0])) : this.channels.forEach((s) => s[e]());
+  }
+  pending(e) {
+    this._checkIntent(e);
+    let t = this._pendings[0];
+    return !t || t.intent !== e ? Promise.resolve() : t.promise;
+  }
+  ensureResubscribed() {
+    this.disposed || (this.intent = void 0, this.ensureSubscribed());
+  }
+  ensureSubscribed() {
+    if (this.intent === "subscribed") return;
+    if (this.disposed) throw Error("Subscription is disposed");
+    this.intent = "subscribed", !this._mergeWithPending("unsubscribed") && this.subscriber(this);
+  }
+  maybeUnsubscribe() {
+    this.disposed || this.intent === "unsubscribed" || this.channels.length > 0 || (this.intent = "unsubscribed", this._mergeWithPending("subscribed")) || this.unsubscriber(this);
+  }
+  async acquire(e) {
+    this._checkIntent(e);
+    let t, i = {
+      promise: new Promise((o) => {
+        t = o;
+      }),
+      intent: e,
+      release: () => {
+        this._pendings.splice(this._pendings.indexOf(i), 1), t(i);
+      },
+      canceled: !1,
+      acquired: !1
+    }, r = this._pendingTop;
+    return this._pendings.push(i), r && await r.promise, this.gvl && await this.gvl.acquire(i, e), i.acquired = !0, i;
+  }
+  close(e) {
+    this.disposed = !0, this.intent = void 0, this.notify("closed", e);
+  }
+  _checkIntent(e) {
+    if (!(e === "unsubscribed" || e === "subscribed"))
+      throw Error(`Unknown subscription intent: ${e}`);
+  }
+  get _pendingTop() {
+    return this._pendings.length ? this._pendings[this._pendings.length - 1] : void 0;
+  }
+  _mergeWithPending(e) {
+    let t = this._pendingTop;
+    return !t || t.acquired || t.intent !== e ? !1 : (this._pendings.pop(), t.canceled = !0, !0);
+  }
+}
+class re {
+  constructor() {
+    this.queue = [];
+  }
+  async acquire(e, t) {
+    t === "subscribed" && (this.queue.push(
+      e.promise.then(() => {
+        this.queue.splice(this.queue.indexOf(e), 1);
+      })
+    ), this.queue.length > 1 && await this.queue[this.queue.length - 2]);
+  }
+}
+class oe {
+  constructor(e) {
+    e.concurrentSubscribes === !1 && (this.glv = new re()), this._subscriptions = {}, this._localToRemote = {};
+  }
+  all() {
+    return Object.values(this._subscriptions);
+  }
+  get(e) {
+    return this._subscriptions[e];
+  }
+  create(e, { subscribe: t, unsubscribe: s }) {
+    let i = this._subscriptions[e] = new ne(e);
+    return i.remoteId = this._localToRemote[e], i.subscriber = t, i.unsubscriber = s, i.gvl = this.glv, i;
+  }
+  remove(e) {
+    delete this._subscriptions[e], delete this._localToRemote[e];
+  }
+  storeRemoteId(e, t) {
+    this._localToRemote[e] = t;
+    let s = this.get(e);
+    s && (s.remoteId = t);
+  }
+}
+class ce {
+  constructor(e = {}) {
+    this.subscriptions = new oe(e), this._pendingMessages = [], this._remoteToLocal = {};
+  }
+  subscribe(e, t) {
+    this._remoteToLocal[t] = e, this.subscriptions.storeRemoteId(e, t), this.flush(t);
+  }
+  unsubscribe(e) {
+    let t = this.subscriptions.get(e);
+    if (!t) return;
+    let s = t.remoteId;
+    s && delete this._remoteToLocal[s], this.subscriptions.remove(e);
+  }
+  transmit(e, t, s) {
+    let i = this._remoteToLocal[e];
+    if (!i) {
+      this._pendingMessages.push([e, t, s]);
+      return;
+    }
+    let r = this.subscriptions.get(i);
+    r && r.channels.forEach((o) => {
+      o.receive(t, s);
+    });
+  }
+  notify(e, t, s) {
+    let i = this._remoteToLocal[e];
+    if (!i)
+      return;
+    let r = this.subscriptions.get(i);
+    r && r.channels.forEach((o) => o.emit(t, s));
+  }
+  close() {
+    this._pendingMessages.length = 0;
+  }
+  get size() {
+    return this.channels.length;
+  }
+  get channels() {
+    return this.subscriptions.all().flatMap((e) => e.channels);
+  }
+  flush(e) {
+    let t = [];
+    for (let s of this._pendingMessages)
+      s[0] === e ? this.transmit(s[0], s[1], s[2]) : t.push(s);
+    this._pendingMessages = t;
+  }
+}
+const F = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+class V {
+  constructor(e) {
+    this.level = e || "warn";
+  }
+  log(e, t, s) {
+    F[e] < F[this.level] || this.writeLogEntry(e, t, s);
+  }
+  writeLogEntry() {
+    throw Error("Not implemented");
+  }
+  debug(e, t) {
+    this.log("debug", e, t);
+  }
+  info(e, t) {
+    this.log("info", e, t);
+  }
+  warn(e, t) {
+    this.log("warn", e, t);
+  }
+  error(e, t) {
+    this.log("error", e, t);
+  }
+}
+class z extends V {
+  writeLogEntry() {
+  }
+}
+class ae {
+  encode(e) {
+    return JSON.stringify(e);
+  }
+  decode(e) {
+    try {
+      return JSON.parse(e);
+    } catch {
+    }
+  }
+}
+let he = 0;
+class H {
+  constructor(e = {}) {
+    let { logger: t } = e;
+    this.logger = t || new z(), this.pendingSubscriptions = {}, this.pendingUnsubscriptions = {}, this.subscribeCooldownInterval = e.subscribeCooldownInterval || 250, this.subscribeRetryInterval = e.subscribeRetryInterval || 5e3;
+  }
+  attached(e) {
+    this.cable = e;
+  }
+  subscribe(e, t) {
+    let s = { channel: e };
+    t && Object.assign(s, t);
+    let i = W(s);
+    if (this.pendingUnsubscriptions[i]) {
+      let o = this.subscribeCooldownInterval * 1.5;
+      return this.logger.debug(
+        `unsubscribed recently, cooldown for ${o}`,
+        i
+      ), new Promise((c) => {
+        setTimeout(() => {
+          c(this.subscribe(e, t));
+        }, o);
+      });
+    }
+    if (this.pendingSubscriptions[i])
+      return this.logger.warn("subscription is already pending, skipping", i), Promise.reject(Error("Already subscribing"));
+    let r = this.subscribeRetryInterval;
+    return new Promise((o, c) => {
+      let d = ++he;
+      this.pendingSubscriptions[i] = {
+        resolve: o,
+        reject: c,
+        id: d
+      }, this.cable.send(this.buildSubscribeRequest(i)), this.maybeRetrySubscribe(d, i, r);
+    });
+  }
+  buildSubscribeRequest(e) {
+    return {
+      command: "subscribe",
+      identifier: e
+    };
+  }
+  maybeRetrySubscribe(e, t, s) {
+    setTimeout(() => {
+      let i = this.pendingSubscriptions[t];
+      i && i.id === e && (this.logger.warn(
+        `no subscription ack received in ${s}ms, retrying subscribe`,
+        t
+      ), this.cable.send(this.buildSubscribeRequest(t)), this.maybeExpireSubscribe(e, t, s));
+    }, s);
+  }
+  maybeExpireSubscribe(e, t, s) {
+    setTimeout(() => {
+      let i = this.pendingSubscriptions[t];
+      i && i.id === e && (delete this.pendingSubscriptions[t], i.reject(
+        new te(
+          `Haven't received subscription ack in ${s * 2}ms for ${t}`
+        )
+      ));
+    }, s);
+  }
+  unsubscribe(e) {
+    return this.cable.send({
+      command: "unsubscribe",
+      identifier: e
+    }), this.pendingUnsubscriptions[e] = !0, setTimeout(() => {
+      delete this.pendingUnsubscriptions[e];
+    }, this.subscribeCooldownInterval), Promise.resolve();
+  }
+  perform(e, t, s) {
+    return t === "$whisper" ? this.whisper(e, s) : (s || (s = {}), s.action || (s.action = t), this.cable.send({
+      command: "message",
+      identifier: e,
+      data: JSON.stringify(s)
+    }), Promise.resolve());
+  }
+  whisper(e, t) {
+    return this.cable.send({
+      command: "whisper",
+      identifier: e,
+      data: t
+    }), Promise.resolve();
+  }
+  receive(e) {
+    if (typeof e != "object") {
+      this.logger.error("unsupported message format", { message: e });
+      return;
+    }
+    let { type: t, identifier: s, message: i, reason: r, reconnect: o } = e;
+    if (t === "ping")
+      return this.cable.keepalive(e.message);
+    if (this.cable.keepalive(), t === "welcome") {
+      let c = e.sid;
+      return c && this.cable.setSessionId(c), this.cable.connected();
+    }
+    if (t === "disconnect") {
+      let c = new v(r);
+      this.reset(c), o === !1 ? this.cable.closed(c) : this.cable.disconnected(c);
+      return;
+    }
+    if (t === "confirm_subscription") {
+      let c = this.pendingSubscriptions[s];
+      if (!c) {
+        this.logger.error("subscription not found, unsubscribing", {
+          type: t,
+          identifier: s
+        }), this.unsubscribe(s);
+        return;
+      }
+      return delete this.pendingSubscriptions[s], c.resolve(s);
+    }
+    if (t === "reject_subscription") {
+      let c = this.pendingSubscriptions[s];
+      return c ? (delete this.pendingSubscriptions[s], c.reject(new G())) : this.logger.error("subscription not found", { type: t, identifier: s });
+    }
+    if (i)
+      return { identifier: s, message: i };
+    this.logger.warn(`unknown message type: ${t}`, { message: e });
+  }
+  reset(e) {
+    for (let t in this.pendingSubscriptions)
+      this.pendingSubscriptions[t].reject(e);
+    this.pendingSubscriptions = {};
+  }
+  recoverableClosure() {
+    return !1;
+  }
+}
+const Q = () => Date.now() / 1e3 | 0;
+class le extends H {
+  constructor(e = {}) {
+    super(e), this.streamsPositions = {}, this.subscriptionStreams = {}, this.pendingHistory = {}, this.pendingPresence = {}, this.presenceInfo = {}, this.restoreSince = e.historyTimestamp, this.disableSessionRecovery = e.disableSessionRecovery, this.restoreSince === void 0 && (this.restoreSince = Q()), this.sessionId = void 0, this.sendPongs = e.pongs;
+  }
+  reset(e) {
+    for (let t in this.pendingPresence)
+      this.pendingPresence[t].reject(e);
+    return this.pendingPresence = {}, super.reset();
+  }
+  receive(e) {
+    if (typeof e != "object") {
+      this.logger.error("unsupported message format", { message: e });
+      return;
+    }
+    let { type: t, identifier: s, message: i } = e;
+    if (t === "disconnect")
+      return delete this.sessionId, this.cable.setSessionId(""), super.receive(e);
+    if (t === "reject_subscription")
+      return super.receive(e);
+    if (t === "confirm_subscription")
+      return this.subscriptionStreams[s] || (this.subscriptionStreams[s] = /* @__PURE__ */ new Set()), super.receive(e);
+    if (t === "ping")
+      return this.restoreSince && (this.restoreSince = Q()), this.sendPongs && this.sendPong(), this.cable.keepalive(e.message);
+    if (this.cable.keepalive(), t === "confirm_history") {
+      this.logger.debug("history result received", e), this.cable.notify("history_received", s);
+      return;
+    }
+    if (t === "reject_history") {
+      this.logger.warn("failed to retrieve history", e), this.cable.notify("history_not_found", s);
+      return;
+    }
+    if (t === "welcome") {
+      if (this.disableSessionRecovery || (this.sessionId = e.sid, this.sessionId && this.cable.setSessionId(this.sessionId)), e.restored) {
+        let r = e.restored_ids || Object.keys(this.subscriptionStreams);
+        for (let o of r)
+          this.cable.send({
+            identifier: o,
+            command: "history",
+            history: this.historyRequestFor(o)
+          }), this.presenceInfo[o] && this.cable.send({
+            identifier: o,
+            command: "join",
+            presence: this.presenceInfo[o]
+          });
+        return this.cable.restored(r);
+      }
+      return this.cable.connected(this.sessionId);
+    }
+    if (t === "presence") {
+      let r = i.type;
+      if (r === "info") {
+        let o = this.pendingPresence[s];
+        o && (delete this.pendingPresence[s], o.resolve(i));
+      } else if (r === "error") {
+        let o = this.pendingPresence[s];
+        o && (delete this.pendingPresence[s], o.reject(new Error("failed to retrieve presence")));
+      }
+      return {
+        type: t,
+        identifier: s,
+        message: i
+      };
+    }
+    if (i) {
+      let r = this.trackStreamPosition(
+        s,
+        e.stream_id,
+        e.epoch,
+        e.offset
+      );
+      return { identifier: s, message: i, meta: r };
+    }
+    this.logger.warn(`unknown message type: ${t}`, { message: e });
+  }
+  perform(e, t, s) {
+    switch (t) {
+      case "$presence:join":
+        return this.join(e, s);
+      case "$presence:leave":
+        return this.leave(e, s);
+      case "$presence:info":
+        return this.presence(e, s);
+    }
+    return super.perform(e, t, s);
+  }
+  unsubscribe(e) {
+    return delete this.presenceInfo[e], super.unsubscribe(e);
+  }
+  buildSubscribeRequest(e) {
+    let t = super.buildSubscribeRequest(e), s = this.historyRequestFor(e);
+    s && (t.history = s, this.pendingHistory[e] = !0);
+    let i = this.presenceInfo[e];
+    return i && (t.presence = i), t;
+  }
+  // TODO: Which error can be non-recoverable?
+  recoverableClosure() {
+    return !!this.sessionId;
+  }
+  historyRequestFor(e) {
+    let t = {}, s = !1;
+    if (this.subscriptionStreams[e])
+      for (let i of this.subscriptionStreams[e]) {
+        let r = this.streamsPositions[i];
+        r && (s = !0, t[i] = r);
+      }
+    if (!(!s && !this.restoreSince))
+      return { since: this.restoreSince, streams: t };
+  }
+  trackStreamPosition(e, t, s, i) {
+    if (!(!t || !s))
+      return this.subscriptionStreams[e] || (this.subscriptionStreams[e] = /* @__PURE__ */ new Set()), this.subscriptionStreams[e].add(t), this.streamsPositions[t] = { epoch: s, offset: i }, { stream: t, epoch: s, offset: i };
+  }
+  // Send pongs asynchrounously—no need to block the main thread
+  async sendPong() {
+    await new Promise((e) => setTimeout(e, 0)), this.cable.state === "connected" && this.cable.send({ command: "pong" });
+  }
+  async join(e, t) {
+    return this.presenceInfo[e] = t, this.cable.send({
+      command: "join",
+      identifier: e,
+      presence: t
+    }), Promise.resolve();
+  }
+  async leave(e, t) {
+    return delete this.presenceInfo[e], this.cable.send({
+      command: "leave",
+      identifier: e,
+      presence: t
+    }), Promise.resolve();
+  }
+  presence(e, t) {
+    return this.pendingPresence[e] ? (this.logger.warn("presence is already pending, skipping", e), Promise.reject(Error("presence request is already pending"))) : new Promise((s, i) => {
+      this.pendingPresence[e] = {
+        resolve: s,
+        reject: i
+      }, this.cable.send({
+        command: "presence",
+        identifier: e,
+        data: t
+      });
+    });
+  }
+}
+class ue extends x {
+  constructor() {
+    super("No connection", "closed"), this.name = "NoConnectionError";
+  }
+}
+class B extends J {
+  constructor(e, t) {
+    super(t), this.channelId = e;
+  }
+  set channelId(e) {
+    this._channelId = e;
+  }
+  get channelId() {
+    return this._channelId;
+  }
+}
+A(B, "identifier", "__ghost__");
+const de = "$pubsub";
+class U extends J {
+  async perform(e, t) {
+    if (e.startsWith("$"))
+      return super.perform(e, t);
+    throw Error("not implemented");
+  }
+}
+A(U, "identifier", de);
+const C = Symbol("state");
+class pe {
+  constructor({
+    transport: e,
+    protocol: t,
+    encoder: s,
+    logger: i,
+    lazy: r,
+    hubOptions: o,
+    performFailures: c,
+    transportConfigurator: d
+  }) {
+    this.emitter = j(), this.transport = e, this.encoder = s, this.logger = i || new z(), this.protocol = t, this.performFailures = c || "throw", this.protocol.attached(this), this.hub = new ce(o || {}), this[C] = "idle", this.handleClose = this.handleClose.bind(this), this.handleIncoming = this.handleIncoming.bind(this), this.transportConfigurator = d, this.transport.on("close", this.handleClose), this.transport.on("data", this.handleIncoming), this.initialConnect = !0, this.recovering = !1, r === !1 && this.connect().catch(() => {
+    });
+  }
+  get state() {
+    return this[C];
+  }
+  async connect() {
+    if (this.state === "connected") return Promise.resolve();
+    if (this.state === "connecting")
+      return this.pendingConnect();
+    let e = this.state === "idle";
+    this[C] = "connecting";
+    let t = this.pendingConnect();
+    this.logger.debug("connecting");
+    try {
+      this.transportConfigurator && await this.transportConfigurator(this.transport, {
+        initial: e
+      }), await this.transport.open();
+    } catch (s) {
+      this.handleClose(s);
+    }
+    return t;
+  }
+  setSessionId(e) {
+    this.sessionId = e, this.transport.setParam("sid", e);
+  }
+  connected() {
+    if (this.state === "connected") return;
+    this.logger.info("connected"), this[C] = "connected", this.recovering && this.hub.subscriptions.all().forEach(
+      (t) => t.notify(
+        "disconnected",
+        new v("recovery_failed")
+      )
+    ), this.hub.subscriptions.all().forEach((t) => this._resubscribe(t));
+    let e = !1;
+    this.recovering = !1, this.initialConnect ? (this.initialConnect = !1, this.emit("connect", { reconnect: !1, restored: e })) : this.emit("connect", { reconnect: !0, restored: e });
+  }
+  restored(e) {
+    this.logger.info("connection recovered", { remoteIds: e }), this[C] = "connected", this.hub.subscriptions.all().forEach((i) => {
+      e && i.remoteId && e.includes(i.remoteId) ? i.notify("restored") : (i.notify(
+        "disconnected",
+        new v("recovery_failed")
+      ), this._resubscribe(i));
+    });
+    let t = !this.initialConnect, s = !0;
+    this.recovering = !1, this.initialConnect = !1, this.emit("connect", { reconnect: t, restored: s });
+  }
+  notify(e, t, s) {
+    t && typeof t != "string" && (s = t, t = void 0), t ? this.hub.notify(t, "info", { type: e, data: s }) : this.emit("info", { type: e, data: s });
+  }
+  handleClose(e) {
+    this.logger.debug("transport closed", { error: e }), this.disconnected(new v(e, "transport_closed"));
+  }
+  disconnected(e) {
+    (this.state === "connected" || this.state === "connecting") && (this.logger.info("disconnected", { reason: e }), this[C] = "disconnected", this.recovering = this.protocol.recoverableClosure(e), this.recovering ? this.hub.subscriptions.all().forEach((t) => t.notify("connecting")) : this.hub.subscriptions.all().forEach((t) => {
+      t.notify("disconnected", e);
+    }), this.protocol.reset(e), this.hub.close(), this.transport.close(), this.emit("disconnect", e));
+  }
+  closed(e) {
+    if (this.state === "closed" || this.state === "idle") return;
+    let t;
+    e && (t = e instanceof v ? e : new v(e, void 0)), this.logger.info("closed", { reason: e || "user" }), this[C] = "closed";
+    let s = t || new v("cable_closed");
+    this.hub.subscriptions.all().forEach((i) => i.notify("disconnected", s)), this.hub.close(), this.protocol.reset(), this.transport.close(), this.initialConnect = !0, this.emit("close", t);
+  }
+  disconnect() {
+    this.closed();
+  }
+  handleIncoming(e) {
+    if (this.state === "closed" || this.state === "idle")
+      return;
+    let t = this.encoder.decode(e);
+    if (t === void 0) {
+      this.logger.error("failed to decode message", { message: e });
+      return;
+    }
+    this.logger.debug("incoming data", t);
+    let s = this.protocol.receive(t);
+    if (s) {
+      this.logger.debug("processed incoming message", s);
+      let { type: i, identifier: r, message: o, meta: c } = s;
+      i ? this.hub.notify(r, i, o) : this.hub.transmit(r, o, c);
+    }
+  }
+  send(e) {
+    if (this.state === "closed")
+      throw Error("Cable is closed");
+    let t = this.encoder.encode(e);
+    if (t === void 0) {
+      this.logger.error("failed to encode message", { message: e });
+      return;
+    }
+    this.logger.debug("outgoing message", e), this.transport.send(t);
+  }
+  keepalive(e) {
+    this.emit("keepalive", e);
+  }
+  streamFrom(e) {
+    let t = new U({ stream_name: e });
+    return this.subscribe(t);
+  }
+  streamFromSigned(e) {
+    let t = new U({ signed_stream_name: e });
+    return this.subscribe(t);
+  }
+  subscribeTo(e, t) {
+    let s, i;
+    return typeof e == "string" && (i = e, e = B), s = i ? new e(i, t) : new e(t), this.subscribe(s);
+  }
+  subscribe(e) {
+    if (!e.attached(this)) return e;
+    let t = e.identifier;
+    e.connecting();
+    let s = this.hub.subscriptions.get(t) || this.hub.subscriptions.create(t, {
+      subscribe: (i) => this._subscribe(i, e.channelId, e.params),
+      unsubscribe: (i) => this._unsubscribe(i)
+    });
+    return s.add(e), s.intent === "subscribed" && s.state === "connected" && e.connected(), s.ensureSubscribed(), e;
+  }
+  async _resubscribe(e) {
+    e.intent !== "subscribed" || !e.channels[0] || (e.notify("connecting"), e.ensureResubscribed());
+  }
+  async _subscribe(e, t, s) {
+    let i = e.id;
+    if (this.state === "idle" && this.connect().catch(() => {
+    }), this.state !== "connected") {
+      this.logger.debug("cancel subscribe, no connection", { identifier: i });
+      return;
+    }
+    this.logger.debug("acquiring subscribe lock", { identifier: i });
+    let r = await e.acquire("subscribed");
+    if (r.canceled) {
+      this.logger.debug("subscribe lock has been canceled", { identifier: i }), r.release();
+      return;
+    }
+    if (this.logger.debug("subscribe lock has been acquired", { identifier: i }), e.intent !== "subscribed") {
+      this.logger.debug("cancel subscribe request, already unsubscribed"), r.release();
+      return;
+    }
+    if (this.state !== "connected") {
+      this.logger.debug("cancel subscribe, no connection", { identifier: i }), r.release();
+      return;
+    }
+    if (e.state === "connected") {
+      this.logger.debug("already connected, skip subscribe command", {
+        identifier: i
+      }), e.notify("connected"), r.release();
+      return;
+    }
+    let o = {
+      identifier: t,
+      params: s
+    };
+    this.logger.debug("subscribing", o);
+    try {
+      let c = await this.protocol.subscribe(t, s);
+      this.hub.subscribe(i, c), this.logger.debug("subscribed", { ...o, remoteId: c }), e.notify("connected");
+    } catch (c) {
+      if (c) {
+        if (c instanceof G && this.logger.warn("rejected", o), c instanceof v) {
+          this.logger.debug(
+            "disconnected during subscription; will retry on connect",
+            o
+          ), r.release();
+          return;
+        }
+        this.logger.error("failed to subscribe", {
+          error: c,
+          ...o
+        });
+      }
+      e.close(c), this.hub.unsubscribe(i);
+    }
+    r.release();
+  }
+  unsubscribe(e) {
+    let t = e.identifier, s = this.hub.subscriptions.get(t);
+    if (!s)
+      throw Error(`Subscription not found: ${t}`);
+    s.remove(e), e.closed(), s.maybeUnsubscribe();
+  }
+  async _unsubscribe(e) {
+    let t = e.id;
+    this.logger.debug("acquiring unsubscribe lock", { identifier: t });
+    let s = await e.acquire("unsubscribed");
+    if (s.canceled) {
+      this.logger.debug("unsubscribe lock has been canceled", { identifier: t }), s.release();
+      return;
+    }
+    if (this.logger.debug("unsubscribe lock has been acquired", { identifier: t }), e.intent !== "unsubscribed") {
+      this.logger.debug("cancel unsubscribe, no longer needed", {
+        identifier: t,
+        intent: e.intent
+      }), s.release();
+      return;
+    }
+    if (e.state === "disconnected" || e.state === "closed") {
+      this.logger.debug(
+        `already ${e.state} connected, skip unsubscribe command`,
+        { identifier: t }
+      ), s.release();
+      return;
+    }
+    let i = e.remoteId;
+    if (this.logger.debug("unsubscribing...", { remoteId: i }), this.state !== "connected") {
+      this.logger.debug("unsubscribe skipped (cable is not connected)", {
+        id: t
+      }), e.close(), this.hub.unsubscribe(t), s.release();
+      return;
+    }
+    try {
+      await this.protocol.unsubscribe(i), this.logger.debug("unsubscribed remotely", { id: t });
+    } catch (r) {
+      r && (r instanceof v ? this.logger.debug(
+        "cable disconnected during the unsubscribe command execution",
+        { id: t, error: r }
+      ) : this.logger.error("unsubscribe failed", {
+        id: t,
+        error: r
+      }));
+    }
+    e.intent === "unsubscribed" ? (e.close(), this.hub.unsubscribe(t)) : e.state = "closed", s.release();
+  }
+  async perform(e, t, s) {
+    if (this.performFailures === "throw")
+      return this._perform(e, t, s);
+    try {
+      return await this._perform(e, t, s);
+    } catch (i) {
+      this.performFailures === "warn" && this.logger.warn("perform failed", { error: i });
+      return;
+    }
+  }
+  async _perform(e, t, s) {
+    if (this.state === "connecting" && await this.pendingConnect(), this.state === "closed" || this.state === "disconnected")
+      throw new ue();
+    let i = this.hub.subscriptions.get(e);
+    if (!i)
+      throw Error(`Subscription not found: ${e}`);
+    if (await i.pending("subscribed"), i.intent !== "subscribed")
+      throw Error(`Subscription is closed: ${e}`);
+    let r = i.remoteId, o = {
+      id: r,
+      action: t,
+      payload: s
+    };
+    this.logger.debug("perform", o);
+    try {
+      let c = await this.protocol.perform(r, t, s);
+      return c && this.logger.debug("perform result", {
+        message: c,
+        request: o
+      }), c;
+    } catch (c) {
+      throw this.logger.error("perform failed", {
+        error: c,
+        request: o
+      }), c;
+    }
+  }
+  on(e, t) {
+    return this.emitter.on(e, t);
+  }
+  once(e, t) {
+    let s = this.emitter.on(e, (...i) => {
+      s(), t(...i);
+    });
+    return s;
+  }
+  emit(e, ...t) {
+    return this.emitter.emit(e, ...t);
+  }
+  pendingConnect() {
+    return this._pendingConnect ? this._pendingConnect : (this._pendingConnect = new Promise((e, t) => {
+      let s = [() => delete this._pendingConnect];
+      s.push(
+        this.on("connect", () => {
+          s.forEach((i) => i()), e();
+        })
+      ), s.push(
+        this.on("close", (i) => {
+          s.forEach((r) => r()), t(i);
+        })
+      ), s.push(
+        this.on("disconnect", (i) => {
+          s.forEach((r) => r()), t(i);
+        })
+      );
+    }), this._pendingConnect);
+  }
+}
+const fe = {
+  maxMissingPings: 2,
+  maxReconnectAttempts: 1 / 0
+}, k = () => Date.now(), K = (n, e) => {
+  e = e || {};
+  let { backoffRate: t, jitterRatio: s, maxInterval: i } = e;
+  return t = t || 2, s === void 0 && (s = 0.5), (r) => {
+    let o = n * t ** r, c = o * t, d = o + (c - o) * Math.random(), p = 2 * (Math.random() - 0.5) * s;
+    return d = d * (1 + p), i && i < d && (d = i), d;
+  };
+};
+let X = class {
+  constructor({ pingInterval: e, ...t }) {
+    if (this.pingInterval = e, !this.pingInterval)
+      throw Error(`Incorrect pingInterval is provided: ${e}`);
+    if (t = Object.assign({}, fe, t), this.strategy = t.reconnectStrategy, !this.strategy)
+      throw Error("Reconnect strategy must be provided");
+    this.maxMissingPings = t.maxMissingPings, this.maxReconnectAttempts = t.maxReconnectAttempts, this.logger = t.logger || new z(), this.state = "pending_connect", this.attempts = 0, this.disconnectedAt = k();
+  }
+  watch(e) {
+    this.target = e, this.initListeners();
+  }
+  reconnectNow() {
+    return this.state === "connected" || this.state === "pending_connect" || this.state === "closed" ? !1 : (this.cancelReconnect(), this.state = "pending_connect", this.target.connect().catch((e) => {
+      this.logger.info("Failed at reconnecting: " + e);
+    }), !0);
+  }
+  initListeners() {
+    this.unbind = [], this.unbind.push(
+      this.target.on("connect", () => {
+        this.attempts = 0, this.pingedAt = k(), this.state = "connected", this.cancelReconnect(), this.startPolling();
+      })
+    ), this.unbind.push(
+      this.target.on("disconnect", () => {
+        this.disconnectedAt = k(), this.state = "disconnected", this.stopPolling(), this.scheduleReconnect();
+      })
+    ), this.unbind.push(
+      this.target.on("close", () => {
+        this.disconnectedAt = k(), this.state = "closed", this.cancelReconnect(), this.stopPolling();
+      })
+    ), this.unbind.push(
+      this.target.on("keepalive", () => {
+        this.pingedAt = k();
+      })
+    ), this.unbind.push(() => {
+      this.cancelReconnect(), this.stopPolling();
+    });
+  }
+  dispose() {
+    delete this.target, this.unbind && this.unbind.forEach((e) => e()), delete this.unbind;
+  }
+  startPolling() {
+    this.pollId && clearTimeout(this.pollId);
+    let e = this.pingInterval + (Math.random() - 0.5) * this.pingInterval * 0.5;
+    this.pollId = setTimeout(() => {
+      this.checkStale(), this.state === "connected" && this.startPolling();
+    }, e);
+  }
+  stopPolling() {
+    this.pollId && clearTimeout(this.pollId);
+  }
+  checkStale() {
+    let e = k() - this.pingedAt;
+    e > this.maxMissingPings * this.pingInterval && (this.logger.warn(`Stale connection: ${e}ms without pings`), this.state = "pending_disconnect", this.target.disconnected(new se()));
+  }
+  scheduleReconnect() {
+    if (this.attempts >= this.maxReconnectAttempts) {
+      this.target.close();
+      return;
+    }
+    let e = this.strategy(this.attempts);
+    this.attempts++, this.logger.info(`Reconnecting in ${e}ms (${this.attempts} attempt)`), this.state = "pending_reconnect", this.reconnnectId = setTimeout(() => this.reconnectNow(), e);
+  }
+  cancelReconnect() {
+    this.reconnnectId && (clearTimeout(this.reconnnectId), delete this.reconnnectId);
+  }
+};
+class be {
+  constructor(e, t = {}) {
+    this.transports = e, this.transport = null, this.emitter = j(), this.unbind = [], this.logger = t.logger || new z();
+  }
+  displayName() {
+    return "fallbacked transport";
+  }
+  async open() {
+    for (let e = 0; e < this.transports.length; e++) {
+      let t = this.transports[e];
+      try {
+        this.transport = t, this.resetListeners(), this.logger.debug(`Trying to connect via ${t.displayName()}`), await t.open(), this.logger.debug(`Connected via ${t.displayName()}`);
+        return;
+      } catch (s) {
+        this.logger.debug(
+          `Failed to connect via ${t.displayName()}: ${s.message}`
+        );
+      }
+    }
+    throw this.transport = null, this.resetListeners(), new Error("Couldn't connect via any available transport");
+  }
+  send(e) {
+    if (!this.transport)
+      throw new Error("No transport is open");
+    this.transport.send(e);
+  }
+  async close() {
+    if (!this.transport)
+      throw new Error("No transport is open");
+    await this.transport.close(), this.transport = null;
+  }
+  setURL() {
+    throw new Error("Not implemented. Set URL for each transport separately");
+  }
+  setParam(e, t) {
+    this.transports.forEach((s) => {
+      s.setParam(e, t);
+    });
+  }
+  setToken(e, t) {
+    this.transports.forEach((s) => {
+      s.setToken(e, t);
+    });
+  }
+  on(e, t) {
+    return this.emitter.on(e, t);
+  }
+  once(e, t) {
+    let s = this.emitter.on(e, (...i) => {
+      s(), t(...i);
+    });
+    return s;
+  }
+  get url() {
+    return this.transport ? this.transport.url : "";
+  }
+  resetListeners() {
+    this.unbind.forEach((e) => e()), this.unbind.length = 0, this.transport && this.unbind.push(
+      this.transport.on("open", () => {
+        this.emitter.emit("open");
+      }),
+      this.transport.on("data", (e) => {
+        this.emitter.emit("data", e);
+      }),
+      this.transport.on("close", (e) => {
+        this.emitter.emit("close", e);
+      }),
+      this.transport.on("error", (e) => {
+        this.emitter.emit("error", e);
+      })
+    );
+  }
+}
+class ge {
+  constructor(e, t = {}) {
+    this.url = e;
+    let s = t.websocketImplementation;
+    if (s)
+      this.Impl = s;
+    else if (typeof WebSocket < "u")
+      this.Impl = WebSocket;
+    else
+      throw new Error("No WebSocket support");
+    this.connected = !1, this.emitter = j();
+    let { format: i, subprotocol: r, authStrategy: o } = t;
+    this.format = i || "text", this.connectionOptions = t.websocketOptions, this.authStrategy = o || "param", this.authProtocol = "", this.subprotocol = r;
+  }
+  displayName() {
+    return "WebSocket(" + this.url + ")";
+  }
+  open() {
+    let e = this.subprotocol;
+    return this.authStrategy === "sub-protocol" && (e = [this.subprotocol, this.authProtocol]), this.connectionOptions ? this.ws = new this.Impl(this.url, e, this.connectionOptions) : this.ws = new this.Impl(this.url, e), this.ws.binaryType = "arraybuffer", this.initListeners(), new Promise((t, s) => {
+      let i = [];
+      i.push(
+        this.once("open", () => {
+          i.forEach((r) => r()), t();
+        })
+      ), i.push(
+        this.once("close", () => {
+          i.forEach((r) => r()), s(Error("WS connection closed"));
+        })
+      );
+    });
+  }
+  setURL(e) {
+    this.url = e;
+  }
+  setParam(e, t) {
+    let s = new URL(this.url);
+    s.searchParams.set(e, t);
+    let i = `${s.protocol}//${s.host}${s.pathname}?${s.searchParams}`;
+    this.setURL(i);
+  }
+  setToken(e, t = "jid") {
+    if (this.authStrategy === "param")
+      this.setParam(t, e);
+    else if (this.authStrategy === "header") {
+      this.connectionOptions = this.connectionOptions || {}, this.connectionOptions.headers = this.connectionOptions.headers || {};
+      let s = `x-${t}`.toLowerCase();
+      s = Object.keys(this.connectionOptions.headers).find(
+        (r) => r.toLowerCase() === s
+      ) || s, this.connectionOptions.headers[s] = e;
+    } else if (this.authStrategy === "sub-protocol")
+      this.authProtocol = `anycable-token.${e}`;
+    else
+      throw new Error("Unknown auth strategy: " + this.authStrategy);
+  }
+  send(e) {
+    if (!this.ws || !this.connected)
+      throw Error("WebSocket is not connected");
+    this.ws.send(e);
+  }
+  close() {
+    this.ws ? this.onclose() : this.connected = !1;
+  }
+  on(e, t) {
+    return this.emitter.on(e, t);
+  }
+  once(e, t) {
+    let s = this.emitter.on(e, (...i) => {
+      s(), t(...i);
+    });
+    return s;
+  }
+  initListeners() {
+    this.ws.onerror = (e) => {
+      this.connected && this.emitter.emit("error", e.error || new Error("WS Error"));
+    }, this.ws.onclose = () => {
+      this.onclose();
+    }, this.ws.onmessage = (e) => {
+      let t = e.data;
+      this.format === "binary" && (t = new Uint8Array(t)), this.emitter.emit("data", t);
+    }, this.ws.onopen = () => {
+      this.connected = !0, this.emitter.emit("open");
+    };
+  }
+  onclose() {
+    this.ws.onclose = void 0, this.ws.onmessage = void 0, this.ws.onopen = void 0, this.ws.close(), delete this.ws, this.connected = !1, this.emitter.emit("close");
+  }
+}
+const Y = {
+  protocol: "actioncable-v1-json",
+  pingInterval: 3e3,
+  maxReconnectAttempts: 1 / 0,
+  maxMissingPings: 2,
+  logLevel: "warn",
+  lazy: !0
+};
+function me(n, e) {
+  if (typeof n == "object" && typeof e > "u" && (e = n, n = void 0), e = e || {}, !n && !e.transport) throw Error("URL or transport must be specified");
+  e = Object.assign({}, Y, e);
+  let {
+    protocol: t,
+    websocketImplementation: s,
+    websocketFormat: i,
+    websocketOptions: r,
+    websocketAuthStrategy: o,
+    fallbacks: c,
+    logLevel: d,
+    logger: p,
+    transport: y,
+    encoder: _,
+    lazy: I,
+    monitor: S,
+    pingInterval: L,
+    reconnectStrategy: T,
+    maxMissingPings: O,
+    maxReconnectAttempts: R,
+    subprotocol: P,
+    tokenRefresher: a,
+    historyTimestamp: h,
+    protocolOptions: l,
+    concurrentSubscribes: w,
+    performFailures: g,
+    transportConfigurator: m,
+    auth: f
+  } = e;
+  if (p = p || new z(d), typeof t == "string") {
+    P = P || t;
+    let E = t.substring(0, t.lastIndexOf("-")), N = t.substring(t.lastIndexOf("-") + 1);
+    if (l = l || {}, E === "actioncable-v1")
+      t = new H({ logger: p, ...l });
+    else if (E === "actioncable-v1-ext")
+      t = new le({
+        logger: p,
+        historyTimestamp: h,
+        ...l
+      });
+    else
+      throw Error(`Protocol is not supported yet: ${t}`);
+    if (N === "json")
+      _ = _ || new ae(), i = i || "text";
+    else if (N === "msgpack") {
+      if (i = "binary", !_)
+        throw Error(
+          "Msgpack encoder must be specified explicitly. Use `@anycable/msgpack-encoder` package or build your own"
+        );
+    } else if (N === "protobuf") {
+      if (i = i || "binary", !_)
+        throw Error(
+          "Protobuf encoder must be specified explicitly. Use `@anycable/protobuf-encoder` package or build your own"
+        );
+    } else
+      throw Error(`Protocol is not supported yet: ${t}`);
+  }
+  if (!t) throw Error("Protocol must be specified");
+  y = y || new ge(n, {
+    websocketImplementation: s,
+    websocketOptions: r,
+    subprotocol: P,
+    authStrategy: o,
+    format: i
+  }), c && (y = new be([y, ...c], { logger: p })), f && f.token && y.setToken(f.token, f.param || "jid"), T = T || K(L), S !== !1 && (S = S || new X({
+    pingInterval: L,
+    reconnectStrategy: T,
+    maxMissingPings: O,
+    maxReconnectAttempts: R,
+    logger: p
+  }));
+  let u = { concurrentSubscribes: w }, b = new pe({
+    protocol: t,
+    transport: y,
+    encoder: _,
+    logger: p,
+    lazy: I,
+    hubOptions: u,
+    performFailures: g,
+    transportConfigurator: m
+  });
+  return S && (S.watch(b), b.monitor = S), a && ye(b, async () => {
+    try {
+      await a(y);
+    } catch (E) {
+      return p.error("Failed to refresh authentication token: " + E), !1;
+    }
+    return b.connect().catch(() => {
+    }), !0;
+  }), b;
+}
+function ye(n, e) {
+  let t = !1;
+  n.on("connect", () => t = !1), n.on("close", async (s) => {
+    if (s) {
+      if (t) {
+        n.logger.warn("Token auto-refresh is disabled", s);
+        return;
+      }
+      s.reason === "token_expired" && (t = !0, await e());
+    }
+  });
+}
+class we extends V {
+  writeLogEntry(e, t, s) {
+    s ? console[e](t, s) : console[e](t);
+  }
+}
+class Se extends X {
+  watch(e) {
+    super.watch(e), this.initActivityListeners();
+  }
+  initActivityListeners() {
+    if (typeof document < "u" && typeof window < "u" && document.addEventListener && window.addEventListener) {
+      let e = () => {
+        document.hidden || this.reconnectNow() && this.logger.debug("Trigger reconnect due to visibility change");
+      }, t = (i) => {
+        this.reconnectNow() && this.logger.debug("Trigger reconnect", { event: i });
+      }, s = () => this.disconnect(new v("page_frozen"));
+      document.addEventListener("visibilitychange", e, !1), window.addEventListener("focus", t, !1), window.addEventListener("online", t, !1), window.addEventListener("resume", t, !1), window.addEventListener("freeze", s, !1), this.unbind.push(() => {
+        document.removeEventListener("visibilitychange", e, !1), window.removeEventListener("focus", t, !1), window.removeEventListener("online", t, !1), window.removeEventListener("resume", t, !1), window.removeEventListener("freeze", s, !1);
+      });
+    }
+  }
+  disconnect(e) {
+    this.state === "disconnected" || this.state === "closed" || (this.logger.info("Disconnecting", { reason: e.message }), this.cancelReconnect(), this.stopPolling(), this.state = "pending_disconnect", this.target.disconnected(e));
+  }
+}
+const ve = ["cable", "action-cable"], _e = "/cable", $ = (n, e) => {
+  for (let t of ve) {
+    let s = n.head.querySelector(`meta[name='${t}-${e}']`);
+    if (s)
+      return s.getAttribute("content");
+  }
+}, D = (n) => n.match(/wss?:\/\//) ? n : typeof window < "u" ? `${window.location.protocol.replace("http", "ws")}//${window.location.host}${n}` : n, Ie = () => {
+  if (typeof document < "u" && document.head) {
+    let n = $(document, "url");
+    if (n)
+      return D(n);
+  }
+  return D(_e);
+}, Ee = () => {
+  if (typeof document < "u" && document.head) {
+    let n = $(document, "history-timestamp");
+    if (n)
+      return n | 0;
+  }
+}, qe = () => {
+  if (typeof document < "u" && document.head)
+    return $(document, "token");
+}, Ce = () => {
+  if (typeof document < "u" && document.head)
+    return $(document, "token-param");
+};
+function Pe(n, e) {
+  typeof n == "object" && typeof e > "u" && (e = n, n = void 0), n = n || Ie(), e = e || {}, e.historyTimestamp || (e.historyTimestamp = Ee());
+  let t = qe();
+  if (t) {
+    let p = Ce();
+    e.auth = Object.assign({ token: t, param: p }, e.auth || {});
+  }
+  e = Object.assign({}, Y, e);
+  let {
+    logLevel: s,
+    logger: i,
+    pingInterval: r,
+    reconnectStrategy: o,
+    maxMissingPings: c,
+    maxReconnectAttempts: d
+  } = e;
+  return i = e.logger = e.logger || new we(s), o = e.reconnectStrategy = e.reconnectStrategy || K(r), e.monitor !== !1 && (e.monitor = e.monitor || new Se({
+    pingInterval: r,
+    reconnectStrategy: o,
+    maxMissingPings: c,
+    maxReconnectAttempts: d,
+    logger: i
+  })), me(n, e);
+}
+const ke = {
+  answer: "/.netlify/functions/quiz-answer",
+  sync: "/.netlify/functions/quiz-sync"
+};
+function Te(n) {
+  if (typeof n != "object" || n === null) return !1;
+  const e = n;
+  return typeof e.sessionId == "string" && (e.activeQuizId === null || typeof e.activeQuizId == "string") && typeof e.results == "object" && e.results !== null;
+}
+function xe(n) {
+  if (typeof n != "object" || n === null) return !1;
+  const e = n;
+  return typeof e.quizId == "string" && typeof e.answer == "string" && typeof e.sessionId == "string";
+}
+class ze {
+  constructor(e) {
+    this.resultsChannel = null, this.activeQuizId = null, this.results = {}, this.voters = {}, this.online = 0, this.submitted = {}, this.listeners = [], this.syncTimer = null, this.syncPending = !1, this.incomingSyncTimer = null, this.incomingSyncData = null, this.role = e.role, this.quizGroupId = e.quizGroupId, this.sessionId = e.sessionId || this.getOrCreateSessionId(), this.endpoints = { ...ke, ...e.endpoints };
+    const t = e.role === "participant" ? 6e4 : 3e5;
+    this.cable = Pe(e.wsUrl, {
+      protocol: "actioncable-v1-ext-json",
+      protocolOptions: {
+        historyTimestamp: Math.floor((Date.now() - t) / 1e3)
+      }
+    }), this.syncChannel = this.cable.streamFrom(
+      `quiz:${e.quizGroupId}:sync`
+    ), this.syncChannel.on("message", this.onSyncMessage.bind(this));
+    const s = this.syncChannel.presence;
+    if (typeof s.stateFromInfo == "function") {
+      const i = s.stateFromInfo.bind(s);
+      s.stateFromInfo = (r) => {
+        if (!(r != null && r.records)) {
+          if (r && typeof r == "object") {
+            const { type: o, ...c } = r;
+            return c;
+          }
+          return {};
+        }
+        return i(r);
+      };
+    }
+    this.syncChannel.on("presence", this.onPresence.bind(this)), e.role === "participant" && this.syncChannel.presence.join(this.sessionId, { id: this.sessionId }), this.syncChannel.presence.info().then((i) => {
+      i && (this.online = Object.keys(i).length, this.notifyStateChange());
+    }).catch(() => {
+    }), e.role === "presenter" && (this.resultsChannel = this.cable.streamFrom(
+      `quiz:${e.quizGroupId}:results`
+    ), this.resultsChannel.on("message", this.onResultsMessage.bind(this)), this.restoreState(), this.activeQuizId && this.sendSync()), e.role === "participant" && this.restoreSubmitted();
+  }
+  // ── Public API ──
+  subscribe(e) {
+    return this.listeners.push(e), e(this.getState()), () => {
+      const t = this.listeners.indexOf(e);
+      t !== -1 && this.listeners.splice(t, 1);
+    };
+  }
+  getState() {
+    return {
+      activeQuizId: this.activeQuizId,
+      results: structuredClone(this.results),
+      online: this.online,
+      submitted: { ...this.submitted }
+    };
+  }
+  getQuizState(e) {
+    return this.results[e] || { votes: {}, total: 0 };
+  }
+  hasVoted(e) {
+    return e in this.submitted;
+  }
+  getVotedAnswer(e) {
+    return this.submitted[e] ?? null;
+  }
+  /** Presenter: set the active quiz (called when slide enters viewport) */
+  setActiveQuiz(e) {
+    this.role === "presenter" && this.activeQuizId !== e && (this.activeQuizId = e, this.saveState(), this.sendSync());
+  }
+  /** Participant: submit an answer */
+  async submitAnswer(e, t) {
+    if (this.hasVoted(e)) return !1;
+    try {
+      const s = await fetch(this.endpoints.answer, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          quizId: e,
+          answer: t,
+          sessionId: this.sessionId,
+          quizGroupId: this.quizGroupId
+        })
+      });
+      return s.ok && (this.submitted[e] = t, this.saveSubmitted(), this.notifyStateChange()), s.ok;
+    } catch {
+      return !1;
+    }
+  }
+  disconnect() {
+    this.role === "participant" && this.syncChannel.presence.leave(), this.cable.disconnect();
+  }
+  // ── Message Handlers ──
+  onSyncMessage(e) {
+    const t = this.parse(e);
+    Te(t) && t.sessionId !== this.sessionId && this.role === "participant" && this.applySyncThrottled(t);
+  }
+  applySyncThrottled(e) {
+    if (this.incomingSyncTimer) {
+      this.incomingSyncData = e;
+      return;
+    }
+    this.applySync(e), this.incomingSyncData = null, this.incomingSyncTimer = setTimeout(() => {
+      this.incomingSyncTimer = null, this.incomingSyncData && (this.applySync(this.incomingSyncData), this.incomingSyncData = null);
+    }, 200);
+  }
+  applySync(e) {
+    var t;
+    this.activeQuizId = e.activeQuizId, this.results = e.results;
+    for (const s of Object.keys(this.submitted))
+      (((t = e.results[s]) == null ? void 0 : t.total) ?? 0) === 0 && this.clearVotedAnswer(s);
+    this.notifyStateChange();
+  }
+  onResultsMessage(e) {
+    if (this.role !== "presenter") return;
+    const t = this.parse(e);
+    if (!xe(t) || t.sessionId === this.sessionId) return;
+    const { quizId: s, answer: i, sessionId: r } = t;
+    this.voters[s] || (this.voters[s] = /* @__PURE__ */ new Set()), !this.voters[s].has(r) && (this.voters[s].add(r), this.results[s] || (this.results[s] = { votes: {}, total: 0 }), this.results[s].votes[i] = (this.results[s].votes[i] || 0) + 1, this.results[s].total += 1, this.saveState(), this.notifyStateChange(), this.sendSyncThrottled());
+  }
+  async onPresence() {
+    try {
+      const e = await this.syncChannel.presence.info();
+      e && (this.online = Object.keys(e).length, this.notifyStateChange(), this.role === "presenter" && this.activeQuizId && this.sendSyncThrottled());
+    } catch {
+    }
+  }
+  // ── Sync Broadcasting ──
+  sendSyncThrottled() {
+    if (this.syncTimer) {
+      this.syncPending = !0;
+      return;
+    }
+    this.sendSync(), this.syncTimer = setTimeout(() => {
+      this.syncTimer = null, this.syncPending && (this.syncPending = !1, this.sendSync());
+    }, 200);
+  }
+  async sendSync() {
+    if (this.role === "presenter")
+      try {
+        await fetch(this.endpoints.sync, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            activeQuizId: this.activeQuizId,
+            sessionId: this.sessionId,
+            quizGroupId: this.quizGroupId,
+            results: this.results
+          })
+        });
+      } catch {
+      }
+  }
+  // ── Persistence ──
+  getOrCreateSessionId() {
+    const e = `quiz-session-${this.quizGroupId}`;
+    let t = sessionStorage.getItem(e);
+    return t || (t = crypto.randomUUID(), sessionStorage.setItem(e, t)), t;
+  }
+  saveState() {
+    if (this.role === "presenter")
+      try {
+        sessionStorage.setItem(
+          `quiz-presenter-${this.quizGroupId}`,
+          JSON.stringify({
+            activeQuizId: this.activeQuizId,
+            results: this.results,
+            voters: Object.fromEntries(
+              Object.entries(this.voters).map(([e, t]) => [e, [...t]])
+            )
+          })
+        );
+      } catch (e) {
+        console.warn("[QuizManager] saveState failed:", e);
+      }
+  }
+  restoreState() {
+    try {
+      const e = sessionStorage.getItem(
+        `quiz-presenter-${this.quizGroupId}`
+      );
+      if (!e) return;
+      const t = JSON.parse(e);
+      if (t.activeQuizId && (this.activeQuizId = t.activeQuizId), t.results && (this.results = t.results), t.voters)
+        for (const [s, i] of Object.entries(t.voters))
+          this.voters[s] = new Set(i);
+    } catch {
+    }
+  }
+  saveSubmitted() {
+    try {
+      sessionStorage.setItem(
+        `quiz-submitted-${this.quizGroupId}`,
+        JSON.stringify(this.submitted)
+      );
+    } catch {
+    }
+  }
+  restoreSubmitted() {
+    try {
+      const e = sessionStorage.getItem(
+        `quiz-submitted-${this.quizGroupId}`
+      );
+      if (!e) return;
+      this.submitted = JSON.parse(e);
+    } catch {
+    }
+  }
+  clearVotedAnswer(e) {
+    delete this.submitted[e], this.saveSubmitted();
+  }
+  // ── Helpers ──
+  notifyStateChange() {
+    const e = this.getState();
+    for (const t of this.listeners) t(e);
+  }
+  parse(e) {
+    if (typeof e == "string")
+      try {
+        return JSON.parse(e);
+      } catch {
+        return {};
+      }
+    return e && typeof e == "object" ? e : {};
+  }
+}
+const M = /* @__PURE__ */ new Map();
+function Le(n) {
+  return M.has(n.quizGroupId) || M.set(
+    n.quizGroupId,
+    new ze({ ...n, role: "participant" })
+  ), M.get(n.quizGroupId);
+}
+function Oe(n, e) {
+  const t = document.querySelector(n);
+  if (!t)
+    throw new Error(`[live-quiz] Element not found: ${n}`);
+  const { questions: s, brandText: i, footerText: r = "Powered by AnyCable" } = e;
+  if (t.innerHTML = "", t.classList.add("lq-participant"), i) {
+    const a = document.createElement("p");
+    a.className = "lq-participant__brand", a.textContent = i, t.appendChild(a);
+  }
+  const o = document.createElement("div");
+  o.className = "lq-participant__stats";
+  const c = document.createElement("span");
+  c.className = "lq-participant__online", c.textContent = "0";
+  const d = document.createElement("span");
+  d.className = "lq-participant__answered", d.textContent = "0", o.append(c, " online · ", d, " answered"), t.appendChild(o);
+  const p = document.createElement("div");
+  p.className = "lq-participant__waiting", p.textContent = "Waiting for the next question...", t.appendChild(p);
+  const y = {};
+  let _ = 0;
+  for (const a of s) {
+    const h = document.createElement("div");
+    h.className = "lq-participant__section lq-participant__section--hidden", h.dataset.quizId = a.quizId;
+    const l = document.createElement("p");
+    l.className = "lq-participant__number", l.textContent = `Question ${_ + 1} of ${s.length}`, h.appendChild(l);
+    const w = document.createElement("h2");
+    w.className = "lq-participant__question", w.textContent = a.question, h.appendChild(w);
+    const g = document.createElement("div");
+    g.className = "lq-participant__options";
+    for (const f of a.options) {
+      const u = document.createElement("button");
+      u.type = "button", u.className = "lq-participant__btn", u.dataset.answer = f.label;
+      const b = document.createElement("span");
+      b.className = "lq-participant__btn-label", b.textContent = f.label;
+      const E = document.createElement("span");
+      E.textContent = f.text, u.append(b, E), g.appendChild(u);
+    }
+    h.appendChild(g);
+    const m = document.createElement("p");
+    m.className = "lq-participant__status", m.setAttribute("role", "status"), m.setAttribute("aria-live", "polite"), h.appendChild(m), t.appendChild(h), y[a.quizId] = h, _++;
+  }
+  if (r) {
+    const a = document.createElement("p");
+    a.className = "lq-participant__footer", a.textContent = r, t.appendChild(a);
+  }
+  const I = Le({
+    wsUrl: e.wsUrl,
+    quizGroupId: e.quizGroupId,
+    endpoints: e.endpoints
+  });
+  let S = null;
+  function L(a) {
+    S = a;
+    for (const [h, l] of Object.entries(y))
+      h === a ? l.classList.remove("lq-participant__section--hidden") : l.classList.add("lq-participant__section--hidden");
+    a ? p.style.display = "none" : p.style.display = "";
+  }
+  function T(a, h) {
+    var u;
+    const l = y[a];
+    if (!l) return;
+    const w = l.querySelectorAll(".lq-participant__btn"), g = l.querySelector(".lq-participant__status");
+    for (const b of w)
+      b.disabled = !0, b.setAttribute("aria-disabled", "true"), b.dataset.answer === h ? b.classList.add("lq-participant__btn--selected") : b.classList.add("lq-participant__btn--faded");
+    const m = ((u = l.querySelector(`[data-answer="${h}"] span:last-child`)) == null ? void 0 : u.textContent) || h;
+    g.textContent = "";
+    const f = document.createElement("strong");
+    f.textContent = m, g.append(f, " — submitted!");
+  }
+  function O(a) {
+    const h = y[a];
+    if (!h) return;
+    const l = h.querySelectorAll(".lq-participant__btn"), w = h.querySelector(".lq-participant__status");
+    for (const g of l)
+      g.disabled = !1, g.removeAttribute("aria-disabled"), g.classList.remove("lq-participant__btn--selected", "lq-participant__btn--faded");
+    w.textContent = "";
+  }
+  const R = I.subscribe((a) => {
+    a.activeQuizId !== void 0 && L(a.activeQuizId), c.textContent = String(a.online), S && a.results[S] && (d.textContent = String(
+      a.results[S].total
+    ));
+    for (const h of s) {
+      const l = a.submitted[h.quizId];
+      l ? T(h.quizId, l) : O(h.quizId);
+    }
+  });
+  for (const a of s) {
+    const h = y[a.quizId];
+    if (!h) continue;
+    const l = h.querySelectorAll(".lq-participant__btn"), w = h.querySelector(".lq-participant__status");
+    async function g(m) {
+      for (const u of l)
+        u.disabled = !0, u.setAttribute("aria-disabled", "true"), u.dataset.answer === m ? u.classList.add("lq-participant__btn--selected") : u.classList.add("lq-participant__btn--faded");
+      if (w.textContent = "Sending...", !await I.submitAnswer(a.quizId, m) && !I.hasVoted(a.quizId)) {
+        w.textContent = "Something went wrong. Try again!";
+        for (const u of l)
+          u.disabled = !1, u.removeAttribute("aria-disabled"), u.classList.remove(
+            "lq-participant__btn--selected",
+            "lq-participant__btn--faded"
+          );
+      }
+    }
+    for (const m of l)
+      m.addEventListener("click", () => {
+        const f = m.dataset.answer;
+        f && !I.hasVoted(a.quizId) && g(f);
+      });
+  }
+  function P() {
+    I.disconnect();
+  }
+  return window.addEventListener("pagehide", P), {
+    destroy() {
+      R(), window.removeEventListener("pagehide", P), I.disconnect(), t.innerHTML = "", t.classList.remove("lq-participant");
+    }
+  };
+}
+export {
+  Oe as createParticipantUI
+};