@thatopen/services 0.0.1

package/dist/index.es.js

@@ -0,0 +1,3310 @@
+var Fe = Object.defineProperty;
+var ge = (n) => {
+  throw TypeError(n);
+};
+var Ve = (n, e, t) => e in n ? Fe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var _ = (n, e, t) => Ve(n, typeof e != "symbol" ? e + "" : e, t), j = (n, e, t) => e.has(n) || ge("Cannot " + t);
+var G = (n, e, t) => (j(n, e, "read from private field"), t ? t.call(n) : e.get(n)), K = (n, e, t) => e.has(n) ? ge("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(n) : e.set(n, t), we = (n, e, t, s) => (j(n, e, "write to private field"), s ? s.call(n, t) : e.set(n, t), t), c = (n, e, t) => (j(n, e, "access private method"), t);
+const k = /* @__PURE__ */ Object.create(null);
+k.open = "0";
+k.close = "1";
+k.ping = "2";
+k.pong = "3";
+k.message = "4";
+k.upgrade = "5";
+k.noop = "6";
+const q = /* @__PURE__ */ Object.create(null);
+Object.keys(k).forEach((n) => {
+  q[k[n]] = n;
+});
+const ee = { type: "error", data: "parser error" }, Ae = typeof Blob == "function" || typeof Blob < "u" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]", Oe = typeof ArrayBuffer == "function", Se = (n) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(n) : n && n.buffer instanceof ArrayBuffer, ue = ({ type: n, data: e }, t, s) => Ae && e instanceof Blob ? t ? s(e) : _e(e, s) : Oe && (e instanceof ArrayBuffer || Se(e)) ? t ? s(e) : _e(new Blob([e]), s) : s(k[n] + (e || "")), _e = (n, e) => {
+  const t = new FileReader();
+  return t.onload = function() {
+    const s = t.result.split(",")[1];
+    e("b" + (s || ""));
+  }, t.readAsDataURL(n);
+};
+function be(n) {
+  return n instanceof Uint8Array ? n : n instanceof ArrayBuffer ? new Uint8Array(n) : new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+}
+let Y;
+function Me(n, e) {
+  if (Ae && n.data instanceof Blob)
+    return n.data.arrayBuffer().then(be).then(e);
+  if (Oe && (n.data instanceof ArrayBuffer || Se(n.data)))
+    return e(be(n.data));
+  ue(n, !1, (t) => {
+    Y || (Y = new TextEncoder()), e(Y.encode(t));
+  });
+}
+const Ee = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", N = typeof Uint8Array > "u" ? [] : new Uint8Array(256);
+for (let n = 0; n < Ee.length; n++)
+  N[Ee.charCodeAt(n)] = n;
+const He = (n) => {
+  let e = n.length * 0.75, t = n.length, s, r = 0, i, o, h, u;
+  n[n.length - 1] === "=" && (e--, n[n.length - 2] === "=" && e--);
+  const y = new ArrayBuffer(e), d = new Uint8Array(y);
+  for (s = 0; s < t; s += 4)
+    i = N[n.charCodeAt(s)], o = N[n.charCodeAt(s + 1)], h = N[n.charCodeAt(s + 2)], u = N[n.charCodeAt(s + 3)], d[r++] = i << 2 | o >> 4, d[r++] = (o & 15) << 4 | h >> 2, d[r++] = (h & 3) << 6 | u & 63;
+  return y;
+}, Je = typeof ArrayBuffer == "function", le = (n, e) => {
+  if (typeof n != "string")
+    return {
+      type: "message",
+      data: Ce(n, e)
+    };
+  const t = n.charAt(0);
+  return t === "b" ? {
+    type: "message",
+    data: je(n.substring(1), e)
+  } : q[t] ? n.length > 1 ? {
+    type: q[t],
+    data: n.substring(1)
+  } : {
+    type: q[t]
+  } : ee;
+}, je = (n, e) => {
+  if (Je) {
+    const t = He(n);
+    return Ce(t, e);
+  } else
+    return { base64: !0, data: n };
+}, Ce = (n, e) => {
+  switch (e) {
+    case "blob":
+      return n instanceof Blob ? n : new Blob([n]);
+    case "arraybuffer":
+    default:
+      return n instanceof ArrayBuffer ? n : n.buffer;
+  }
+}, Re = "", Ge = (n, e) => {
+  const t = n.length, s = new Array(t);
+  let r = 0;
+  n.forEach((i, o) => {
+    ue(i, !1, (h) => {
+      s[o] = h, ++r === t && e(s.join(Re));
+    });
+  });
+}, Ke = (n, e) => {
+  const t = n.split(Re), s = [];
+  for (let r = 0; r < t.length; r++) {
+    const i = le(t[r], e);
+    if (s.push(i), i.type === "error")
+      break;
+  }
+  return s;
+};
+function Ye() {
+  return new TransformStream({
+    transform(n, e) {
+      Me(n, (t) => {
+        const s = t.length;
+        let r;
+        if (s < 126)
+          r = new Uint8Array(1), new DataView(r.buffer).setUint8(0, s);
+        else if (s < 65536) {
+          r = new Uint8Array(3);
+          const i = new DataView(r.buffer);
+          i.setUint8(0, 126), i.setUint16(1, s);
+        } else {
+          r = new Uint8Array(9);
+          const i = new DataView(r.buffer);
+          i.setUint8(0, 127), i.setBigUint64(1, BigInt(s));
+        }
+        n.data && typeof n.data != "string" && (r[0] |= 128), e.enqueue(r), e.enqueue(t);
+      });
+    }
+  });
+}
+let W;
+function P(n) {
+  return n.reduce((e, t) => e + t.length, 0);
+}
+function L(n, e) {
+  if (n[0].length === e)
+    return n.shift();
+  const t = new Uint8Array(e);
+  let s = 0;
+  for (let r = 0; r < e; r++)
+    t[r] = n[0][s++], s === n[0].length && (n.shift(), s = 0);
+  return n.length && s < n[0].length && (n[0] = n[0].slice(s)), t;
+}
+function We(n, e) {
+  W || (W = new TextDecoder());
+  const t = [];
+  let s = 0, r = -1, i = !1;
+  return new TransformStream({
+    transform(o, h) {
+      for (t.push(o); ; ) {
+        if (s === 0) {
+          if (P(t) < 1)
+            break;
+          const u = L(t, 1);
+          i = (u[0] & 128) === 128, r = u[0] & 127, r < 126 ? s = 3 : r === 126 ? s = 1 : s = 2;
+        } else if (s === 1) {
+          if (P(t) < 2)
+            break;
+          const u = L(t, 2);
+          r = new DataView(u.buffer, u.byteOffset, u.length).getUint16(0), s = 3;
+        } else if (s === 2) {
+          if (P(t) < 8)
+            break;
+          const u = L(t, 8), y = new DataView(u.buffer, u.byteOffset, u.length), d = y.getUint32(0);
+          if (d > Math.pow(2, 21) - 1) {
+            h.enqueue(ee);
+            break;
+          }
+          r = d * Math.pow(2, 32) + y.getUint32(4), s = 3;
+        } else {
+          if (P(t) < r)
+            break;
+          const u = L(t, r);
+          h.enqueue(le(i ? u : W.decode(u), e)), s = 0;
+        }
+        if (r === 0 || r > n) {
+          h.enqueue(ee);
+          break;
+        }
+      }
+    }
+  });
+}
+const $e = 4;
+function g(n) {
+  if (n) return ze(n);
+}
+function ze(n) {
+  for (var e in g.prototype)
+    n[e] = g.prototype[e];
+  return n;
+}
+g.prototype.on = g.prototype.addEventListener = function(n, e) {
+  return this._callbacks = this._callbacks || {}, (this._callbacks["$" + n] = this._callbacks["$" + n] || []).push(e), this;
+};
+g.prototype.once = function(n, e) {
+  function t() {
+    this.off(n, t), e.apply(this, arguments);
+  }
+  return t.fn = e, this.on(n, t), this;
+};
+g.prototype.off = g.prototype.removeListener = g.prototype.removeAllListeners = g.prototype.removeEventListener = function(n, e) {
+  if (this._callbacks = this._callbacks || {}, arguments.length == 0)
+    return this._callbacks = {}, this;
+  var t = this._callbacks["$" + n];
+  if (!t) return this;
+  if (arguments.length == 1)
+    return delete this._callbacks["$" + n], this;
+  for (var s, r = 0; r < t.length; r++)
+    if (s = t[r], s === e || s.fn === e) {
+      t.splice(r, 1);
+      break;
+    }
+  return t.length === 0 && delete this._callbacks["$" + n], this;
+};
+g.prototype.emit = function(n) {
+  this._callbacks = this._callbacks || {};
+  for (var e = new Array(arguments.length - 1), t = this._callbacks["$" + n], s = 1; s < arguments.length; s++)
+    e[s - 1] = arguments[s];
+  if (t) {
+    t = t.slice(0);
+    for (var s = 0, r = t.length; s < r; ++s)
+      t[s].apply(this, e);
+  }
+  return this;
+};
+g.prototype.emitReserved = g.prototype.emit;
+g.prototype.listeners = function(n) {
+  return this._callbacks = this._callbacks || {}, this._callbacks["$" + n] || [];
+};
+g.prototype.hasListeners = function(n) {
+  return !!this.listeners(n).length;
+};
+const H = typeof Promise == "function" && typeof Promise.resolve == "function" ? (e) => Promise.resolve().then(e) : (e, t) => t(e, 0), b = typeof self < "u" ? self : typeof window < "u" ? window : Function("return this")(), Xe = "arraybuffer";
+function Be(n, ...e) {
+  return e.reduce((t, s) => (n.hasOwnProperty(s) && (t[s] = n[s]), t), {});
+}
+const Qe = b.setTimeout, Ze = b.clearTimeout;
+function J(n, e) {
+  e.useNativeTimers ? (n.setTimeoutFn = Qe.bind(b), n.clearTimeoutFn = Ze.bind(b)) : (n.setTimeoutFn = b.setTimeout.bind(b), n.clearTimeoutFn = b.clearTimeout.bind(b));
+}
+const et = 1.33;
+function tt(n) {
+  return typeof n == "string" ? st(n) : Math.ceil((n.byteLength || n.size) * et);
+}
+function st(n) {
+  let e = 0, t = 0;
+  for (let s = 0, r = n.length; s < r; s++)
+    e = n.charCodeAt(s), e < 128 ? t += 1 : e < 2048 ? t += 2 : e < 55296 || e >= 57344 ? t += 3 : (s++, t += 4);
+  return t;
+}
+function xe() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
+}
+function nt(n) {
+  let e = "";
+  for (let t in n)
+    n.hasOwnProperty(t) && (e.length && (e += "&"), e += encodeURIComponent(t) + "=" + encodeURIComponent(n[t]));
+  return e;
+}
+function rt(n) {
+  let e = {}, t = n.split("&");
+  for (let s = 0, r = t.length; s < r; s++) {
+    let i = t[s].split("=");
+    e[decodeURIComponent(i[0])] = decodeURIComponent(i[1]);
+  }
+  return e;
+}
+class it extends Error {
+  constructor(e, t, s) {
+    super(e), this.description = t, this.context = s, this.type = "TransportError";
+  }
+}
+class fe extends g {
+  /**
+   * Transport abstract constructor.
+   *
+   * @param {Object} opts - options
+   * @protected
+   */
+  constructor(e) {
+    super(), this.writable = !1, J(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, s) {
+    return super.emitReserved("error", new it(e, t, s)), 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 = le(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 = nt(e);
+    return t.length ? "?" + t : "";
+  }
+}
+class ot extends fe {
+  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 s = 0;
+      this._polling && (s++, this.once("pollComplete", function() {
+        --s || t();
+      })), this.writable || (s++, this.once("drain", function() {
+        --s || 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 = (s) => {
+      if (this.readyState === "opening" && s.type === "open" && this.onOpen(), s.type === "close")
+        return this.onClose({ description: "transport closed by the server" }), !1;
+      this.onPacket(s);
+    };
+    Ke(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, Ge(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] = xe()), !this.supportsBinary && !t.sid && (t.b64 = 1), this.createUri(e, t);
+  }
+}
+let Ne = !1;
+try {
+  Ne = typeof XMLHttpRequest < "u" && "withCredentials" in new XMLHttpRequest();
+} catch {
+}
+const at = Ne;
+function ct() {
+}
+class ht extends ot {
+  /**
+   * XHR Polling constructor.
+   *
+   * @param {Object} opts
+   * @package
+   */
+  constructor(e) {
+    if (super(e), typeof location < "u") {
+      const t = location.protocol === "https:";
+      let s = location.port;
+      s || (s = t ? "443" : "80"), this.xd = typeof location < "u" && e.hostname !== location.hostname || s !== e.port;
+    }
+  }
+  /**
+   * Sends data.
+   *
+   * @param {String} data to send.
+   * @param {Function} called upon flush.
+   * @private
+   */
+  doWrite(e, t) {
+    const s = this.request({
+      method: "POST",
+      data: e
+    });
+    s.on("success", t), s.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, s) => {
+      this.onError("xhr poll error", t, s);
+    }), this.pollXhr = e;
+  }
+}
+class v extends g {
+  /**
+   * Request constructor
+   *
+   * @param {Object} options
+   * @package
+   */
+  constructor(e, t, s) {
+    super(), this.createRequest = e, J(this, s), this._opts = s, this._method = s.method || "GET", this._uri = t, this._data = s.data !== void 0 ? s.data : null, this._create();
+  }
+  /**
+   * Creates the XHR object and sends the request.
+   *
+   * @private
+   */
+  _create() {
+    var e;
+    const t = Be(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    t.xdomain = !!this._opts.xd;
+    const s = this._xhr = this.createRequest(t);
+    try {
+      s.open(this._method, this._uri, !0);
+      try {
+        if (this._opts.extraHeaders) {
+          s.setDisableHeaderCheck && s.setDisableHeaderCheck(!0);
+          for (let r in this._opts.extraHeaders)
+            this._opts.extraHeaders.hasOwnProperty(r) && s.setRequestHeader(r, this._opts.extraHeaders[r]);
+        }
+      } catch {
+      }
+      if (this._method === "POST")
+        try {
+          s.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+        } catch {
+        }
+      try {
+        s.setRequestHeader("Accept", "*/*");
+      } catch {
+      }
+      (e = this._opts.cookieJar) === null || e === void 0 || e.addCookies(s), "withCredentials" in s && (s.withCredentials = this._opts.withCredentials), this._opts.requestTimeout && (s.timeout = this._opts.requestTimeout), s.onreadystatechange = () => {
+        var r;
+        s.readyState === 3 && ((r = this._opts.cookieJar) === null || r === void 0 || r.parseCookies(
+          // @ts-ignore
+          s.getResponseHeader("set-cookie")
+        )), s.readyState === 4 && (s.status === 200 || s.status === 1223 ? this._onLoad() : this.setTimeoutFn(() => {
+          this._onError(typeof s.status == "number" ? s.status : 0);
+        }, 0));
+      }, s.send(this._data);
+    } catch (r) {
+      this.setTimeoutFn(() => {
+        this._onError(r);
+      }, 0);
+      return;
+    }
+    typeof document < "u" && (this._index = v.requestsCount++, v.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 = ct, e)
+        try {
+          this._xhr.abort();
+        } catch {
+        }
+      typeof document < "u" && delete v.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();
+  }
+}
+v.requestsCount = 0;
+v.requests = {};
+if (typeof document < "u") {
+  if (typeof attachEvent == "function")
+    attachEvent("onunload", Te);
+  else if (typeof addEventListener == "function") {
+    const n = "onpagehide" in b ? "pagehide" : "unload";
+    addEventListener(n, Te, !1);
+  }
+}
+function Te() {
+  for (let n in v.requests)
+    v.requests.hasOwnProperty(n) && v.requests[n].abort();
+}
+const ut = function() {
+  const n = Pe({
+    xdomain: !1
+  });
+  return n && n.responseType !== null;
+}();
+class lt extends ht {
+  constructor(e) {
+    super(e);
+    const t = e && e.forceBase64;
+    this.supportsBinary = ut && !t;
+  }
+  request(e = {}) {
+    return Object.assign(e, { xd: this.xd }, this.opts), new v(Pe, this.uri(), e);
+  }
+}
+function Pe(n) {
+  const e = n.xdomain;
+  try {
+    if (typeof XMLHttpRequest < "u" && (!e || at))
+      return new XMLHttpRequest();
+  } catch {
+  }
+  if (!e)
+    try {
+      return new b[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+    } catch {
+    }
+}
+const Le = typeof navigator < "u" && typeof navigator.product == "string" && navigator.product.toLowerCase() === "reactnative";
+class ft extends fe {
+  get name() {
+    return "websocket";
+  }
+  doOpen() {
+    const e = this.uri(), t = this.opts.protocols, s = Le ? {} : Be(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
+    this.opts.extraHeaders && (s.headers = this.opts.extraHeaders);
+    try {
+      this.ws = this.createSocket(e, t, s);
+    } 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 s = e[t], r = t === e.length - 1;
+      ue(s, this.supportsBinary, (i) => {
+        try {
+          this.doWrite(s, i);
+        } catch {
+        }
+        r && H(() => {
+          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] = xe()), this.supportsBinary || (t.b64 = 1), this.createUri(e, t);
+  }
+}
+const z = b.WebSocket || b.MozWebSocket;
+class pt extends ft {
+  createSocket(e, t, s) {
+    return Le ? new z(e, t, s) : t ? new z(e, t) : new z(e);
+  }
+  doWrite(e, t) {
+    this.ws.send(t);
+  }
+}
+class dt extends fe {
+  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 = We(Number.MAX_SAFE_INTEGER, this.socket.binaryType), s = e.readable.pipeThrough(t).getReader(), r = Ye();
+        r.readable.pipeTo(e.writable), this._writer = r.writable.getWriter();
+        const i = () => {
+          s.read().then(({ done: h, value: u }) => {
+            h || (this.onPacket(u), i());
+          }).catch((h) => {
+          });
+        };
+        i();
+        const o = { type: "open" };
+        this.query.sid && (o.data = `{"sid":"${this.query.sid}"}`), this._writer.write(o).then(() => this.onOpen());
+      });
+    });
+  }
+  write(e) {
+    this.writable = !1;
+    for (let t = 0; t < e.length; t++) {
+      const s = e[t], r = t === e.length - 1;
+      this._writer.write(s).then(() => {
+        r && H(() => {
+          this.writable = !0, this.emitReserved("drain");
+        }, this.setTimeoutFn);
+      });
+    }
+  }
+  doClose() {
+    var e;
+    (e = this._transport) === null || e === void 0 || e.close();
+  }
+}
+const yt = {
+  websocket: pt,
+  webtransport: dt,
+  polling: lt
+}, mt = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/, gt = [
+  "source",
+  "protocol",
+  "authority",
+  "userInfo",
+  "user",
+  "password",
+  "host",
+  "port",
+  "relative",
+  "path",
+  "directory",
+  "file",
+  "query",
+  "anchor"
+];
+function te(n) {
+  if (n.length > 8e3)
+    throw "URI too long";
+  const e = n, t = n.indexOf("["), s = n.indexOf("]");
+  t != -1 && s != -1 && (n = n.substring(0, t) + n.substring(t, s).replace(/:/g, ";") + n.substring(s, n.length));
+  let r = mt.exec(n || ""), i = {}, o = 14;
+  for (; o--; )
+    i[gt[o]] = r[o] || "";
+  return t != -1 && s != -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 = wt(i, i.path), i.queryKey = _t(i, i.query), i;
+}
+function wt(n, e) {
+  const t = /\/{2,9}/g, s = e.replace(t, "/").split("/");
+  return (e.slice(0, 1) == "/" || e.length === 0) && s.splice(0, 1), e.slice(-1) == "/" && s.splice(s.length - 1, 1), s;
+}
+function _t(n, e) {
+  const t = {};
+  return e.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function(s, r, i) {
+    r && (t[r] = i);
+  }), t;
+}
+const se = typeof addEventListener == "function" && typeof removeEventListener == "function", U = [];
+se && addEventListener("offline", () => {
+  U.forEach((n) => n());
+}, !1);
+class C extends g {
+  /**
+   * Socket constructor.
+   *
+   * @param {String|Object} uri - uri or options
+   * @param {Object} opts - options
+   */
+  constructor(e, t) {
+    if (super(), this.binaryType = Xe, 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 s = te(e);
+      t.hostname = s.host, t.secure = s.protocol === "https" || s.protocol === "wss", t.port = s.port, s.query && (t.query = s.query);
+    } else t.host && (t.hostname = te(t.host).host);
+    J(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((s) => {
+      const r = s.prototype.name;
+      this.transports.push(r), this._transportsByName[r] = s;
+    }), 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 = rt(this.opts.query)), se && (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"
+      });
+    }, U.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 = $e, t.transport = e, this.id && (t.sid = this.id);
+    const s = 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](s);
+  }
+  /**
+   * 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 && C.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", C.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 s = 0; s < this.writeBuffer.length; s++) {
+      const r = this.writeBuffer[s].data;
+      if (r && (t += tt(r)), s > 0 && t > this._maxPayload)
+        return this.writeBuffer.slice(0, s);
+      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, H(() => {
+      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, s) {
+    return this._sendPacket("message", e, t, s), 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, s) {
+    return this._sendPacket("message", e, t, s), this;
+  }
+  /**
+   * Sends a packet.
+   *
+   * @param {String} type: packet type.
+   * @param {String} data.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @private
+   */
+  _sendPacket(e, t, s, r) {
+    if (typeof t == "function" && (r = t, t = void 0), typeof s == "function" && (r = s, s = null), this.readyState === "closing" || this.readyState === "closed")
+      return;
+    s = s || {}, s.compress = s.compress !== !1;
+    const i = {
+      type: e,
+      data: t,
+      options: s
+    };
+    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();
+    }, s = () => {
+      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 ? s() : e();
+    }) : this.upgrading ? s() : e()), this;
+  }
+  /**
+   * Called upon transport error
+   *
+   * @private
+   */
+  _onError(e) {
+    if (C.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(), se && (this._beforeunloadEventListener && removeEventListener("beforeunload", this._beforeunloadEventListener, !1), this._offlineEventListener)) {
+        const s = U.indexOf(this._offlineEventListener);
+        s !== -1 && U.splice(s, 1);
+      }
+      this.readyState = "closed", this.id = null, this.emitReserved("close", e, t), this.writeBuffer = [], this._prevBufferLen = 0;
+    }
+  }
+}
+C.protocol = $e;
+class bt extends C {
+  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), s = !1;
+    C.priorWebsocketSuccess = !1;
+    const r = () => {
+      s || (t.send([{ type: "ping", data: "probe" }]), t.once("packet", (m) => {
+        if (!s)
+          if (m.type === "pong" && m.data === "probe") {
+            if (this.upgrading = !0, this.emitReserved("upgrading", t), !t)
+              return;
+            C.priorWebsocketSuccess = t.name === "websocket", this.transport.pause(() => {
+              s || this.readyState !== "closed" && (d(), 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() {
+      s || (s = !0, d(), t.close(), t = null);
+    }
+    const o = (m) => {
+      const w = new Error("probe error: " + m);
+      w.transport = t.name, i(), this.emitReserved("upgradeError", w);
+    };
+    function h() {
+      o("transport closed");
+    }
+    function u() {
+      o("socket closed");
+    }
+    function y(m) {
+      t && m.name !== t.name && i();
+    }
+    const d = () => {
+      t.removeListener("open", r), t.removeListener("error", o), t.removeListener("close", h), this.off("close", u), this.off("upgrading", y);
+    };
+    t.once("open", r), t.once("error", o), t.once("close", h), this.once("close", u), this.once("upgrading", y), this._upgrades.indexOf("webtransport") !== -1 && e !== "webtransport" ? this.setTimeoutFn(() => {
+      s || 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 s = 0; s < e.length; s++)
+      ~this.transports.indexOf(e[s]) && t.push(e[s]);
+    return t;
+  }
+}
+let Et = class extends bt {
+  constructor(e, t = {}) {
+    const s = typeof e == "object" ? e : t;
+    (!s.transports || s.transports && typeof s.transports[0] == "string") && (s.transports = (s.transports || ["polling", "websocket", "webtransport"]).map((r) => yt[r]).filter((r) => !!r)), super(e, s);
+  }
+};
+function Tt(n, e = "", t) {
+  let s = n;
+  t = t || typeof location < "u" && location, n == null && (n = t.protocol + "//" + t.host), typeof n == "string" && (n.charAt(0) === "/" && (n.charAt(1) === "/" ? n = t.protocol + n : n = t.host + n), /^(https?|wss?):\/\//.test(n) || (typeof t < "u" ? n = t.protocol + "//" + n : n = "https://" + n), s = te(n)), s.port || (/^(http|ws)$/.test(s.protocol) ? s.port = "80" : /^(http|ws)s$/.test(s.protocol) && (s.port = "443")), s.path = s.path || "/";
+  const i = s.host.indexOf(":") !== -1 ? "[" + s.host + "]" : s.host;
+  return s.id = s.protocol + "://" + i + ":" + s.port + e, s.href = s.protocol + "://" + i + (t && t.port === s.port ? "" : ":" + s.port), s;
+}
+const vt = typeof ArrayBuffer == "function", kt = (n) => typeof ArrayBuffer.isView == "function" ? ArrayBuffer.isView(n) : n.buffer instanceof ArrayBuffer, Ie = Object.prototype.toString, At = typeof Blob == "function" || typeof Blob < "u" && Ie.call(Blob) === "[object BlobConstructor]", Ot = typeof File == "function" || typeof File < "u" && Ie.call(File) === "[object FileConstructor]";
+function pe(n) {
+  return vt && (n instanceof ArrayBuffer || kt(n)) || At && n instanceof Blob || Ot && n instanceof File;
+}
+function D(n, e) {
+  if (!n || typeof n != "object")
+    return !1;
+  if (Array.isArray(n)) {
+    for (let t = 0, s = n.length; t < s; t++)
+      if (D(n[t]))
+        return !0;
+    return !1;
+  }
+  if (pe(n))
+    return !0;
+  if (n.toJSON && typeof n.toJSON == "function" && arguments.length === 1)
+    return D(n.toJSON(), !0);
+  for (const t in n)
+    if (Object.prototype.hasOwnProperty.call(n, t) && D(n[t]))
+      return !0;
+  return !1;
+}
+function St(n) {
+  const e = [], t = n.data, s = n;
+  return s.data = ne(t, e), s.attachments = e.length, { packet: s, buffers: e };
+}
+function ne(n, e) {
+  if (!n)
+    return n;
+  if (pe(n)) {
+    const t = { _placeholder: !0, num: e.length };
+    return e.push(n), t;
+  } else if (Array.isArray(n)) {
+    const t = new Array(n.length);
+    for (let s = 0; s < n.length; s++)
+      t[s] = ne(n[s], e);
+    return t;
+  } else if (typeof n == "object" && !(n instanceof Date)) {
+    const t = {};
+    for (const s in n)
+      Object.prototype.hasOwnProperty.call(n, s) && (t[s] = ne(n[s], e));
+    return t;
+  }
+  return n;
+}
+function Ct(n, e) {
+  return n.data = re(n.data, e), delete n.attachments, n;
+}
+function re(n, e) {
+  if (!n)
+    return n;
+  if (n && n._placeholder === !0) {
+    if (typeof n.num == "number" && n.num >= 0 && n.num < e.length)
+      return e[n.num];
+    throw new Error("illegal attachments");
+  } else if (Array.isArray(n))
+    for (let t = 0; t < n.length; t++)
+      n[t] = re(n[t], e);
+  else if (typeof n == "object")
+    for (const t in n)
+      Object.prototype.hasOwnProperty.call(n, t) && (n[t] = re(n[t], e));
+  return n;
+}
+const Rt = [
+  "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 f;
+(function(n) {
+  n[n.CONNECT = 0] = "CONNECT", n[n.DISCONNECT = 1] = "DISCONNECT", n[n.EVENT = 2] = "EVENT", n[n.ACK = 3] = "ACK", n[n.CONNECT_ERROR = 4] = "CONNECT_ERROR", n[n.BINARY_EVENT = 5] = "BINARY_EVENT", n[n.BINARY_ACK = 6] = "BINARY_ACK";
+})(f || (f = {}));
+class $t {
+  /**
+   * 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 === f.EVENT || e.type === f.ACK) && D(e) ? this.encodeAsBinary({
+      type: e.type === f.EVENT ? f.BINARY_EVENT : f.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 === f.BINARY_EVENT || e.type === f.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 = St(e), s = this.encodeAsString(t.packet), r = t.buffers;
+    return r.unshift(s), r;
+  }
+}
+class de extends g {
+  /**
+   * 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 s = t.type === f.BINARY_EVENT;
+      s || t.type === f.BINARY_ACK ? (t.type = s ? f.EVENT : f.ACK, this.reconstructor = new Bt(t), t.attachments === 0 && super.emitReserved("decoded", t)) : super.emitReserved("decoded", t);
+    } else if (pe(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 s = {
+      type: Number(e.charAt(0))
+    };
+    if (f[s.type] === void 0)
+      throw new Error("unknown packet type " + s.type);
+    if (s.type === f.BINARY_EVENT || s.type === f.BINARY_ACK) {
+      const i = t + 1;
+      for (; e.charAt(++t) !== "-" && t != e.length; )
+        ;
+      const o = e.substring(i, t);
+      if (o != Number(o) || e.charAt(t) !== "-")
+        throw new Error("Illegal attachments");
+      s.attachments = Number(o);
+    }
+    if (e.charAt(t + 1) === "/") {
+      const i = t + 1;
+      for (; ++t && !(e.charAt(t) === "," || t === e.length); )
+        ;
+      s.nsp = e.substring(i, t);
+    } else
+      s.nsp = "/";
+    const r = e.charAt(t + 1);
+    if (r !== "" && Number(r) == r) {
+      const i = t + 1;
+      for (; ++t; ) {
+        const o = e.charAt(t);
+        if (o == null || Number(o) != o) {
+          --t;
+          break;
+        }
+        if (t === e.length)
+          break;
+      }
+      s.id = Number(e.substring(i, t + 1));
+    }
+    if (e.charAt(++t)) {
+      const i = this.tryParse(e.substr(t));
+      if (de.isPayloadValid(s.type, i))
+        s.data = i;
+      else
+        throw new Error("invalid payload");
+    }
+    return s;
+  }
+  tryParse(e) {
+    try {
+      return JSON.parse(e, this.reviver);
+    } catch {
+      return !1;
+    }
+  }
+  static isPayloadValid(e, t) {
+    switch (e) {
+      case f.CONNECT:
+        return ve(t);
+      case f.DISCONNECT:
+        return t === void 0;
+      case f.CONNECT_ERROR:
+        return typeof t == "string" || ve(t);
+      case f.EVENT:
+      case f.BINARY_EVENT:
+        return Array.isArray(t) && (typeof t[0] == "number" || typeof t[0] == "string" && Rt.indexOf(t[0]) === -1);
+      case f.ACK:
+      case f.BINARY_ACK:
+        return Array.isArray(t);
+    }
+  }
+  /**
+   * Deallocates a parser's resources
+   */
+  destroy() {
+    this.reconstructor && (this.reconstructor.finishedReconstruction(), this.reconstructor = null);
+  }
+}
+class Bt {
+  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 = Ct(this.reconPack, this.buffers);
+      return this.finishedReconstruction(), t;
+    }
+    return null;
+  }
+  /**
+   * Cleans up binary packet reconstruction variables.
+   */
+  finishedReconstruction() {
+    this.reconPack = null, this.buffers = [];
+  }
+}
+function ve(n) {
+  return Object.prototype.toString.call(n) === "[object Object]";
+}
+const xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Decoder: de,
+  Encoder: $t,
+  get PacketType() {
+    return f;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+function E(n, e, t) {
+  return n.on(e, t), function() {
+    n.off(e, t);
+  };
+}
+const Nt = 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 qe extends g {
+  /**
+   * `Socket` constructor.
+   */
+  constructor(e, t, s) {
+    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, s && s.auth && (this.auth = s.auth), this._opts = Object.assign({}, s), 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 = [
+      E(e, "open", this.onopen.bind(this)),
+      E(e, "packet", this.onpacket.bind(this)),
+      E(e, "error", this.onerror.bind(this)),
+      E(e, "close", this.onclose.bind(this))
+    ];
+  }
+  /**
+   * 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 s, r, i;
+    if (Nt.hasOwnProperty(e))
+      throw new Error('"' + e.toString() + '" is a reserved event name');
+    if (t.unshift(e), this._opts.retries && !this.flags.fromQueue && !this.flags.volatile)
+      return this._addToQueue(t), this;
+    const o = {
+      type: f.EVENT,
+      data: t
+    };
+    if (o.options = {}, o.options.compress = this.flags.compress !== !1, typeof t[t.length - 1] == "function") {
+      const d = this.ids++, m = t.pop();
+      this._registerAckCallback(d, m), o.id = d;
+    }
+    const h = (r = (s = this.io.engine) === null || s === void 0 ? void 0 : s.transport) === null || r === void 0 ? void 0 : r.writable, u = this.connected && !(!((i = this.io.engine) === null || i === void 0) && i._hasPingExpired());
+    return this.flags.volatile && !h || (u ? (this.notifyOutgoingListeners(o), this.packet(o)) : this.sendBuffer.push(o)), this.flags = {}, this;
+  }
+  /**
+   * @private
+   */
+  _registerAckCallback(e, t) {
+    var s;
+    const r = (s = this.flags.timeout) !== null && s !== void 0 ? s : this._opts.ackTimeout;
+    if (r === void 0) {
+      this.acks[e] = t;
+      return;
+    }
+    const i = this.io.setTimeoutFn(() => {
+      delete this.acks[e];
+      for (let h = 0; h < this.sendBuffer.length; h++)
+        this.sendBuffer[h].id === e && this.sendBuffer.splice(h, 1);
+      t.call(this, new Error("operation has timed out"));
+    }, r), o = (...h) => {
+      this.io.clearTimeoutFn(i), t.apply(this, h);
+    };
+    o.withError = !0, this.acks[e] = o;
+  }
+  /**
+   * 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((s, r) => {
+      const i = (o, h) => o ? r(o) : s(h);
+      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 s = {
+      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 ? s.tryCount > this._opts.retries && (this._queue.shift(), t && t(r)) : (this._queue.shift(), t && t(null, ...i)), s.pending = !1, this._drainQueue())), this._queue.push(s), 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: f.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((s) => String(s.id) === e)) {
+        const s = this.acks[e];
+        delete this.acks[e], s.withError && s.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 f.CONNECT:
+          e.data && e.data.sid ? this.onconnect(e.data.sid, e.data.pid) : this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+          break;
+        case f.EVENT:
+        case f.BINARY_EVENT:
+          this.onevent(e);
+          break;
+        case f.ACK:
+        case f.BINARY_ACK:
+          this.onack(e);
+          break;
+        case f.DISCONNECT:
+          this.ondisconnect();
+          break;
+        case f.CONNECT_ERROR:
+          this.destroy();
+          const s = new Error(e.data.message);
+          s.data = e.data.data, this.emitReserved("connect_error", s);
+          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 s of t)
+        s.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 s = !1;
+    return function(...r) {
+      s || (s = !0, t.packet({
+        type: f.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: f.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 s = 0; s < t.length; s++)
+        if (e === t[s])
+          return t.splice(s, 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 s = 0; s < t.length; s++)
+        if (e === t[s])
+          return t.splice(s, 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 s of t)
+        s.apply(this, e.data);
+    }
+  }
+}
+function B(n) {
+  n = n || {}, this.ms = n.min || 100, this.max = n.max || 1e4, this.factor = n.factor || 2, this.jitter = n.jitter > 0 && n.jitter <= 1 ? n.jitter : 0, this.attempts = 0;
+}
+B.prototype.duration = function() {
+  var n = this.ms * Math.pow(this.factor, this.attempts++);
+  if (this.jitter) {
+    var e = Math.random(), t = Math.floor(e * this.jitter * n);
+    n = Math.floor(e * 10) & 1 ? n + t : n - t;
+  }
+  return Math.min(n, this.max) | 0;
+};
+B.prototype.reset = function() {
+  this.attempts = 0;
+};
+B.prototype.setMin = function(n) {
+  this.ms = n;
+};
+B.prototype.setMax = function(n) {
+  this.max = n;
+};
+B.prototype.setJitter = function(n) {
+  this.jitter = n;
+};
+class ie extends g {
+  constructor(e, t) {
+    var s;
+    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, J(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((s = t.randomizationFactor) !== null && s !== void 0 ? s : 0.5), this.backoff = new B({
+      min: this.reconnectionDelay(),
+      max: this.reconnectionDelayMax(),
+      jitter: this.randomizationFactor()
+    }), this.timeout(t.timeout == null ? 2e4 : t.timeout), this._readyState = "closed", this.uri = e;
+    const r = t.parser || xt;
+    this.encoder = new r.Encoder(), this.decoder = new r.Decoder(), this._autoConnect = t.autoConnect !== !1, this._autoConnect && this.open();
+  }
+  reconnection(e) {
+    return arguments.length ? (this._reconnection = !!e, e || (this.skipReconnect = !0), this) : this._reconnection;
+  }
+  reconnectionAttempts(e) {
+    return e === void 0 ? this._reconnectionAttempts : (this._reconnectionAttempts = e, this);
+  }
+  reconnectionDelay(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelay : (this._reconnectionDelay = e, (t = this.backoff) === null || t === void 0 || t.setMin(e), this);
+  }
+  randomizationFactor(e) {
+    var t;
+    return e === void 0 ? this._randomizationFactor : (this._randomizationFactor = e, (t = this.backoff) === null || t === void 0 || t.setJitter(e), this);
+  }
+  reconnectionDelayMax(e) {
+    var t;
+    return e === void 0 ? this._reconnectionDelayMax : (this._reconnectionDelayMax = e, (t = this.backoff) === null || t === void 0 || t.setMax(e), this);
+  }
+  timeout(e) {
+    return arguments.length ? (this._timeout = e, this) : this._timeout;
+  }
+  /**
+   * 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 Et(this.uri, this.opts);
+    const t = this.engine, s = this;
+    this._readyState = "opening", this.skipReconnect = !1;
+    const r = E(t, "open", function() {
+      s.onopen(), e && e();
+    }), i = (h) => {
+      this.cleanup(), this._readyState = "closed", this.emitReserved("error", h), e ? e(h) : this.maybeReconnectOnOpen();
+    }, o = E(t, "error", i);
+    if (this._timeout !== !1) {
+      const h = this._timeout, u = this.setTimeoutFn(() => {
+        r(), i(new Error("timeout")), t.close();
+      }, h);
+      this.opts.autoUnref && u.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(u);
+      });
+    }
+    return this.subs.push(r), this.subs.push(o), 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(
+      E(e, "ping", this.onping.bind(this)),
+      E(e, "data", this.ondata.bind(this)),
+      E(e, "error", this.onerror.bind(this)),
+      E(e, "close", this.onclose.bind(this)),
+      // @ts-ignore
+      E(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) {
+    H(() => {
+      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 s = this.nsps[e];
+    return s ? this._autoConnect && !s.active && s.connect() : (s = new qe(this, e, t), this.nsps[e] = s), s;
+  }
+  /**
+   * Called upon a socket close.
+   *
+   * @param socket
+   * @private
+   */
+  _destroy(e) {
+    const t = Object.keys(this.nsps);
+    for (const s of t)
+      if (this.nsps[s].active)
+        return;
+    this._close();
+  }
+  /**
+   * Writes a packet.
+   *
+   * @param packet
+   * @private
+   */
+  _packet(e) {
+    const t = this.encoder.encode(e);
+    for (let s = 0; s < t.length; s++)
+      this.engine.write(t[s], 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 s;
+    this.cleanup(), (s = this.engine) === null || s === void 0 || s.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 s = 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 && s.unref(), this.subs.push(() => {
+        this.clearTimeoutFn(s);
+      });
+    }
+  }
+  /**
+   * Called upon successful reconnect.
+   *
+   * @private
+   */
+  onreconnect() {
+    const e = this.backoff.attempts;
+    this._reconnecting = !1, this.backoff.reset(), this.emitReserved("reconnect", e);
+  }
+}
+const x = {};
+function F(n, e) {
+  typeof n == "object" && (e = n, n = void 0), e = e || {};
+  const t = Tt(n, e.path || "/socket.io"), s = t.source, r = t.id, i = t.path, o = x[r] && i in x[r].nsps, h = e.forceNew || e["force new connection"] || e.multiplex === !1 || o;
+  let u;
+  return h ? u = new ie(s, e) : (x[r] || (x[r] = new ie(s, e)), u = x[r]), t.query && !e.query && (e.query = t.queryKey), u.socket(t.path, e);
+}
+Object.assign(F, {
+  Manager: ie,
+  Socket: qe,
+  io: F,
+  connect: F
+});
+function Pt(n) {
+  try {
+    const e = JSON.parse(n);
+    if (e && typeof e == "object") {
+      const t = e;
+      return {
+        message: typeof t.message == "string" ? t.message : void 0,
+        code: typeof t.code == "string" ? t.code : void 0,
+        details: t.details
+      };
+    }
+  } catch {
+  }
+  return {};
+}
+class Lt extends Error {
+  constructor(t, s, r) {
+    const i = Pt(r);
+    super(i.message ?? `${s || "Request failed"} (${t})`);
+    _(this, "status");
+    _(this, "code");
+    _(this, "details");
+    _(this, "body");
+    this.name = "RequestError", this.status = t, this.code = i.code, this.details = i.details, this.body = r;
+  }
+}
+const T = "item/folder", p = "item", O = "processor", R = "hidden", X = "FILE", Q = "TOOL", Z = "APP";
+var a, ae, l, S, V, M, ce, he, Ue;
+const ye = class ye {
+  /**
+   * Creates a new EngineServicesClient instance.
+   * @param accessToken - API access token (obtained from the platform dashboard)
+   *   or an Auth0 JWT (when using `useBearer: true`).
+   * @param apiUrl - Base URL of the API (e.g. "https://api.thatopen.com").
+   * @param props - Optional configuration (retry count, auth mode, etc.).
+   */
+  constructor(e, t, s) {
+    K(this, a);
+    _(this, "apiUrl");
+    _(this, "accessToken");
+    _(this, "wsUrl");
+    _(this, "retries");
+    _(this, "useBearer");
+    _(this, "builtInGlobals", null);
+    /**
+     * URL of a local execution server (e.g. `http://localhost:4001`).
+     * When set, execution methods are routed to this server instead of the cloud API.
+     * Set to `null` to disable local routing and use the cloud API.
+     */
+    _(this, "localServerUrl", null);
+    /**
+     * The platform context this client was created with.
+     * Contains `appId`, `projectId`, `accessToken`, and `apiUrl`.
+     * Populated automatically when using {@link fromPlatformContext}.
+     */
+    _(this, "context");
+    const { retries: r = 0, useBearer: i = !1, localServerUrl: o } = s || {};
+    let h = t;
+    if (h.charAt(h.length - 1) === "/" && (h = h.slice(0, -1)), this.apiUrl = `${h}/api`, this.accessToken = e, this.wsUrl = `${h}?accessToken=${e}`, this.retries = r, this.useBearer = i, this.context = { appId: "", projectId: "", accessToken: e, apiUrl: t }, o) {
+      let u = o;
+      u.charAt(u.length - 1) === "/" && (u = u.slice(0, -1)), this.localServerUrl = u;
+    }
+  }
+  /**
+   * Creates a client from the platform context injected into
+   * `window.__THATOPEN_CONTEXT__` by the That Open Platform.
+   *
+   * This is the recommended way to create a client inside platform apps.
+   * It automatically reads the auth context and sets `useBearer: true`.
+   *
+   * @param props - Optional configuration (retry count, local server URL, etc.).
+   * @returns A new EngineServicesClient instance.
+   *
+   * @example
+   * ```ts
+   * const client = EngineServicesClient.fromPlatformContext();
+   * console.log(client.context.projectId);
+   * ```
+   */
+  static fromPlatformContext(e) {
+    const t = (typeof window < "u" ? window.__THATOPEN_CONTEXT__ : null) || { appId: "", projectId: "", accessToken: "", apiUrl: "" }, s = new ye(t.accessToken, t.apiUrl, {
+      ...e,
+      useBearer: !0
+    });
+    return s.context = t, s;
+  }
+  /**
+   * Sets the number of automatic retries for failed requests.
+   * @param retries - Number of retries (0 = no retries).
+   */
+  setRetries(e) {
+    this.retries = e;
+  }
+  /**
+   * Registers the global libraries that built-in components need at runtime.
+   *
+   * Call this once after importing your libraries. Then every subsequent
+   * {@link initBuiltInComponent} call will use these globals automatically
+   * — you no longer need to pass a `globals` argument to each one.
+   *
+   * @param globals - Map of global names to module namespaces.
+   *   Common keys: `OBC`, `OBF`, `BUI`, `CUI`, `THREE`, `FRAGS`, `MARKERJS`.
+   *
+   * @example
+   * ```ts
+   * import * as OBC from "@thatopen/components";
+   * import * as OBF from "@thatopen/components-front";
+   * import * as BUI from "@thatopen/ui";
+   * import * as CUI from "@thatopen/ui-obc";
+   * import * as THREE from "three";
+   * import * as FRAGS from "@thatopen/fragments";
+   *
+   * client.setBuiltInGlobals({ OBC, OBF, BUI, CUI, THREE, FRAGS });
+   *
+   * // Now just pass the component — no globals needed:
+   * await client.initBuiltInComponent(AppManager, components);
+   * await client.initBuiltInComponent(ViewerToolbar, components);
+   * await client.initBuiltInComponent(ModelsPanel, components);
+   * ```
+   */
+  setBuiltInGlobals(e) {
+    this.builtInGlobals = e;
+  }
+  /**
+   * Protected extension point for subclasses that need dynamic tokens
+   * (e.g. `PlatformClient` with an auth provider callback). The default
+   * returns the static token captured at construction time.
+   *
+   * When a subclass overrides this to call an async refresh function,
+   * the new token is picked up on every request — expired tokens no
+   * longer stick around.
+   */
+  async resolveAccessToken() {
+    return this.accessToken;
+  }
+  /**
+   * Protected extension hook for subclasses (e.g. `PlatformClient`) that
+   * need to add HTTP methods against additional backend routes. Delegates
+   * to the private `#requestApi` implementation so retry / auth / query-
+   * cleaning logic is applied identically.
+   */
+  async request(e, t, s) {
+    return c(this, a, l).call(this, e, t, s);
+  }
+  // ─── Files ───────────────────────────────────────────────────────
+  /**
+   * Lists all files accessible by the current token.
+   * @param filters - Optional filters for folder and archive status.
+   * @returns Array of file items.
+   */
+  async listFiles(e) {
+    const { folderId: t, archived: s, projectId: r } = e || {};
+    return t ? await c(this, a, l).call(this, "GET", `${T}/${t}/items`, { query: { itemType: X, archived: s } }) : await c(this, a, l).call(this, "GET", `${p}`, {
+      query: {
+        itemType: X,
+        archived: s,
+        ...r && { projectId: r }
+      }
+    });
+  }
+  /**
+   * Gets a single file by ID, optionally including version history.
+   * @param fileId - The file's unique identifier.
+   * @param props - Options such as whether to include versions.
+   * @returns The file item, optionally with version history.
+   */
+  async getFile(e, t) {
+    return await c(this, a, he).call(this, e, t);
+  }
+  /**
+   * Uploads a new file.
+   * @param fileData - File content, name, and version tag.
+   * @returns The created item and its first version.
+   */
+  async createFile(e) {
+    return await c(this, a, M).call(this, e, X);
+  }
+  /**
+   * Updates an existing file. Can rename, move to a different folder,
+   * and/or upload a new version — all in a single call.
+   * @param fileId - The file's unique identifier.
+   * @param fileData - Properties to update (name, folderId, file, versionTag).
+   * @returns The updated item and/or the new version.
+   */
+  async updateFile(e, t) {
+    return await c(this, a, ce).call(this, e, t);
+  }
+  /**
+   * Archives (soft-deletes) a file. Can be recovered with {@link recoverFile}.
+   * @param fileId - The file's unique identifier.
+   */
+  async archiveFile(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${e}`);
+  }
+  /**
+   * Recovers a previously archived file.
+   * @param fileId - The file's unique identifier.
+   */
+  async recoverFile(e) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${e}/recover`);
+  }
+  /**
+   * Downloads a file's content. Returns the raw fetch Response.
+   * @param fileId - The file's unique identifier.
+   * @param params - Optional version selection parameters.
+   * @returns A fetch Response containing the file data.
+   */
+  async downloadFile(e, t) {
+    return await c(this, a, V).call(this, e, t);
+  }
+  /**
+   * Retrieves the free-JSON metadata for a specific file version.
+   * Returns `{}` when the version exists but has no metadata.
+   * @param fileId - The file's unique identifier.
+   * @param versionTag - The version tag (e.g. "v1").
+   * @param params - Optional flags such as `withDraft`.
+   */
+  async getFileVersionMetadata(e, t, s) {
+    const { withDraft: r } = s || {};
+    return await c(this, a, l).call(this, "GET", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}/metadata`, {
+      query: {
+        ...r && { withDraft: "true" }
+      }
+    });
+  }
+  /**
+   * Replaces the metadata of a specific file version with the provided object.
+   * @param fileId - The file's unique identifier.
+   * @param versionTag - The version tag.
+   * @param metadata - Free-JSON object (max 200 fields, 50-char keys/values).
+   */
+  async updateFileVersionMetadata(e, t, s) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}/metadata`, {
+      body: JSON.stringify({ metadata: s }),
+      contentType: "application/json"
+    });
+  }
+  /**
+   * Clears all metadata from a specific file version.
+   * @param fileId - The file's unique identifier.
+   * @param versionTag - The version tag.
+   */
+  async deleteFileVersionMetadata(e, t) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}/metadata`);
+  }
+  // ─── Folders ─────────────────────────────────────────────────────
+  /**
+   * Lists all folders accessible by the current token.
+   * @param params - Optional filters for parent folder and archive status.
+   * @returns Array of folder items.
+   */
+  async listFolders(e) {
+    const { archived: t, parentFolderId: s, projectId: r } = e || {};
+    return await c(this, a, l).call(this, "GET", T, {
+      query: {
+        parentFolderId: s,
+        archived: t,
+        ...r && { projectId: r }
+      }
+    });
+  }
+  /**
+   * Gets a single folder by ID.
+   * @param folderId - The folder's unique identifier.
+   */
+  async getFolder(e) {
+    return await c(this, a, l).call(this, "GET", `${T}/${e}`);
+  }
+  /**
+   * Creates a new folder.
+   * @param name - Display name for the folder.
+   * @param parentId - Optional parent folder ID for nesting.
+   * @returns The created folder.
+   */
+  async createFolder(e, t, s) {
+    return await c(this, a, l).call(this, "POST", T, {
+      body: JSON.stringify({
+        name: e,
+        ...t && { parentId: t },
+        ...s && { projectId: s }
+      }),
+      contentType: "application/json"
+    });
+  }
+  /**
+   * Renames a folder.
+   * @param folderId - The folder's unique identifier.
+   * @param updateFolderParams - New name for the folder.
+   * @returns The updated folder.
+   */
+  async updateFolder(e, t) {
+    const { name: s } = t;
+    return await c(this, a, l).call(this, "PUT", `${T}/${e}`, {
+      body: JSON.stringify({ name: s }),
+      contentType: "application/json"
+    });
+  }
+  /**
+   * Archives (soft-deletes) a folder. Can be recovered with {@link recoverFolder}.
+   * @param folderId - The folder's unique identifier.
+   */
+  async archiveFolder(e) {
+    return await c(this, a, l).call(this, "DELETE", `${T}/${e}`);
+  }
+  /**
+   * Recovers a previously archived folder.
+   * @param folderId - The folder's unique identifier.
+   */
+  async recoverFolder(e) {
+    return await c(this, a, l).call(this, "PUT", `${T}/${e}/recover`);
+  }
+  /**
+   * Downloads an entire folder as a ZIP archive.
+   * @param folderId - The folder's unique identifier.
+   * @returns A fetch Response containing the ZIP data.
+   */
+  async downloadFolder(e) {
+    return await c(this, a, S).call(this, `${T}/${e}/download`);
+  }
+  // ─── Components ──────────────────────────────────────────────────
+  /**
+   * Lists all components (tools) accessible by the current token.
+   * @param params - Optional filters for folder and version inclusion.
+   * @returns Array of component items.
+   */
+  async listComponents(e) {
+    const { folderId: t, ShowVersions: s, projectId: r } = e || {};
+    return t ? await c(this, a, l).call(this, "GET", `${T}/${t}/items`, {
+      query: {
+        itemType: Q,
+        ...s && { ShowVersions: s }
+      }
+    }) : await c(this, a, l).call(this, "GET", `${p}`, {
+      query: {
+        itemType: Q,
+        ...s && { ShowVersions: s },
+        ...r && { projectId: r }
+      }
+    });
+  }
+  /**
+   * Gets a single component by ID, optionally including version history.
+   * @param componentId - The component's unique identifier.
+   * @param props - Options such as whether to include versions.
+   */
+  async getComponent(e, t) {
+    return await c(this, a, he).call(this, e, t);
+  }
+  /**
+   * Creates a new component with the given file and version properties.
+   * @param componentData - File content, name, version tag, and component-specific props.
+   * @returns The created component item and its first version.
+   */
+  async createComponent(e) {
+    const { componentProps: t } = e;
+    return await c(this, a, M).call(this, e, Q, t);
+  }
+  /**
+   * Updates an existing component. Can rename, move, and/or upload a new version.
+   * @param componentId - The component's unique identifier.
+   * @param componentData - Properties to update, including optional new componentProps.
+   * @returns The updated item and/or new version.
+   */
+  async updateComponent(e, t) {
+    const { componentProps: s } = t;
+    return await c(this, a, ce).call(this, e, t, s);
+  }
+  /**
+   * Downloads a component's full ZIP file. Returns the raw fetch Response.
+   * @param componentId - The component's unique identifier.
+   * @param params - Optional version selection parameters.
+   * @returns A fetch Response containing the ZIP data.
+   */
+  async downloadComponent(e, t) {
+    return await c(this, a, V).call(this, e, t);
+  }
+  /**
+   * Downloads only the JavaScript bundle from a component's ZIP.
+   * This is the extracted `bundle` entry, returned as text.
+   * @param componentId - The component's unique identifier.
+   * @param params - Optional version selection parameters.
+   * @returns A fetch Response containing the bundle JavaScript text.
+   */
+  async downloadComponentBundle(e, t) {
+    const { versionTag: s, withDraft: r } = t || {};
+    return await c(this, a, S).call(this, `${p}/${e}/download/bundle`, {
+      query: {
+        ...s && { versionTag: s },
+        ...r && { withDraft: r }
+      }
+    });
+  }
+  /**
+   * Archives (soft-deletes) a component. Can be recovered with {@link recoverComponent}.
+   * @param componentId - The component's unique identifier.
+   */
+  async archiveComponent(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${e}`);
+  }
+  /**
+   * Recovers a previously archived component.
+   * @param componentId - The component's unique identifier.
+   */
+  async recoverComponent(e) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${e}/recover`);
+  }
+  // ─── Built-in Components ─────────────────────────────────────────
+  /**
+   * Fetches a built-in component's JavaScript bundle by name.
+   * @param name - The built-in component name (e.g. "hello-world").
+   * @returns The component's JavaScript source code as a string.
+   */
+  async getBuiltInComponent(e) {
+    return await (await c(this, a, S).call(this, `built-in/${e}/bundle`)).text();
+  }
+  /**
+   * Fetches a built-in component bundle, evaluates it, and registers it
+   * with the given `components` instance via `components.get()`.
+   *
+   * After calling this, retrieve the singleton instance with
+   * `components.get(ComponentClass)`.
+   *
+   * @param component - The component class stub (must have a static `uuid`).
+   * @param components - The OBC `Components` instance used to register the
+   *   component (must expose a `.get()` method).
+   * @param globals - Map of global names to values that the component source
+   *   expects in scope (e.g. `{ OBC, BUI }`). If omitted, falls back to
+   *   globals registered via {@link setBuiltInGlobals}, then to
+   *   `window.ThatOpenCompany`.
+   *
+   * @example
+   * ```ts
+   * // Option 1: register globals once, then init without passing them
+   * client.setBuiltInGlobals({ OBC, OBF, BUI, CUI, THREE, FRAGS });
+   * await client.initBuiltInComponent(AppManager, components);
+   * await client.initBuiltInComponent(ViewerToolbar, components);
+   *
+   * // Option 2: pass globals per component (still works)
+   * await client.initBuiltInComponent(HelloWorld, components, { OBC, BUI });
+   * ```
+   */
+  async initBuiltInComponent(e, t, s) {
+    const r = await this.getBuiltInComponent(e.uuid), i = s ?? this.builtInGlobals ?? (typeof window < "u" ? window.ThatOpenCompany : {}) ?? {}, o = Object.keys(i), h = o.map((m) => i[m]), y = new Function(...o, `${r}
+return main;`)(...h), d = (y == null ? void 0 : y.componentDefinition) ?? y;
+    t.get(d);
+  }
+  /**
+   * Loads multiple built-in components in parallel.
+   *
+   * Convenience wrapper around {@link initBuiltInComponent} that fetches
+   * and registers all given component stubs concurrently.
+   *
+   * @param components - The OBC `Components` instance.
+   * @param stubs - One or more component stubs (e.g. `AppManager`, `ViewportManager`).
+   *
+   * @example
+   * ```ts
+   * await client.initBuiltInComponents(components, AppManager, ViewportManager);
+   * ```
+   */
+  async initBuiltInComponents(e, ...t) {
+    await Promise.all(
+      t.map((s) => this.initBuiltInComponent(s, e))
+    );
+  }
+  /**
+   * High-level helper that creates an OBC component system, initialises BUI,
+   * loads built-in components, and starts the engine — all in one call.
+   *
+   * @param globals - Map of global names to module namespaces
+   *   (must include at least `OBC` and `BUI`).
+   * @param builtIns - Built-in component stubs to load (e.g. `AppManager`, `ViewportManager`).
+   * @returns An object containing the initialised `components` instance.
+   *
+   * @example
+   * ```ts
+   * const { components } = await client.setup(
+   *   { OBC, OBF, BUI, CUI, THREE, FRAGS },
+   *   AppManager, ViewportManager,
+   * );
+   *
+   * const viewports = components.get(ViewportManager);
+   * const { element, world } = await viewports.create();
+   * ```
+   */
+  async setup(e, ...t) {
+    var o, h;
+    const s = e.OBC, r = e.BUI;
+    if (!(s != null && s.Components))
+      throw new Error("globals.OBC must include Components");
+    if (!(r != null && r.Manager)) throw new Error("globals.BUI must include Manager");
+    const i = new s.Components();
+    return r.Manager.init(), this.setBuiltInGlobals(e), await this.initBuiltInComponents(i, ...t), i.init(), (h = (o = this.context.appEventOrchestrator) == null ? void 0 : o.appLoaded) == null || h.call(o), { components: i };
+  }
+  /**
+   * Reports an error to the platform via the {@link AppEventOrchestrator.appError} callback.
+   * @param code - Numeric error code.
+   * @param data - Arbitrary error data to send to the platform.
+   */
+  throwError(e, t) {
+    var s, r;
+    (r = (s = this.context.appEventOrchestrator) == null ? void 0 : s.appError) == null || r.call(s, e, t);
+  }
+  // ─── Apps ────────────────────────────────────────────────────────
+  /**
+   * Lists all apps accessible by the current token.
+   * @param params - Optional filters for folder and version inclusion.
+   * @returns Array of app items.
+   */
+  async listApps(e) {
+    const { folderId: t, ShowVersions: s, projectId: r } = e || {};
+    return t ? await c(this, a, l).call(this, "GET", `${T}/${t}/items`, {
+      query: {
+        itemType: Z,
+        ...s && { ShowVersions: s }
+      }
+    }) : await c(this, a, l).call(this, "GET", `${p}`, {
+      query: {
+        itemType: Z,
+        ...s && { ShowVersions: s },
+        ...r && { projectId: r }
+      }
+    });
+  }
+  /**
+   * Creates a new app with the given file and optional version properties.
+   * @param appData - File content, name, version tag, and optional app-specific props.
+   * @returns The created app item and its first version.
+   */
+  async createApp(e) {
+    const { appProps: t } = e;
+    return await c(this, a, M).call(this, e, Z, t);
+  }
+  /**
+   * Downloads an app's full ZIP file. Returns the raw fetch Response.
+   * @param appId - The app's unique identifier.
+   * @param params - Optional version selection parameters.
+   * @returns A fetch Response containing the ZIP data.
+   */
+  async downloadApp(e, t) {
+    return await c(this, a, V).call(this, e, t);
+  }
+  /**
+   * Downloads only the JavaScript bundle from an app's ZIP.
+   * This is the extracted `bundle` entry, returned as text.
+   * @param appId - The app's unique identifier.
+   * @param params - Optional version selection parameters.
+   * @returns A fetch Response containing the bundle JavaScript text.
+   */
+  async downloadAppBundle(e, t) {
+    const { versionTag: s, withDraft: r } = t || {};
+    return await c(this, a, S).call(this, `${p}/${e}/download/bundle`, {
+      query: {
+        ...s && { versionTag: s },
+        ...r && { withDraft: r }
+      }
+    });
+  }
+  /**
+   * Archives (soft-deletes) an app.
+   * @param appId - The app's unique identifier.
+   */
+  async archiveApp(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${e}`);
+  }
+  // ─── Execution ───────────────────────────────────────────────────
+  /**
+   * Triggers server-side execution of a cloud component.
+   *
+   * Pass `projectId` in `executionParams` when running the component in the
+   * context of a specific project. The backend validates that the component
+   * is linked to that project AND that the user has execute permission
+   * there; a foreign `projectId` is rejected with 403. Omit `projectId` for
+   * personal executions (ownership path).
+   *
+   * @param componentId - The component's unique identifier.
+   * @param executionParams - Arbitrary parameters passed to the component's `main()` function. Include `projectId` to scope the execution.
+   * @param versionTag - Optional version to execute (defaults to latest).
+   * @returns An object containing the `executionId` to track progress.
+   */
+  async executeComponent(e, t, s) {
+    if (this.localServerUrl) {
+      const r = `${this.localServerUrl}/api/${O}/${e}/execute`, i = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(t)
+      });
+      if (!i.ok) {
+        const o = await i.text().catch(() => "");
+        throw new Error(`Local server request failed: ${i.status} - ${o}`);
+      }
+      return await i.json();
+    }
+    return await c(this, a, l).call(this, "POST", `${O}/${e}/execute`, {
+      body: JSON.stringify(t),
+      query: { ...s && { versionTag: s } },
+      contentType: "application/json"
+    });
+  }
+  /**
+   * Aborts a running execution.
+   * @param executionId - The execution's unique identifier.
+   */
+  async abortExecution(e) {
+    if (this.localServerUrl) {
+      const t = `${this.localServerUrl}/api/${O}/progress/${e}/abort`, s = await fetch(t, { method: "POST" });
+      if (!s.ok) {
+        const r = await s.text().catch(() => "");
+        throw new Error(`Local server request failed: ${s.status} - ${r}`);
+      }
+      return await s.json();
+    }
+    return await c(this, a, l).call(this, "POST", `${O}/progress/${e}/abort`);
+  }
+  /**
+   * Lists all executions for a given component.
+   *
+   * When `projectId` is supplied, the backend scopes the query to that
+   * project — returning only executions launched in that context AND
+   * enforcing that the caller has access to the component there. Without
+   * `projectId`, the caller's personal executions for the component are
+   * returned.
+   *
+   * @param componentId - The component's unique identifier.
+   * @param projectId - Optional project scope.
+   * @returns Array of execution entities.
+   */
+  async listExecutions(e, t) {
+    if (this.localServerUrl) {
+      const s = t ? `?projectId=${encodeURIComponent(t)}` : "", r = `${this.localServerUrl}/api/${O}/${e}/progress${s}`, i = await fetch(r);
+      if (!i.ok) {
+        const o = await i.text().catch(() => "");
+        throw new Error(
+          `Local server request failed: ${i.status} - ${o}`
+        );
+      }
+      return await i.json();
+    }
+    return await c(this, a, l).call(this, "GET", `${O}/${e}/progress`, { query: { ...t && { projectId: t } } });
+  }
+  /**
+   * Gets details of a specific execution, including its messages.
+   * @param executionId - The execution's unique identifier.
+   * @returns The execution entity with progress and result info.
+   */
+  async getExecution(e) {
+    if (this.localServerUrl) {
+      const t = `${this.localServerUrl}/api/${O}/progress/${e}`, s = await fetch(t);
+      if (!s.ok) {
+        const r = await s.text().catch(() => "");
+        throw new Error(`Local server request failed: ${s.status} - ${r}`);
+      }
+      return await s.json();
+    }
+    return await c(this, a, l).call(this, "GET", `${O}/progress/${e}`);
+  }
+  /**
+   * Subscribes to real-time execution progress via WebSocket.
+   * The callback fires on each progress update until the execution completes.
+   * @param executionId - The execution's unique identifier.
+   * @param onUpdateCallback - Callback invoked on each progress/result event.
+   */
+  async onExecutionProgress(e, t) {
+    const s = this.localServerUrl ? `${this.localServerUrl}?accessToken=${this.accessToken}` : this.wsUrl, r = await F(s, {
+      ...this.localServerUrl && { transports: ["websocket"] }
+    });
+    r.on("connect", function() {
+      r.emit("executionSubscription", JSON.stringify({ executionId: e })), r.on("execution", (i) => {
+        t(i);
+      });
+    }), r.on("connect_error", function(i) {
+      console.log(i);
+    });
+  }
+  // ─── Hidden Files ────────────────────────────────────────────────
+  /**
+   * Creates a hidden file attached to a parent item (e.g., dependencies, assets).
+   * @param file - The file to upload.
+   * @param parentFileId - The parent item's unique identifier.
+   * @returns The hidden file ID.
+   */
+  async createHiddenFile(e, t) {
+    const s = new FormData();
+    return s.append("file", e), s.append("parentItemId", t), await c(this, a, l).call(this, "POST", `${p}/${R}`, {
+      body: s
+    });
+  }
+  /**
+   * Deletes a hidden file by its ID.
+   * @param hiddenId - The hidden file's unique identifier.
+   */
+  async deleteHiddenFile(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${R}/${e}`);
+  }
+  /**
+   * Gets metadata for a hidden file.
+   * @param hiddenId - The hidden file's unique identifier.
+   */
+  async getHiddenFile(e) {
+    return await c(this, a, l).call(this, "GET", `${p}/${R}/${e}`);
+  }
+  /**
+   * Downloads a hidden file's content. Returns the raw fetch Response.
+   * @param hiddenId - The hidden file's unique identifier.
+   */
+  async downloadHiddenFile(e) {
+    return await c(this, a, S).call(this, `${p}/${R}/${e}/download`);
+  }
+  /**
+   * Lists all hidden files attached to a parent item.
+   * @param parentFileId - The parent item's unique identifier.
+   * @returns Array of hidden file entities.
+   */
+  async getHiddenFilesByParent(e) {
+    return await c(this, a, l).call(this, "GET", `${p}/${e}/${R}`);
+  }
+  /**
+   * Deletes all hidden files attached to a parent item.
+   * @param parentFileId - The parent item's unique identifier.
+   */
+  async deleteHiddenFilesByParent(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${e}/${R}`);
+  }
+  // ─── Icons ───────────────────────────────────────────────────────
+  /**
+   * Uploads or replaces the icon for an item (app, component, or file).
+   * Accepts PNG, WebP, or ICO images up to 512 KB.
+   * @param itemId - The item's unique identifier.
+   * @param icon - The icon image file (File in browsers, Blob in Node.js).
+   * @returns The updated item with `iconFileId` and `iconMimeType` set.
+   */
+  async uploadItemIcon(e, t) {
+    const s = new FormData();
+    return s.append("icon", t), await c(this, a, l).call(this, "PUT", `${p}/${e}/icon`, { body: s });
+  }
+  /**
+   * Downloads the icon for an item as a binary stream.
+   * @param itemId - The item's unique identifier.
+   * @returns The raw Response (use `.blob()`, `.arrayBuffer()`, or pipe the body).
+   */
+  async getItemIcon(e) {
+    return await c(this, a, S).call(this, `${p}/${e}/icon`);
+  }
+  /**
+   * Removes the icon from an item.
+   * @param itemId - The item's unique identifier.
+   * @returns The updated item with icon fields removed.
+   */
+  async removeItemIcon(e) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${e}/icon`);
+  }
+  // ─── General Item Operations ─────────────────────────────────────
+  /**
+   * Renames or moves an item (file, component, or app) without creating a new version.
+   * @param itemId - The item's unique identifier.
+   * @param params - New name and/or new folder ID.
+   * @returns The updated item.
+   */
+  async updateItem(e, t) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${e}`, {
+      body: JSON.stringify(t),
+      contentType: "application/json"
+    });
+  }
+  /**
+   * Creates a new version of an item by uploading a new file.
+   * For APP and TOOL types, `extraProps` is required by the backend.
+   * @param itemId - The item's unique identifier.
+   * @param file - The new file to upload.
+   * @param versionTag - Version tag for the new version (e.g. "v2").
+   * @param extraProps - Version-specific properties (required for APP/TOOL types).
+   * @param metadata - Optional free-JSON metadata to store on the new version.
+   * @returns The created version.
+   */
+  async createVersion(e, t, s, r, i) {
+    const o = new FormData();
+    return o.append("file", t), o.append("versionTag", s), r && o.append("extraProps", JSON.stringify(r)), i && o.append("metadata", JSON.stringify(i)), await c(this, a, l).call(this, "POST", `${p}/${e}/version`, { body: o });
+  }
+  /**
+   * Lists versions of an item. Pass `archived: true` to fetch only archived
+   * versions, `false` to fetch only active ones, or omit to receive both.
+   * @param itemId - The item's unique identifier.
+   * @param params - Optional `{ archived }` filter.
+   * @returns Array of versions, sorted by creation date descending.
+   */
+  async listVersions(e, t = {}) {
+    return await c(this, a, l).call(this, "GET", `${p}/${encodeURIComponent(e)}/versions`, { query: t });
+  }
+  /**
+   * Archives a version of an item. Archived versions remain available via
+   * `listVersions({ archived: true })` and can be recovered or permanently
+   * deleted. Cleanup runs daily and removes archived versions older than the
+   * platform retention period.
+   * @param itemId - The item's unique identifier.
+   * @param versionTag - The version's tag (e.g. "v2").
+   * @returns The archived version.
+   */
+  async archiveVersion(e, t) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}/archive`);
+  }
+  /**
+   * Recovers a previously archived version, restoring it to the active list.
+   * @param itemId - The item's unique identifier.
+   * @param versionTag - The version's tag (e.g. "v2").
+   * @returns The recovered version.
+   */
+  async recoverVersion(e, t) {
+    return await c(this, a, l).call(this, "PUT", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}/recover`);
+  }
+  /**
+   * Permanently deletes a version, including its file in object storage.
+   * The version must be archived first; otherwise the call is rejected.
+   * @param itemId - The item's unique identifier.
+   * @param versionTag - The version's tag (e.g. "v2").
+   */
+  async deleteVersion(e, t) {
+    return await c(this, a, l).call(this, "DELETE", `${p}/${encodeURIComponent(e)}/version/${encodeURIComponent(t)}`);
+  }
+};
+a = new WeakSet(), ae = function(e) {
+  return `${this.apiUrl}/${e}`;
+}, l = async function(e, t, s) {
+  const { body: r, query: i, contentType: o, retries: h } = s || {}, u = c(this, a, ae).call(this, t), y = c(this, a, Ue).call(this, i), d = await this.resolveAccessToken(), m = {
+    ...y,
+    ...this.useBearer ? {} : { accessToken: d }
+  };
+  try {
+    const w = await fetch(
+      u + "?" + new URLSearchParams(m).toString(),
+      {
+        method: e,
+        headers: {
+          Accept: "application/json",
+          ...o && { "Content-Type": o },
+          ...this.useBearer && { Authorization: `Bearer ${d}` }
+        },
+        ...r && { body: r }
+      }
+    );
+    if (!w.ok) {
+      const A = await w.text().then((De) => De).catch(() => "");
+      throw new Lt(
+        w.status,
+        w.statusText,
+        A
+      );
+    }
+    return w.json().then((A) => A).catch(() => {
+    });
+  } catch (w) {
+    let A = h ?? this.retries;
+    if (A)
+      return A = A - 1, await c(this, a, l).call(this, e, t, {
+        ...s,
+        retries: A
+      });
+    throw w;
+  }
+}, S = async function(e, t) {
+  const { query: s } = t || {}, r = c(this, a, ae).call(this, e), i = await this.resolveAccessToken(), o = {
+    ...s,
+    ...this.useBearer ? {} : { accessToken: i }
+  };
+  return await fetch(
+    r + "?" + new URLSearchParams(o).toString(),
+    {
+      method: "GET",
+      ...this.useBearer && {
+        headers: { Authorization: `Bearer ${i}` }
+      }
+    }
+  );
+}, V = async function(e, t) {
+  const { versionTag: s, withDraft: r } = t || {};
+  return await c(this, a, S).call(this, `${p}/${e}/download`, {
+    query: {
+      ...s && { versionTag: s },
+      ...r && { withDraft: r }
+    }
+  });
+}, M = async function(e, t, s) {
+  const { name: r, versionTag: i, parentFolderId: o, projectId: h, file: u, metadata: y } = e, d = new FormData();
+  return d.append("file", u), d.append("name", r), d.append("versionTag", i), d.append("itemType", t), o && d.append("folderId", o), h && d.append("projectId", h), s && d.append("extraProps", JSON.stringify(s)), y && d.append("metadata", JSON.stringify(y)), await c(this, a, l).call(this, "POST", p, {
+    body: d
+  });
+}, ce = async function(e, t, s) {
+  const { name: r, versionTag: i, parentFolderId: o, file: h, metadata: u } = t;
+  let y, d;
+  if (h) {
+    const m = new FormData();
+    m.append("file", h), i && m.append("versionTag", i), s && m.append("extraProps", JSON.stringify(s)), u && m.append("metadata", JSON.stringify(u)), d = await c(this, a, l).call(this, "POST", `${p}/${e}/version`, {
+      body: m
+    });
+  }
+  if (r || o) {
+    const m = {
+      ...r && { name: r },
+      ...o && { folderId: o }
+    }, w = JSON.stringify(m);
+    y = await c(this, a, l).call(this, "PUT", `${p}/${e}`, {
+      body: w,
+      contentType: "application/json"
+    });
+  }
+  return { item: y, version: d };
+}, he = async function(e, t) {
+  const { showVersions: s = !1 } = t || {};
+  return await c(this, a, l).call(this, "GET", `${p}/${e}`, {
+    query: { showVersions: s }
+  });
+}, Ue = function(e) {
+  return e && Object.entries(e).filter(([, t]) => t !== void 0).reduce(
+    (t, [s, r]) => (t[s] = r, t),
+    {}
+  );
+};
+let oe = ye;
+const I = "project";
+var $;
+const me = class me extends oe {
+  /**
+   * @param token - A bearer JWT, OR a function returning the current JWT
+   *   (sync or async). When a function is passed, it's invoked before every
+   *   request — ideal for token-refreshing sources like Auth0.
+   * @param apiUrl - Base URL of the API (e.g. `https://api.thatopen.com`).
+   * @param props - Optional client configuration. `useBearer` is forced to
+   *   `true` and cannot be overridden.
+   */
+  constructor(t, s, r) {
+    super(typeof t == "string" ? t : "", s, { ...r, useBearer: !0 });
+    K(this, $);
+    typeof t == "function" && we(this, $, t);
+  }
+  async resolveAccessToken() {
+    return G(this, $) ? await G(this, $).call(this) : super.resolveAccessToken();
+  }
+  /**
+   * Creates a client from the platform context injected into
+   * `window.__THATOPEN_CONTEXT__` by the That Open Platform. Recommended
+   * entry point for apps running inside the platform's iframe — the context
+   * carries a fresh JWT on every navigation.
+   */
+  static fromPlatformContext(t) {
+    const s = (typeof window < "u" ? window.__THATOPEN_CONTEXT__ : null) || { appId: "", projectId: "", accessToken: "", apiUrl: "" }, r = new me(s.accessToken, s.apiUrl, t);
+    return r.context = s, r;
+  }
+  // ─── Projects (JWT-only backend routes) ──────────────────────────
+  /**
+   * Gets a project by ID. JWT-only — lives here because
+   * `GET /project/:id` is guarded by `AccountActiveGuard + ProjectAccessGuard`.
+   */
+  async getProject(t) {
+    return await this.request("GET", `${I}/${t}`);
+  }
+  /**
+   * Gets the full project data (users, roles, files, folders) for a project.
+   * User data is stripped of sensitive fields server-side.
+   */
+  async getProjectData(t) {
+    return await this.request(
+      "GET",
+      `${I}/${t}/data`
+    );
+  }
+  // ─── Permissions (JWT-only backend routes) ───────────────────────
+  /**
+   * Checks whether the caller has a specific permission within a project.
+   * Returns `{ hasPermission, scope }` where `scope` is `'global'` for
+   * admin/owner, `'project'` for a role broad grant, `'entity'` for a
+   * per-entity override, `'none'` for denied.
+   */
+  async checkPermission(t) {
+    return await this.request(
+      "GET",
+      `${I}/permissions/check`,
+      { query: t }
+    );
+  }
+  /**
+   * Batch variant of {@link checkPermission}. Evaluates multiple checks in a
+   * single round-trip; results come back in the same order as `checks`.
+   */
+  async checkPermissionBatch(t) {
+    return (await this.request("POST", `${I}/permissions/check/batch`, {
+      body: JSON.stringify({ checks: t }),
+      contentType: "application/json"
+    })).results;
+  }
+};
+$ = new WeakMap();
+let ke = me;
+const Ut = {
+  MAX_FIELDS: 200,
+  MAX_KEY_LENGTH: 50,
+  MAX_VALUE_LENGTH: 50
+}, Dt = { uuid: "2e32d873-02c9-421c-8743-d8a5ca6ad38a" }, Ft = { uuid: "b0b5e2a2-0b3a-4a6b-8b1c-0b1c4a6b8b1c" }, Vt = { uuid: "2c4ae432-fc24-43e9-9783-0c960c674e96" }, Mt = { uuid: "3c2a9f34-8b6c-4d1b-8f7a-1e4a5b2c9f08" }, Ht = { uuid: "234f1416-528d-452a-9cc9-a16c5239b2eb" }, Jt = { uuid: "def81d43-6b44-4f4a-9c08-7649486112a4" };
+export {
+  Dt as AppManager,
+  oe as EngineServicesClient,
+  Ft as FileList,
+  Vt as HelloWorld,
+  Ut as METADATA_LIMITS,
+  ke as PlatformClient,
+  Lt as RequestError,
+  Mt as TabbedNavigation,
+  Ht as UIManager,
+  Jt as ViewportsManager
+};