@sendity/client 0.1.0

package/dist/sendity-client.js

@@ -0,0 +1,4459 @@
+const pt = `<template id="sendity-tpl">
+    <div class="sendity flex items-center">
+        <slot id="prompt">
+            <div class="prompt" aria-live="polite" aria-atomic="true" hidden></div>
+        </slot>
+
+        <div class="code" aria-live="polite" aria-atomic="true">
+            <span class="spinner" aria-hidden="true"></span>
+            <span class="formatted-code" data-placeholder="••••" hidden>&nbsp;</span>
+        </div>
+
+        <div class="success" aria-live="polite" aria-atomic="true" hidden></div>
+
+        <div class="verifiers">
+            <!-- Links will be inserted here -->
+        </div>
+
+        <footer class="sendity-footer" aria-live="polite" aria-atomic="true">
+            <span class="footer-brand">Secure passwordless authentication by <span class="footer-logo">sendity.io</span></span>
+            <span class="footer-status" hidden>
+                <span class="footer-spinner" aria-hidden="true"></span>
+                <span class="footer-message"></span>
+            </span>
+        </footer>
+    </div>
+</template>
+`, Ni = `:host {
+    /* Theme variables (override these on the host page or on the Sendity Client host element) */
+    --sendity-color: #111827; /* text-gray-900 */
+    --sendity-primary-color: #14b8a6; /* teal-500 */
+    --sendity-success-color: #14b8a6; /* teal-500 */
+    --sendity-error-color: #b91c1c; /* red-700 */
+
+    --sendity-font-size: 1rem; /* text-base */
+    --sendity-font-size-sm: 0.875rem; /* text-sm */
+    --sendity-font-family: system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, "Helvetica Neue", Arial, "Apple Color Emoji", "Segoe UI Emoji";
+
+    --sendity-code-font-size: 1.5rem; /* text-lg */
+    --sendity-code-font-weight: 600;
+    --sendity-code-font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    --sendity-code-bg: #f3f4f6; /* gray-100 */
+    --sendity-code-padding: 0.5rem 0.75rem; /* px-3 py-2 */
+    --sendity-code-color: var(--sendity-color);
+    --sendity-code-border-size: 0px;
+    --sendity-code-border-color: transparent;
+    --sendity-code-border-radius: 0.375rem; /* rounded-md */
+    --sendity-code-validity-duration: 600s;
+
+    --sendity-btn-font-size: var(--sendity-font-size);
+    --sendity-btn-border-size: 0px;
+    --sendity-btn-border-color: transparent;
+    --sendity-btn-border-radius: 0.375rem;
+    --sendity-btn-padding: 0.5rem 0.75rem;
+    --sendity-btn-bg: var(--sendity-primary-color);
+    --sendity-btn-color: #fff;
+    --sendity-success-check-bg: var(--sendity-success-color);
+    --sendity-success-check-color: #ffffff;
+}
+
+.sendity {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    font-family: var(--sendity-font-family);
+    font-size: var(--sendity-font-size);
+    color: var(--sendity-color);
+    text-align: center;
+}
+
+.sendity .branding {
+    font-weight: 600;
+}
+
+.sendity .code {
+    position: relative;
+    font-variant-numeric: tabular-nums; /* keep digits aligned */
+    font-feature-settings: "tnum";
+    padding: var(--sendity-code-padding);
+    border-radius: var(--sendity-code-border-radius);
+    background: var(--sendity-code-bg);
+    color: var(--sendity-code-color);
+    border: var(--sendity-code-border-size) solid var(--sendity-code-border-color);
+    min-height: 2rem;
+    max-height: 4rem;
+    display: inline-grid;
+    place-items: center;
+    text-align: center;
+    gap: 0.5rem;
+    overflow: hidden;
+    transition: opacity 160ms ease, transform 160ms ease, max-height 180ms ease, min-height 180ms ease, padding 180ms ease, margin 180ms ease;
+}
+
+.sendity .code--active::after {
+    content: '';
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    height: 3px;
+    border-radius: 0 0 var(--sendity-code-border-radius) var(--sendity-code-border-radius);
+    background: var(--sendity-primary-color);
+    transform-origin: left center;
+    animation: sendity-code-validity var(--sendity-code-validity-duration) linear forwards;
+}
+
+.sendity .code--verified {
+    opacity: 0;
+    transform: translateY(-0.125rem) scale(0.98);
+    max-height: 0;
+    min-height: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    margin: 0;
+    pointer-events: none;
+}
+
+.sendity .spinner {
+    width: 1rem;
+    height: 1rem;
+    border: 2px solid rgba(0, 0, 0, 0.15);
+    border-top-color: var(--sendity-primary-color);
+    border-radius: 50%;
+    animation: sendity-spin 0.8s linear infinite;
+}
+
+@keyframes sendity-spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+.sendity .formatted-code {
+    letter-spacing: 0.05em;
+    line-height: 1;
+    font-size: var(--sendity-code-font-size);
+    font-weight: var(--sendity-code-font-weight);
+    font-family: var(--sendity-code-font-family);
+}
+
+.sendity .prompt {
+    color: #374151; /* gray-700 */
+}
+
+.sendity .success {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    color: var(--sendity-success-color);
+    font-weight: 700;
+    text-align: center;
+}
+
+.sendity .success[hidden] {
+    display: none !important;
+}
+
+.sendity .success-check {
+    display: inline-grid;
+    place-items: center;
+    width: 2.75rem;
+    height: 2.75rem;
+    border-radius: 999px;
+    background: var(--sendity-success-check-bg);
+    color: var(--sendity-success-check-color);
+    box-shadow: 0 10px 30px rgba(20, 184, 166, 0.28);
+    animation: sendity-success-bounce 260ms cubic-bezier(0.17, 1.2, 0.28, 1) both;
+}
+
+.sendity .success-check svg {
+    width: 1.55rem;
+    height: 1.55rem;
+    stroke: currentColor;
+    stroke-width: 3;
+    fill: none;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+}
+
+.sendity .success-message {
+    color: var(--sendity-color);
+}
+
+@keyframes sendity-success-bounce {
+    0% {
+        opacity: 0;
+        transform: scale(0.72);
+    }
+    70% {
+        opacity: 1;
+        transform: scale(1.08);
+    }
+    100% {
+        opacity: 1;
+        transform: scale(1);
+    }
+}
+
+@keyframes sendity-code-validity {
+    from {
+        transform: scaleX(1);
+    }
+    to {
+        transform: scaleX(0);
+    }
+}
+
+.sendity .verifiers {
+    display: flex;
+    align-self: center;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+}
+
+.sendity .verifiers a {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.375rem; /* ~6px */
+    text-decoration: none;
+    color: var(--sendity-btn-color);
+    background: var(--sendity-btn-bg);
+    padding: var(--sendity-btn-padding);
+    border-radius: var(--sendity-btn-border-radius);
+    border: var(--sendity-btn-border-size) solid var(--sendity-btn-border-color);
+    font-size: var(--sendity-btn-font-size);
+}
+
+.sendity .verifiers a .icon {
+    width: 1em;
+    height: 1em;
+    display: inline-flex;
+}
+
+.sendity .verifiers a .icon svg {
+    width: 1em;
+    height: 1em;
+    display: block;
+}
+
+.sendity .verifiers a:hover {
+    text-decoration: none;
+}
+
+.sendity .sendity-footer {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 1.125rem;
+    color: rgba(17, 24, 39, 0.55);
+    font-size: 0.6875rem;
+    line-height: 1rem;
+    letter-spacing: 0.01em;
+    text-align: center;
+    user-select: none;
+}
+
+.sendity .sendity-footer[hidden],
+.sendity .sendity-footer [hidden] {
+    display: none !important;
+}
+
+.sendity .footer-logo {
+    font-weight: 700;
+    color: rgba(17, 24, 39, 0.72);
+}
+
+.sendity .footer-status {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.375rem;
+}
+
+.sendity .footer-spinner {
+    width: 0.75rem;
+    height: 0.75rem;
+    border: 1.5px solid rgba(17, 24, 39, 0.16);
+    border-top-color: var(--sendity-primary-color);
+    border-radius: 50%;
+    animation: sendity-spin 0.8s linear infinite;
+}
+`;
+class Oe {
+  constructor() {
+    this.notificationCreatedEvent = ".Illuminate\\Notifications\\Events\\BroadcastNotificationCreated";
+  }
+  /**
+   * Listen for a whisper event on the channel instance.
+   */
+  listenForWhisper(i, o) {
+    return this.listen(".client-" + i, o);
+  }
+  /**
+   * Listen for an event on the channel instance.
+   */
+  notification(i) {
+    return this.listen(this.notificationCreatedEvent, i);
+  }
+  /**
+   * Stop listening for notification events on the channel instance.
+   */
+  stopListeningForNotification(i) {
+    return this.stopListening(this.notificationCreatedEvent, i);
+  }
+  /**
+   * Stop listening for a whisper event on the channel instance.
+   */
+  stopListeningForWhisper(i, o) {
+    return this.stopListening(".client-" + i, o);
+  }
+}
+class wt {
+  /**
+   * Create a new class instance.
+   */
+  constructor(i) {
+    this.namespace = i;
+  }
+  /**
+   * Format the given event name.
+   */
+  format(i) {
+    return [".", "\\"].includes(i.charAt(0)) ? i.substring(1) : (this.namespace && (i = this.namespace + "." + i), i.replace(/\./g, "\\"));
+  }
+  /**
+   * Set the event namespace.
+   */
+  setNamespace(i) {
+    this.namespace = i;
+  }
+}
+function Mi(g) {
+  try {
+    return Reflect.construct(String, [], g), !0;
+  } catch {
+    return !1;
+  }
+}
+class qe extends Oe {
+  /**
+   * Create a new class instance.
+   */
+  constructor(i, o, c) {
+    super(), this.name = o, this.pusher = i, this.options = c, this.eventFormatter = new wt(this.options.namespace), this.subscribe();
+  }
+  /**
+   * Subscribe to a Pusher channel.
+   */
+  subscribe() {
+    this.subscription = this.pusher.subscribe(this.name);
+  }
+  /**
+   * Unsubscribe from a Pusher channel.
+   */
+  unsubscribe() {
+    this.pusher.unsubscribe(this.name);
+  }
+  /**
+   * Listen for an event on the channel instance.
+   */
+  listen(i, o) {
+    return this.on(this.eventFormatter.format(i), o), this;
+  }
+  /**
+   * Listen for all events on the channel instance.
+   */
+  listenToAll(i) {
+    return this.subscription.bind_global((o, c) => {
+      if (o.startsWith("pusher:"))
+        return;
+      let h = String(this.options.namespace ?? "").replace(
+        /\./g,
+        "\\"
+      ), C = o.startsWith(h) ? o.substring(h.length + 1) : "." + o;
+      i(C, c);
+    }), this;
+  }
+  /**
+   * Stop listening for an event on the channel instance.
+   */
+  stopListening(i, o) {
+    return o ? this.subscription.unbind(
+      this.eventFormatter.format(i),
+      o
+    ) : this.subscription.unbind(this.eventFormatter.format(i)), this;
+  }
+  /**
+   * Stop listening for all events on the channel instance.
+   */
+  stopListeningToAll(i) {
+    return i ? this.subscription.unbind_global(i) : this.subscription.unbind_global(), this;
+  }
+  /**
+   * Register a callback to be called anytime a subscription succeeds.
+   */
+  subscribed(i) {
+    return this.on("pusher:subscription_succeeded", () => {
+      i();
+    }), this;
+  }
+  /**
+   * Register a callback to be called anytime a subscription error occurs.
+   */
+  error(i) {
+    return this.on("pusher:subscription_error", (o) => {
+      i(o);
+    }), this;
+  }
+  /**
+   * Bind a channel to an event.
+   */
+  on(i, o) {
+    return this.subscription.bind(i, o), this;
+  }
+}
+class Ct extends qe {
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this.pusher.channels.channels[this.name].trigger(
+      `client-${i}`,
+      o
+    ), this;
+  }
+}
+class zi extends qe {
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this.pusher.channels.channels[this.name].trigger(
+      `client-${i}`,
+      o
+    ), this;
+  }
+}
+class Hi extends Ct {
+  /**
+   * Register a callback to be called anytime the member list changes.
+   */
+  here(i) {
+    return this.on("pusher:subscription_succeeded", (o) => {
+      i(Object.keys(o.members).map((c) => o.members[c]));
+    }), this;
+  }
+  /**
+   * Listen for someone joining the channel.
+   */
+  joining(i) {
+    return this.on("pusher:member_added", (o) => {
+      i(o.info);
+    }), this;
+  }
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this.pusher.channels.channels[this.name].trigger(
+      `client-${i}`,
+      o
+    ), this;
+  }
+  /**
+   * Listen for someone leaving the channel.
+   */
+  leaving(i) {
+    return this.on("pusher:member_removed", (o) => {
+      i(o.info);
+    }), this;
+  }
+}
+class St extends Oe {
+  /**
+   * Create a new class instance.
+   */
+  constructor(i, o, c) {
+    super(), this.events = {}, this.listeners = {}, this.name = o, this.socket = i, this.options = c, this.eventFormatter = new wt(this.options.namespace), this.subscribe();
+  }
+  /**
+   * Subscribe to a Socket.io channel.
+   */
+  subscribe() {
+    this.socket.emit("subscribe", {
+      channel: this.name,
+      auth: this.options.auth || {}
+    });
+  }
+  /**
+   * Unsubscribe from channel and ubind event callbacks.
+   */
+  unsubscribe() {
+    this.unbind(), this.socket.emit("unsubscribe", {
+      channel: this.name,
+      auth: this.options.auth || {}
+    });
+  }
+  /**
+   * Listen for an event on the channel instance.
+   */
+  listen(i, o) {
+    return this.on(this.eventFormatter.format(i), o), this;
+  }
+  /**
+   * Stop listening for an event on the channel instance.
+   */
+  stopListening(i, o) {
+    return this.unbindEvent(this.eventFormatter.format(i), o), this;
+  }
+  /**
+   * Register a callback to be called anytime a subscription succeeds.
+   */
+  subscribed(i) {
+    return this.on("connect", (o) => {
+      i(o);
+    }), this;
+  }
+  /**
+   * Register a callback to be called anytime an error occurs.
+   */
+  error(i) {
+    return this;
+  }
+  /**
+   * Bind the channel's socket to an event and store the callback.
+   */
+  on(i, o) {
+    return this.listeners[i] = this.listeners[i] || [], this.events[i] || (this.events[i] = (c, h) => {
+      this.name === c && this.listeners[i] && this.listeners[i].forEach((C) => C(h));
+    }, this.socket.on(i, this.events[i])), this.listeners[i].push(o), this;
+  }
+  /**
+   * Unbind the channel's socket from all stored event callbacks.
+   */
+  unbind() {
+    Object.keys(this.events).forEach((i) => {
+      this.unbindEvent(i);
+    });
+  }
+  /**
+   * Unbind the listeners for the given event.
+   */
+  unbindEvent(i, o) {
+    this.listeners[i] = this.listeners[i] || [], o && (this.listeners[i] = this.listeners[i].filter(
+      (c) => c !== o
+    )), (!o || this.listeners[i].length === 0) && (this.events[i] && (this.socket.removeListener(i, this.events[i]), delete this.events[i]), delete this.listeners[i]);
+  }
+}
+class _t extends St {
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this.socket.emit("client event", {
+      channel: this.name,
+      event: `client-${i}`,
+      data: o
+    }), this;
+  }
+}
+class Di extends _t {
+  /**
+   * Register a callback to be called anytime the member list changes.
+   */
+  here(i) {
+    return this.on("presence:subscribed", (o) => {
+      i(o.map((c) => c.user_info));
+    }), this;
+  }
+  /**
+   * Listen for someone joining the channel.
+   */
+  joining(i) {
+    return this.on(
+      "presence:joining",
+      (o) => i(o.user_info)
+    ), this;
+  }
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this.socket.emit("client event", {
+      channel: this.name,
+      event: `client-${i}`,
+      data: o
+    }), this;
+  }
+  /**
+   * Listen for someone leaving the channel.
+   */
+  leaving(i) {
+    return this.on(
+      "presence:leaving",
+      (o) => i(o.user_info)
+    ), this;
+  }
+}
+class fe extends Oe {
+  /**
+   * Subscribe to a channel.
+   */
+  subscribe() {
+  }
+  /**
+   * Unsubscribe from a channel.
+   */
+  unsubscribe() {
+  }
+  /**
+   * Listen for an event on the channel instance.
+   */
+  listen(i, o) {
+    return this;
+  }
+  /**
+   * Listen for all events on the channel instance.
+   */
+  listenToAll(i) {
+    return this;
+  }
+  /**
+   * Stop listening for an event on the channel instance.
+   */
+  stopListening(i, o) {
+    return this;
+  }
+  /**
+   * Register a callback to be called anytime a subscription succeeds.
+   */
+  subscribed(i) {
+    return this;
+  }
+  /**
+   * Register a callback to be called anytime an error occurs.
+   */
+  error(i) {
+    return this;
+  }
+  /**
+   * Bind a channel to an event.
+   */
+  on(i, o) {
+    return this;
+  }
+}
+class Tt extends fe {
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this;
+  }
+}
+class Wi extends fe {
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this;
+  }
+}
+class Fi extends Tt {
+  /**
+   * Register a callback to be called anytime the member list changes.
+   */
+  here(i) {
+    return this;
+  }
+  /**
+   * Listen for someone joining the channel.
+   */
+  joining(i) {
+    return this;
+  }
+  /**
+   * Send a whisper event to other clients in the channel.
+   */
+  whisper(i, o) {
+    return this;
+  }
+  /**
+   * Listen for someone leaving the channel.
+   */
+  leaving(i) {
+    return this;
+  }
+}
+const kt = class Et {
+  /**
+   * Create a new class instance.
+   */
+  constructor(i) {
+    this.setOptions(i), this.connect();
+  }
+  /**
+   * Merge the custom options with the defaults.
+   */
+  setOptions(i) {
+    this.options = {
+      ...Et._defaultOptions,
+      ...i,
+      broadcaster: i.broadcaster
+    };
+    let o = this.csrfToken();
+    o && (this.options.auth.headers["X-CSRF-TOKEN"] = o, this.options.userAuthentication.headers["X-CSRF-TOKEN"] = o), o = this.options.bearerToken, o && (this.options.auth.headers.Authorization = "Bearer " + o, this.options.userAuthentication.headers.Authorization = "Bearer " + o);
+  }
+  /**
+   * Extract the CSRF token from the page.
+   */
+  csrfToken() {
+    var i, o;
+    return typeof window < "u" && (i = window.Laravel) != null && i.csrfToken ? window.Laravel.csrfToken : this.options.csrfToken ? this.options.csrfToken : typeof document < "u" && typeof document.querySelector == "function" ? ((o = document.querySelector('meta[name="csrf-token"]')) == null ? void 0 : o.getAttribute("content")) ?? null : null;
+  }
+};
+kt._defaultOptions = {
+  auth: {
+    headers: {}
+  },
+  authEndpoint: "/broadcasting/auth",
+  userAuthentication: {
+    endpoint: "/broadcasting/user-auth",
+    headers: {}
+  },
+  csrfToken: null,
+  bearerToken: null,
+  host: null,
+  key: null,
+  namespace: "App.Events"
+};
+let Ue = kt;
+class pe extends Ue {
+  constructor() {
+    super(...arguments), this.channels = {};
+  }
+  /**
+   * Create a fresh Pusher connection.
+   */
+  connect() {
+    if (typeof this.options.client < "u")
+      this.pusher = this.options.client;
+    else if (this.options.Pusher)
+      this.pusher = new this.options.Pusher(
+        this.options.key,
+        this.options
+      );
+    else if (typeof window < "u" && typeof window.Pusher < "u")
+      this.pusher = new window.Pusher(this.options.key, this.options);
+    else
+      throw new Error(
+        "Pusher client not found. Should be globally available or passed via options.client"
+      );
+  }
+  /**
+   * Sign in the user via Pusher user authentication (https://pusher.com/docs/channels/using_channels/user-authentication/).
+   */
+  signin() {
+    this.pusher.signin();
+  }
+  /**
+   * Listen for an event on a channel instance.
+   */
+  listen(i, o, c) {
+    return this.channel(i).listen(o, c);
+  }
+  /**
+   * Get a channel instance by name.
+   */
+  channel(i) {
+    return this.channels[i] || (this.channels[i] = new qe(
+      this.pusher,
+      i,
+      this.options
+    )), this.channels[i];
+  }
+  /**
+   * Get a private channel instance by name.
+   */
+  privateChannel(i) {
+    return this.channels["private-" + i] || (this.channels["private-" + i] = new Ct(
+      this.pusher,
+      "private-" + i,
+      this.options
+    )), this.channels["private-" + i];
+  }
+  /**
+   * Get a private encrypted channel instance by name.
+   */
+  encryptedPrivateChannel(i) {
+    return this.channels["private-encrypted-" + i] || (this.channels["private-encrypted-" + i] = new zi(
+      this.pusher,
+      "private-encrypted-" + i,
+      this.options
+    )), this.channels["private-encrypted-" + i];
+  }
+  /**
+   * Get a presence channel instance by name.
+   */
+  presenceChannel(i) {
+    return this.channels["presence-" + i] || (this.channels["presence-" + i] = new Hi(
+      this.pusher,
+      "presence-" + i,
+      this.options
+    )), this.channels["presence-" + i];
+  }
+  /**
+   * Leave the given channel, as well as its private and presence variants.
+   */
+  leave(i) {
+    [
+      i,
+      "private-" + i,
+      "private-encrypted-" + i,
+      "presence-" + i
+    ].forEach((o) => {
+      this.leaveChannel(o);
+    });
+  }
+  /**
+   * Leave the given channel.
+   */
+  leaveChannel(i) {
+    this.channels[i] && (this.channels[i].unsubscribe(), delete this.channels[i]);
+  }
+  /**
+   * Get the socket ID for the connection.
+   */
+  socketId() {
+    return this.pusher.connection.socket_id;
+  }
+  /**
+   * Get the current connection status.
+   */
+  connectionStatus() {
+    const i = this.pusher.connection.state;
+    switch (i) {
+      case "connected":
+      case "connecting":
+        return i;
+      case "failed":
+      case "unavailable":
+        return "failed";
+      default:
+        return "disconnected";
+    }
+  }
+  /**
+   * Subscribe to connection status changes.
+   */
+  onConnectionChange(i) {
+    const o = () => {
+      i(this.connectionStatus());
+    }, c = ["state_change", "connected", "disconnected"];
+    return c.forEach((h) => {
+      this.pusher.connection.bind(h, o);
+    }), () => {
+      c.forEach((h) => {
+        this.pusher.connection.unbind(h, o);
+      });
+    };
+  }
+  /**
+   * Disconnect Pusher connection.
+   */
+  disconnect() {
+    this.pusher.disconnect();
+  }
+}
+class Bi extends Ue {
+  constructor() {
+    super(...arguments), this.channels = {};
+  }
+  /**
+   * Create a fresh Socket.io connection.
+   */
+  connect() {
+    let i = this.getSocketIO();
+    this.socket = i(
+      this.options.host ?? void 0,
+      this.options
+    ), this.socket.io.on("reconnect", () => {
+      Object.values(this.channels).forEach((o) => {
+        o.subscribe();
+      });
+    });
+  }
+  /**
+   * Get socket.io module from global scope or options.
+   */
+  getSocketIO() {
+    if (typeof this.options.client < "u")
+      return this.options.client;
+    if (typeof window < "u" && typeof window.io < "u")
+      return window.io;
+    throw new Error(
+      "Socket.io client not found. Should be globally available or passed via options.client"
+    );
+  }
+  /**
+   * Listen for an event on a channel instance.
+   */
+  listen(i, o, c) {
+    return this.channel(i).listen(o, c);
+  }
+  /**
+   * Get a channel instance by name.
+   */
+  channel(i) {
+    return this.channels[i] || (this.channels[i] = new St(
+      this.socket,
+      i,
+      this.options
+    )), this.channels[i];
+  }
+  /**
+   * Get a private channel instance by name.
+   */
+  privateChannel(i) {
+    return this.channels["private-" + i] || (this.channels["private-" + i] = new _t(
+      this.socket,
+      "private-" + i,
+      this.options
+    )), this.channels["private-" + i];
+  }
+  /**
+   * Get a presence channel instance by name.
+   */
+  presenceChannel(i) {
+    return this.channels["presence-" + i] || (this.channels["presence-" + i] = new Di(
+      this.socket,
+      "presence-" + i,
+      this.options
+    )), this.channels["presence-" + i];
+  }
+  /**
+   * Leave the given channel, as well as its private and presence variants.
+   */
+  leave(i) {
+    [i, "private-" + i, "presence-" + i].forEach((o) => {
+      this.leaveChannel(o);
+    });
+  }
+  /**
+   * Leave the given channel.
+   */
+  leaveChannel(i) {
+    this.channels[i] && (this.channels[i].unsubscribe(), delete this.channels[i]);
+  }
+  /**
+   * Get the socket ID for the connection.
+   */
+  socketId() {
+    return this.socket.id;
+  }
+  /**
+   * Get the current connection status.
+   */
+  connectionStatus() {
+    return this.socket.connected ? "connected" : this.socket.io._reconnecting ? "reconnecting" : this.socket.id !== void 0 ? "disconnected" : "connecting";
+  }
+  /**
+   * Subscribe to connection status changes.
+   */
+  onConnectionChange(i) {
+    const o = () => {
+      i(this.connectionStatus());
+    }, c = [
+      "connect",
+      "disconnect",
+      "connect_error",
+      "reconnect_attempt",
+      "reconnect",
+      "reconnect_error",
+      "reconnect_failed"
+    ];
+    return c.forEach((h) => {
+      this.socket.on(h, o);
+    }), () => {
+      c.forEach((h) => {
+        this.socket.off(h, o);
+      });
+    };
+  }
+  /**
+   * Disconnect Socketio connection.
+   */
+  disconnect() {
+    this.socket.disconnect();
+  }
+}
+class ft extends Ue {
+  constructor() {
+    super(...arguments), this.channels = {};
+  }
+  /**
+   * Create a fresh connection.
+   */
+  connect() {
+  }
+  /**
+   * Listen for an event on a channel instance.
+   */
+  listen(i, o, c) {
+    return new fe();
+  }
+  /**
+   * Get a channel instance by name.
+   */
+  channel(i) {
+    return new fe();
+  }
+  /**
+   * Get a private channel instance by name.
+   */
+  privateChannel(i) {
+    return new Tt();
+  }
+  /**
+   * Get a private encrypted channel instance by name.
+   */
+  encryptedPrivateChannel(i) {
+    return new Wi();
+  }
+  /**
+   * Get a presence channel instance by name.
+   */
+  presenceChannel(i) {
+    return new Fi();
+  }
+  /**
+   * Leave the given channel, as well as its private and presence variants.
+   */
+  leave(i) {
+  }
+  /**
+   * Leave the given channel.
+   */
+  leaveChannel(i) {
+  }
+  /**
+   * Get the socket ID for the connection.
+   */
+  socketId() {
+    return "fake-socket-id";
+  }
+  /**
+   * Get the current connection status.
+   */
+  connectionStatus() {
+    return "connected";
+  }
+  /**
+   * Subscribe to connection status changes.
+   */
+  onConnectionChange(i) {
+    return () => {
+    };
+  }
+  /**
+   * Disconnect the connection.
+   */
+  disconnect() {
+  }
+}
+class $i {
+  /**
+   * Create a new class instance.
+   */
+  constructor(i) {
+    this.options = i, this.connect(), this.options.withoutInterceptors || this.registerInterceptors();
+  }
+  /**
+   * Get a channel instance by name.
+   */
+  channel(i) {
+    return this.connector.channel(i);
+  }
+  /**
+   * Create a new connection.
+   */
+  connect() {
+    if (this.options.broadcaster === "reverb")
+      this.connector = new pe({
+        ...this.options,
+        cluster: ""
+      });
+    else if (this.options.broadcaster === "pusher")
+      this.connector = new pe(this.options);
+    else if (this.options.broadcaster === "ably")
+      this.connector = new pe({
+        ...this.options,
+        cluster: "",
+        broadcaster: "pusher"
+      });
+    else if (this.options.broadcaster === "socket.io")
+      this.connector = new Bi(this.options);
+    else if (this.options.broadcaster === "null")
+      this.connector = new ft(this.options);
+    else if (typeof this.options.broadcaster == "function" && Mi(this.options.broadcaster))
+      this.connector = new this.options.broadcaster(this.options);
+    else
+      throw new Error(
+        `Broadcaster ${typeof this.options.broadcaster} ${String(this.options.broadcaster)} is not supported.`
+      );
+  }
+  /**
+   * Disconnect from the Echo server.
+   */
+  disconnect() {
+    this.connector.disconnect();
+  }
+  /**
+   * Get a presence channel instance by name.
+   */
+  join(i) {
+    return this.connector.presenceChannel(i);
+  }
+  /**
+   * Leave the given channel, as well as its private and presence variants.
+   */
+  leave(i) {
+    this.connector.leave(i);
+  }
+  /**
+   * Leave the given channel.
+   */
+  leaveChannel(i) {
+    this.connector.leaveChannel(i);
+  }
+  /**
+   * Leave all channels.
+   */
+  leaveAllChannels() {
+    for (const i in this.connector.channels)
+      this.leaveChannel(i);
+  }
+  /**
+   * Listen for an event on a channel instance.
+   */
+  listen(i, o, c) {
+    return this.connector.listen(i, o, c);
+  }
+  /**
+   * Get a private channel instance by name.
+   */
+  private(i) {
+    return this.connector.privateChannel(i);
+  }
+  /**
+   * Get a private encrypted channel instance by name.
+   */
+  encryptedPrivate(i) {
+    if (this.connectorSupportsEncryptedPrivateChannels(this.connector))
+      return this.connector.encryptedPrivateChannel(i);
+    throw new Error(
+      `Broadcaster ${typeof this.options.broadcaster} ${String(
+        this.options.broadcaster
+      )} does not support encrypted private channels.`
+    );
+  }
+  connectorSupportsEncryptedPrivateChannels(i) {
+    return i instanceof pe || i instanceof ft;
+  }
+  /**
+   * Get the Socket ID for the connection.
+   */
+  socketId() {
+    return this.connector.socketId();
+  }
+  /**
+   * Get the current connection status.
+   */
+  connectionStatus() {
+    return this.connector.connectionStatus();
+  }
+  /**
+   * Register 3rd party request interceptors. These are used to automatically
+   * send a connections socket id to a Laravel app with a X-Socket-Id header.
+   */
+  registerInterceptors() {
+    typeof Vue < "u" && Vue != null && Vue.http && this.registerVueRequestInterceptor(), typeof axios == "function" && this.registerAxiosRequestInterceptor(), typeof jQuery == "function" && this.registerjQueryAjaxSetup(), typeof Turbo == "object" && this.registerTurboRequestInterceptor();
+  }
+  /**
+   * Register a Vue HTTP interceptor to add the X-Socket-ID header.
+   */
+  registerVueRequestInterceptor() {
+    Vue.http.interceptors.push(
+      (i, o) => {
+        this.socketId() && i.headers.set("X-Socket-ID", this.socketId()), o();
+      }
+    );
+  }
+  /**
+   * Register an Axios HTTP interceptor to add the X-Socket-ID header.
+   */
+  registerAxiosRequestInterceptor() {
+    axios.interceptors.request.use(
+      (i) => (this.socketId() && (i.headers["X-Socket-Id"] = this.socketId()), i)
+    );
+  }
+  /**
+   * Register jQuery AjaxPrefilter to add the X-Socket-ID header.
+   */
+  registerjQueryAjaxSetup() {
+    typeof jQuery.ajax < "u" && jQuery.ajaxPrefilter(
+      (i, o, c) => {
+        this.socketId() && c.setRequestHeader("X-Socket-Id", this.socketId());
+      }
+    );
+  }
+  /**
+   * Register the Turbo Request interceptor to add the X-Socket-ID header.
+   */
+  registerTurboRequestInterceptor() {
+    document.addEventListener(
+      "turbo:before-fetch-request",
+      (i) => {
+        i.detail.fetchOptions.headers["X-Socket-Id"] = this.socketId();
+      }
+    );
+  }
+}
+function Xi(g) {
+  return g && g.__esModule && Object.prototype.hasOwnProperty.call(g, "default") ? g.default : g;
+}
+var Ae = { exports: {} };
+var gt;
+function Vi() {
+  return gt || (gt = 1, (function(g, i) {
+    (function(c, h) {
+      g.exports = h();
+    })(self, () => (
+      /******/
+      (() => {
+        var o = {
+          /***/
+          594(y, f) {
+            var m = this && this.__extends || /* @__PURE__ */ (function() {
+              var T = function(l, d) {
+                return T = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(w, P) {
+                  w.__proto__ = P;
+                } || function(w, P) {
+                  for (var q in P) P.hasOwnProperty(q) && (w[q] = P[q]);
+                }, T(l, d);
+              };
+              return function(l, d) {
+                T(l, d);
+                function w() {
+                  this.constructor = l;
+                }
+                l.prototype = d === null ? Object.create(d) : (w.prototype = d.prototype, new w());
+              };
+            })();
+            Object.defineProperty(f, "__esModule", { value: !0 });
+            var k = 256, S = (
+              /** @class */
+              (function() {
+                function T(l) {
+                  l === void 0 && (l = "="), this._paddingCharacter = l;
+                }
+                return T.prototype.encodedLength = function(l) {
+                  return this._paddingCharacter ? (l + 2) / 3 * 4 | 0 : (l * 8 + 5) / 6 | 0;
+                }, T.prototype.encode = function(l) {
+                  for (var d = "", w = 0; w < l.length - 2; w += 3) {
+                    var P = l[w] << 16 | l[w + 1] << 8 | l[w + 2];
+                    d += this._encodeByte(P >>> 18 & 63), d += this._encodeByte(P >>> 12 & 63), d += this._encodeByte(P >>> 6 & 63), d += this._encodeByte(P >>> 0 & 63);
+                  }
+                  var q = l.length - w;
+                  if (q > 0) {
+                    var P = l[w] << 16 | (q === 2 ? l[w + 1] << 8 : 0);
+                    d += this._encodeByte(P >>> 18 & 63), d += this._encodeByte(P >>> 12 & 63), q === 2 ? d += this._encodeByte(P >>> 6 & 63) : d += this._paddingCharacter || "", d += this._paddingCharacter || "";
+                  }
+                  return d;
+                }, T.prototype.maxDecodedLength = function(l) {
+                  return this._paddingCharacter ? l / 4 * 3 | 0 : (l * 6 + 7) / 8 | 0;
+                }, T.prototype.decodedLength = function(l) {
+                  return this.maxDecodedLength(l.length - this._getPaddingLength(l));
+                }, T.prototype.decode = function(l) {
+                  if (l.length === 0)
+                    return new Uint8Array(0);
+                  for (var d = this._getPaddingLength(l), w = l.length - d, P = new Uint8Array(this.maxDecodedLength(w)), q = 0, N = 0, z = 0, V = 0, D = 0, H = 0, J = 0; N < w - 4; N += 4)
+                    V = this._decodeChar(l.charCodeAt(N + 0)), D = this._decodeChar(l.charCodeAt(N + 1)), H = this._decodeChar(l.charCodeAt(N + 2)), J = this._decodeChar(l.charCodeAt(N + 3)), P[q++] = V << 2 | D >>> 4, P[q++] = D << 4 | H >>> 2, P[q++] = H << 6 | J, z |= V & k, z |= D & k, z |= H & k, z |= J & k;
+                  if (N < w - 1 && (V = this._decodeChar(l.charCodeAt(N)), D = this._decodeChar(l.charCodeAt(N + 1)), P[q++] = V << 2 | D >>> 4, z |= V & k, z |= D & k), N < w - 2 && (H = this._decodeChar(l.charCodeAt(N + 2)), P[q++] = D << 4 | H >>> 2, z |= H & k), N < w - 3 && (J = this._decodeChar(l.charCodeAt(N + 3)), P[q++] = H << 6 | J, z |= J & k), z !== 0)
+                    throw new Error("Base64Coder: incorrect characters for decoding");
+                  return P;
+                }, T.prototype._encodeByte = function(l) {
+                  var d = l;
+                  return d += 65, d += 25 - l >>> 8 & 6, d += 51 - l >>> 8 & -75, d += 61 - l >>> 8 & -15, d += 62 - l >>> 8 & 3, String.fromCharCode(d);
+                }, T.prototype._decodeChar = function(l) {
+                  var d = k;
+                  return d += (42 - l & l - 44) >>> 8 & -k + l - 43 + 62, d += (46 - l & l - 48) >>> 8 & -k + l - 47 + 63, d += (47 - l & l - 58) >>> 8 & -k + l - 48 + 52, d += (64 - l & l - 91) >>> 8 & -k + l - 65 + 0, d += (96 - l & l - 123) >>> 8 & -k + l - 97 + 26, d;
+                }, T.prototype._getPaddingLength = function(l) {
+                  var d = 0;
+                  if (this._paddingCharacter) {
+                    for (var w = l.length - 1; w >= 0 && l[w] === this._paddingCharacter; w--)
+                      d++;
+                    if (l.length < 4 || d > 2)
+                      throw new Error("Base64Coder: incorrect padding");
+                  }
+                  return d;
+                }, T;
+              })()
+            );
+            f.Coder = S;
+            var L = new S();
+            function _(T) {
+              return L.encode(T);
+            }
+            f.encode = _;
+            function A(T) {
+              return L.decode(T);
+            }
+            f.decode = A;
+            var W = (
+              /** @class */
+              (function(T) {
+                m(l, T);
+                function l() {
+                  return T !== null && T.apply(this, arguments) || this;
+                }
+                return l.prototype._encodeByte = function(d) {
+                  var w = d;
+                  return w += 65, w += 25 - d >>> 8 & 6, w += 51 - d >>> 8 & -75, w += 61 - d >>> 8 & -13, w += 62 - d >>> 8 & 49, String.fromCharCode(w);
+                }, l.prototype._decodeChar = function(d) {
+                  var w = k;
+                  return w += (44 - d & d - 46) >>> 8 & -k + d - 45 + 62, w += (94 - d & d - 96) >>> 8 & -k + d - 95 + 63, w += (47 - d & d - 58) >>> 8 & -k + d - 48 + 52, w += (64 - d & d - 91) >>> 8 & -k + d - 65 + 0, w += (96 - d & d - 123) >>> 8 & -k + d - 97 + 26, w;
+                }, l;
+              })(S)
+            );
+            f.URLSafeCoder = W;
+            var j = new W();
+            function F(T) {
+              return j.encode(T);
+            }
+            f.encodeURLSafe = F;
+            function ee(T) {
+              return j.decode(T);
+            }
+            f.decodeURLSafe = ee, f.encodedLength = function(T) {
+              return L.encodedLength(T);
+            }, f.maxDecodedLength = function(T) {
+              return L.maxDecodedLength(T);
+            }, f.decodedLength = function(T) {
+              return L.decodedLength(T);
+            };
+          },
+          /***/
+          978(y, f) {
+            var m = "utf8: invalid source encoding";
+            function k(S) {
+              for (var L = [], _ = 0; _ < S.length; _++) {
+                var A = S[_];
+                if (A & 128) {
+                  var W = void 0;
+                  if (A < 224) {
+                    if (_ >= S.length)
+                      throw new Error(m);
+                    var j = S[++_];
+                    if ((j & 192) !== 128)
+                      throw new Error(m);
+                    A = (A & 31) << 6 | j & 63, W = 128;
+                  } else if (A < 240) {
+                    if (_ >= S.length - 1)
+                      throw new Error(m);
+                    var j = S[++_], F = S[++_];
+                    if ((j & 192) !== 128 || (F & 192) !== 128)
+                      throw new Error(m);
+                    A = (A & 15) << 12 | (j & 63) << 6 | F & 63, W = 2048;
+                  } else if (A < 248) {
+                    if (_ >= S.length - 2)
+                      throw new Error(m);
+                    var j = S[++_], F = S[++_], ee = S[++_];
+                    if ((j & 192) !== 128 || (F & 192) !== 128 || (ee & 192) !== 128)
+                      throw new Error(m);
+                    A = (A & 15) << 18 | (j & 63) << 12 | (F & 63) << 6 | ee & 63, W = 65536;
+                  } else
+                    throw new Error(m);
+                  if (A < W || A >= 55296 && A <= 57343)
+                    throw new Error(m);
+                  if (A >= 65536) {
+                    if (A > 1114111)
+                      throw new Error(m);
+                    A -= 65536, L.push(String.fromCharCode(55296 | A >> 10)), A = 56320 | A & 1023;
+                  }
+                }
+                L.push(String.fromCharCode(A));
+              }
+              return L.join("");
+            }
+            f.D4 = k;
+          },
+          /***/
+          721(y, f, m) {
+            y.exports = m(207).default;
+          },
+          /***/
+          207(y, f, m) {
+            m.d(f, {
+              default: () => (
+                /* binding */
+                le
+              )
+            });
+            class k {
+              constructor(e, t) {
+                this.lastId = 0, this.prefix = e, this.name = t;
+              }
+              create(e) {
+                this.lastId++;
+                var t = this.lastId, r = this.prefix + t, s = this.name + "[" + t + "]", a = !1, u = function() {
+                  a || (e.apply(null, arguments), a = !0);
+                };
+                return this[t] = u, { number: t, id: r, name: s, callback: u };
+              }
+              remove(e) {
+                delete this[e.number];
+              }
+            }
+            var S = new k("_pusher_script_", "Pusher.ScriptReceivers"), L = {
+              VERSION: "8.5.0",
+              PROTOCOL: 7,
+              wsPort: 80,
+              wssPort: 443,
+              wsPath: "",
+              httpHost: "sockjs.pusher.com",
+              httpPort: 80,
+              httpsPort: 443,
+              httpPath: "/pusher",
+              stats_host: "stats.pusher.com",
+              authEndpoint: "/pusher/auth",
+              authTransport: "ajax",
+              activityTimeout: 12e4,
+              pongTimeout: 3e4,
+              unavailableTimeout: 1e4,
+              userAuthentication: {
+                endpoint: "/pusher/user-auth",
+                transport: "ajax"
+              },
+              channelAuthorization: {
+                endpoint: "/pusher/auth",
+                transport: "ajax"
+              },
+              cdn_http: "http://js.pusher.com",
+              cdn_https: "https://js.pusher.com",
+              dependency_suffix: ""
+            };
+            const _ = L;
+            class A {
+              constructor(e) {
+                this.options = e, this.receivers = e.receivers || S, this.loading = {};
+              }
+              load(e, t, r) {
+                var s = this;
+                if (s.loading[e] && s.loading[e].length > 0)
+                  s.loading[e].push(r);
+                else {
+                  s.loading[e] = [r];
+                  var a = b.createScriptRequest(s.getPath(e, t)), u = s.receivers.create(function(p) {
+                    if (s.receivers.remove(u), s.loading[e]) {
+                      var v = s.loading[e];
+                      delete s.loading[e];
+                      for (var E = function(I) {
+                        I || a.cleanup();
+                      }, x = 0; x < v.length; x++)
+                        v[x](p, E);
+                    }
+                  });
+                  a.send(u);
+                }
+              }
+              getRoot(e) {
+                var t, r = b.getDocument().location.protocol;
+                return e && e.useTLS || r === "https:" ? t = this.options.cdn_https : t = this.options.cdn_http, t.replace(/\/*$/, "") + "/" + this.options.version;
+              }
+              getPath(e, t) {
+                return this.getRoot(t) + "/" + e + this.options.suffix + ".js";
+              }
+            }
+            var W = new k("_pusher_dependencies", "Pusher.DependenciesReceivers"), j = new A({
+              cdn_http: _.cdn_http,
+              cdn_https: _.cdn_https,
+              version: _.VERSION,
+              suffix: _.dependency_suffix,
+              receivers: W
+            });
+            const F = {
+              baseUrl: "https://pusher.com",
+              urls: {
+                authenticationEndpoint: {
+                  path: "/docs/channels/server_api/authenticating_users"
+                },
+                authorizationEndpoint: {
+                  path: "/docs/channels/server_api/authorizing-users/"
+                },
+                javascriptQuickStart: {
+                  path: "/docs/javascript_quick_start"
+                },
+                triggeringClientEvents: {
+                  path: "/docs/client_api_guide/client_events#trigger-events"
+                },
+                encryptedChannelSupport: {
+                  fullUrl: "https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support"
+                }
+              }
+            }, T = { buildLogSuffix: function(n) {
+              const e = "See:", t = F.urls[n];
+              if (!t)
+                return "";
+              let r;
+              return t.fullUrl ? r = t.fullUrl : t.path && (r = F.baseUrl + t.path), r ? `${e} ${r}` : "";
+            } };
+            var l;
+            (function(n) {
+              n.UserAuthentication = "user-authentication", n.ChannelAuthorization = "channel-authorization";
+            })(l || (l = {}));
+            class d extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class w extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class P extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class q extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class N extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class z extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class V extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class D extends Error {
+              constructor(e) {
+                super(e), Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            class H extends Error {
+              constructor(e, t) {
+                super(t), this.status = e, Object.setPrototypeOf(this, new.target.prototype);
+              }
+            }
+            const xt = function(n, e, t, r, s) {
+              const a = b.createXHR();
+              a.open("POST", t.endpoint, !0), a.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+              for (var u in t.headers)
+                a.setRequestHeader(u, t.headers[u]);
+              if (t.headersProvider != null) {
+                let p = t.headersProvider();
+                for (var u in p)
+                  a.setRequestHeader(u, p[u]);
+              }
+              return a.onreadystatechange = function() {
+                if (a.readyState === 4)
+                  if (a.status === 200) {
+                    let p, v = !1;
+                    try {
+                      p = JSON.parse(a.responseText), v = !0;
+                    } catch {
+                      s(new H(200, `JSON returned from ${r.toString()} endpoint was invalid, yet status code was 200. Data was: ${a.responseText}`), null);
+                    }
+                    v && s(null, p);
+                  } else {
+                    let p = "";
+                    switch (r) {
+                      case l.UserAuthentication:
+                        p = T.buildLogSuffix("authenticationEndpoint");
+                        break;
+                      case l.ChannelAuthorization:
+                        p = `Clients must be authorized to join private or presence channels. ${T.buildLogSuffix("authorizationEndpoint")}`;
+                        break;
+                    }
+                    s(new H(a.status, `Unable to retrieve auth string from ${r.toString()} endpoint - received status: ${a.status} from ${t.endpoint}. ${p}`), null);
+                  }
+              }, a.send(e), a;
+            };
+            function At(n) {
+              return It(Rt(n));
+            }
+            var te = String.fromCharCode, oe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", Pt = function(n) {
+              var e = n.charCodeAt(0);
+              return e < 128 ? n : e < 2048 ? te(192 | e >>> 6) + te(128 | e & 63) : te(224 | e >>> 12 & 15) + te(128 | e >>> 6 & 63) + te(128 | e & 63);
+            }, Rt = function(n) {
+              return n.replace(/[^\x00-\x7F]/g, Pt);
+            }, Lt = function(n) {
+              var e = [0, 2, 1][n.length % 3], t = n.charCodeAt(0) << 16 | (n.length > 1 ? n.charCodeAt(1) : 0) << 8 | (n.length > 2 ? n.charCodeAt(2) : 0), r = [
+                oe.charAt(t >>> 18),
+                oe.charAt(t >>> 12 & 63),
+                e >= 2 ? "=" : oe.charAt(t >>> 6 & 63),
+                e >= 1 ? "=" : oe.charAt(t & 63)
+              ];
+              return r.join("");
+            }, It = window.btoa || function(n) {
+              return n.replace(/[\s\S]{1,3}/g, Lt);
+            };
+            class Ot {
+              constructor(e, t, r, s) {
+                this.clear = t, this.timer = e(() => {
+                  this.timer && (this.timer = s(this.timer));
+                }, r);
+              }
+              isRunning() {
+                return this.timer !== null;
+              }
+              ensureAborted() {
+                this.timer && (this.clear(this.timer), this.timer = null);
+              }
+            }
+            const Me = Ot;
+            function qt(n) {
+              window.clearTimeout(n);
+            }
+            function Ut(n) {
+              window.clearInterval(n);
+            }
+            class G extends Me {
+              constructor(e, t) {
+                super(setTimeout, qt, e, function(r) {
+                  return t(), null;
+                });
+              }
+            }
+            class jt extends Me {
+              constructor(e, t) {
+                super(setInterval, Ut, e, function(r) {
+                  return t(), r;
+                });
+              }
+            }
+            var Nt = {
+              now() {
+                return Date.now ? Date.now() : (/* @__PURE__ */ new Date()).valueOf();
+              },
+              defer(n) {
+                return new G(0, n);
+              },
+              method(n, ...e) {
+                var t = Array.prototype.slice.call(arguments, 1);
+                return function(r) {
+                  return r[n].apply(r, t.concat(arguments));
+                };
+              }
+            };
+            const U = Nt;
+            function M(n, ...e) {
+              for (var t = 0; t < e.length; t++) {
+                var r = e[t];
+                for (var s in r)
+                  r[s] && r[s].constructor && r[s].constructor === Object ? n[s] = M(n[s] || {}, r[s]) : n[s] = r[s];
+              }
+              return n;
+            }
+            function Mt() {
+              for (var n = ["Pusher"], e = 0; e < arguments.length; e++)
+                typeof arguments[e] == "string" ? n.push(arguments[e]) : n.push(ae(arguments[e]));
+              return n.join(" : ");
+            }
+            function ze(n, e) {
+              var t = Array.prototype.indexOf;
+              if (n === null)
+                return -1;
+              if (t && n.indexOf === t)
+                return n.indexOf(e);
+              for (var r = 0, s = n.length; r < s; r++)
+                if (n[r] === e)
+                  return r;
+              return -1;
+            }
+            function B(n, e) {
+              for (var t in n)
+                Object.prototype.hasOwnProperty.call(n, t) && e(n[t], t, n);
+            }
+            function He(n) {
+              var e = [];
+              return B(n, function(t, r) {
+                e.push(r);
+              }), e;
+            }
+            function zt(n) {
+              var e = [];
+              return B(n, function(t) {
+                e.push(t);
+              }), e;
+            }
+            function ne(n, e, t) {
+              for (var r = 0; r < n.length; r++)
+                e.call(t || window, n[r], r, n);
+            }
+            function De(n, e) {
+              for (var t = [], r = 0; r < n.length; r++)
+                t.push(e(n[r], r, n, t));
+              return t;
+            }
+            function Ht(n, e) {
+              var t = {};
+              return B(n, function(r, s) {
+                t[s] = e(r);
+              }), t;
+            }
+            function We(n, e) {
+              e = e || function(s) {
+                return !!s;
+              };
+              for (var t = [], r = 0; r < n.length; r++)
+                e(n[r], r, n, t) && t.push(n[r]);
+              return t;
+            }
+            function Fe(n, e) {
+              var t = {};
+              return B(n, function(r, s) {
+                (e && e(r, s, n, t) || r) && (t[s] = r);
+              }), t;
+            }
+            function Dt(n) {
+              var e = [];
+              return B(n, function(t, r) {
+                e.push([r, t]);
+              }), e;
+            }
+            function Be(n, e) {
+              for (var t = 0; t < n.length; t++)
+                if (e(n[t], t, n))
+                  return !0;
+              return !1;
+            }
+            function Wt(n, e) {
+              for (var t = 0; t < n.length; t++)
+                if (!e(n[t], t, n))
+                  return !1;
+              return !0;
+            }
+            function Ft(n) {
+              return Ht(n, function(e) {
+                return typeof e == "object" && (e = ae(e)), encodeURIComponent(At(e.toString()));
+              });
+            }
+            function Bt(n) {
+              var e = Fe(n, function(r) {
+                return r !== void 0;
+              }), t = De(Dt(Ft(e)), U.method("join", "=")).join("&");
+              return t;
+            }
+            function $t(n) {
+              var e = [], t = [];
+              return (function r(s, a) {
+                var u, p, v;
+                switch (typeof s) {
+                  case "object":
+                    if (!s)
+                      return null;
+                    for (u = 0; u < e.length; u += 1)
+                      if (e[u] === s)
+                        return { $ref: t[u] };
+                    if (e.push(s), t.push(a), Object.prototype.toString.apply(s) === "[object Array]")
+                      for (v = [], u = 0; u < s.length; u += 1)
+                        v[u] = r(s[u], a + "[" + u + "]");
+                    else {
+                      v = {};
+                      for (p in s)
+                        Object.prototype.hasOwnProperty.call(s, p) && (v[p] = r(s[p], a + "[" + JSON.stringify(p) + "]"));
+                    }
+                    return v;
+                  case "number":
+                  case "string":
+                  case "boolean":
+                    return s;
+                }
+              })(n, "$");
+            }
+            function ae(n) {
+              try {
+                return JSON.stringify(n);
+              } catch {
+                return JSON.stringify($t(n));
+              }
+            }
+            class Xt {
+              constructor() {
+                this.globalLog = (e) => {
+                  window.console && window.console.log && window.console.log(e);
+                };
+              }
+              debug(...e) {
+                this.log(this.globalLog, e);
+              }
+              warn(...e) {
+                this.log(this.globalLogWarn, e);
+              }
+              error(...e) {
+                this.log(this.globalLogError, e);
+              }
+              globalLogWarn(e) {
+                window.console && window.console.warn ? window.console.warn(e) : this.globalLog(e);
+              }
+              globalLogError(e) {
+                window.console && window.console.error ? window.console.error(e) : this.globalLogWarn(e);
+              }
+              log(e, ...t) {
+                var r = Mt.apply(this, arguments);
+                le.log ? le.log(r) : le.logToConsole && e.bind(this)(r);
+              }
+            }
+            const R = new Xt();
+            var Vt = function(n, e, t, r, s) {
+              (t.headers !== void 0 || t.headersProvider != null) && R.warn(`To send headers with the ${r.toString()} request, you must use AJAX, rather than JSONP.`);
+              var a = n.nextAuthCallbackID.toString();
+              n.nextAuthCallbackID++;
+              var u = n.getDocument(), p = u.createElement("script");
+              n.auth_callbacks[a] = function(x) {
+                s(null, x);
+              };
+              var v = "Pusher.auth_callbacks['" + a + "']";
+              p.src = t.endpoint + "?callback=" + encodeURIComponent(v) + "&" + e;
+              var E = u.getElementsByTagName("head")[0] || u.documentElement;
+              E.insertBefore(p, E.firstChild);
+            };
+            const Jt = Vt;
+            class Gt {
+              constructor(e) {
+                this.src = e;
+              }
+              send(e) {
+                var t = this, r = "Error loading " + t.src;
+                t.script = document.createElement("script"), t.script.id = e.id, t.script.src = t.src, t.script.type = "text/javascript", t.script.charset = "UTF-8", t.script.addEventListener ? (t.script.onerror = function() {
+                  e.callback(r);
+                }, t.script.onload = function() {
+                  e.callback(null);
+                }) : t.script.onreadystatechange = function() {
+                  (t.script.readyState === "loaded" || t.script.readyState === "complete") && e.callback(null);
+                }, t.script.async === void 0 && document.attachEvent && /opera/i.test(navigator.userAgent) ? (t.errorScript = document.createElement("script"), t.errorScript.id = e.id + "_error", t.errorScript.text = e.name + "('" + r + "');", t.script.async = t.errorScript.async = !1) : t.script.async = !0;
+                var s = document.getElementsByTagName("head")[0];
+                s.insertBefore(t.script, s.firstChild), t.errorScript && s.insertBefore(t.errorScript, t.script.nextSibling);
+              }
+              cleanup() {
+                this.script && (this.script.onload = this.script.onerror = null, this.script.onreadystatechange = null), this.script && this.script.parentNode && this.script.parentNode.removeChild(this.script), this.errorScript && this.errorScript.parentNode && this.errorScript.parentNode.removeChild(this.errorScript), this.script = null, this.errorScript = null;
+              }
+            }
+            class Kt {
+              constructor(e, t) {
+                this.url = e, this.data = t;
+              }
+              send(e) {
+                if (!this.request) {
+                  var t = Bt(this.data), r = this.url + "/" + e.number + "?" + t;
+                  this.request = b.createScriptRequest(r), this.request.send(e);
+                }
+              }
+              cleanup() {
+                this.request && this.request.cleanup();
+              }
+            }
+            var Qt = function(n, e) {
+              return function(t, r) {
+                var s = "http" + (e ? "s" : "") + "://", a = s + (n.host || n.options.host) + n.options.path, u = b.createJSONPRequest(a, t), p = b.ScriptReceivers.create(function(v, E) {
+                  S.remove(p), u.cleanup(), E && E.host && (n.host = E.host), r && r(v, E);
+                });
+                u.send(p);
+              };
+            }, Yt = {
+              name: "jsonp",
+              getAgent: Qt
+            };
+            const Zt = Yt;
+            function me(n, e, t) {
+              var r = n + (e.useTLS ? "s" : ""), s = e.useTLS ? e.hostTLS : e.hostNonTLS;
+              return r + "://" + s + t;
+            }
+            function ve(n, e) {
+              var t = "/app/" + n, r = "?protocol=" + _.PROTOCOL + "&client=js&version=" + _.VERSION + (e ? "&" + e : "");
+              return t + r;
+            }
+            var en = {
+              getInitial: function(n, e) {
+                var t = (e.httpPath || "") + ve(n, "flash=false");
+                return me("ws", e, t);
+              }
+            }, tn = {
+              getInitial: function(n, e) {
+                var t = (e.httpPath || "/pusher") + ve(n);
+                return me("http", e, t);
+              }
+            }, nn = {
+              getInitial: function(n, e) {
+                return me("http", e, e.httpPath || "/pusher");
+              },
+              getPath: function(n, e) {
+                return ve(n);
+              }
+            };
+            class rn {
+              constructor() {
+                this._callbacks = {};
+              }
+              get(e) {
+                return this._callbacks[be(e)];
+              }
+              add(e, t, r) {
+                var s = be(e);
+                this._callbacks[s] = this._callbacks[s] || [], this._callbacks[s].push({
+                  fn: t,
+                  context: r
+                });
+              }
+              remove(e, t, r) {
+                if (!e && !t && !r) {
+                  this._callbacks = {};
+                  return;
+                }
+                var s = e ? [be(e)] : He(this._callbacks);
+                t || r ? this.removeCallback(s, t, r) : this.removeAllCallbacks(s);
+              }
+              removeCallback(e, t, r) {
+                ne(e, function(s) {
+                  this._callbacks[s] = We(this._callbacks[s] || [], function(a) {
+                    return t && t !== a.fn || r && r !== a.context;
+                  }), this._callbacks[s].length === 0 && delete this._callbacks[s];
+                }, this);
+              }
+              removeAllCallbacks(e) {
+                ne(e, function(t) {
+                  delete this._callbacks[t];
+                }, this);
+              }
+            }
+            function be(n) {
+              return "_" + n;
+            }
+            class $ {
+              constructor(e) {
+                this.callbacks = new rn(), this.global_callbacks = [], this.failThrough = e;
+              }
+              bind(e, t, r) {
+                return this.callbacks.add(e, t, r), this;
+              }
+              bind_global(e) {
+                return this.global_callbacks.push(e), this;
+              }
+              unbind(e, t, r) {
+                return this.callbacks.remove(e, t, r), this;
+              }
+              unbind_global(e) {
+                return e ? (this.global_callbacks = We(this.global_callbacks || [], (t) => t !== e), this) : (this.global_callbacks = [], this);
+              }
+              unbind_all() {
+                return this.unbind(), this.unbind_global(), this;
+              }
+              emit(e, t, r) {
+                for (var s = 0; s < this.global_callbacks.length; s++)
+                  this.global_callbacks[s](e, t);
+                var a = this.callbacks.get(e), u = [];
+                if (r ? u.push(t, r) : t && u.push(t), a && a.length > 0)
+                  for (var s = 0; s < a.length; s++)
+                    a[s].fn.apply(a[s].context || window, u);
+                else this.failThrough && this.failThrough(e, t);
+                return this;
+              }
+            }
+            class sn extends $ {
+              constructor(e, t, r, s, a) {
+                super(), this.initialize = b.transportConnectionInitializer, this.hooks = e, this.name = t, this.priority = r, this.key = s, this.options = a, this.state = "new", this.timeline = a.timeline, this.activityTimeout = a.activityTimeout, this.id = this.timeline.generateUniqueID();
+              }
+              handlesActivityChecks() {
+                return !!this.hooks.handlesActivityChecks;
+              }
+              supportsPing() {
+                return !!this.hooks.supportsPing;
+              }
+              connect() {
+                if (this.socket || this.state !== "initialized")
+                  return !1;
+                var e = this.hooks.urls.getInitial(this.key, this.options);
+                try {
+                  this.socket = this.hooks.getSocket(e, this.options);
+                } catch (t) {
+                  return U.defer(() => {
+                    this.onError(t), this.changeState("closed");
+                  }), !1;
+                }
+                return this.bindListeners(), R.debug("Connecting", { transport: this.name, url: e }), this.changeState("connecting"), !0;
+              }
+              close() {
+                return this.socket ? (this.socket.close(), !0) : !1;
+              }
+              send(e) {
+                return this.state === "open" ? (U.defer(() => {
+                  this.socket && this.socket.send(e);
+                }), !0) : !1;
+              }
+              ping() {
+                this.state === "open" && this.supportsPing() && this.socket.ping();
+              }
+              onOpen() {
+                this.hooks.beforeOpen && this.hooks.beforeOpen(this.socket, this.hooks.urls.getPath(this.key, this.options)), this.changeState("open"), this.socket.onopen = void 0;
+              }
+              onError(e) {
+                this.emit("error", { type: "WebSocketError", error: e }), this.timeline.error(this.buildTimelineMessage({ error: e.toString() }));
+              }
+              onClose(e) {
+                e ? this.changeState("closed", {
+                  code: e.code,
+                  reason: e.reason,
+                  wasClean: e.wasClean
+                }) : this.changeState("closed"), this.unbindListeners(), this.socket = void 0;
+              }
+              onMessage(e) {
+                this.emit("message", e);
+              }
+              onActivity() {
+                this.emit("activity");
+              }
+              bindListeners() {
+                this.socket.onopen = () => {
+                  this.onOpen();
+                }, this.socket.onerror = (e) => {
+                  this.onError(e);
+                }, this.socket.onclose = (e) => {
+                  this.onClose(e);
+                }, this.socket.onmessage = (e) => {
+                  this.onMessage(e);
+                }, this.supportsPing() && (this.socket.onactivity = () => {
+                  this.onActivity();
+                });
+              }
+              unbindListeners() {
+                this.socket && (this.socket.onopen = void 0, this.socket.onerror = void 0, this.socket.onclose = void 0, this.socket.onmessage = void 0, this.supportsPing() && (this.socket.onactivity = void 0));
+              }
+              changeState(e, t) {
+                this.state = e, this.timeline.info(this.buildTimelineMessage({
+                  state: e,
+                  params: t
+                })), this.emit(e, t);
+              }
+              buildTimelineMessage(e) {
+                return M({ cid: this.id }, e);
+              }
+            }
+            class Z {
+              constructor(e) {
+                this.hooks = e;
+              }
+              isSupported(e) {
+                return this.hooks.isSupported(e);
+              }
+              createConnection(e, t, r, s) {
+                return new sn(this.hooks, e, t, r, s);
+              }
+            }
+            var on = new Z({
+              urls: en,
+              handlesActivityChecks: !1,
+              supportsPing: !1,
+              isInitialized: function() {
+                return !!b.getWebSocketAPI();
+              },
+              isSupported: function() {
+                return !!b.getWebSocketAPI();
+              },
+              getSocket: function(n) {
+                return b.createWebSocket(n);
+              }
+            }), $e = {
+              urls: tn,
+              handlesActivityChecks: !1,
+              supportsPing: !0,
+              isInitialized: function() {
+                return !0;
+              }
+            }, Xe = M({
+              getSocket: function(n) {
+                return b.HTTPFactory.createStreamingSocket(n);
+              }
+            }, $e), Ve = M({
+              getSocket: function(n) {
+                return b.HTTPFactory.createPollingSocket(n);
+              }
+            }, $e), Je = {
+              isSupported: function() {
+                return b.isXHRSupported();
+              }
+            }, an = new Z(M({}, Xe, Je)), cn = new Z(M({}, Ve, Je)), hn = {
+              ws: on,
+              xhr_streaming: an,
+              xhr_polling: cn
+            };
+            const ce = hn;
+            var un = new Z({
+              file: "sockjs",
+              urls: nn,
+              handlesActivityChecks: !0,
+              supportsPing: !1,
+              isSupported: function() {
+                return !0;
+              },
+              isInitialized: function() {
+                return window.SockJS !== void 0;
+              },
+              getSocket: function(n, e) {
+                return new window.SockJS(n, null, {
+                  js_path: j.getPath("sockjs", {
+                    useTLS: e.useTLS
+                  }),
+                  ignore_null_origin: e.ignoreNullOrigin
+                });
+              },
+              beforeOpen: function(n, e) {
+                n.send(JSON.stringify({
+                  path: e
+                }));
+              }
+            }), Ge = {
+              isSupported: function(n) {
+                var e = b.isXDRSupported(n.useTLS);
+                return e;
+              }
+            }, ln = new Z(M({}, Xe, Ge)), dn = new Z(M({}, Ve, Ge));
+            ce.xdr_streaming = ln, ce.xdr_polling = dn, ce.sockjs = un;
+            const pn = ce;
+            class fn extends $ {
+              constructor() {
+                super();
+                var e = this;
+                window.addEventListener !== void 0 && (window.addEventListener("online", function() {
+                  e.emit("online");
+                }, !1), window.addEventListener("offline", function() {
+                  e.emit("offline");
+                }, !1));
+              }
+              isOnline() {
+                return window.navigator.onLine === void 0 ? !0 : window.navigator.onLine;
+              }
+            }
+            var gn = new fn();
+            class mn {
+              constructor(e, t, r) {
+                this.manager = e, this.transport = t, this.minPingDelay = r.minPingDelay, this.maxPingDelay = r.maxPingDelay, this.pingDelay = void 0;
+              }
+              createConnection(e, t, r, s) {
+                s = M({}, s, {
+                  activityTimeout: this.pingDelay
+                });
+                var a = this.transport.createConnection(e, t, r, s), u = null, p = function() {
+                  a.unbind("open", p), a.bind("closed", v), u = U.now();
+                }, v = (E) => {
+                  if (a.unbind("closed", v), E.code === 1002 || E.code === 1003)
+                    this.manager.reportDeath();
+                  else if (!E.wasClean && u) {
+                    var x = U.now() - u;
+                    x < 2 * this.maxPingDelay && (this.manager.reportDeath(), this.pingDelay = Math.max(x / 2, this.minPingDelay));
+                  }
+                };
+                return a.bind("open", p), a;
+              }
+              isSupported(e) {
+                return this.manager.isAlive() && this.transport.isSupported(e);
+              }
+            }
+            const Ke = {
+              decodeMessage: function(n) {
+                try {
+                  var e = JSON.parse(n.data), t = e.data;
+                  if (typeof t == "string")
+                    try {
+                      t = JSON.parse(e.data);
+                    } catch {
+                    }
+                  var r = {
+                    event: e.event,
+                    channel: e.channel,
+                    data: t
+                  };
+                  return e.user_id && (r.user_id = e.user_id), r;
+                } catch (s) {
+                  throw { type: "MessageParseError", error: s, data: n.data };
+                }
+              },
+              encodeMessage: function(n) {
+                return JSON.stringify(n);
+              },
+              processHandshake: function(n) {
+                var e = Ke.decodeMessage(n);
+                if (e.event === "pusher:connection_established") {
+                  if (!e.data.activity_timeout)
+                    throw "No activity timeout specified in handshake";
+                  return {
+                    action: "connected",
+                    id: e.data.socket_id,
+                    activityTimeout: e.data.activity_timeout * 1e3
+                  };
+                } else {
+                  if (e.event === "pusher:error")
+                    return {
+                      action: this.getCloseAction(e.data),
+                      error: this.getCloseError(e.data)
+                    };
+                  throw "Invalid handshake";
+                }
+              },
+              getCloseAction: function(n) {
+                return n.code < 4e3 ? n.code >= 1002 && n.code <= 1004 ? "backoff" : null : n.code === 4e3 ? "tls_only" : n.code < 4100 ? "refused" : n.code < 4200 ? "backoff" : n.code < 4300 ? "retry" : "refused";
+              },
+              getCloseError: function(n) {
+                return n.code !== 1e3 && n.code !== 1001 ? {
+                  type: "PusherError",
+                  data: {
+                    code: n.code,
+                    message: n.reason || n.message
+                  }
+                } : null;
+              }
+            }, K = Ke;
+            class vn extends $ {
+              constructor(e, t) {
+                super(), this.id = e, this.transport = t, this.activityTimeout = t.activityTimeout, this.bindListeners();
+              }
+              handlesActivityChecks() {
+                return this.transport.handlesActivityChecks();
+              }
+              send(e) {
+                return this.transport.send(e);
+              }
+              send_event(e, t, r) {
+                var s = { event: e, data: t };
+                return r && (s.channel = r), R.debug("Event sent", s), this.send(K.encodeMessage(s));
+              }
+              ping() {
+                this.transport.supportsPing() ? this.transport.ping() : this.send_event("pusher:ping", {});
+              }
+              close() {
+                this.transport.close();
+              }
+              bindListeners() {
+                var e = {
+                  message: (r) => {
+                    var s;
+                    try {
+                      s = K.decodeMessage(r);
+                    } catch (a) {
+                      this.emit("error", {
+                        type: "MessageParseError",
+                        error: a,
+                        data: r.data
+                      });
+                    }
+                    if (s !== void 0) {
+                      switch (R.debug("Event recd", s), s.event) {
+                        case "pusher:error":
+                          this.emit("error", {
+                            type: "PusherError",
+                            data: s.data
+                          });
+                          break;
+                        case "pusher:ping":
+                          this.emit("ping");
+                          break;
+                        case "pusher:pong":
+                          this.emit("pong");
+                          break;
+                      }
+                      this.emit("message", s);
+                    }
+                  },
+                  activity: () => {
+                    this.emit("activity");
+                  },
+                  error: (r) => {
+                    this.emit("error", r);
+                  },
+                  closed: (r) => {
+                    t(), r && r.code && this.handleCloseEvent(r), this.transport = null, this.emit("closed");
+                  }
+                }, t = () => {
+                  B(e, (r, s) => {
+                    this.transport.unbind(s, r);
+                  });
+                };
+                B(e, (r, s) => {
+                  this.transport.bind(s, r);
+                });
+              }
+              handleCloseEvent(e) {
+                var t = K.getCloseAction(e), r = K.getCloseError(e);
+                r && this.emit("error", r), t && this.emit(t, { action: t, error: r });
+              }
+            }
+            class bn {
+              constructor(e, t) {
+                this.transport = e, this.callback = t, this.bindListeners();
+              }
+              close() {
+                this.unbindListeners(), this.transport.close();
+              }
+              bindListeners() {
+                this.onMessage = (e) => {
+                  this.unbindListeners();
+                  var t;
+                  try {
+                    t = K.processHandshake(e);
+                  } catch (r) {
+                    this.finish("error", { error: r }), this.transport.close();
+                    return;
+                  }
+                  t.action === "connected" ? this.finish("connected", {
+                    connection: new vn(t.id, this.transport),
+                    activityTimeout: t.activityTimeout
+                  }) : (this.finish(t.action, { error: t.error }), this.transport.close());
+                }, this.onClosed = (e) => {
+                  this.unbindListeners();
+                  var t = K.getCloseAction(e) || "backoff", r = K.getCloseError(e);
+                  this.finish(t, { error: r });
+                }, this.transport.bind("message", this.onMessage), this.transport.bind("closed", this.onClosed);
+              }
+              unbindListeners() {
+                this.transport.unbind("message", this.onMessage), this.transport.unbind("closed", this.onClosed);
+              }
+              finish(e, t) {
+                this.callback(M({ transport: this.transport, action: e }, t));
+              }
+            }
+            class yn {
+              constructor(e, t) {
+                this.timeline = e, this.options = t || {};
+              }
+              send(e, t) {
+                this.timeline.isEmpty() || this.timeline.send(b.TimelineTransport.getAgent(this, e), t);
+              }
+            }
+            class ye extends $ {
+              constructor(e, t) {
+                super(function(r, s) {
+                  R.debug("No callbacks on " + e + " for " + r);
+                }), this.name = e, this.pusher = t, this.subscribed = !1, this.subscriptionPending = !1, this.subscriptionCancelled = !1;
+              }
+              authorize(e, t) {
+                return t(null, { auth: "" });
+              }
+              trigger(e, t) {
+                if (e.indexOf("client-") !== 0)
+                  throw new d("Event '" + e + "' does not start with 'client-'");
+                if (!this.subscribed) {
+                  var r = T.buildLogSuffix("triggeringClientEvents");
+                  R.warn(`Client event triggered before channel 'subscription_succeeded' event . ${r}`);
+                }
+                return this.pusher.send_event(e, t, this.name);
+              }
+              disconnect() {
+                this.subscribed = !1, this.subscriptionPending = !1;
+              }
+              handleEvent(e) {
+                var t = e.event, r = e.data;
+                if (t === "pusher_internal:subscription_succeeded")
+                  this.handleSubscriptionSucceededEvent(e);
+                else if (t === "pusher_internal:subscription_count")
+                  this.handleSubscriptionCountEvent(e);
+                else if (t.indexOf("pusher_internal:") !== 0) {
+                  var s = {};
+                  this.emit(t, r, s);
+                }
+              }
+              handleSubscriptionSucceededEvent(e) {
+                this.subscriptionPending = !1, this.subscribed = !0, this.subscriptionCancelled ? this.pusher.unsubscribe(this.name) : this.emit("pusher:subscription_succeeded", e.data);
+              }
+              handleSubscriptionCountEvent(e) {
+                e.data.subscription_count && (this.subscriptionCount = e.data.subscription_count), this.emit("pusher:subscription_count", e.data);
+              }
+              subscribe() {
+                this.subscribed || (this.subscriptionPending = !0, this.subscriptionCancelled = !1, this.authorize(this.pusher.connection.socket_id, (e, t) => {
+                  e ? (this.subscriptionPending = !1, R.error(e.toString()), this.emit("pusher:subscription_error", Object.assign({}, {
+                    type: "AuthError",
+                    error: e.message
+                  }, e instanceof H ? { status: e.status } : {}))) : this.pusher.send_event("pusher:subscribe", {
+                    auth: t.auth,
+                    channel_data: t.channel_data,
+                    channel: this.name
+                  });
+                }));
+              }
+              unsubscribe() {
+                this.subscribed = !1, this.pusher.send_event("pusher:unsubscribe", {
+                  channel: this.name
+                });
+              }
+              cancelSubscription() {
+                this.subscriptionCancelled = !0;
+              }
+              reinstateSubscription() {
+                this.subscriptionCancelled = !1;
+              }
+            }
+            class we extends ye {
+              authorize(e, t) {
+                return this.pusher.config.channelAuthorizer({
+                  channelName: this.name,
+                  socketId: e
+                }, t);
+              }
+            }
+            class wn {
+              constructor() {
+                this.reset();
+              }
+              get(e) {
+                return Object.prototype.hasOwnProperty.call(this.members, e) ? {
+                  id: e,
+                  info: this.members[e]
+                } : null;
+              }
+              each(e) {
+                B(this.members, (t, r) => {
+                  e(this.get(r));
+                });
+              }
+              setMyID(e) {
+                this.myID = e;
+              }
+              onSubscription(e) {
+                this.members = e.presence.hash, this.count = e.presence.count, this.me = this.get(this.myID);
+              }
+              addMember(e) {
+                return this.get(e.user_id) === null && this.count++, this.members[e.user_id] = e.user_info, this.get(e.user_id);
+              }
+              removeMember(e) {
+                var t = this.get(e.user_id);
+                return t && (delete this.members[e.user_id], this.count--), t;
+              }
+              reset() {
+                this.members = {}, this.count = 0, this.myID = null, this.me = null;
+              }
+            }
+            var Cn = function(n, e, t, r) {
+              function s(a) {
+                return a instanceof t ? a : new t(function(u) {
+                  u(a);
+                });
+              }
+              return new (t || (t = Promise))(function(a, u) {
+                function p(x) {
+                  try {
+                    E(r.next(x));
+                  } catch (I) {
+                    u(I);
+                  }
+                }
+                function v(x) {
+                  try {
+                    E(r.throw(x));
+                  } catch (I) {
+                    u(I);
+                  }
+                }
+                function E(x) {
+                  x.done ? a(x.value) : s(x.value).then(p, v);
+                }
+                E((r = r.apply(n, e || [])).next());
+              });
+            };
+            class Sn extends we {
+              constructor(e, t) {
+                super(e, t), this.members = new wn();
+              }
+              authorize(e, t) {
+                super.authorize(e, (r, s) => Cn(this, void 0, void 0, function* () {
+                  if (!r)
+                    if (s = s, s.channel_data != null) {
+                      var a = JSON.parse(s.channel_data);
+                      this.members.setMyID(a.user_id);
+                    } else if (yield this.pusher.user.signinDonePromise, this.pusher.user.user_data != null)
+                      this.members.setMyID(this.pusher.user.user_data.id);
+                    else {
+                      let u = T.buildLogSuffix("authorizationEndpoint");
+                      R.error(`Invalid auth response for channel '${this.name}', expected 'channel_data' field. ${u}, or the user should be signed in.`), t("Invalid auth response");
+                      return;
+                    }
+                  t(r, s);
+                }));
+              }
+              handleEvent(e) {
+                var t = e.event;
+                if (t.indexOf("pusher_internal:") === 0)
+                  this.handleInternalEvent(e);
+                else {
+                  var r = e.data, s = {};
+                  e.user_id && (s.user_id = e.user_id), this.emit(t, r, s);
+                }
+              }
+              handleInternalEvent(e) {
+                var t = e.event, r = e.data;
+                switch (t) {
+                  case "pusher_internal:subscription_succeeded":
+                    this.handleSubscriptionSucceededEvent(e);
+                    break;
+                  case "pusher_internal:subscription_count":
+                    this.handleSubscriptionCountEvent(e);
+                    break;
+                  case "pusher_internal:member_added":
+                    var s = this.members.addMember(r);
+                    this.emit("pusher:member_added", s);
+                    break;
+                  case "pusher_internal:member_removed":
+                    var a = this.members.removeMember(r);
+                    a && this.emit("pusher:member_removed", a);
+                    break;
+                }
+              }
+              handleSubscriptionSucceededEvent(e) {
+                this.subscriptionPending = !1, this.subscribed = !0, this.subscriptionCancelled ? this.pusher.unsubscribe(this.name) : (this.members.onSubscription(e.data), this.emit("pusher:subscription_succeeded", this.members));
+              }
+              disconnect() {
+                this.members.reset(), super.disconnect();
+              }
+            }
+            var _n = m(978), Ce = m(594);
+            class Tn extends we {
+              constructor(e, t, r) {
+                super(e, t), this.key = null, this.nacl = r;
+              }
+              authorize(e, t) {
+                super.authorize(e, (r, s) => {
+                  if (r) {
+                    t(r, s);
+                    return;
+                  }
+                  let a = s.shared_secret;
+                  if (!a) {
+                    t(new Error(`No shared_secret key in auth payload for encrypted channel: ${this.name}`), null);
+                    return;
+                  }
+                  this.key = (0, Ce.decode)(a), delete s.shared_secret, t(null, s);
+                });
+              }
+              trigger(e, t) {
+                throw new z("Client events are not currently supported for encrypted channels");
+              }
+              handleEvent(e) {
+                var t = e.event, r = e.data;
+                if (t.indexOf("pusher_internal:") === 0 || t.indexOf("pusher:") === 0) {
+                  super.handleEvent(e);
+                  return;
+                }
+                this.handleEncryptedEvent(t, r);
+              }
+              handleEncryptedEvent(e, t) {
+                if (!this.key) {
+                  R.debug("Received encrypted event before key has been retrieved from the authEndpoint");
+                  return;
+                }
+                if (!t.ciphertext || !t.nonce) {
+                  R.error("Unexpected format for encrypted event, expected object with `ciphertext` and `nonce` fields, got: " + t);
+                  return;
+                }
+                let r = (0, Ce.decode)(t.ciphertext);
+                if (r.length < this.nacl.secretbox.overheadLength) {
+                  R.error(`Expected encrypted event ciphertext length to be ${this.nacl.secretbox.overheadLength}, got: ${r.length}`);
+                  return;
+                }
+                let s = (0, Ce.decode)(t.nonce);
+                if (s.length < this.nacl.secretbox.nonceLength) {
+                  R.error(`Expected encrypted event nonce length to be ${this.nacl.secretbox.nonceLength}, got: ${s.length}`);
+                  return;
+                }
+                let a = this.nacl.secretbox.open(r, s, this.key);
+                if (a === null) {
+                  R.debug("Failed to decrypt an event, probably because it was encrypted with a different key. Fetching a new key from the authEndpoint..."), this.authorize(this.pusher.connection.socket_id, (u, p) => {
+                    if (u) {
+                      R.error(`Failed to make a request to the authEndpoint: ${p}. Unable to fetch new key, so dropping encrypted event`);
+                      return;
+                    }
+                    if (a = this.nacl.secretbox.open(r, s, this.key), a === null) {
+                      R.error("Failed to decrypt event with new key. Dropping encrypted event");
+                      return;
+                    }
+                    this.emit(e, this.getDataToEmit(a));
+                  });
+                  return;
+                }
+                this.emit(e, this.getDataToEmit(a));
+              }
+              getDataToEmit(e) {
+                let t = (0, _n.D4)(e);
+                try {
+                  return JSON.parse(t);
+                } catch {
+                  return t;
+                }
+              }
+            }
+            class kn extends $ {
+              constructor(e, t) {
+                super(), this.state = "initialized", this.connection = null, this.key = e, this.options = t, this.timeline = this.options.timeline, this.usingTLS = this.options.useTLS, this.errorCallbacks = this.buildErrorCallbacks(), this.connectionCallbacks = this.buildConnectionCallbacks(this.errorCallbacks), this.handshakeCallbacks = this.buildHandshakeCallbacks(this.errorCallbacks);
+                var r = b.getNetwork();
+                r.bind("online", () => {
+                  this.timeline.info({ netinfo: "online" }), (this.state === "connecting" || this.state === "unavailable") && this.retryIn(0);
+                }), r.bind("offline", () => {
+                  this.timeline.info({ netinfo: "offline" }), this.connection && this.sendActivityCheck();
+                }), this.updateStrategy();
+              }
+              switchCluster(e) {
+                this.key = e, this.updateStrategy(), this.retryIn(0);
+              }
+              connect() {
+                if (!(this.connection || this.runner)) {
+                  if (!this.strategy.isSupported()) {
+                    this.updateState("failed");
+                    return;
+                  }
+                  this.updateState("connecting"), this.startConnecting(), this.setUnavailableTimer();
+                }
+              }
+              send(e) {
+                return this.connection ? this.connection.send(e) : !1;
+              }
+              send_event(e, t, r) {
+                return this.connection ? this.connection.send_event(e, t, r) : !1;
+              }
+              disconnect() {
+                this.disconnectInternally(), this.updateState("disconnected");
+              }
+              isUsingTLS() {
+                return this.usingTLS;
+              }
+              startConnecting() {
+                var e = (t, r) => {
+                  t ? this.runner = this.strategy.connect(0, e) : r.action === "error" ? (this.emit("error", {
+                    type: "HandshakeError",
+                    error: r.error
+                  }), this.timeline.error({ handshakeError: r.error })) : (this.abortConnecting(), this.handshakeCallbacks[r.action](r));
+                };
+                this.runner = this.strategy.connect(0, e);
+              }
+              abortConnecting() {
+                this.runner && (this.runner.abort(), this.runner = null);
+              }
+              disconnectInternally() {
+                if (this.abortConnecting(), this.clearRetryTimer(), this.clearUnavailableTimer(), this.connection) {
+                  var e = this.abandonConnection();
+                  e.close();
+                }
+              }
+              updateStrategy() {
+                this.strategy = this.options.getStrategy({
+                  key: this.key,
+                  timeline: this.timeline,
+                  useTLS: this.usingTLS
+                });
+              }
+              retryIn(e) {
+                this.timeline.info({ action: "retry", delay: e }), e > 0 && this.emit("connecting_in", Math.round(e / 1e3)), this.retryTimer = new G(e || 0, () => {
+                  this.disconnectInternally(), this.connect();
+                });
+              }
+              clearRetryTimer() {
+                this.retryTimer && (this.retryTimer.ensureAborted(), this.retryTimer = null);
+              }
+              setUnavailableTimer() {
+                this.unavailableTimer = new G(this.options.unavailableTimeout, () => {
+                  this.updateState("unavailable");
+                });
+              }
+              clearUnavailableTimer() {
+                this.unavailableTimer && this.unavailableTimer.ensureAborted();
+              }
+              sendActivityCheck() {
+                this.stopActivityCheck(), this.connection.ping(), this.activityTimer = new G(this.options.pongTimeout, () => {
+                  this.timeline.error({ pong_timed_out: this.options.pongTimeout }), this.retryIn(0);
+                });
+              }
+              resetActivityCheck() {
+                this.stopActivityCheck(), this.connection && !this.connection.handlesActivityChecks() && (this.activityTimer = new G(this.activityTimeout, () => {
+                  this.sendActivityCheck();
+                }));
+              }
+              stopActivityCheck() {
+                this.activityTimer && this.activityTimer.ensureAborted();
+              }
+              buildConnectionCallbacks(e) {
+                return M({}, e, {
+                  message: (t) => {
+                    this.resetActivityCheck(), this.emit("message", t);
+                  },
+                  ping: () => {
+                    this.send_event("pusher:pong", {});
+                  },
+                  activity: () => {
+                    this.resetActivityCheck();
+                  },
+                  error: (t) => {
+                    this.emit("error", t);
+                  },
+                  closed: () => {
+                    this.abandonConnection(), this.shouldRetry() && this.retryIn(1e3);
+                  }
+                });
+              }
+              buildHandshakeCallbacks(e) {
+                return M({}, e, {
+                  connected: (t) => {
+                    this.activityTimeout = Math.min(this.options.activityTimeout, t.activityTimeout, t.connection.activityTimeout || 1 / 0), this.clearUnavailableTimer(), this.setConnection(t.connection), this.socket_id = this.connection.id, this.updateState("connected", { socket_id: this.socket_id });
+                  }
+                });
+              }
+              buildErrorCallbacks() {
+                let e = (t) => (r) => {
+                  r.error && this.emit("error", { type: "WebSocketError", error: r.error }), t(r);
+                };
+                return {
+                  tls_only: e(() => {
+                    this.usingTLS = !0, this.updateStrategy(), this.retryIn(0);
+                  }),
+                  refused: e(() => {
+                    this.disconnect();
+                  }),
+                  backoff: e(() => {
+                    this.retryIn(1e3);
+                  }),
+                  retry: e(() => {
+                    this.retryIn(0);
+                  })
+                };
+              }
+              setConnection(e) {
+                this.connection = e;
+                for (var t in this.connectionCallbacks)
+                  this.connection.bind(t, this.connectionCallbacks[t]);
+                this.resetActivityCheck();
+              }
+              abandonConnection() {
+                if (this.connection) {
+                  this.stopActivityCheck();
+                  for (var e in this.connectionCallbacks)
+                    this.connection.unbind(e, this.connectionCallbacks[e]);
+                  var t = this.connection;
+                  return this.connection = null, t;
+                }
+              }
+              updateState(e, t) {
+                var r = this.state;
+                if (this.state = e, r !== e) {
+                  var s = e;
+                  s === "connected" && (s += " with new socket ID " + t.socket_id), R.debug("State changed", r + " -> " + s), this.timeline.info({ state: e, params: t }), this.emit("state_change", { previous: r, current: e }), this.emit(e, t);
+                }
+              }
+              shouldRetry() {
+                return this.state === "connecting" || this.state === "connected";
+              }
+            }
+            class En {
+              constructor() {
+                this.channels = {};
+              }
+              add(e, t) {
+                return this.channels[e] || (this.channels[e] = xn(e, t)), this.channels[e];
+              }
+              all() {
+                return zt(this.channels);
+              }
+              find(e) {
+                return this.channels[e];
+              }
+              remove(e) {
+                var t = this.channels[e];
+                return delete this.channels[e], t;
+              }
+              disconnect() {
+                B(this.channels, function(e) {
+                  e.disconnect();
+                });
+              }
+            }
+            function xn(n, e) {
+              if (n.indexOf("private-encrypted-") === 0) {
+                if (e.config.nacl)
+                  return X.createEncryptedChannel(n, e, e.config.nacl);
+                let t = "Tried to subscribe to a private-encrypted- channel but no nacl implementation available", r = T.buildLogSuffix("encryptedChannelSupport");
+                throw new z(`${t}. ${r}`);
+              } else {
+                if (n.indexOf("private-") === 0)
+                  return X.createPrivateChannel(n, e);
+                if (n.indexOf("presence-") === 0)
+                  return X.createPresenceChannel(n, e);
+                if (n.indexOf("#") === 0)
+                  throw new w('Cannot create a channel with name "' + n + '".');
+                return X.createChannel(n, e);
+              }
+            }
+            var An = {
+              createChannels() {
+                return new En();
+              },
+              createConnectionManager(n, e) {
+                return new kn(n, e);
+              },
+              createChannel(n, e) {
+                return new ye(n, e);
+              },
+              createPrivateChannel(n, e) {
+                return new we(n, e);
+              },
+              createPresenceChannel(n, e) {
+                return new Sn(n, e);
+              },
+              createEncryptedChannel(n, e, t) {
+                return new Tn(n, e, t);
+              },
+              createTimelineSender(n, e) {
+                return new yn(n, e);
+              },
+              createHandshake(n, e) {
+                return new bn(n, e);
+              },
+              createAssistantToTheTransportManager(n, e, t) {
+                return new mn(n, e, t);
+              }
+            };
+            const X = An;
+            class Qe {
+              constructor(e) {
+                this.options = e || {}, this.livesLeft = this.options.lives || 1 / 0;
+              }
+              getAssistant(e) {
+                return X.createAssistantToTheTransportManager(this, e, {
+                  minPingDelay: this.options.minPingDelay,
+                  maxPingDelay: this.options.maxPingDelay
+                });
+              }
+              isAlive() {
+                return this.livesLeft > 0;
+              }
+              reportDeath() {
+                this.livesLeft -= 1;
+              }
+            }
+            class Q {
+              constructor(e, t) {
+                this.strategies = e, this.loop = !!t.loop, this.failFast = !!t.failFast, this.timeout = t.timeout, this.timeoutLimit = t.timeoutLimit;
+              }
+              isSupported() {
+                return Be(this.strategies, U.method("isSupported"));
+              }
+              connect(e, t) {
+                var r = this.strategies, s = 0, a = this.timeout, u = null, p = (v, E) => {
+                  E ? t(null, E) : (s = s + 1, this.loop && (s = s % r.length), s < r.length ? (a && (a = a * 2, this.timeoutLimit && (a = Math.min(a, this.timeoutLimit))), u = this.tryStrategy(r[s], e, { timeout: a, failFast: this.failFast }, p)) : t(!0));
+                };
+                return u = this.tryStrategy(r[s], e, { timeout: a, failFast: this.failFast }, p), {
+                  abort: function() {
+                    u.abort();
+                  },
+                  forceMinPriority: function(v) {
+                    e = v, u && u.forceMinPriority(v);
+                  }
+                };
+              }
+              tryStrategy(e, t, r, s) {
+                var a = null, u = null;
+                return r.timeout > 0 && (a = new G(r.timeout, function() {
+                  u.abort(), s(!0);
+                })), u = e.connect(t, function(p, v) {
+                  p && a && a.isRunning() && !r.failFast || (a && a.ensureAborted(), s(p, v));
+                }), {
+                  abort: function() {
+                    a && a.ensureAborted(), u.abort();
+                  },
+                  forceMinPriority: function(p) {
+                    u.forceMinPriority(p);
+                  }
+                };
+              }
+            }
+            class Se {
+              constructor(e) {
+                this.strategies = e;
+              }
+              isSupported() {
+                return Be(this.strategies, U.method("isSupported"));
+              }
+              connect(e, t) {
+                return Pn(this.strategies, e, function(r, s) {
+                  return function(a, u) {
+                    if (s[r].error = a, a) {
+                      Rn(s) && t(!0);
+                      return;
+                    }
+                    ne(s, function(p) {
+                      p.forceMinPriority(u.transport.priority);
+                    }), t(null, u);
+                  };
+                });
+              }
+            }
+            function Pn(n, e, t) {
+              var r = De(n, function(s, a, u, p) {
+                return s.connect(e, t(a, p));
+              });
+              return {
+                abort: function() {
+                  ne(r, Ln);
+                },
+                forceMinPriority: function(s) {
+                  ne(r, function(a) {
+                    a.forceMinPriority(s);
+                  });
+                }
+              };
+            }
+            function Rn(n) {
+              return Wt(n, function(e) {
+                return !!e.error;
+              });
+            }
+            function Ln(n) {
+              !n.error && !n.aborted && (n.abort(), n.aborted = !0);
+            }
+            class In {
+              constructor(e, t, r) {
+                this.strategy = e, this.transports = t, this.ttl = r.ttl || 18e5, this.usingTLS = r.useTLS, this.timeline = r.timeline;
+              }
+              isSupported() {
+                return this.strategy.isSupported();
+              }
+              connect(e, t) {
+                var r = this.usingTLS, s = On(r), a = s && s.cacheSkipCount ? s.cacheSkipCount : 0, u = [this.strategy];
+                if (s && s.timestamp + this.ttl >= U.now()) {
+                  var p = this.transports[s.transport];
+                  p && (["ws", "wss"].includes(s.transport) || a > 3 ? (this.timeline.info({
+                    cached: !0,
+                    transport: s.transport,
+                    latency: s.latency
+                  }), u.push(new Q([p], {
+                    timeout: s.latency * 2 + 1e3,
+                    failFast: !0
+                  }))) : a++);
+                }
+                var v = U.now(), E = u.pop().connect(e, function x(I, de) {
+                  I ? (Ye(r), u.length > 0 ? (v = U.now(), E = u.pop().connect(e, x)) : t(I)) : (qn(r, de.transport.name, U.now() - v, a), t(null, de));
+                });
+                return {
+                  abort: function() {
+                    E.abort();
+                  },
+                  forceMinPriority: function(x) {
+                    e = x, E && E.forceMinPriority(x);
+                  }
+                };
+              }
+            }
+            function _e(n) {
+              return "pusherTransport" + (n ? "TLS" : "NonTLS");
+            }
+            function On(n) {
+              var e = b.getLocalStorage();
+              if (e)
+                try {
+                  var t = e[_e(n)];
+                  if (t)
+                    return JSON.parse(t);
+                } catch {
+                  Ye(n);
+                }
+              return null;
+            }
+            function qn(n, e, t, r) {
+              var s = b.getLocalStorage();
+              if (s)
+                try {
+                  s[_e(n)] = ae({
+                    timestamp: U.now(),
+                    transport: e,
+                    latency: t,
+                    cacheSkipCount: r
+                  });
+                } catch {
+                }
+            }
+            function Ye(n) {
+              var e = b.getLocalStorage();
+              if (e)
+                try {
+                  delete e[_e(n)];
+                } catch {
+                }
+            }
+            class he {
+              constructor(e, { delay: t }) {
+                this.strategy = e, this.options = { delay: t };
+              }
+              isSupported() {
+                return this.strategy.isSupported();
+              }
+              connect(e, t) {
+                var r = this.strategy, s, a = new G(this.options.delay, function() {
+                  s = r.connect(e, t);
+                });
+                return {
+                  abort: function() {
+                    a.ensureAborted(), s && s.abort();
+                  },
+                  forceMinPriority: function(u) {
+                    e = u, s && s.forceMinPriority(u);
+                  }
+                };
+              }
+            }
+            class ie {
+              constructor(e, t, r) {
+                this.test = e, this.trueBranch = t, this.falseBranch = r;
+              }
+              isSupported() {
+                var e = this.test() ? this.trueBranch : this.falseBranch;
+                return e.isSupported();
+              }
+              connect(e, t) {
+                var r = this.test() ? this.trueBranch : this.falseBranch;
+                return r.connect(e, t);
+              }
+            }
+            class Un {
+              constructor(e) {
+                this.strategy = e;
+              }
+              isSupported() {
+                return this.strategy.isSupported();
+              }
+              connect(e, t) {
+                var r = this.strategy.connect(e, function(s, a) {
+                  a && r.abort(), t(s, a);
+                });
+                return r;
+              }
+            }
+            function re(n) {
+              return function() {
+                return n.isSupported();
+              };
+            }
+            var jn = function(n, e, t) {
+              var r = {};
+              function s(lt, Oi, qi, Ui, ji) {
+                var dt = t(n, lt, Oi, qi, Ui, ji);
+                return r[lt] = dt, dt;
+              }
+              var a = Object.assign({}, e, {
+                hostNonTLS: n.wsHost + ":" + n.wsPort,
+                hostTLS: n.wsHost + ":" + n.wssPort,
+                httpPath: n.wsPath
+              }), u = Object.assign({}, a, {
+                useTLS: !0
+              }), p = Object.assign({}, e, {
+                hostNonTLS: n.httpHost + ":" + n.httpPort,
+                hostTLS: n.httpHost + ":" + n.httpsPort,
+                httpPath: n.httpPath
+              }), v = {
+                loop: !0,
+                timeout: 15e3,
+                timeoutLimit: 6e4
+              }, E = new Qe({
+                minPingDelay: 1e4,
+                maxPingDelay: n.activityTimeout
+              }), x = new Qe({
+                lives: 2,
+                minPingDelay: 1e4,
+                maxPingDelay: n.activityTimeout
+              }), I = s("ws", "ws", 3, a, E), de = s("wss", "ws", 3, u, E), Ai = s("sockjs", "sockjs", 1, p), st = s("xhr_streaming", "xhr_streaming", 1, p, x), Pi = s("xdr_streaming", "xdr_streaming", 1, p, x), ot = s("xhr_polling", "xhr_polling", 1, p), Ri = s("xdr_polling", "xdr_polling", 1, p), at = new Q([I], v), Li = new Q([de], v), Ii = new Q([Ai], v), ct = new Q([
+                new ie(re(st), st, Pi)
+              ], v), ht = new Q([
+                new ie(re(ot), ot, Ri)
+              ], v), ut = new Q([
+                new ie(re(ct), new Se([
+                  ct,
+                  new he(ht, { delay: 4e3 })
+                ]), ht)
+              ], v), Ee = new ie(re(ut), ut, Ii), xe;
+              return e.useTLS ? xe = new Se([
+                at,
+                new he(Ee, { delay: 2e3 })
+              ]) : xe = new Se([
+                at,
+                new he(Li, { delay: 2e3 }),
+                new he(Ee, { delay: 5e3 })
+              ]), new In(new Un(new ie(re(I), xe, Ee)), r, {
+                ttl: 18e5,
+                timeline: e.timeline,
+                useTLS: e.useTLS
+              });
+            };
+            const Nn = jn;
+            function Mn() {
+              var n = this;
+              n.timeline.info(n.buildTimelineMessage({
+                transport: n.name + (n.options.useTLS ? "s" : "")
+              })), n.hooks.isInitialized() ? n.changeState("initialized") : n.hooks.file ? (n.changeState("initializing"), j.load(n.hooks.file, { useTLS: n.options.useTLS }, function(e, t) {
+                n.hooks.isInitialized() ? (n.changeState("initialized"), t(!0)) : (e && n.onError(e), n.onClose(), t(!1));
+              })) : n.onClose();
+            }
+            var zn = {
+              getRequest: function(n) {
+                var e = new window.XDomainRequest();
+                return e.ontimeout = function() {
+                  n.emit("error", new P()), n.close();
+                }, e.onerror = function(t) {
+                  n.emit("error", t), n.close();
+                }, e.onprogress = function() {
+                  e.responseText && e.responseText.length > 0 && n.onChunk(200, e.responseText);
+                }, e.onload = function() {
+                  e.responseText && e.responseText.length > 0 && n.onChunk(200, e.responseText), n.emit("finished", 200), n.close();
+                }, e;
+              },
+              abortRequest: function(n) {
+                n.ontimeout = n.onerror = n.onprogress = n.onload = null, n.abort();
+              }
+            };
+            const Hn = zn, Dn = 256 * 1024;
+            class Wn extends $ {
+              constructor(e, t, r) {
+                super(), this.hooks = e, this.method = t, this.url = r;
+              }
+              start(e) {
+                this.position = 0, this.xhr = this.hooks.getRequest(this), this.unloader = () => {
+                  this.close();
+                }, b.addUnloadListener(this.unloader), this.xhr.open(this.method, this.url, !0), this.xhr.setRequestHeader && this.xhr.setRequestHeader("Content-Type", "application/json"), this.xhr.send(e);
+              }
+              close() {
+                this.unloader && (b.removeUnloadListener(this.unloader), this.unloader = null), this.xhr && (this.hooks.abortRequest(this.xhr), this.xhr = null);
+              }
+              onChunk(e, t) {
+                for (; ; ) {
+                  var r = this.advanceBuffer(t);
+                  if (r)
+                    this.emit("chunk", { status: e, data: r });
+                  else
+                    break;
+                }
+                this.isBufferTooLong(t) && this.emit("buffer_too_long");
+              }
+              advanceBuffer(e) {
+                var t = e.slice(this.position), r = t.indexOf(`
+`);
+                return r !== -1 ? (this.position += r + 1, t.slice(0, r)) : null;
+              }
+              isBufferTooLong(e) {
+                return this.position === e.length && e.length > Dn;
+              }
+            }
+            var Te;
+            (function(n) {
+              n[n.CONNECTING = 0] = "CONNECTING", n[n.OPEN = 1] = "OPEN", n[n.CLOSED = 3] = "CLOSED";
+            })(Te || (Te = {}));
+            const Y = Te;
+            var Fn = 1;
+            class Bn {
+              constructor(e, t) {
+                this.hooks = e, this.session = et(1e3) + "/" + Jn(8), this.location = $n(t), this.readyState = Y.CONNECTING, this.openStream();
+              }
+              send(e) {
+                return this.sendRaw(JSON.stringify([e]));
+              }
+              ping() {
+                this.hooks.sendHeartbeat(this);
+              }
+              close(e, t) {
+                this.onClose(e, t, !0);
+              }
+              sendRaw(e) {
+                if (this.readyState === Y.OPEN)
+                  try {
+                    return b.createSocketRequest("POST", Ze(Xn(this.location, this.session))).start(e), !0;
+                  } catch {
+                    return !1;
+                  }
+                else
+                  return !1;
+              }
+              reconnect() {
+                this.closeStream(), this.openStream();
+              }
+              onClose(e, t, r) {
+                this.closeStream(), this.readyState = Y.CLOSED, this.onclose && this.onclose({
+                  code: e,
+                  reason: t,
+                  wasClean: r
+                });
+              }
+              onChunk(e) {
+                if (e.status === 200) {
+                  this.readyState === Y.OPEN && this.onActivity();
+                  var t, r = e.data.slice(0, 1);
+                  switch (r) {
+                    case "o":
+                      t = JSON.parse(e.data.slice(1) || "{}"), this.onOpen(t);
+                      break;
+                    case "a":
+                      t = JSON.parse(e.data.slice(1) || "[]");
+                      for (var s = 0; s < t.length; s++)
+                        this.onEvent(t[s]);
+                      break;
+                    case "m":
+                      t = JSON.parse(e.data.slice(1) || "null"), this.onEvent(t);
+                      break;
+                    case "h":
+                      this.hooks.onHeartbeat(this);
+                      break;
+                    case "c":
+                      t = JSON.parse(e.data.slice(1) || "[]"), this.onClose(t[0], t[1], !0);
+                      break;
+                  }
+                }
+              }
+              onOpen(e) {
+                this.readyState === Y.CONNECTING ? (e && e.hostname && (this.location.base = Vn(this.location.base, e.hostname)), this.readyState = Y.OPEN, this.onopen && this.onopen()) : this.onClose(1006, "Server lost session", !0);
+              }
+              onEvent(e) {
+                this.readyState === Y.OPEN && this.onmessage && this.onmessage({ data: e });
+              }
+              onActivity() {
+                this.onactivity && this.onactivity();
+              }
+              onError(e) {
+                this.onerror && this.onerror(e);
+              }
+              openStream() {
+                this.stream = b.createSocketRequest("POST", Ze(this.hooks.getReceiveURL(this.location, this.session))), this.stream.bind("chunk", (e) => {
+                  this.onChunk(e);
+                }), this.stream.bind("finished", (e) => {
+                  this.hooks.onFinished(this, e);
+                }), this.stream.bind("buffer_too_long", () => {
+                  this.reconnect();
+                });
+                try {
+                  this.stream.start();
+                } catch (e) {
+                  U.defer(() => {
+                    this.onError(e), this.onClose(1006, "Could not start streaming", !1);
+                  });
+                }
+              }
+              closeStream() {
+                this.stream && (this.stream.unbind_all(), this.stream.close(), this.stream = null);
+              }
+            }
+            function $n(n) {
+              var e = /([^\?]*)\/*(\??.*)/.exec(n);
+              return {
+                base: e[1],
+                queryString: e[2]
+              };
+            }
+            function Xn(n, e) {
+              return n.base + "/" + e + "/xhr_send";
+            }
+            function Ze(n) {
+              var e = n.indexOf("?") === -1 ? "?" : "&";
+              return n + e + "t=" + +/* @__PURE__ */ new Date() + "&n=" + Fn++;
+            }
+            function Vn(n, e) {
+              var t = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(n);
+              return t[1] + e + t[3];
+            }
+            function et(n) {
+              return b.randomInt(n);
+            }
+            function Jn(n) {
+              for (var e = [], t = 0; t < n; t++)
+                e.push(et(32).toString(32));
+              return e.join("");
+            }
+            const Gn = Bn;
+            var Kn = {
+              getReceiveURL: function(n, e) {
+                return n.base + "/" + e + "/xhr_streaming" + n.queryString;
+              },
+              onHeartbeat: function(n) {
+                n.sendRaw("[]");
+              },
+              sendHeartbeat: function(n) {
+                n.sendRaw("[]");
+              },
+              onFinished: function(n, e) {
+                n.onClose(1006, "Connection interrupted (" + e + ")", !1);
+              }
+            };
+            const Qn = Kn;
+            var Yn = {
+              getReceiveURL: function(n, e) {
+                return n.base + "/" + e + "/xhr" + n.queryString;
+              },
+              onHeartbeat: function() {
+              },
+              sendHeartbeat: function(n) {
+                n.sendRaw("[]");
+              },
+              onFinished: function(n, e) {
+                e === 200 ? n.reconnect() : n.onClose(1006, "Connection interrupted (" + e + ")", !1);
+              }
+            };
+            const Zn = Yn;
+            var ei = {
+              getRequest: function(n) {
+                var e = b.getXHRAPI(), t = new e();
+                return t.onreadystatechange = t.onprogress = function() {
+                  switch (t.readyState) {
+                    case 3:
+                      t.responseText && t.responseText.length > 0 && n.onChunk(t.status, t.responseText);
+                      break;
+                    case 4:
+                      t.responseText && t.responseText.length > 0 && n.onChunk(t.status, t.responseText), n.emit("finished", t.status), n.close();
+                      break;
+                  }
+                }, t;
+              },
+              abortRequest: function(n) {
+                n.onreadystatechange = null, n.abort();
+              }
+            };
+            const ti = ei;
+            var ni = {
+              createStreamingSocket(n) {
+                return this.createSocket(Qn, n);
+              },
+              createPollingSocket(n) {
+                return this.createSocket(Zn, n);
+              },
+              createSocket(n, e) {
+                return new Gn(n, e);
+              },
+              createXHR(n, e) {
+                return this.createRequest(ti, n, e);
+              },
+              createRequest(n, e, t) {
+                return new Wn(n, e, t);
+              }
+            };
+            const tt = ni;
+            tt.createXDR = function(n, e) {
+              return this.createRequest(Hn, n, e);
+            };
+            var ii = {
+              nextAuthCallbackID: 1,
+              auth_callbacks: {},
+              ScriptReceivers: S,
+              DependenciesReceivers: W,
+              getDefaultStrategy: Nn,
+              Transports: pn,
+              transportConnectionInitializer: Mn,
+              HTTPFactory: tt,
+              TimelineTransport: Zt,
+              getXHRAPI() {
+                return window.XMLHttpRequest;
+              },
+              getWebSocketAPI() {
+                return window.WebSocket || window.MozWebSocket;
+              },
+              setup(n) {
+                window.Pusher = n;
+                var e = () => {
+                  this.onDocumentBody(n.ready);
+                };
+                window.JSON ? e() : j.load("json2", {}, e);
+              },
+              getDocument() {
+                return document;
+              },
+              getProtocol() {
+                return this.getDocument().location.protocol;
+              },
+              getAuthorizers() {
+                return { ajax: xt, jsonp: Jt };
+              },
+              onDocumentBody(n) {
+                document.body ? n() : setTimeout(() => {
+                  this.onDocumentBody(n);
+                }, 0);
+              },
+              createJSONPRequest(n, e) {
+                return new Kt(n, e);
+              },
+              createScriptRequest(n) {
+                return new Gt(n);
+              },
+              getLocalStorage() {
+                try {
+                  return window.localStorage;
+                } catch {
+                  return;
+                }
+              },
+              createXHR() {
+                return this.getXHRAPI() ? this.createXMLHttpRequest() : this.createMicrosoftXHR();
+              },
+              createXMLHttpRequest() {
+                var n = this.getXHRAPI();
+                return new n();
+              },
+              createMicrosoftXHR() {
+                return new ActiveXObject("Microsoft.XMLHTTP");
+              },
+              getNetwork() {
+                return gn;
+              },
+              createWebSocket(n) {
+                var e = this.getWebSocketAPI();
+                return new e(n);
+              },
+              createSocketRequest(n, e) {
+                if (this.isXHRSupported())
+                  return this.HTTPFactory.createXHR(n, e);
+                if (this.isXDRSupported(e.indexOf("https:") === 0))
+                  return this.HTTPFactory.createXDR(n, e);
+                throw "Cross-origin HTTP requests are not supported";
+              },
+              isXHRSupported() {
+                var n = this.getXHRAPI();
+                return !!n && new n().withCredentials !== void 0;
+              },
+              isXDRSupported(n) {
+                var e = n ? "https:" : "http:", t = this.getProtocol();
+                return !!window.XDomainRequest && t === e;
+              },
+              addUnloadListener(n) {
+                window.addEventListener !== void 0 ? window.addEventListener("unload", n, !1) : window.attachEvent !== void 0 && window.attachEvent("onunload", n);
+              },
+              removeUnloadListener(n) {
+                window.addEventListener !== void 0 ? window.removeEventListener("unload", n, !1) : window.detachEvent !== void 0 && window.detachEvent("onunload", n);
+              },
+              randomInt(n) {
+                return Math.floor(function() {
+                  return (window.crypto || window.msCrypto).getRandomValues(new Uint32Array(1))[0] / Math.pow(2, 32);
+                }() * n);
+              }
+            };
+            const b = ii;
+            var ke;
+            (function(n) {
+              n[n.ERROR = 3] = "ERROR", n[n.INFO = 6] = "INFO", n[n.DEBUG = 7] = "DEBUG";
+            })(ke || (ke = {}));
+            const ue = ke;
+            class ri {
+              constructor(e, t, r) {
+                this.key = e, this.session = t, this.events = [], this.options = r || {}, this.sent = 0, this.uniqueID = 0;
+              }
+              log(e, t) {
+                e <= this.options.level && (this.events.push(M({}, t, { timestamp: U.now() })), this.options.limit && this.events.length > this.options.limit && this.events.shift());
+              }
+              error(e) {
+                this.log(ue.ERROR, e);
+              }
+              info(e) {
+                this.log(ue.INFO, e);
+              }
+              debug(e) {
+                this.log(ue.DEBUG, e);
+              }
+              isEmpty() {
+                return this.events.length === 0;
+              }
+              send(e, t) {
+                var r = M({
+                  session: this.session,
+                  bundle: this.sent + 1,
+                  key: this.key,
+                  lib: "js",
+                  version: this.options.version,
+                  cluster: this.options.cluster,
+                  features: this.options.features,
+                  timeline: this.events
+                }, this.options.params);
+                return this.events = [], e(r, (s, a) => {
+                  s || this.sent++, t && t(s, a);
+                }), !0;
+              }
+              generateUniqueID() {
+                return this.uniqueID++, this.uniqueID;
+              }
+            }
+            class si {
+              constructor(e, t, r, s) {
+                this.name = e, this.priority = t, this.transport = r, this.options = s || {};
+              }
+              isSupported() {
+                return this.transport.isSupported({
+                  useTLS: this.options.useTLS
+                });
+              }
+              connect(e, t) {
+                if (this.isSupported()) {
+                  if (this.priority < e)
+                    return nt(new q(), t);
+                } else return nt(new D(), t);
+                var r = !1, s = this.transport.createConnection(this.name, this.priority, this.options.key, this.options), a = null, u = function() {
+                  s.unbind("initialized", u), s.connect();
+                }, p = function() {
+                  a = X.createHandshake(s, function(I) {
+                    r = !0, x(), t(null, I);
+                  });
+                }, v = function(I) {
+                  x(), t(I);
+                }, E = function() {
+                  x();
+                  var I;
+                  I = ae(s), t(new N(I));
+                }, x = function() {
+                  s.unbind("initialized", u), s.unbind("open", p), s.unbind("error", v), s.unbind("closed", E);
+                };
+                return s.bind("initialized", u), s.bind("open", p), s.bind("error", v), s.bind("closed", E), s.initialize(), {
+                  abort: () => {
+                    r || (x(), a ? a.close() : s.close());
+                  },
+                  forceMinPriority: (I) => {
+                    r || this.priority < I && (a ? a.close() : s.close());
+                  }
+                };
+              }
+            }
+            function nt(n, e) {
+              return U.defer(function() {
+                e(n);
+              }), {
+                abort: function() {
+                },
+                forceMinPriority: function() {
+                }
+              };
+            }
+            const { Transports: oi } = b;
+            var ai = function(n, e, t, r, s, a) {
+              var u = oi[t];
+              if (!u)
+                throw new V(t);
+              var p = (!n.enabledTransports || ze(n.enabledTransports, e) !== -1) && (!n.disabledTransports || ze(n.disabledTransports, e) === -1), v;
+              return p ? (s = Object.assign({ ignoreNullOrigin: n.ignoreNullOrigin }, s), v = new si(e, r, a ? a.getAssistant(u) : u, s)) : v = ci, v;
+            }, ci = {
+              isSupported: function() {
+                return !1;
+              },
+              connect: function(n, e) {
+                var t = U.defer(function() {
+                  e(new D());
+                });
+                return {
+                  abort: function() {
+                    t.ensureAborted();
+                  },
+                  forceMinPriority: function() {
+                  }
+                };
+              }
+            };
+            function hi(n) {
+              if (n == null)
+                throw "You must pass an options object";
+              if (n.cluster == null)
+                throw "Options object must provide a cluster";
+              "disableStats" in n && R.warn("The disableStats option is deprecated in favor of enableStats");
+            }
+            const ui = (n, e) => {
+              var t = "socket_id=" + encodeURIComponent(n.socketId);
+              for (var r in e.params)
+                t += "&" + encodeURIComponent(r) + "=" + encodeURIComponent(e.params[r]);
+              if (e.paramsProvider != null) {
+                let s = e.paramsProvider();
+                for (var r in s)
+                  t += "&" + encodeURIComponent(r) + "=" + encodeURIComponent(s[r]);
+              }
+              return t;
+            }, li = (n) => {
+              if (typeof b.getAuthorizers()[n.transport] > "u")
+                throw `'${n.transport}' is not a recognized auth transport`;
+              return (e, t) => {
+                const r = ui(e, n);
+                b.getAuthorizers()[n.transport](b, r, n, l.UserAuthentication, t);
+              };
+            }, di = (n, e) => {
+              var t = "socket_id=" + encodeURIComponent(n.socketId);
+              t += "&channel_name=" + encodeURIComponent(n.channelName);
+              for (var r in e.params)
+                t += "&" + encodeURIComponent(r) + "=" + encodeURIComponent(e.params[r]);
+              if (e.paramsProvider != null) {
+                let s = e.paramsProvider();
+                for (var r in s)
+                  t += "&" + encodeURIComponent(r) + "=" + encodeURIComponent(s[r]);
+              }
+              return t;
+            }, pi = (n) => {
+              if (typeof b.getAuthorizers()[n.transport] > "u")
+                throw `'${n.transport}' is not a recognized auth transport`;
+              return (e, t) => {
+                const r = di(e, n);
+                b.getAuthorizers()[n.transport](b, r, n, l.ChannelAuthorization, t);
+              };
+            }, fi = (n, e, t) => {
+              const r = {
+                authTransport: e.transport,
+                authEndpoint: e.endpoint,
+                auth: {
+                  params: e.params,
+                  headers: e.headers
+                }
+              };
+              return (s, a) => {
+                const u = n.channel(s.channelName);
+                t(u, r).authorize(s.socketId, a);
+              };
+            };
+            function it(n, e) {
+              let t = {
+                activityTimeout: n.activityTimeout || _.activityTimeout,
+                cluster: n.cluster,
+                httpPath: n.httpPath || _.httpPath,
+                httpPort: n.httpPort || _.httpPort,
+                httpsPort: n.httpsPort || _.httpsPort,
+                pongTimeout: n.pongTimeout || _.pongTimeout,
+                statsHost: n.statsHost || _.stats_host,
+                unavailableTimeout: n.unavailableTimeout || _.unavailableTimeout,
+                wsPath: n.wsPath || _.wsPath,
+                wsPort: n.wsPort || _.wsPort,
+                wssPort: n.wssPort || _.wssPort,
+                enableStats: yi(n),
+                httpHost: gi(n),
+                useTLS: bi(n),
+                wsHost: mi(n),
+                userAuthenticator: wi(n),
+                channelAuthorizer: Si(n, e)
+              };
+              return "disabledTransports" in n && (t.disabledTransports = n.disabledTransports), "enabledTransports" in n && (t.enabledTransports = n.enabledTransports), "ignoreNullOrigin" in n && (t.ignoreNullOrigin = n.ignoreNullOrigin), "timelineParams" in n && (t.timelineParams = n.timelineParams), "nacl" in n && (t.nacl = n.nacl), t;
+            }
+            function gi(n) {
+              return n.httpHost ? n.httpHost : n.cluster ? `sockjs-${n.cluster}.pusher.com` : _.httpHost;
+            }
+            function mi(n) {
+              return n.wsHost ? n.wsHost : vi(n.cluster);
+            }
+            function vi(n) {
+              return `ws-${n}.pusher.com`;
+            }
+            function bi(n) {
+              return b.getProtocol() === "https:" ? !0 : n.forceTLS !== !1;
+            }
+            function yi(n) {
+              return "enableStats" in n ? n.enableStats : "disableStats" in n ? !n.disableStats : !1;
+            }
+            const rt = (n) => "customHandler" in n && n.customHandler != null;
+            function wi(n) {
+              const e = Object.assign(Object.assign({}, _.userAuthentication), n.userAuthentication);
+              return rt(e) ? e.customHandler : li(e);
+            }
+            function Ci(n, e) {
+              let t;
+              if ("channelAuthorization" in n)
+                t = Object.assign(Object.assign({}, _.channelAuthorization), n.channelAuthorization);
+              else if (t = {
+                transport: n.authTransport || _.authTransport,
+                endpoint: n.authEndpoint || _.authEndpoint
+              }, "auth" in n && ("params" in n.auth && (t.params = n.auth.params), "headers" in n.auth && (t.headers = n.auth.headers)), "authorizer" in n)
+                return {
+                  customHandler: fi(e, t, n.authorizer)
+                };
+              return t;
+            }
+            function Si(n, e) {
+              const t = Ci(n, e);
+              return rt(t) ? t.customHandler : pi(t);
+            }
+            class _i extends $ {
+              constructor(e) {
+                super(function(t, r) {
+                  R.debug(`No callbacks on watchlist events for ${t}`);
+                }), this.pusher = e, this.bindWatchlistInternalEvent();
+              }
+              handleEvent(e) {
+                e.data.events.forEach((t) => {
+                  this.emit(t.name, t);
+                });
+              }
+              bindWatchlistInternalEvent() {
+                this.pusher.connection.bind("message", (e) => {
+                  var t = e.event;
+                  t === "pusher_internal:watchlist_events" && this.handleEvent(e);
+                });
+              }
+            }
+            function Ti() {
+              let n, e;
+              return { promise: new Promise((r, s) => {
+                n = r, e = s;
+              }), resolve: n, reject: e };
+            }
+            const ki = Ti;
+            class Ei extends $ {
+              constructor(e) {
+                super(function(t, r) {
+                  R.debug("No callbacks on user for " + t);
+                }), this.signin_requested = !1, this.user_data = null, this.serverToUserChannel = null, this.signinDonePromise = null, this._signinDoneResolve = null, this._onAuthorize = (t, r) => {
+                  if (t) {
+                    R.warn(`Error during signin: ${t}`), this._cleanup();
+                    return;
+                  }
+                  this.pusher.send_event("pusher:signin", {
+                    auth: r.auth,
+                    user_data: r.user_data
+                  });
+                }, this.pusher = e, this.pusher.connection.bind("state_change", ({ previous: t, current: r }) => {
+                  t !== "connected" && r === "connected" && this._signin(), t === "connected" && r !== "connected" && (this._cleanup(), this._newSigninPromiseIfNeeded());
+                }), this.watchlist = new _i(e), this.pusher.connection.bind("message", (t) => {
+                  var r = t.event;
+                  r === "pusher:signin_success" && this._onSigninSuccess(t.data), this.serverToUserChannel && this.serverToUserChannel.name === t.channel && this.serverToUserChannel.handleEvent(t);
+                });
+              }
+              signin() {
+                this.signin_requested || (this.signin_requested = !0, this._signin());
+              }
+              _signin() {
+                this.signin_requested && (this._newSigninPromiseIfNeeded(), this.pusher.connection.state === "connected" && this.pusher.config.userAuthenticator({
+                  socketId: this.pusher.connection.socket_id
+                }, this._onAuthorize));
+              }
+              _onSigninSuccess(e) {
+                try {
+                  this.user_data = JSON.parse(e.user_data);
+                } catch {
+                  R.error(`Failed parsing user data after signin: ${e.user_data}`), this._cleanup();
+                  return;
+                }
+                if (typeof this.user_data.id != "string" || this.user_data.id === "") {
+                  R.error(`user_data doesn't contain an id. user_data: ${this.user_data}`), this._cleanup();
+                  return;
+                }
+                this._signinDoneResolve(), this._subscribeChannels();
+              }
+              _subscribeChannels() {
+                const e = (t) => {
+                  t.subscriptionPending && t.subscriptionCancelled ? t.reinstateSubscription() : !t.subscriptionPending && this.pusher.connection.state === "connected" && t.subscribe();
+                };
+                this.serverToUserChannel = new ye(`#server-to-user-${this.user_data.id}`, this.pusher), this.serverToUserChannel.bind_global((t, r) => {
+                  t.indexOf("pusher_internal:") === 0 || t.indexOf("pusher:") === 0 || this.emit(t, r);
+                }), e(this.serverToUserChannel);
+              }
+              _cleanup() {
+                this.user_data = null, this.serverToUserChannel && (this.serverToUserChannel.unbind_all(), this.serverToUserChannel.disconnect(), this.serverToUserChannel = null), this.signin_requested && this._signinDoneResolve();
+              }
+              _newSigninPromiseIfNeeded() {
+                if (!this.signin_requested || this.signinDonePromise && !this.signinDonePromise.done)
+                  return;
+                const { promise: e, resolve: t } = ki();
+                e.done = !1;
+                const r = () => {
+                  e.done = !0;
+                };
+                e.then(r).catch(r), this.signinDonePromise = e, this._signinDoneResolve = t;
+              }
+            }
+            class O {
+              static ready() {
+                O.isReady = !0;
+                for (var e = 0, t = O.instances.length; e < t; e++)
+                  O.instances[e].connect();
+              }
+              static getClientFeatures() {
+                return He(Fe({ ws: b.Transports.ws }, function(e) {
+                  return e.isSupported({});
+                }));
+              }
+              constructor(e, t) {
+                xi(e), hi(t), this.key = e, this.options = t, this.config = it(this.options, this), this.channels = X.createChannels(), this.global_emitter = new $(), this.sessionID = b.randomInt(1e9), this.timeline = new ri(this.key, this.sessionID, {
+                  cluster: this.config.cluster,
+                  features: O.getClientFeatures(),
+                  params: this.config.timelineParams || {},
+                  limit: 50,
+                  level: ue.INFO,
+                  version: _.VERSION
+                }), this.config.enableStats && (this.timelineSender = X.createTimelineSender(this.timeline, {
+                  host: this.config.statsHost,
+                  path: "/timeline/v2/" + b.TimelineTransport.name
+                }));
+                var r = (s) => b.getDefaultStrategy(this.config, s, ai);
+                this.connection = X.createConnectionManager(this.key, {
+                  getStrategy: r,
+                  timeline: this.timeline,
+                  activityTimeout: this.config.activityTimeout,
+                  pongTimeout: this.config.pongTimeout,
+                  unavailableTimeout: this.config.unavailableTimeout,
+                  useTLS: !!this.config.useTLS
+                }), this.connection.bind("connected", () => {
+                  this.subscribeAll(), this.timelineSender && this.timelineSender.send(this.connection.isUsingTLS());
+                }), this.connection.bind("message", (s) => {
+                  var a = s.event, u = a.indexOf("pusher_internal:") === 0;
+                  if (s.channel) {
+                    var p = this.channel(s.channel);
+                    p && p.handleEvent(s);
+                  }
+                  u || this.global_emitter.emit(s.event, s.data);
+                }), this.connection.bind("connecting", () => {
+                  this.channels.disconnect();
+                }), this.connection.bind("disconnected", () => {
+                  this.channels.disconnect();
+                }), this.connection.bind("error", (s) => {
+                  R.warn(s);
+                }), O.instances.push(this), this.timeline.info({ instances: O.instances.length }), this.user = new Ei(this), O.isReady && this.connect();
+              }
+              switchCluster(e) {
+                const { appKey: t, cluster: r } = e;
+                this.key = t, this.options = Object.assign(Object.assign({}, this.options), { cluster: r }), this.config = it(this.options, this), this.connection.switchCluster(this.key);
+              }
+              channel(e) {
+                return this.channels.find(e);
+              }
+              allChannels() {
+                return this.channels.all();
+              }
+              connect() {
+                if (this.connection.connect(), this.timelineSender && !this.timelineSenderTimer) {
+                  var e = this.connection.isUsingTLS(), t = this.timelineSender;
+                  this.timelineSenderTimer = new jt(6e4, function() {
+                    t.send(e);
+                  });
+                }
+              }
+              disconnect() {
+                this.connection.disconnect(), this.timelineSenderTimer && (this.timelineSenderTimer.ensureAborted(), this.timelineSenderTimer = null);
+              }
+              bind(e, t, r) {
+                return this.global_emitter.bind(e, t, r), this;
+              }
+              unbind(e, t, r) {
+                return this.global_emitter.unbind(e, t, r), this;
+              }
+              bind_global(e) {
+                return this.global_emitter.bind_global(e), this;
+              }
+              unbind_global(e) {
+                return this.global_emitter.unbind_global(e), this;
+              }
+              unbind_all(e) {
+                return this.global_emitter.unbind_all(), this;
+              }
+              subscribeAll() {
+                var e;
+                for (e in this.channels.channels)
+                  this.channels.channels.hasOwnProperty(e) && this.subscribe(e);
+              }
+              subscribe(e) {
+                var t = this.channels.add(e, this);
+                return t.subscriptionPending && t.subscriptionCancelled ? t.reinstateSubscription() : !t.subscriptionPending && this.connection.state === "connected" && t.subscribe(), t;
+              }
+              unsubscribe(e) {
+                var t = this.channels.find(e);
+                t && t.subscriptionPending ? t.cancelSubscription() : (t = this.channels.remove(e), t && t.subscribed && t.unsubscribe());
+              }
+              send_event(e, t, r) {
+                return this.connection.send_event(e, t, r);
+              }
+              shouldUseTLS() {
+                return this.config.useTLS;
+              }
+              signin() {
+                this.user.signin();
+              }
+            }
+            O.instances = [], O.isReady = !1, O.logToConsole = !1, O.Runtime = b, O.ScriptReceivers = b.ScriptReceivers, O.DependenciesReceivers = b.DependenciesReceivers, O.auth_callbacks = b.auth_callbacks;
+            const le = O;
+            function xi(n) {
+              if (n == null)
+                throw "You must pass your app key when you instantiate Pusher.";
+            }
+            b.setup(O);
+          }
+          /******/
+        }, c = {};
+        function h(y) {
+          var f = c[y];
+          if (f !== void 0)
+            return f.exports;
+          var m = c[y] = {
+            /******/
+            // no module.id needed
+            /******/
+            // no module.loaded needed
+            /******/
+            exports: {}
+            /******/
+          };
+          return o[y].call(m.exports, m, m.exports, h), m.exports;
+        }
+        h.d = (y, f) => {
+          for (var m in f)
+            h.o(f, m) && !h.o(y, m) && Object.defineProperty(y, m, { enumerable: !0, get: f[m] });
+        }, h.o = (y, f) => Object.prototype.hasOwnProperty.call(y, f);
+        var C = h(721);
+        return C;
+      })()
+    ));
+  })(Ae)), Ae.exports;
+}
+var Ji = Vi();
+const Gi = /* @__PURE__ */ Xi(Ji), Pe = "/vendor/sendity-client/tailwind.css", Ki = {
+  labels: {
+    email: "Email",
+    whatsapp: "WhatsApp"
+  },
+  ui: {
+    sendCodePrompt: "Send this code to sign in:",
+    successGreeting: "(Name), you're in!",
+    by: "by",
+    footerWaiting: "Waiting for your code…",
+    footerWaitingUntil: "Waiting for your code until (Time)…"
+  },
+  templates: {
+    emailSubject: "Sign me into (Host) with this code: (Code)",
+    emailBody: `To authenticate with (Host), send this email without making any changes.
+
+Code: (Code)`,
+    whatsappText: "Sign me into (Host) with this code: (Code)"
+  }
+}, Qi = {
+  labels: {
+    email: "E-Mail",
+    whatsapp: "WhatsApp"
+  },
+  ui: {
+    sendCodePrompt: "Sende diesen Code, um dich anzumelden:",
+    successGreeting: "(Name), du bist drin!",
+    by: "per",
+    footerWaiting: "Wir warten auf deinen Code …",
+    footerWaitingUntil: "Wir warten bis (Time) auf deinen Code …"
+  },
+  templates: {
+    emailSubject: "Melde mich bei (Host) mit diesem Code an: (Code)",
+    emailBody: `Um dich bei (Host) zu authentifizieren, sende diese E-Mail unverändert ab.
+
+Code: (Code)`,
+    whatsappText: "Melde mich bei (Host) mit diesem Code an: (Code)"
+  }
+}, Yi = {
+  labels: {
+    email: "E-mail",
+    whatsapp: "WhatsApp"
+  },
+  ui: {
+    sendCodePrompt: "Envoyez ce code pour vous connecter :",
+    successGreeting: "(Name), vous êtes connecté !",
+    by: "par",
+    footerWaiting: "En attente de votre code…",
+    footerWaitingUntil: "En attente de votre code jusqu’à (Time)…"
+  },
+  templates: {
+    emailSubject: "Connectez-moi à (Host) avec ce code : (Code)",
+    emailBody: `Pour vous authentifier auprès de (Host), envoyez simplement cet e-mail sans aucune modification.
+
+Code : (Code)`,
+    whatsappText: "Connectez-moi à (Host) avec ce code : (Code)"
+  }
+};
+function se(g) {
+  switch (g) {
+    case "de":
+      return Qi;
+    case "fr":
+      return Yi;
+    default:
+      return Ki;
+  }
+}
+const mt = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" class="size-6">
+    <path d="M1.5 8.67v8.58a3 3 0 0 0 3 3h15a3 3 0 0 0 3-3V8.67l-8.928 5.493a3 3 0 0 1-3.144 0L1.5 8.67Z" />
+    <path d="M22.5 6.908V6.75a3 3 0 0 0-3-3h-15a3 3 0 0 0-3 3v.158l9.714 5.978a1.5 1.5 0 0 0 1.572 0L22.5 6.908Z" />
+</svg>
+`, vt = '<svg role="img" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg"><title>WhatsApp</title><path d="M17.472 14.382c-.297-.149-1.758-.867-2.03-.967-.273-.099-.471-.148-.67.15-.197.297-.767.966-.94 1.164-.173.199-.347.223-.644.075-.297-.15-1.255-.463-2.39-1.475-.883-.788-1.48-1.761-1.653-2.059-.173-.297-.018-.458.13-.606.134-.133.298-.347.446-.52.149-.174.198-.298.298-.497.099-.198.05-.371-.025-.52-.075-.149-.669-1.612-.916-2.207-.242-.579-.487-.5-.669-.51-.173-.008-.371-.01-.57-.01-.198 0-.52.074-.792.372-.272.297-1.04 1.016-1.04 2.479 0 1.462 1.065 2.875 1.213 3.074.149.198 2.096 3.2 5.077 4.487.709.306 1.262.489 1.694.625.712.227 1.36.195 1.871.118.571-.085 1.758-.719 2.006-1.413.248-.694.248-1.289.173-1.413-.074-.124-.272-.198-.57-.347m-5.421 7.403h-.004a9.87 9.87 0 01-5.031-1.378l-.361-.214-3.741.982.998-3.648-.235-.374a9.86 9.86 0 01-1.51-5.26c.001-5.45 4.436-9.884 9.888-9.884 2.64 0 5.122 1.03 6.988 2.898a9.825 9.825 0 012.893 6.994c-.003 5.45-4.437 9.884-9.885 9.884m8.413-18.297A11.815 11.815 0 0012.05 0C5.495 0 .16 5.335.157 11.892c0 2.096.547 4.142 1.588 5.945L.057 24l6.305-1.654a11.882 11.882 0 005.683 1.448h.005c6.554 0 11.89-5.335 11.893-11.893a11.821 11.821 0 00-3.48-8.413Z"/></svg>', je = "sendityAuthRequest", Zi = "https://sendity.io/api", er = ["mailto:verify@sendity.io"], tr = 600 * 1e3, nr = 5e3, ir = 15e3, Re = 2e3, rr = 0;
+function Ne(g, i) {
+  return `sendity:auth-request:${encodeURIComponent(g)}:${encodeURIComponent(i)}`;
+}
+function bt(g, i, o, c = Date.now()) {
+  g.removeItem(je);
+  const h = Ne(i, o), C = g.getItem(h);
+  if (!C) return null;
+  try {
+    const y = JSON.parse(C);
+    if (typeof y.id != "string" || typeof y.clientSecret != "string" || typeof y.createdAt != "number")
+      throw new Error("invalid stored auth request");
+    return c - y.createdAt >= tr ? (g.removeItem(h), null) : { id: y.id, clientSecret: y.clientSecret };
+  } catch {
+    return g.removeItem(h), null;
+  }
+}
+function sr(g, i, o, c, h = Date.now()) {
+  g.setItem(Ne(i, o), JSON.stringify({ ...c, createdAt: h }));
+}
+function yt(g, i, o) {
+  g.removeItem(Ne(i, o)), g.removeItem(je);
+}
+function Le() {
+  return window.localStorage.removeItem(je), window.sessionStorage;
+}
+function or(g, i = window.location.origin) {
+  return g.filter((o) => ar(o, i));
+}
+function ar(g, i) {
+  try {
+    const o = new URL(g, i);
+    return ["http:", "https:", "mailto:", "whatsapp:"].includes(o.protocol);
+  } catch {
+    return !1;
+  }
+}
+function cr(g, i, o) {
+  return g === "polling" ? { start: !0, delayMs: 0 } : g === "push" ? { start: !1, delayMs: 0 } : !i || !o ? { start: !0, delayMs: 0 } : { start: !1, delayMs: 0 };
+}
+const ge = class ge extends HTMLElement {
+  constructor() {
+    super(), this.pollTimer = null, this.fallbackPollTimer = null, this.authenticatedEventTimer = null, this.codeContainerEl = null, this.codeEl = null, this.promptEl = null, this.successEl = null, this.spinnerEl = null, this.verifiersEl = null, this.footerEl = null, this.footerBrandEl = null, this.footerStatusEl = null, this.footerMessageEl = null, this.footerObserver = null, this.footerWaitTimer = null, this.currentConfig = null, this.destroyed = !1, this.lastCode = void 0, this.echo = null, this.authenticated = !1;
+    const i = this.attachShadow({ mode: "open" });
+    this.injectTailwind(i);
+    const o = document.createElement("div");
+    o.innerHTML = pt;
+    const c = o.querySelector("template"), h = c ? c.content.cloneNode(!0) : document.createRange().createContextualFragment(pt), C = document.createElement("style");
+    C.textContent = Ni, i.appendChild(C), i.appendChild(h);
+  }
+  static get observedAttributes() {
+    return ["server-url", "public-key", "verify-urls", "lang", "transport", "hide-footer", "footer", "authenticated-event-delay-ms"];
+  }
+  connectedCallback() {
+    this.codeContainerEl = this.shadowRoot?.querySelector(".code"), this.codeEl = this.shadowRoot?.querySelector(".formatted-code"), this.promptEl = this.shadowRoot?.querySelector(".prompt"), this.successEl = this.shadowRoot?.querySelector(".success"), this.spinnerEl = this.shadowRoot?.querySelector(".spinner"), this.verifiersEl = this.shadowRoot?.querySelector(".verifiers"), this.footerEl = this.shadowRoot?.querySelector(".sendity-footer"), this.footerBrandEl = this.shadowRoot?.querySelector(".footer-brand"), this.footerStatusEl = this.shadowRoot?.querySelector(".footer-status"), this.footerMessageEl = this.shadowRoot?.querySelector(".footer-message");
+    try {
+      this.currentConfig = this.resolveConfig();
+    } catch (i) {
+      this.handleInitialError(i);
+      return;
+    }
+    this.configureFooter(), this.dispatchPublicEvent("sendity:ready", {
+      transport: this.currentConfig.transport,
+      channel: this.primaryChannel(this.currentConfig.verifyUrls)
+    }), this.showLoading(), this.renderVerifiers(this.currentConfig.verifyUrls), this.start();
+  }
+  disconnectedCallback() {
+    this.stop(), this.destroyed = !0;
+  }
+  attributeChangedCallback() {
+    this.isConnected && (this.currentConfig = this.resolveConfig(), this.configureFooter(), this.renderVerifiers(this.currentConfig.verifyUrls));
+  }
+  start() {
+    this.step().then((i) => {
+      this.authenticated || this.destroyed || this.configureRealtime(i);
+    }).catch((i) => {
+      this.handleInitialError(i);
+    });
+  }
+  stop() {
+    this.pollTimer !== null && (clearInterval(this.pollTimer), this.pollTimer = null), this.fallbackPollTimer !== null && (clearTimeout(this.fallbackPollTimer), this.fallbackPollTimer = null), this.footerWaitTimer !== null && (clearTimeout(this.footerWaitTimer), this.footerWaitTimer = null), this.authenticatedEventTimer !== null && (clearTimeout(this.authenticatedEventTimer), this.authenticatedEventTimer = null), this.footerObserver?.disconnect(), this.footerObserver = null, this.echo && this.activeAuthRequestId && this.echo.leave(`sendity.auth-requests.${this.activeAuthRequestId}`), this.echo?.disconnect(), this.echo = null;
+  }
+  // Inject Tailwind CSS into the Shadow DOM so Tailwind utility classes
+  // used in sendity.html work within the component. We cache the processed
+  // CSS text across instances to avoid redundant network requests and ensure
+  // the Tailwind layer is inserted before component CSS.
+  injectTailwind(i) {
+    const o = document.createElement("style");
+    o.setAttribute("data-sendity-tw", ""), i.appendChild(o);
+    const c = this.constructor;
+    if (c.tailwindCssText !== null) {
+      if (c.tailwindCssText)
+        o.textContent = c.tailwindCssText;
+      else {
+        const h = document.createElement("link");
+        h.rel = "stylesheet", h.href = Pe, i.insertBefore(h, o);
+      }
+      return;
+    }
+    c.tailwindLoading || (c.tailwindLoading = fetch(Pe).then((h) => h.ok ? h.text() : Promise.reject(new Error(`HTTP ${h.status}`))).then((h) => {
+      c.tailwindCssText = h;
+    }).catch((h) => {
+      console.warn("[sendity-auth] Failed to load Tailwind CSS for Shadow DOM", h), c.tailwindCssText = "";
+    })), c.tailwindLoading.then(() => {
+      if (!this.destroyed && i)
+        if (c.tailwindCssText)
+          o.textContent = c.tailwindCssText;
+        else {
+          const h = document.createElement("link");
+          h.rel = "stylesheet", h.href = Pe, i.insertBefore(h, o);
+        }
+    });
+  }
+  configureFooter() {
+    if (this.footerEl) {
+      if (this.isFooterHidden()) {
+        this.footerEl.hidden = !0, this.footerWaitTimer !== null && (clearTimeout(this.footerWaitTimer), this.footerWaitTimer = null), this.footerObserver?.disconnect(), this.footerObserver = null;
+        return;
+      }
+      this.footerEl.hidden = !1, this.footerBrandEl?.removeAttribute("hidden"), this.footerStatusEl?.setAttribute("hidden", ""), this.observeFooterVisibility();
+    }
+  }
+  isFooterHidden() {
+    const i = (this.getAttribute("footer") ?? "").trim().toLowerCase();
+    return this.hasAttribute("hide-footer") || ["false", "hidden", "none", "off", "0"].includes(i);
+  }
+  observeFooterVisibility() {
+    !this.footerEl || this.footerObserver || !("IntersectionObserver" in window) || (this.footerObserver = new IntersectionObserver((i) => {
+      i.some((c) => c.isIntersecting) ? this.scheduleFooterWaitingState() : this.footerWaitTimer !== null && (clearTimeout(this.footerWaitTimer), this.footerWaitTimer = null);
+    }), this.footerObserver.observe(this));
+  }
+  scheduleFooterWaitingState() {
+    this.footerWaitTimer !== null || this.isFooterHidden() || (this.footerWaitTimer = window.setTimeout(() => {
+      this.footerWaitTimer = null, this.showFooterWaitingState();
+    }, ir));
+  }
+  showFooterWaitingState() {
+    this.isFooterHidden() || (this.footerBrandEl?.setAttribute("hidden", ""), this.currentConfig && this.footerMessageEl && (this.footerMessageEl.textContent = this.waitingFooterMessage()), this.footerStatusEl?.removeAttribute("hidden"));
+  }
+  handleInitialError(i) {
+    console.error("[sendity-auth] Unable to initialize authentication", i), this.renderError("Unable to initialize authentication, see console for details"), this.dispatchEvent(
+      new CustomEvent("sendity:error", {
+        bubbles: !0,
+        composed: !0,
+        detail: i instanceof Error ? { message: i.message, name: i.name } : { message: String(i) }
+      })
+    );
+  }
+  resolveConfig() {
+    const i = {
+      lang: navigator.language?.startsWith("de") ? "de" : navigator.language?.startsWith("fr") ? "fr" : "en",
+      transport: "auto"
+    }, o = (L) => this.getAttribute(L) ?? void 0, c = o("server-url")?.trim() || Zi, h = o("public-key")?.trim();
+    if (!h)
+      throw new Error("Missing required sendity-auth attribute: public-key");
+    let C = [...er];
+    const y = o("verify-urls");
+    if (y)
+      try {
+        if (C = JSON.parse(y), !Array.isArray(C)) throw new Error("verify-urls not array");
+        C = C.map(String);
+      } catch {
+        C = y.split(",").map((L) => L.trim()).filter(Boolean);
+      }
+    if (C = or(C), C.length === 0)
+      throw new Error("Missing required sendity-auth attribute: verify-urls");
+    let f = o("lang") || i.lang;
+    f !== "en" && f !== "de" && f !== "fr" && (f = i.lang);
+    const m = o("transport"), k = m === "push" || m === "polling" ? m : i.transport, S = this.parseAuthenticatedEventDelayMs(o("authenticated-event-delay-ms"));
+    return { serverUrl: c, publicKey: h, verifyUrls: C, lang: f, transport: k, authenticatedEventDelayMs: S };
+  }
+  parseAuthenticatedEventDelayMs(i) {
+    if (i === void 0 || i.trim() === "") return Re;
+    const o = Number(i);
+    return !Number.isFinite(o) || o < 0 ? Re : Math.round(o);
+  }
+  async step() {
+    this.currentConfig || (this.currentConfig = this.resolveConfig());
+    const { serverUrl: i, publicKey: o } = this.currentConfig, c = Le(), h = bt(c, i, o), C = h?.id;
+    if (!C) {
+      const k = await fetch(this.joinUrl(i, "/auth-requests"), {
+        method: "POST",
+        mode: "cors",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify({ public_key: o })
+      });
+      if (!k.ok) throw new Error(`Auth request creation failed: ${k.status}`);
+      const S = await k.json();
+      if (!S.id) throw new Error("Missing id from server response");
+      const L = this.extractClientSecret(S);
+      if (!L) throw new Error("Missing client secret from server response");
+      return sr(c, i, o, { id: String(S.id), clientSecret: L }), this.activeAuthRequestId = String(S.id), this.activeAuthRequestSecret = L, this.updateActiveAuthRequestExpiry(S), this.updateCode(S.formattedCode ?? S.code), this.dispatchPublicEvent("sendity:challenge-created", {
+        verificationId: String(S.id),
+        code: S.formattedCode ?? S.code ?? "",
+        channel: this.primaryChannel(this.currentConfig.verifyUrls)
+      }), S;
+    }
+    this.activeAuthRequestId = C, this.activeAuthRequestSecret = h.clientSecret;
+    const y = await fetch(
+      this.authRequestStatusUrl(i, C),
+      this.authRequestStatusInit(h.clientSecret)
+    );
+    if (y.status !== 200)
+      return yt(c, i, o), await this.step();
+    const f = await y.json();
+    if (f.status === "verified")
+      return this.handleAuthenticated(f), f;
+    f.id && (this.activeAuthRequestId = String(f.id));
+    const m = this.extractClientSecret(f);
+    return m && (this.activeAuthRequestSecret = m), this.updateActiveAuthRequestExpiry(f), this.updateCode(f.formattedCode ?? f.code), f;
+  }
+  configureRealtime(i) {
+    this.currentConfig || (this.currentConfig = this.resolveConfig());
+    const { transport: o } = this.currentConfig, c = i?.broadcasting, h = !!(c?.key && c.channel && c.authEndpoint);
+    let C = !1;
+    o !== "polling" && h && c ? C = this.subscribeToBroadcasting(c) : o === "push" && console.warn("[sendity-auth] Push transport requested, but server response does not contain broadcasting metadata");
+    const y = cr(o, h, C);
+    y.start && this.startPolling(y.delayMs);
+  }
+  subscribeToBroadcasting(i) {
+    if (!this.currentConfig || !i.key || !i.channel || !i.authEndpoint) return !1;
+    try {
+      window.Pusher = Gi;
+      const o = (i.scheme ?? "https") === "https", c = i.port ?? (o ? 443 : 80);
+      return this.echo = new $i({
+        broadcaster: "reverb",
+        key: i.key,
+        wsHost: i.host ?? new URL(this.currentConfig.serverUrl).hostname,
+        wsPort: c,
+        wssPort: c,
+        wsPath: i.wsPath ?? "/ws",
+        forceTLS: o,
+        encrypted: o,
+        enabledTransports: ["ws", "wss"],
+        authEndpoint: this.joinUrl(this.currentConfig.serverUrl, i.authEndpoint),
+        auth: {
+          headers: {
+            Accept: "application/json"
+          }
+        }
+      }), this.echo.private(i.channel).listen(i.event ?? ".authenticated", (h) => {
+        this.handleAuthenticated(h);
+      }), !0;
+    } catch (o) {
+      return console.warn("[sendity-auth] realtime subscription failed, falling back to polling if enabled", o), this.currentConfig.transport === "auto" && this.startPolling(rr), !1;
+    }
+  }
+  startPolling(i) {
+    if (this.pollTimer !== null || this.authenticated) return;
+    const o = () => {
+      this.pollTimer !== null || this.authenticated || this.destroyed || (this.pollTimer = window.setInterval(() => {
+        this.step().catch((c) => console.warn("[sendity-auth] poll failed", c));
+      }, nr));
+    };
+    i > 0 ? this.fallbackPollTimer = window.setTimeout(() => {
+      this.fallbackPollTimer = null, o();
+    }, i) : o();
+  }
+  handleAuthenticated(i) {
+    if (this.authenticated) return;
+    if (!i.authorization) {
+      console.warn("[sendity-auth] authenticated signal did not include authorization; fetching canonical status"), this.fetchAuthorizationAfterAuthenticatedSignal().catch((h) => {
+        console.warn("[sendity-auth] failed to fetch authorization after authenticated signal", h);
+      });
+      return;
+    }
+    this.authenticated = !0, this.currentConfig && yt(Le(), this.currentConfig.serverUrl, this.currentConfig.publicKey), this.stopAuthTransports(), this.showSuccess(i.name);
+    const o = this.toPublicAuthenticatedDetail(i), c = this.currentConfig?.authenticatedEventDelayMs ?? Re;
+    this.authenticatedEventTimer = window.setTimeout(() => {
+      this.authenticatedEventTimer = null, !this.destroyed && this.dispatchPublicEvent("sendity:authenticated", o);
+    }, c);
+  }
+  stopAuthTransports() {
+    this.pollTimer !== null && (clearInterval(this.pollTimer), this.pollTimer = null), this.fallbackPollTimer !== null && (clearTimeout(this.fallbackPollTimer), this.fallbackPollTimer = null), this.echo && this.activeAuthRequestId && this.echo.leave(`sendity.auth-requests.${this.activeAuthRequestId}`), this.echo?.disconnect(), this.echo = null;
+  }
+  dispatchPublicEvent(i, o) {
+    this.dispatchEvent(new CustomEvent(i, { bubbles: !0, composed: !0, detail: o }));
+  }
+  toPublicAuthenticatedDetail(i) {
+    const o = String(i.auth_request_id ?? i.authRequestId ?? this.activeAuthRequestId ?? ""), c = i.channel ?? this.primaryChannel(this.currentConfig?.verifyUrls ?? []), h = i.expires_at ?? i.expiresAt;
+    return {
+      sessionId: o,
+      channel: c,
+      ...i.identifier ? { address: i.identifier } : {},
+      verificationId: o,
+      signedResult: String(i.authorization ?? ""),
+      ...h ? { expiresAt: String(h) } : {}
+    };
+  }
+  primaryChannel(i) {
+    const o = i[0] ?? "";
+    return o.startsWith("mailto:") ? "email" : o.startsWith("whatsapp:") || o.startsWith("whatsapp://") ? "whatsapp" : "unknown";
+  }
+  authRequestStatusUrl(i, o) {
+    return new URL(this.joinUrl(i, `/auth-requests/${encodeURIComponent(o)}`)).toString();
+  }
+  authRequestStatusInit(i) {
+    return {
+      method: "GET",
+      mode: "cors",
+      headers: {
+        Accept: "application/json",
+        "X-Sendity-Client-Secret": i
+      }
+    };
+  }
+  extractClientSecret(i) {
+    return String(i.client_secret ?? i.clientSecret ?? "");
+  }
+  updateActiveAuthRequestExpiry(i) {
+    const o = i.expires_at ?? i.expiresAt;
+    o && (this.activeAuthRequestExpiresAt = String(o), this.updateCodeValidityDuration());
+  }
+  waitingFooterMessage() {
+    if (!this.currentConfig) return "";
+    const i = se(this.currentConfig.lang), o = this.formatExpiryTime(this.activeAuthRequestExpiresAt, this.currentConfig.lang);
+    return o ? i.ui.footerWaitingUntil.replace("(Time)", o) : i.ui.footerWaiting;
+  }
+  formatExpiryTime(i, o) {
+    if (!i) return null;
+    const c = new Date(i);
+    return Number.isNaN(c.getTime()) ? null : new Intl.DateTimeFormat(this.localeForLang(o), { timeStyle: "short" }).format(c);
+  }
+  localeForLang(i) {
+    switch (i) {
+      case "de":
+        return "de-DE";
+      case "fr":
+        return "fr-FR";
+      default:
+        return "en-US";
+    }
+  }
+  updateCodeValidityDuration() {
+    if (!this.codeContainerEl || !this.activeAuthRequestExpiresAt) return;
+    const i = new Date(this.activeAuthRequestExpiresAt).getTime();
+    if (Number.isNaN(i)) return;
+    const o = Math.max(1, Math.round((i - Date.now()) / 1e3));
+    this.codeContainerEl.style.setProperty("--sendity-code-validity-duration", `${o}s`);
+  }
+  async fetchAuthorizationAfterAuthenticatedSignal() {
+    this.currentConfig || (this.currentConfig = this.resolveConfig());
+    const i = bt(Le(), this.currentConfig.serverUrl, this.currentConfig.publicKey), o = this.activeAuthRequestId ?? i?.id, c = this.activeAuthRequestSecret ?? i?.clientSecret;
+    if (!o || !c)
+      throw new Error("Cannot fetch authorization without an active auth request id and client secret");
+    const h = await fetch(
+      this.authRequestStatusUrl(this.currentConfig.serverUrl, o),
+      this.authRequestStatusInit(c)
+    );
+    if (!h.ok)
+      throw new Error(`Authorization fetch failed: ${h.status}`);
+    const C = await h.json();
+    if (C.status === "verified" && C.authorization) {
+      this.handleAuthenticated(C);
+      return;
+    }
+    throw new Error("Verified auth request did not include authorization");
+  }
+  updateCode(i) {
+    if (!this.codeEl) return;
+    if (!!(i && String(i).trim().length > 0)) {
+      const c = String(i);
+      this.lastCode = c, this.codeEl.textContent = c, this.showCodeState();
+    } else {
+      this.lastCode = void 0;
+      const c = this.codeEl.getAttribute("data-placeholder") || "••••";
+      this.codeEl.textContent = c, this.showLoading();
+    }
+    this.currentConfig && this.renderVerifiers(this.currentConfig.verifyUrls);
+  }
+  renderError(i) {
+    this.codeEl && (this.codeEl.textContent = i), this.verifiersEl && (this.verifiersEl.innerHTML = "");
+  }
+  showLoading() {
+    this.spinnerEl?.removeAttribute("hidden"), this.codeContainerEl?.classList.remove("code--active", "code--verified"), this.codeEl?.setAttribute("hidden", ""), this.promptEl?.setAttribute("hidden", ""), this.successEl?.setAttribute("hidden", "");
+  }
+  showCodeState() {
+    if (this.spinnerEl?.setAttribute("hidden", ""), this.codeContainerEl?.classList.remove("code--verified"), this.codeContainerEl?.classList.add("code--active"), this.codeEl?.removeAttribute("hidden"), this.currentConfig && this.promptEl) {
+      const i = se(this.currentConfig.lang);
+      this.promptEl.textContent = i.ui.sendCodePrompt, this.promptEl.removeAttribute("hidden");
+    }
+    this.successEl?.setAttribute("hidden", "");
+  }
+  showSuccess(i) {
+    if (this.spinnerEl?.setAttribute("hidden", ""), this.codeContainerEl?.classList.remove("code--active"), this.codeContainerEl?.classList.add("code--verified"), this.promptEl?.setAttribute("hidden", ""), this.footerWaitTimer !== null && (clearTimeout(this.footerWaitTimer), this.footerWaitTimer = null), this.footerEl && (this.footerEl.hidden = !0), this.verifiersEl && (this.verifiersEl.innerHTML = ""), this.currentConfig && this.successEl) {
+      const o = se(this.currentConfig.lang), c = i && i.trim().length > 0 ? o.ui.successGreeting.replace("(Name)", i) : "You're in!";
+      this.successEl.innerHTML = `
+        <span class="success-check" aria-hidden="true">
+          <svg viewBox="0 0 24 24"><path d="M5 12.5 10 17l9-10" /></svg>
+        </span>
+        <span class="success-message">${this.escapeHtml(c)}</span>
+      `, this.successEl.removeAttribute("hidden");
+    }
+  }
+  escapeHtml(i) {
+    return i.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#039;");
+  }
+  renderVerifiers(i) {
+    if (!this.verifiersEl) return;
+    this.verifiersEl.innerHTML = "";
+    const o = this.currentConfig;
+    i.forEach((c) => {
+      const h = document.createElement("a"), C = this.buildLink(c, o.lang);
+      h.href = C, h.target = "_blank", h.rel = "noopener noreferrer", h.addEventListener("click", () => {
+        this.footerWaitTimer !== null && (clearTimeout(this.footerWaitTimer), this.footerWaitTimer = null), this.showFooterWaitingState();
+      });
+      const y = document.createElement("span");
+      y.className = "icon", y.setAttribute("aria-hidden", "true");
+      const f = this.iconForUrl(c);
+      f && (y.innerHTML = f);
+      const m = document.createElement("span");
+      m.className = "label", m.textContent = this.labelForUrl(c, o.lang), f && h.appendChild(y), h.appendChild(m), this.verifiersEl.appendChild(h);
+    });
+  }
+  iconForUrl(i) {
+    try {
+      const o = new URL(i, window.location.origin);
+      if (o.protocol === "mailto:") return mt;
+      if (o.protocol === "whatsapp:" || o.protocol === "whatsapp://") return vt;
+    } catch {
+      if (i.startsWith("mailto:")) return mt;
+      if (i.startsWith("whatsapp:") || i.startsWith("whatsapp://")) return vt;
+    }
+    return null;
+  }
+  labelForUrl(i, o) {
+    const c = se(o);
+    try {
+      const h = new URL(i, window.location.origin);
+      return h.protocol === "mailto:" ? `${c.ui.by} ${c.labels.email}` : h.protocol.startsWith("http") ? h.hostname : h.protocol === "whatsapp:" ? `${c.ui.by} ${c.labels.whatsapp}` : h.protocol.replace(":", "");
+    } catch {
+      return i.startsWith("mailto:") ? `${c.ui.by} ${c.labels.email}` : i.startsWith("whatsapp:") || i.startsWith("whatsapp://") ? `${c.ui.by} ${c.labels.whatsapp}` : i;
+    }
+  }
+  buildLink(i, o) {
+    const c = this.lastCode, h = se(o), C = window.location.host;
+    if (!c) return i;
+    if (i.startsWith("mailto:")) {
+      const [y, f = ""] = i.split("?"), m = new URLSearchParams(f), k = this.applyTemplate(h.templates.emailSubject, C, c), S = this.applyTemplate(h.templates.emailBody, C, c);
+      m.set("subject", k), m.set("body", S);
+      const L = this.toQuery(m);
+      return `${y}?${L}`;
+    }
+    if (i.startsWith("whatsapp:") || i.startsWith("whatsapp://")) {
+      const [y, f = ""] = i.split("?"), m = new URLSearchParams(f), k = this.applyTemplate(h.templates.whatsappText, C, c);
+      m.set("text", k);
+      const S = this.toQuery(m);
+      return `${y}?${S}`;
+    }
+    return i;
+  }
+  applyTemplate(i, o, c) {
+    return i.replaceAll("(Host)", o).replaceAll("(Code)", c);
+  }
+  // Build query string without using URLSearchParams.toString() because it encodes
+  // spaces as '+', which breaks expectations for many mail clients handling mailto:
+  // We use encodeURIComponent so spaces become '%20' and follow RFC 3986 style.
+  toQuery(i) {
+    const o = [];
+    return i.forEach((c, h) => {
+      const C = encodeURIComponent(h), y = encodeURIComponent(c);
+      o.push(`${C}=${y}`);
+    }), o.join("&");
+  }
+  joinUrl(i, o) {
+    return i.endsWith("/") && o.startsWith("/") ? i + o.slice(1) : !i.endsWith("/") && !o.startsWith("/") ? i + "/" + o : i + o;
+  }
+};
+ge.tailwindCssText = null, ge.tailwindLoading = null;
+let Ie = ge;
+customElements.get("sendity-auth") || customElements.define("sendity-auth", Ie);
+export {
+  Ie as Sendity
+};