@brainfish-ai/web-tracker 0.0.4-alpha.15 → 0.0.4-alpha.17

package/dist/index.js

@@ -1,5 +1,1944 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const e = require("./index-D2jDlqQC.js");
-exports.Tracker = e.Tracker, exports.VERSION = e.VERSION;
+var Je = Object.defineProperty, Qe = Object.defineProperties;
+var Ge = Object.getOwnPropertyDescriptors;
+var pe = Object.getOwnPropertySymbols, Ze = Object.getPrototypeOf, et = Object.prototype.hasOwnProperty, tt = Object.prototype.propertyIsEnumerable, st = Reflect.get;
+var fe = Math.pow, z = (s, e, t) => e in s ? Je(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t, v = (s, e) => {
+  for (var t in e || (e = {}))
+    et.call(e, t) && z(s, t, e[t]);
+  if (pe)
+    for (var t of pe(e))
+      tt.call(e, t) && z(s, t, e[t]);
+  return s;
+}, O = (s, e) => Qe(s, Ge(e));
+var b = (s, e, t) => z(s, typeof e != "symbol" ? e + "" : e, t);
+var ge = (s, e, t) => st(Ze(s), t, e);
+var p = (s, e, t) => new Promise((n, r) => {
+  var i = (c) => {
+    try {
+      a(t.next(c));
+    } catch (h) {
+      r(h);
+    }
+  }, o = (c) => {
+    try {
+      a(t.throw(c));
+    } catch (h) {
+      r(h);
+    }
+  }, a = (c) => c.done ? n(c.value) : Promise.resolve(c.value).then(i, o);
+  a((t = t.apply(s, e)).next());
+});
+const R = /* @__PURE__ */ Object.create(null);
+R.open = "0", R.close = "1", R.ping = "2", R.pong = "3", R.message = "4", R.upgrade = "5", R.noop = "6";
+const U = /* @__PURE__ */ Object.create(null);
+Object.keys(R).forEach((s) => {
+  U[R[s]] = s;
+});
+const G = { type: "error", data: "parser error" }, Oe = typeof Blob == "function" || typeof Blob != "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", Ne = typeof ArrayBuffer == "function", Le = (s) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(s) : s && s.buffer instanceof ArrayBuffer, ie = ({ type: s, data: e }, t, n) => Oe && e instanceof Blob ? t ? n(e) : ye(e, n) : Ne && (e instanceof ArrayBuffer || Le(e)) ? t ? n(e) : ye(new Blob([e]), n) : n(R[s] + (e || "")), ye = (s, e) => {
+  const t = new FileReader();
+  return t.onload = function() {
+    const n = t.result.split(",")[1];
+    e("b" + (n || ""));
+  }, t.readAsDataURL(s);
+};
+function me(s) {
+  return s instanceof Uint8Array ? s : s instanceof ArrayBuffer ? new Uint8Array(s) : new Uint8Array(s.buffer, s.byteOffset, s.byteLength);
+}
+let K;
+const nt = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", P = typeof Uint8Array == "undefined" ? [] : new Uint8Array(256);
+for (let s = 0; s < 64; s++) P[nt.charCodeAt(s)] = s;
+const rt = typeof ArrayBuffer == "function", oe = (s, e) => {
+  if (typeof s != "string") return { type: "message", data: Pe(s, e) };
+  const t = s.charAt(0);
+  return t === "b" ? { type: "message", data: it(s.substring(1), e) } : U[t] ? s.length > 1 ? { type: U[t], data: s.substring(1) } : { type: U[t] } : G;
+}, it = (s, e) => {
+  if (rt) {
+    const t = ((n) => {
+      let r, i, o, a, c, h = 0.75 * n.length, u = n.length, l = 0;
+      n[n.length - 1] === "=" && (h--, n[n.length - 2] === "=" && h--);
+      const d = new ArrayBuffer(h), m = new Uint8Array(d);
+      for (r = 0; r < u; r += 4) i = P[n.charCodeAt(r)], o = P[n.charCodeAt(r + 1)], a = P[n.charCodeAt(r + 2)], c = P[n.charCodeAt(r + 3)], m[l++] = i << 2 | o >> 4, m[l++] = (15 & o) << 4 | a >> 2, m[l++] = (3 & a) << 6 | 63 & c;
+      return d;
+    })(s);
+    return Pe(t, e);
+  }
+  return { base64: !0, data: s };
+}, Pe = (s, e) => e === "blob" ? s instanceof Blob ? s : new Blob([s]) : s instanceof ArrayBuffer ? s : s.buffer, be = "";
+function ot() {
+  return new TransformStream({ transform(s, e) {
+    (function(t, n) {
+      Oe && t.data instanceof Blob ? t.data.arrayBuffer().then(me).then(n) : Ne && (t.data instanceof ArrayBuffer || Le(t.data)) ? n(me(t.data)) : ie(t, !1, (r) => {
+        K || (K = new TextEncoder()), n(K.encode(r));
+      });
+    })(s, (t) => {
+      const n = t.length;
+      let r;
+      if (n < 126) r = new Uint8Array(1), new DataView(r.buffer).setUint8(0, n);
+      else if (n < 65536) {
+        r = new Uint8Array(3);
+        const i = new DataView(r.buffer);
+        i.setUint8(0, 126), i.setUint16(1, n);
+      } else {
+        r = new Uint8Array(9);
+        const i = new DataView(r.buffer);
+        i.setUint8(0, 127), i.setBigUint64(1, BigInt(n));
+      }
+      s.data && typeof s.data != "string" && (r[0] |= 128), e.enqueue(r), e.enqueue(t);
+    });
+  } });
+}
+let Y;
+function B(s) {
+  return s.reduce((e, t) => e + t.length, 0);
+}
+function I(s, e) {
+  if (s[0].length === e) return s.shift();
+  const t = new Uint8Array(e);
+  let n = 0;
+  for (let r = 0; r < e; r++) t[r] = s[0][n++], n === s[0].length && (s.shift(), n = 0);
+  return s.length && n < s[0].length && (s[0] = s[0].slice(n)), t;
+}
+function y(s) {
+  if (s) return function(e) {
+    for (var t in y.prototype) e[t] = y.prototype[t];
+    return e;
+  }(s);
+}
+y.prototype.on = y.prototype.addEventListener = function(s, e) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks["$" + s] = this._callbacks["$" + s] || []).push(e), this;
+}, y.prototype.once = function(s, e) {
+  function t() {
+    this.off(s, t), e.apply(this, arguments);
+  }
+  return t.fn = e, this.on(s, t), this;
+}, y.prototype.off = y.prototype.removeListener = y.prototype.removeAllListeners = y.prototype.removeEventListener = function(s, e) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0) return this._callbacks = {}, this;
+  var t, n = this._callbacks["$" + s];
+  if (!n) return this;
+  if (arguments.length == 1) return delete this._callbacks["$" + s], this;
+  for (var r = 0; r < n.length; r++) if ((t = n[r]) === e || t.fn === e) {
+    n.splice(r, 1);
+    break;
+  }
+  return n.length === 0 && delete this._callbacks["$" + s], this;
+}, y.prototype.emit = function(s) {
+  this._callbacks = this._callbacks || {};
+  for (var e = new Array(arguments.length - 1), t = this._callbacks["$" + s], n = 1; n < arguments.length; n++) e[n - 1] = arguments[n];
+  if (t) {
+    n = 0;
+    for (var r = (t = t.slice(0)).length; n < r; ++n) t[n].apply(this, e);
+  }
+  return this;
+}, y.prototype.emitReserved = y.prototype.emit, y.prototype.listeners = function(s) {
+  return this._callbacks = this._callbacks || {}, this._callbacks["$" + s] || [];
+}, y.prototype.hasListeners = function(s) {
+  return !!this.listeners(s).length;
+};
+const W = typeof Promise == "function" && typeof Promise.resolve == "function" ? (s) => Promise.resolve().then(s) : (s, e) => e(s, 0), k = typeof self != "undefined" ? self : typeof window != "undefined" ? window : Function("return this")();
+function Be(s, ...e) {
+  return e.reduce((t, n) => (s.hasOwnProperty(n) && (t[n] = s[n]), t), {});
+}
+const at = k.setTimeout, ct = k.clearTimeout;
+function H(s, e) {
+  e.useNativeTimers ? (s.setTimeoutFn = at.bind(k), s.clearTimeoutFn = ct.bind(k)) : (s.setTimeoutFn = k.setTimeout.bind(k), s.clearTimeoutFn = k.clearTimeout.bind(k));
+}
+function Ie() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+class ht extends Error {
+  constructor(e, t, n) {
+    super(e), this.description = t, this.context = n, this.type = "TransportError";
+  }
+}
+class ae extends y {
+  constructor(e) {
+    super(), this.writable = !1, H(this, e), this.opts = e, this.query = e.query, this.socket = e.socket, this.supportsBinary = !e.forceBase64;
+  }
+  onError(e, t, n) {
+    return super.emitReserved("error", new ht(e, t, n)), this;
+  }
+  open() {
+    return this.readyState = "opening", this.doOpen(), this;
+  }
+  close() {
+    return this.readyState !== "opening" && this.readyState !== "open" || (this.doClose(), this.onClose()), this;
+  }
+  send(e) {
+    this.readyState === "open" && this.write(e);
+  }
+  onOpen() {
+    this.readyState = "open", this.writable = !0, super.emitReserved("open");
+  }
+  onData(e) {
+    const t = oe(e, this.socket.binaryType);
+    this.onPacket(t);
+  }
+  onPacket(e) {
+    super.emitReserved("packet", e);
+  }
+  onClose(e) {
+    this.readyState = "closed", super.emitReserved("close", e);
+  }
+  pause(e) {
+  }
+  createUri(e, t = {}) {
+    return e + "://" + this._hostname() + this._port() + this.opts.path + this._query(t);
+  }
+  _hostname() {
+    const e = this.opts.hostname;
+    return e.indexOf(":") === -1 ? e : "[" + e + "]";
+  }
+  _port() {
+    return this.opts.port && (this.opts.secure && +(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80) ? ":" + this.opts.port : "";
+  }
+  _query(e) {
+    const t = function(n) {
+      let r = "";
+      for (let i in n) n.hasOwnProperty(i) && (r.length && (r += "&"), r += encodeURIComponent(i) + "=" + encodeURIComponent(n[i]));
+      return r;
+    }(e);
+    return t.length ? "?" + t : "";
+  }
+}
+class ut extends ae {
+  constructor() {
+    super(...arguments), this._polling = !1;
+  }
+  get name() {
+    return "polling";
+  }
+  doOpen() {
+    this._poll();
+  }
+  pause(e) {
+    this.readyState = "pausing";
+    const t = () => {
+      this.readyState = "paused", e();
+    };
+    if (this._polling || !this.writable) {
+      let n = 0;
+      this._polling && (n++, this.once("pollComplete", function() {
+        --n || t();
+      })), this.writable || (n++, this.once("drain", function() {
+        --n || t();
+      }));
+    } else t();
+  }
+  _poll() {
+    this._polling = !0, this.doPoll(), this.emitReserved("poll");
+  }
+  onData(e) {
+    ((t, n) => {
+      const r = t.split(be), i = [];
+      for (let o = 0; o < r.length; o++) {
+        const a = oe(r[o], n);
+        if (i.push(a), a.type === "error") break;
+      }
+      return i;
+    })(e, this.socket.binaryType).forEach((t) => {
+      if (this.readyState === "opening" && t.type === "open" && this.onOpen(), t.type === "close") return this.onClose({ description: "transport closed by the server" }), !1;
+      this.onPacket(t);
+    }), this.readyState !== "closed" && (this._polling = !1, this.emitReserved("pollComplete"), this.readyState === "open" && this._poll());
+  }
+  doClose() {
+    const e = () => {
+      this.write([{ type: "close" }]);
+    };
+    this.readyState === "open" ? e() : this.once("open", e);
+  }
+  write(e) {
+    this.writable = !1, ((t, n) => {
+      const r = t.length, i = new Array(r);
+      let o = 0;
+      t.forEach((a, c) => {
+        ie(a, !1, (h) => {
+          i[c] = h, ++o === r && n(i.join(be));
+        });
+      });
+    })(e, (t) => {
+      this.doWrite(t, () => {
+        this.writable = !0, this.emitReserved("drain");
+      });
+    });
+  }
+  uri() {
+    const e = this.opts.secure ? "https" : "http", t = this.query || {};
+    return this.opts.timestampRequests !== !1 && (t[this.opts.timestampParam] = Ie()), this.supportsBinary || t.sid || (t.b64 = 1), this.createUri(e, t);
+  }
+}
+let qe = !1;
+try {
+  qe = typeof XMLHttpRequest != "undefined" && "withCredentials" in new XMLHttpRequest();
+} catch (s) {
+}
+const lt = qe;
+function dt() {
+}
+class pt extends ut {
+  constructor(e) {
+    if (super(e), typeof location != "undefined") {
+      const t = location.protocol === "https:";
+      let n = location.port;
+      n || (n = t ? "443" : "80"), this.xd = typeof location != "undefined" && e.hostname !== location.hostname || n !== e.port;
+    }
+  }
+  doWrite(e, t) {
+    const n = this.request({ method: "POST", data: e });
+    n.on("success", t), n.on("error", (r, i) => {
+      this.onError("xhr post error", r, i);
+    });
+  }
+  doPoll() {
+    const e = this.request();
+    e.on("data", this.onData.bind(this)), e.on("error", (t, n) => {
+      this.onError("xhr poll error", t, n);
+    }), this.pollXhr = e;
+  }
+}
+class A extends y {
+  constructor(e, t, n) {
+    super(), this.createRequest = e, H(this, n), this._opts = n, this._method = n.method || "GET", this._uri = t, this._data = n.data !== void 0 ? n.data : null, this._create();
+  }
+  _create() {
+    var e;
+    const t = Be(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    t.xdomain = !!this._opts.xd;
+    const n = this._xhr = this.createRequest(t);
+    try {
+      n.open(this._method, this._uri, !0);
+      try {
+        if (this._opts.extraHeaders) {
+          n.setDisableHeaderCheck && n.setDisableHeaderCheck(!0);
+          for (let r in this._opts.extraHeaders) this._opts.extraHeaders.hasOwnProperty(r) && n.setRequestHeader(r, this._opts.extraHeaders[r]);
+        }
+      } catch (r) {
+      }
+      if (this._method === "POST") try {
+        n.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+      } catch (r) {
+      }
+      try {
+        n.setRequestHeader("Accept", "*/*");
+      } catch (r) {
+      }
+      (e = this._opts.cookieJar) === null || e === void 0 || e.addCookies(n), "withCredentials" in n && (n.withCredentials = this._opts.withCredentials), this._opts.requestTimeout && (n.timeout = this._opts.requestTimeout), n.onreadystatechange = () => {
+        var r;
+        n.readyState === 3 && ((r = this._opts.cookieJar) === null || r === void 0 || r.parseCookies(n.getResponseHeader("set-cookie"))), n.readyState === 4 && (n.status === 200 || n.status === 1223 ? this._onLoad() : this.setTimeoutFn(() => {
+          this._onError(typeof n.status == "number" ? n.status : 0);
+        }, 0));
+      }, n.send(this._data);
+    } catch (r) {
+      return void this.setTimeoutFn(() => {
+        this._onError(r);
+      }, 0);
+    }
+    typeof document != "undefined" && (this._index = A.requestsCount++, A.requests[this._index] = this);
+  }
+  _onError(e) {
+    this.emitReserved("error", e, this._xhr), this._cleanup(!0);
+  }
+  _cleanup(e) {
+    if (this._xhr !== void 0 && this._xhr !== null) {
+      if (this._xhr.onreadystatechange = dt, e) try {
+        this._xhr.abort();
+      } catch (t) {
+      }
+      typeof document != "undefined" && delete A.requests[this._index], this._xhr = null;
+    }
+  }
+  _onLoad() {
+    const e = this._xhr.responseText;
+    e !== null && (this.emitReserved("data", e), this.emitReserved("success"), this._cleanup());
+  }
+  abort() {
+    this._cleanup();
+  }
+}
+A.requestsCount = 0, A.requests = {}, typeof document != "undefined" && (typeof attachEvent == "function" ? attachEvent("onunload", we) : typeof addEventListener == "function" && addEventListener("onpagehide" in k ? "pagehide" : "unload", we, !1));
+function we() {
+  for (let s in A.requests) A.requests.hasOwnProperty(s) && A.requests[s].abort();
+}
+const ft = function() {
+  const s = je({ xdomain: !1 });
+  return s && s.responseType !== null;
+}();
+function je(s) {
+  const e = s.xdomain;
+  try {
+    if (typeof XMLHttpRequest != "undefined" && (!e || lt)) return new XMLHttpRequest();
+  } catch (t) {
+  }
+  if (!e) try {
+    return new k[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+  } catch (t) {
+  }
+}
+const Ue = typeof navigator != "undefined" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class gt extends ae {
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    const e = this.uri(), t = this.opts.protocols, n = Ue ? {} : Be(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+    this.opts.extraHeaders && (n.headers = this.opts.extraHeaders);
+    try {
+      this.ws = this.createSocket(e, t, n);
+    } catch (r) {
+      return this.emitReserved("error", r);
+    }
+    this.ws.binaryType = this.socket.binaryType, this.addEventListeners();
+  }
+  addEventListeners() {
+    this.ws.onopen = () => {
+      this.opts.autoUnref && this.ws._socket.unref(), this.onOpen();
+    }, this.ws.onclose = (e) => this.onClose({ description: "websocket connection closed", context: e }), this.ws.onmessage = (e) => this.onData(e.data), this.ws.onerror = (e) => this.onError("websocket error", e);
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const n = e[t], r = t === e.length - 1;
+      ie(n, this.supportsBinary, (i) => {
+        try {
+          this.doWrite(n, i);
+        } catch (o) {
+        }
+        r && W(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    this.ws !== void 0 && (this.ws.close(), this.ws = null);
+  }
+  uri() {
+    const e = this.opts.secure ? "wss" : "ws", t = this.query || {};
+    return this.opts.timestampRequests && (t[this.opts.timestampParam] = Ie()), this.supportsBinary || (t.b64 = 1), this.createUri(e, t);
+  }
+}
+const X = k.WebSocket || k.MozWebSocket, yt = { websocket: class extends gt {
+  createSocket(s, e, t) {
+    return Ue ? new X(s, e, t) : e ? new X(s, e) : new X(s);
+  }
+  doWrite(s, e) {
+    this.ws.send(e);
+  }
+}, webtransport: class extends ae {
+  get name() {
+    return "webtransport";
+  }
+  doOpen() {
+    try {
+      this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+    } catch (s) {
+      return this.emitReserved("error", s);
+    }
+    this._transport.closed.then(() => {
+      this.onClose();
+    }).catch((s) => {
+      this.onError("webtransport error", s);
+    }), this._transport.ready.then(() => {
+      this._transport.createBidirectionalStream().then((s) => {
+        const e = function(o, a) {
+          Y || (Y = new TextDecoder());
+          const c = [];
+          let h = 0, u = -1, l = !1;
+          return new TransformStream({ transform(d, m) {
+            for (c.push(d); ; ) {
+              if (h === 0) {
+                if (B(c) < 1) break;
+                const g = I(c, 1);
+                l = !(128 & ~g[0]), u = 127 & g[0], h = u < 126 ? 3 : u === 126 ? 1 : 2;
+              } else if (h === 1) {
+                if (B(c) < 2) break;
+                const g = I(c, 2);
+                u = new DataView(g.buffer, g.byteOffset, g.length).getUint16(0), h = 3;
+              } else if (h === 2) {
+                if (B(c) < 8) break;
+                const g = I(c, 8), C = new DataView(g.buffer, g.byteOffset, g.length), de = C.getUint32(0);
+                if (de > Math.pow(2, 21) - 1) {
+                  m.enqueue(G);
+                  break;
+                }
+                u = de * Math.pow(2, 32) + C.getUint32(4), h = 3;
+              } else {
+                if (B(c) < u) break;
+                const g = I(c, u);
+                m.enqueue(oe(l ? g : Y.decode(g), a)), h = 0;
+              }
+              if (u === 0 || u > o) {
+                m.enqueue(G);
+                break;
+              }
+            }
+          } });
+        }(Number.MAX_SAFE_INTEGER, this.socket.binaryType), t = s.readable.pipeThrough(e).getReader(), n = ot();
+        n.readable.pipeTo(s.writable), this._writer = n.writable.getWriter();
+        const r = () => {
+          t.read().then(({ done: o, value: a }) => {
+            o || (this.onPacket(a), r());
+          }).catch((o) => {
+          });
+        };
+        r();
+        const i = { type: "open" };
+        this.query.sid && (i.data = `{"sid":"${this.query.sid}"}`), this._writer.write(i).then(() => this.onOpen());
+      });
+    });
+  }
+  write(s) {
+    this.writable = !1;
+    for (let e = 0; e < s.length; e++) {
+      const t = s[e], n = e === s.length - 1;
+      this._writer.write(t).then(() => {
+        n && W(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    var s;
+    (s = this._transport) === null || s === void 0 || s.close();
+  }
+}, polling: class extends pt {
+  constructor(s) {
+    super(s);
+    const e = s && s.forceBase64;
+    this.supportsBinary = ft && !e;
+  }
+  request(s = {}) {
+    return Object.assign(s, { xd: this.xd }, this.opts), new A(je, this.uri(), s);
+  }
+} }, mt = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, bt = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];
+function Z(s) {
+  if (s.length > 8e3) throw "URI too long";
+  const e = s, t = s.indexOf("["), n = s.indexOf("]");
+  t != -1 && n != -1 && (s = s.substring(0, t) + s.substring(t, n).replace(/:/g, ";") + s.substring(n, s.length));
+  let r = mt.exec(s || ""), i = {}, o = 14;
+  for (; o--; ) i[bt[o]] = r[o] || "";
+  return t != -1 && n != -1 && (i.source = e, i.host = i.host.substring(1, i.host.length - 1).replace(/;/g, ":"), i.authority = i.authority.replace("[", "").replace("]", "").replace(/;/g, ":"), i.ipv6uri = !0), i.pathNames = function(a, c) {
+    const h = /\/{2,9}/g, u = c.replace(h, "/").split("/");
+    return c.slice(0, 1) != "/" && c.length !== 0 || u.splice(0, 1), c.slice(-1) == "/" && u.splice(u.length - 1, 1), u;
+  }(0, i.path), i.queryKey = function(a, c) {
+    const h = {};
+    return c.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(u, l, d) {
+      l && (h[l] = d);
+    }), h;
+  }(0, i.query), i;
+}
+const ee = typeof addEventListener == "function" && typeof removeEventListener == "function", D = [];
+ee && addEventListener("offline", () => {
+  D.forEach((s) => s());
+}, !1);
+class T extends y {
+  constructor(e, t) {
+    if (super(), this.binaryType = "arraybuffer", this.writeBuffer = [], this._prevBufferLen = 0, this._pingInterval = -1, this._pingTimeout = -1, this._maxPayload = -1, this._pingTimeoutTime = 1 / 0, e && typeof e == "object" && (t = e, e = null), e) {
+      const n = Z(e);
+      t.hostname = n.host, t.secure = n.protocol === "https" || n.protocol === "wss", t.port = n.port, n.query && (t.query = n.query);
+    } else t.host && (t.hostname = Z(t.host).host);
+    H(this, t), this.secure = t.secure != null ? t.secure : typeof location != "undefined" && location.protocol === "https:", t.hostname && !t.port && (t.port = this.secure ? "443" : "80"), this.hostname = t.hostname || (typeof location != "undefined" ? location.hostname : "localhost"), this.port = t.port || (typeof location != "undefined" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = [], this._transportsByName = {}, t.transports.forEach((n) => {
+      const r = n.prototype.name;
+      this.transports.push(r), this._transportsByName[r] = n;
+    }), this.opts = Object.assign({ path: "/engine.io", agent: !1, withCredentials: !1, upgrade: !0, timestampParam: "t", rememberUpgrade: !1, addTrailingSlash: !0, rejectUnauthorized: !0, perMessageDeflate: { threshold: 1024 }, transportOptions: {}, closeOnBeforeunload: !1 }, t), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = function(n) {
+      let r = {}, i = n.split("&");
+      for (let o = 0, a = i.length; o < a; o++) {
+        let c = i[o].split("=");
+        r[decodeURIComponent(c[0])] = decodeURIComponent(c[1]);
+      }
+      return r;
+    }(this.opts.query)), ee && (this.opts.closeOnBeforeunload && (this._beforeunloadEventListener = () => {
+      this.transport && (this.transport.removeAllListeners(), this.transport.close());
+    }, addEventListener("beforeunload", this._beforeunloadEventListener, !1)), this.hostname !== "localhost" && (this._offlineEventListener = () => {
+      this._onClose("transport close", { description: "network connection lost" });
+    }, D.push(this._offlineEventListener))), this.opts.withCredentials && (this._cookieJar = void 0), this._open();
+  }
+  createTransport(e) {
+    const t = Object.assign({}, this.opts.query);
+    t.EIO = 4, t.transport = e, this.id && (t.sid = this.id);
+    const n = Object.assign({}, this.opts, { query: t, socket: this, hostname: this.hostname, secure: this.secure, port: this.port }, this.opts.transportOptions[e]);
+    return new this._transportsByName[e](n);
+  }
+  _open() {
+    if (this.transports.length === 0) return void this.setTimeoutFn(() => {
+      this.emitReserved("error", "No transports available");
+    }, 0);
+    const e = this.opts.rememberUpgrade && T.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+    this.readyState = "opening";
+    const t = this.createTransport(e);
+    t.open(), this.setTransport(t);
+  }
+  setTransport(e) {
+    this.transport && this.transport.removeAllListeners(), this.transport = e, e.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (t) => this._onClose("transport close", t));
+  }
+  onOpen() {
+    this.readyState = "open", T.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush();
+  }
+  _onPacket(e) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") switch (this.emitReserved("packet", e), this.emitReserved("heartbeat"), e.type) {
+      case "open":
+        this.onHandshake(JSON.parse(e.data));
+        break;
+      case "ping":
+        this._sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong"), this._resetPingTimeout();
+        break;
+      case "error":
+        const t = new Error("server error");
+        t.code = e.data, this._onError(t);
+        break;
+      case "message":
+        this.emitReserved("data", e.data), this.emitReserved("message", e.data);
+    }
+  }
+  onHandshake(e) {
+    this.emitReserved("handshake", e), this.id = e.sid, this.transport.query.sid = e.sid, this._pingInterval = e.pingInterval, this._pingTimeout = e.pingTimeout, this._maxPayload = e.maxPayload, this.onOpen(), this.readyState !== "closed" && this._resetPingTimeout();
+  }
+  _resetPingTimeout() {
+    this.clearTimeoutFn(this._pingTimeoutTimer);
+    const e = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + e, this._pingTimeoutTimer = this.setTimeoutFn(() => {
+      this._onClose("ping timeout");
+    }, e), this.opts.autoUnref && this._pingTimeoutTimer.unref();
+  }
+  _onDrain() {
+    this.writeBuffer.splice(0, this._prevBufferLen), this._prevBufferLen = 0, this.writeBuffer.length === 0 ? this.emitReserved("drain") : this.flush();
+  }
+  flush() {
+    if (this.readyState !== "closed" && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+      const e = this._getWritablePackets();
+      this.transport.send(e), this._prevBufferLen = e.length, this.emitReserved("flush");
+    }
+  }
+  _getWritablePackets() {
+    if (!(this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1)) return this.writeBuffer;
+    let e = 1;
+    for (let n = 0; n < this.writeBuffer.length; n++) {
+      const r = this.writeBuffer[n].data;
+      if (r && (e += typeof (t = r) == "string" ? function(i) {
+        let o = 0, a = 0;
+        for (let c = 0, h = i.length; c < h; c++) o = i.charCodeAt(c), o < 128 ? a += 1 : o < 2048 ? a += 2 : o < 55296 || o >= 57344 ? a += 3 : (c++, a += 4);
+        return a;
+      }(t) : Math.ceil(1.33 * (t.byteLength || t.size))), n > 0 && e > this._maxPayload) return this.writeBuffer.slice(0, n);
+      e += 2;
+    }
+    var t;
+    return this.writeBuffer;
+  }
+  _hasPingExpired() {
+    if (!this._pingTimeoutTime) return !0;
+    const e = Date.now() > this._pingTimeoutTime;
+    return e && (this._pingTimeoutTime = 0, W(() => {
+      this._onClose("ping timeout");
+    }, this.setTimeoutFn)), e;
+  }
+  write(e, t, n) {
+    return this._sendPacket("message", e, t, n), this;
+  }
+  send(e, t, n) {
+    return this._sendPacket("message", e, t, n), this;
+  }
+  _sendPacket(e, t, n, r) {
+    if (typeof t == "function" && (r = t, t = void 0), typeof n == "function" && (r = n, n = null), this.readyState === "closing" || this.readyState === "closed") return;
+    (n = n || {}).compress = n.compress !== !1;
+    const i = { type: e, data: t, options: n };
+    this.emitReserved("packetCreate", i), this.writeBuffer.push(i), r && this.once("flush", r), this.flush();
+  }
+  close() {
+    const e = () => {
+      this._onClose("forced close"), this.transport.close();
+    }, t = () => {
+      this.off("upgrade", t), this.off("upgradeError", t), e();
+    }, n = () => {
+      this.once("upgrade", t), this.once("upgradeError", t);
+    };
+    return this.readyState !== "opening" && this.readyState !== "open" || (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? n() : e();
+    }) : this.upgrading ? n() : e()), this;
+  }
+  _onError(e) {
+    if (T.priorWebsocketSuccess = !1, this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") return this.transports.shift(), this._open();
+    this.emitReserved("error", e), this._onClose("transport error", e);
+  }
+  _onClose(e, t) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+      if (this.clearTimeoutFn(this._pingTimeoutTimer), this.transport.removeAllListeners("close"), this.transport.close(), this.transport.removeAllListeners(), ee && (this._beforeunloadEventListener && removeEventListener("beforeunload", this._beforeunloadEventListener, !1), this._offlineEventListener)) {
+        const n = D.indexOf(this._offlineEventListener);
+        n !== -1 && D.splice(n, 1);
+      }
+      this.readyState = "closed", this.id = null, this.emitReserved("close", e, t), this.writeBuffer = [], this._prevBufferLen = 0;
+    }
+  }
+}
+T.protocol = 4;
+class wt extends T {
+  constructor() {
+    super(...arguments), this._upgrades = [];
+  }
+  onOpen() {
+    if (super.onOpen(), this.readyState === "open" && this.opts.upgrade) for (let e = 0; e < this._upgrades.length; e++) this._probe(this._upgrades[e]);
+  }
+  _probe(e) {
+    let t = this.createTransport(e), n = !1;
+    T.priorWebsocketSuccess = !1;
+    const r = () => {
+      n || (t.send([{ type: "ping", data: "probe" }]), t.once("packet", (l) => {
+        if (!n) if (l.type === "pong" && l.data === "probe") {
+          if (this.upgrading = !0, this.emitReserved("upgrading", t), !t) return;
+          T.priorWebsocketSuccess = t.name === "websocket", this.transport.pause(() => {
+            n || this.readyState !== "closed" && (u(), this.setTransport(t), t.send([{ type: "upgrade" }]), this.emitReserved("upgrade", t), t = null, this.upgrading = !1, this.flush());
+          });
+        } else {
+          const d = new Error("probe error");
+          d.transport = t.name, this.emitReserved("upgradeError", d);
+        }
+      }));
+    };
+    function i() {
+      n || (n = !0, u(), t.close(), t = null);
+    }
+    const o = (l) => {
+      const d = new Error("probe error: " + l);
+      d.transport = t.name, i(), this.emitReserved("upgradeError", d);
+    };
+    function a() {
+      o("transport closed");
+    }
+    function c() {
+      o("socket closed");
+    }
+    function h(l) {
+      t && l.name !== t.name && i();
+    }
+    const u = () => {
+      t.removeListener("open", r), t.removeListener("error", o), t.removeListener("close", a), this.off("close", c), this.off("upgrading", h);
+    };
+    t.once("open", r), t.once("error", o), t.once("close", a), this.once("close", c), this.once("upgrading", h), this._upgrades.indexOf("webtransport") !== -1 && e !== "webtransport" ? this.setTimeoutFn(() => {
+      n || t.open();
+    }, 200) : t.open();
+  }
+  onHandshake(e) {
+    this._upgrades = this._filterUpgrades(e.upgrades), super.onHandshake(e);
+  }
+  _filterUpgrades(e) {
+    const t = [];
+    for (let n = 0; n < e.length; n++) ~this.transports.indexOf(e[n]) && t.push(e[n]);
+    return t;
+  }
+}
+let _t = class extends wt {
+  constructor(s, e = {}) {
+    const t = typeof s == "object" ? s : e;
+    (!t.transports || t.transports && typeof t.transports[0] == "string") && (t.transports = (t.transports || ["polling", "websocket", "webtransport"]).map((n) => yt[n]).filter((n) => !!n)), super(s, t);
+  }
+};
+const vt = typeof ArrayBuffer == "function", De = Object.prototype.toString, kt = typeof Blob == "function" || typeof Blob != "undefined" && De.call(Blob) === "[object BlobConstructor]", Et = typeof File == "function" || typeof File != "undefined" && De.call(File) === "[object FileConstructor]";
+function ce(s) {
+  return vt && (s instanceof ArrayBuffer || ((e) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(e) : e.buffer instanceof ArrayBuffer)(s)) || kt && s instanceof Blob || Et && s instanceof File;
+}
+function $(s, e) {
+  if (!s || typeof s != "object") return !1;
+  if (Array.isArray(s)) {
+    for (let t = 0, n = s.length; t < n; t++) if ($(s[t])) return !0;
+    return !1;
+  }
+  if (ce(s)) return !0;
+  if (s.toJSON && typeof s.toJSON == "function" && arguments.length === 1) return $(s.toJSON(), !0);
+  for (const t in s) if (Object.prototype.hasOwnProperty.call(s, t) && $(s[t])) return !0;
+  return !1;
+}
+function Rt(s) {
+  const e = [], t = s.data, n = s;
+  return n.data = te(t, e), n.attachments = e.length, { packet: n, buffers: e };
+}
+function te(s, e) {
+  if (!s) return s;
+  if (ce(s)) {
+    const t = { _placeholder: !0, num: e.length };
+    return e.push(s), t;
+  }
+  if (Array.isArray(s)) {
+    const t = new Array(s.length);
+    for (let n = 0; n < s.length; n++) t[n] = te(s[n], e);
+    return t;
+  }
+  if (typeof s == "object" && !(s instanceof Date)) {
+    const t = {};
+    for (const n in s) Object.prototype.hasOwnProperty.call(s, n) && (t[n] = te(s[n], e));
+    return t;
+  }
+  return s;
+}
+function At(s, e) {
+  return s.data = se(s.data, e), delete s.attachments, s;
+}
+function se(s, e) {
+  if (!s) return s;
+  if (s && s._placeholder === !0) {
+    if (typeof s.num == "number" && s.num >= 0 && s.num < e.length) return e[s.num];
+    throw new Error("illegal attachments");
+  }
+  if (Array.isArray(s)) for (let t = 0; t < s.length; t++) s[t] = se(s[t], e);
+  else if (typeof s == "object") for (const t in s) Object.prototype.hasOwnProperty.call(s, t) && (s[t] = se(s[t], e));
+  return s;
+}
+const St = ["connect", "connect_error", "disconnect", "disconnecting", "newListener", "removeListener"];
+var f;
+(function(s) {
+  s[s.CONNECT = 0] = "CONNECT", s[s.DISCONNECT = 1] = "DISCONNECT", s[s.EVENT = 2] = "EVENT", s[s.ACK = 3] = "ACK", s[s.CONNECT_ERROR = 4] = "CONNECT_ERROR", s[s.BINARY_EVENT = 5] = "BINARY_EVENT", s[s.BINARY_ACK = 6] = "BINARY_ACK";
+})(f || (f = {}));
+function _e(s) {
+  return Object.prototype.toString.call(s) === "[object Object]";
+}
+class he extends y {
+  constructor(e) {
+    super(), this.reviver = e;
+  }
+  add(e) {
+    let t;
+    if (typeof e == "string") {
+      if (this.reconstructor) throw new Error("got plaintext data when reconstructing a packet");
+      t = this.decodeString(e);
+      const n = t.type === f.BINARY_EVENT;
+      n || t.type === f.BINARY_ACK ? (t.type = n ? f.EVENT : f.ACK, this.reconstructor = new Tt(t), t.attachments === 0 && super.emitReserved("decoded", t)) : super.emitReserved("decoded", t);
+    } else {
+      if (!ce(e) && !e.base64) throw new Error("Unknown type: " + e);
+      if (!this.reconstructor) throw new Error("got binary data when not reconstructing a packet");
+      t = this.reconstructor.takeBinaryData(e), t && (this.reconstructor = null, super.emitReserved("decoded", t));
+    }
+  }
+  decodeString(e) {
+    let t = 0;
+    const n = { type: Number(e.charAt(0)) };
+    if (f[n.type] === void 0) throw new Error("unknown packet type " + n.type);
+    if (n.type === f.BINARY_EVENT || n.type === f.BINARY_ACK) {
+      const i = t + 1;
+      for (; e.charAt(++t) !== "-" && t != e.length; ) ;
+      const o = e.substring(i, t);
+      if (o != Number(o) || e.charAt(t) !== "-") throw new Error("Illegal attachments");
+      n.attachments = Number(o);
+    }
+    if (e.charAt(t + 1) === "/") {
+      const i = t + 1;
+      for (; ++t && !(e.charAt(t) === "," || t === e.length); )
+        ;
+      n.nsp = e.substring(i, t);
+    } else n.nsp = "/";
+    const r = e.charAt(t + 1);
+    if (r !== "" && Number(r) == r) {
+      const i = t + 1;
+      for (; ++t; ) {
+        const o = e.charAt(t);
+        if (o == null || Number(o) != o) {
+          --t;
+          break;
+        }
+        if (t === e.length) break;
+      }
+      n.id = Number(e.substring(i, t + 1));
+    }
+    if (e.charAt(++t)) {
+      const i = this.tryParse(e.substr(t));
+      if (!he.isPayloadValid(n.type, i)) throw new Error("invalid payload");
+      n.data = i;
+    }
+    return n;
+  }
+  tryParse(e) {
+    try {
+      return JSON.parse(e, this.reviver);
+    } catch (t) {
+      return !1;
+    }
+  }
+  static isPayloadValid(e, t) {
+    switch (e) {
+      case f.CONNECT:
+        return _e(t);
+      case f.DISCONNECT:
+        return t === void 0;
+      case f.CONNECT_ERROR:
+        return typeof t == "string" || _e(t);
+      case f.EVENT:
+      case f.BINARY_EVENT:
+        return Array.isArray(t) && (typeof t[0] == "number" || typeof t[0] == "string" && St.indexOf(t[0]) === -1);
+      case f.ACK:
+      case f.BINARY_ACK:
+        return Array.isArray(t);
+    }
+  }
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class Tt {
+  constructor(e) {
+    this.packet = e, this.buffers = [], this.reconPack = e;
+  }
+  takeBinaryData(e) {
+    if (this.buffers.push(e), this.buffers.length === this.reconPack.attachments) {
+      const t = At(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), t;
+    }
+    return null;
+  }
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+const xt = Object.freeze(Object.defineProperty({ __proto__: null, Decoder: he, Encoder: class {
+  constructor(s) {
+    this.replacer = s;
+  }
+  encode(s) {
+    return s.type !== f.EVENT && s.type !== f.ACK || !$(s) ? [this.encodeAsString(s)] : this.encodeAsBinary({ type: s.type === f.EVENT ? f.BINARY_EVENT : f.BINARY_ACK, nsp: s.nsp, data: s.data, id: s.id });
+  }
+  encodeAsString(s) {
+    let e = "" + s.type;
+    return s.type !== f.BINARY_EVENT && s.type !== f.BINARY_ACK || (e += s.attachments + "-"), s.nsp && s.nsp !== "/" && (e += s.nsp + ","), s.id != null && (e += s.id), s.data != null && (e += JSON.stringify(s.data, this.replacer)), e;
+  }
+  encodeAsBinary(s) {
+    const e = Rt(s), t = this.encodeAsString(e.packet), n = e.buffers;
+    return n.unshift(t), n;
+  }
+}, get PacketType() {
+  return f;
+}, protocol: 5 }, Symbol.toStringTag, { value: "Module" }));
+function E(s, e, t) {
+  return s.on(e, t), function() {
+    s.off(e, t);
+  };
+}
+const Ct = Object.freeze({ connect: 1, connect_error: 1, disconnect: 1, disconnecting: 1, newListener: 1, removeListener: 1 });
+class $e extends y {
+  constructor(e, t, n) {
+    super(), this.connected = !1, this.recovered = !1, this.receiveBuffer = [], this.sendBuffer = [], this._queue = [], this._queueSeq = 0, this.ids = 0, this.acks = {}, this.flags = {}, this.io = e, this.nsp = t, n && n.auth && (this.auth = n.auth), this._opts = Object.assign({}, n), this.io._autoConnect && this.open();
+  }
+  get disconnected() {
+    return !this.connected;
+  }
+  subEvents() {
+    if (this.subs) return;
+    const e = this.io;
+    this.subs = [E(e, "open", this.onopen.bind(this)), E(e, "packet", this.onpacket.bind(this)), E(e, "error", this.onerror.bind(this)), E(e, "close", this.onclose.bind(this))];
+  }
+  get active() {
+    return !!this.subs;
+  }
+  connect() {
+    return this.connected || (this.subEvents(), this.io._reconnecting || this.io.open(), this.io._readyState === "open" && this.onopen()), this;
+  }
+  open() {
+    return this.connect();
+  }
+  send(...e) {
+    return e.unshift("message"), this.emit.apply(this, e), this;
+  }
+  emit(e, ...t) {
+    var n, r, i;
+    if (Ct.hasOwnProperty(e)) throw new Error('"' + e.toString() + '" is a reserved event name');
+    if (t.unshift(e), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) return this._addToQueue(t), this;
+    const o = { type: f.EVENT, data: t, options: {} };
+    if (o.options.compress = this.flags.compress !== !1, typeof t[t.length - 1] == "function") {
+      const h = this.ids++, u = t.pop();
+      this._registerAckCallback(h, u), o.id = h;
+    }
+    const a = (r = (n = this.io.engine) === null || n === void 0 ? void 0 : n.transport) === null || r === void 0 ? void 0 : r.writable, c = this.connected && !(!((i = this.io.engine) === null || i === void 0) && i._hasPingExpired());
+    return this.flags.volatile && !a || (c ? (this.notifyOutgoingListeners(o), this.packet(o)) : this.sendBuffer.push(o)), this.flags = {}, this;
+  }
+  _registerAckCallback(e, t) {
+    var n;
+    const r = (n = this.flags.timeout) !== null && n !== void 0 ? n : this._opts.ackTimeout;
+    if (r === void 0) return void (this.acks[e] = t);
+    const i = this.io.setTimeoutFn(() => {
+      delete this.acks[e];
+      for (let a = 0; a < this.sendBuffer.length; a++) this.sendBuffer[a].id === e && this.sendBuffer.splice(a, 1);
+      t.call(this, new Error("operation has timed out"));
+    }, r), o = (...a) => {
+      this.io.clearTimeoutFn(i), t.apply(this, a);
+    };
+    o.withError = !0, this.acks[e] = o;
+  }
+  emitWithAck(e, ...t) {
+    return new Promise((n, r) => {
+      const i = (o, a) => o ? r(o) : n(a);
+      i.withError = !0, t.push(i), this.emit(e, ...t);
+    });
+  }
+  _addToQueue(e) {
+    let t;
+    typeof e[e.length - 1] == "function" && (t = e.pop());
+    const n = { id: this._queueSeq++, tryCount: 0, pending: !1, args: e, flags: Object.assign({ fromQueue: !0 }, this.flags) };
+    e.push((r, ...i) => {
+      if (n === this._queue[0])
+        return r !== null ? n.tryCount > this._opts.retries && (this._queue.shift(), t && t(r)) : (this._queue.shift(), t && t(null, ...i)), n.pending = !1, this._drainQueue();
+    }), this._queue.push(n), this._drainQueue();
+  }
+  _drainQueue(e = !1) {
+    if (!this.connected || this._queue.length === 0) return;
+    const t = this._queue[0];
+    t.pending && !e || (t.pending = !0, t.tryCount++, this.flags = t.flags, this.emit.apply(this, t.args));
+  }
+  packet(e) {
+    e.nsp = this.nsp, this.io._packet(e);
+  }
+  onopen() {
+    typeof this.auth == "function" ? this.auth((e) => {
+      this._sendConnectPacket(e);
+    }) : this._sendConnectPacket(this.auth);
+  }
+  _sendConnectPacket(e) {
+    this.packet({ type: f.CONNECT, data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, e) : e });
+  }
+  onerror(e) {
+    this.connected || this.emitReserved("connect_error", e);
+  }
+  onclose(e, t) {
+    this.connected = !1, delete this.id, this.emitReserved("disconnect", e, t), this._clearAcks();
+  }
+  _clearAcks() {
+    Object.keys(this.acks).forEach((e) => {
+      if (!this.sendBuffer.some((t) => String(t.id) === e)) {
+        const t = this.acks[e];
+        delete this.acks[e], t.withError && t.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+  onpacket(e) {
+    if (e.nsp === this.nsp) switch (e.type) {
+      case f.CONNECT:
+        e.data && e.data.sid ? this.onconnect(e.data.sid, e.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+        break;
+      case f.EVENT:
+      case f.BINARY_EVENT:
+        this.onevent(e);
+        break;
+      case f.ACK:
+      case f.BINARY_ACK:
+        this.onack(e);
+        break;
+      case f.DISCONNECT:
+        this.ondisconnect();
+        break;
+      case f.CONNECT_ERROR:
+        this.destroy();
+        const t = new Error(e.data.message);
+        t.data = e.data.data, this.emitReserved("connect_error", t);
+    }
+  }
+  onevent(e) {
+    const t = e.data || [];
+    e.id != null && t.push(this.ack(e.id)), this.connected ? this.emitEvent(t) : this.receiveBuffer.push(Object.freeze(t));
+  }
+  emitEvent(e) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const t = this._anyListeners.slice();
+      for (const n of t) n.apply(this, e);
+    }
+    super.emit.apply(this, e), this._pid && e.length && typeof e[e.length - 1] == "string" && (this._lastOffset = e[e.length - 1]);
+  }
+  ack(e) {
+    const t = this;
+    let n = !1;
+    return function(...r) {
+      n || (n = !0, t.packet({ type: f.ACK, id: e, data: r }));
+    };
+  }
+  onack(e) {
+    const t = this.acks[e.id];
+    typeof t == "function" && (delete this.acks[e.id], t.withError && e.data.unshift(null), t.apply(this, e.data));
+  }
+  onconnect(e, t) {
+    this.id = e, this.recovered = t && this._pid === t, this._pid = t, this.connected = !0, this.emitBuffered(), this.emitReserved("connect"), this._drainQueue(!0);
+  }
+  emitBuffered() {
+    this.receiveBuffer.forEach((e) => this.emitEvent(e)), this.receiveBuffer = [], this.sendBuffer.forEach((e) => {
+      this.notifyOutgoingListeners(e), this.packet(e);
+    }), this.sendBuffer = [];
+  }
+  ondisconnect() {
+    this.destroy(), this.onclose("io server disconnect");
+  }
+  destroy() {
+    this.subs && (this.subs.forEach((e) => e()), this.subs = void 0), this.io._destroy(this);
+  }
+  disconnect() {
+    return this.connected && this.packet({ type: f.DISCONNECT }), this.destroy(), this.connected && this.onclose("io client disconnect"), this;
+  }
+  close() {
+    return this.disconnect();
+  }
+  compress(e) {
+    return this.flags.compress = e, this;
+  }
+  get volatile() {
+    return this.flags.volatile = !0, this;
+  }
+  timeout(e) {
+    return this.flags.timeout = e, this;
+  }
+  onAny(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(e), this;
+  }
+  prependAny(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(e), this;
+  }
+  offAny(e) {
+    if (!this._anyListeners) return this;
+    if (e) {
+      const t = this._anyListeners;
+      for (let n = 0; n < t.length; n++) if (e === t[n]) return t.splice(n, 1), this;
+    } else this._anyListeners = [];
+    return this;
+  }
+  listenersAny() {
+    return this._anyListeners || [];
+  }
+  onAnyOutgoing(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(e), this;
+  }
+  prependAnyOutgoing(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(e), this;
+  }
+  offAnyOutgoing(e) {
+    if (!this._anyOutgoingListeners) return this;
+    if (e) {
+      const t = this._anyOutgoingListeners;
+      for (let n = 0; n < t.length; n++) if (e === t[n]) return t.splice(n, 1), this;
+    } else this._anyOutgoingListeners = [];
+    return this;
+  }
+  listenersAnyOutgoing() {
+    return this._anyOutgoingListeners || [];
+  }
+  notifyOutgoingListeners(e) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const t = this._anyOutgoingListeners.slice();
+      for (const n of t) n.apply(this, e.data);
+    }
+  }
+}
+function x(s) {
+  s = s || {}, this.ms = s.min || 100, this.max = s.max || 1e4, this.factor = s.factor || 2, this.jitter = s.jitter > 0 && s.jitter <= 1 ? s.jitter : 0, this.attempts = 0;
+}
+x.prototype.duration = function() {
+  var s = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var e = Math.random(), t = Math.floor(e * this.jitter * s);
+    s = 1 & Math.floor(10 * e) ? s + t : s - t;
+  }
+  return 0 | Math.min(s, this.max);
+}, x.prototype.reset = function() {
+  this.attempts = 0;
+}, x.prototype.setMin = function(s) {
+  this.ms = s;
+}, x.prototype.setMax = function(s) {
+  this.max = s;
+}, x.prototype.setJitter = function(s) {
+  this.jitter = s;
+};
+class ne extends y {
+  constructor(e, t) {
+    var n;
+    super(), this.nsps = {}, this.subs = [], e && typeof e == "object" && (t = e, e = void 0), (t = t || {}).path = t.path || "/socket.io", this.opts = t, H(this, t), this.reconnection(t.reconnection !== !1), this.reconnectionAttempts(t.reconnectionAttempts || 1 / 0), this.reconnectionDelay(t.reconnectionDelay || 1e3), this.reconnectionDelayMax(t.reconnectionDelayMax || 5e3), this.randomizationFactor((n = t.randomizationFactor) !== null && n !== void 0 ? n : 0.5), this.backoff = new x({ min: this.reconnectionDelay(), max: this.reconnectionDelayMax(), jitter: this.randomizationFactor() }), this.timeout(t.timeout == null ? 2e4 : t.timeout), this._readyState = "closed", this.uri = e;
+    const r = t.parser || xt;
+    this.encoder = new r.Encoder(), this.decoder = new r.Decoder(), this._autoConnect = t.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(e) {
+    return arguments.length ? (this._reconnection = !!e, e || (this.skipReconnect = !0), this) : this._reconnection;
+  }
+  reconnectionAttempts(e) {
+    return e === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = e, this);
+  }
+  reconnectionDelay(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = e, (t = this.backoff) === null || t === void 0 || t.setMin(e), this);
+  }
+  randomizationFactor(e) {
+    var t;
+    return e === void 0 ? this._randomizationFactor : (this._randomizationFactor = e, (t = this.backoff) === null || t === void 0 || t.setJitter(e), this);
+  }
+  reconnectionDelayMax(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = e, (t = this.backoff) === null || t === void 0 || t.setMax(e), this);
+  }
+  timeout(e) {
+    return arguments.length ? (this._timeout = e, this) : this._timeout;
+  }
+  maybeReconnectOnOpen() {
+    !this._reconnecting && this._reconnection && this.backoff.attempts === 0 && this.reconnect();
+  }
+  open(e) {
+    if (~this._readyState.indexOf("open")) return this;
+    this.engine = new _t(this.uri, this.opts);
+    const t = this.engine, n = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const r = E(t, "open", function() {
+      n.onopen(), e && e();
+    }), i = (a) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", a), e ? e(a) : this.maybeReconnectOnOpen();
+    }, o = E(t, "error", i);
+    if (this._timeout !== !1) {
+      const a = this._timeout, c = this.setTimeoutFn(() => {
+        r(), i(new Error("timeout")), t.close();
+      }, a);
+      this.opts.autoUnref && c.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(c);
+      });
+    }
+    return this.subs.push(r), this.subs.push(o), this;
+  }
+  connect(e) {
+    return this.open(e);
+  }
+  onopen() {
+    this.cleanup(), this._readyState = "open", this.emitReserved("open");
+    const e = this.engine;
+    this.subs.push(E(e, "ping", this.onping.bind(this)), E(e, "data", this.ondata.bind(this)), E(e, "error", this.onerror.bind(this)), E(e, "close", this.onclose.bind(this)), E(this.decoder, "decoded", this.ondecoded.bind(this)));
+  }
+  onping() {
+    this.emitReserved("ping");
+  }
+  ondata(e) {
+    try {
+      this.decoder.add(e);
+    } catch (t) {
+      this.onclose("parse error", t);
+    }
+  }
+  ondecoded(e) {
+    W(() => {
+      this.emitReserved("packet", e);
+    }, this.setTimeoutFn);
+  }
+  onerror(e) {
+    this.emitReserved("error", e);
+  }
+  socket(e, t) {
+    let n = this.nsps[e];
+    return n ? this._autoConnect && !n.active && n.connect() : (n = new $e(this, e, t), this.nsps[e] = n), n;
+  }
+  _destroy(e) {
+    const t = Object.keys(this.nsps);
+    for (const n of t)
+      if (this.nsps[n].active) return;
+    this._close();
+  }
+  _packet(e) {
+    const t = this.encoder.encode(e);
+    for (let n = 0; n < t.length; n++) this.engine.write(t[n], e.options);
+  }
+  cleanup() {
+    this.subs.forEach((e) => e()), this.subs.length = 0, this.decoder.destroy();
+  }
+  _close() {
+    this.skipReconnect = !0, this._reconnecting = !1, this.onclose("forced close");
+  }
+  disconnect() {
+    return this._close();
+  }
+  onclose(e, t) {
+    var n;
+    this.cleanup(), (n = this.engine) === null || n === void 0 || n.close(), this.backoff.reset(), this._readyState = "closed", this.emitReserved("close", e, t), this._reconnection && !this.skipReconnect && this.reconnect();
+  }
+  reconnect() {
+    if (this._reconnecting || this.skipReconnect) return this;
+    const e = this;
+    if (this.backoff.attempts >= this._reconnectionAttempts) this.backoff.reset(), this.emitReserved("reconnect_failed"), this._reconnecting = !1;
+    else {
+      const t = this.backoff.duration();
+      this._reconnecting = !0;
+      const n = this.setTimeoutFn(() => {
+        e.skipReconnect || (this.emitReserved("reconnect_attempt", e.backoff.attempts), e.skipReconnect || e.open((r) => {
+          r ? (e._reconnecting = !1, e.reconnect(), this.emitReserved("reconnect_error", r)) : e.onreconnect();
+        }));
+      }, t);
+      this.opts.autoUnref && n.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(n);
+      });
+    }
+  }
+  onreconnect() {
+    const e = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", e);
+  }
+}
+const N = {};
+function F(s, e) {
+  typeof s == "object" && (e = s, s = void 0);
+  const t = function(c, h = "", u) {
+    let l = c;
+    u = u || typeof location != "undefined" && location, c == null && (c = u.protocol + "//" + u.host), typeof c == "string" && (c.charAt(0) === "/" && (c = c.charAt(1) === "/" ? u.protocol + c : u.host + c), /^(https?|wss?):\/\//.test(c) || (c = u !== void 0 ? u.protocol + "//" + c : "https://" + c), l = Z(c)), l.port || (/^(http|ws)$/.test(l.protocol) ? l.port = "80" : /^(http|ws)s$/.test(l.protocol) && (l.port = "443")), l.path = l.path || "/";
+    const d = l.host.indexOf(":") !== -1 ? "[" + l.host + "]" : l.host;
+    return l.id = l.protocol + "://" + d + ":" + l.port + h, l.href = l.protocol + "://" + d + (u && u.port === l.port ? "" : ":" + l.port), l;
+  }(s, (e = e || {}).path || "/socket.io"), n = t.source, r = t.id, i = t.path, o = N[r] && i in N[r].nsps;
+  let a;
+  return e.forceNew || e["force new connection"] || e.multiplex === !1 || o ? a = new ne(n, e) : (N[r] || (N[r] = new ne(n, e)), a = N[r]), t.query && !e.query && (e.query = t.queryKey), a.socket(t.path, e);
+}
+Object.assign(F, { Manager: ne, Socket: $e, io: F, connect: F });
+class Ot {
+  constructor(e) {
+    b(this, "socket");
+    b(this, "encode");
+    var t;
+    this.socket = F(e.baseUrl, { transports: ["websocket"], path: "/analytics/ws", auth: { token: e.authToken }, query: e.query }), this.encode = (t = e.encoder) != null ? t : (n) => function(r) {
+      const i = new TextEncoder().encode(r);
+      if (typeof window != "undefined" && typeof window.btoa == "function") {
+        const o = Array.from(i, (a) => String.fromCharCode(a)).join("");
+        return btoa(o);
+      }
+      if (typeof Buffer != "undefined") return Buffer.from(i).toString("base64");
+      throw new Error("[utils.base64Encode]: Unsupported environment");
+    }(JSON.stringify(n));
+  }
+  send(e, t) {
+    this.socket.emit(e, this.encode(t));
+  }
+}
+class Nt {
+  constructor(e) {
+    b(this, "options");
+    b(this, "client");
+    b(this, "userId");
+    b(this, "global");
+    b(this, "queue", []);
+    this.options = e;
+    const t = { sdk_name: e.sdk || "node", sdk_version: e.sdkVersion || "" };
+    this.client = new Ot({ baseUrl: e.apiUrl || "https://analytic.brainfi.sh", authToken: e.accessKey, query: t });
+  }
+  init() {
+  }
+  ready() {
+    this.options.waitForUser = !1, this.flush();
+  }
+  send(e) {
+    return p(this, null, function* () {
+      return this.options.disabled || this.options.filter && !this.options.filter(e) ? Promise.resolve() : this.options.waitForUser && !this.userId ? (this.queue.push(e), Promise.resolve()) : this.client.send("t", e);
+    });
+  }
+  setGlobalProperties(e) {
+    this.global = v(v({}, this.global), e);
+  }
+  track(e, t) {
+    return p(this, null, function* () {
+      var n, r;
+      return this.send({ type: "event.track", payload: { name: e, userId: (n = t == null ? void 0 : t.userId) != null ? n : this.userId, properties: v(v({}, (r = this.global) != null ? r : {}), t != null ? t : {}) } });
+    });
+  }
+  identify(e) {
+    return p(this, null, function* () {
+      if (e.userId && (this.userId = e.userId, this.flush()), Object.keys(e).length > 1) return this.send({ type: "user.identify", payload: O(v({}, e), { properties: v(v({}, this.global), e.properties) }) });
+    });
+  }
+  record(e) {
+    return p(this, null, function* () {
+      return this.send({ type: "event.record", payload: { events: e, userId: this.userId } });
+    });
+  }
+  alias(e) {
+    return p(this, null, function* () {
+      return this.send({ type: "user.alias", payload: e });
+    });
+  }
+  increment(e) {
+    return p(this, null, function* () {
+      return this.send({ type: "user.increment", payload: e });
+    });
+  }
+  decrement(e) {
+    return p(this, null, function* () {
+      return this.send({ type: "user.decrement", payload: e });
+    });
+  }
+  clear() {
+    this.userId = void 0;
+  }
+  flush() {
+    this.queue.forEach((e) => {
+      var t;
+      this.send(O(v({}, e), { payload: O(v({}, e.payload), { userId: (t = e.payload.userId) != null ? t : this.userId }) }));
+    }), this.queue = [];
+  }
+}
+const Lt = /* @__PURE__ */ (() => {
+  let s = 0;
+  return () => (s += 1, `u${`0000${(Math.random() * fe(36, 4) | 0).toString(36)}`.slice(-4)}${s}`);
+})();
+function S(s) {
+  const e = [];
+  for (let t = 0, n = s.length; t < n; t++) e.push(s[t]);
+  return e;
+}
+function q(s, e) {
+  const t = (s.ownerDocument.defaultView || window).getComputedStyle(s).getPropertyValue(e);
+  return t ? parseFloat(t.replace("px", "")) : 0;
+}
+function Fe(s, e = {}) {
+  return { width: e.width || function(t) {
+    const n = q(t, "border-left-width"), r = q(t, "border-right-width");
+    return t.clientWidth + n + r;
+  }(s), height: e.height || function(t) {
+    const n = q(t, "border-top-width"), r = q(t, "border-bottom-width");
+    return t.clientHeight + n + r;
+  }(s) };
+}
+const _ = 16384;
+function M(s) {
+  return new Promise((e, t) => {
+    const n = new Image();
+    n.decode = () => e(n), n.onload = () => e(n), n.onerror = t, n.crossOrigin = "anonymous", n.decoding = "async", n.src = s;
+  });
+}
+function Pt(s, e, t) {
+  return p(this, null, function* () {
+    const n = "http://www.w3.org/2000/svg", r = document.createElementNS(n, "svg"), i = document.createElementNS(n, "foreignObject");
+    return r.setAttribute("width", `${e}`), r.setAttribute("height", `${t}`), r.setAttribute("viewBox", `0 0 ${e} ${t}`), i.setAttribute("width", "100%"), i.setAttribute("height", "100%"), i.setAttribute("x", "0"), i.setAttribute("y", "0"), i.setAttribute("externalResourcesRequired", "true"), r.appendChild(i), i.appendChild(s), function(o) {
+      return p(this, null, function* () {
+        return Promise.resolve().then(() => new XMLSerializer().serializeToString(o)).then(encodeURIComponent).then((a) => `data:image/svg+xml;charset=utf-8,${a}`);
+      });
+    }(r);
+  });
+}
+const w = (s, e) => {
+  if (s instanceof e) return !0;
+  const t = Object.getPrototypeOf(s);
+  return t !== null && (t.constructor.name === e.name || w(t, e));
+};
+function Bt(s, e, t) {
+  const n = `.${s}:${e}`, r = t.cssText ? function(i) {
+    const o = i.getPropertyValue("content");
+    return `${i.cssText} content: '${o.replace(/'|"/g, "")}';`;
+  }(t) : function(i) {
+    return S(i).map((o) => `${o}: ${i.getPropertyValue(o)}${i.getPropertyPriority(o) ? " !important" : ""};`).join(" ");
+  }(t);
+  return document.createTextNode(`${n}{${r}}`);
+}
+function ve(s, e, t) {
+  const n = window.getComputedStyle(s, t), r = n.getPropertyValue("content");
+  if (r === "" || r === "none") return;
+  const i = Lt();
+  try {
+    e.className = `${e.className} ${i}`;
+  } catch (a) {
+    return;
+  }
+  const o = document.createElement("style");
+  o.appendChild(Bt(i, t, n)), e.appendChild(o);
+}
+const ke = "application/font-woff", Ee = "image/jpeg", It = { woff: ke, woff2: ke, ttf: "application/font-truetype", eot: "application/vnd.ms-fontobject", png: "image/png", jpg: Ee, jpeg: Ee, gif: "image/gif", tiff: "image/tiff", svg: "image/svg+xml", webp: "image/webp" };
+function ue(s) {
+  const e = function(t) {
+    const n = /\.([^./]*?)$/g.exec(t);
+    return n ? n[1] : "";
+  }(s).toLowerCase();
+  return It[e] || "";
+}
+function re(s) {
+  return s.search(/^(data:)/) !== -1;
+}
+function Me(s, e, t) {
+  return p(this, null, function* () {
+    const n = yield fetch(s, e);
+    if (n.status === 404) throw new Error(`Resource "${n.url}" not found`);
+    const r = yield n.blob();
+    return new Promise((i, o) => {
+      const a = new FileReader();
+      a.onerror = o, a.onloadend = () => {
+        try {
+          i(t({ res: n, result: a.result }));
+        } catch (c) {
+          o(c);
+        }
+      }, a.readAsDataURL(r);
+    });
+  });
+}
+const J = {};
+function le(s, e, t) {
+  return p(this, null, function* () {
+    const n = function(i, o, a) {
+      let c = i.replace(/\?.*/, "");
+      return a && (c = i), /ttf|otf|eot|woff2?/i.test(c) && (c = c.replace(/.*\//, "")), o ? `[${o}]${c}` : c;
+    }(s, e, t.includeQueryParams);
+    if (J[n] != null) return J[n];
+    let r;
+    t.cacheBust && (s += (/\?/.test(s) ? "&" : "?") + (/* @__PURE__ */ new Date()).getTime());
+    try {
+      const i = yield Me(s, t.fetchRequestInit, ({ res: o, result: a }) => (e || (e = o.headers.get("Content-Type") || ""), function(c) {
+        return c.split(/,/)[1];
+      }(a)));
+      r = function(o, a) {
+        return `data:${a};base64,${o}`;
+      }(i, e);
+    } catch (i) {
+      r = t.imagePlaceholder || "";
+      let o = `Failed to fetch resource: ${s}`;
+      i && (o = typeof i == "string" ? i : i.message), o && console.warn(o);
+    }
+    return J[n] = r, r;
+  });
+}
+function qt(s, e) {
+  return p(this, null, function* () {
+    return w(s, HTMLCanvasElement) ? function(t) {
+      return p(this, null, function* () {
+        const n = t.toDataURL();
+        return n === "data:," ? t.cloneNode(!1) : M(n);
+      });
+    }(s) : w(s, HTMLVideoElement) ? function(t, n) {
+      return p(this, null, function* () {
+        if (t.currentSrc) {
+          const o = document.createElement("canvas"), a = o.getContext("2d");
+          return o.width = t.clientWidth, o.height = t.clientHeight, a == null || a.drawImage(t, 0, 0, o.width, o.height), M(o.toDataURL());
+        }
+        const r = t.poster, i = ue(r);
+        return M(yield le(r, i, n));
+      });
+    }(s, e) : w(s, HTMLIFrameElement) ? function(t) {
+      return p(this, null, function* () {
+        var n;
+        try {
+          if (!((n = t == null ? void 0 : t.contentDocument) === null || n === void 0) && n.body) return yield V(t.contentDocument.body, {}, !0);
+        } catch (r) {
+        }
+        return t.cloneNode(!1);
+      });
+    }(s) : s.cloneNode(!1);
+  });
+}
+const jt = (s) => s.tagName != null && s.tagName.toUpperCase() === "SLOT";
+function Ut(s, e) {
+  return w(e, Element) && (function(t, n) {
+    const r = n.style;
+    if (!r) return;
+    const i = window.getComputedStyle(t);
+    i.cssText ? (r.cssText = i.cssText, r.transformOrigin = i.transformOrigin) : S(i).forEach((o) => {
+      let a = i.getPropertyValue(o);
+      o === "font-size" && a.endsWith("px") && (a = `${Math.floor(parseFloat(a.substring(0, a.length - 2))) - 0.1}px`), w(t, HTMLIFrameElement) && o === "display" && a === "inline" && (a = "block"), o === "d" && n.getAttribute("d") && (a = `path(${n.getAttribute("d")})`), r.setProperty(o, a, i.getPropertyPriority(o));
+    });
+  }(s, e), function(t, n) {
+    ve(t, n, ":before"), ve(t, n, ":after");
+  }(s, e), function(t, n) {
+    w(t, HTMLTextAreaElement) && (n.innerHTML = t.value), w(t, HTMLInputElement) && n.setAttribute("value", t.value);
+  }(s, e), function(t, n) {
+    if (w(t, HTMLSelectElement)) {
+      const r = n, i = Array.from(r.children).find((o) => t.value === o.getAttribute("value"));
+      i && i.setAttribute("selected", "");
+    }
+  }(s, e)), e;
+}
+function V(s, e, t) {
+  return p(this, null, function* () {
+    return t || !e.filter || e.filter(s) ? Promise.resolve(s).then((n) => qt(n, e)).then((n) => function(r, i, o) {
+      return p(this, null, function* () {
+        var a, c;
+        let h = [];
+        return h = jt(r) && r.assignedNodes ? S(r.assignedNodes()) : w(r, HTMLIFrameElement) && (!((a = r.contentDocument) === null || a === void 0) && a.body) ? S(r.contentDocument.body.childNodes) : S(((c = r.shadowRoot) !== null && c !== void 0 ? c : r).childNodes), h.length === 0 || w(r, HTMLVideoElement) || (yield h.reduce((u, l) => u.then(() => V(l, o)).then((d) => {
+          d && i.appendChild(d);
+        }), Promise.resolve())), i;
+      });
+    }(s, n, e)).then((n) => Ut(s, n)).then((n) => function(r, i) {
+      return p(this, null, function* () {
+        const o = r.querySelectorAll ? r.querySelectorAll("use") : [];
+        if (o.length === 0) return r;
+        const a = {};
+        for (let h = 0; h < o.length; h++) {
+          const u = o[h].getAttribute("xlink:href");
+          if (u) {
+            const l = r.querySelector(u), d = document.querySelector(u);
+            l || !d || a[u] || (a[u] = yield V(d, i, !0));
+          }
+        }
+        const c = Object.values(a);
+        if (c.length) {
+          const h = "http://www.w3.org/1999/xhtml", u = document.createElementNS(h, "svg");
+          u.setAttribute("xmlns", h), u.style.position = "absolute", u.style.width = "0", u.style.height = "0", u.style.overflow = "hidden", u.style.display = "none";
+          const l = document.createElementNS(h, "defs");
+          u.appendChild(l);
+          for (let d = 0; d < c.length; d++) l.appendChild(c[d]);
+          r.appendChild(u);
+        }
+        return r;
+      });
+    }(n, e)) : null;
+  });
+}
+const Ve = /url\((['"]?)([^'"]+?)\1\)/g, Dt = /url\([^)]+\)\s*format\((["']?)([^"']+)\1\)/g, $t = /src:\s*(?:url\([^)]+\)\s*format\([^)]+\)[,;]\s*)+/g;
+function Ft(s, e, t, n, r) {
+  return p(this, null, function* () {
+    try {
+      const i = t ? function(c, h) {
+        if (c.match(/^[a-z]+:\/\//i)) return c;
+        if (c.match(/^\/\//)) return window.location.protocol + c;
+        if (c.match(/^[a-z]+:/i)) return c;
+        const u = document.implementation.createHTMLDocument(), l = u.createElement("base"), d = u.createElement("a");
+        return u.head.appendChild(l), u.body.appendChild(d), h && (l.href = h), d.href = c, d.href;
+      }(e, t) : e, o = ue(e);
+      let a;
+      return r || (a = yield le(i, o, n)), s.replace(function(c) {
+        const h = c.replace(/([.*+?^${}()|\[\]\/\\])/g, "\\$1");
+        return new RegExp(`(url\\(['"]?)(${h})(['"]?\\))`, "g");
+      }(e), `$1${a}$3`);
+    } catch (i) {
+    }
+    return s;
+  });
+}
+function We(s) {
+  return s.search(Ve) !== -1;
+}
+function He(s, e, t) {
+  return p(this, null, function* () {
+    if (!We(s)) return s;
+    const n = function(i, { preferredFontFormat: o }) {
+      return o ? i.replace($t, (a) => {
+        for (; ; ) {
+          const [c, , h] = Dt.exec(a) || [];
+          if (!h) return "";
+          if (h === o) return `src: ${c};`;
+        }
+      }) : i;
+    }(s, t);
+    return function(i) {
+      const o = [];
+      return i.replace(Ve, (a, c, h) => (o.push(h), a)), o.filter((a) => !re(a));
+    }(n).reduce((i, o) => i.then((a) => Ft(a, o, e, t)), Promise.resolve(n));
+  });
+}
+function j(s, e, t) {
+  return p(this, null, function* () {
+    var n;
+    const r = (n = e.style) === null || n === void 0 ? void 0 : n.getPropertyValue(s);
+    if (r) {
+      const i = yield He(r, null, t);
+      return e.style.setProperty(s, i, e.style.getPropertyPriority(s)), !0;
+    }
+    return !1;
+  });
+}
+function ze(s, e) {
+  return p(this, null, function* () {
+    w(s, Element) && (yield function(t, n) {
+      return p(this, null, function* () {
+        (yield j("background", t, n)) || (yield j("background-image", t, n)), (yield j("mask", t, n)) || (yield j("mask-image", t, n));
+      });
+    }(s, e), yield function(t, n) {
+      return p(this, null, function* () {
+        const r = w(t, HTMLImageElement);
+        if ((!r || re(t.src)) && (!w(t, SVGImageElement) || re(t.href.baseVal))) return;
+        const i = r ? t.src : t.href.baseVal, o = yield le(i, ue(i), n);
+        yield new Promise((a, c) => {
+          t.onload = a, t.onerror = c;
+          const h = t;
+          h.decode && (h.decode = a), h.loading === "lazy" && (h.loading = "eager"), r ? (t.srcset = "", t.src = o) : t.href.baseVal = o;
+        });
+      });
+    }(s, e), yield function(t, n) {
+      return p(this, null, function* () {
+        const r = S(t.childNodes).map((i) => ze(i, n));
+        yield Promise.all(r).then(() => t);
+      });
+    }(s, e));
+  });
+}
+const Re = {};
+function Ae(s) {
+  return p(this, null, function* () {
+    let e = Re[s];
+    if (e != null) return e;
+    const t = yield fetch(s);
+    return e = { url: s, cssText: yield t.text() }, Re[s] = e, e;
+  });
+}
+function Se(s, e) {
+  return p(this, null, function* () {
+    let t = s.cssText;
+    const n = /url\(["']?([^"')]+)["']?\)/g, r = (t.match(/url\([^)]+\)/g) || []).map((i) => p(this, null, function* () {
+      let o = i.replace(n, "$1");
+      return o.startsWith("https://") || (o = new URL(o, s.url).href), Me(o, e.fetchRequestInit, ({ result: a }) => (t = t.replace(i, `url(${a})`), [i, a]));
+    }));
+    return Promise.all(r).then(() => t);
+  });
+}
+function Te(s) {
+  if (s == null) return [];
+  const e = [];
+  let t = s.replace(/(\/\*[\s\S]*?\*\/)/gi, "");
+  const n = new RegExp("((@.*?keyframes [\\s\\S]*?){([\\s\\S]*?}\\s*?)})", "gi");
+  for (; ; ) {
+    const o = n.exec(t);
+    if (o === null) break;
+    e.push(o[0]);
+  }
+  t = t.replace(n, "");
+  const r = /@import[\s\S]*?url\([^)]*\)[\s\S]*?;/gi, i = new RegExp("((\\s*?(?:\\/\\*[\\s\\S]*?\\*\\/)?\\s*?@media[\\s\\S]*?){([\\s\\S]*?)}\\s*?})|(([\\s\\S]*?){([\\s\\S]*?)})", "gi");
+  for (; ; ) {
+    let o = r.exec(t);
+    if (o === null) {
+      if (o = i.exec(t), o === null) break;
+      r.lastIndex = i.lastIndex;
+    } else i.lastIndex = r.lastIndex;
+    e.push(o[0]);
+  }
+  return e;
+}
+function Mt(s, e) {
+  return p(this, null, function* () {
+    if (s.ownerDocument == null) throw new Error("Provided element is not within a Document");
+    const t = S(s.ownerDocument.styleSheets), n = yield function(r, i) {
+      return p(this, null, function* () {
+        const o = [], a = [];
+        return r.forEach((c) => {
+          if ("cssRules" in c) try {
+            S(c.cssRules || []).forEach((h, u) => {
+              if (h.type === CSSRule.IMPORT_RULE) {
+                let l = u + 1;
+                const d = Ae(h.href).then((m) => Se(m, i)).then((m) => Te(m).forEach((g) => {
+                  try {
+                    c.insertRule(g, g.startsWith("@import") ? l += 1 : c.cssRules.length);
+                  } catch (C) {
+                    console.error("Error inserting rule from remote css", { rule: g, error: C });
+                  }
+                })).catch((m) => {
+                  console.error("Error loading remote css", m.toString());
+                });
+                a.push(d);
+              }
+            });
+          } catch (h) {
+            const u = r.find((l) => l.href == null) || document.styleSheets[0];
+            c.href != null && a.push(Ae(c.href).then((l) => Se(l, i)).then((l) => Te(l).forEach((d) => {
+              u.insertRule(d, c.cssRules.length);
+            })).catch((l) => {
+              console.error("Error loading remote stylesheet", l);
+            })), console.error("Error inlining remote css file", h);
+          }
+        }), Promise.all(a).then(() => (r.forEach((c) => {
+          if ("cssRules" in c) try {
+            S(c.cssRules || []).forEach((h) => {
+              o.push(h);
+            });
+          } catch (h) {
+            console.error(`Error while reading CSS rules from ${c.href}`, h);
+          }
+        }), o));
+      });
+    }(t, e);
+    return function(r) {
+      return r.filter((i) => i.type === CSSRule.FONT_FACE_RULE).filter((i) => We(i.style.getPropertyValue("src")));
+    }(n);
+  });
+}
+function Vt(s, e) {
+  return p(this, null, function* () {
+    const t = e.fontEmbedCSS != null ? e.fontEmbedCSS : e.skipFonts ? null : yield function(n, r) {
+      return p(this, null, function* () {
+        const i = yield Mt(n, r);
+        return (yield Promise.all(i.map((o) => {
+          const a = o.parentStyleSheet ? o.parentStyleSheet.href : null;
+          return He(o.cssText, a, r);
+        }))).join(`
+`);
+      });
+    }(s, e);
+    if (t) {
+      const n = document.createElement("style"), r = document.createTextNode(t);
+      n.appendChild(r), s.firstChild ? s.insertBefore(n, s.firstChild) : s.appendChild(n);
+    }
+  });
+}
+function Wt(t) {
+  return p(this, arguments, function* (s, e = {}) {
+    const { width: n, height: r } = Fe(s, e), i = yield V(s, e, !0);
+    return yield Vt(i, e), yield ze(i, e), function(o, a) {
+      const { style: c } = o;
+      a.backgroundColor && (c.backgroundColor = a.backgroundColor), a.width && (c.width = `${a.width}px`), a.height && (c.height = `${a.height}px`);
+      const h = a.style;
+      h != null && Object.keys(h).forEach((u) => {
+        c[u] = h[u];
+      });
+    }(i, e), yield Pt(i, n, r);
+  });
+}
+function Ht(t) {
+  return p(this, arguments, function* (s, e = {}) {
+    const { width: n, height: r } = Fe(s, e), i = yield Wt(s, e), o = yield M(i), a = document.createElement("canvas"), c = a.getContext("2d"), h = e.pixelRatio || function() {
+      let d, m;
+      try {
+        m = process;
+      } catch (C) {
+      }
+      const g = m && m.env ? m.env.devicePixelRatio : null;
+      return g && (d = parseInt(g, 10), Number.isNaN(d) && (d = 1)), d || window.devicePixelRatio || 1;
+    }(), u = e.canvasWidth || n, l = e.canvasHeight || r;
+    return a.width = u * h, a.height = l * h, e.skipAutoScale || function(d) {
+      (d.width > _ || d.height > _) && (d.width > _ && d.height > _ ? d.width > d.height ? (d.height *= _ / d.width, d.width = _) : (d.width *= _ / d.height, d.height = _) : d.width > _ ? (d.height *= _ / d.width, d.width = _) : (d.width *= _ / d.height, d.height = _));
+    }(a), a.style.width = `${u}`, a.style.height = `${l}`, e.backgroundColor && (c.fillStyle = e.backgroundColor, c.fillRect(0, 0, a.width, a.height)), c.drawImage(o, 0, 0, a.width, a.height), a;
+  });
+}
+function zt(s) {
+  return p(this, null, function* () {
+    const e = document.documentElement.scrollHeight, t = document.documentElement.scrollWidth, n = Array.from(document.styleSheets).map((o) => {
+      try {
+        return Array.from(o.cssRules).map((a) => a.cssText).join("");
+      } catch (a) {
+        return console.log("Error accessing stylesheet rules:", a), "";
+      }
+    }).join(`
+`), r = document.createElement("style");
+    r.textContent = n, s.appendChild(r);
+    const i = yield function(c) {
+      return p(this, arguments, function* (o, a = {}) {
+        return (yield Ht(o, a)).toDataURL();
+      });
+    }(s, { quality: 0.7, width: t, height: e, style: { transform: "scale(1)" }, skipFonts: !0, cacheBust: !0, backgroundColor: "white", fetchRequestInit: { mode: "cors" } });
+    return s.removeChild(r), i;
+  });
+}
+const L = new RegExp("(((" + /(^|\.\s+)(dear|hi|hello|greetings|hey|hey there)/gi.source + ")|(" + /(thx|thanks|thank you|regards|best|[a-z]+ly|[a-z]+ regards|all the best|happy [a-z]+ing|take care|have a [a-z]+ (weekend|night|day))/gi.source + "\\s*[,.!]*))[\\s-]*)", "gi"), Q = new RegExp("( ?(([A-Z][a-z]+)|([A-Z]\\.)))+([,.]|[,.]?$)", "gm"), Kt = new RegExp("\\b(\\s*)(\\s*(" + (void 0)("|") + "))+\\b", "gim");
+class Yt {
+  constructor(e = "PERSON_NAME") {
+    this.replaceWith = e;
+  }
+  redact(e) {
+    L.lastIndex = 0, Q.lastIndex = 0;
+    let t = L.exec(e);
+    for (; t !== null; ) {
+      Q.lastIndex = L.lastIndex;
+      let n = Q.exec(e);
+      if (n !== null && n.index === L.lastIndex) {
+        let r = n[5] === null ? "" : n[5];
+        e = e.slice(0, n.index) + this.replaceWith + r + e.slice(n.index + n[0].length);
+      }
+      t = L.exec(e);
+    }
+    return e = e.replace(Kt, "$1" + this.replaceWith);
+  }
+}
+const Xt = new RegExp("(\\d+\\s*(\\w+ ){1,2}" + /(street|st|road|rd|avenue|ave|drive|dr|loop|court|ct|circle|cir|lane|ln|boulevard|blvd|way)\.?\b/gi.source + "(\\s+" + /(apt|bldg|dept|fl|hngr|lot|pier|rm|ste|slip|trlr|unit|#)\.? *[a-z0-9-]+\b/gi.source + ")?)|(" + /P\.? ?O\.? *Box +\d+/gi.source + ")", "gi"), xe = Object.freeze(Object.defineProperty({ __proto__: null, credentials: /(login( cred(ential)?s| info(rmation)?)?|cred(ential)?s) ?:\s*\S+\s+\/?\s*\S+/gi, creditCardNumber: /\d{4}[ -]?\d{4}[ -]?\d{4}[ -]?\d{4}|\d{4}[ -]?\d{6}[ -]?\d{4}\d?/g, digits: /\b\d{4,}\b/g, emailAddress: /([a-z0-9_\-.+]+)@\w+(\.\w+)*/gi, ipAddress: /(\d{1,3}(\.\d{1,3}){3}|[0-9A-F]{4}(:[0-9A-F]{4}){5}(::|(:0000)+))/gi, password: /(pass(word|phrase)?|secret): \S+/gi, phoneNumber: /(\(?\+?[0-9]{1,2}\)?[-. ]?)?(\(?[0-9]{3}\)?|[0-9]{3})[-. ]?([0-9]{3}[-. ]?[0-9]{4}|\b[A-Z0-9]{7}\b)/g, streetAddress: Xt, url: /([^\s:/?#]+):\/\/([^/?#\s]*)([^?#\s]*)(\?([^#\s]*))?(#([^\s]*))?/g, usSocialSecurityNumber: /\b\d{3}[ -.]\d{2}[ -.]\d{4}\b/g, username: /(user( ?name)?|login): \S+/gi, zipcode: /\b\d{5}\b(-\d{4})?\b/g }, Symbol.toStringTag, { value: "Module" }));
+function Ke(s) {
+  return s.replace(/[A-Z]/g, (e, t) => t !== 0 ? `_${e.toLowerCase()}` : e.toLowerCase());
+}
+class Ye {
+  constructor({ replaceWith: e = Ke("default").toUpperCase(), regexpPattern: t }) {
+    b(this, "regexpMatcher");
+    b(this, "replaceWith");
+    this.replaceWith = e, this.regexpMatcher = t;
+  }
+  redact(e) {
+    return e.replace(this.regexpMatcher, this.replaceWith);
+  }
+}
+function Ce(s) {
+  return s.regexpPattern !== void 0 ? new Ye({ regexpPattern: s.regexpPattern, replaceWith: s.replaceWith }) : s;
+}
+class Jt {
+  constructor(e) {
+    b(this, "childRedactors", []);
+    b(this, "redact", (e) => {
+      for (const t of this.childRedactors) e = t.redact(e);
+      return e;
+    });
+    this.childRedactors = function(t = {}) {
+      const n = [];
+      t.customRedactors && t.customRedactors.before && t.customRedactors.before.map(Ce).forEach((r) => n.push(r));
+      for (const r of Object.keys(xe)) t.builtInRedactors && t.builtInRedactors[r] && t.builtInRedactors[r].enabled === !1 || n.push(new Ye({ regexpPattern: xe[r], replaceWith: t.globalReplaceWith || Ke(r).toUpperCase() }));
+      return t.builtInRedactors && t.builtInRedactors.names && t.builtInRedactors.names.enabled === !1 || n.push(new Yt(t.globalReplaceWith)), t.customRedactors && t.customRedactors.after && t.customRedactors.after.map(Ce).forEach((r) => n.push(r)), n;
+    }(e);
+  }
+}
+const Qt = { before: [{ regexpPattern: /\b[A-Z]\d{7}\b/g, replaceWith: "PASSPORT_NUMBER" }, { regexpPattern: new RegExp("(?<=password: )(.*)", "gi"), replaceWith: "[REDACTED]" }] };
+function Gt(s) {
+  const e = document.createTreeWalker(s, NodeFilter.SHOW_TEXT, null);
+  let t;
+  for (; t = e.nextNode(); ) {
+    const r = t.nodeValue, i = (n = r, new Jt({ builtInRedactors: { names: { replaceWith: "ANONYMOUS_PERSON" } }, customRedactors: Qt }).redact(n));
+    r !== i && (t.nodeValue = i);
+  }
+  var n;
+  (function(r) {
+    Array.from(r.querySelectorAll('input[type="password"]')).forEach((o) => {
+      o.value = "[REDACTED]";
+    });
+  })(s);
+}
+const Zt = "0.0.4-alpha.16";
+class Xe extends Nt {
+  constructor(t) {
+    super(v({ sdk: "web", sdkVersion: Zt }, t));
+    b(this, "lastPath", "");
+    b(this, "debounceTimer", null);
+    this.options = t, this.isServer() || (this.setGlobalProperties({ __referrer: document.referrer }), this.options.trackOutgoingLinks && this.trackOutgoingLinks(), this.options.trackScreenViews && this.trackScreenViews(), this.options.trackAttributes && this.trackAttributes());
+  }
+  debounce(t, n) {
+    this.debounceTimer && clearTimeout(this.debounceTimer), this.debounceTimer = setTimeout(t, n);
+  }
+  isServer() {
+    return typeof document == "undefined";
+  }
+  trackOutgoingLinks() {
+    this.isServer() || document.addEventListener("click", (t) => {
+      const n = t.target, r = n.closest("a");
+      if (r && n) {
+        const i = r.getAttribute("href");
+        i != null && i.startsWith("http") && super.track("link_out", { href: i, text: r.innerText || r.getAttribute("title") || n.getAttribute("alt") || n.getAttribute("title") });
+      }
+    });
+  }
+  trackScreenViews() {
+    if (this.isServer()) return;
+    this.screenView();
+    const t = history.pushState;
+    history.pushState = function(...i) {
+      const o = t.apply(this, i);
+      return window.dispatchEvent(new Event("pushstate")), window.dispatchEvent(new Event("locationchange")), o;
+    };
+    const n = history.replaceState;
+    history.replaceState = function(...i) {
+      const o = n.apply(this, i);
+      return window.dispatchEvent(new Event("replacestate")), window.dispatchEvent(new Event("locationchange")), o;
+    }, window.addEventListener("popstate", function() {
+      window.dispatchEvent(new Event("locationchange"));
+    });
+    const r = () => this.debounce(() => this.screenView(), 50);
+    this.options.trackHashChanges ? window.addEventListener("hashchange", r) : window.addEventListener("locationchange", r);
+  }
+  trackAttributes() {
+    this.isServer() || document.addEventListener("click", (t) => {
+      const n = t.target, r = n.closest("button"), i = n.closest("a"), o = r != null && r.getAttribute("data-track") ? r : i != null && i.getAttribute("data-track") ? i : null;
+      if (o) {
+        const c = {};
+        for (const u of o.attributes) u.name.startsWith("data-") && u.name !== "data-track" && (c[a = u.name.replace(/^data-/, ""), a.replace(/([-_][a-z])/gi, (l) => l.toUpperCase().replace("-", "").replace("_", ""))] = u.value);
+        const h = o.getAttribute("data-track");
+        h && super.track(h, c);
+      }
+      var a;
+    });
+  }
+  screenView(t, n) {
+    return p(this, null, function* () {
+      if (this.isServer()) return;
+      let r, i;
+      if (typeof t == "string" ? (r = t, i = n) : (r = window.location.href, i = t), this.lastPath === r) return;
+      const o = yield function() {
+        return p(this, null, function* () {
+          try {
+            yield new Promise((h) => {
+              document.readyState === "complete" ? h(null) : window.addEventListener("load", h);
+            });
+            const a = document.body.cloneNode(!0);
+            Gt(a);
+            const c = yield zt(a);
+            return window.location.hostname === "localhost" && console.log(c), c;
+          } catch (a) {
+            console.error("An error occurred:", a);
+          }
+        });
+      }();
+      this.lastPath = r, ge(Xe.prototype, this, "track").call(this, "screen_view", O(v({}, i != null ? i : {}), { screenshot: o, __path: r, __title: document.title }));
+    });
+  }
+}
+export {
+  Xe as Tracker,
+  Zt as VERSION
+};
 //# sourceMappingURL=index.js.map