@bynder/compact-view 5.2.0 → 5.2.2

package/sdk-DhxX43BH.js

@@ -0,0 +1,4813 @@
+const kr = [];
+for (let r = 0; r < 256; ++r)
+  kr.push((r + 256).toString(16).slice(1));
+typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var he = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function Ve(r) {
+  return r && r.__esModule && Object.prototype.hasOwnProperty.call(r, "default") ? r.default : r;
+}
+var qt = { exports: {} }, Sr = qt.exports, pe;
+function Or() {
+  return pe || (pe = 1, (function(r) {
+    (function(t, e) {
+      r.exports ? r.exports = e() : t.log = e();
+    })(Sr, function() {
+      var t = function() {
+      }, e = "undefined", n = typeof window !== e && typeof window.navigator !== e && /Trident\/|MSIE /.test(window.navigator.userAgent), o = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ], i = {}, u = null;
+      function l(E, U) {
+        var S = E[U];
+        if (typeof S.bind == "function")
+          return S.bind(E);
+        try {
+          return Function.prototype.bind.call(S, E);
+        } catch {
+          return function() {
+            return Function.prototype.apply.apply(S, [E, arguments]);
+          };
+        }
+      }
+      function f() {
+        console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+      }
+      function d(E) {
+        return E === "debug" && (E = "log"), typeof console === e ? !1 : E === "trace" && n ? f : console[E] !== void 0 ? l(console, E) : console.log !== void 0 ? l(console, "log") : t;
+      }
+      function _() {
+        for (var E = this.getLevel(), U = 0; U < o.length; U++) {
+          var S = o[U];
+          this[S] = U < E ? t : this.methodFactory(S, E, this.name);
+        }
+        if (this.log = this.debug, typeof console === e && E < this.levels.SILENT)
+          return "No console available for logging";
+      }
+      function L(E) {
+        return function() {
+          typeof console !== e && (_.call(this), this[E].apply(this, arguments));
+        };
+      }
+      function B(E, U, S) {
+        return d(E) || L.apply(this, arguments);
+      }
+      function K(E, U) {
+        var S = this, y, g, m, p = "loglevel";
+        typeof E == "string" ? p += ":" + E : typeof E == "symbol" && (p = void 0);
+        function x(P) {
+          var N = (o[P] || "silent").toUpperCase();
+          if (!(typeof window === e || !p)) {
+            try {
+              window.localStorage[p] = N;
+              return;
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(p) + "=" + N + ";";
+            } catch {
+            }
+          }
+        }
+        function k() {
+          var P;
+          if (!(typeof window === e || !p)) {
+            try {
+              P = window.localStorage[p];
+            } catch {
+            }
+            if (typeof P === e)
+              try {
+                var N = window.document.cookie, b = encodeURIComponent(p), z = N.indexOf(b + "=");
+                z !== -1 && (P = /^([^;]+)/.exec(
+                  N.slice(z + b.length + 1)
+                )[1]);
+              } catch {
+              }
+            return S.levels[P] === void 0 && (P = void 0), P;
+          }
+        }
+        function C() {
+          if (!(typeof window === e || !p)) {
+            try {
+              window.localStorage.removeItem(p);
+            } catch {
+            }
+            try {
+              window.document.cookie = encodeURIComponent(p) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+            } catch {
+            }
+          }
+        }
+        function O(P) {
+          var N = P;
+          if (typeof N == "string" && S.levels[N.toUpperCase()] !== void 0 && (N = S.levels[N.toUpperCase()]), typeof N == "number" && N >= 0 && N <= S.levels.SILENT)
+            return N;
+          throw new TypeError("log.setLevel() called with invalid level: " + P);
+        }
+        S.name = E, S.levels = {
+          TRACE: 0,
+          DEBUG: 1,
+          INFO: 2,
+          WARN: 3,
+          ERROR: 4,
+          SILENT: 5
+        }, S.methodFactory = U || B, S.getLevel = function() {
+          return m ?? g ?? y;
+        }, S.setLevel = function(P, N) {
+          return m = O(P), N !== !1 && x(m), _.call(S);
+        }, S.setDefaultLevel = function(P) {
+          g = O(P), k() || S.setLevel(P, !1);
+        }, S.resetLevel = function() {
+          m = null, C(), _.call(S);
+        }, S.enableAll = function(P) {
+          S.setLevel(S.levels.TRACE, P);
+        }, S.disableAll = function(P) {
+          S.setLevel(S.levels.SILENT, P);
+        }, S.rebuild = function() {
+          if (u !== S && (y = O(u.getLevel())), _.call(S), u === S)
+            for (var P in i)
+              i[P].rebuild();
+        }, y = O(
+          u ? u.getLevel() : "WARN"
+        );
+        var q = k();
+        q != null && (m = O(q)), _.call(S);
+      }
+      u = new K(), u.getLogger = function(E) {
+        if (typeof E != "symbol" && typeof E != "string" || E === "")
+          throw new TypeError("You must supply a name when creating a logger.");
+        var U = i[E];
+        return U || (U = i[E] = new K(
+          E,
+          u.methodFactory
+        )), U;
+      };
+      var G = typeof window !== e ? window.log : void 0;
+      return u.noConflict = function() {
+        return typeof window !== e && window.log === u && (window.log = G), u;
+      }, u.getLoggers = function() {
+        return i;
+      }, u.default = u, u;
+    });
+  })(qt)), qt.exports;
+}
+var xr = Or();
+const Q = /* @__PURE__ */ Ve(xr);
+let Ft = localStorage.getItem("asset_sdk_verbose") === "true";
+const Ur = {};
+Q.setDefaultLevel(Ft ? Q.levels.DEBUG : Q.levels.WARN);
+function Rr(r) {
+  Ft = r, localStorage.setItem("asset_sdk_verbose", String(!!r));
+  const t = Ft ? Q.levels.DEBUG : Q.levels.WARN;
+  Q.setLevel(t), Object.values(Ur).forEach((e) => {
+    e.setLevel(t);
+  });
+  try {
+    localStorage.setItem("asset_sdk_verbose", String(r));
+  } catch (e) {
+    console.error(`Can't save logger verbosity to localStorage: ${e}`);
+  }
+}
+typeof window < "u" && (window.asset_sdk_logger = { setVerbose: Rr, log: Q });
+const J = /* @__PURE__ */ Object.create(null);
+J.open = "0";
+J.close = "1";
+J.ping = "2";
+J.pong = "3";
+J.message = "4";
+J.upgrade = "5";
+J.noop = "6";
+const St = /* @__PURE__ */ Object.create(null);
+Object.keys(J).forEach((r) => {
+  St[J[r]] = r;
+});
+const Ht = { type: "error", data: "parser error" }, Ke = typeof Blob == "function" || typeof Blob < "u" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", Ge = typeof ArrayBuffer == "function", Ye = (r) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(r) : r && r.buffer instanceof ArrayBuffer, ee = ({ type: r, data: t }, e, n) => Ke && t instanceof Blob ? e ? n(t) : fe(t, n) : Ge && (t instanceof ArrayBuffer || Ye(t)) ? e ? n(t) : fe(new Blob([t]), n) : n(J[r] + (t || "")), fe = (r, t) => {
+  const e = new FileReader();
+  return e.onload = function() {
+    const n = e.result.split(",")[1];
+    t("b" + (n || ""));
+  }, e.readAsDataURL(r);
+};
+function de(r) {
+  return r instanceof Uint8Array ? r : r instanceof ArrayBuffer ? new Uint8Array(r) : new Uint8Array(r.buffer, r.byteOffset, r.byteLength);
+}
+let At;
+function Tr(r, t) {
+  if (Ke && r.data instanceof Blob)
+    return r.data.arrayBuffer().then(de).then(t);
+  if (Ge && (r.data instanceof ArrayBuffer || Ye(r.data)))
+    return t(de(r.data));
+  ee(r, !1, (e) => {
+    At || (At = new TextEncoder()), t(At.encode(e));
+  });
+}
+const ye = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", ut = typeof Uint8Array > "u" ? [] : new Uint8Array(256);
+for (let r = 0; r < ye.length; r++)
+  ut[ye.charCodeAt(r)] = r;
+const Cr = (r) => {
+  let t = r.length * 0.75, e = r.length, n, o = 0, i, u, l, f;
+  r[r.length - 1] === "=" && (t--, r[r.length - 2] === "=" && t--);
+  const d = new ArrayBuffer(t), _ = new Uint8Array(d);
+  for (n = 0; n < e; n += 4)
+    i = ut[r.charCodeAt(n)], u = ut[r.charCodeAt(n + 1)], l = ut[r.charCodeAt(n + 2)], f = ut[r.charCodeAt(n + 3)], _[o++] = i << 2 | u >> 4, _[o++] = (u & 15) << 4 | l >> 2, _[o++] = (l & 3) << 6 | f & 63;
+  return d;
+}, Pr = typeof ArrayBuffer == "function", re = (r, t) => {
+  if (typeof r != "string")
+    return {
+      type: "message",
+      data: We(r, t)
+    };
+  const e = r.charAt(0);
+  return e === "b" ? {
+    type: "message",
+    data: Lr(r.substring(1), t)
+  } : St[e] ? r.length > 1 ? {
+    type: St[e],
+    data: r.substring(1)
+  } : {
+    type: St[e]
+  } : Ht;
+}, Lr = (r, t) => {
+  if (Pr) {
+    const e = Cr(r);
+    return We(e, t);
+  } else
+    return { base64: !0, data: r };
+}, We = (r, t) => {
+  switch (t) {
+    case "blob":
+      return r instanceof Blob ? r : new Blob([r]);
+    case "arraybuffer":
+    default:
+      return r instanceof ArrayBuffer ? r : r.buffer;
+  }
+}, Je = "", Ar = (r, t) => {
+  const e = r.length, n = new Array(e);
+  let o = 0;
+  r.forEach((i, u) => {
+    ee(i, !1, (l) => {
+      n[u] = l, ++o === e && t(n.join(Je));
+    });
+  });
+}, jr = (r, t) => {
+  const e = r.split(Je), n = [];
+  for (let o = 0; o < e.length; o++) {
+    const i = re(e[o], t);
+    if (n.push(i), i.type === "error")
+      break;
+  }
+  return n;
+};
+function Br() {
+  return new TransformStream({
+    transform(r, t) {
+      Tr(r, (e) => {
+        const n = e.length;
+        let o;
+        if (n < 126)
+          o = new Uint8Array(1), new DataView(o.buffer).setUint8(0, n);
+        else if (n < 65536) {
+          o = new Uint8Array(3);
+          const i = new DataView(o.buffer);
+          i.setUint8(0, 126), i.setUint16(1, n);
+        } else {
+          o = new Uint8Array(9);
+          const i = new DataView(o.buffer);
+          i.setUint8(0, 127), i.setBigUint64(1, BigInt(n));
+        }
+        r.data && typeof r.data != "string" && (o[0] |= 128), t.enqueue(o), t.enqueue(e);
+      });
+    }
+  });
+}
+let jt;
+function bt(r) {
+  return r.reduce((t, e) => t + e.length, 0);
+}
+function _t(r, t) {
+  if (r[0].length === t)
+    return r.shift();
+  const e = new Uint8Array(t);
+  let n = 0;
+  for (let o = 0; o < t; o++)
+    e[o] = r[0][n++], n === r[0].length && (r.shift(), n = 0);
+  return r.length && n < r[0].length && (r[0] = r[0].slice(n)), e;
+}
+function Nr(r, t) {
+  jt || (jt = new TextDecoder());
+  const e = [];
+  let n = 0, o = -1, i = !1;
+  return new TransformStream({
+    transform(u, l) {
+      for (e.push(u); ; ) {
+        if (n === 0) {
+          if (bt(e) < 1)
+            break;
+          const f = _t(e, 1);
+          i = (f[0] & 128) === 128, o = f[0] & 127, o < 126 ? n = 3 : o === 126 ? n = 1 : n = 2;
+        } else if (n === 1) {
+          if (bt(e) < 2)
+            break;
+          const f = _t(e, 2);
+          o = new DataView(f.buffer, f.byteOffset, f.length).getUint16(0), n = 3;
+        } else if (n === 2) {
+          if (bt(e) < 8)
+            break;
+          const f = _t(e, 8), d = new DataView(f.buffer, f.byteOffset, f.length), _ = d.getUint32(0);
+          if (_ > Math.pow(2, 21) - 1) {
+            l.enqueue(Ht);
+            break;
+          }
+          o = _ * Math.pow(2, 32) + d.getUint32(4), n = 3;
+        } else {
+          if (bt(e) < o)
+            break;
+          const f = _t(e, o);
+          l.enqueue(re(i ? f : jt.decode(f), t)), n = 0;
+        }
+        if (o === 0 || o > r) {
+          l.enqueue(Ht);
+          break;
+        }
+      }
+    }
+  });
+}
+const Xe = 4;
+function D(r) {
+  if (r) return Ir(r);
+}
+function Ir(r) {
+  for (var t in D.prototype)
+    r[t] = D.prototype[t];
+  return r;
+}
+D.prototype.on = D.prototype.addEventListener = function(r, t) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks["$" + r] = this._callbacks["$" + r] || []).push(t), this;
+};
+D.prototype.once = function(r, t) {
+  function e() {
+    this.off(r, e), t.apply(this, arguments);
+  }
+  return e.fn = t, this.on(r, e), this;
+};
+D.prototype.off = D.prototype.removeListener = D.prototype.removeAllListeners = D.prototype.removeEventListener = function(r, t) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0)
+    return this._callbacks = {}, this;
+  var e = this._callbacks["$" + r];
+  if (!e) return this;
+  if (arguments.length == 1)
+    return delete this._callbacks["$" + r], this;
+  for (var n, o = 0; o < e.length; o++)
+    if (n = e[o], n === t || n.fn === t) {
+      e.splice(o, 1);
+      break;
+    }
+  return e.length === 0 && delete this._callbacks["$" + r], this;
+};
+D.prototype.emit = function(r) {
+  this._callbacks = this._callbacks || {};
+  for (var t = new Array(arguments.length - 1), e = this._callbacks["$" + r], n = 1; n < arguments.length; n++)
+    t[n - 1] = arguments[n];
+  if (e) {
+    e = e.slice(0);
+    for (var n = 0, o = e.length; n < o; ++n)
+      e[n].apply(this, t);
+  }
+  return this;
+};
+D.prototype.emitReserved = D.prototype.emit;
+D.prototype.listeners = function(r) {
+  return this._callbacks = this._callbacks || {}, this._callbacks["$" + r] || [];
+};
+D.prototype.hasListeners = function(r) {
+  return !!this.listeners(r).length;
+};
+const Pt = typeof Promise == "function" && typeof Promise.resolve == "function" ? (r) => Promise.resolve().then(r) : (r, t) => t(r, 0), V = typeof self < "u" ? self : typeof window < "u" ? window : Function("return this")(), Dr = "arraybuffer";
+function $e(r, ...t) {
+  return t.reduce((e, n) => (r.hasOwnProperty(n) && (e[n] = r[n]), e), {});
+}
+const qr = V.setTimeout, Fr = V.clearTimeout;
+function Lt(r, t) {
+  t.useNativeTimers ? (r.setTimeoutFn = qr.bind(V), r.clearTimeoutFn = Fr.bind(V)) : (r.setTimeoutFn = V.setTimeout.bind(V), r.clearTimeoutFn = V.clearTimeout.bind(V));
+}
+const Hr = 1.33;
+function zr(r) {
+  return typeof r == "string" ? Mr(r) : Math.ceil((r.byteLength || r.size) * Hr);
+}
+function Mr(r) {
+  let t = 0, e = 0;
+  for (let n = 0, o = r.length; n < o; n++)
+    t = r.charCodeAt(n), t < 128 ? e += 1 : t < 2048 ? e += 2 : t < 55296 || t >= 57344 ? e += 3 : (n++, e += 4);
+  return e;
+}
+function Qe() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+function Vr(r) {
+  let t = "";
+  for (let e in r)
+    r.hasOwnProperty(e) && (t.length && (t += "&"), t += encodeURIComponent(e) + "=" + encodeURIComponent(r[e]));
+  return t;
+}
+function Kr(r) {
+  let t = {}, e = r.split("&");
+  for (let n = 0, o = e.length; n < o; n++) {
+    let i = e[n].split("=");
+    t[decodeURIComponent(i[0])] = decodeURIComponent(i[1]);
+  }
+  return t;
+}
+class Gr extends Error {
+  constructor(t, e, n) {
+    super(t), this.description = e, this.context = n, this.type = "TransportError";
+  }
+}
+class ne extends D {
+  /**
+   * Transport abstract constructor.
+   *
+   * @param {Object} opts - options
+   * @protected
+   */
+  constructor(t) {
+    super(), this.writable = !1, Lt(this, t), this.opts = t, this.query = t.query, this.socket = t.socket, this.supportsBinary = !t.forceBase64;
+  }
+  /**
+   * Emits an error.
+   *
+   * @param {String} reason
+   * @param description
+   * @param context - the error context
+   * @return {Transport} for chaining
+   * @protected
+   */
+  onError(t, e, n) {
+    return super.emitReserved("error", new Gr(t, e, n)), this;
+  }
+  /**
+   * Opens the transport.
+   */
+  open() {
+    return this.readyState = "opening", this.doOpen(), this;
+  }
+  /**
+   * Closes the transport.
+   */
+  close() {
+    return (this.readyState === "opening" || this.readyState === "open") && (this.doClose(), this.onClose()), this;
+  }
+  /**
+   * Sends multiple packets.
+   *
+   * @param {Array} packets
+   */
+  send(t) {
+    this.readyState === "open" && this.write(t);
+  }
+  /**
+   * Called upon open
+   *
+   * @protected
+   */
+  onOpen() {
+    this.readyState = "open", this.writable = !0, super.emitReserved("open");
+  }
+  /**
+   * Called with data.
+   *
+   * @param {String} data
+   * @protected
+   */
+  onData(t) {
+    const e = re(t, this.socket.binaryType);
+    this.onPacket(e);
+  }
+  /**
+   * Called with a decoded packet.
+   *
+   * @protected
+   */
+  onPacket(t) {
+    super.emitReserved("packet", t);
+  }
+  /**
+   * Called upon close.
+   *
+   * @protected
+   */
+  onClose(t) {
+    this.readyState = "closed", super.emitReserved("close", t);
+  }
+  /**
+   * Pauses the transport, in order not to lose packets during an upgrade.
+   *
+   * @param onPause
+   */
+  pause(t) {
+  }
+  createUri(t, e = {}) {
+    return t + "://" + this._hostname() + this._port() + this.opts.path + this._query(e);
+  }
+  _hostname() {
+    const t = this.opts.hostname;
+    return t.indexOf(":") === -1 ? t : "[" + t + "]";
+  }
+  _port() {
+    return this.opts.port && (this.opts.secure && +(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80) ? ":" + this.opts.port : "";
+  }
+  _query(t) {
+    const e = Vr(t);
+    return e.length ? "?" + e : "";
+  }
+}
+class Yr extends ne {
+  constructor() {
+    super(...arguments), this._polling = !1;
+  }
+  get name() {
+    return "polling";
+  }
+  /**
+   * Opens the socket (triggers polling). We write a PING message to determine
+   * when the transport is open.
+   *
+   * @protected
+   */
+  doOpen() {
+    this._poll();
+  }
+  /**
+   * Pauses polling.
+   *
+   * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+   * @package
+   */
+  pause(t) {
+    this.readyState = "pausing";
+    const e = () => {
+      this.readyState = "paused", t();
+    };
+    if (this._polling || !this.writable) {
+      let n = 0;
+      this._polling && (n++, this.once("pollComplete", function() {
+        --n || e();
+      })), this.writable || (n++, this.once("drain", function() {
+        --n || e();
+      }));
+    } else
+      e();
+  }
+  /**
+   * Starts polling cycle.
+   *
+   * @private
+   */
+  _poll() {
+    this._polling = !0, this.doPoll(), this.emitReserved("poll");
+  }
+  /**
+   * Overloads onData to detect payloads.
+   *
+   * @protected
+   */
+  onData(t) {
+    const e = (n) => {
+      if (this.readyState === "opening" && n.type === "open" && this.onOpen(), n.type === "close")
+        return this.onClose({ description: "transport closed by the server" }), !1;
+      this.onPacket(n);
+    };
+    jr(t, this.socket.binaryType).forEach(e), this.readyState !== "closed" && (this._polling = !1, this.emitReserved("pollComplete"), this.readyState === "open" && this._poll());
+  }
+  /**
+   * For polling, send a close packet.
+   *
+   * @protected
+   */
+  doClose() {
+    const t = () => {
+      this.write([{ type: "close" }]);
+    };
+    this.readyState === "open" ? t() : this.once("open", t);
+  }
+  /**
+   * Writes a packets payload.
+   *
+   * @param {Array} packets - data packets
+   * @protected
+   */
+  write(t) {
+    this.writable = !1, Ar(t, (e) => {
+      this.doWrite(e, () => {
+        this.writable = !0, this.emitReserved("drain");
+      });
+    });
+  }
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const t = this.opts.secure ? "https" : "http", e = this.query || {};
+    return this.opts.timestampRequests !== !1 && (e[this.opts.timestampParam] = Qe()), !this.supportsBinary && !e.sid && (e.b64 = 1), this.createUri(t, e);
+  }
+}
+let Ze = !1;
+try {
+  Ze = typeof XMLHttpRequest < "u" && "withCredentials" in new XMLHttpRequest();
+} catch {
+}
+const Wr = Ze;
+function Jr() {
+}
+class Xr extends Yr {
+  /**
+   * XHR Polling constructor.
+   *
+   * @param {Object} opts
+   * @package
+   */
+  constructor(t) {
+    if (super(t), typeof location < "u") {
+      const e = location.protocol === "https:";
+      let n = location.port;
+      n || (n = e ? "443" : "80"), this.xd = typeof location < "u" && t.hostname !== location.hostname || n !== t.port;
+    }
+  }
+  /**
+   * Sends data.
+   *
+   * @param {String} data to send.
+   * @param {Function} called upon flush.
+   * @private
+   */
+  doWrite(t, e) {
+    const n = this.request({
+      method: "POST",
+      data: t
+    });
+    n.on("success", e), n.on("error", (o, i) => {
+      this.onError("xhr post error", o, i);
+    });
+  }
+  /**
+   * Starts a poll cycle.
+   *
+   * @private
+   */
+  doPoll() {
+    const t = this.request();
+    t.on("data", this.onData.bind(this)), t.on("error", (e, n) => {
+      this.onError("xhr poll error", e, n);
+    }), this.pollXhr = t;
+  }
+}
+let nt = class Ot extends D {
+  /**
+   * Request constructor
+   *
+   * @param {Object} options
+   * @package
+   */
+  constructor(t, e, n) {
+    super(), this.createRequest = t, Lt(this, n), this._opts = n, this._method = n.method || "GET", this._uri = e, this._data = n.data !== void 0 ? n.data : null, this._create();
+  }
+  /**
+   * Creates the XHR object and sends the request.
+   *
+   * @private
+   */
+  _create() {
+    var t;
+    const e = $e(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    e.xdomain = !!this._opts.xd;
+    const n = this._xhr = this.createRequest(e);
+    try {
+      n.open(this._method, this._uri, !0);
+      try {
+        if (this._opts.extraHeaders) {
+          n.setDisableHeaderCheck && n.setDisableHeaderCheck(!0);
+          for (let o in this._opts.extraHeaders)
+            this._opts.extraHeaders.hasOwnProperty(o) && n.setRequestHeader(o, this._opts.extraHeaders[o]);
+        }
+      } catch {
+      }
+      if (this._method === "POST")
+        try {
+          n.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+        } catch {
+        }
+      try {
+        n.setRequestHeader("Accept", "*/*");
+      } catch {
+      }
+      (t = this._opts.cookieJar) === null || t === void 0 || t.addCookies(n), "withCredentials" in n && (n.withCredentials = this._opts.withCredentials), this._opts.requestTimeout && (n.timeout = this._opts.requestTimeout), n.onreadystatechange = () => {
+        var o;
+        n.readyState === 3 && ((o = this._opts.cookieJar) === null || o === void 0 || o.parseCookies(
+          // @ts-ignore
+          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 (o) {
+      this.setTimeoutFn(() => {
+        this._onError(o);
+      }, 0);
+      return;
+    }
+    typeof document < "u" && (this._index = Ot.requestsCount++, Ot.requests[this._index] = this);
+  }
+  /**
+   * Called upon error.
+   *
+   * @private
+   */
+  _onError(t) {
+    this.emitReserved("error", t, this._xhr), this._cleanup(!0);
+  }
+  /**
+   * Cleans up house.
+   *
+   * @private
+   */
+  _cleanup(t) {
+    if (!(typeof this._xhr > "u" || this._xhr === null)) {
+      if (this._xhr.onreadystatechange = Jr, t)
+        try {
+          this._xhr.abort();
+        } catch {
+        }
+      typeof document < "u" && delete Ot.requests[this._index], this._xhr = null;
+    }
+  }
+  /**
+   * Called upon load.
+   *
+   * @private
+   */
+  _onLoad() {
+    const t = this._xhr.responseText;
+    t !== null && (this.emitReserved("data", t), this.emitReserved("success"), this._cleanup());
+  }
+  /**
+   * Aborts the request.
+   *
+   * @package
+   */
+  abort() {
+    this._cleanup();
+  }
+};
+nt.requestsCount = 0;
+nt.requests = {};
+if (typeof document < "u") {
+  if (typeof attachEvent == "function")
+    attachEvent("onunload", ge);
+  else if (typeof addEventListener == "function") {
+    const r = "onpagehide" in V ? "pagehide" : "unload";
+    addEventListener(r, ge, !1);
+  }
+}
+function ge() {
+  for (let r in nt.requests)
+    nt.requests.hasOwnProperty(r) && nt.requests[r].abort();
+}
+const $r = (function() {
+  const r = tr({
+    xdomain: !1
+  });
+  return r && r.responseType !== null;
+})();
+class Qr extends Xr {
+  constructor(t) {
+    super(t);
+    const e = t && t.forceBase64;
+    this.supportsBinary = $r && !e;
+  }
+  request(t = {}) {
+    return Object.assign(t, { xd: this.xd }, this.opts), new nt(tr, this.uri(), t);
+  }
+}
+function tr(r) {
+  const t = r.xdomain;
+  try {
+    if (typeof XMLHttpRequest < "u" && (!t || Wr))
+      return new XMLHttpRequest();
+  } catch {
+  }
+  if (!t)
+    try {
+      return new V[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch {
+    }
+}
+const er = typeof navigator < "u" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class Zr extends ne {
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    const t = this.uri(), e = this.opts.protocols, n = er ? {} : $e(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(t, e, n);
+    } catch (o) {
+      return this.emitReserved("error", o);
+    }
+    this.ws.binaryType = this.socket.binaryType, this.addEventListeners();
+  }
+  /**
+   * Adds event listeners to the socket
+   *
+   * @private
+   */
+  addEventListeners() {
+    this.ws.onopen = () => {
+      this.opts.autoUnref && this.ws._socket.unref(), this.onOpen();
+    }, this.ws.onclose = (t) => this.onClose({
+      description: "websocket connection closed",
+      context: t
+    }), this.ws.onmessage = (t) => this.onData(t.data), this.ws.onerror = (t) => this.onError("websocket error", t);
+  }
+  write(t) {
+    this.writable = !1;
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e], o = e === t.length - 1;
+      ee(n, this.supportsBinary, (i) => {
+        try {
+          this.doWrite(n, i);
+        } catch {
+        }
+        o && Pt(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    typeof this.ws < "u" && (this.ws.onerror = () => {
+    }, this.ws.close(), this.ws = null);
+  }
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const t = this.opts.secure ? "wss" : "ws", e = this.query || {};
+    return this.opts.timestampRequests && (e[this.opts.timestampParam] = Qe()), this.supportsBinary || (e.b64 = 1), this.createUri(t, e);
+  }
+}
+const Bt = V.WebSocket || V.MozWebSocket;
+class tn extends Zr {
+  createSocket(t, e, n) {
+    return er ? new Bt(t, e, n) : e ? new Bt(t, e) : new Bt(t);
+  }
+  doWrite(t, e) {
+    this.ws.send(e);
+  }
+}
+class en extends ne {
+  get name() {
+    return "webtransport";
+  }
+  doOpen() {
+    try {
+      this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+    } catch (t) {
+      return this.emitReserved("error", t);
+    }
+    this._transport.closed.then(() => {
+      this.onClose();
+    }).catch((t) => {
+      this.onError("webtransport error", t);
+    }), this._transport.ready.then(() => {
+      this._transport.createBidirectionalStream().then((t) => {
+        const e = Nr(Number.MAX_SAFE_INTEGER, this.socket.binaryType), n = t.readable.pipeThrough(e).getReader(), o = Br();
+        o.readable.pipeTo(t.writable), this._writer = o.writable.getWriter();
+        const i = () => {
+          n.read().then(({ done: l, value: f }) => {
+            l || (this.onPacket(f), i());
+          }).catch((l) => {
+          });
+        };
+        i();
+        const u = { type: "open" };
+        this.query.sid && (u.data = `{"sid":"${this.query.sid}"}`), this._writer.write(u).then(() => this.onOpen());
+      });
+    });
+  }
+  write(t) {
+    this.writable = !1;
+    for (let e = 0; e < t.length; e++) {
+      const n = t[e], o = e === t.length - 1;
+      this._writer.write(n).then(() => {
+        o && Pt(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    var t;
+    (t = this._transport) === null || t === void 0 || t.close();
+  }
+}
+const rn = {
+  websocket: tn,
+  webtransport: en,
+  polling: Qr
+}, nn = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, on = [
+  "source",
+  "protocol",
+  "authority",
+  "userInfo",
+  "user",
+  "password",
+  "host",
+  "port",
+  "relative",
+  "path",
+  "directory",
+  "file",
+  "query",
+  "anchor"
+];
+function zt(r) {
+  if (r.length > 8e3)
+    throw "URI too long";
+  const t = r, e = r.indexOf("["), n = r.indexOf("]");
+  e != -1 && n != -1 && (r = r.substring(0, e) + r.substring(e, n).replace(/:/g, ";") + r.substring(n, r.length));
+  let o = nn.exec(r || ""), i = {}, u = 14;
+  for (; u--; )
+    i[on[u]] = o[u] || "";
+  return e != -1 && n != -1 && (i.source = t, 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 = sn(i, i.path), i.queryKey = an(i, i.query), i;
+}
+function sn(r, t) {
+  const e = /\/{2,9}/g, n = t.replace(e, "/").split("/");
+  return (t.slice(0, 1) == "/" || t.length === 0) && n.splice(0, 1), t.slice(-1) == "/" && n.splice(n.length - 1, 1), n;
+}
+function an(r, t) {
+  const e = {};
+  return t.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(n, o, i) {
+    o && (e[o] = i);
+  }), e;
+}
+const Mt = typeof addEventListener == "function" && typeof removeEventListener == "function", xt = [];
+Mt && addEventListener("offline", () => {
+  xt.forEach((r) => r());
+}, !1);
+class X extends D {
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(t, e) {
+    if (super(), this.binaryType = Dr, this.writeBuffer = [], this._prevBufferLen = 0, this._pingInterval = -1, this._pingTimeout = -1, this._maxPayload = -1, this._pingTimeoutTime = 1 / 0, t && typeof t == "object" && (e = t, t = null), t) {
+      const n = zt(t);
+      e.hostname = n.host, e.secure = n.protocol === "https" || n.protocol === "wss", e.port = n.port, n.query && (e.query = n.query);
+    } else e.host && (e.hostname = zt(e.host).host);
+    Lt(this, e), this.secure = e.secure != null ? e.secure : typeof location < "u" && location.protocol === "https:", e.hostname && !e.port && (e.port = this.secure ? "443" : "80"), this.hostname = e.hostname || (typeof location < "u" ? location.hostname : "localhost"), this.port = e.port || (typeof location < "u" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = [], this._transportsByName = {}, e.transports.forEach((n) => {
+      const o = n.prototype.name;
+      this.transports.push(o), this._transportsByName[o] = 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
+    }, e), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = Kr(this.opts.query)), Mt && (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"
+      });
+    }, xt.push(this._offlineEventListener))), this.opts.withCredentials && (this._cookieJar = void 0), this._open();
+  }
+  /**
+   * Creates transport of the given type.
+   *
+   * @param {String} name - transport name
+   * @return {Transport}
+   * @private
+   */
+  createTransport(t) {
+    const e = Object.assign({}, this.opts.query);
+    e.EIO = Xe, e.transport = t, this.id && (e.sid = this.id);
+    const n = Object.assign({}, this.opts, {
+      query: e,
+      socket: this,
+      hostname: this.hostname,
+      secure: this.secure,
+      port: this.port
+    }, this.opts.transportOptions[t]);
+    return new this._transportsByName[t](n);
+  }
+  /**
+   * Initializes transport to use and starts probe.
+   *
+   * @private
+   */
+  _open() {
+    if (this.transports.length === 0) {
+      this.setTimeoutFn(() => {
+        this.emitReserved("error", "No transports available");
+      }, 0);
+      return;
+    }
+    const t = this.opts.rememberUpgrade && X.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+    this.readyState = "opening";
+    const e = this.createTransport(t);
+    e.open(), this.setTransport(e);
+  }
+  /**
+   * Sets the current transport. Disables the existing one (if any).
+   *
+   * @private
+   */
+  setTransport(t) {
+    this.transport && this.transport.removeAllListeners(), this.transport = t, t.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (e) => this._onClose("transport close", e));
+  }
+  /**
+   * Called when connection is deemed open.
+   *
+   * @private
+   */
+  onOpen() {
+    this.readyState = "open", X.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush();
+  }
+  /**
+   * Handles a packet.
+   *
+   * @private
+   */
+  _onPacket(t) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing")
+      switch (this.emitReserved("packet", t), this.emitReserved("heartbeat"), t.type) {
+        case "open":
+          this.onHandshake(JSON.parse(t.data));
+          break;
+        case "ping":
+          this._sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong"), this._resetPingTimeout();
+          break;
+        case "error":
+          const e = new Error("server error");
+          e.code = t.data, this._onError(e);
+          break;
+        case "message":
+          this.emitReserved("data", t.data), this.emitReserved("message", t.data);
+          break;
+      }
+  }
+  /**
+   * Called upon handshake completion.
+   *
+   * @param {Object} data - handshake obj
+   * @private
+   */
+  onHandshake(t) {
+    this.emitReserved("handshake", t), this.id = t.sid, this.transport.query.sid = t.sid, this._pingInterval = t.pingInterval, this._pingTimeout = t.pingTimeout, this._maxPayload = t.maxPayload, this.onOpen(), this.readyState !== "closed" && this._resetPingTimeout();
+  }
+  /**
+   * Sets and resets ping timeout timer based on server pings.
+   *
+   * @private
+   */
+  _resetPingTimeout() {
+    this.clearTimeoutFn(this._pingTimeoutTimer);
+    const t = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + t, this._pingTimeoutTimer = this.setTimeoutFn(() => {
+      this._onClose("ping timeout");
+    }, t), this.opts.autoUnref && this._pingTimeoutTimer.unref();
+  }
+  /**
+   * Called on `drain` event
+   *
+   * @private
+   */
+  _onDrain() {
+    this.writeBuffer.splice(0, this._prevBufferLen), this._prevBufferLen = 0, this.writeBuffer.length === 0 ? this.emitReserved("drain") : this.flush();
+  }
+  /**
+   * Flush write buffers.
+   *
+   * @private
+   */
+  flush() {
+    if (this.readyState !== "closed" && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
+      const t = this._getWritablePackets();
+      this.transport.send(t), this._prevBufferLen = t.length, this.emitReserved("flush");
+    }
+  }
+  /**
+   * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+   * long-polling)
+   *
+   * @private
+   */
+  _getWritablePackets() {
+    if (!(this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1))
+      return this.writeBuffer;
+    let t = 1;
+    for (let e = 0; e < this.writeBuffer.length; e++) {
+      const n = this.writeBuffer[e].data;
+      if (n && (t += zr(n)), e > 0 && t > this._maxPayload)
+        return this.writeBuffer.slice(0, e);
+      t += 2;
+    }
+    return this.writeBuffer;
+  }
+  /**
+   * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+   *
+   * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+   * `write()` method then the message would not be buffered by the Socket.IO client.
+   *
+   * @return {boolean}
+   * @private
+   */
+  /* private */
+  _hasPingExpired() {
+    if (!this._pingTimeoutTime)
+      return !0;
+    const t = Date.now() > this._pingTimeoutTime;
+    return t && (this._pingTimeoutTime = 0, Pt(() => {
+      this._onClose("ping timeout");
+    }, this.setTimeoutFn)), t;
+  }
+  /**
+   * Sends a message.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
+  write(t, e, n) {
+    return this._sendPacket("message", t, e, n), this;
+  }
+  /**
+   * Sends a message. Alias of {@link Socket#write}.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
+  send(t, e, n) {
+    return this._sendPacket("message", t, e, n), this;
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type: packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  _sendPacket(t, e, n, o) {
+    if (typeof e == "function" && (o = e, e = void 0), typeof n == "function" && (o = n, n = null), this.readyState === "closing" || this.readyState === "closed")
+      return;
+    n = n || {}, n.compress = n.compress !== !1;
+    const i = {
+      type: t,
+      data: e,
+      options: n
+    };
+    this.emitReserved("packetCreate", i), this.writeBuffer.push(i), o && this.once("flush", o), this.flush();
+  }
+  /**
+   * Closes the connection.
+   */
+  close() {
+    const t = () => {
+      this._onClose("forced close"), this.transport.close();
+    }, e = () => {
+      this.off("upgrade", e), this.off("upgradeError", e), t();
+    }, n = () => {
+      this.once("upgrade", e), this.once("upgradeError", e);
+    };
+    return (this.readyState === "opening" || this.readyState === "open") && (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? n() : t();
+    }) : this.upgrading ? n() : t()), this;
+  }
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  _onError(t) {
+    if (X.priorWebsocketSuccess = !1, this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening")
+      return this.transports.shift(), this._open();
+    this.emitReserved("error", t), this._onClose("transport error", t);
+  }
+  /**
+   * Called upon transport close.
+   *
+   * @private
+   */
+  _onClose(t, e) {
+    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(), Mt && (this._beforeunloadEventListener && removeEventListener("beforeunload", this._beforeunloadEventListener, !1), this._offlineEventListener)) {
+        const n = xt.indexOf(this._offlineEventListener);
+        n !== -1 && xt.splice(n, 1);
+      }
+      this.readyState = "closed", this.id = null, this.emitReserved("close", t, e), this.writeBuffer = [], this._prevBufferLen = 0;
+    }
+  }
+}
+X.protocol = Xe;
+class un extends X {
+  constructor() {
+    super(...arguments), this._upgrades = [];
+  }
+  onOpen() {
+    if (super.onOpen(), this.readyState === "open" && this.opts.upgrade)
+      for (let t = 0; t < this._upgrades.length; t++)
+        this._probe(this._upgrades[t]);
+  }
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  _probe(t) {
+    let e = this.createTransport(t), n = !1;
+    X.priorWebsocketSuccess = !1;
+    const o = () => {
+      n || (e.send([{ type: "ping", data: "probe" }]), e.once("packet", (L) => {
+        if (!n)
+          if (L.type === "pong" && L.data === "probe") {
+            if (this.upgrading = !0, this.emitReserved("upgrading", e), !e)
+              return;
+            X.priorWebsocketSuccess = e.name === "websocket", this.transport.pause(() => {
+              n || this.readyState !== "closed" && (_(), this.setTransport(e), e.send([{ type: "upgrade" }]), this.emitReserved("upgrade", e), e = null, this.upgrading = !1, this.flush());
+            });
+          } else {
+            const B = new Error("probe error");
+            B.transport = e.name, this.emitReserved("upgradeError", B);
+          }
+      }));
+    };
+    function i() {
+      n || (n = !0, _(), e.close(), e = null);
+    }
+    const u = (L) => {
+      const B = new Error("probe error: " + L);
+      B.transport = e.name, i(), this.emitReserved("upgradeError", B);
+    };
+    function l() {
+      u("transport closed");
+    }
+    function f() {
+      u("socket closed");
+    }
+    function d(L) {
+      e && L.name !== e.name && i();
+    }
+    const _ = () => {
+      e.removeListener("open", o), e.removeListener("error", u), e.removeListener("close", l), this.off("close", f), this.off("upgrading", d);
+    };
+    e.once("open", o), e.once("error", u), e.once("close", l), this.once("close", f), this.once("upgrading", d), this._upgrades.indexOf("webtransport") !== -1 && t !== "webtransport" ? this.setTimeoutFn(() => {
+      n || e.open();
+    }, 200) : e.open();
+  }
+  onHandshake(t) {
+    this._upgrades = this._filterUpgrades(t.upgrades), super.onHandshake(t);
+  }
+  /**
+   * Filters upgrades, returning only those matching client transports.
+   *
+   * @param {Array} upgrades - server upgrades
+   * @private
+   */
+  _filterUpgrades(t) {
+    const e = [];
+    for (let n = 0; n < t.length; n++)
+      ~this.transports.indexOf(t[n]) && e.push(t[n]);
+    return e;
+  }
+}
+let cn = class extends un {
+  constructor(r, t = {}) {
+    const e = typeof r == "object" ? r : t;
+    (!e.transports || e.transports && typeof e.transports[0] == "string") && (e.transports = (e.transports || ["polling", "websocket", "webtransport"]).map((n) => rn[n]).filter((n) => !!n)), super(r, e);
+  }
+};
+function ln(r, t = "", e) {
+  let n = r;
+  e = e || typeof location < "u" && location, r == null && (r = e.protocol + "//" + e.host), typeof r == "string" && (r.charAt(0) === "/" && (r.charAt(1) === "/" ? r = e.protocol + r : r = e.host + r), /^(https?|wss?):\/\//.test(r) || (typeof e < "u" ? r = e.protocol + "//" + r : r = "https://" + r), n = zt(r)), n.port || (/^(http|ws)$/.test(n.protocol) ? n.port = "80" : /^(http|ws)s$/.test(n.protocol) && (n.port = "443")), n.path = n.path || "/";
+  const o = n.host.indexOf(":") !== -1 ? "[" + n.host + "]" : n.host;
+  return n.id = n.protocol + "://" + o + ":" + n.port + t, n.href = n.protocol + "://" + o + (e && e.port === n.port ? "" : ":" + n.port), n;
+}
+const hn = typeof ArrayBuffer == "function", pn = (r) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(r) : r.buffer instanceof ArrayBuffer, rr = Object.prototype.toString, fn = typeof Blob == "function" || typeof Blob < "u" && rr.call(Blob) === "[object BlobConstructor]", dn = typeof File == "function" || typeof File < "u" && rr.call(File) === "[object FileConstructor]";
+function oe(r) {
+  return hn && (r instanceof ArrayBuffer || pn(r)) || fn && r instanceof Blob || dn && r instanceof File;
+}
+function Ut(r, t) {
+  if (!r || typeof r != "object")
+    return !1;
+  if (Array.isArray(r)) {
+    for (let e = 0, n = r.length; e < n; e++)
+      if (Ut(r[e]))
+        return !0;
+    return !1;
+  }
+  if (oe(r))
+    return !0;
+  if (r.toJSON && typeof r.toJSON == "function" && arguments.length === 1)
+    return Ut(r.toJSON(), !0);
+  for (const e in r)
+    if (Object.prototype.hasOwnProperty.call(r, e) && Ut(r[e]))
+      return !0;
+  return !1;
+}
+function yn(r) {
+  const t = [], e = r.data, n = r;
+  return n.data = Vt(e, t), n.attachments = t.length, { packet: n, buffers: t };
+}
+function Vt(r, t) {
+  if (!r)
+    return r;
+  if (oe(r)) {
+    const e = { _placeholder: !0, num: t.length };
+    return t.push(r), e;
+  } else if (Array.isArray(r)) {
+    const e = new Array(r.length);
+    for (let n = 0; n < r.length; n++)
+      e[n] = Vt(r[n], t);
+    return e;
+  } else if (typeof r == "object" && !(r instanceof Date)) {
+    const e = {};
+    for (const n in r)
+      Object.prototype.hasOwnProperty.call(r, n) && (e[n] = Vt(r[n], t));
+    return e;
+  }
+  return r;
+}
+function gn(r, t) {
+  return r.data = Kt(r.data, t), delete r.attachments, r;
+}
+function Kt(r, t) {
+  if (!r)
+    return r;
+  if (r && r._placeholder === !0) {
+    if (typeof r.num == "number" && r.num >= 0 && r.num < t.length)
+      return t[r.num];
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(r))
+    for (let e = 0; e < r.length; e++)
+      r[e] = Kt(r[e], t);
+  else if (typeof r == "object")
+    for (const e in r)
+      Object.prototype.hasOwnProperty.call(r, e) && (r[e] = Kt(r[e], t));
+  return r;
+}
+const mn = [
+  "connect",
+  "connect_error",
+  "disconnect",
+  "disconnecting",
+  "newListener",
+  "removeListener"
+  // used by the Node.js EventEmitter
+], vn = 5;
+var T;
+(function(r) {
+  r[r.CONNECT = 0] = "CONNECT", r[r.DISCONNECT = 1] = "DISCONNECT", r[r.EVENT = 2] = "EVENT", r[r.ACK = 3] = "ACK", r[r.CONNECT_ERROR = 4] = "CONNECT_ERROR", r[r.BINARY_EVENT = 5] = "BINARY_EVENT", r[r.BINARY_ACK = 6] = "BINARY_ACK";
+})(T || (T = {}));
+class bn {
+  /**
+   * Encoder constructor
+   *
+   * @param {function} replacer - custom replacer to pass down to JSON.parse
+   */
+  constructor(t) {
+    this.replacer = t;
+  }
+  /**
+   * Encode a packet as a single string if non-binary, or as a
+   * buffer sequence, depending on packet type.
+   *
+   * @param {Object} obj - packet object
+   */
+  encode(t) {
+    return (t.type === T.EVENT || t.type === T.ACK) && Ut(t) ? this.encodeAsBinary({
+      type: t.type === T.EVENT ? T.BINARY_EVENT : T.BINARY_ACK,
+      nsp: t.nsp,
+      data: t.data,
+      id: t.id
+    }) : [this.encodeAsString(t)];
+  }
+  /**
+   * Encode packet as string.
+   */
+  encodeAsString(t) {
+    let e = "" + t.type;
+    return (t.type === T.BINARY_EVENT || t.type === T.BINARY_ACK) && (e += t.attachments + "-"), t.nsp && t.nsp !== "/" && (e += t.nsp + ","), t.id != null && (e += t.id), t.data != null && (e += JSON.stringify(t.data, this.replacer)), e;
+  }
+  /**
+   * Encode packet as 'buffer sequence' by removing blobs, and
+   * deconstructing packet into object with placeholders and
+   * a list of buffers.
+   */
+  encodeAsBinary(t) {
+    const e = yn(t), n = this.encodeAsString(e.packet), o = e.buffers;
+    return o.unshift(n), o;
+  }
+}
+function me(r) {
+  return Object.prototype.toString.call(r) === "[object Object]";
+}
+class ie extends D {
+  /**
+   * Decoder constructor
+   *
+   * @param {function} reviver - custom reviver to pass down to JSON.stringify
+   */
+  constructor(t) {
+    super(), this.reviver = t;
+  }
+  /**
+   * Decodes an encoded packet string into packet JSON.
+   *
+   * @param {String} obj - encoded packet
+   */
+  add(t) {
+    let e;
+    if (typeof t == "string") {
+      if (this.reconstructor)
+        throw new Error("got plaintext data when reconstructing a packet");
+      e = this.decodeString(t);
+      const n = e.type === T.BINARY_EVENT;
+      n || e.type === T.BINARY_ACK ? (e.type = n ? T.EVENT : T.ACK, this.reconstructor = new _n(e), e.attachments === 0 && super.emitReserved("decoded", e)) : super.emitReserved("decoded", e);
+    } else if (oe(t) || t.base64)
+      if (this.reconstructor)
+        e = this.reconstructor.takeBinaryData(t), e && (this.reconstructor = null, super.emitReserved("decoded", e));
+      else
+        throw new Error("got binary data when not reconstructing a packet");
+    else
+      throw new Error("Unknown type: " + t);
+  }
+  /**
+   * Decode a packet String (JSON data)
+   *
+   * @param {String} str
+   * @return {Object} packet
+   */
+  decodeString(t) {
+    let e = 0;
+    const n = {
+      type: Number(t.charAt(0))
+    };
+    if (T[n.type] === void 0)
+      throw new Error("unknown packet type " + n.type);
+    if (n.type === T.BINARY_EVENT || n.type === T.BINARY_ACK) {
+      const i = e + 1;
+      for (; t.charAt(++e) !== "-" && e != t.length; )
+        ;
+      const u = t.substring(i, e);
+      if (u != Number(u) || t.charAt(e) !== "-")
+        throw new Error("Illegal attachments");
+      n.attachments = Number(u);
+    }
+    if (t.charAt(e + 1) === "/") {
+      const i = e + 1;
+      for (; ++e && !(t.charAt(e) === "," || e === t.length); )
+        ;
+      n.nsp = t.substring(i, e);
+    } else
+      n.nsp = "/";
+    const o = t.charAt(e + 1);
+    if (o !== "" && Number(o) == o) {
+      const i = e + 1;
+      for (; ++e; ) {
+        const u = t.charAt(e);
+        if (u == null || Number(u) != u) {
+          --e;
+          break;
+        }
+        if (e === t.length)
+          break;
+      }
+      n.id = Number(t.substring(i, e + 1));
+    }
+    if (t.charAt(++e)) {
+      const i = this.tryParse(t.substr(e));
+      if (ie.isPayloadValid(n.type, i))
+        n.data = i;
+      else
+        throw new Error("invalid payload");
+    }
+    return n;
+  }
+  tryParse(t) {
+    try {
+      return JSON.parse(t, this.reviver);
+    } catch {
+      return !1;
+    }
+  }
+  static isPayloadValid(t, e) {
+    switch (t) {
+      case T.CONNECT:
+        return me(e);
+      case T.DISCONNECT:
+        return e === void 0;
+      case T.CONNECT_ERROR:
+        return typeof e == "string" || me(e);
+      case T.EVENT:
+      case T.BINARY_EVENT:
+        return Array.isArray(e) && (typeof e[0] == "number" || typeof e[0] == "string" && mn.indexOf(e[0]) === -1);
+      case T.ACK:
+      case T.BINARY_ACK:
+        return Array.isArray(e);
+    }
+  }
+  /**
+   * Deallocates a parser's resources
+   */
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class _n {
+  constructor(t) {
+    this.packet = t, this.buffers = [], this.reconPack = t;
+  }
+  /**
+   * Method to be called when binary data received from connection
+   * after a BINARY_EVENT packet.
+   *
+   * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+   * @return {null | Object} returns null if more binary data is expected or
+   *   a reconstructed packet object if all buffers have been received.
+   */
+  takeBinaryData(t) {
+    if (this.buffers.push(t), this.buffers.length === this.reconPack.attachments) {
+      const e = gn(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), e;
+    }
+    return null;
+  }
+  /**
+   * Cleans up binary packet reconstruction variables.
+   */
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+const wn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Decoder: ie,
+  Encoder: bn,
+  get PacketType() {
+    return T;
+  },
+  protocol: vn
+}, Symbol.toStringTag, { value: "Module" }));
+function W(r, t, e) {
+  return r.on(t, e), function() {
+    r.off(t, e);
+  };
+}
+const En = Object.freeze({
+  connect: 1,
+  connect_error: 1,
+  disconnect: 1,
+  disconnecting: 1,
+  // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+  newListener: 1,
+  removeListener: 1
+});
+class nr extends D {
+  /**
+   * `Socket` constructor.
+   */
+  constructor(t, e, 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 = t, this.nsp = e, n && n.auth && (this.auth = n.auth), this._opts = Object.assign({}, n), this.io._autoConnect && this.open();
+  }
+  /**
+   * Whether the socket is currently disconnected
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("connect", () => {
+   *   console.log(socket.disconnected); // false
+   * });
+   *
+   * socket.on("disconnect", () => {
+   *   console.log(socket.disconnected); // true
+   * });
+   */
+  get disconnected() {
+    return !this.connected;
+  }
+  /**
+   * Subscribe to open, close and packet events
+   *
+   * @private
+   */
+  subEvents() {
+    if (this.subs)
+      return;
+    const t = this.io;
+    this.subs = [
+      W(t, "open", this.onopen.bind(this)),
+      W(t, "packet", this.onpacket.bind(this)),
+      W(t, "error", this.onerror.bind(this)),
+      W(t, "close", this.onclose.bind(this))
+    ];
+  }
+  /**
+   * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+   *
+   * @example
+   * const socket = io();
+   *
+   * console.log(socket.active); // true
+   *
+   * socket.on("disconnect", (reason) => {
+   *   if (reason === "io server disconnect") {
+   *     // the disconnection was initiated by the server, you need to manually reconnect
+   *     console.log(socket.active); // false
+   *   }
+   *   // else the socket will automatically try to reconnect
+   *   console.log(socket.active); // true
+   * });
+   */
+  get active() {
+    return !!this.subs;
+  }
+  /**
+   * "Opens" the socket.
+   *
+   * @example
+   * const socket = io({
+   *   autoConnect: false
+   * });
+   *
+   * socket.connect();
+   */
+  connect() {
+    return this.connected ? this : (this.subEvents(), this.io._reconnecting || this.io.open(), this.io._readyState === "open" && this.onopen(), this);
+  }
+  /**
+   * Alias for {@link connect()}.
+   */
+  open() {
+    return this.connect();
+  }
+  /**
+   * Sends a `message` event.
+   *
+   * This method mimics the WebSocket.send() method.
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+   *
+   * @example
+   * socket.send("hello");
+   *
+   * // this is equivalent to
+   * socket.emit("message", "hello");
+   *
+   * @return self
+   */
+  send(...t) {
+    return t.unshift("message"), this.emit.apply(this, t), this;
+  }
+  /**
+   * Override `emit`.
+   * If the event is in `events`, it's emitted normally.
+   *
+   * @example
+   * socket.emit("hello", "world");
+   *
+   * // all serializable datastructures are supported (no need to call JSON.stringify)
+   * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+   *
+   * // with an acknowledgement from the server
+   * socket.emit("hello", "world", (val) => {
+   *   // ...
+   * });
+   *
+   * @return self
+   */
+  emit(t, ...e) {
+    var n, o, i;
+    if (En.hasOwnProperty(t))
+      throw new Error('"' + t.toString() + '" is a reserved event name');
+    if (e.unshift(t), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile)
+      return this._addToQueue(e), this;
+    const u = {
+      type: T.EVENT,
+      data: e
+    };
+    if (u.options = {}, u.options.compress = this.flags.compress !== !1, typeof e[e.length - 1] == "function") {
+      const d = this.ids++, _ = e.pop();
+      this._registerAckCallback(d, _), u.id = d;
+    }
+    const l = (o = (n = this.io.engine) === null || n === void 0 ? void 0 : n.transport) === null || o === void 0 ? void 0 : o.writable, f = this.connected && !(!((i = this.io.engine) === null || i === void 0) && i._hasPingExpired());
+    return this.flags.volatile && !l || (f ? (this.notifyOutgoingListeners(u), this.packet(u)) : this.sendBuffer.push(u)), this.flags = {}, this;
+  }
+  /**
+   * @private
+   */
+  _registerAckCallback(t, e) {
+    var n;
+    const o = (n = this.flags.timeout) !== null && n !== void 0 ? n : this._opts.ackTimeout;
+    if (o === void 0) {
+      this.acks[t] = e;
+      return;
+    }
+    const i = this.io.setTimeoutFn(() => {
+      delete this.acks[t];
+      for (let l = 0; l < this.sendBuffer.length; l++)
+        this.sendBuffer[l].id === t && this.sendBuffer.splice(l, 1);
+      e.call(this, new Error("operation has timed out"));
+    }, o), u = (...l) => {
+      this.io.clearTimeoutFn(i), e.apply(this, l);
+    };
+    u.withError = !0, this.acks[t] = u;
+  }
+  /**
+   * Emits an event and waits for an acknowledgement
+   *
+   * @example
+   * // without timeout
+   * const response = await socket.emitWithAck("hello", "world");
+   *
+   * // with a specific timeout
+   * try {
+   *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+   * } catch (err) {
+   *   // the server did not acknowledge the event in the given delay
+   * }
+   *
+   * @return a Promise that will be fulfilled when the server acknowledges the event
+   */
+  emitWithAck(t, ...e) {
+    return new Promise((n, o) => {
+      const i = (u, l) => u ? o(u) : n(l);
+      i.withError = !0, e.push(i), this.emit(t, ...e);
+    });
+  }
+  /**
+   * Add the packet to the queue.
+   * @param args
+   * @private
+   */
+  _addToQueue(t) {
+    let e;
+    typeof t[t.length - 1] == "function" && (e = t.pop());
+    const n = {
+      id: this._queueSeq++,
+      tryCount: 0,
+      pending: !1,
+      args: t,
+      flags: Object.assign({ fromQueue: !0 }, this.flags)
+    };
+    t.push((o, ...i) => n !== this._queue[0] ? void 0 : (o !== null ? n.tryCount > this._opts.retries && (this._queue.shift(), e && e(o)) : (this._queue.shift(), e && e(null, ...i)), n.pending = !1, this._drainQueue())), this._queue.push(n), this._drainQueue();
+  }
+  /**
+   * Send the first packet of the queue, and wait for an acknowledgement from the server.
+   * @param force - whether to resend a packet that has not been acknowledged yet
+   *
+   * @private
+   */
+  _drainQueue(t = !1) {
+    if (!this.connected || this._queue.length === 0)
+      return;
+    const e = this._queue[0];
+    e.pending && !t || (e.pending = !0, e.tryCount++, this.flags = e.flags, this.emit.apply(this, e.args));
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param packet
+   * @private
+   */
+  packet(t) {
+    t.nsp = this.nsp, this.io._packet(t);
+  }
+  /**
+   * Called upon engine `open`.
+   *
+   * @private
+   */
+  onopen() {
+    typeof this.auth == "function" ? this.auth((t) => {
+      this._sendConnectPacket(t);
+    }) : this._sendConnectPacket(this.auth);
+  }
+  /**
+   * Sends a CONNECT packet to initiate the Socket.IO session.
+   *
+   * @param data
+   * @private
+   */
+  _sendConnectPacket(t) {
+    this.packet({
+      type: T.CONNECT,
+      data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, t) : t
+    });
+  }
+  /**
+   * Called upon engine or manager `error`.
+   *
+   * @param err
+   * @private
+   */
+  onerror(t) {
+    this.connected || this.emitReserved("connect_error", t);
+  }
+  /**
+   * Called upon engine `close`.
+   *
+   * @param reason
+   * @param description
+   * @private
+   */
+  onclose(t, e) {
+    this.connected = !1, delete this.id, this.emitReserved("disconnect", t, e), this._clearAcks();
+  }
+  /**
+   * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+   * the server.
+   *
+   * @private
+   */
+  _clearAcks() {
+    Object.keys(this.acks).forEach((t) => {
+      if (!this.sendBuffer.some((e) => String(e.id) === t)) {
+        const e = this.acks[t];
+        delete this.acks[t], e.withError && e.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+  /**
+   * Called with socket packet.
+   *
+   * @param packet
+   * @private
+   */
+  onpacket(t) {
+    if (t.nsp === this.nsp)
+      switch (t.type) {
+        case T.CONNECT:
+          t.data && t.data.sid ? this.onconnect(t.data.sid, t.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 T.EVENT:
+        case T.BINARY_EVENT:
+          this.onevent(t);
+          break;
+        case T.ACK:
+        case T.BINARY_ACK:
+          this.onack(t);
+          break;
+        case T.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case T.CONNECT_ERROR:
+          this.destroy();
+          const e = new Error(t.data.message);
+          e.data = t.data.data, this.emitReserved("connect_error", e);
+          break;
+      }
+  }
+  /**
+   * Called upon a server event.
+   *
+   * @param packet
+   * @private
+   */
+  onevent(t) {
+    const e = t.data || [];
+    t.id != null && e.push(this.ack(t.id)), this.connected ? this.emitEvent(e) : this.receiveBuffer.push(Object.freeze(e));
+  }
+  emitEvent(t) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const e = this._anyListeners.slice();
+      for (const n of e)
+        n.apply(this, t);
+    }
+    super.emit.apply(this, t), this._pid && t.length && typeof t[t.length - 1] == "string" && (this._lastOffset = t[t.length - 1]);
+  }
+  /**
+   * Produces an ack callback to emit with an event.
+   *
+   * @private
+   */
+  ack(t) {
+    const e = this;
+    let n = !1;
+    return function(...o) {
+      n || (n = !0, e.packet({
+        type: T.ACK,
+        id: t,
+        data: o
+      }));
+    };
+  }
+  /**
+   * Called upon a server acknowledgement.
+   *
+   * @param packet
+   * @private
+   */
+  onack(t) {
+    const e = this.acks[t.id];
+    typeof e == "function" && (delete this.acks[t.id], e.withError && t.data.unshift(null), e.apply(this, t.data));
+  }
+  /**
+   * Called upon server connect.
+   *
+   * @private
+   */
+  onconnect(t, e) {
+    this.id = t, this.recovered = e && this._pid === e, this._pid = e, this.connected = !0, this.emitBuffered(), this.emitReserved("connect"), this._drainQueue(!0);
+  }
+  /**
+   * Emit buffered events (received and emitted).
+   *
+   * @private
+   */
+  emitBuffered() {
+    this.receiveBuffer.forEach((t) => this.emitEvent(t)), this.receiveBuffer = [], this.sendBuffer.forEach((t) => {
+      this.notifyOutgoingListeners(t), this.packet(t);
+    }), this.sendBuffer = [];
+  }
+  /**
+   * Called upon server disconnect.
+   *
+   * @private
+   */
+  ondisconnect() {
+    this.destroy(), this.onclose("io server disconnect");
+  }
+  /**
+   * Called upon forced client/server side disconnections,
+   * this method ensures the manager stops tracking us and
+   * that reconnections don't get triggered for this.
+   *
+   * @private
+   */
+  destroy() {
+    this.subs && (this.subs.forEach((t) => t()), this.subs = void 0), this.io._destroy(this);
+  }
+  /**
+   * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+   *
+   * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("disconnect", (reason) => {
+   *   // console.log(reason); prints "io client disconnect"
+   * });
+   *
+   * socket.disconnect();
+   *
+   * @return self
+   */
+  disconnect() {
+    return this.connected && this.packet({ type: T.DISCONNECT }), this.destroy(), this.connected && this.onclose("io client disconnect"), this;
+  }
+  /**
+   * Alias for {@link disconnect()}.
+   *
+   * @return self
+   */
+  close() {
+    return this.disconnect();
+  }
+  /**
+   * Sets the compress flag.
+   *
+   * @example
+   * socket.compress(false).emit("hello");
+   *
+   * @param compress - if `true`, compresses the sending data
+   * @return self
+   */
+  compress(t) {
+    return this.flags.compress = t, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+   * ready to send messages.
+   *
+   * @example
+   * socket.volatile.emit("hello"); // the server may or may not receive it
+   *
+   * @returns self
+   */
+  get volatile() {
+    return this.flags.volatile = !0, this;
+  }
+  /**
+   * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+   * given number of milliseconds have elapsed without an acknowledgement from the server:
+   *
+   * @example
+   * socket.timeout(5000).emit("my-event", (err) => {
+   *   if (err) {
+   *     // the server did not acknowledge the event in the given delay
+   *   }
+   * });
+   *
+   * @returns self
+   */
+  timeout(t) {
+    return this.flags.timeout = t, this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * @example
+   * socket.onAny((event, ...args) => {
+   *   console.log(`got ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * @example
+   * socket.prependAny((event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAny(t) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`got event ${event}`);
+   * }
+   *
+   * socket.onAny(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAny(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAny();
+   *
+   * @param listener
+   */
+  offAny(t) {
+    if (!this._anyListeners)
+      return this;
+    if (t) {
+      const e = this._anyListeners;
+      for (let n = 0; n < e.length; n++)
+        if (t === e[n])
+          return e.splice(n, 1), this;
+    } else
+      this._anyListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAny() {
+    return this._anyListeners || [];
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.onAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  onAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(t), this;
+  }
+  /**
+   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+   * callback. The listener is added to the beginning of the listeners array.
+   *
+   * Note: acknowledgements sent to the server are not included.
+   *
+   * @example
+   * socket.prependAnyOutgoing((event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * });
+   *
+   * @param listener
+   */
+  prependAnyOutgoing(t) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(t), this;
+  }
+  /**
+   * Removes the listener that will be fired when any event is emitted.
+   *
+   * @example
+   * const catchAllListener = (event, ...args) => {
+   *   console.log(`sent event ${event}`);
+   * }
+   *
+   * socket.onAnyOutgoing(catchAllListener);
+   *
+   * // remove a specific listener
+   * socket.offAnyOutgoing(catchAllListener);
+   *
+   * // or remove all listeners
+   * socket.offAnyOutgoing();
+   *
+   * @param [listener] - the catch-all listener (optional)
+   */
+  offAnyOutgoing(t) {
+    if (!this._anyOutgoingListeners)
+      return this;
+    if (t) {
+      const e = this._anyOutgoingListeners;
+      for (let n = 0; n < e.length; n++)
+        if (t === e[n])
+          return e.splice(n, 1), this;
+    } else
+      this._anyOutgoingListeners = [];
+    return this;
+  }
+  /**
+   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+   * e.g. to remove listeners.
+   */
+  listenersAnyOutgoing() {
+    return this._anyOutgoingListeners || [];
+  }
+  /**
+   * Notify the listeners for each packet sent
+   *
+   * @param packet
+   *
+   * @private
+   */
+  notifyOutgoingListeners(t) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const e = this._anyOutgoingListeners.slice();
+      for (const n of e)
+        n.apply(this, t.data);
+    }
+  }
+}
+function it(r) {
+  r = r || {}, this.ms = r.min || 100, this.max = r.max || 1e4, this.factor = r.factor || 2, this.jitter = r.jitter > 0 && r.jitter <= 1 ? r.jitter : 0, this.attempts = 0;
+}
+it.prototype.duration = function() {
+  var r = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var t = Math.random(), e = Math.floor(t * this.jitter * r);
+    r = (Math.floor(t * 10) & 1) == 0 ? r - e : r + e;
+  }
+  return Math.min(r, this.max) | 0;
+};
+it.prototype.reset = function() {
+  this.attempts = 0;
+};
+it.prototype.setMin = function(r) {
+  this.ms = r;
+};
+it.prototype.setMax = function(r) {
+  this.max = r;
+};
+it.prototype.setJitter = function(r) {
+  this.jitter = r;
+};
+class Gt extends D {
+  constructor(t, e) {
+    var n;
+    super(), this.nsps = {}, this.subs = [], t && typeof t == "object" && (e = t, t = void 0), e = e || {}, e.path = e.path || "/socket.io", this.opts = e, Lt(this, e), this.reconnection(e.reconnection !== !1), this.reconnectionAttempts(e.reconnectionAttempts || 1 / 0), this.reconnectionDelay(e.reconnectionDelay || 1e3), this.reconnectionDelayMax(e.reconnectionDelayMax || 5e3), this.randomizationFactor((n = e.randomizationFactor) !== null && n !== void 0 ? n : 0.5), this.backoff = new it({
+      min: this.reconnectionDelay(),
+      max: this.reconnectionDelayMax(),
+      jitter: this.randomizationFactor()
+    }), this.timeout(e.timeout == null ? 2e4 : e.timeout), this._readyState = "closed", this.uri = t;
+    const o = e.parser || wn;
+    this.encoder = new o.Encoder(), this.decoder = new o.Decoder(), this._autoConnect = e.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(t) {
+    return arguments.length ? (this._reconnection = !!t, t || (this.skipReconnect = !0), this) : this._reconnection;
+  }
+  reconnectionAttempts(t) {
+    return t === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = t, this);
+  }
+  reconnectionDelay(t) {
+    var e;
+    return t === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = t, (e = this.backoff) === null || e === void 0 || e.setMin(t), this);
+  }
+  randomizationFactor(t) {
+    var e;
+    return t === void 0 ? this._randomizationFactor : (this._randomizationFactor = t, (e = this.backoff) === null || e === void 0 || e.setJitter(t), this);
+  }
+  reconnectionDelayMax(t) {
+    var e;
+    return t === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = t, (e = this.backoff) === null || e === void 0 || e.setMax(t), this);
+  }
+  timeout(t) {
+    return arguments.length ? (this._timeout = t, this) : this._timeout;
+  }
+  /**
+   * Starts trying to reconnect if reconnection is enabled and we have not
+   * started reconnecting yet
+   *
+   * @private
+   */
+  maybeReconnectOnOpen() {
+    !this._reconnecting && this._reconnection && this.backoff.attempts === 0 && this.reconnect();
+  }
+  /**
+   * Sets the current transport `socket`.
+   *
+   * @param {Function} fn - optional, callback
+   * @return self
+   * @public
+   */
+  open(t) {
+    if (~this._readyState.indexOf("open"))
+      return this;
+    this.engine = new cn(this.uri, this.opts);
+    const e = this.engine, n = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const o = W(e, "open", function() {
+      n.onopen(), t && t();
+    }), i = (l) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", l), t ? t(l) : this.maybeReconnectOnOpen();
+    }, u = W(e, "error", i);
+    if (this._timeout !== !1) {
+      const l = this._timeout, f = this.setTimeoutFn(() => {
+        o(), i(new Error("timeout")), e.close();
+      }, l);
+      this.opts.autoUnref && f.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(f);
+      });
+    }
+    return this.subs.push(o), this.subs.push(u), this;
+  }
+  /**
+   * Alias for open()
+   *
+   * @return self
+   * @public
+   */
+  connect(t) {
+    return this.open(t);
+  }
+  /**
+   * Called upon transport open.
+   *
+   * @private
+   */
+  onopen() {
+    this.cleanup(), this._readyState = "open", this.emitReserved("open");
+    const t = this.engine;
+    this.subs.push(
+      W(t, "ping", this.onping.bind(this)),
+      W(t, "data", this.ondata.bind(this)),
+      W(t, "error", this.onerror.bind(this)),
+      W(t, "close", this.onclose.bind(this)),
+      // @ts-ignore
+      W(this.decoder, "decoded", this.ondecoded.bind(this))
+    );
+  }
+  /**
+   * Called upon a ping.
+   *
+   * @private
+   */
+  onping() {
+    this.emitReserved("ping");
+  }
+  /**
+   * Called with data.
+   *
+   * @private
+   */
+  ondata(t) {
+    try {
+      this.decoder.add(t);
+    } catch (e) {
+      this.onclose("parse error", e);
+    }
+  }
+  /**
+   * Called when parser fully decodes a packet.
+   *
+   * @private
+   */
+  ondecoded(t) {
+    Pt(() => {
+      this.emitReserved("packet", t);
+    }, this.setTimeoutFn);
+  }
+  /**
+   * Called upon socket error.
+   *
+   * @private
+   */
+  onerror(t) {
+    this.emitReserved("error", t);
+  }
+  /**
+   * Creates a new socket for the given `nsp`.
+   *
+   * @return {Socket}
+   * @public
+   */
+  socket(t, e) {
+    let n = this.nsps[t];
+    return n ? this._autoConnect && !n.active && n.connect() : (n = new nr(this, t, e), this.nsps[t] = n), n;
+  }
+  /**
+   * Called upon a socket close.
+   *
+   * @param socket
+   * @private
+   */
+  _destroy(t) {
+    const e = Object.keys(this.nsps);
+    for (const n of e)
+      if (this.nsps[n].active)
+        return;
+    this._close();
+  }
+  /**
+   * Writes a packet.
+   *
+   * @param packet
+   * @private
+   */
+  _packet(t) {
+    const e = this.encoder.encode(t);
+    for (let n = 0; n < e.length; n++)
+      this.engine.write(e[n], t.options);
+  }
+  /**
+   * Clean up transport subscriptions and packet buffer.
+   *
+   * @private
+   */
+  cleanup() {
+    this.subs.forEach((t) => t()), this.subs.length = 0, this.decoder.destroy();
+  }
+  /**
+   * Close the current socket.
+   *
+   * @private
+   */
+  _close() {
+    this.skipReconnect = !0, this._reconnecting = !1, this.onclose("forced close");
+  }
+  /**
+   * Alias for close()
+   *
+   * @private
+   */
+  disconnect() {
+    return this._close();
+  }
+  /**
+   * Called when:
+   *
+   * - the low-level engine is closed
+   * - the parser encountered a badly formatted packet
+   * - all sockets are disconnected
+   *
+   * @private
+   */
+  onclose(t, e) {
+    var n;
+    this.cleanup(), (n = this.engine) === null || n === void 0 || n.close(), this.backoff.reset(), this._readyState = "closed", this.emitReserved("close", t, e), this._reconnection && !this.skipReconnect && this.reconnect();
+  }
+  /**
+   * Attempt a reconnection.
+   *
+   * @private
+   */
+  reconnect() {
+    if (this._reconnecting || this.skipReconnect)
+      return this;
+    const t = this;
+    if (this.backoff.attempts >= this._reconnectionAttempts)
+      this.backoff.reset(), this.emitReserved("reconnect_failed"), this._reconnecting = !1;
+    else {
+      const e = this.backoff.duration();
+      this._reconnecting = !0;
+      const n = this.setTimeoutFn(() => {
+        t.skipReconnect || (this.emitReserved("reconnect_attempt", t.backoff.attempts), !t.skipReconnect && t.open((o) => {
+          o ? (t._reconnecting = !1, t.reconnect(), this.emitReserved("reconnect_error", o)) : t.onreconnect();
+        }));
+      }, e);
+      this.opts.autoUnref && n.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(n);
+      });
+    }
+  }
+  /**
+   * Called upon successful reconnect.
+   *
+   * @private
+   */
+  onreconnect() {
+    const t = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", t);
+  }
+}
+const at = {};
+function Nt(r, t) {
+  typeof r == "object" && (t = r, r = void 0), t = t || {};
+  const e = ln(r, t.path || "/socket.io"), n = e.source, o = e.id, i = e.path, u = at[o] && i in at[o].nsps, l = t.forceNew || t["force new connection"] || t.multiplex === !1 || u;
+  let f;
+  return l ? f = new Gt(n, t) : (at[o] || (at[o] = new Gt(n, t)), f = at[o]), e.query && !t.query && (t.query = e.queryKey), f.socket(e.path, t);
+}
+Object.assign(Nt, {
+  Manager: Gt,
+  Socket: nr,
+  io: Nt,
+  connect: Nt
+});
+/*!
+ * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+ * (c) Dani Biro
+ * @license MIT
+ */
+function kn(r, t, e, n) {
+  function o(i) {
+    return i instanceof e ? i : new e(function(u) {
+      u(i);
+    });
+  }
+  return new (e || (e = Promise))(function(i, u) {
+    function l(_) {
+      try {
+        d(n.next(_));
+      } catch (L) {
+        u(L);
+      }
+    }
+    function f(_) {
+      try {
+        d(n.throw(_));
+      } catch (L) {
+        u(L);
+      }
+    }
+    function d(_) {
+      _.done ? i(_.value) : o(_.value).then(l, f);
+    }
+    d((n = n.apply(r, [])).next());
+  });
+}
+class I {
+  constructor() {
+    this.mutex = Promise.resolve();
+  }
+  lock() {
+    let t = () => {
+    };
+    return this.mutex = this.mutex.then(() => new Promise(t)), new Promise((e) => {
+      t = e;
+    });
+  }
+  dispatch(t) {
+    return kn(this, void 0, void 0, function* () {
+      const e = yield this.lock();
+      try {
+        return yield Promise.resolve(t());
+      } finally {
+        e();
+      }
+    });
+  }
+}
+function Sn() {
+  return typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global;
+}
+const ve = Sn();
+ve.TextEncoder && new ve.TextEncoder();
+const be = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", On = new Uint8Array(256);
+for (let r = 0; r < be.length; r++)
+  On[be.charCodeAt(r)] = r;
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+new I();
+function Yt(r) {
+  "@babel/helpers - typeof";
+  return Yt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, Yt(r);
+}
+function xn(r, t, e) {
+  return Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Un(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Rn(r, t, e) {
+  return t = pt(t), Tn(r, se() ? Reflect.construct(t, e || [], pt(r).constructor) : t.apply(r, e));
+}
+function Tn(r, t) {
+  if (t && (Yt(t) === "object" || typeof t == "function"))
+    return t;
+  if (t !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return Cn(r);
+}
+function Cn(r) {
+  if (r === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function Pn(r, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(t && t.prototype, { constructor: { value: r, writable: !0, configurable: !0 } }), Object.defineProperty(r, "prototype", { writable: !1 }), t && ht(r, t);
+}
+function Wt(r) {
+  var t = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;
+  return Wt = function(e) {
+    if (e === null || !An(e)) return e;
+    if (typeof e != "function")
+      throw new TypeError("Super expression must either be null or a function");
+    if (typeof t < "u") {
+      if (t.has(e)) return t.get(e);
+      t.set(e, n);
+    }
+    function n() {
+      return Ln(e, arguments, pt(this).constructor);
+    }
+    return n.prototype = Object.create(e.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), ht(n, e);
+  }, Wt(r);
+}
+function Ln(r, t, e) {
+  if (se()) return Reflect.construct.apply(null, arguments);
+  var n = [null];
+  n.push.apply(n, t);
+  var o = new (r.bind.apply(r, n))();
+  return e && ht(o, e.prototype), o;
+}
+function se() {
+  try {
+    var r = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (se = function() {
+    return !!r;
+  })();
+}
+function An(r) {
+  try {
+    return Function.toString.call(r).indexOf("[native code]") !== -1;
+  } catch {
+    return typeof r == "function";
+  }
+}
+function ht(r, t) {
+  return ht = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, n) {
+    return e.__proto__ = n, e;
+  }, ht(r, t);
+}
+function pt(r) {
+  return pt = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, pt(r);
+}
+var wt = /* @__PURE__ */ (function(r) {
+  function t(e) {
+    var n, o = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : null, u = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
+    if (Un(this, t), n = Rn(this, t, [e]), n.originalRequest = i, n.originalResponse = u, n.causingError = o, o != null && (e += ", caused by ".concat(o.toString())), i != null) {
+      var l = i.getHeader("X-Request-ID") || "n/a", f = i.getMethod(), d = i.getURL(), _ = u ? u.getStatus() : "n/a", L = u ? u.getBody() || "" : "n/a";
+      e += ", originated from request (method: ".concat(f, ", url: ").concat(d, ", response code: ").concat(_, ", response text: ").concat(L, ", request id: ").concat(l, ")");
+    }
+    return n.message = e, n;
+  }
+  return Pn(t, r), xn(t);
+})(/* @__PURE__ */ Wt(Error));
+function ft(r) {
+  "@babel/helpers - typeof";
+  return ft = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, ft(r);
+}
+function jn(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Bn(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, In(n.key), n);
+  }
+}
+function Nn(r, t, e) {
+  return t && Bn(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function In(r) {
+  var t = Dn(r, "string");
+  return ft(t) == "symbol" ? t : t + "";
+}
+function Dn(r, t) {
+  if (ft(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (ft(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var qn = /* @__PURE__ */ (function() {
+  function r() {
+    jn(this, r);
+  }
+  return Nn(r, [{
+    key: "listAllUploads",
+    value: function() {
+      return Promise.resolve([]);
+    }
+  }, {
+    key: "findUploadsByFingerprint",
+    value: function(t) {
+      return Promise.resolve([]);
+    }
+  }, {
+    key: "removeUpload",
+    value: function(t) {
+      return Promise.resolve();
+    }
+  }, {
+    key: "addUpload",
+    value: function(t, e) {
+      return Promise.resolve(null);
+    }
+  }]);
+})();
+const or = "3.7.7", Fn = or, st = typeof Buffer == "function", _e = typeof TextDecoder == "function" ? new TextDecoder() : void 0, we = typeof TextEncoder == "function" ? new TextEncoder() : void 0, Hn = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", ct = Array.prototype.slice.call(Hn), Et = ((r) => {
+  let t = {};
+  return r.forEach((e, n) => t[e] = n), t;
+})(ct), zn = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/, F = String.fromCharCode.bind(String), Ee = typeof Uint8Array.from == "function" ? Uint8Array.from.bind(Uint8Array) : (r) => new Uint8Array(Array.prototype.slice.call(r, 0)), ir = (r) => r.replace(/=/g, "").replace(/[+\/]/g, (t) => t == "+" ? "-" : "_"), sr = (r) => r.replace(/[^A-Za-z0-9\+\/]/g, ""), ar = (r) => {
+  let t, e, n, o, i = "";
+  const u = r.length % 3;
+  for (let l = 0; l < r.length; ) {
+    if ((e = r.charCodeAt(l++)) > 255 || (n = r.charCodeAt(l++)) > 255 || (o = r.charCodeAt(l++)) > 255)
+      throw new TypeError("invalid character found");
+    t = e << 16 | n << 8 | o, i += ct[t >> 18 & 63] + ct[t >> 12 & 63] + ct[t >> 6 & 63] + ct[t & 63];
+  }
+  return u ? i.slice(0, u - 3) + "===".substring(u) : i;
+}, ae = typeof btoa == "function" ? (r) => btoa(r) : st ? (r) => Buffer.from(r, "binary").toString("base64") : ar, Jt = st ? (r) => Buffer.from(r).toString("base64") : (r) => {
+  let t = [];
+  for (let e = 0, n = r.length; e < n; e += 4096)
+    t.push(F.apply(null, r.subarray(e, e + 4096)));
+  return ae(t.join(""));
+}, Rt = (r, t = !1) => t ? ir(Jt(r)) : Jt(r), Mn = (r) => {
+  if (r.length < 2) {
+    var t = r.charCodeAt(0);
+    return t < 128 ? r : t < 2048 ? F(192 | t >>> 6) + F(128 | t & 63) : F(224 | t >>> 12 & 15) + F(128 | t >>> 6 & 63) + F(128 | t & 63);
+  } else {
+    var t = 65536 + (r.charCodeAt(0) - 55296) * 1024 + (r.charCodeAt(1) - 56320);
+    return F(240 | t >>> 18 & 7) + F(128 | t >>> 12 & 63) + F(128 | t >>> 6 & 63) + F(128 | t & 63);
+  }
+}, Vn = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g, ur = (r) => r.replace(Vn, Mn), ke = st ? (r) => Buffer.from(r, "utf8").toString("base64") : we ? (r) => Jt(we.encode(r)) : (r) => ae(ur(r)), ot = (r, t = !1) => t ? ir(ke(r)) : ke(r), Se = (r) => ot(r, !0), Kn = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g, Gn = (r) => {
+  switch (r.length) {
+    case 4:
+      var t = (7 & r.charCodeAt(0)) << 18 | (63 & r.charCodeAt(1)) << 12 | (63 & r.charCodeAt(2)) << 6 | 63 & r.charCodeAt(3), e = t - 65536;
+      return F((e >>> 10) + 55296) + F((e & 1023) + 56320);
+    case 3:
+      return F((15 & r.charCodeAt(0)) << 12 | (63 & r.charCodeAt(1)) << 6 | 63 & r.charCodeAt(2));
+    default:
+      return F((31 & r.charCodeAt(0)) << 6 | 63 & r.charCodeAt(1));
+  }
+}, cr = (r) => r.replace(Kn, Gn), lr = (r) => {
+  if (r = r.replace(/\s+/g, ""), !zn.test(r))
+    throw new TypeError("malformed base64.");
+  r += "==".slice(2 - (r.length & 3));
+  let t, e = "", n, o;
+  for (let i = 0; i < r.length; )
+    t = Et[r.charAt(i++)] << 18 | Et[r.charAt(i++)] << 12 | (n = Et[r.charAt(i++)]) << 6 | (o = Et[r.charAt(i++)]), e += n === 64 ? F(t >> 16 & 255) : o === 64 ? F(t >> 16 & 255, t >> 8 & 255) : F(t >> 16 & 255, t >> 8 & 255, t & 255);
+  return e;
+}, ue = typeof atob == "function" ? (r) => atob(sr(r)) : st ? (r) => Buffer.from(r, "base64").toString("binary") : lr, hr = st ? (r) => Ee(Buffer.from(r, "base64")) : (r) => Ee(ue(r).split("").map((t) => t.charCodeAt(0))), pr = (r) => hr(fr(r)), Yn = st ? (r) => Buffer.from(r, "base64").toString("utf8") : _e ? (r) => _e.decode(hr(r)) : (r) => cr(ue(r)), fr = (r) => sr(r.replace(/[-_]/g, (t) => t == "-" ? "+" : "/")), Xt = (r) => Yn(fr(r)), Wn = (r) => {
+  if (typeof r != "string")
+    return !1;
+  const t = r.replace(/\s+/g, "").replace(/={0,2}$/, "");
+  return !/[^\s0-9a-zA-Z\+/]/.test(t) || !/[^\s0-9a-zA-Z\-_]/.test(t);
+}, dr = (r) => ({
+  value: r,
+  enumerable: !1,
+  writable: !0,
+  configurable: !0
+}), yr = function() {
+  const r = (t, e) => Object.defineProperty(String.prototype, t, dr(e));
+  r("fromBase64", function() {
+    return Xt(this);
+  }), r("toBase64", function(t) {
+    return ot(this, t);
+  }), r("toBase64URI", function() {
+    return ot(this, !0);
+  }), r("toBase64URL", function() {
+    return ot(this, !0);
+  }), r("toUint8Array", function() {
+    return pr(this);
+  });
+}, gr = function() {
+  const r = (t, e) => Object.defineProperty(Uint8Array.prototype, t, dr(e));
+  r("toBase64", function(t) {
+    return Rt(this, t);
+  }), r("toBase64URI", function() {
+    return Rt(this, !0);
+  }), r("toBase64URL", function() {
+    return Rt(this, !0);
+  });
+}, Jn = () => {
+  yr(), gr();
+}, Xn = {
+  version: or,
+  VERSION: Fn,
+  atob: ue,
+  atobPolyfill: lr,
+  btoa: ae,
+  btoaPolyfill: ar,
+  fromBase64: Xt,
+  toBase64: ot,
+  encode: ot,
+  encodeURI: Se,
+  encodeURL: Se,
+  utob: ur,
+  btou: cr,
+  decode: Xt,
+  isValid: Wn,
+  fromUint8Array: Rt,
+  toUint8Array: pr,
+  extendString: yr,
+  extendUint8Array: gr,
+  extendBuiltins: Jn
+};
+var Oe, xe;
+function $n() {
+  return xe || (xe = 1, Oe = function(r, t) {
+    if (t = t.split(":")[0], r = +r, !r) return !1;
+    switch (t) {
+      case "http":
+      case "ws":
+        return r !== 80;
+      case "https":
+      case "wss":
+        return r !== 443;
+      case "ftp":
+        return r !== 21;
+      case "gopher":
+        return r !== 70;
+      case "file":
+        return !1;
+    }
+    return r !== 0;
+  }), Oe;
+}
+var kt = {}, Ue;
+function Qn() {
+  if (Ue) return kt;
+  Ue = 1;
+  var r = Object.prototype.hasOwnProperty, t;
+  function e(u) {
+    try {
+      return decodeURIComponent(u.replace(/\+/g, " "));
+    } catch {
+      return null;
+    }
+  }
+  function n(u) {
+    try {
+      return encodeURIComponent(u);
+    } catch {
+      return null;
+    }
+  }
+  function o(u) {
+    for (var l = /([^=?#&]+)=?([^&]*)/g, f = {}, d; d = l.exec(u); ) {
+      var _ = e(d[1]), L = e(d[2]);
+      _ === null || L === null || _ in f || (f[_] = L);
+    }
+    return f;
+  }
+  function i(u, l) {
+    l = l || "";
+    var f = [], d, _;
+    typeof l != "string" && (l = "?");
+    for (_ in u)
+      if (r.call(u, _)) {
+        if (d = u[_], !d && (d === null || d === t || isNaN(d)) && (d = ""), _ = n(_), d = n(d), _ === null || d === null) continue;
+        f.push(_ + "=" + d);
+      }
+    return f.length ? l + f.join("&") : "";
+  }
+  return kt.stringify = i, kt.parse = o, kt;
+}
+var It, Re;
+function Zn() {
+  if (Re) return It;
+  Re = 1;
+  var r = $n(), t = Qn(), e = /^[\x00-\x20\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000\ufeff]+/, n = /[\n\r\t]/g, o = /^[A-Za-z][A-Za-z0-9+-.]*:\/\//, i = /:\d+$/, u = /^([a-z][a-z0-9.+-]*:)?(\/\/)?([\\/]+)?([\S\s]*)/i, l = /^[a-zA-Z]:/;
+  function f(y) {
+    return (y || "").toString().replace(e, "");
+  }
+  var d = [
+    ["#", "hash"],
+    // Extract from the back.
+    ["?", "query"],
+    // Extract from the back.
+    function(y, g) {
+      return B(g.protocol) ? y.replace(/\\/g, "/") : y;
+    },
+    ["/", "pathname"],
+    // Extract from the back.
+    ["@", "auth", 1],
+    // Extract from the front.
+    [NaN, "host", void 0, 1, 1],
+    // Set left over value.
+    [/:(\d*)$/, "port", void 0, 1],
+    // RegExp the back.
+    [NaN, "hostname", void 0, 1, 1]
+    // Set left over.
+  ], _ = { hash: 1, query: 1 };
+  function L(y) {
+    var g;
+    typeof window < "u" ? g = window : typeof he < "u" ? g = he : typeof self < "u" ? g = self : g = {};
+    var m = g.location || {};
+    y = y || m;
+    var p = {}, x = typeof y, k;
+    if (y.protocol === "blob:")
+      p = new E(unescape(y.pathname), {});
+    else if (x === "string") {
+      p = new E(y, {});
+      for (k in _) delete p[k];
+    } else if (x === "object") {
+      for (k in y)
+        k in _ || (p[k] = y[k]);
+      p.slashes === void 0 && (p.slashes = o.test(y.href));
+    }
+    return p;
+  }
+  function B(y) {
+    return y === "file:" || y === "ftp:" || y === "http:" || y === "https:" || y === "ws:" || y === "wss:";
+  }
+  function K(y, g) {
+    y = f(y), y = y.replace(n, ""), g = g || {};
+    var m = u.exec(y), p = m[1] ? m[1].toLowerCase() : "", x = !!m[2], k = !!m[3], C = 0, O;
+    return x ? k ? (O = m[2] + m[3] + m[4], C = m[2].length + m[3].length) : (O = m[2] + m[4], C = m[2].length) : k ? (O = m[3] + m[4], C = m[3].length) : O = m[4], p === "file:" ? C >= 2 && (O = O.slice(2)) : B(p) ? O = m[4] : p ? x && (O = O.slice(2)) : C >= 2 && B(g.protocol) && (O = m[4]), {
+      protocol: p,
+      slashes: x || B(p),
+      slashesCount: C,
+      rest: O
+    };
+  }
+  function G(y, g) {
+    if (y === "") return g;
+    for (var m = (g || "/").split("/").slice(0, -1).concat(y.split("/")), p = m.length, x = m[p - 1], k = !1, C = 0; p--; )
+      m[p] === "." ? m.splice(p, 1) : m[p] === ".." ? (m.splice(p, 1), C++) : C && (p === 0 && (k = !0), m.splice(p, 1), C--);
+    return k && m.unshift(""), (x === "." || x === "..") && m.push(""), m.join("/");
+  }
+  function E(y, g, m) {
+    if (y = f(y), y = y.replace(n, ""), !(this instanceof E))
+      return new E(y, g, m);
+    var p, x, k, C, O, q, P = d.slice(), N = typeof g, b = this, z = 0;
+    for (N !== "object" && N !== "string" && (m = g, g = null), m && typeof m != "function" && (m = t.parse), g = L(g), x = K(y || "", g), p = !x.protocol && !x.slashes, b.slashes = x.slashes || p && g.slashes, b.protocol = x.protocol || g.protocol || "", y = x.rest, (x.protocol === "file:" && (x.slashesCount !== 2 || l.test(y)) || !x.slashes && (x.protocol || x.slashesCount < 2 || !B(b.protocol))) && (P[3] = [/(.*)/, "pathname"]); z < P.length; z++) {
+      if (C = P[z], typeof C == "function") {
+        y = C(y, b);
+        continue;
+      }
+      k = C[0], q = C[1], k !== k ? b[q] = y : typeof k == "string" ? (O = k === "@" ? y.lastIndexOf(k) : y.indexOf(k), ~O && (typeof C[2] == "number" ? (b[q] = y.slice(0, O), y = y.slice(O + C[2])) : (b[q] = y.slice(O), y = y.slice(0, O)))) : (O = k.exec(y)) && (b[q] = O[1], y = y.slice(0, O.index)), b[q] = b[q] || p && C[3] && g[q] || "", C[4] && (b[q] = b[q].toLowerCase());
+    }
+    m && (b.query = m(b.query)), p && g.slashes && b.pathname.charAt(0) !== "/" && (b.pathname !== "" || g.pathname !== "") && (b.pathname = G(b.pathname, g.pathname)), b.pathname.charAt(0) !== "/" && B(b.protocol) && (b.pathname = "/" + b.pathname), r(b.port, b.protocol) || (b.host = b.hostname, b.port = ""), b.username = b.password = "", b.auth && (O = b.auth.indexOf(":"), ~O ? (b.username = b.auth.slice(0, O), b.username = encodeURIComponent(decodeURIComponent(b.username)), b.password = b.auth.slice(O + 1), b.password = encodeURIComponent(decodeURIComponent(b.password))) : b.username = encodeURIComponent(decodeURIComponent(b.auth)), b.auth = b.password ? b.username + ":" + b.password : b.username), b.origin = b.protocol !== "file:" && B(b.protocol) && b.host ? b.protocol + "//" + b.host : "null", b.href = b.toString();
+  }
+  function U(y, g, m) {
+    var p = this;
+    switch (y) {
+      case "query":
+        typeof g == "string" && g.length && (g = (m || t.parse)(g)), p[y] = g;
+        break;
+      case "port":
+        p[y] = g, r(g, p.protocol) ? g && (p.host = p.hostname + ":" + g) : (p.host = p.hostname, p[y] = "");
+        break;
+      case "hostname":
+        p[y] = g, p.port && (g += ":" + p.port), p.host = g;
+        break;
+      case "host":
+        p[y] = g, i.test(g) ? (g = g.split(":"), p.port = g.pop(), p.hostname = g.join(":")) : (p.hostname = g, p.port = "");
+        break;
+      case "protocol":
+        p.protocol = g.toLowerCase(), p.slashes = !m;
+        break;
+      case "pathname":
+      case "hash":
+        if (g) {
+          var x = y === "pathname" ? "/" : "#";
+          p[y] = g.charAt(0) !== x ? x + g : g;
+        } else
+          p[y] = g;
+        break;
+      case "username":
+      case "password":
+        p[y] = encodeURIComponent(g);
+        break;
+      case "auth":
+        var k = g.indexOf(":");
+        ~k ? (p.username = g.slice(0, k), p.username = encodeURIComponent(decodeURIComponent(p.username)), p.password = g.slice(k + 1), p.password = encodeURIComponent(decodeURIComponent(p.password))) : p.username = encodeURIComponent(decodeURIComponent(g));
+    }
+    for (var C = 0; C < d.length; C++) {
+      var O = d[C];
+      O[4] && (p[O[1]] = p[O[1]].toLowerCase());
+    }
+    return p.auth = p.password ? p.username + ":" + p.password : p.username, p.origin = p.protocol !== "file:" && B(p.protocol) && p.host ? p.protocol + "//" + p.host : "null", p.href = p.toString(), p;
+  }
+  function S(y) {
+    (!y || typeof y != "function") && (y = t.stringify);
+    var g, m = this, p = m.host, x = m.protocol;
+    x && x.charAt(x.length - 1) !== ":" && (x += ":");
+    var k = x + (m.protocol && m.slashes || B(m.protocol) ? "//" : "");
+    return m.username ? (k += m.username, m.password && (k += ":" + m.password), k += "@") : m.password ? (k += ":" + m.password, k += "@") : m.protocol !== "file:" && B(m.protocol) && !p && m.pathname !== "/" && (k += "@"), (p[p.length - 1] === ":" || i.test(m.hostname) && !m.port) && (p += ":"), k += p + m.pathname, g = typeof m.query == "object" ? y(m.query) : m.query, g && (k += g.charAt(0) !== "?" ? "?" + g : g), m.hash && (k += m.hash), k;
+  }
+  return E.prototype = { set: U, toString: S }, E.extractProtocol = K, E.location = L, E.trimLeft = f, E.qs = t, It = E, It;
+}
+var to = Zn();
+const eo = /* @__PURE__ */ Ve(to);
+function ro() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(r) {
+    var t = Math.random() * 16 | 0, e = r === "x" ? t : t & 3 | 8;
+    return e.toString(16);
+  });
+}
+function $t() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  $t = function() {
+    return t;
+  };
+  var r, t = {}, e = Object.prototype, n = e.hasOwnProperty, o = Object.defineProperty || function(a, s, c) {
+    a[s] = c.value;
+  }, i = typeof Symbol == "function" ? Symbol : {}, u = i.iterator || "@@iterator", l = i.asyncIterator || "@@asyncIterator", f = i.toStringTag || "@@toStringTag";
+  function d(a, s, c) {
+    return Object.defineProperty(a, s, { value: c, enumerable: !0, configurable: !0, writable: !0 }), a[s];
+  }
+  try {
+    d({}, "");
+  } catch {
+    d = function(a, s, c) {
+      return a[s] = c;
+    };
+  }
+  function _(a, s, c, v) {
+    var h = s && s.prototype instanceof S ? s : S, w = Object.create(h.prototype), R = new z(v || []);
+    return o(w, "_invoke", { value: q(a, c, R) }), w;
+  }
+  function L(a, s, c) {
+    try {
+      return { type: "normal", arg: a.call(s, c) };
+    } catch (v) {
+      return { type: "throw", arg: v };
+    }
+  }
+  t.wrap = _;
+  var B = "suspendedStart", K = "suspendedYield", G = "executing", E = "completed", U = {};
+  function S() {
+  }
+  function y() {
+  }
+  function g() {
+  }
+  var m = {};
+  d(m, u, function() {
+    return this;
+  });
+  var p = Object.getPrototypeOf, x = p && p(p($([])));
+  x && x !== e && n.call(x, u) && (m = x);
+  var k = g.prototype = S.prototype = Object.create(m);
+  function C(a) {
+    ["next", "throw", "return"].forEach(function(s) {
+      d(a, s, function(c) {
+        return this._invoke(s, c);
+      });
+    });
+  }
+  function O(a, s) {
+    function c(h, w, R, A) {
+      var j = L(a[h], a, w);
+      if (j.type !== "throw") {
+        var M = j.arg, Y = M.value;
+        return Y && Z(Y) == "object" && n.call(Y, "__await") ? s.resolve(Y.__await).then(function(H) {
+          c("next", H, R, A);
+        }, function(H) {
+          c("throw", H, R, A);
+        }) : s.resolve(Y).then(function(H) {
+          M.value = H, R(M);
+        }, function(H) {
+          return c("throw", H, R, A);
+        });
+      }
+      A(j.arg);
+    }
+    var v;
+    o(this, "_invoke", { value: function(h, w) {
+      function R() {
+        return new s(function(A, j) {
+          c(h, w, A, j);
+        });
+      }
+      return v = v ? v.then(R, R) : R();
+    } });
+  }
+  function q(a, s, c) {
+    var v = B;
+    return function(h, w) {
+      if (v === G) throw Error("Generator is already running");
+      if (v === E) {
+        if (h === "throw") throw w;
+        return { value: r, done: !0 };
+      }
+      for (c.method = h, c.arg = w; ; ) {
+        var R = c.delegate;
+        if (R) {
+          var A = P(R, c);
+          if (A) {
+            if (A === U) continue;
+            return A;
+          }
+        }
+        if (c.method === "next") c.sent = c._sent = c.arg;
+        else if (c.method === "throw") {
+          if (v === B) throw v = E, c.arg;
+          c.dispatchException(c.arg);
+        } else c.method === "return" && c.abrupt("return", c.arg);
+        v = G;
+        var j = L(a, s, c);
+        if (j.type === "normal") {
+          if (v = c.done ? E : K, j.arg === U) continue;
+          return { value: j.arg, done: c.done };
+        }
+        j.type === "throw" && (v = E, c.method = "throw", c.arg = j.arg);
+      }
+    };
+  }
+  function P(a, s) {
+    var c = s.method, v = a.iterator[c];
+    if (v === r) return s.delegate = null, c === "throw" && a.iterator.return && (s.method = "return", s.arg = r, P(a, s), s.method === "throw") || c !== "return" && (s.method = "throw", s.arg = new TypeError("The iterator does not provide a '" + c + "' method")), U;
+    var h = L(v, a.iterator, s.arg);
+    if (h.type === "throw") return s.method = "throw", s.arg = h.arg, s.delegate = null, U;
+    var w = h.arg;
+    return w ? w.done ? (s[a.resultName] = w.value, s.next = a.nextLoc, s.method !== "return" && (s.method = "next", s.arg = r), s.delegate = null, U) : w : (s.method = "throw", s.arg = new TypeError("iterator result is not an object"), s.delegate = null, U);
+  }
+  function N(a) {
+    var s = { tryLoc: a[0] };
+    1 in a && (s.catchLoc = a[1]), 2 in a && (s.finallyLoc = a[2], s.afterLoc = a[3]), this.tryEntries.push(s);
+  }
+  function b(a) {
+    var s = a.completion || {};
+    s.type = "normal", delete s.arg, a.completion = s;
+  }
+  function z(a) {
+    this.tryEntries = [{ tryLoc: "root" }], a.forEach(N, this), this.reset(!0);
+  }
+  function $(a) {
+    if (a || a === "") {
+      var s = a[u];
+      if (s) return s.call(a);
+      if (typeof a.next == "function") return a;
+      if (!isNaN(a.length)) {
+        var c = -1, v = function h() {
+          for (; ++c < a.length; ) if (n.call(a, c)) return h.value = a[c], h.done = !1, h;
+          return h.value = r, h.done = !0, h;
+        };
+        return v.next = v;
+      }
+    }
+    throw new TypeError(Z(a) + " is not iterable");
+  }
+  return y.prototype = g, o(k, "constructor", { value: g, configurable: !0 }), o(g, "constructor", { value: y, configurable: !0 }), y.displayName = d(g, f, "GeneratorFunction"), t.isGeneratorFunction = function(a) {
+    var s = typeof a == "function" && a.constructor;
+    return !!s && (s === y || (s.displayName || s.name) === "GeneratorFunction");
+  }, t.mark = function(a) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(a, g) : (a.__proto__ = g, d(a, f, "GeneratorFunction")), a.prototype = Object.create(k), a;
+  }, t.awrap = function(a) {
+    return { __await: a };
+  }, C(O.prototype), d(O.prototype, l, function() {
+    return this;
+  }), t.AsyncIterator = O, t.async = function(a, s, c, v, h) {
+    h === void 0 && (h = Promise);
+    var w = new O(_(a, s, c, v), h);
+    return t.isGeneratorFunction(s) ? w : w.next().then(function(R) {
+      return R.done ? R.value : w.next();
+    });
+  }, C(k), d(k, f, "Generator"), d(k, u, function() {
+    return this;
+  }), d(k, "toString", function() {
+    return "[object Generator]";
+  }), t.keys = function(a) {
+    var s = Object(a), c = [];
+    for (var v in s) c.push(v);
+    return c.reverse(), function h() {
+      for (; c.length; ) {
+        var w = c.pop();
+        if (w in s) return h.value = w, h.done = !1, h;
+      }
+      return h.done = !0, h;
+    };
+  }, t.values = $, z.prototype = { constructor: z, reset: function(a) {
+    if (this.prev = 0, this.next = 0, this.sent = this._sent = r, this.done = !1, this.delegate = null, this.method = "next", this.arg = r, this.tryEntries.forEach(b), !a) for (var s in this) s.charAt(0) === "t" && n.call(this, s) && !isNaN(+s.slice(1)) && (this[s] = r);
+  }, stop: function() {
+    this.done = !0;
+    var a = this.tryEntries[0].completion;
+    if (a.type === "throw") throw a.arg;
+    return this.rval;
+  }, dispatchException: function(a) {
+    if (this.done) throw a;
+    var s = this;
+    function c(j, M) {
+      return w.type = "throw", w.arg = a, s.next = j, M && (s.method = "next", s.arg = r), !!M;
+    }
+    for (var v = this.tryEntries.length - 1; v >= 0; --v) {
+      var h = this.tryEntries[v], w = h.completion;
+      if (h.tryLoc === "root") return c("end");
+      if (h.tryLoc <= this.prev) {
+        var R = n.call(h, "catchLoc"), A = n.call(h, "finallyLoc");
+        if (R && A) {
+          if (this.prev < h.catchLoc) return c(h.catchLoc, !0);
+          if (this.prev < h.finallyLoc) return c(h.finallyLoc);
+        } else if (R) {
+          if (this.prev < h.catchLoc) return c(h.catchLoc, !0);
+        } else {
+          if (!A) throw Error("try statement without catch or finally");
+          if (this.prev < h.finallyLoc) return c(h.finallyLoc);
+        }
+      }
+    }
+  }, abrupt: function(a, s) {
+    for (var c = this.tryEntries.length - 1; c >= 0; --c) {
+      var v = this.tryEntries[c];
+      if (v.tryLoc <= this.prev && n.call(v, "finallyLoc") && this.prev < v.finallyLoc) {
+        var h = v;
+        break;
+      }
+    }
+    h && (a === "break" || a === "continue") && h.tryLoc <= s && s <= h.finallyLoc && (h = null);
+    var w = h ? h.completion : {};
+    return w.type = a, w.arg = s, h ? (this.method = "next", this.next = h.finallyLoc, U) : this.complete(w);
+  }, complete: function(a, s) {
+    if (a.type === "throw") throw a.arg;
+    return a.type === "break" || a.type === "continue" ? this.next = a.arg : a.type === "return" ? (this.rval = this.arg = a.arg, this.method = "return", this.next = "end") : a.type === "normal" && s && (this.next = s), U;
+  }, finish: function(a) {
+    for (var s = this.tryEntries.length - 1; s >= 0; --s) {
+      var c = this.tryEntries[s];
+      if (c.finallyLoc === a) return this.complete(c.completion, c.afterLoc), b(c), U;
+    }
+  }, catch: function(a) {
+    for (var s = this.tryEntries.length - 1; s >= 0; --s) {
+      var c = this.tryEntries[s];
+      if (c.tryLoc === a) {
+        var v = c.completion;
+        if (v.type === "throw") {
+          var h = v.arg;
+          b(c);
+        }
+        return h;
+      }
+    }
+    throw Error("illegal catch attempt");
+  }, delegateYield: function(a, s, c) {
+    return this.delegate = { iterator: $(a), resultName: s, nextLoc: c }, this.method === "next" && (this.arg = r), U;
+  } }, t;
+}
+function Te(r, t, e, n, o, i, u) {
+  try {
+    var l = r[i](u), f = l.value;
+  } catch (d) {
+    e(d);
+    return;
+  }
+  l.done ? t(f) : Promise.resolve(f).then(n, o);
+}
+function no(r) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(n, o) {
+      var i = r.apply(t, e);
+      function u(f) {
+        Te(i, n, o, u, l, "next", f);
+      }
+      function l(f) {
+        Te(i, n, o, u, l, "throw", f);
+      }
+      u(void 0);
+    });
+  };
+}
+function mr(r, t) {
+  return so(r) || io(r, t) || vr(r, t) || oo();
+}
+function oo() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function io(r, t) {
+  var e = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (e != null) {
+    var n, o, i, u, l = [], f = !0, d = !1;
+    try {
+      if (i = (e = e.call(r)).next, t !== 0) for (; !(f = (n = i.call(e)).done) && (l.push(n.value), l.length !== t); f = !0) ;
+    } catch (_) {
+      d = !0, o = _;
+    } finally {
+      try {
+        if (!f && e.return != null && (u = e.return(), Object(u) !== u)) return;
+      } finally {
+        if (d) throw o;
+      }
+    }
+    return l;
+  }
+}
+function so(r) {
+  if (Array.isArray(r)) return r;
+}
+function Z(r) {
+  "@babel/helpers - typeof";
+  return Z = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, Z(r);
+}
+function ao(r, t) {
+  var e = typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (!e) {
+    if (Array.isArray(r) || (e = vr(r)) || t) {
+      e && (r = e);
+      var n = 0, o = function() {
+      };
+      return { s: o, n: function() {
+        return n >= r.length ? { done: !0 } : { done: !1, value: r[n++] };
+      }, e: function(f) {
+        throw f;
+      }, f: o };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var i = !0, u = !1, l;
+  return { s: function() {
+    e = e.call(r);
+  }, n: function() {
+    var f = e.next();
+    return i = f.done, f;
+  }, e: function(f) {
+    u = !0, l = f;
+  }, f: function() {
+    try {
+      !i && e.return != null && e.return();
+    } finally {
+      if (u) throw l;
+    }
+  } };
+}
+function vr(r, t) {
+  if (r) {
+    if (typeof r == "string") return Ce(r, t);
+    var e = Object.prototype.toString.call(r).slice(8, -1);
+    if (e === "Object" && r.constructor && (e = r.constructor.name), e === "Map" || e === "Set") return Array.from(r);
+    if (e === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(e)) return Ce(r, t);
+  }
+}
+function Ce(r, t) {
+  (t == null || t > r.length) && (t = r.length);
+  for (var e = 0, n = new Array(t); e < t; e++) n[e] = r[e];
+  return n;
+}
+function Pe(r, t) {
+  var e = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(r);
+    t && (n = n.filter(function(o) {
+      return Object.getOwnPropertyDescriptor(r, o).enumerable;
+    })), e.push.apply(e, n);
+  }
+  return e;
+}
+function et(r) {
+  for (var t = 1; t < arguments.length; t++) {
+    var e = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? Pe(Object(e), !0).forEach(function(n) {
+      uo(r, n, e[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(e)) : Pe(Object(e)).forEach(function(n) {
+      Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(e, n));
+    });
+  }
+  return r;
+}
+function uo(r, t, e) {
+  return t = br(t), t in r ? Object.defineProperty(r, t, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : r[t] = e, r;
+}
+function co(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Le(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, br(n.key), n);
+  }
+}
+function lo(r, t, e) {
+  return t && Le(r.prototype, t), e && Le(r, e), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function br(r) {
+  var t = ho(r, "string");
+  return Z(t) == "symbol" ? t : t + "";
+}
+function ho(r, t) {
+  if (Z(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (Z(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var Tt = "tus-v1", Ct = "ietf-draft-03", lt = "ietf-draft-05", po = {
+  endpoint: null,
+  uploadUrl: null,
+  metadata: {},
+  metadataForPartialUploads: {},
+  fingerprint: null,
+  uploadSize: null,
+  onProgress: null,
+  onChunkComplete: null,
+  onSuccess: null,
+  onError: null,
+  onUploadUrlAvailable: null,
+  overridePatchMethod: !1,
+  headers: {},
+  addRequestId: !1,
+  onBeforeRequest: null,
+  onAfterResponse: null,
+  onShouldRetry: wr,
+  chunkSize: Number.POSITIVE_INFINITY,
+  retryDelays: [0, 1e3, 3e3, 5e3],
+  parallelUploads: 1,
+  parallelUploadBoundaries: null,
+  storeFingerprintForResuming: !0,
+  removeFingerprintOnSuccess: !1,
+  uploadLengthDeferred: !1,
+  uploadDataDuringCreation: !1,
+  urlStorage: null,
+  fileReader: null,
+  httpStack: null,
+  protocol: Tt
+}, _r = /* @__PURE__ */ (function() {
+  function r(t, e) {
+    co(this, r), "resume" in e && console.log("tus: The `resume` option has been removed in tus-js-client v2. Please use the URL storage API instead."), this.options = e, this.options.chunkSize = Number(this.options.chunkSize), this._urlStorage = this.options.urlStorage, this.file = t, this.url = null, this._req = null, this._fingerprint = null, this._urlStorageKey = null, this._offset = null, this._aborted = !1, this._size = null, this._source = null, this._retryAttempt = 0, this._retryTimeout = null, this._offsetBeforeRetry = 0, this._parallelUploads = null, this._parallelUploadUrls = null;
+  }
+  return lo(r, [{
+    key: "findPreviousUploads",
+    value: function() {
+      var t = this;
+      return this.options.fingerprint(this.file, this.options).then(function(e) {
+        return t._urlStorage.findUploadsByFingerprint(e);
+      });
+    }
+  }, {
+    key: "resumeFromPreviousUpload",
+    value: function(t) {
+      this.url = t.uploadUrl || null, this._parallelUploadUrls = t.parallelUploadUrls || null, this._urlStorageKey = t.urlStorageKey;
+    }
+  }, {
+    key: "start",
+    value: function() {
+      var t = this, e = this.file;
+      if (!e) {
+        this._emitError(new Error("tus: no file or stream to upload provided"));
+        return;
+      }
+      if (![Tt, Ct, lt].includes(this.options.protocol)) {
+        this._emitError(new Error("tus: unsupported protocol ".concat(this.options.protocol)));
+        return;
+      }
+      if (!this.options.endpoint && !this.options.uploadUrl && !this.url) {
+        this._emitError(new Error("tus: neither an endpoint or an upload URL is provided"));
+        return;
+      }
+      var n = this.options.retryDelays;
+      if (n != null && Object.prototype.toString.call(n) !== "[object Array]") {
+        this._emitError(new Error("tus: the `retryDelays` option must either be an array or null"));
+        return;
+      }
+      if (this.options.parallelUploads > 1)
+        for (var o = 0, i = ["uploadUrl", "uploadSize", "uploadLengthDeferred"]; o < i.length; o++) {
+          var u = i[o];
+          if (this.options[u]) {
+            this._emitError(new Error("tus: cannot use the ".concat(u, " option when parallelUploads is enabled")));
+            return;
+          }
+        }
+      if (this.options.parallelUploadBoundaries) {
+        if (this.options.parallelUploads <= 1) {
+          this._emitError(new Error("tus: cannot use the `parallelUploadBoundaries` option when `parallelUploads` is disabled"));
+          return;
+        }
+        if (this.options.parallelUploads !== this.options.parallelUploadBoundaries.length) {
+          this._emitError(new Error("tus: the `parallelUploadBoundaries` must have the same length as the value of `parallelUploads`"));
+          return;
+        }
+      }
+      this.options.fingerprint(e, this.options).then(function(l) {
+        return t._fingerprint = l, t._source ? t._source : t.options.fileReader.openFile(e, t.options.chunkSize);
+      }).then(function(l) {
+        if (t._source = l, t.options.uploadLengthDeferred)
+          t._size = null;
+        else if (t.options.uploadSize != null) {
+          if (t._size = Number(t.options.uploadSize), Number.isNaN(t._size)) {
+            t._emitError(new Error("tus: cannot convert `uploadSize` option into a number"));
+            return;
+          }
+        } else if (t._size = t._source.size, t._size == null) {
+          t._emitError(new Error("tus: cannot automatically derive upload's size from input. Specify it manually using the `uploadSize` option or use the `uploadLengthDeferred` option"));
+          return;
+        }
+        t.options.parallelUploads > 1 || t._parallelUploadUrls != null ? t._startParallelUpload() : t._startSingleUpload();
+      }).catch(function(l) {
+        t._emitError(l);
+      });
+    }
+    /**
+     * Initiate the uploading procedure for a parallelized upload, where one file is split into
+     * multiple request which are run in parallel.
+     *
+     * @api private
+     */
+  }, {
+    key: "_startParallelUpload",
+    value: function() {
+      var t, e = this, n = this._size, o = 0;
+      this._parallelUploads = [];
+      var i = this._parallelUploadUrls != null ? this._parallelUploadUrls.length : this.options.parallelUploads, u = (t = this.options.parallelUploadBoundaries) !== null && t !== void 0 ? t : yo(this._source.size, i);
+      this._parallelUploadUrls && u.forEach(function(d, _) {
+        d.uploadUrl = e._parallelUploadUrls[_] || null;
+      }), this._parallelUploadUrls = new Array(u.length);
+      var l = u.map(function(d, _) {
+        var L = 0;
+        return e._source.slice(d.start, d.end).then(function(B) {
+          var K = B.value;
+          return new Promise(function(G, E) {
+            var U = et(et({}, e.options), {}, {
+              // If available, the partial upload should be resumed from a previous URL.
+              uploadUrl: d.uploadUrl || null,
+              // We take manually care of resuming for partial uploads, so they should
+              // not be stored in the URL storage.
+              storeFingerprintForResuming: !1,
+              removeFingerprintOnSuccess: !1,
+              // Reset the parallelUploads option to not cause recursion.
+              parallelUploads: 1,
+              // Reset this option as we are not doing a parallel upload.
+              parallelUploadBoundaries: null,
+              metadata: e.options.metadataForPartialUploads,
+              // Add the header to indicate the this is a partial upload.
+              headers: et(et({}, e.options.headers), {}, {
+                "Upload-Concat": "partial"
+              }),
+              // Reject or resolve the promise if the upload errors or completes.
+              onSuccess: G,
+              onError: E,
+              // Based in the progress for this partial upload, calculate the progress
+              // for the entire final upload.
+              onProgress: function(y) {
+                o = o - L + y, L = y, e._emitProgress(o, n);
+              },
+              // Wait until every partial upload has an upload URL, so we can add
+              // them to the URL storage.
+              onUploadUrlAvailable: function() {
+                e._parallelUploadUrls[_] = S.url, e._parallelUploadUrls.filter(function(y) {
+                  return !!y;
+                }).length === u.length && e._saveUploadInUrlStorage();
+              }
+            }), S = new r(K, U);
+            S.start(), e._parallelUploads.push(S);
+          });
+        });
+      }), f;
+      Promise.all(l).then(function() {
+        f = e._openRequest("POST", e.options.endpoint), f.setHeader("Upload-Concat", "final;".concat(e._parallelUploadUrls.join(" ")));
+        var d = Ae(e.options.metadata);
+        return d !== "" && f.setHeader("Upload-Metadata", d), e._sendRequest(f, null);
+      }).then(function(d) {
+        if (!rt(d.getStatus(), 200)) {
+          e._emitHttpError(f, d, "tus: unexpected response while creating upload");
+          return;
+        }
+        var _ = d.getHeader("Location");
+        if (_ == null) {
+          e._emitHttpError(f, d, "tus: invalid or missing Location header");
+          return;
+        }
+        e.url = Ie(e.options.endpoint, _), "Created upload at ".concat(e.url), e._emitSuccess(d);
+      }).catch(function(d) {
+        e._emitError(d);
+      });
+    }
+    /**
+     * Initiate the uploading procedure for a non-parallel upload. Here the entire file is
+     * uploaded in a sequential matter.
+     *
+     * @api private
+     */
+  }, {
+    key: "_startSingleUpload",
+    value: function() {
+      if (this._aborted = !1, this.url != null) {
+        "Resuming upload from previous URL: ".concat(this.url), this._resumeUpload();
+        return;
+      }
+      if (this.options.uploadUrl != null) {
+        "Resuming upload from provided URL: ".concat(this.options.uploadUrl), this.url = this.options.uploadUrl, this._resumeUpload();
+        return;
+      }
+      this._createUpload();
+    }
+    /**
+     * Abort any running request and stop the current upload. After abort is called, no event
+     * handler will be invoked anymore. You can use the `start` method to resume the upload
+     * again.
+     * If `shouldTerminate` is true, the `terminate` function will be called to remove the
+     * current upload from the server.
+     *
+     * @param {boolean} shouldTerminate True if the upload should be deleted from the server.
+     * @return {Promise} The Promise will be resolved/rejected when the requests finish.
+     */
+  }, {
+    key: "abort",
+    value: function(t) {
+      var e = this;
+      if (this._parallelUploads != null) {
+        var n = ao(this._parallelUploads), o;
+        try {
+          for (n.s(); !(o = n.n()).done; ) {
+            var i = o.value;
+            i.abort(t);
+          }
+        } catch (u) {
+          n.e(u);
+        } finally {
+          n.f();
+        }
+      }
+      return this._req !== null && this._req.abort(), this._aborted = !0, this._retryTimeout != null && (clearTimeout(this._retryTimeout), this._retryTimeout = null), !t || this.url == null ? Promise.resolve() : r.terminate(this.url, this.options).then(function() {
+        return e._removeFromUrlStorage();
+      });
+    }
+  }, {
+    key: "_emitHttpError",
+    value: function(t, e, n, o) {
+      this._emitError(new wt(n, o, t, e));
+    }
+  }, {
+    key: "_emitError",
+    value: function(t) {
+      var e = this;
+      if (!this._aborted) {
+        if (this.options.retryDelays != null) {
+          var n = this._offset != null && this._offset > this._offsetBeforeRetry;
+          if (n && (this._retryAttempt = 0), Ne(t, this._retryAttempt, this.options)) {
+            var o = this.options.retryDelays[this._retryAttempt++];
+            this._offsetBeforeRetry = this._offset, this._retryTimeout = setTimeout(function() {
+              e.start();
+            }, o);
+            return;
+          }
+        }
+        if (typeof this.options.onError == "function")
+          this.options.onError(t);
+        else
+          throw t;
+      }
+    }
+    /**
+     * Publishes notification if the upload has been successfully completed.
+     *
+     * @param {object} lastResponse Last HTTP response.
+     * @api private
+     */
+  }, {
+    key: "_emitSuccess",
+    value: function(t) {
+      this.options.removeFingerprintOnSuccess && this._removeFromUrlStorage(), typeof this.options.onSuccess == "function" && this.options.onSuccess({
+        lastResponse: t
+      });
+    }
+    /**
+     * Publishes notification when data has been sent to the server. This
+     * data may not have been accepted by the server yet.
+     *
+     * @param {number} bytesSent  Number of bytes sent to the server.
+     * @param {number} bytesTotal Total number of bytes to be sent to the server.
+     * @api private
+     */
+  }, {
+    key: "_emitProgress",
+    value: function(t, e) {
+      typeof this.options.onProgress == "function" && this.options.onProgress(t, e);
+    }
+    /**
+     * Publishes notification when a chunk of data has been sent to the server
+     * and accepted by the server.
+     * @param {number} chunkSize  Size of the chunk that was accepted by the server.
+     * @param {number} bytesAccepted Total number of bytes that have been
+     *                                accepted by the server.
+     * @param {number} bytesTotal Total number of bytes to be sent to the server.
+     * @api private
+     */
+  }, {
+    key: "_emitChunkComplete",
+    value: function(t, e, n) {
+      typeof this.options.onChunkComplete == "function" && this.options.onChunkComplete(t, e, n);
+    }
+    /**
+     * Create a new upload using the creation extension by sending a POST
+     * request to the endpoint. After successful creation the file will be
+     * uploaded
+     *
+     * @api private
+     */
+  }, {
+    key: "_createUpload",
+    value: function() {
+      var t = this;
+      if (!this.options.endpoint) {
+        this._emitError(new Error("tus: unable to create upload because no endpoint is provided"));
+        return;
+      }
+      var e = this._openRequest("POST", this.options.endpoint);
+      this.options.uploadLengthDeferred ? e.setHeader("Upload-Defer-Length", "1") : e.setHeader("Upload-Length", "".concat(this._size));
+      var n = Ae(this.options.metadata);
+      n !== "" && e.setHeader("Upload-Metadata", n);
+      var o;
+      this.options.uploadDataDuringCreation && !this.options.uploadLengthDeferred ? (this._offset = 0, o = this._addChunkToRequest(e)) : ((this.options.protocol === Ct || this.options.protocol === lt) && e.setHeader("Upload-Complete", "?0"), o = this._sendRequest(e, null)), o.then(function(i) {
+        if (!rt(i.getStatus(), 200)) {
+          t._emitHttpError(e, i, "tus: unexpected response while creating upload");
+          return;
+        }
+        var u = i.getHeader("Location");
+        if (u == null) {
+          t._emitHttpError(e, i, "tus: invalid or missing Location header");
+          return;
+        }
+        if (t.url = Ie(t.options.endpoint, u), "Created upload at ".concat(t.url), typeof t.options.onUploadUrlAvailable == "function" && t.options.onUploadUrlAvailable(), t._size === 0) {
+          t._emitSuccess(i), t._source.close();
+          return;
+        }
+        t._saveUploadInUrlStorage().then(function() {
+          t.options.uploadDataDuringCreation ? t._handleUploadResponse(e, i) : (t._offset = 0, t._performUpload());
+        });
+      }).catch(function(i) {
+        t._emitHttpError(e, null, "tus: failed to create upload", i);
+      });
+    }
+    /*
+     * Try to resume an existing upload. First a HEAD request will be sent
+     * to retrieve the offset. If the request fails a new upload will be
+     * created. In the case of a successful response the file will be uploaded.
+     *
+     * @api private
+     */
+  }, {
+    key: "_resumeUpload",
+    value: function() {
+      var t = this, e = this._openRequest("HEAD", this.url), n = this._sendRequest(e, null);
+      n.then(function(o) {
+        var i = o.getStatus();
+        if (!rt(i, 200)) {
+          if (i === 423) {
+            t._emitHttpError(e, o, "tus: upload is currently locked; retry later");
+            return;
+          }
+          if (rt(i, 400) && t._removeFromUrlStorage(), !t.options.endpoint) {
+            t._emitHttpError(e, o, "tus: unable to resume upload (new upload cannot be created without an endpoint)");
+            return;
+          }
+          t.url = null, t._createUpload();
+          return;
+        }
+        var u = Number.parseInt(o.getHeader("Upload-Offset"), 10);
+        if (Number.isNaN(u)) {
+          t._emitHttpError(e, o, "tus: invalid or missing offset value");
+          return;
+        }
+        var l = Number.parseInt(o.getHeader("Upload-Length"), 10);
+        if (Number.isNaN(l) && !t.options.uploadLengthDeferred && t.options.protocol === Tt) {
+          t._emitHttpError(e, o, "tus: invalid or missing length value");
+          return;
+        }
+        typeof t.options.onUploadUrlAvailable == "function" && t.options.onUploadUrlAvailable(), t._saveUploadInUrlStorage().then(function() {
+          if (u === l) {
+            t._emitProgress(l, l), t._emitSuccess(o);
+            return;
+          }
+          t._offset = u, t._performUpload();
+        });
+      }).catch(function(o) {
+        t._emitHttpError(e, null, "tus: failed to resume upload", o);
+      });
+    }
+    /**
+     * Start uploading the file using PATCH requests. The file will be divided
+     * into chunks as specified in the chunkSize option. During the upload
+     * the onProgress event handler may be invoked multiple times.
+     *
+     * @api private
+     */
+  }, {
+    key: "_performUpload",
+    value: function() {
+      var t = this;
+      if (!this._aborted) {
+        var e;
+        this.options.overridePatchMethod ? (e = this._openRequest("POST", this.url), e.setHeader("X-HTTP-Method-Override", "PATCH")) : e = this._openRequest("PATCH", this.url), e.setHeader("Upload-Offset", "".concat(this._offset));
+        var n = this._addChunkToRequest(e);
+        n.then(function(o) {
+          if (!rt(o.getStatus(), 200)) {
+            t._emitHttpError(e, o, "tus: unexpected response while uploading chunk");
+            return;
+          }
+          t._handleUploadResponse(e, o);
+        }).catch(function(o) {
+          t._aborted || t._emitHttpError(e, null, "tus: failed to upload chunk at offset ".concat(t._offset), o);
+        });
+      }
+    }
+    /**
+     * _addChunktoRequest reads a chunk from the source and sends it using the
+     * supplied request object. It will not handle the response.
+     *
+     * @api private
+     */
+  }, {
+    key: "_addChunkToRequest",
+    value: function(t) {
+      var e = this, n = this._offset, o = this._offset + this.options.chunkSize;
+      return t.setProgressHandler(function(i) {
+        e._emitProgress(n + i, e._size);
+      }), this.options.protocol === Tt ? t.setHeader("Content-Type", "application/offset+octet-stream") : this.options.protocol === lt && t.setHeader("Content-Type", "application/partial-upload"), (o === Number.POSITIVE_INFINITY || o > this._size) && !this.options.uploadLengthDeferred && (o = this._size), this._source.slice(n, o).then(function(i) {
+        var u = i.value, l = i.done, f = u != null && u.size ? u.size : 0;
+        e.options.uploadLengthDeferred && l && (e._size = e._offset + f, t.setHeader("Upload-Length", "".concat(e._size)));
+        var d = e._offset + f;
+        return !e.options.uploadLengthDeferred && l && d !== e._size ? Promise.reject(new Error("upload was configured with a size of ".concat(e._size, " bytes, but the source is done after ").concat(d, " bytes"))) : u === null ? e._sendRequest(t) : ((e.options.protocol === Ct || e.options.protocol === lt) && t.setHeader("Upload-Complete", l ? "?1" : "?0"), e._emitProgress(e._offset, e._size), e._sendRequest(t, u));
+      });
+    }
+    /**
+     * _handleUploadResponse is used by requests that haven been sent using _addChunkToRequest
+     * and already have received a response.
+     *
+     * @api private
+     */
+  }, {
+    key: "_handleUploadResponse",
+    value: function(t, e) {
+      var n = Number.parseInt(e.getHeader("Upload-Offset"), 10);
+      if (Number.isNaN(n)) {
+        this._emitHttpError(t, e, "tus: invalid or missing offset value");
+        return;
+      }
+      if (this._emitProgress(n, this._size), this._emitChunkComplete(n - this._offset, n, this._size), this._offset = n, n === this._size) {
+        this._emitSuccess(e), this._source.close();
+        return;
+      }
+      this._performUpload();
+    }
+    /**
+     * Create a new HTTP request object with the given method and URL.
+     *
+     * @api private
+     */
+  }, {
+    key: "_openRequest",
+    value: function(t, e) {
+      var n = je(t, e, this.options);
+      return this._req = n, n;
+    }
+    /**
+     * Remove the entry in the URL storage, if it has been saved before.
+     *
+     * @api private
+     */
+  }, {
+    key: "_removeFromUrlStorage",
+    value: function() {
+      var t = this;
+      this._urlStorageKey && (this._urlStorage.removeUpload(this._urlStorageKey).catch(function(e) {
+        t._emitError(e);
+      }), this._urlStorageKey = null);
+    }
+    /**
+     * Add the upload URL to the URL storage, if possible.
+     *
+     * @api private
+     */
+  }, {
+    key: "_saveUploadInUrlStorage",
+    value: function() {
+      var t = this;
+      if (!this.options.storeFingerprintForResuming || !this._fingerprint || this._urlStorageKey !== null)
+        return Promise.resolve();
+      var e = {
+        size: this._size,
+        metadata: this.options.metadata,
+        creationTime: (/* @__PURE__ */ new Date()).toString()
+      };
+      return this._parallelUploads ? e.parallelUploadUrls = this._parallelUploadUrls : e.uploadUrl = this.url, this._urlStorage.addUpload(this._fingerprint, e).then(function(n) {
+        t._urlStorageKey = n;
+      });
+    }
+    /**
+     * Send a request with the provided body.
+     *
+     * @api private
+     */
+  }, {
+    key: "_sendRequest",
+    value: function(t) {
+      var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
+      return Be(t, e, this.options);
+    }
+  }], [{
+    key: "terminate",
+    value: function(t) {
+      var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, n = je("DELETE", t, e);
+      return Be(n, null, e).then(function(o) {
+        if (o.getStatus() !== 204)
+          throw new wt("tus: unexpected response while terminating upload", null, n, o);
+      }).catch(function(o) {
+        if (o instanceof wt || (o = new wt("tus: failed to terminate upload", o, n, null)), !Ne(o, 0, e))
+          throw o;
+        var i = e.retryDelays[0], u = e.retryDelays.slice(1), l = et(et({}, e), {}, {
+          retryDelays: u
+        });
+        return new Promise(function(f) {
+          return setTimeout(f, i);
+        }).then(function() {
+          return r.terminate(t, l);
+        });
+      });
+    }
+  }]);
+})();
+function Ae(r) {
+  return Object.entries(r).map(function(t) {
+    var e = mr(t, 2), n = e[0], o = e[1];
+    return "".concat(n, " ").concat(Xn.encode(String(o)));
+  }).join(",");
+}
+function rt(r, t) {
+  return r >= t && r < t + 100;
+}
+function je(r, t, e) {
+  var n = e.httpStack.createRequest(r, t);
+  e.protocol === Ct ? n.setHeader("Upload-Draft-Interop-Version", "5") : e.protocol === lt ? n.setHeader("Upload-Draft-Interop-Version", "6") : n.setHeader("Tus-Resumable", "1.0.0");
+  for (var o = e.headers || {}, i = 0, u = Object.entries(o); i < u.length; i++) {
+    var l = mr(u[i], 2), f = l[0], d = l[1];
+    n.setHeader(f, d);
+  }
+  if (e.addRequestId) {
+    var _ = ro();
+    n.setHeader("X-Request-ID", _);
+  }
+  return n;
+}
+function Be(r, t, e) {
+  return Qt.apply(this, arguments);
+}
+function Qt() {
+  return Qt = no(/* @__PURE__ */ $t().mark(function r(t, e, n) {
+    var o;
+    return $t().wrap(function(i) {
+      for (; ; ) switch (i.prev = i.next) {
+        case 0:
+          if (typeof n.onBeforeRequest != "function") {
+            i.next = 3;
+            break;
+          }
+          return i.next = 3, n.onBeforeRequest(t);
+        case 3:
+          return i.next = 5, t.send(e);
+        case 5:
+          if (o = i.sent, typeof n.onAfterResponse != "function") {
+            i.next = 9;
+            break;
+          }
+          return i.next = 9, n.onAfterResponse(t, o);
+        case 9:
+          return i.abrupt("return", o);
+        case 10:
+        case "end":
+          return i.stop();
+      }
+    }, r);
+  })), Qt.apply(this, arguments);
+}
+function fo() {
+  var r = !0;
+  return typeof navigator < "u" && navigator.onLine === !1 && (r = !1), r;
+}
+function Ne(r, t, e) {
+  return e.retryDelays == null || t >= e.retryDelays.length || r.originalRequest == null ? !1 : e && typeof e.onShouldRetry == "function" ? e.onShouldRetry(r, t, e) : wr(r);
+}
+function wr(r) {
+  var t = r.originalResponse ? r.originalResponse.getStatus() : 0;
+  return (!rt(t, 400) || t === 409 || t === 423) && fo();
+}
+function Ie(r, t) {
+  return new eo(t, r).toString();
+}
+function yo(r, t) {
+  for (var e = Math.floor(r / t), n = [], o = 0; o < t; o++)
+    n.push({
+      start: e * o,
+      end: e * (o + 1)
+    });
+  return n[t - 1].end = r, n;
+}
+_r.defaultOptions = po;
+var Er = function() {
+  return typeof navigator < "u" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+};
+function go(r) {
+  return new Promise(function(t, e) {
+    var n = new XMLHttpRequest();
+    n.responseType = "blob", n.onload = function() {
+      var o = n.response;
+      t(o);
+    }, n.onerror = function(o) {
+      e(o);
+    }, n.open("GET", r), n.send();
+  });
+}
+var mo = function() {
+  return typeof window < "u" && (typeof window.PhoneGap < "u" || typeof window.Cordova < "u" || typeof window.cordova < "u");
+};
+function vo(r) {
+  return new Promise(function(t, e) {
+    var n = new FileReader();
+    n.onload = function() {
+      var o = new Uint8Array(n.result);
+      t({
+        value: o
+      });
+    }, n.onerror = function(o) {
+      e(o);
+    }, n.readAsArrayBuffer(r);
+  });
+}
+function dt(r) {
+  "@babel/helpers - typeof";
+  return dt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, dt(r);
+}
+function bo(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _o(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, Eo(n.key), n);
+  }
+}
+function wo(r, t, e) {
+  return t && _o(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Eo(r) {
+  var t = ko(r, "string");
+  return dt(t) == "symbol" ? t : t + "";
+}
+function ko(r, t) {
+  if (dt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (dt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var De = /* @__PURE__ */ (function() {
+  function r(t) {
+    bo(this, r), this._file = t, this.size = t.size;
+  }
+  return wo(r, [{
+    key: "slice",
+    value: function(t, e) {
+      if (mo())
+        return vo(this._file.slice(t, e));
+      var n = this._file.slice(t, e), o = e >= this.size;
+      return Promise.resolve({
+        value: n,
+        done: o
+      });
+    }
+  }, {
+    key: "close",
+    value: function() {
+    }
+  }]);
+})();
+function yt(r) {
+  "@babel/helpers - typeof";
+  return yt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, yt(r);
+}
+function So(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Oo(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, Uo(n.key), n);
+  }
+}
+function xo(r, t, e) {
+  return t && Oo(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Uo(r) {
+  var t = Ro(r, "string");
+  return yt(t) == "symbol" ? t : t + "";
+}
+function Ro(r, t) {
+  if (yt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (yt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+function qe(r) {
+  return r === void 0 ? 0 : r.size !== void 0 ? r.size : r.length;
+}
+function To(r, t) {
+  if (r.concat)
+    return r.concat(t);
+  if (r instanceof Blob)
+    return new Blob([r, t], {
+      type: r.type
+    });
+  if (r.set) {
+    var e = new r.constructor(r.length + t.length);
+    return e.set(r), e.set(t, r.length), e;
+  }
+  throw new Error("Unknown data type");
+}
+var Co = /* @__PURE__ */ (function() {
+  function r(t) {
+    So(this, r), this._buffer = void 0, this._bufferOffset = 0, this._reader = t, this._done = !1;
+  }
+  return xo(r, [{
+    key: "slice",
+    value: function(t, e) {
+      return t < this._bufferOffset ? Promise.reject(new Error("Requested data is before the reader's current offset")) : this._readUntilEnoughDataOrDone(t, e);
+    }
+  }, {
+    key: "_readUntilEnoughDataOrDone",
+    value: function(t, e) {
+      var n = this, o = e <= this._bufferOffset + qe(this._buffer);
+      if (this._done || o) {
+        var i = this._getDataFromBuffer(t, e), u = i == null ? this._done : !1;
+        return Promise.resolve({
+          value: i,
+          done: u
+        });
+      }
+      return this._reader.read().then(function(l) {
+        var f = l.value, d = l.done;
+        return d ? n._done = !0 : n._buffer === void 0 ? n._buffer = f : n._buffer = To(n._buffer, f), n._readUntilEnoughDataOrDone(t, e);
+      });
+    }
+  }, {
+    key: "_getDataFromBuffer",
+    value: function(t, e) {
+      t > this._bufferOffset && (this._buffer = this._buffer.slice(t - this._bufferOffset), this._bufferOffset = t);
+      var n = qe(this._buffer) === 0;
+      return this._done && n ? null : this._buffer.slice(0, e - t);
+    }
+  }, {
+    key: "close",
+    value: function() {
+      this._reader.cancel && this._reader.cancel();
+    }
+  }]);
+})();
+function tt(r) {
+  "@babel/helpers - typeof";
+  return tt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, tt(r);
+}
+function Zt() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  Zt = function() {
+    return t;
+  };
+  var r, t = {}, e = Object.prototype, n = e.hasOwnProperty, o = Object.defineProperty || function(a, s, c) {
+    a[s] = c.value;
+  }, i = typeof Symbol == "function" ? Symbol : {}, u = i.iterator || "@@iterator", l = i.asyncIterator || "@@asyncIterator", f = i.toStringTag || "@@toStringTag";
+  function d(a, s, c) {
+    return Object.defineProperty(a, s, { value: c, enumerable: !0, configurable: !0, writable: !0 }), a[s];
+  }
+  try {
+    d({}, "");
+  } catch {
+    d = function(a, s, c) {
+      return a[s] = c;
+    };
+  }
+  function _(a, s, c, v) {
+    var h = s && s.prototype instanceof S ? s : S, w = Object.create(h.prototype), R = new z(v || []);
+    return o(w, "_invoke", { value: q(a, c, R) }), w;
+  }
+  function L(a, s, c) {
+    try {
+      return { type: "normal", arg: a.call(s, c) };
+    } catch (v) {
+      return { type: "throw", arg: v };
+    }
+  }
+  t.wrap = _;
+  var B = "suspendedStart", K = "suspendedYield", G = "executing", E = "completed", U = {};
+  function S() {
+  }
+  function y() {
+  }
+  function g() {
+  }
+  var m = {};
+  d(m, u, function() {
+    return this;
+  });
+  var p = Object.getPrototypeOf, x = p && p(p($([])));
+  x && x !== e && n.call(x, u) && (m = x);
+  var k = g.prototype = S.prototype = Object.create(m);
+  function C(a) {
+    ["next", "throw", "return"].forEach(function(s) {
+      d(a, s, function(c) {
+        return this._invoke(s, c);
+      });
+    });
+  }
+  function O(a, s) {
+    function c(h, w, R, A) {
+      var j = L(a[h], a, w);
+      if (j.type !== "throw") {
+        var M = j.arg, Y = M.value;
+        return Y && tt(Y) == "object" && n.call(Y, "__await") ? s.resolve(Y.__await).then(function(H) {
+          c("next", H, R, A);
+        }, function(H) {
+          c("throw", H, R, A);
+        }) : s.resolve(Y).then(function(H) {
+          M.value = H, R(M);
+        }, function(H) {
+          return c("throw", H, R, A);
+        });
+      }
+      A(j.arg);
+    }
+    var v;
+    o(this, "_invoke", { value: function(h, w) {
+      function R() {
+        return new s(function(A, j) {
+          c(h, w, A, j);
+        });
+      }
+      return v = v ? v.then(R, R) : R();
+    } });
+  }
+  function q(a, s, c) {
+    var v = B;
+    return function(h, w) {
+      if (v === G) throw Error("Generator is already running");
+      if (v === E) {
+        if (h === "throw") throw w;
+        return { value: r, done: !0 };
+      }
+      for (c.method = h, c.arg = w; ; ) {
+        var R = c.delegate;
+        if (R) {
+          var A = P(R, c);
+          if (A) {
+            if (A === U) continue;
+            return A;
+          }
+        }
+        if (c.method === "next") c.sent = c._sent = c.arg;
+        else if (c.method === "throw") {
+          if (v === B) throw v = E, c.arg;
+          c.dispatchException(c.arg);
+        } else c.method === "return" && c.abrupt("return", c.arg);
+        v = G;
+        var j = L(a, s, c);
+        if (j.type === "normal") {
+          if (v = c.done ? E : K, j.arg === U) continue;
+          return { value: j.arg, done: c.done };
+        }
+        j.type === "throw" && (v = E, c.method = "throw", c.arg = j.arg);
+      }
+    };
+  }
+  function P(a, s) {
+    var c = s.method, v = a.iterator[c];
+    if (v === r) return s.delegate = null, c === "throw" && a.iterator.return && (s.method = "return", s.arg = r, P(a, s), s.method === "throw") || c !== "return" && (s.method = "throw", s.arg = new TypeError("The iterator does not provide a '" + c + "' method")), U;
+    var h = L(v, a.iterator, s.arg);
+    if (h.type === "throw") return s.method = "throw", s.arg = h.arg, s.delegate = null, U;
+    var w = h.arg;
+    return w ? w.done ? (s[a.resultName] = w.value, s.next = a.nextLoc, s.method !== "return" && (s.method = "next", s.arg = r), s.delegate = null, U) : w : (s.method = "throw", s.arg = new TypeError("iterator result is not an object"), s.delegate = null, U);
+  }
+  function N(a) {
+    var s = { tryLoc: a[0] };
+    1 in a && (s.catchLoc = a[1]), 2 in a && (s.finallyLoc = a[2], s.afterLoc = a[3]), this.tryEntries.push(s);
+  }
+  function b(a) {
+    var s = a.completion || {};
+    s.type = "normal", delete s.arg, a.completion = s;
+  }
+  function z(a) {
+    this.tryEntries = [{ tryLoc: "root" }], a.forEach(N, this), this.reset(!0);
+  }
+  function $(a) {
+    if (a || a === "") {
+      var s = a[u];
+      if (s) return s.call(a);
+      if (typeof a.next == "function") return a;
+      if (!isNaN(a.length)) {
+        var c = -1, v = function h() {
+          for (; ++c < a.length; ) if (n.call(a, c)) return h.value = a[c], h.done = !1, h;
+          return h.value = r, h.done = !0, h;
+        };
+        return v.next = v;
+      }
+    }
+    throw new TypeError(tt(a) + " is not iterable");
+  }
+  return y.prototype = g, o(k, "constructor", { value: g, configurable: !0 }), o(g, "constructor", { value: y, configurable: !0 }), y.displayName = d(g, f, "GeneratorFunction"), t.isGeneratorFunction = function(a) {
+    var s = typeof a == "function" && a.constructor;
+    return !!s && (s === y || (s.displayName || s.name) === "GeneratorFunction");
+  }, t.mark = function(a) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(a, g) : (a.__proto__ = g, d(a, f, "GeneratorFunction")), a.prototype = Object.create(k), a;
+  }, t.awrap = function(a) {
+    return { __await: a };
+  }, C(O.prototype), d(O.prototype, l, function() {
+    return this;
+  }), t.AsyncIterator = O, t.async = function(a, s, c, v, h) {
+    h === void 0 && (h = Promise);
+    var w = new O(_(a, s, c, v), h);
+    return t.isGeneratorFunction(s) ? w : w.next().then(function(R) {
+      return R.done ? R.value : w.next();
+    });
+  }, C(k), d(k, f, "Generator"), d(k, u, function() {
+    return this;
+  }), d(k, "toString", function() {
+    return "[object Generator]";
+  }), t.keys = function(a) {
+    var s = Object(a), c = [];
+    for (var v in s) c.push(v);
+    return c.reverse(), function h() {
+      for (; c.length; ) {
+        var w = c.pop();
+        if (w in s) return h.value = w, h.done = !1, h;
+      }
+      return h.done = !0, h;
+    };
+  }, t.values = $, z.prototype = { constructor: z, reset: function(a) {
+    if (this.prev = 0, this.next = 0, this.sent = this._sent = r, this.done = !1, this.delegate = null, this.method = "next", this.arg = r, this.tryEntries.forEach(b), !a) for (var s in this) s.charAt(0) === "t" && n.call(this, s) && !isNaN(+s.slice(1)) && (this[s] = r);
+  }, stop: function() {
+    this.done = !0;
+    var a = this.tryEntries[0].completion;
+    if (a.type === "throw") throw a.arg;
+    return this.rval;
+  }, dispatchException: function(a) {
+    if (this.done) throw a;
+    var s = this;
+    function c(j, M) {
+      return w.type = "throw", w.arg = a, s.next = j, M && (s.method = "next", s.arg = r), !!M;
+    }
+    for (var v = this.tryEntries.length - 1; v >= 0; --v) {
+      var h = this.tryEntries[v], w = h.completion;
+      if (h.tryLoc === "root") return c("end");
+      if (h.tryLoc <= this.prev) {
+        var R = n.call(h, "catchLoc"), A = n.call(h, "finallyLoc");
+        if (R && A) {
+          if (this.prev < h.catchLoc) return c(h.catchLoc, !0);
+          if (this.prev < h.finallyLoc) return c(h.finallyLoc);
+        } else if (R) {
+          if (this.prev < h.catchLoc) return c(h.catchLoc, !0);
+        } else {
+          if (!A) throw Error("try statement without catch or finally");
+          if (this.prev < h.finallyLoc) return c(h.finallyLoc);
+        }
+      }
+    }
+  }, abrupt: function(a, s) {
+    for (var c = this.tryEntries.length - 1; c >= 0; --c) {
+      var v = this.tryEntries[c];
+      if (v.tryLoc <= this.prev && n.call(v, "finallyLoc") && this.prev < v.finallyLoc) {
+        var h = v;
+        break;
+      }
+    }
+    h && (a === "break" || a === "continue") && h.tryLoc <= s && s <= h.finallyLoc && (h = null);
+    var w = h ? h.completion : {};
+    return w.type = a, w.arg = s, h ? (this.method = "next", this.next = h.finallyLoc, U) : this.complete(w);
+  }, complete: function(a, s) {
+    if (a.type === "throw") throw a.arg;
+    return a.type === "break" || a.type === "continue" ? this.next = a.arg : a.type === "return" ? (this.rval = this.arg = a.arg, this.method = "return", this.next = "end") : a.type === "normal" && s && (this.next = s), U;
+  }, finish: function(a) {
+    for (var s = this.tryEntries.length - 1; s >= 0; --s) {
+      var c = this.tryEntries[s];
+      if (c.finallyLoc === a) return this.complete(c.completion, c.afterLoc), b(c), U;
+    }
+  }, catch: function(a) {
+    for (var s = this.tryEntries.length - 1; s >= 0; --s) {
+      var c = this.tryEntries[s];
+      if (c.tryLoc === a) {
+        var v = c.completion;
+        if (v.type === "throw") {
+          var h = v.arg;
+          b(c);
+        }
+        return h;
+      }
+    }
+    throw Error("illegal catch attempt");
+  }, delegateYield: function(a, s, c) {
+    return this.delegate = { iterator: $(a), resultName: s, nextLoc: c }, this.method === "next" && (this.arg = r), U;
+  } }, t;
+}
+function Fe(r, t, e, n, o, i, u) {
+  try {
+    var l = r[i](u), f = l.value;
+  } catch (d) {
+    e(d);
+    return;
+  }
+  l.done ? t(f) : Promise.resolve(f).then(n, o);
+}
+function Po(r) {
+  return function() {
+    var t = this, e = arguments;
+    return new Promise(function(n, o) {
+      var i = r.apply(t, e);
+      function u(f) {
+        Fe(i, n, o, u, l, "next", f);
+      }
+      function l(f) {
+        Fe(i, n, o, u, l, "throw", f);
+      }
+      u(void 0);
+    });
+  };
+}
+function Lo(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Ao(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, Bo(n.key), n);
+  }
+}
+function jo(r, t, e) {
+  return t && Ao(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Bo(r) {
+  var t = No(r, "string");
+  return tt(t) == "symbol" ? t : t + "";
+}
+function No(r, t) {
+  if (tt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (tt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var Io = /* @__PURE__ */ (function() {
+  function r() {
+    Lo(this, r);
+  }
+  return jo(r, [{
+    key: "openFile",
+    value: (function() {
+      var t = Po(/* @__PURE__ */ Zt().mark(function n(o, i) {
+        var u;
+        return Zt().wrap(function(l) {
+          for (; ; ) switch (l.prev = l.next) {
+            case 0:
+              if (!(Er() && o && typeof o.uri < "u")) {
+                l.next = 11;
+                break;
+              }
+              return l.prev = 1, l.next = 4, go(o.uri);
+            case 4:
+              return u = l.sent, l.abrupt("return", new De(u));
+            case 8:
+              throw l.prev = 8, l.t0 = l.catch(1), new Error("tus: cannot fetch `file.uri` as Blob, make sure the uri is correct and accessible. ".concat(l.t0));
+            case 11:
+              if (!(typeof o.slice == "function" && typeof o.size < "u")) {
+                l.next = 13;
+                break;
+              }
+              return l.abrupt("return", Promise.resolve(new De(o)));
+            case 13:
+              if (typeof o.read != "function") {
+                l.next = 18;
+                break;
+              }
+              if (i = Number(i), Number.isFinite(i)) {
+                l.next = 17;
+                break;
+              }
+              return l.abrupt("return", Promise.reject(new Error("cannot create source for stream without a finite value for the `chunkSize` option")));
+            case 17:
+              return l.abrupt("return", Promise.resolve(new Co(o, i)));
+            case 18:
+              return l.abrupt("return", Promise.reject(new Error("source object may only be an instance of File, Blob, or Reader in this environment")));
+            case 19:
+            case "end":
+              return l.stop();
+          }
+        }, n, null, [[1, 8]]);
+      }));
+      function e(n, o) {
+        return t.apply(this, arguments);
+      }
+      return e;
+    })()
+  }]);
+})();
+function Do(r, t) {
+  return Er() ? Promise.resolve(qo(r, t)) : Promise.resolve(["tus-br", r.name, r.type, r.size, r.lastModified, t.endpoint].join("-"));
+}
+function qo(r, t) {
+  var e = r.exif ? Fo(JSON.stringify(r.exif)) : "noexif";
+  return ["tus-rn", r.name || "noname", r.size || "nosize", e, t.endpoint].join("/");
+}
+function Fo(r) {
+  var t = 0;
+  if (r.length === 0)
+    return t;
+  for (var e = 0; e < r.length; e++) {
+    var n = r.charCodeAt(e);
+    t = (t << 5) - t + n, t &= t;
+  }
+  return t;
+}
+function gt(r) {
+  "@babel/helpers - typeof";
+  return gt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, gt(r);
+}
+function ce(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Ho(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, zo(n.key), n);
+  }
+}
+function le(r, t, e) {
+  return t && Ho(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function zo(r) {
+  var t = Mo(r, "string");
+  return gt(t) == "symbol" ? t : t + "";
+}
+function Mo(r, t) {
+  if (gt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (gt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var Vo = /* @__PURE__ */ (function() {
+  function r() {
+    ce(this, r);
+  }
+  return le(r, [{
+    key: "createRequest",
+    value: function(t, e) {
+      return new Ko(t, e);
+    }
+  }, {
+    key: "getName",
+    value: function() {
+      return "XHRHttpStack";
+    }
+  }]);
+})(), Ko = /* @__PURE__ */ (function() {
+  function r(t, e) {
+    ce(this, r), this._xhr = new XMLHttpRequest(), this._xhr.open(t, e, !0), this._method = t, this._url = e, this._headers = {};
+  }
+  return le(r, [{
+    key: "getMethod",
+    value: function() {
+      return this._method;
+    }
+  }, {
+    key: "getURL",
+    value: function() {
+      return this._url;
+    }
+  }, {
+    key: "setHeader",
+    value: function(t, e) {
+      this._xhr.setRequestHeader(t, e), this._headers[t] = e;
+    }
+  }, {
+    key: "getHeader",
+    value: function(t) {
+      return this._headers[t];
+    }
+  }, {
+    key: "setProgressHandler",
+    value: function(t) {
+      "upload" in this._xhr && (this._xhr.upload.onprogress = function(e) {
+        e.lengthComputable && t(e.loaded);
+      });
+    }
+  }, {
+    key: "send",
+    value: function() {
+      var t = this, e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : null;
+      return new Promise(function(n, o) {
+        t._xhr.onload = function() {
+          n(new Go(t._xhr));
+        }, t._xhr.onerror = function(i) {
+          o(i);
+        }, t._xhr.send(e);
+      });
+    }
+  }, {
+    key: "abort",
+    value: function() {
+      return this._xhr.abort(), Promise.resolve();
+    }
+  }, {
+    key: "getUnderlyingObject",
+    value: function() {
+      return this._xhr;
+    }
+  }]);
+})(), Go = /* @__PURE__ */ (function() {
+  function r(t) {
+    ce(this, r), this._xhr = t;
+  }
+  return le(r, [{
+    key: "getStatus",
+    value: function() {
+      return this._xhr.status;
+    }
+  }, {
+    key: "getHeader",
+    value: function(t) {
+      return this._xhr.getResponseHeader(t);
+    }
+  }, {
+    key: "getBody",
+    value: function() {
+      return this._xhr.responseText;
+    }
+  }, {
+    key: "getUnderlyingObject",
+    value: function() {
+      return this._xhr;
+    }
+  }]);
+})();
+function mt(r) {
+  "@babel/helpers - typeof";
+  return mt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, mt(r);
+}
+function Yo(r, t) {
+  if (!(r instanceof t))
+    throw new TypeError("Cannot call a class as a function");
+}
+function Wo(r, t) {
+  for (var e = 0; e < t.length; e++) {
+    var n = t[e];
+    n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(r, Xo(n.key), n);
+  }
+}
+function Jo(r, t, e) {
+  return t && Wo(r.prototype, t), Object.defineProperty(r, "prototype", { writable: !1 }), r;
+}
+function Xo(r) {
+  var t = $o(r, "string");
+  return mt(t) == "symbol" ? t : t + "";
+}
+function $o(r, t) {
+  if (mt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (mt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return String(r);
+}
+var te = !1;
+try {
+  te = "localStorage" in window;
+  var Dt = "tusSupport", He = localStorage.getItem(Dt);
+  localStorage.setItem(Dt, He), He === null && localStorage.removeItem(Dt);
+} catch (r) {
+  if (r.code === r.SECURITY_ERR || r.code === r.QUOTA_EXCEEDED_ERR)
+    te = !1;
+  else
+    throw r;
+}
+var Qo = te, Zo = /* @__PURE__ */ (function() {
+  function r() {
+    Yo(this, r);
+  }
+  return Jo(r, [{
+    key: "findAllUploads",
+    value: function() {
+      var t = this._findEntries("tus::");
+      return Promise.resolve(t);
+    }
+  }, {
+    key: "findUploadsByFingerprint",
+    value: function(t) {
+      var e = this._findEntries("tus::".concat(t, "::"));
+      return Promise.resolve(e);
+    }
+  }, {
+    key: "removeUpload",
+    value: function(t) {
+      return localStorage.removeItem(t), Promise.resolve();
+    }
+  }, {
+    key: "addUpload",
+    value: function(t, e) {
+      var n = Math.round(Math.random() * 1e12), o = "tus::".concat(t, "::").concat(n);
+      return localStorage.setItem(o, JSON.stringify(e)), Promise.resolve(o);
+    }
+  }, {
+    key: "_findEntries",
+    value: function(t) {
+      for (var e = [], n = 0; n < localStorage.length; n++) {
+        var o = localStorage.key(n);
+        if (o.indexOf(t) === 0)
+          try {
+            var i = JSON.parse(localStorage.getItem(o));
+            i.urlStorageKey = o, e.push(i);
+          } catch {
+          }
+      }
+      return e;
+    }
+  }]);
+})();
+function vt(r) {
+  "@babel/helpers - typeof";
+  return vt = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t) {
+    return typeof t;
+  } : function(t) {
+    return t && typeof Symbol == "function" && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+  }, vt(r);
+}
+function ze(r, t) {
+  var e = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(r);
+    t && (n = n.filter(function(o) {
+      return Object.getOwnPropertyDescriptor(r, o).enumerable;
+    })), e.push.apply(e, n);
+  }
+  return e;
+}
+function Me(r) {
+  for (var t = 1; t < arguments.length; t++) {
+    var e = arguments[t] != null ? arguments[t] : {};
+    t % 2 ? ze(Object(e), !0).forEach(function(n) {
+      ti(r, n, e[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(e)) : ze(Object(e)).forEach(function(n) {
+      Object.defineProperty(r, n, Object.getOwnPropertyDescriptor(e, n));
+    });
+  }
+  return r;
+}
+function ti(r, t, e) {
+  return t = ei(t), t in r ? Object.defineProperty(r, t, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : r[t] = e, r;
+}
+function ei(r) {
+  var t = ri(r, "string");
+  return vt(t) == "symbol" ? t : t + "";
+}
+function ri(r, t) {
+  if (vt(r) != "object" || !r) return r;
+  var e = r[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(r, t);
+    if (vt(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(r);
+}
+Me(Me({}, _r.defaultOptions), {}, {
+  httpStack: new Vo(),
+  fileReader: new Io(),
+  urlStorage: Qo ? new Zo() : new qn(),
+  fingerprint: Do
+});
+export {
+  Ve as g
+};