@vunex/support-chat 1.0.0

package/dist/gig-support-chat.es.js

@@ -0,0 +1,3106 @@
+import { hasInjectionContext as St, inject as Ct, getCurrentInstance as Nt, ref as b, reactive as Ot, markRaw as J, effectScope as Tt, isRef as se, isReactive as Pe, toRef as ge, toRaw as xt, nextTick as be, getCurrentScope as Rt, onScopeDispose as At, watch as tt, toRefs as Fe, computed as De, defineComponent as Ie, openBlock as C, createElementBlock as O, normalizeClass as Ee, createElementVNode as u, toDisplayString as V, createCommentVNode as U, onMounted as st, onUnmounted as nt, normalizeStyle as Bt, withModifiers as He, Fragment as We, renderList as ze, createBlock as rt, unref as N, createVNode as ke, Transition as Se, withCtx as Ce, createStaticVNode as Lt, withDirectives as Pt, withKeys as Dt, vModelText as It } from "vue";
+function re(s, e, t) {
+  return Array.isArray(s) ? (s.length = Math.max(s.length, e), s.splice(e, 1, t), t) : (s[e] = t, t);
+}
+function ye(s, e) {
+  if (Array.isArray(s)) {
+    s.splice(e, 1);
+    return;
+  }
+  delete s[e];
+}
+/*!
+ * pinia v2.3.1
+ * (c) 2025 Eduardo San Martin Morote
+ * @license MIT
+ */
+let Q;
+const he = (s) => Q = s, Vt = process.env.NODE_ENV !== "production" ? Symbol("pinia") : (
+  /* istanbul ignore next */
+  Symbol()
+);
+function $(s) {
+  return s && typeof s == "object" && Object.prototype.toString.call(s) === "[object Object]" && typeof s.toJSON != "function";
+}
+var te;
+(function(s) {
+  s.direct = "direct", s.patchObject = "patch object", s.patchFunction = "patch function";
+})(te || (te = {}));
+const Z = typeof window < "u";
+function it(s, e) {
+  for (const t in e) {
+    const n = e[t];
+    if (!(t in s))
+      continue;
+    const r = s[t];
+    $(r) && $(n) && !se(n) && !Pe(n) ? s[t] = it(r, n) : s[t] = n;
+  }
+  return s;
+}
+const ot = () => {
+};
+function je(s, e, t, n = ot) {
+  s.push(e);
+  const r = () => {
+    const i = s.indexOf(e);
+    i > -1 && (s.splice(i, 1), n());
+  };
+  return !t && Rt() && At(r), r;
+}
+function H(s, ...e) {
+  s.slice().forEach((t) => {
+    t(...e);
+  });
+}
+const Ut = (s) => s(), Ke = Symbol(), me = Symbol();
+function Ne(s, e) {
+  s instanceof Map && e instanceof Map ? e.forEach((t, n) => s.set(n, t)) : s instanceof Set && e instanceof Set && e.forEach(s.add, s);
+  for (const t in e) {
+    if (!e.hasOwnProperty(t))
+      continue;
+    const n = e[t], r = s[t];
+    $(r) && $(n) && s.hasOwnProperty(t) && !se(n) && !Pe(n) ? s[t] = Ne(r, n) : s[t] = n;
+  }
+  return s;
+}
+const Mt = process.env.NODE_ENV !== "production" ? Symbol("pinia:skipHydration") : (
+  /* istanbul ignore next */
+  Symbol()
+);
+function qt(s) {
+  return !$(s) || !s.hasOwnProperty(Mt);
+}
+const { assign: B } = Object;
+function Ye(s) {
+  return !!(se(s) && s.effect);
+}
+function Xe(s, e, t, n) {
+  const { state: r, actions: i, getters: c } = e, l = t.state.value[s];
+  let h;
+  function f() {
+    !l && (process.env.NODE_ENV === "production" || !n) && (t.state.value[s] = r ? r() : {});
+    const p = process.env.NODE_ENV !== "production" && n ? (
+      // use ref() to unwrap refs inside state TODO: check if this is still necessary
+      Fe(b(r ? r() : {}).value)
+    ) : Fe(t.state.value[s]);
+    return B(p, i, Object.keys(c || {}).reduce((g, w) => (process.env.NODE_ENV !== "production" && w in p && console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${w}" in store "${s}".`), g[w] = J(De(() => {
+      he(t);
+      const T = t._s.get(s);
+      return c[w].call(T, T);
+    })), g), {}));
+  }
+  return h = Oe(s, f, e, t, n, !0), h;
+}
+function Oe(s, e, t = {}, n, r, i) {
+  let c;
+  const l = B({ actions: {} }, t);
+  if (process.env.NODE_ENV !== "production" && !n._e.active)
+    throw new Error("Pinia destroyed");
+  const h = { deep: !0 };
+  process.env.NODE_ENV !== "production" && (h.onTrigger = (o) => {
+    f ? T = o : f == !1 && !d._hotUpdating && (Array.isArray(T) ? T.push(o) : console.error("🍍 debuggerEvents should be an array. This is most likely an internal Pinia bug."));
+  });
+  let f, p, g = [], w = [], T;
+  const x = n.state.value[s];
+  !i && !x && (process.env.NODE_ENV === "production" || !r) && (n.state.value[s] = {});
+  const F = b({});
+  let z;
+  function j(o) {
+    let a;
+    f = p = !1, process.env.NODE_ENV !== "production" && (T = []), typeof o == "function" ? (o(n.state.value[s]), a = {
+      type: te.patchFunction,
+      storeId: s,
+      events: T
+    }) : (Ne(n.state.value[s], o), a = {
+      type: te.patchObject,
+      payload: o,
+      storeId: s,
+      events: T
+    });
+    const m = z = Symbol();
+    be().then(() => {
+      z === m && (f = !0);
+    }), p = !0, H(g, a, n.state.value[s]);
+  }
+  const q = i ? function() {
+    const { state: a } = t, m = a ? a() : {};
+    this.$patch((R) => {
+      B(R, m);
+    });
+  } : (
+    /* istanbul ignore next */
+    process.env.NODE_ENV !== "production" ? () => {
+      throw new Error(`🍍: Store "${s}" is built using the setup syntax and does not implement $reset().`);
+    } : ot
+  );
+  function ne() {
+    c.stop(), g = [], w = [], n._s.delete(s);
+  }
+  const k = (o, a = "") => {
+    if (Ke in o)
+      return o[me] = a, o;
+    const m = function() {
+      he(n);
+      const R = Array.from(arguments), Y = [], pe = [];
+      function Et(A) {
+        Y.push(A);
+      }
+      function kt(A) {
+        pe.push(A);
+      }
+      H(w, {
+        args: R,
+        name: m[me],
+        store: d,
+        after: Et,
+        onError: kt
+      });
+      let X;
+      try {
+        X = o.apply(this && this.$id === s ? this : d, R);
+      } catch (A) {
+        throw H(pe, A), A;
+      }
+      return X instanceof Promise ? X.then((A) => (H(Y, A), A)).catch((A) => (H(pe, A), Promise.reject(A))) : (H(Y, X), X);
+    };
+    return m[Ke] = !0, m[me] = a, m;
+  }, _ = /* @__PURE__ */ J({
+    actions: {},
+    getters: {},
+    state: [],
+    hotState: F
+  }), S = {
+    _p: n,
+    // _s: scope,
+    $id: s,
+    $onAction: je.bind(null, w),
+    $patch: j,
+    $reset: q,
+    $subscribe(o, a = {}) {
+      const m = je(g, o, a.detached, () => R()), R = c.run(() => tt(() => n.state.value[s], (Y) => {
+        (a.flush === "sync" ? p : f) && o({
+          storeId: s,
+          type: te.direct,
+          events: T
+        }, Y);
+      }, B({}, h, a)));
+      return m;
+    },
+    $dispose: ne
+  }, d = Ot(process.env.NODE_ENV !== "production" || process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && Z ? B(
+    {
+      _hmrPayload: _,
+      _customProperties: J(/* @__PURE__ */ new Set())
+      // devtools custom properties
+    },
+    S
+    // must be added later
+    // setupStore
+  ) : S);
+  n._s.set(s, d);
+  const y = (n._a && n._a.runWithContext || Ut)(() => n._e.run(() => (c = Tt()).run(() => e({ action: k }))));
+  for (const o in y) {
+    const a = y[o];
+    if (se(a) && !Ye(a) || Pe(a))
+      process.env.NODE_ENV !== "production" && r ? re(F.value, o, ge(y, o)) : i || (x && qt(a) && (se(a) ? a.value = x[o] : Ne(a, x[o])), n.state.value[s][o] = a), process.env.NODE_ENV !== "production" && _.state.push(o);
+    else if (typeof a == "function") {
+      const m = process.env.NODE_ENV !== "production" && r ? a : k(a, o);
+      y[o] = m, process.env.NODE_ENV !== "production" && (_.actions[o] = a), l.actions[o] = a;
+    } else process.env.NODE_ENV !== "production" && Ye(a) && (_.getters[o] = i ? (
+      // @ts-expect-error
+      t.getters[o]
+    ) : a, Z && (y._getters || // @ts-expect-error: same
+    (y._getters = J([]))).push(o));
+  }
+  if (B(d, y), B(xt(d), y), Object.defineProperty(d, "$state", {
+    get: () => process.env.NODE_ENV !== "production" && r ? F.value : n.state.value[s],
+    set: (o) => {
+      if (process.env.NODE_ENV !== "production" && r)
+        throw new Error("cannot set hotState");
+      j((a) => {
+        B(a, o);
+      });
+    }
+  }), process.env.NODE_ENV !== "production" && (d._hotUpdate = J((o) => {
+    d._hotUpdating = !0, o._hmrPayload.state.forEach((a) => {
+      if (a in d.$state) {
+        const m = o.$state[a], R = d.$state[a];
+        typeof m == "object" && $(m) && $(R) ? it(m, R) : o.$state[a] = R;
+      }
+      re(d, a, ge(o.$state, a));
+    }), Object.keys(d.$state).forEach((a) => {
+      a in o.$state || ye(d, a);
+    }), f = !1, p = !1, n.state.value[s] = ge(o._hmrPayload, "hotState"), p = !0, be().then(() => {
+      f = !0;
+    });
+    for (const a in o._hmrPayload.actions) {
+      const m = o[a];
+      re(d, a, k(m, a));
+    }
+    for (const a in o._hmrPayload.getters) {
+      const m = o._hmrPayload.getters[a], R = i ? (
+        // special handling of options api
+        De(() => (he(n), m.call(d, d)))
+      ) : m;
+      re(d, a, R);
+    }
+    Object.keys(d._hmrPayload.getters).forEach((a) => {
+      a in o._hmrPayload.getters || ye(d, a);
+    }), Object.keys(d._hmrPayload.actions).forEach((a) => {
+      a in o._hmrPayload.actions || ye(d, a);
+    }), d._hmrPayload = o._hmrPayload, d._getters = o._getters, d._hotUpdating = !1;
+  })), process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && Z) {
+    const o = {
+      writable: !0,
+      configurable: !0,
+      // avoid warning on devtools trying to display this property
+      enumerable: !1
+    };
+    ["_p", "_hmrPayload", "_getters", "_customProperties"].forEach((a) => {
+      Object.defineProperty(d, a, B({ value: d[a] }, o));
+    });
+  }
+  return n._p.forEach((o) => {
+    if (process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test" && Z) {
+      const a = c.run(() => o({
+        store: d,
+        app: n._a,
+        pinia: n,
+        options: l
+      }));
+      Object.keys(a || {}).forEach((m) => d._customProperties.add(m)), B(d, a);
+    } else
+      B(d, c.run(() => o({
+        store: d,
+        app: n._a,
+        pinia: n,
+        options: l
+      })));
+  }), process.env.NODE_ENV !== "production" && d.$state && typeof d.$state == "object" && typeof d.$state.constructor == "function" && !d.$state.constructor.toString().includes("[native code]") && console.warn(`[🍍]: The "state" must be a plain object. It cannot be
+	state: () => new MyClass()
+Found in store "${d.$id}".`), x && i && t.hydrate && t.hydrate(d.$state, x), f = !0, p = !0, d;
+}
+/*! #__NO_SIDE_EFFECTS__ */
+// @__NO_SIDE_EFFECTS__
+function $t(s, e, t) {
+  let n, r;
+  const i = typeof e == "function";
+  n = s, r = i ? t : e;
+  function c(l, h) {
+    const f = St();
+    if (l = // in test mode, ignore the argument provided as we can always retrieve a
+    // pinia instance with getActivePinia()
+    (process.env.NODE_ENV === "test" && Q && Q._testing ? null : l) || (f ? Ct(Vt, null) : null), l && he(l), process.env.NODE_ENV !== "production" && !Q)
+      throw new Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "app.use(pinia)"?
+See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.
+This will fail in production.`);
+    l = Q, l._s.has(n) || (i ? Oe(n, e, r, l) : Xe(n, r, l), process.env.NODE_ENV !== "production" && (c._pinia = l));
+    const p = l._s.get(n);
+    if (process.env.NODE_ENV !== "production" && h) {
+      const g = "__hot:" + n, w = i ? Oe(g, e, r, l, !0) : Xe(g, B({}, r), l, !0);
+      h._hotUpdate(w), delete l.state.value[g], l._s.delete(g);
+    }
+    if (process.env.NODE_ENV !== "production" && Z) {
+      const g = Nt();
+      if (g && g.proxy && // avoid adding stores that are just built for hot module replacement
+      !h) {
+        const w = g.proxy, T = "_pStores" in w ? w._pStores : w._pStores = {};
+        T[n] = p;
+      }
+    }
+    return p;
+  }
+  return c.$id = n, c;
+}
+const I = /* @__PURE__ */ Object.create(null);
+I.open = "0";
+I.close = "1";
+I.ping = "2";
+I.pong = "3";
+I.message = "4";
+I.upgrade = "5";
+I.noop = "6";
+const ae = /* @__PURE__ */ Object.create(null);
+Object.keys(I).forEach((s) => {
+  ae[I[s]] = s;
+});
+const Te = { type: "error", data: "parser error" }, at = typeof Blob == "function" || typeof Blob < "u" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", ct = typeof ArrayBuffer == "function", lt = (s) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(s) : s && s.buffer instanceof ArrayBuffer, Ve = ({ type: s, data: e }, t, n) => at && e instanceof Blob ? t ? n(e) : Ge(e, n) : ct && (e instanceof ArrayBuffer || lt(e)) ? t ? n(e) : Ge(new Blob([e]), n) : n(I[s] + (e || "")), Ge = (s, e) => {
+  const t = new FileReader();
+  return t.onload = function() {
+    const n = t.result.split(",")[1];
+    e("b" + (n || ""));
+  }, t.readAsDataURL(s);
+};
+function Je(s) {
+  return s instanceof Uint8Array ? s : s instanceof ArrayBuffer ? new Uint8Array(s) : new Uint8Array(s.buffer, s.byteOffset, s.byteLength);
+}
+let ve;
+function Ft(s, e) {
+  if (at && s.data instanceof Blob)
+    return s.data.arrayBuffer().then(Je).then(e);
+  if (ct && (s.data instanceof ArrayBuffer || lt(s.data)))
+    return e(Je(s.data));
+  Ve(s, !1, (t) => {
+    ve || (ve = new TextEncoder()), e(ve.encode(t));
+  });
+}
+const Qe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", ee = typeof Uint8Array > "u" ? [] : new Uint8Array(256);
+for (let s = 0; s < Qe.length; s++)
+  ee[Qe.charCodeAt(s)] = s;
+const Ht = (s) => {
+  let e = s.length * 0.75, t = s.length, n, r = 0, i, c, l, h;
+  s[s.length - 1] === "=" && (e--, s[s.length - 2] === "=" && e--);
+  const f = new ArrayBuffer(e), p = new Uint8Array(f);
+  for (n = 0; n < t; n += 4)
+    i = ee[s.charCodeAt(n)], c = ee[s.charCodeAt(n + 1)], l = ee[s.charCodeAt(n + 2)], h = ee[s.charCodeAt(n + 3)], p[r++] = i << 2 | c >> 4, p[r++] = (c & 15) << 4 | l >> 2, p[r++] = (l & 3) << 6 | h & 63;
+  return f;
+}, Wt = typeof ArrayBuffer == "function", Ue = (s, e) => {
+  if (typeof s != "string")
+    return {
+      type: "message",
+      data: ut(s, e)
+    };
+  const t = s.charAt(0);
+  return t === "b" ? {
+    type: "message",
+    data: zt(s.substring(1), e)
+  } : ae[t] ? s.length > 1 ? {
+    type: ae[t],
+    data: s.substring(1)
+  } : {
+    type: ae[t]
+  } : Te;
+}, zt = (s, e) => {
+  if (Wt) {
+    const t = Ht(s);
+    return ut(t, e);
+  } else
+    return { base64: !0, data: s };
+}, ut = (s, e) => {
+  switch (e) {
+    case "blob":
+      return s instanceof Blob ? s : new Blob([s]);
+    case "arraybuffer":
+    default:
+      return s instanceof ArrayBuffer ? s : s.buffer;
+  }
+}, ht = "", jt = (s, e) => {
+  const t = s.length, n = new Array(t);
+  let r = 0;
+  s.forEach((i, c) => {
+    Ve(i, !1, (l) => {
+      n[c] = l, ++r === t && e(n.join(ht));
+    });
+  });
+}, Kt = (s, e) => {
+  const t = s.split(ht), n = [];
+  for (let r = 0; r < t.length; r++) {
+    const i = Ue(t[r], e);
+    if (n.push(i), i.type === "error")
+      break;
+  }
+  return n;
+};
+function Yt() {
+  return new TransformStream({
+    transform(s, e) {
+      Ft(s, (t) => {
+        const n = t.length;
+        let r;
+        if (n < 126)
+          r = new Uint8Array(1), new DataView(r.buffer).setUint8(0, n);
+        else if (n < 65536) {
+          r = new Uint8Array(3);
+          const i = new DataView(r.buffer);
+          i.setUint8(0, 126), i.setUint16(1, n);
+        } else {
+          r = new Uint8Array(9);
+          const i = new DataView(r.buffer);
+          i.setUint8(0, 127), i.setBigUint64(1, BigInt(n));
+        }
+        s.data && typeof s.data != "string" && (r[0] |= 128), e.enqueue(r), e.enqueue(t);
+      });
+    }
+  });
+}
+let _e;
+function ie(s) {
+  return s.reduce((e, t) => e + t.length, 0);
+}
+function oe(s, e) {
+  if (s[0].length === e)
+    return s.shift();
+  const t = new Uint8Array(e);
+  let n = 0;
+  for (let r = 0; r < e; r++)
+    t[r] = s[0][n++], n === s[0].length && (s.shift(), n = 0);
+  return s.length && n < s[0].length && (s[0] = s[0].slice(n)), t;
+}
+function Xt(s, e) {
+  _e || (_e = new TextDecoder());
+  const t = [];
+  let n = 0, r = -1, i = !1;
+  return new TransformStream({
+    transform(c, l) {
+      for (t.push(c); ; ) {
+        if (n === 0) {
+          if (ie(t) < 1)
+            break;
+          const h = oe(t, 1);
+          i = (h[0] & 128) === 128, r = h[0] & 127, r < 126 ? n = 3 : r === 126 ? n = 1 : n = 2;
+        } else if (n === 1) {
+          if (ie(t) < 2)
+            break;
+          const h = oe(t, 2);
+          r = new DataView(h.buffer, h.byteOffset, h.length).getUint16(0), n = 3;
+        } else if (n === 2) {
+          if (ie(t) < 8)
+            break;
+          const h = oe(t, 8), f = new DataView(h.buffer, h.byteOffset, h.length), p = f.getUint32(0);
+          if (p > Math.pow(2, 21) - 1) {
+            l.enqueue(Te);
+            break;
+          }
+          r = p * Math.pow(2, 32) + f.getUint32(4), n = 3;
+        } else {
+          if (ie(t) < r)
+            break;
+          const h = oe(t, r);
+          l.enqueue(Ue(i ? h : _e.decode(h), e)), n = 0;
+        }
+        if (r === 0 || r > s) {
+          l.enqueue(Te);
+          break;
+        }
+      }
+    }
+  });
+}
+const ft = 4;
+function E(s) {
+  if (s) return Gt(s);
+}
+function Gt(s) {
+  for (var e in E.prototype)
+    s[e] = E.prototype[e];
+  return s;
+}
+E.prototype.on = E.prototype.addEventListener = function(s, e) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks["$" + s] = this._callbacks["$" + s] || []).push(e), this;
+};
+E.prototype.once = function(s, e) {
+  function t() {
+    this.off(s, t), e.apply(this, arguments);
+  }
+  return t.fn = e, this.on(s, t), this;
+};
+E.prototype.off = E.prototype.removeListener = E.prototype.removeAllListeners = E.prototype.removeEventListener = function(s, e) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0)
+    return this._callbacks = {}, this;
+  var t = this._callbacks["$" + s];
+  if (!t) return this;
+  if (arguments.length == 1)
+    return delete this._callbacks["$" + s], this;
+  for (var n, r = 0; r < t.length; r++)
+    if (n = t[r], n === e || n.fn === e) {
+      t.splice(r, 1);
+      break;
+    }
+  return t.length === 0 && delete this._callbacks["$" + s], this;
+};
+E.prototype.emit = function(s) {
+  this._callbacks = this._callbacks || {};
+  for (var e = new Array(arguments.length - 1), t = this._callbacks["$" + s], n = 1; n < arguments.length; n++)
+    e[n - 1] = arguments[n];
+  if (t) {
+    t = t.slice(0);
+    for (var n = 0, r = t.length; n < r; ++n)
+      t[n].apply(this, e);
+  }
+  return this;
+};
+E.prototype.emitReserved = E.prototype.emit;
+E.prototype.listeners = function(s) {
+  return this._callbacks = this._callbacks || {}, this._callbacks["$" + s] || [];
+};
+E.prototype.hasListeners = function(s) {
+  return !!this.listeners(s).length;
+};
+const fe = typeof Promise == "function" && typeof Promise.resolve == "function" ? (e) => Promise.resolve().then(e) : (e, t) => t(e, 0), L = typeof self < "u" ? self : typeof window < "u" ? window : Function("return this")(), Jt = "arraybuffer";
+function dt(s, ...e) {
+  return e.reduce((t, n) => (s.hasOwnProperty(n) && (t[n] = s[n]), t), {});
+}
+const Qt = L.setTimeout, Zt = L.clearTimeout;
+function de(s, e) {
+  e.useNativeTimers ? (s.setTimeoutFn = Qt.bind(L), s.clearTimeoutFn = Zt.bind(L)) : (s.setTimeoutFn = L.setTimeout.bind(L), s.clearTimeoutFn = L.clearTimeout.bind(L));
+}
+const es = 1.33;
+function ts(s) {
+  return typeof s == "string" ? ss(s) : Math.ceil((s.byteLength || s.size) * es);
+}
+function ss(s) {
+  let e = 0, t = 0;
+  for (let n = 0, r = s.length; n < r; n++)
+    e = s.charCodeAt(n), e < 128 ? t += 1 : e < 2048 ? t += 2 : e < 55296 || e >= 57344 ? t += 3 : (n++, t += 4);
+  return t;
+}
+function pt() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+function ns(s) {
+  let e = "";
+  for (let t in s)
+    s.hasOwnProperty(t) && (e.length && (e += "&"), e += encodeURIComponent(t) + "=" + encodeURIComponent(s[t]));
+  return e;
+}
+function rs(s) {
+  let e = {}, t = s.split("&");
+  for (let n = 0, r = t.length; n < r; n++) {
+    let i = t[n].split("=");
+    e[decodeURIComponent(i[0])] = decodeURIComponent(i[1]);
+  }
+  return e;
+}
+class is extends Error {
+  constructor(e, t, n) {
+    super(e), this.description = t, this.context = n, this.type = "TransportError";
+  }
+}
+class Me extends E {
+  /**
+   * Transport abstract constructor.
+   *
+   * @param {Object} opts - options
+   * @protected
+   */
+  constructor(e) {
+    super(), this.writable = !1, de(this, e), this.opts = e, this.query = e.query, this.socket = e.socket, this.supportsBinary = !e.forceBase64;
+  }
+  /**
+   * Emits an error.
+   *
+   * @param {String} reason
+   * @param description
+   * @param context - the error context
+   * @return {Transport} for chaining
+   * @protected
+   */
+  onError(e, t, n) {
+    return super.emitReserved("error", new is(e, t, 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(e) {
+    this.readyState === "open" && this.write(e);
+  }
+  /**
+   * Called upon open
+   *
+   * @protected
+   */
+  onOpen() {
+    this.readyState = "open", this.writable = !0, super.emitReserved("open");
+  }
+  /**
+   * Called with data.
+   *
+   * @param {String} data
+   * @protected
+   */
+  onData(e) {
+    const t = Ue(e, this.socket.binaryType);
+    this.onPacket(t);
+  }
+  /**
+   * Called with a decoded packet.
+   *
+   * @protected
+   */
+  onPacket(e) {
+    super.emitReserved("packet", e);
+  }
+  /**
+   * Called upon close.
+   *
+   * @protected
+   */
+  onClose(e) {
+    this.readyState = "closed", super.emitReserved("close", e);
+  }
+  /**
+   * Pauses the transport, in order not to lose packets during an upgrade.
+   *
+   * @param onPause
+   */
+  pause(e) {
+  }
+  createUri(e, t = {}) {
+    return e + "://" + this._hostname() + this._port() + this.opts.path + this._query(t);
+  }
+  _hostname() {
+    const e = this.opts.hostname;
+    return e.indexOf(":") === -1 ? e : "[" + e + "]";
+  }
+  _port() {
+    return this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80) ? ":" + this.opts.port : "";
+  }
+  _query(e) {
+    const t = ns(e);
+    return t.length ? "?" + t : "";
+  }
+}
+class os extends Me {
+  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(e) {
+    this.readyState = "pausing";
+    const t = () => {
+      this.readyState = "paused", e();
+    };
+    if (this._polling || !this.writable) {
+      let n = 0;
+      this._polling && (n++, this.once("pollComplete", function() {
+        --n || t();
+      })), this.writable || (n++, this.once("drain", function() {
+        --n || t();
+      }));
+    } else
+      t();
+  }
+  /**
+   * Starts polling cycle.
+   *
+   * @private
+   */
+  _poll() {
+    this._polling = !0, this.doPoll(), this.emitReserved("poll");
+  }
+  /**
+   * Overloads onData to detect payloads.
+   *
+   * @protected
+   */
+  onData(e) {
+    const t = (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);
+    };
+    Kt(e, this.socket.binaryType).forEach(t), this.readyState !== "closed" && (this._polling = !1, this.emitReserved("pollComplete"), this.readyState === "open" && this._poll());
+  }
+  /**
+   * For polling, send a close packet.
+   *
+   * @protected
+   */
+  doClose() {
+    const e = () => {
+      this.write([{ type: "close" }]);
+    };
+    this.readyState === "open" ? e() : this.once("open", e);
+  }
+  /**
+   * Writes a packets payload.
+   *
+   * @param {Array} packets - data packets
+   * @protected
+   */
+  write(e) {
+    this.writable = !1, jt(e, (t) => {
+      this.doWrite(t, () => {
+        this.writable = !0, this.emitReserved("drain");
+      });
+    });
+  }
+  /**
+   * Generates uri for connection.
+   *
+   * @private
+   */
+  uri() {
+    const e = this.opts.secure ? "https" : "http", t = this.query || {};
+    return this.opts.timestampRequests !== !1 && (t[this.opts.timestampParam] = pt()), !this.supportsBinary && !t.sid && (t.b64 = 1), this.createUri(e, t);
+  }
+}
+let gt = !1;
+try {
+  gt = typeof XMLHttpRequest < "u" && "withCredentials" in new XMLHttpRequest();
+} catch {
+}
+const as = gt;
+function cs() {
+}
+class ls extends os {
+  /**
+   * XHR Polling constructor.
+   *
+   * @param {Object} opts
+   * @package
+   */
+  constructor(e) {
+    if (super(e), typeof location < "u") {
+      const t = location.protocol === "https:";
+      let n = location.port;
+      n || (n = t ? "443" : "80"), this.xd = typeof location < "u" && e.hostname !== location.hostname || n !== e.port;
+    }
+  }
+  /**
+   * Sends data.
+   *
+   * @param {String} data to send.
+   * @param {Function} called upon flush.
+   * @private
+   */
+  doWrite(e, t) {
+    const n = this.request({
+      method: "POST",
+      data: e
+    });
+    n.on("success", t), n.on("error", (r, i) => {
+      this.onError("xhr post error", r, i);
+    });
+  }
+  /**
+   * Starts a poll cycle.
+   *
+   * @private
+   */
+  doPoll() {
+    const e = this.request();
+    e.on("data", this.onData.bind(this)), e.on("error", (t, n) => {
+      this.onError("xhr poll error", t, n);
+    }), this.pollXhr = e;
+  }
+}
+class D extends E {
+  /**
+   * Request constructor
+   *
+   * @param {Object} options
+   * @package
+   */
+  constructor(e, t, n) {
+    super(), this.createRequest = e, de(this, n), this._opts = n, this._method = n.method || "GET", this._uri = t, this._data = n.data !== void 0 ? n.data : null, this._create();
+  }
+  /**
+   * Creates the XHR object and sends the request.
+   *
+   * @private
+   */
+  _create() {
+    var e;
+    const t = dt(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    t.xdomain = !!this._opts.xd;
+    const n = this._xhr = this.createRequest(t);
+    try {
+      n.open(this._method, this._uri, !0);
+      try {
+        if (this._opts.extraHeaders) {
+          n.setDisableHeaderCheck && n.setDisableHeaderCheck(!0);
+          for (let r in this._opts.extraHeaders)
+            this._opts.extraHeaders.hasOwnProperty(r) && n.setRequestHeader(r, this._opts.extraHeaders[r]);
+        }
+      } catch {
+      }
+      if (this._method === "POST")
+        try {
+          n.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+        } catch {
+        }
+      try {
+        n.setRequestHeader("Accept", "*/*");
+      } catch {
+      }
+      (e = this._opts.cookieJar) === null || e === void 0 || e.addCookies(n), "withCredentials" in n && (n.withCredentials = this._opts.withCredentials), this._opts.requestTimeout && (n.timeout = this._opts.requestTimeout), n.onreadystatechange = () => {
+        var r;
+        n.readyState === 3 && ((r = this._opts.cookieJar) === null || r === void 0 || r.parseCookies(
+          // @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 (r) {
+      this.setTimeoutFn(() => {
+        this._onError(r);
+      }, 0);
+      return;
+    }
+    typeof document < "u" && (this._index = D.requestsCount++, D.requests[this._index] = this);
+  }
+  /**
+   * Called upon error.
+   *
+   * @private
+   */
+  _onError(e) {
+    this.emitReserved("error", e, this._xhr), this._cleanup(!0);
+  }
+  /**
+   * Cleans up house.
+   *
+   * @private
+   */
+  _cleanup(e) {
+    if (!(typeof this._xhr > "u" || this._xhr === null)) {
+      if (this._xhr.onreadystatechange = cs, e)
+        try {
+          this._xhr.abort();
+        } catch {
+        }
+      typeof document < "u" && delete D.requests[this._index], this._xhr = null;
+    }
+  }
+  /**
+   * Called upon load.
+   *
+   * @private
+   */
+  _onLoad() {
+    const e = this._xhr.responseText;
+    e !== null && (this.emitReserved("data", e), this.emitReserved("success"), this._cleanup());
+  }
+  /**
+   * Aborts the request.
+   *
+   * @package
+   */
+  abort() {
+    this._cleanup();
+  }
+}
+D.requestsCount = 0;
+D.requests = {};
+if (typeof document < "u") {
+  if (typeof attachEvent == "function")
+    attachEvent("onunload", Ze);
+  else if (typeof addEventListener == "function") {
+    const s = "onpagehide" in L ? "pagehide" : "unload";
+    addEventListener(s, Ze, !1);
+  }
+}
+function Ze() {
+  for (let s in D.requests)
+    D.requests.hasOwnProperty(s) && D.requests[s].abort();
+}
+const us = (function() {
+  const s = yt({
+    xdomain: !1
+  });
+  return s && s.responseType !== null;
+})();
+class hs extends ls {
+  constructor(e) {
+    super(e);
+    const t = e && e.forceBase64;
+    this.supportsBinary = us && !t;
+  }
+  request(e = {}) {
+    return Object.assign(e, { xd: this.xd }, this.opts), new D(yt, this.uri(), e);
+  }
+}
+function yt(s) {
+  const e = s.xdomain;
+  try {
+    if (typeof XMLHttpRequest < "u" && (!e || as))
+      return new XMLHttpRequest();
+  } catch {
+  }
+  if (!e)
+    try {
+      return new L[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch {
+    }
+}
+const mt = typeof navigator < "u" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class fs extends Me {
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    const e = this.uri(), t = this.opts.protocols, n = mt ? {} : dt(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+    this.opts.extraHeaders && (n.headers = this.opts.extraHeaders);
+    try {
+      this.ws = this.createSocket(e, t, n);
+    } catch (r) {
+      return this.emitReserved("error", r);
+    }
+    this.ws.binaryType = this.socket.binaryType, this.addEventListeners();
+  }
+  /**
+   * Adds event listeners to the socket
+   *
+   * @private
+   */
+  addEventListeners() {
+    this.ws.onopen = () => {
+      this.opts.autoUnref && this.ws._socket.unref(), this.onOpen();
+    }, this.ws.onclose = (e) => this.onClose({
+      description: "websocket connection closed",
+      context: e
+    }), this.ws.onmessage = (e) => this.onData(e.data), this.ws.onerror = (e) => this.onError("websocket error", e);
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const n = e[t], r = t === e.length - 1;
+      Ve(n, this.supportsBinary, (i) => {
+        try {
+          this.doWrite(n, i);
+        } catch {
+        }
+        r && fe(() => {
+          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 e = this.opts.secure ? "wss" : "ws", t = this.query || {};
+    return this.opts.timestampRequests && (t[this.opts.timestampParam] = pt()), this.supportsBinary || (t.b64 = 1), this.createUri(e, t);
+  }
+}
+const we = L.WebSocket || L.MozWebSocket;
+class ds extends fs {
+  createSocket(e, t, n) {
+    return mt ? new we(e, t, n) : t ? new we(e, t) : new we(e);
+  }
+  doWrite(e, t) {
+    this.ws.send(t);
+  }
+}
+class ps extends Me {
+  get name() {
+    return "webtransport";
+  }
+  doOpen() {
+    try {
+      this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+    } catch (e) {
+      return this.emitReserved("error", e);
+    }
+    this._transport.closed.then(() => {
+      this.onClose();
+    }).catch((e) => {
+      this.onError("webtransport error", e);
+    }), this._transport.ready.then(() => {
+      this._transport.createBidirectionalStream().then((e) => {
+        const t = Xt(Number.MAX_SAFE_INTEGER, this.socket.binaryType), n = e.readable.pipeThrough(t).getReader(), r = Yt();
+        r.readable.pipeTo(e.writable), this._writer = r.writable.getWriter();
+        const i = () => {
+          n.read().then(({ done: l, value: h }) => {
+            l || (this.onPacket(h), i());
+          }).catch((l) => {
+          });
+        };
+        i();
+        const c = { type: "open" };
+        this.query.sid && (c.data = `{"sid":"${this.query.sid}"}`), this._writer.write(c).then(() => this.onOpen());
+      });
+    });
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const n = e[t], r = t === e.length - 1;
+      this._writer.write(n).then(() => {
+        r && fe(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    var e;
+    (e = this._transport) === null || e === void 0 || e.close();
+  }
+}
+const gs = {
+  websocket: ds,
+  webtransport: ps,
+  polling: hs
+}, ys = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, ms = [
+  "source",
+  "protocol",
+  "authority",
+  "userInfo",
+  "user",
+  "password",
+  "host",
+  "port",
+  "relative",
+  "path",
+  "directory",
+  "file",
+  "query",
+  "anchor"
+];
+function xe(s) {
+  if (s.length > 8e3)
+    throw "URI too long";
+  const e = s, t = s.indexOf("["), n = s.indexOf("]");
+  t != -1 && n != -1 && (s = s.substring(0, t) + s.substring(t, n).replace(/:/g, ";") + s.substring(n, s.length));
+  let r = ys.exec(s || ""), i = {}, c = 14;
+  for (; c--; )
+    i[ms[c]] = r[c] || "";
+  return t != -1 && n != -1 && (i.source = e, i.host = i.host.substring(1, i.host.length - 1).replace(/;/g, ":"), i.authority = i.authority.replace("[", "").replace("]", "").replace(/;/g, ":"), i.ipv6uri = !0), i.pathNames = vs(i, i.path), i.queryKey = _s(i, i.query), i;
+}
+function vs(s, e) {
+  const t = /\/{2,9}/g, n = e.replace(t, "/").split("/");
+  return (e.slice(0, 1) == "/" || e.length === 0) && n.splice(0, 1), e.slice(-1) == "/" && n.splice(n.length - 1, 1), n;
+}
+function _s(s, e) {
+  const t = {};
+  return e.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(n, r, i) {
+    r && (t[r] = i);
+  }), t;
+}
+const Re = typeof addEventListener == "function" && typeof removeEventListener == "function", ce = [];
+Re && addEventListener("offline", () => {
+  ce.forEach((s) => s());
+}, !1);
+class M extends E {
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(e, t) {
+    if (super(), this.binaryType = Jt, this.writeBuffer = [], this._prevBufferLen = 0, this._pingInterval = -1, this._pingTimeout = -1, this._maxPayload = -1, this._pingTimeoutTime = 1 / 0, e && typeof e == "object" && (t = e, e = null), e) {
+      const n = xe(e);
+      t.hostname = n.host, t.secure = n.protocol === "https" || n.protocol === "wss", t.port = n.port, n.query && (t.query = n.query);
+    } else t.host && (t.hostname = xe(t.host).host);
+    de(this, t), this.secure = t.secure != null ? t.secure : typeof location < "u" && location.protocol === "https:", t.hostname && !t.port && (t.port = this.secure ? "443" : "80"), this.hostname = t.hostname || (typeof location < "u" ? location.hostname : "localhost"), this.port = t.port || (typeof location < "u" && location.port ? location.port : this.secure ? "443" : "80"), this.transports = [], this._transportsByName = {}, t.transports.forEach((n) => {
+      const r = n.prototype.name;
+      this.transports.push(r), this._transportsByName[r] = n;
+    }), this.opts = Object.assign({
+      path: "/engine.io",
+      agent: !1,
+      withCredentials: !1,
+      upgrade: !0,
+      timestampParam: "t",
+      rememberUpgrade: !1,
+      addTrailingSlash: !0,
+      rejectUnauthorized: !0,
+      perMessageDeflate: {
+        threshold: 1024
+      },
+      transportOptions: {},
+      closeOnBeforeunload: !1
+    }, t), this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : ""), typeof this.opts.query == "string" && (this.opts.query = rs(this.opts.query)), Re && (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"
+      });
+    }, ce.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(e) {
+    const t = Object.assign({}, this.opts.query);
+    t.EIO = ft, t.transport = e, this.id && (t.sid = this.id);
+    const n = Object.assign({}, this.opts, {
+      query: t,
+      socket: this,
+      hostname: this.hostname,
+      secure: this.secure,
+      port: this.port
+    }, this.opts.transportOptions[e]);
+    return new this._transportsByName[e](n);
+  }
+  /**
+   * 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 e = this.opts.rememberUpgrade && M.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
+    this.readyState = "opening";
+    const t = this.createTransport(e);
+    t.open(), this.setTransport(t);
+  }
+  /**
+   * Sets the current transport. Disables the existing one (if any).
+   *
+   * @private
+   */
+  setTransport(e) {
+    this.transport && this.transport.removeAllListeners(), this.transport = e, e.on("drain", this._onDrain.bind(this)).on("packet", this._onPacket.bind(this)).on("error", this._onError.bind(this)).on("close", (t) => this._onClose("transport close", t));
+  }
+  /**
+   * Called when connection is deemed open.
+   *
+   * @private
+   */
+  onOpen() {
+    this.readyState = "open", M.priorWebsocketSuccess = this.transport.name === "websocket", this.emitReserved("open"), this.flush();
+  }
+  /**
+   * Handles a packet.
+   *
+   * @private
+   */
+  _onPacket(e) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing")
+      switch (this.emitReserved("packet", e), this.emitReserved("heartbeat"), e.type) {
+        case "open":
+          this.onHandshake(JSON.parse(e.data));
+          break;
+        case "ping":
+          this._sendPacket("pong"), this.emitReserved("ping"), this.emitReserved("pong"), this._resetPingTimeout();
+          break;
+        case "error":
+          const t = new Error("server error");
+          t.code = e.data, this._onError(t);
+          break;
+        case "message":
+          this.emitReserved("data", e.data), this.emitReserved("message", e.data);
+          break;
+      }
+  }
+  /**
+   * Called upon handshake completion.
+   *
+   * @param {Object} data - handshake obj
+   * @private
+   */
+  onHandshake(e) {
+    this.emitReserved("handshake", e), this.id = e.sid, this.transport.query.sid = e.sid, this._pingInterval = e.pingInterval, this._pingTimeout = e.pingTimeout, this._maxPayload = e.maxPayload, this.onOpen(), this.readyState !== "closed" && this._resetPingTimeout();
+  }
+  /**
+   * Sets and resets ping timeout timer based on server pings.
+   *
+   * @private
+   */
+  _resetPingTimeout() {
+    this.clearTimeoutFn(this._pingTimeoutTimer);
+    const e = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + e, this._pingTimeoutTimer = this.setTimeoutFn(() => {
+      this._onClose("ping timeout");
+    }, e), this.opts.autoUnref && this._pingTimeoutTimer.unref();
+  }
+  /**
+   * 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 e = this._getWritablePackets();
+      this.transport.send(e), this._prevBufferLen = e.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 n = 0; n < this.writeBuffer.length; n++) {
+      const r = this.writeBuffer[n].data;
+      if (r && (t += ts(r)), n > 0 && t > this._maxPayload)
+        return this.writeBuffer.slice(0, n);
+      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 e = Date.now() > this._pingTimeoutTime;
+    return e && (this._pingTimeoutTime = 0, fe(() => {
+      this._onClose("ping timeout");
+    }, this.setTimeoutFn)), e;
+  }
+  /**
+   * Sends a message.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
+  write(e, t, n) {
+    return this._sendPacket("message", e, t, 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(e, t, n) {
+    return this._sendPacket("message", e, t, n), this;
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type: packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  _sendPacket(e, t, n, r) {
+    if (typeof t == "function" && (r = t, t = void 0), typeof n == "function" && (r = n, n = null), this.readyState === "closing" || this.readyState === "closed")
+      return;
+    n = n || {}, n.compress = n.compress !== !1;
+    const i = {
+      type: e,
+      data: t,
+      options: n
+    };
+    this.emitReserved("packetCreate", i), this.writeBuffer.push(i), r && this.once("flush", r), this.flush();
+  }
+  /**
+   * Closes the connection.
+   */
+  close() {
+    const e = () => {
+      this._onClose("forced close"), this.transport.close();
+    }, t = () => {
+      this.off("upgrade", t), this.off("upgradeError", t), e();
+    }, n = () => {
+      this.once("upgrade", t), this.once("upgradeError", t);
+    };
+    return (this.readyState === "opening" || this.readyState === "open") && (this.readyState = "closing", this.writeBuffer.length ? this.once("drain", () => {
+      this.upgrading ? n() : e();
+    }) : this.upgrading ? n() : e()), this;
+  }
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  _onError(e) {
+    if (M.priorWebsocketSuccess = !1, this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening")
+      return this.transports.shift(), this._open();
+    this.emitReserved("error", e), this._onClose("transport error", e);
+  }
+  /**
+   * Called upon transport close.
+   *
+   * @private
+   */
+  _onClose(e, t) {
+    if (this.readyState === "opening" || this.readyState === "open" || this.readyState === "closing") {
+      if (this.clearTimeoutFn(this._pingTimeoutTimer), this.transport.removeAllListeners("close"), this.transport.close(), this.transport.removeAllListeners(), Re && (this._beforeunloadEventListener && removeEventListener("beforeunload", this._beforeunloadEventListener, !1), this._offlineEventListener)) {
+        const n = ce.indexOf(this._offlineEventListener);
+        n !== -1 && ce.splice(n, 1);
+      }
+      this.readyState = "closed", this.id = null, this.emitReserved("close", e, t), this.writeBuffer = [], this._prevBufferLen = 0;
+    }
+  }
+}
+M.protocol = ft;
+class ws extends M {
+  constructor() {
+    super(...arguments), this._upgrades = [];
+  }
+  onOpen() {
+    if (super.onOpen(), this.readyState === "open" && this.opts.upgrade)
+      for (let e = 0; e < this._upgrades.length; e++)
+        this._probe(this._upgrades[e]);
+  }
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  _probe(e) {
+    let t = this.createTransport(e), n = !1;
+    M.priorWebsocketSuccess = !1;
+    const r = () => {
+      n || (t.send([{ type: "ping", data: "probe" }]), t.once("packet", (g) => {
+        if (!n)
+          if (g.type === "pong" && g.data === "probe") {
+            if (this.upgrading = !0, this.emitReserved("upgrading", t), !t)
+              return;
+            M.priorWebsocketSuccess = t.name === "websocket", this.transport.pause(() => {
+              n || this.readyState !== "closed" && (p(), this.setTransport(t), t.send([{ type: "upgrade" }]), this.emitReserved("upgrade", t), t = null, this.upgrading = !1, this.flush());
+            });
+          } else {
+            const w = new Error("probe error");
+            w.transport = t.name, this.emitReserved("upgradeError", w);
+          }
+      }));
+    };
+    function i() {
+      n || (n = !0, p(), t.close(), t = null);
+    }
+    const c = (g) => {
+      const w = new Error("probe error: " + g);
+      w.transport = t.name, i(), this.emitReserved("upgradeError", w);
+    };
+    function l() {
+      c("transport closed");
+    }
+    function h() {
+      c("socket closed");
+    }
+    function f(g) {
+      t && g.name !== t.name && i();
+    }
+    const p = () => {
+      t.removeListener("open", r), t.removeListener("error", c), t.removeListener("close", l), this.off("close", h), this.off("upgrading", f);
+    };
+    t.once("open", r), t.once("error", c), t.once("close", l), this.once("close", h), this.once("upgrading", f), this._upgrades.indexOf("webtransport") !== -1 && e !== "webtransport" ? this.setTimeoutFn(() => {
+      n || t.open();
+    }, 200) : t.open();
+  }
+  onHandshake(e) {
+    this._upgrades = this._filterUpgrades(e.upgrades), super.onHandshake(e);
+  }
+  /**
+   * Filters upgrades, returning only those matching client transports.
+   *
+   * @param {Array} upgrades - server upgrades
+   * @private
+   */
+  _filterUpgrades(e) {
+    const t = [];
+    for (let n = 0; n < e.length; n++)
+      ~this.transports.indexOf(e[n]) && t.push(e[n]);
+    return t;
+  }
+}
+let bs = class extends ws {
+  constructor(e, t = {}) {
+    const n = typeof e == "object" ? e : t;
+    (!n.transports || n.transports && typeof n.transports[0] == "string") && (n.transports = (n.transports || ["polling", "websocket", "webtransport"]).map((r) => gs[r]).filter((r) => !!r)), super(e, n);
+  }
+};
+function Es(s, e = "", t) {
+  let n = s;
+  t = t || typeof location < "u" && location, s == null && (s = t.protocol + "//" + t.host), typeof s == "string" && (s.charAt(0) === "/" && (s.charAt(1) === "/" ? s = t.protocol + s : s = t.host + s), /^(https?|wss?):\/\//.test(s) || (typeof t < "u" ? s = t.protocol + "//" + s : s = "https://" + s), n = xe(s)), n.port || (/^(http|ws)$/.test(n.protocol) ? n.port = "80" : /^(http|ws)s$/.test(n.protocol) && (n.port = "443")), n.path = n.path || "/";
+  const i = n.host.indexOf(":") !== -1 ? "[" + n.host + "]" : n.host;
+  return n.id = n.protocol + "://" + i + ":" + n.port + e, n.href = n.protocol + "://" + i + (t && t.port === n.port ? "" : ":" + n.port), n;
+}
+const ks = typeof ArrayBuffer == "function", Ss = (s) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(s) : s.buffer instanceof ArrayBuffer, vt = Object.prototype.toString, Cs = typeof Blob == "function" || typeof Blob < "u" && vt.call(Blob) === "[object BlobConstructor]", Ns = typeof File == "function" || typeof File < "u" && vt.call(File) === "[object FileConstructor]";
+function qe(s) {
+  return ks && (s instanceof ArrayBuffer || Ss(s)) || Cs && s instanceof Blob || Ns && s instanceof File;
+}
+function le(s, e) {
+  if (!s || typeof s != "object")
+    return !1;
+  if (Array.isArray(s)) {
+    for (let t = 0, n = s.length; t < n; t++)
+      if (le(s[t]))
+        return !0;
+    return !1;
+  }
+  if (qe(s))
+    return !0;
+  if (s.toJSON && typeof s.toJSON == "function" && arguments.length === 1)
+    return le(s.toJSON(), !0);
+  for (const t in s)
+    if (Object.prototype.hasOwnProperty.call(s, t) && le(s[t]))
+      return !0;
+  return !1;
+}
+function Os(s) {
+  const e = [], t = s.data, n = s;
+  return n.data = Ae(t, e), n.attachments = e.length, { packet: n, buffers: e };
+}
+function Ae(s, e) {
+  if (!s)
+    return s;
+  if (qe(s)) {
+    const t = { _placeholder: !0, num: e.length };
+    return e.push(s), t;
+  } else if (Array.isArray(s)) {
+    const t = new Array(s.length);
+    for (let n = 0; n < s.length; n++)
+      t[n] = Ae(s[n], e);
+    return t;
+  } else if (typeof s == "object" && !(s instanceof Date)) {
+    const t = {};
+    for (const n in s)
+      Object.prototype.hasOwnProperty.call(s, n) && (t[n] = Ae(s[n], e));
+    return t;
+  }
+  return s;
+}
+function Ts(s, e) {
+  return s.data = Be(s.data, e), delete s.attachments, s;
+}
+function Be(s, e) {
+  if (!s)
+    return s;
+  if (s && s._placeholder === !0) {
+    if (typeof s.num == "number" && s.num >= 0 && s.num < e.length)
+      return e[s.num];
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(s))
+    for (let t = 0; t < s.length; t++)
+      s[t] = Be(s[t], e);
+  else if (typeof s == "object")
+    for (const t in s)
+      Object.prototype.hasOwnProperty.call(s, t) && (s[t] = Be(s[t], e));
+  return s;
+}
+const xs = [
+  "connect",
+  // used on the client side
+  "connect_error",
+  // used on the client side
+  "disconnect",
+  // used on both sides
+  "disconnecting",
+  // used on the server side
+  "newListener",
+  // used by the Node.js EventEmitter
+  "removeListener"
+  // used by the Node.js EventEmitter
+];
+var v;
+(function(s) {
+  s[s.CONNECT = 0] = "CONNECT", s[s.DISCONNECT = 1] = "DISCONNECT", s[s.EVENT = 2] = "EVENT", s[s.ACK = 3] = "ACK", s[s.CONNECT_ERROR = 4] = "CONNECT_ERROR", s[s.BINARY_EVENT = 5] = "BINARY_EVENT", s[s.BINARY_ACK = 6] = "BINARY_ACK";
+})(v || (v = {}));
+class Rs {
+  /**
+   * Encoder constructor
+   *
+   * @param {function} replacer - custom replacer to pass down to JSON.parse
+   */
+  constructor(e) {
+    this.replacer = e;
+  }
+  /**
+   * 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(e) {
+    return (e.type === v.EVENT || e.type === v.ACK) && le(e) ? this.encodeAsBinary({
+      type: e.type === v.EVENT ? v.BINARY_EVENT : v.BINARY_ACK,
+      nsp: e.nsp,
+      data: e.data,
+      id: e.id
+    }) : [this.encodeAsString(e)];
+  }
+  /**
+   * Encode packet as string.
+   */
+  encodeAsString(e) {
+    let t = "" + e.type;
+    return (e.type === v.BINARY_EVENT || e.type === v.BINARY_ACK) && (t += e.attachments + "-"), e.nsp && e.nsp !== "/" && (t += e.nsp + ","), e.id != null && (t += e.id), e.data != null && (t += JSON.stringify(e.data, this.replacer)), t;
+  }
+  /**
+   * Encode packet as 'buffer sequence' by removing blobs, and
+   * deconstructing packet into object with placeholders and
+   * a list of buffers.
+   */
+  encodeAsBinary(e) {
+    const t = Os(e), n = this.encodeAsString(t.packet), r = t.buffers;
+    return r.unshift(n), r;
+  }
+}
+class $e extends E {
+  /**
+   * Decoder constructor
+   *
+   * @param {function} reviver - custom reviver to pass down to JSON.stringify
+   */
+  constructor(e) {
+    super(), this.reviver = e;
+  }
+  /**
+   * Decodes an encoded packet string into packet JSON.
+   *
+   * @param {String} obj - encoded packet
+   */
+  add(e) {
+    let t;
+    if (typeof e == "string") {
+      if (this.reconstructor)
+        throw new Error("got plaintext data when reconstructing a packet");
+      t = this.decodeString(e);
+      const n = t.type === v.BINARY_EVENT;
+      n || t.type === v.BINARY_ACK ? (t.type = n ? v.EVENT : v.ACK, this.reconstructor = new As(t), t.attachments === 0 && super.emitReserved("decoded", t)) : super.emitReserved("decoded", t);
+    } else if (qe(e) || e.base64)
+      if (this.reconstructor)
+        t = this.reconstructor.takeBinaryData(e), t && (this.reconstructor = null, super.emitReserved("decoded", t));
+      else
+        throw new Error("got binary data when not reconstructing a packet");
+    else
+      throw new Error("Unknown type: " + e);
+  }
+  /**
+   * Decode a packet String (JSON data)
+   *
+   * @param {String} str
+   * @return {Object} packet
+   */
+  decodeString(e) {
+    let t = 0;
+    const n = {
+      type: Number(e.charAt(0))
+    };
+    if (v[n.type] === void 0)
+      throw new Error("unknown packet type " + n.type);
+    if (n.type === v.BINARY_EVENT || n.type === v.BINARY_ACK) {
+      const i = t + 1;
+      for (; e.charAt(++t) !== "-" && t != e.length; )
+        ;
+      const c = e.substring(i, t);
+      if (c != Number(c) || e.charAt(t) !== "-")
+        throw new Error("Illegal attachments");
+      n.attachments = Number(c);
+    }
+    if (e.charAt(t + 1) === "/") {
+      const i = t + 1;
+      for (; ++t && !(e.charAt(t) === "," || t === e.length); )
+        ;
+      n.nsp = e.substring(i, t);
+    } else
+      n.nsp = "/";
+    const r = e.charAt(t + 1);
+    if (r !== "" && Number(r) == r) {
+      const i = t + 1;
+      for (; ++t; ) {
+        const c = e.charAt(t);
+        if (c == null || Number(c) != c) {
+          --t;
+          break;
+        }
+        if (t === e.length)
+          break;
+      }
+      n.id = Number(e.substring(i, t + 1));
+    }
+    if (e.charAt(++t)) {
+      const i = this.tryParse(e.substr(t));
+      if ($e.isPayloadValid(n.type, i))
+        n.data = i;
+      else
+        throw new Error("invalid payload");
+    }
+    return n;
+  }
+  tryParse(e) {
+    try {
+      return JSON.parse(e, this.reviver);
+    } catch {
+      return !1;
+    }
+  }
+  static isPayloadValid(e, t) {
+    switch (e) {
+      case v.CONNECT:
+        return et(t);
+      case v.DISCONNECT:
+        return t === void 0;
+      case v.CONNECT_ERROR:
+        return typeof t == "string" || et(t);
+      case v.EVENT:
+      case v.BINARY_EVENT:
+        return Array.isArray(t) && (typeof t[0] == "number" || typeof t[0] == "string" && xs.indexOf(t[0]) === -1);
+      case v.ACK:
+      case v.BINARY_ACK:
+        return Array.isArray(t);
+    }
+  }
+  /**
+   * Deallocates a parser's resources
+   */
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class As {
+  constructor(e) {
+    this.packet = e, this.buffers = [], this.reconPack = e;
+  }
+  /**
+   * 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(e) {
+    if (this.buffers.push(e), this.buffers.length === this.reconPack.attachments) {
+      const t = Ts(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), t;
+    }
+    return null;
+  }
+  /**
+   * Cleans up binary packet reconstruction variables.
+   */
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+function et(s) {
+  return Object.prototype.toString.call(s) === "[object Object]";
+}
+const Bs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Decoder: $e,
+  Encoder: Rs,
+  get PacketType() {
+    return v;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+function P(s, e, t) {
+  return s.on(e, t), function() {
+    s.off(e, t);
+  };
+}
+const Ls = 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 _t extends E {
+  /**
+   * `Socket` constructor.
+   */
+  constructor(e, t, n) {
+    super(), this.connected = !1, this.recovered = !1, this.receiveBuffer = [], this.sendBuffer = [], this._queue = [], this._queueSeq = 0, this.ids = 0, this.acks = {}, this.flags = {}, this.io = e, this.nsp = t, n && n.auth && (this.auth = n.auth), this._opts = Object.assign({}, n), this.io._autoConnect && this.open();
+  }
+  /**
+   * 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 e = this.io;
+    this.subs = [
+      P(e, "open", this.onopen.bind(this)),
+      P(e, "packet", this.onpacket.bind(this)),
+      P(e, "error", this.onerror.bind(this)),
+      P(e, "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(...e) {
+    return e.unshift("message"), this.emit.apply(this, e), 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(e, ...t) {
+    var n, r, i;
+    if (Ls.hasOwnProperty(e))
+      throw new Error('"' + e.toString() + '" is a reserved event name');
+    if (t.unshift(e), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile)
+      return this._addToQueue(t), this;
+    const c = {
+      type: v.EVENT,
+      data: t
+    };
+    if (c.options = {}, c.options.compress = this.flags.compress !== !1, typeof t[t.length - 1] == "function") {
+      const p = this.ids++, g = t.pop();
+      this._registerAckCallback(p, g), c.id = p;
+    }
+    const l = (r = (n = this.io.engine) === null || n === void 0 ? void 0 : n.transport) === null || r === void 0 ? void 0 : r.writable, h = this.connected && !(!((i = this.io.engine) === null || i === void 0) && i._hasPingExpired());
+    return this.flags.volatile && !l || (h ? (this.notifyOutgoingListeners(c), this.packet(c)) : this.sendBuffer.push(c)), this.flags = {}, this;
+  }
+  /**
+   * @private
+   */
+  _registerAckCallback(e, t) {
+    var n;
+    const r = (n = this.flags.timeout) !== null && n !== void 0 ? n : this._opts.ackTimeout;
+    if (r === void 0) {
+      this.acks[e] = t;
+      return;
+    }
+    const i = this.io.setTimeoutFn(() => {
+      delete this.acks[e];
+      for (let l = 0; l < this.sendBuffer.length; l++)
+        this.sendBuffer[l].id === e && this.sendBuffer.splice(l, 1);
+      t.call(this, new Error("operation has timed out"));
+    }, r), c = (...l) => {
+      this.io.clearTimeoutFn(i), t.apply(this, l);
+    };
+    c.withError = !0, this.acks[e] = c;
+  }
+  /**
+   * 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(e, ...t) {
+    return new Promise((n, r) => {
+      const i = (c, l) => c ? r(c) : n(l);
+      i.withError = !0, t.push(i), this.emit(e, ...t);
+    });
+  }
+  /**
+   * Add the packet to the queue.
+   * @param args
+   * @private
+   */
+  _addToQueue(e) {
+    let t;
+    typeof e[e.length - 1] == "function" && (t = e.pop());
+    const n = {
+      id: this._queueSeq++,
+      tryCount: 0,
+      pending: !1,
+      args: e,
+      flags: Object.assign({ fromQueue: !0 }, this.flags)
+    };
+    e.push((r, ...i) => (this._queue[0], r !== null ? n.tryCount > this._opts.retries && (this._queue.shift(), t && t(r)) : (this._queue.shift(), t && t(null, ...i)), n.pending = !1, this._drainQueue())), this._queue.push(n), this._drainQueue();
+  }
+  /**
+   * 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(e = !1) {
+    if (!this.connected || this._queue.length === 0)
+      return;
+    const t = this._queue[0];
+    t.pending && !e || (t.pending = !0, t.tryCount++, this.flags = t.flags, this.emit.apply(this, t.args));
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param packet
+   * @private
+   */
+  packet(e) {
+    e.nsp = this.nsp, this.io._packet(e);
+  }
+  /**
+   * Called upon engine `open`.
+   *
+   * @private
+   */
+  onopen() {
+    typeof this.auth == "function" ? this.auth((e) => {
+      this._sendConnectPacket(e);
+    }) : this._sendConnectPacket(this.auth);
+  }
+  /**
+   * Sends a CONNECT packet to initiate the Socket.IO session.
+   *
+   * @param data
+   * @private
+   */
+  _sendConnectPacket(e) {
+    this.packet({
+      type: v.CONNECT,
+      data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, e) : e
+    });
+  }
+  /**
+   * Called upon engine or manager `error`.
+   *
+   * @param err
+   * @private
+   */
+  onerror(e) {
+    this.connected || this.emitReserved("connect_error", e);
+  }
+  /**
+   * Called upon engine `close`.
+   *
+   * @param reason
+   * @param description
+   * @private
+   */
+  onclose(e, t) {
+    this.connected = !1, delete this.id, this.emitReserved("disconnect", e, t), 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((e) => {
+      if (!this.sendBuffer.some((n) => String(n.id) === e)) {
+        const n = this.acks[e];
+        delete this.acks[e], n.withError && n.call(this, new Error("socket has been disconnected"));
+      }
+    });
+  }
+  /**
+   * Called with socket packet.
+   *
+   * @param packet
+   * @private
+   */
+  onpacket(e) {
+    if (e.nsp === this.nsp)
+      switch (e.type) {
+        case v.CONNECT:
+          e.data && e.data.sid ? this.onconnect(e.data.sid, e.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          break;
+        case v.EVENT:
+        case v.BINARY_EVENT:
+          this.onevent(e);
+          break;
+        case v.ACK:
+        case v.BINARY_ACK:
+          this.onack(e);
+          break;
+        case v.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case v.CONNECT_ERROR:
+          this.destroy();
+          const n = new Error(e.data.message);
+          n.data = e.data.data, this.emitReserved("connect_error", n);
+          break;
+      }
+  }
+  /**
+   * Called upon a server event.
+   *
+   * @param packet
+   * @private
+   */
+  onevent(e) {
+    const t = e.data || [];
+    e.id != null && t.push(this.ack(e.id)), this.connected ? this.emitEvent(t) : this.receiveBuffer.push(Object.freeze(t));
+  }
+  emitEvent(e) {
+    if (this._anyListeners && this._anyListeners.length) {
+      const t = this._anyListeners.slice();
+      for (const n of t)
+        n.apply(this, e);
+    }
+    super.emit.apply(this, e), this._pid && e.length && typeof e[e.length - 1] == "string" && (this._lastOffset = e[e.length - 1]);
+  }
+  /**
+   * Produces an ack callback to emit with an event.
+   *
+   * @private
+   */
+  ack(e) {
+    const t = this;
+    let n = !1;
+    return function(...r) {
+      n || (n = !0, t.packet({
+        type: v.ACK,
+        id: e,
+        data: r
+      }));
+    };
+  }
+  /**
+   * Called upon a server acknowledgement.
+   *
+   * @param packet
+   * @private
+   */
+  onack(e) {
+    const t = this.acks[e.id];
+    typeof t == "function" && (delete this.acks[e.id], t.withError && e.data.unshift(null), t.apply(this, e.data));
+  }
+  /**
+   * Called upon server connect.
+   *
+   * @private
+   */
+  onconnect(e, t) {
+    this.id = e, this.recovered = t && this._pid === t, this._pid = t, this.connected = !0, this.emitBuffered(), this._drainQueue(!0), this.emitReserved("connect");
+  }
+  /**
+   * Emit buffered events (received and emitted).
+   *
+   * @private
+   */
+  emitBuffered() {
+    this.receiveBuffer.forEach((e) => this.emitEvent(e)), this.receiveBuffer = [], this.sendBuffer.forEach((e) => {
+      this.notifyOutgoingListeners(e), this.packet(e);
+    }), 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((e) => e()), 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: v.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(e) {
+    return this.flags.compress = e, 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(e) {
+    return this.flags.timeout = e, 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(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.push(e), 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(e) {
+    return this._anyListeners = this._anyListeners || [], this._anyListeners.unshift(e), 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(e) {
+    if (!this._anyListeners)
+      return this;
+    if (e) {
+      const t = this._anyListeners;
+      for (let n = 0; n < t.length; n++)
+        if (e === t[n])
+          return t.splice(n, 1), this;
+    } else
+      this._anyListeners = [];
+    return this;
+  }
+  /**
+   * 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(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.push(e), 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(e) {
+    return this._anyOutgoingListeners = this._anyOutgoingListeners || [], this._anyOutgoingListeners.unshift(e), 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(e) {
+    if (!this._anyOutgoingListeners)
+      return this;
+    if (e) {
+      const t = this._anyOutgoingListeners;
+      for (let n = 0; n < t.length; n++)
+        if (e === t[n])
+          return t.splice(n, 1), this;
+    } else
+      this._anyOutgoingListeners = [];
+    return this;
+  }
+  /**
+   * 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(e) {
+    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+      const t = this._anyOutgoingListeners.slice();
+      for (const n of t)
+        n.apply(this, e.data);
+    }
+  }
+}
+function W(s) {
+  s = s || {}, this.ms = s.min || 100, this.max = s.max || 1e4, this.factor = s.factor || 2, this.jitter = s.jitter > 0 && s.jitter <= 1 ? s.jitter : 0, this.attempts = 0;
+}
+W.prototype.duration = function() {
+  var s = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var e = Math.random(), t = Math.floor(e * this.jitter * s);
+    s = (Math.floor(e * 10) & 1) == 0 ? s - t : s + t;
+  }
+  return Math.min(s, this.max) | 0;
+};
+W.prototype.reset = function() {
+  this.attempts = 0;
+};
+W.prototype.setMin = function(s) {
+  this.ms = s;
+};
+W.prototype.setMax = function(s) {
+  this.max = s;
+};
+W.prototype.setJitter = function(s) {
+  this.jitter = s;
+};
+class Le extends E {
+  constructor(e, t) {
+    var n;
+    super(), this.nsps = {}, this.subs = [], e && typeof e == "object" && (t = e, e = void 0), t = t || {}, t.path = t.path || "/socket.io", this.opts = t, de(this, t), this.reconnection(t.reconnection !== !1), this.reconnectionAttempts(t.reconnectionAttempts || 1 / 0), this.reconnectionDelay(t.reconnectionDelay || 1e3), this.reconnectionDelayMax(t.reconnectionDelayMax || 5e3), this.randomizationFactor((n = t.randomizationFactor) !== null && n !== void 0 ? n : 0.5), this.backoff = new W({
+      min: this.reconnectionDelay(),
+      max: this.reconnectionDelayMax(),
+      jitter: this.randomizationFactor()
+    }), this.timeout(t.timeout == null ? 2e4 : t.timeout), this._readyState = "closed", this.uri = e;
+    const r = t.parser || Bs;
+    this.encoder = new r.Encoder(), this.decoder = new r.Decoder(), this._autoConnect = t.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(e) {
+    return arguments.length ? (this._reconnection = !!e, e || (this.skipReconnect = !0), this) : this._reconnection;
+  }
+  reconnectionAttempts(e) {
+    return e === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = e, this);
+  }
+  reconnectionDelay(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = e, (t = this.backoff) === null || t === void 0 || t.setMin(e), this);
+  }
+  randomizationFactor(e) {
+    var t;
+    return e === void 0 ? this._randomizationFactor : (this._randomizationFactor = e, (t = this.backoff) === null || t === void 0 || t.setJitter(e), this);
+  }
+  reconnectionDelayMax(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = e, (t = this.backoff) === null || t === void 0 || t.setMax(e), this);
+  }
+  timeout(e) {
+    return arguments.length ? (this._timeout = e, this) : this._timeout;
+  }
+  /**
+   * 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(e) {
+    if (~this._readyState.indexOf("open"))
+      return this;
+    this.engine = new bs(this.uri, this.opts);
+    const t = this.engine, n = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const r = P(t, "open", function() {
+      n.onopen(), e && e();
+    }), i = (l) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", l), e ? e(l) : this.maybeReconnectOnOpen();
+    }, c = P(t, "error", i);
+    if (this._timeout !== !1) {
+      const l = this._timeout, h = this.setTimeoutFn(() => {
+        r(), i(new Error("timeout")), t.close();
+      }, l);
+      this.opts.autoUnref && h.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(h);
+      });
+    }
+    return this.subs.push(r), this.subs.push(c), this;
+  }
+  /**
+   * Alias for open()
+   *
+   * @return self
+   * @public
+   */
+  connect(e) {
+    return this.open(e);
+  }
+  /**
+   * Called upon transport open.
+   *
+   * @private
+   */
+  onopen() {
+    this.cleanup(), this._readyState = "open", this.emitReserved("open");
+    const e = this.engine;
+    this.subs.push(
+      P(e, "ping", this.onping.bind(this)),
+      P(e, "data", this.ondata.bind(this)),
+      P(e, "error", this.onerror.bind(this)),
+      P(e, "close", this.onclose.bind(this)),
+      // @ts-ignore
+      P(this.decoder, "decoded", this.ondecoded.bind(this))
+    );
+  }
+  /**
+   * Called upon a ping.
+   *
+   * @private
+   */
+  onping() {
+    this.emitReserved("ping");
+  }
+  /**
+   * Called with data.
+   *
+   * @private
+   */
+  ondata(e) {
+    try {
+      this.decoder.add(e);
+    } catch (t) {
+      this.onclose("parse error", t);
+    }
+  }
+  /**
+   * Called when parser fully decodes a packet.
+   *
+   * @private
+   */
+  ondecoded(e) {
+    fe(() => {
+      this.emitReserved("packet", e);
+    }, this.setTimeoutFn);
+  }
+  /**
+   * Called upon socket error.
+   *
+   * @private
+   */
+  onerror(e) {
+    this.emitReserved("error", e);
+  }
+  /**
+   * Creates a new socket for the given `nsp`.
+   *
+   * @return {Socket}
+   * @public
+   */
+  socket(e, t) {
+    let n = this.nsps[e];
+    return n ? this._autoConnect && !n.active && n.connect() : (n = new _t(this, e, t), this.nsps[e] = n), n;
+  }
+  /**
+   * Called upon a socket close.
+   *
+   * @param socket
+   * @private
+   */
+  _destroy(e) {
+    const t = Object.keys(this.nsps);
+    for (const n of t)
+      if (this.nsps[n].active)
+        return;
+    this._close();
+  }
+  /**
+   * Writes a packet.
+   *
+   * @param packet
+   * @private
+   */
+  _packet(e) {
+    const t = this.encoder.encode(e);
+    for (let n = 0; n < t.length; n++)
+      this.engine.write(t[n], e.options);
+  }
+  /**
+   * Clean up transport subscriptions and packet buffer.
+   *
+   * @private
+   */
+  cleanup() {
+    this.subs.forEach((e) => e()), 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(e, t) {
+    var n;
+    this.cleanup(), (n = this.engine) === null || n === void 0 || n.close(), this.backoff.reset(), this._readyState = "closed", this.emitReserved("close", e, t), this._reconnection && !this.skipReconnect && this.reconnect();
+  }
+  /**
+   * Attempt a reconnection.
+   *
+   * @private
+   */
+  reconnect() {
+    if (this._reconnecting || this.skipReconnect)
+      return this;
+    const e = this;
+    if (this.backoff.attempts >= this._reconnectionAttempts)
+      this.backoff.reset(), this.emitReserved("reconnect_failed"), this._reconnecting = !1;
+    else {
+      const t = this.backoff.duration();
+      this._reconnecting = !0;
+      const n = this.setTimeoutFn(() => {
+        e.skipReconnect || (this.emitReserved("reconnect_attempt", e.backoff.attempts), !e.skipReconnect && e.open((r) => {
+          r ? (e._reconnecting = !1, e.reconnect(), this.emitReserved("reconnect_error", r)) : e.onreconnect();
+        }));
+      }, t);
+      this.opts.autoUnref && n.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(n);
+      });
+    }
+  }
+  /**
+   * Called upon successful reconnect.
+   *
+   * @private
+   */
+  onreconnect() {
+    const e = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", e);
+  }
+}
+const G = {};
+function ue(s, e) {
+  typeof s == "object" && (e = s, s = void 0), e = e || {};
+  const t = Es(s, e.path || "/socket.io"), n = t.source, r = t.id, i = t.path, c = G[r] && i in G[r].nsps, l = e.forceNew || e["force new connection"] || e.multiplex === !1 || c;
+  let h;
+  return l ? h = new Le(n, e) : (G[r] || (G[r] = new Le(n, e)), h = G[r]), t.query && !e.query && (e.query = t.queryKey), h.socket(t.path, e);
+}
+Object.assign(ue, {
+  Manager: Le,
+  Socket: _t,
+  io: ue,
+  connect: ue
+});
+const wt = /* @__PURE__ */ $t("gigSupportChat", () => {
+  const s = b(null), e = b([]), t = b(!1), n = b(!1), r = b(0), i = b(""), c = b([]), l = b(!1), h = b(null), f = b(null), p = (k) => {
+    f.value = k;
+  }, g = () => {
+    var k;
+    (k = s.value) != null && k.connected || !f.value || (s.value = ue(f.value.apiUrl, {
+      path: f.value.path || "/ws",
+      transports: ["websocket", "polling"],
+      auth: {
+        apiKey: f.value.apiKey,
+        uuid: f.value.uuid,
+        metaUser: f.value.metaUser
+      }
+    }), s.value.on("connect", () => {
+      console.log("[GigSupportChat] Connected"), t.value = !0;
+    }), s.value.on("connected", (_) => {
+      console.log("[GigSupportChat] Registered as:", _.userId), i.value = _.userId, x();
+    }), s.value.on("disconnect", () => {
+      console.log("[GigSupportChat] Disconnected"), t.value = !1;
+    }), s.value.on("new_message", (_) => {
+      _.status === "SUCCESS" && (e.value.find((S) => S.id === _.message.id) || (e.value.push(_.message), n.value || r.value++));
+    }), s.value.on("message_sent", (_) => {
+      _.status === "SUCCESS" && (e.value.find((S) => S.id === _.message.id) || e.value.push(_.message));
+    }), s.value.on("history", (_) => {
+      _.status === "SUCCESS" && (e.value = _.messages);
+    }), s.value.on("error", (_) => {
+      console.error("[GigSupportChat] Socket error:", _);
+    }));
+  }, w = () => {
+    s.value && (s.value.disconnect(), s.value = null), t.value = !1, e.value = [], r.value = 0, i.value = "";
+  }, T = (k) => {
+    var _, S;
+    !s.value || !t.value || (s.value.emit("send_message", {
+      userId: i.value,
+      text: k,
+      replyToMessageId: (_ = h.value) == null ? void 0 : _.id,
+      metaUser: (S = f.value) == null ? void 0 : S.metaUser
+    }), h.value = null);
+  }, x = () => {
+    !s.value || !i.value || s.value.emit("get_history", {
+      userId: i.value,
+      limit: 50,
+      offset: 0
+    });
+  };
+  return {
+    messages: e,
+    isConnected: t,
+    isWidgetOpen: n,
+    unreadCount: r,
+    currentUserId: i,
+    stickers: c,
+    isLoadingStickers: l,
+    replyingToMessage: h,
+    init: p,
+    connect: g,
+    disconnect: w,
+    sendMessage: T,
+    sendSticker: (k) => {
+      var _, S;
+      !s.value || !t.value || (s.value.emit("send_message", {
+        userId: i.value,
+        stickerId: k,
+        messageType: "sticker",
+        replyToMessageId: (_ = h.value) == null ? void 0 : _.id,
+        metaUser: (S = f.value) == null ? void 0 : S.metaUser
+      }), h.value = null);
+    },
+    fetchStickers: async () => {
+      var k;
+      if ((k = f.value) != null && k.apiUrl) {
+        l.value = !0;
+        try {
+          const S = await (await fetch(`${f.value.apiUrl}/api/v1.0/stickers?activeOnly=true`, {
+            headers: {
+              "x-api-key": f.value.apiKey || ""
+            }
+          })).json();
+          S.status === "SUCCESS" && (c.value = S.content);
+        } catch (_) {
+          console.error("[GigSupportChat] Error fetching stickers:", _);
+        } finally {
+          l.value = !1;
+        }
+      }
+    },
+    toggleWidget: () => {
+      n.value = !n.value, n.value && (r.value = 0);
+    },
+    loadHistory: x,
+    startReply: (k) => {
+      h.value = k;
+    },
+    cancelReply: () => {
+      h.value = null;
+    }
+  };
+}), Ps = ["data-message-id"], Ds = {
+  key: 0,
+  class: "gig-message-author"
+}, Is = { class: "gig-author-name" }, Vs = { class: "gig-reply-author" }, Us = { class: "gig-reply-text" }, Ms = ["src", "alt"], qs = ["innerHTML"], $s = { class: "gig-message-meta" }, Fs = { class: "gig-message-time" }, Hs = /* @__PURE__ */ Ie({
+  __name: "ChatMessage",
+  props: {
+    message: {},
+    currentUserId: {}
+  },
+  emits: ["reply", "scroll-to"],
+  setup(s) {
+    const e = s, t = De(() => e.message.userId === e.currentUserId), n = (c) => new Date(c).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }), r = (c) => {
+      if (!c || c === "GIGMARKET Support") return c;
+      const l = c.trim().split(/\s+/);
+      return l.length >= 2 && l[1] ? `${l[0]} ${l[1][0]}.` : c;
+    }, i = (c) => {
+      if (!c) return "";
+      const h = ((p) => p.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;"))(c), f = /(https?:\/\/[^\s<]+[^\s<.,;:!?'")\]}>])/gi;
+      return h.replace(f, (p) => `<a href="${p.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'")}" target="_blank" rel="noopener noreferrer">${p}</a>`);
+    };
+    return (c, l) => (C(), O("div", {
+      class: Ee(["gig-message-wrapper", t.value ? "sent" : "received"]),
+      "data-message-id": s.message.id
+    }, [
+      t.value ? U("", !0) : (C(), O("div", Ds, [
+        l[2] || (l[2] = u("div", { class: "gig-author-avatar" }, "GP", -1)),
+        u("span", Is, V(r(s.message.userName || "Support")), 1)
+      ])),
+      u("div", {
+        class: Ee(["gig-message-bubble", s.message.messageType === "sticker" ? "is-sticker" : ""])
+      }, [
+        s.message.replyToMessage ? (C(), O("div", {
+          key: 0,
+          class: "gig-reply-preview",
+          onClick: l[0] || (l[0] = (h) => c.$emit("scroll-to", s.message.replyToMessageId))
+        }, [
+          u("div", Vs, V(s.message.replyToMessage.userId === s.currentUserId ? "Вы" : r(s.message.replyToMessage.userName || "Support")), 1),
+          u("div", Us, V(s.message.replyToMessage.messageType === "sticker" ? "[Стикер]" : s.message.replyToMessage.text), 1)
+        ])) : U("", !0),
+        s.message.messageType === "sticker" && s.message.sticker ? (C(), O("img", {
+          key: 1,
+          src: `data:${s.message.sticker.mimeType || "image/png"};base64,${s.message.sticker.base64}`,
+          class: "gig-sticker-img",
+          alt: s.message.sticker.name
+        }, null, 8, Ms)) : (C(), O("div", {
+          key: 2,
+          class: "gig-message-text",
+          innerHTML: i(s.message.text || "")
+        }, null, 8, qs)),
+        u("div", $s, [
+          u("span", Fs, V(n(s.message.createdAt)), 1)
+        ]),
+        u("button", {
+          class: "gig-message-reply-btn",
+          onClick: l[1] || (l[1] = (h) => c.$emit("reply", s.message))
+        }, [...l[3] || (l[3] = [
+          u("svg", {
+            viewBox: "0 0 24 24",
+            width: "14",
+            height: "14",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2"
+          }, [
+            u("polyline", { points: "9 17 4 12 9 7" }),
+            u("path", { d: "M20 18v-2a4 4 0 0 0-4-4H4" })
+          ], -1)
+        ])])
+      ], 2)
+    ], 10, Ps));
+  }
+}), bt = (s, e) => {
+  const t = s.__vccOpts || s;
+  for (const [n, r] of e)
+    t[n] = r;
+  return t;
+}, Ws = /* @__PURE__ */ bt(Hs, [["__scopeId", "data-v-0f2196d9"]]), zs = { class: "gig-header-info" }, js = { class: "gig-status-area" }, Ks = { class: "gig-status-text" }, Ys = {
+  key: 0,
+  class: "gig-empty-state"
+}, Xs = {
+  key: 0,
+  class: "gig-sticker-picker"
+}, Gs = { class: "gig-picker-header" }, Js = { class: "gig-sticker-grid" }, Qs = {
+  key: 0,
+  class: "gig-loading"
+}, Zs = ["onClick"], en = ["src", "alt"], tn = {
+  key: 0,
+  class: "gig-reply-bar"
+}, sn = { class: "gig-reply-content" }, nn = { class: "gig-reply-title" }, rn = { class: "gig-reply-preview" }, on = { class: "gig-chat-input-area" }, an = { class: "gig-input-wrapper" }, cn = ["onKeydown"], ln = ["disabled"], un = /* @__PURE__ */ Ie({
+  __name: "ChatWindow",
+  props: {
+    messages: {},
+    isConnected: { type: Boolean },
+    currentUserId: {}
+  },
+  emits: ["close"],
+  setup(s, { emit: e }) {
+    const t = s, n = wt(), r = b(""), i = b(null), c = b({ x: 30, y: 110 }), l = b({ width: 440, height: 600 }), h = b(!1), f = b(null), p = b({ x: 0, y: 0, w: 0, h: 0 }), g = b(!1), w = () => {
+      g.value = !g.value, g.value && n.stickers.length === 0 && n.fetchStickers();
+    }, T = (y) => {
+      n.sendSticker(y), g.value = !1, q();
+    }, x = () => {
+      r.value.trim() && (n.sendMessage(r.value), r.value = "", q());
+    }, F = (y) => y.userId === t.currentUserId ? "вам" : j(y.userName || "Support"), z = (y) => y.messageType === "sticker" ? "[Стикер]" : y.text || "", j = (y) => y.trim().split(/\s+/)[0], q = async () => {
+      await be(), i.value && (i.value.scrollTop = i.value.scrollHeight);
+    }, ne = (y) => {
+      var a;
+      const o = (a = i.value) == null ? void 0 : a.querySelector(`[data-message-id="${y}"]`);
+      o && (o.scrollIntoView({ behavior: "smooth", block: "center" }), o.classList.add("gig-highlight"), setTimeout(() => o.classList.remove("gig-highlight"), 2e3));
+    }, k = (y) => {
+      y.target.closest("button") || (h.value = !0, p.value = { x: y.clientX + c.value.x, y: y.clientY + c.value.y, w: 0, h: 0 }, window.addEventListener("mousemove", _), window.addEventListener("mouseup", K));
+    }, _ = (y) => {
+      h.value && (c.value = { x: p.value.x - y.clientX, y: p.value.y - y.clientY });
+    }, S = (y, o) => {
+      y.preventDefault(), f.value = o, p.value = { x: y.clientX, y: y.clientY, w: l.value.width, h: l.value.height }, window.addEventListener("mousemove", d), window.addEventListener("mouseup", K);
+    }, d = (y) => {
+      if (!f.value) return;
+      const o = p.value.x - y.clientX, a = p.value.y - y.clientY;
+      if (f.value === "left" || f.value === "corner") {
+        const m = p.value.w + o;
+        m > 320 && m < 800 && (l.value.width = m);
+      }
+      if (f.value === "top" || f.value === "corner") {
+        const m = p.value.h + a;
+        m > 400 && m < 900 && (l.value.height = m);
+      }
+    }, K = () => {
+      h.value = !1, f.value = null, window.removeEventListener("mousemove", _), window.removeEventListener("mousemove", d), window.removeEventListener("mouseup", K);
+    };
+    return tt(() => t.messages.length, q), st(q), nt(K), (y, o) => (C(), O("div", {
+      class: "gig-chat-window",
+      style: Bt({
+        width: l.value.width + "px",
+        height: l.value.height + "px",
+        bottom: c.value.y + "px",
+        right: c.value.x + "px",
+        cursor: h.value ? "grabbing" : "auto"
+      })
+    }, [
+      u("div", {
+        class: "gig-resize-h gig-resize-left",
+        onMousedown: o[0] || (o[0] = (a) => S(a, "left"))
+      }, null, 32),
+      u("div", {
+        class: "gig-resize-h gig-resize-top",
+        onMousedown: o[1] || (o[1] = (a) => S(a, "top"))
+      }, null, 32),
+      u("div", {
+        class: "gig-resize-corner",
+        onMousedown: o[2] || (o[2] = (a) => S(a, "corner"))
+      }, null, 32),
+      u("div", {
+        class: "gig-chat-header",
+        onMousedown: k
+      }, [
+        o[13] || (o[13] = u("div", { class: "gig-header-brand-overlay" }, null, -1)),
+        u("div", zs, [
+          o[11] || (o[11] = u("div", { class: "gig-header-avatar" }, [
+            u("svg", {
+              viewBox: "0 0 24 24",
+              width: "20",
+              height: "20",
+              fill: "none",
+              stroke: "currentColor",
+              "stroke-width": "2"
+            }, [
+              u("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" })
+            ])
+          ], -1)),
+          u("div", null, [
+            o[10] || (o[10] = u("h3", null, "Поддержка", -1)),
+            u("div", js, [
+              o[9] || (o[9] = u("span", { class: "gig-status-pulse" }, null, -1)),
+              u("span", Ks, V(s.isConnected ? "В сети" : "Подключение..."), 1)
+            ])
+          ])
+        ]),
+        u("button", {
+          onClick: o[3] || (o[3] = He((a) => y.$emit("close"), ["stop"])),
+          class: "gig-close-btn"
+        }, [...o[12] || (o[12] = [
+          u("svg", {
+            viewBox: "0 0 24 24",
+            width: "20",
+            height: "20",
+            fill: "none",
+            stroke: "currentColor",
+            "stroke-width": "2"
+          }, [
+            u("line", {
+              x1: "18",
+              y1: "6",
+              x2: "6",
+              y2: "18"
+            }),
+            u("line", {
+              x1: "6",
+              y1: "6",
+              x2: "18",
+              y2: "18"
+            })
+          ], -1)
+        ])])
+      ], 32),
+      u("div", {
+        class: "gig-messages-container",
+        ref_key: "messagesContainer",
+        ref: i
+      }, [
+        s.messages.length === 0 ? (C(), O("div", Ys, [...o[14] || (o[14] = [
+          u("div", { class: "gig-empty-icon" }, [
+            u("svg", {
+              viewBox: "0 0 24 24",
+              width: "40",
+              height: "40",
+              fill: "none",
+              stroke: "currentColor",
+              "stroke-width": "1.5"
+            }, [
+              u("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" })
+            ])
+          ], -1),
+          u("p", null, "Чем мы можем вам помочь?", -1)
+        ])])) : U("", !0),
+        (C(!0), O(We, null, ze(s.messages, (a) => (C(), rt(Ws, {
+          key: a.id,
+          message: a,
+          "current-user-id": s.currentUserId,
+          onReply: o[4] || (o[4] = (m) => N(n).startReply(m)),
+          onScrollTo: ne
+        }, null, 8, ["message", "current-user-id"]))), 128))
+      ], 512),
+      ke(Se, { name: "gig-slide-up" }, {
+        default: Ce(() => [
+          g.value ? (C(), O("div", Xs, [
+            u("div", Gs, [
+              o[15] || (o[15] = u("span", null, "Выберите стикер", -1)),
+              u("button", {
+                onClick: o[5] || (o[5] = (a) => g.value = !1),
+                class: "gig-picker-close"
+              }, "×")
+            ]),
+            u("div", Js, [
+              N(n).isLoadingStickers ? (C(), O("div", Qs, "...")) : U("", !0),
+              (C(!0), O(We, null, ze(N(n).stickers, (a) => (C(), O("div", {
+                key: a.id,
+                class: "gig-sticker-item",
+                onClick: (m) => T(a.id)
+              }, [
+                u("img", {
+                  src: `data:${a.mimeType || "image/png"};base64,${a.base64}`,
+                  alt: a.name
+                }, null, 8, en)
+              ], 8, Zs))), 128))
+            ])
+          ])) : U("", !0)
+        ]),
+        _: 1
+      }),
+      ke(Se, { name: "gig-fade" }, {
+        default: Ce(() => [
+          N(n).replyingToMessage ? (C(), O("div", tn, [
+            o[16] || (o[16] = u("div", { class: "gig-reply-line" }, null, -1)),
+            u("div", sn, [
+              u("div", nn, "Ответ " + V(F(N(n).replyingToMessage)), 1),
+              u("div", rn, V(z(N(n).replyingToMessage)), 1)
+            ]),
+            u("button", {
+              onClick: o[6] || (o[6] = (a) => N(n).cancelReply()),
+              class: "gig-reply-close"
+            }, "×")
+          ])) : U("", !0)
+        ]),
+        _: 1
+      }),
+      u("div", on, [
+        u("div", an, [
+          u("button", {
+            class: Ee(["gig-sticker-toggle", { active: g.value }]),
+            onClick: w
+          }, [...o[17] || (o[17] = [
+            Lt('<svg viewBox="0 0 24 24" width="20" height="20" fill="none" stroke="currentColor" stroke-width="2" data-v-4a6ac4c2><circle cx="12" cy="12" r="10" data-v-4a6ac4c2></circle><path d="M8 14s1.5 2 4 2 4-2 4-2" data-v-4a6ac4c2></path><line x1="9" y1="9" x2="9.01" y2="9" data-v-4a6ac4c2></line><line x1="15" y1="9" x2="15.01" y2="9" data-v-4a6ac4c2></line></svg>', 1)
+          ])], 2),
+          Pt(u("textarea", {
+            "onUpdate:modelValue": o[7] || (o[7] = (a) => r.value = a),
+            onKeydown: Dt(He(x, ["exact", "prevent"]), ["enter"]),
+            placeholder: "Введите сообщение...",
+            class: "gig-chat-input",
+            rows: "1",
+            onFocus: o[8] || (o[8] = (a) => g.value = !1)
+          }, null, 40, cn), [
+            [It, r.value]
+          ]),
+          u("button", {
+            onClick: x,
+            class: "gig-send-btn",
+            disabled: !r.value.trim()
+          }, [...o[18] || (o[18] = [
+            u("svg", {
+              viewBox: "0 0 24 24",
+              width: "20",
+              height: "20",
+              fill: "none",
+              stroke: "currentColor",
+              "stroke-width": "2"
+            }, [
+              u("line", {
+                x1: "22",
+                y1: "2",
+                x2: "11",
+                y2: "13"
+              }),
+              u("polygon", { points: "22 2 15 22 11 13 2 9 22 2" })
+            ], -1)
+          ])], 8, ln)
+        ]),
+        o[19] || (o[19] = u("div", { class: "gig-powered-by" }, [
+          u("span", null, "Powered by GIGMARKET")
+        ], -1))
+      ])
+    ], 4));
+  }
+}), hn = /* @__PURE__ */ bt(un, [["__scopeId", "data-v-4a6ac4c2"]]), fn = { class: "gig-chat-wrapper" }, dn = {
+  key: 0,
+  class: "gig-chat-badge"
+}, pn = {
+  key: 1,
+  viewBox: "0 0 24 24",
+  width: "32",
+  height: "32",
+  fill: "none",
+  stroke: "white",
+  "stroke-width": "2"
+}, gn = {
+  key: 2,
+  viewBox: "0 0 24 24",
+  width: "32",
+  height: "32",
+  fill: "none",
+  stroke: "white",
+  "stroke-width": "2"
+}, yn = /* @__PURE__ */ Ie({
+  __name: "GigSupportChat",
+  props: {
+    config: {}
+  },
+  setup(s) {
+    const e = s, t = wt();
+    return st(() => {
+      t.init(e.config), t.connect();
+    }), nt(() => {
+      t.disconnect();
+    }), (n, r) => (C(), O("div", fn, [
+      ke(Se, { name: "gig-fade" }, {
+        default: Ce(() => [
+          N(t).isWidgetOpen ? (C(), rt(hn, {
+            key: 0,
+            messages: N(t).messages,
+            "is-connected": N(t).isConnected,
+            "current-user-id": N(t).currentUserId,
+            onSend: r[0] || (r[0] = (i) => N(t).sendMessage(i)),
+            onClose: r[1] || (r[1] = (i) => N(t).toggleWidget())
+          }, null, 8, ["messages", "is-connected", "current-user-id"])) : U("", !0)
+        ]),
+        _: 1
+      }),
+      u("button", {
+        class: "gig-chat-trigger",
+        onClick: r[2] || (r[2] = (i) => N(t).toggleWidget())
+      }, [
+        N(t).unreadCount > 0 ? (C(), O("div", dn, V(N(t).unreadCount), 1)) : U("", !0),
+        N(t).isWidgetOpen ? (C(), O("svg", gn, [...r[4] || (r[4] = [
+          u("line", {
+            x1: "18",
+            y1: "6",
+            x2: "6",
+            y2: "18"
+          }, null, -1),
+          u("line", {
+            x1: "6",
+            y1: "6",
+            x2: "18",
+            y2: "18"
+          }, null, -1)
+        ])])) : (C(), O("svg", pn, [...r[3] || (r[3] = [
+          u("path", { d: "M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" }, null, -1)
+        ])]))
+      ])
+    ]));
+  }
+}), _n = {
+  install: (s) => {
+    s.component("GigSupportChat", yn);
+  }
+};
+export {
+  yn as GigSupportChat,
+  _n as default,
+  wt as useSupportChat
+};