@aiqa/sdk 0.0.1 → 0.0.2

package/dist/aiqa-sdk.browser.js

@@ -1,3617 +0,0 @@
-var AiQaSdk = (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    default: () => src_default
-  });
-
-  // node_modules/engine.io-parser/build/esm/commons.js
-  var PACKET_TYPES = /* @__PURE__ */ Object.create(null);
-  PACKET_TYPES["open"] = "0";
-  PACKET_TYPES["close"] = "1";
-  PACKET_TYPES["ping"] = "2";
-  PACKET_TYPES["pong"] = "3";
-  PACKET_TYPES["message"] = "4";
-  PACKET_TYPES["upgrade"] = "5";
-  PACKET_TYPES["noop"] = "6";
-  var PACKET_TYPES_REVERSE = /* @__PURE__ */ Object.create(null);
-  Object.keys(PACKET_TYPES).forEach((key) => {
-    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
-  });
-  var ERROR_PACKET = { type: "error", data: "parser error" };
-
-  // node_modules/engine.io-parser/build/esm/encodePacket.browser.js
-  var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]";
-  var withNativeArrayBuffer = typeof ArrayBuffer === "function";
-  var isView = (obj) => {
-    return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer;
-  };
-  var encodePacket = ({ type, data }, supportsBinary, callback) => {
-    if (withNativeBlob && data instanceof Blob) {
-      if (supportsBinary) {
-        return callback(data);
-      } else {
-        return encodeBlobAsBase64(data, callback);
-      }
-    } else if (withNativeArrayBuffer && (data instanceof ArrayBuffer || isView(data))) {
-      if (supportsBinary) {
-        return callback(data);
-      } else {
-        return encodeBlobAsBase64(new Blob([data]), callback);
-      }
-    }
-    return callback(PACKET_TYPES[type] + (data || ""));
-  };
-  var encodeBlobAsBase64 = (data, callback) => {
-    const fileReader = new FileReader();
-    fileReader.onload = function() {
-      const content = fileReader.result.split(",")[1];
-      callback("b" + (content || ""));
-    };
-    return fileReader.readAsDataURL(data);
-  };
-  function toArray(data) {
-    if (data instanceof Uint8Array) {
-      return data;
-    } else if (data instanceof ArrayBuffer) {
-      return new Uint8Array(data);
-    } else {
-      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-    }
-  }
-  var TEXT_ENCODER;
-  function encodePacketToBinary(packet, callback) {
-    if (withNativeBlob && packet.data instanceof Blob) {
-      return packet.data.arrayBuffer().then(toArray).then(callback);
-    } else if (withNativeArrayBuffer && (packet.data instanceof ArrayBuffer || isView(packet.data))) {
-      return callback(toArray(packet.data));
-    }
-    encodePacket(packet, false, (encoded) => {
-      if (!TEXT_ENCODER) {
-        TEXT_ENCODER = new TextEncoder();
-      }
-      callback(TEXT_ENCODER.encode(encoded));
-    });
-  }
-
-  // node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js
-  var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
-  for (let i2 = 0; i2 < chars.length; i2++) {
-    lookup[chars.charCodeAt(i2)] = i2;
-  }
-  var decode = (base64) => {
-    let bufferLength = base64.length * 0.75, len = base64.length, i2, p = 0, encoded1, encoded2, encoded3, encoded4;
-    if (base64[base64.length - 1] === "=") {
-      bufferLength--;
-      if (base64[base64.length - 2] === "=") {
-        bufferLength--;
-      }
-    }
-    const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
-    for (i2 = 0; i2 < len; i2 += 4) {
-      encoded1 = lookup[base64.charCodeAt(i2)];
-      encoded2 = lookup[base64.charCodeAt(i2 + 1)];
-      encoded3 = lookup[base64.charCodeAt(i2 + 2)];
-      encoded4 = lookup[base64.charCodeAt(i2 + 3)];
-      bytes[p++] = encoded1 << 2 | encoded2 >> 4;
-      bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
-      bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
-    }
-    return arraybuffer;
-  };
-
-  // node_modules/engine.io-parser/build/esm/decodePacket.browser.js
-  var withNativeArrayBuffer2 = typeof ArrayBuffer === "function";
-  var decodePacket = (encodedPacket, binaryType) => {
-    if (typeof encodedPacket !== "string") {
-      return {
-        type: "message",
-        data: mapBinary(encodedPacket, binaryType)
-      };
-    }
-    const type = encodedPacket.charAt(0);
-    if (type === "b") {
-      return {
-        type: "message",
-        data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
-      };
-    }
-    const packetType = PACKET_TYPES_REVERSE[type];
-    if (!packetType) {
-      return ERROR_PACKET;
-    }
-    return encodedPacket.length > 1 ? {
-      type: PACKET_TYPES_REVERSE[type],
-      data: encodedPacket.substring(1)
-    } : {
-      type: PACKET_TYPES_REVERSE[type]
-    };
-  };
-  var decodeBase64Packet = (data, binaryType) => {
-    if (withNativeArrayBuffer2) {
-      const decoded = decode(data);
-      return mapBinary(decoded, binaryType);
-    } else {
-      return { base64: true, data };
-    }
-  };
-  var mapBinary = (data, binaryType) => {
-    switch (binaryType) {
-      case "blob":
-        if (data instanceof Blob) {
-          return data;
-        } else {
-          return new Blob([data]);
-        }
-      case "arraybuffer":
-      default:
-        if (data instanceof ArrayBuffer) {
-          return data;
-        } else {
-          return data.buffer;
-        }
-    }
-  };
-
-  // node_modules/engine.io-parser/build/esm/index.js
-  var SEPARATOR = String.fromCharCode(30);
-  var encodePayload = (packets, callback) => {
-    const length2 = packets.length;
-    const encodedPackets = new Array(length2);
-    let count = 0;
-    packets.forEach((packet, i2) => {
-      encodePacket(packet, false, (encodedPacket) => {
-        encodedPackets[i2] = encodedPacket;
-        if (++count === length2) {
-          callback(encodedPackets.join(SEPARATOR));
-        }
-      });
-    });
-  };
-  var decodePayload = (encodedPayload, binaryType) => {
-    const encodedPackets = encodedPayload.split(SEPARATOR);
-    const packets = [];
-    for (let i2 = 0; i2 < encodedPackets.length; i2++) {
-      const decodedPacket = decodePacket(encodedPackets[i2], binaryType);
-      packets.push(decodedPacket);
-      if (decodedPacket.type === "error") {
-        break;
-      }
-    }
-    return packets;
-  };
-  function createPacketEncoderStream() {
-    return new TransformStream({
-      transform(packet, controller) {
-        encodePacketToBinary(packet, (encodedPacket) => {
-          const payloadLength = encodedPacket.length;
-          let header;
-          if (payloadLength < 126) {
-            header = new Uint8Array(1);
-            new DataView(header.buffer).setUint8(0, payloadLength);
-          } else if (payloadLength < 65536) {
-            header = new Uint8Array(3);
-            const view = new DataView(header.buffer);
-            view.setUint8(0, 126);
-            view.setUint16(1, payloadLength);
-          } else {
-            header = new Uint8Array(9);
-            const view = new DataView(header.buffer);
-            view.setUint8(0, 127);
-            view.setBigUint64(1, BigInt(payloadLength));
-          }
-          if (packet.data && typeof packet.data !== "string") {
-            header[0] |= 128;
-          }
-          controller.enqueue(header);
-          controller.enqueue(encodedPacket);
-        });
-      }
-    });
-  }
-  var TEXT_DECODER;
-  function totalLength(chunks) {
-    return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-  }
-  function concatChunks(chunks, size) {
-    if (chunks[0].length === size) {
-      return chunks.shift();
-    }
-    const buffer = new Uint8Array(size);
-    let j = 0;
-    for (let i2 = 0; i2 < size; i2++) {
-      buffer[i2] = chunks[0][j++];
-      if (j === chunks[0].length) {
-        chunks.shift();
-        j = 0;
-      }
-    }
-    if (chunks.length && j < chunks[0].length) {
-      chunks[0] = chunks[0].slice(j);
-    }
-    return buffer;
-  }
-  function createPacketDecoderStream(maxPayload, binaryType) {
-    if (!TEXT_DECODER) {
-      TEXT_DECODER = new TextDecoder();
-    }
-    const chunks = [];
-    let state = 0;
-    let expectedLength = -1;
-    let isBinary2 = false;
-    return new TransformStream({
-      transform(chunk, controller) {
-        chunks.push(chunk);
-        while (true) {
-          if (state === 0) {
-            if (totalLength(chunks) < 1) {
-              break;
-            }
-            const header = concatChunks(chunks, 1);
-            isBinary2 = (header[0] & 128) === 128;
-            expectedLength = header[0] & 127;
-            if (expectedLength < 126) {
-              state = 3;
-            } else if (expectedLength === 126) {
-              state = 1;
-            } else {
-              state = 2;
-            }
-          } else if (state === 1) {
-            if (totalLength(chunks) < 2) {
-              break;
-            }
-            const headerArray = concatChunks(chunks, 2);
-            expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
-            state = 3;
-          } else if (state === 2) {
-            if (totalLength(chunks) < 8) {
-              break;
-            }
-            const headerArray = concatChunks(chunks, 8);
-            const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
-            const n = view.getUint32(0);
-            if (n > Math.pow(2, 53 - 32) - 1) {
-              controller.enqueue(ERROR_PACKET);
-              break;
-            }
-            expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
-            state = 3;
-          } else {
-            if (totalLength(chunks) < expectedLength) {
-              break;
-            }
-            const data = concatChunks(chunks, expectedLength);
-            controller.enqueue(decodePacket(isBinary2 ? data : TEXT_DECODER.decode(data), binaryType));
-            state = 0;
-          }
-          if (expectedLength === 0 || expectedLength > maxPayload) {
-            controller.enqueue(ERROR_PACKET);
-            break;
-          }
-        }
-      }
-    });
-  }
-  var protocol = 4;
-
-  // node_modules/@socket.io/component-emitter/lib/esm/index.js
-  function Emitter(obj) {
-    if (obj) return mixin(obj);
-  }
-  function mixin(obj) {
-    for (var key in Emitter.prototype) {
-      obj[key] = Emitter.prototype[key];
-    }
-    return obj;
-  }
-  Emitter.prototype.on = Emitter.prototype.addEventListener = function(event, fn) {
-    this._callbacks = this._callbacks || {};
-    (this._callbacks["$" + event] = this._callbacks["$" + event] || []).push(fn);
-    return this;
-  };
-  Emitter.prototype.once = function(event, fn) {
-    function on2() {
-      this.off(event, on2);
-      fn.apply(this, arguments);
-    }
-    on2.fn = fn;
-    this.on(event, on2);
-    return this;
-  };
-  Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function(event, fn) {
-    this._callbacks = this._callbacks || {};
-    if (0 == arguments.length) {
-      this._callbacks = {};
-      return this;
-    }
-    var callbacks = this._callbacks["$" + event];
-    if (!callbacks) return this;
-    if (1 == arguments.length) {
-      delete this._callbacks["$" + event];
-      return this;
-    }
-    var cb;
-    for (var i2 = 0; i2 < callbacks.length; i2++) {
-      cb = callbacks[i2];
-      if (cb === fn || cb.fn === fn) {
-        callbacks.splice(i2, 1);
-        break;
-      }
-    }
-    if (callbacks.length === 0) {
-      delete this._callbacks["$" + event];
-    }
-    return this;
-  };
-  Emitter.prototype.emit = function(event) {
-    this._callbacks = this._callbacks || {};
-    var args = new Array(arguments.length - 1), callbacks = this._callbacks["$" + event];
-    for (var i2 = 1; i2 < arguments.length; i2++) {
-      args[i2 - 1] = arguments[i2];
-    }
-    if (callbacks) {
-      callbacks = callbacks.slice(0);
-      for (var i2 = 0, len = callbacks.length; i2 < len; ++i2) {
-        callbacks[i2].apply(this, args);
-      }
-    }
-    return this;
-  };
-  Emitter.prototype.emitReserved = Emitter.prototype.emit;
-  Emitter.prototype.listeners = function(event) {
-    this._callbacks = this._callbacks || {};
-    return this._callbacks["$" + event] || [];
-  };
-  Emitter.prototype.hasListeners = function(event) {
-    return !!this.listeners(event).length;
-  };
-
-  // node_modules/engine.io-client/build/esm/globalThis.browser.js
-  var globalThisShim = (() => {
-    if (typeof self !== "undefined") {
-      return self;
-    } else if (typeof window !== "undefined") {
-      return window;
-    } else {
-      return Function("return this")();
-    }
-  })();
-
-  // node_modules/engine.io-client/build/esm/util.js
-  function pick(obj, ...attr) {
-    return attr.reduce((acc, k) => {
-      if (obj.hasOwnProperty(k)) {
-        acc[k] = obj[k];
-      }
-      return acc;
-    }, {});
-  }
-  var NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
-  var NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
-  function installTimerFunctions(obj, opts) {
-    if (opts.useNativeTimers) {
-      obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
-      obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
-    } else {
-      obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim);
-      obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
-    }
-  }
-  var BASE64_OVERHEAD = 1.33;
-  function byteLength(obj) {
-    if (typeof obj === "string") {
-      return utf8Length(obj);
-    }
-    return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
-  }
-  function utf8Length(str) {
-    let c = 0, length2 = 0;
-    for (let i2 = 0, l = str.length; i2 < l; i2++) {
-      c = str.charCodeAt(i2);
-      if (c < 128) {
-        length2 += 1;
-      } else if (c < 2048) {
-        length2 += 2;
-      } else if (c < 55296 || c >= 57344) {
-        length2 += 3;
-      } else {
-        i2++;
-        length2 += 4;
-      }
-    }
-    return length2;
-  }
-
-  // node_modules/engine.io-client/build/esm/contrib/parseqs.js
-  function encode(obj) {
-    let str = "";
-    for (let i2 in obj) {
-      if (obj.hasOwnProperty(i2)) {
-        if (str.length)
-          str += "&";
-        str += encodeURIComponent(i2) + "=" + encodeURIComponent(obj[i2]);
-      }
-    }
-    return str;
-  }
-  function decode2(qs) {
-    let qry = {};
-    let pairs = qs.split("&");
-    for (let i2 = 0, l = pairs.length; i2 < l; i2++) {
-      let pair = pairs[i2].split("=");
-      qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
-    }
-    return qry;
-  }
-
-  // node_modules/engine.io-client/build/esm/transport.js
-  var TransportError = class extends Error {
-    constructor(reason, description, context) {
-      super(reason);
-      this.description = description;
-      this.context = context;
-      this.type = "TransportError";
-    }
-  };
-  var Transport = class extends Emitter {
-    /**
-     * Transport abstract constructor.
-     *
-     * @param {Object} opts - options
-     * @protected
-     */
-    constructor(opts) {
-      super();
-      this.writable = false;
-      installTimerFunctions(this, opts);
-      this.opts = opts;
-      this.query = opts.query;
-      this.socket = opts.socket;
-    }
-    /**
-     * Emits an error.
-     *
-     * @param {String} reason
-     * @param description
-     * @param context - the error context
-     * @return {Transport} for chaining
-     * @protected
-     */
-    onError(reason, description, context) {
-      super.emitReserved("error", new TransportError(reason, description, context));
-      return this;
-    }
-    /**
-     * Opens the transport.
-     */
-    open() {
-      this.readyState = "opening";
-      this.doOpen();
-      return this;
-    }
-    /**
-     * Closes the transport.
-     */
-    close() {
-      if (this.readyState === "opening" || this.readyState === "open") {
-        this.doClose();
-        this.onClose();
-      }
-      return this;
-    }
-    /**
-     * Sends multiple packets.
-     *
-     * @param {Array} packets
-     */
-    send(packets) {
-      if (this.readyState === "open") {
-        this.write(packets);
-      } else {
-      }
-    }
-    /**
-     * Called upon open
-     *
-     * @protected
-     */
-    onOpen() {
-      this.readyState = "open";
-      this.writable = true;
-      super.emitReserved("open");
-    }
-    /**
-     * Called with data.
-     *
-     * @param {String} data
-     * @protected
-     */
-    onData(data) {
-      const packet = decodePacket(data, this.socket.binaryType);
-      this.onPacket(packet);
-    }
-    /**
-     * Called with a decoded packet.
-     *
-     * @protected
-     */
-    onPacket(packet) {
-      super.emitReserved("packet", packet);
-    }
-    /**
-     * Called upon close.
-     *
-     * @protected
-     */
-    onClose(details) {
-      this.readyState = "closed";
-      super.emitReserved("close", details);
-    }
-    /**
-     * Pauses the transport, in order not to lose packets during an upgrade.
-     *
-     * @param onPause
-     */
-    pause(onPause) {
-    }
-    createUri(schema, query = {}) {
-      return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query);
-    }
-    _hostname() {
-      const hostname = this.opts.hostname;
-      return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
-    }
-    _port() {
-      if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) {
-        return ":" + this.opts.port;
-      } else {
-        return "";
-      }
-    }
-    _query(query) {
-      const encodedQuery = encode(query);
-      return encodedQuery.length ? "?" + encodedQuery : "";
-    }
-  };
-
-  // node_modules/engine.io-client/build/esm/contrib/yeast.js
-  var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split("");
-  var length = 64;
-  var map = {};
-  var seed = 0;
-  var i = 0;
-  var prev;
-  function encode2(num) {
-    let encoded = "";
-    do {
-      encoded = alphabet[num % length] + encoded;
-      num = Math.floor(num / length);
-    } while (num > 0);
-    return encoded;
-  }
-  function yeast() {
-    const now = encode2(+/* @__PURE__ */ new Date());
-    if (now !== prev)
-      return seed = 0, prev = now;
-    return now + "." + encode2(seed++);
-  }
-  for (; i < length; i++)
-    map[alphabet[i]] = i;
-
-  // node_modules/engine.io-client/build/esm/contrib/has-cors.js
-  var value = false;
-  try {
-    value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
-  } catch (err) {
-  }
-  var hasCORS = value;
-
-  // node_modules/engine.io-client/build/esm/transports/xmlhttprequest.browser.js
-  function XHR(opts) {
-    const xdomain = opts.xdomain;
-    try {
-      if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {
-        return new XMLHttpRequest();
-      }
-    } catch (e) {
-    }
-    if (!xdomain) {
-      try {
-        return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
-      } catch (e) {
-      }
-    }
-  }
-  function createCookieJar() {
-  }
-
-  // node_modules/engine.io-client/build/esm/transports/polling.js
-  function empty() {
-  }
-  var hasXHR2 = function() {
-    const xhr = new XHR({
-      xdomain: false
-    });
-    return null != xhr.responseType;
-  }();
-  var Polling = class extends Transport {
-    /**
-     * XHR Polling constructor.
-     *
-     * @param {Object} opts
-     * @package
-     */
-    constructor(opts) {
-      super(opts);
-      this.polling = false;
-      if (typeof location !== "undefined") {
-        const isSSL = "https:" === location.protocol;
-        let port = location.port;
-        if (!port) {
-          port = isSSL ? "443" : "80";
-        }
-        this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port;
-      }
-      const forceBase64 = opts && opts.forceBase64;
-      this.supportsBinary = hasXHR2 && !forceBase64;
-      if (this.opts.withCredentials) {
-        this.cookieJar = createCookieJar();
-      }
-    }
-    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(onPause) {
-      this.readyState = "pausing";
-      const pause = () => {
-        this.readyState = "paused";
-        onPause();
-      };
-      if (this.polling || !this.writable) {
-        let total = 0;
-        if (this.polling) {
-          total++;
-          this.once("pollComplete", function() {
-            --total || pause();
-          });
-        }
-        if (!this.writable) {
-          total++;
-          this.once("drain", function() {
-            --total || pause();
-          });
-        }
-      } else {
-        pause();
-      }
-    }
-    /**
-     * Starts polling cycle.
-     *
-     * @private
-     */
-    poll() {
-      this.polling = true;
-      this.doPoll();
-      this.emitReserved("poll");
-    }
-    /**
-     * Overloads onData to detect payloads.
-     *
-     * @protected
-     */
-    onData(data) {
-      const callback = (packet) => {
-        if ("opening" === this.readyState && packet.type === "open") {
-          this.onOpen();
-        }
-        if ("close" === packet.type) {
-          this.onClose({ description: "transport closed by the server" });
-          return false;
-        }
-        this.onPacket(packet);
-      };
-      decodePayload(data, this.socket.binaryType).forEach(callback);
-      if ("closed" !== this.readyState) {
-        this.polling = false;
-        this.emitReserved("pollComplete");
-        if ("open" === this.readyState) {
-          this.poll();
-        } else {
-        }
-      }
-    }
-    /**
-     * For polling, send a close packet.
-     *
-     * @protected
-     */
-    doClose() {
-      const close = () => {
-        this.write([{ type: "close" }]);
-      };
-      if ("open" === this.readyState) {
-        close();
-      } else {
-        this.once("open", close);
-      }
-    }
-    /**
-     * Writes a packets payload.
-     *
-     * @param {Array} packets - data packets
-     * @protected
-     */
-    write(packets) {
-      this.writable = false;
-      encodePayload(packets, (data) => {
-        this.doWrite(data, () => {
-          this.writable = true;
-          this.emitReserved("drain");
-        });
-      });
-    }
-    /**
-     * Generates uri for connection.
-     *
-     * @private
-     */
-    uri() {
-      const schema = this.opts.secure ? "https" : "http";
-      const query = this.query || {};
-      if (false !== this.opts.timestampRequests) {
-        query[this.opts.timestampParam] = yeast();
-      }
-      if (!this.supportsBinary && !query.sid) {
-        query.b64 = 1;
-      }
-      return this.createUri(schema, query);
-    }
-    /**
-     * Creates a request.
-     *
-     * @param {String} method
-     * @private
-     */
-    request(opts = {}) {
-      Object.assign(opts, { xd: this.xd, cookieJar: this.cookieJar }, this.opts);
-      return new Request(this.uri(), opts);
-    }
-    /**
-     * Sends data.
-     *
-     * @param {String} data to send.
-     * @param {Function} called upon flush.
-     * @private
-     */
-    doWrite(data, fn) {
-      const req = this.request({
-        method: "POST",
-        data
-      });
-      req.on("success", fn);
-      req.on("error", (xhrStatus, context) => {
-        this.onError("xhr post error", xhrStatus, context);
-      });
-    }
-    /**
-     * Starts a poll cycle.
-     *
-     * @private
-     */
-    doPoll() {
-      const req = this.request();
-      req.on("data", this.onData.bind(this));
-      req.on("error", (xhrStatus, context) => {
-        this.onError("xhr poll error", xhrStatus, context);
-      });
-      this.pollXhr = req;
-    }
-  };
-  var Request = class _Request extends Emitter {
-    /**
-     * Request constructor
-     *
-     * @param {Object} options
-     * @package
-     */
-    constructor(uri, opts) {
-      super();
-      installTimerFunctions(this, opts);
-      this.opts = opts;
-      this.method = opts.method || "GET";
-      this.uri = uri;
-      this.data = void 0 !== opts.data ? opts.data : null;
-      this.create();
-    }
-    /**
-     * Creates the XHR object and sends the request.
-     *
-     * @private
-     */
-    create() {
-      var _a;
-      const opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
-      opts.xdomain = !!this.opts.xd;
-      const xhr = this.xhr = new XHR(opts);
-      try {
-        xhr.open(this.method, this.uri, true);
-        try {
-          if (this.opts.extraHeaders) {
-            xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
-            for (let i2 in this.opts.extraHeaders) {
-              if (this.opts.extraHeaders.hasOwnProperty(i2)) {
-                xhr.setRequestHeader(i2, this.opts.extraHeaders[i2]);
-              }
-            }
-          }
-        } catch (e) {
-        }
-        if ("POST" === this.method) {
-          try {
-            xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
-          } catch (e) {
-          }
-        }
-        try {
-          xhr.setRequestHeader("Accept", "*/*");
-        } catch (e) {
-        }
-        (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
-        if ("withCredentials" in xhr) {
-          xhr.withCredentials = this.opts.withCredentials;
-        }
-        if (this.opts.requestTimeout) {
-          xhr.timeout = this.opts.requestTimeout;
-        }
-        xhr.onreadystatechange = () => {
-          var _a2;
-          if (xhr.readyState === 3) {
-            (_a2 = this.opts.cookieJar) === null || _a2 === void 0 ? void 0 : _a2.parseCookies(xhr);
-          }
-          if (4 !== xhr.readyState)
-            return;
-          if (200 === xhr.status || 1223 === xhr.status) {
-            this.onLoad();
-          } else {
-            this.setTimeoutFn(() => {
-              this.onError(typeof xhr.status === "number" ? xhr.status : 0);
-            }, 0);
-          }
-        };
-        xhr.send(this.data);
-      } catch (e) {
-        this.setTimeoutFn(() => {
-          this.onError(e);
-        }, 0);
-        return;
-      }
-      if (typeof document !== "undefined") {
-        this.index = _Request.requestsCount++;
-        _Request.requests[this.index] = this;
-      }
-    }
-    /**
-     * Called upon error.
-     *
-     * @private
-     */
-    onError(err) {
-      this.emitReserved("error", err, this.xhr);
-      this.cleanup(true);
-    }
-    /**
-     * Cleans up house.
-     *
-     * @private
-     */
-    cleanup(fromError) {
-      if ("undefined" === typeof this.xhr || null === this.xhr) {
-        return;
-      }
-      this.xhr.onreadystatechange = empty;
-      if (fromError) {
-        try {
-          this.xhr.abort();
-        } catch (e) {
-        }
-      }
-      if (typeof document !== "undefined") {
-        delete _Request.requests[this.index];
-      }
-      this.xhr = null;
-    }
-    /**
-     * Called upon load.
-     *
-     * @private
-     */
-    onLoad() {
-      const data = this.xhr.responseText;
-      if (data !== null) {
-        this.emitReserved("data", data);
-        this.emitReserved("success");
-        this.cleanup();
-      }
-    }
-    /**
-     * Aborts the request.
-     *
-     * @package
-     */
-    abort() {
-      this.cleanup();
-    }
-  };
-  Request.requestsCount = 0;
-  Request.requests = {};
-  if (typeof document !== "undefined") {
-    if (typeof attachEvent === "function") {
-      attachEvent("onunload", unloadHandler);
-    } else if (typeof addEventListener === "function") {
-      const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
-      addEventListener(terminationEvent, unloadHandler, false);
-    }
-  }
-  function unloadHandler() {
-    for (let i2 in Request.requests) {
-      if (Request.requests.hasOwnProperty(i2)) {
-        Request.requests[i2].abort();
-      }
-    }
-  }
-
-  // node_modules/engine.io-client/build/esm/transports/websocket-constructor.browser.js
-  var nextTick = (() => {
-    const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
-    if (isPromiseAvailable) {
-      return (cb) => Promise.resolve().then(cb);
-    } else {
-      return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
-    }
-  })();
-  var WebSocket = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
-  var usingBrowserWebSocket = true;
-  var defaultBinaryType = "arraybuffer";
-
-  // node_modules/engine.io-client/build/esm/transports/websocket.js
-  var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
-  var WS = class extends Transport {
-    /**
-     * WebSocket transport constructor.
-     *
-     * @param {Object} opts - connection options
-     * @protected
-     */
-    constructor(opts) {
-      super(opts);
-      this.supportsBinary = !opts.forceBase64;
-    }
-    get name() {
-      return "websocket";
-    }
-    doOpen() {
-      if (!this.check()) {
-        return;
-      }
-      const uri = this.uri();
-      const protocols = this.opts.protocols;
-      const opts = isReactNative ? {} : pick(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
-      if (this.opts.extraHeaders) {
-        opts.headers = this.opts.extraHeaders;
-      }
-      try {
-        this.ws = usingBrowserWebSocket && !isReactNative ? protocols ? new WebSocket(uri, protocols) : new WebSocket(uri) : new WebSocket(uri, protocols, opts);
-      } catch (err) {
-        return this.emitReserved("error", err);
-      }
-      this.ws.binaryType = this.socket.binaryType;
-      this.addEventListeners();
-    }
-    /**
-     * Adds event listeners to the socket
-     *
-     * @private
-     */
-    addEventListeners() {
-      this.ws.onopen = () => {
-        if (this.opts.autoUnref) {
-          this.ws._socket.unref();
-        }
-        this.onOpen();
-      };
-      this.ws.onclose = (closeEvent) => this.onClose({
-        description: "websocket connection closed",
-        context: closeEvent
-      });
-      this.ws.onmessage = (ev) => this.onData(ev.data);
-      this.ws.onerror = (e) => this.onError("websocket error", e);
-    }
-    write(packets) {
-      this.writable = false;
-      for (let i2 = 0; i2 < packets.length; i2++) {
-        const packet = packets[i2];
-        const lastPacket = i2 === packets.length - 1;
-        encodePacket(packet, this.supportsBinary, (data) => {
-          const opts = {};
-          if (!usingBrowserWebSocket) {
-            if (packet.options) {
-              opts.compress = packet.options.compress;
-            }
-            if (this.opts.perMessageDeflate) {
-              const len = (
-                // @ts-ignore
-                "string" === typeof data ? Buffer.byteLength(data) : data.length
-              );
-              if (len < this.opts.perMessageDeflate.threshold) {
-                opts.compress = false;
-              }
-            }
-          }
-          try {
-            if (usingBrowserWebSocket) {
-              this.ws.send(data);
-            } else {
-              this.ws.send(data, opts);
-            }
-          } catch (e) {
-          }
-          if (lastPacket) {
-            nextTick(() => {
-              this.writable = true;
-              this.emitReserved("drain");
-            }, this.setTimeoutFn);
-          }
-        });
-      }
-    }
-    doClose() {
-      if (typeof this.ws !== "undefined") {
-        this.ws.close();
-        this.ws = null;
-      }
-    }
-    /**
-     * Generates uri for connection.
-     *
-     * @private
-     */
-    uri() {
-      const schema = this.opts.secure ? "wss" : "ws";
-      const query = this.query || {};
-      if (this.opts.timestampRequests) {
-        query[this.opts.timestampParam] = yeast();
-      }
-      if (!this.supportsBinary) {
-        query.b64 = 1;
-      }
-      return this.createUri(schema, query);
-    }
-    /**
-     * Feature detection for WebSocket.
-     *
-     * @return {Boolean} whether this transport is available.
-     * @private
-     */
-    check() {
-      return !!WebSocket;
-    }
-  };
-
-  // node_modules/engine.io-client/build/esm/transports/webtransport.js
-  var WT = class extends Transport {
-    get name() {
-      return "webtransport";
-    }
-    doOpen() {
-      if (typeof WebTransport !== "function") {
-        return;
-      }
-      this.transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
-      this.transport.closed.then(() => {
-        this.onClose();
-      }).catch((err) => {
-        this.onError("webtransport error", err);
-      });
-      this.transport.ready.then(() => {
-        this.transport.createBidirectionalStream().then((stream) => {
-          const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
-          const reader = stream.readable.pipeThrough(decoderStream).getReader();
-          const encoderStream = createPacketEncoderStream();
-          encoderStream.readable.pipeTo(stream.writable);
-          this.writer = encoderStream.writable.getWriter();
-          const read = () => {
-            reader.read().then(({ done, value: value2 }) => {
-              if (done) {
-                return;
-              }
-              this.onPacket(value2);
-              read();
-            }).catch((err) => {
-            });
-          };
-          read();
-          const packet = { type: "open" };
-          if (this.query.sid) {
-            packet.data = `{"sid":"${this.query.sid}"}`;
-          }
-          this.writer.write(packet).then(() => this.onOpen());
-        });
-      });
-    }
-    write(packets) {
-      this.writable = false;
-      for (let i2 = 0; i2 < packets.length; i2++) {
-        const packet = packets[i2];
-        const lastPacket = i2 === packets.length - 1;
-        this.writer.write(packet).then(() => {
-          if (lastPacket) {
-            nextTick(() => {
-              this.writable = true;
-              this.emitReserved("drain");
-            }, this.setTimeoutFn);
-          }
-        });
-      }
-    }
-    doClose() {
-      var _a;
-      (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
-    }
-  };
-
-  // node_modules/engine.io-client/build/esm/transports/index.js
-  var transports = {
-    websocket: WS,
-    webtransport: WT,
-    polling: Polling
-  };
-
-  // node_modules/engine.io-client/build/esm/contrib/parseuri.js
-  var re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
-  var parts = [
-    "source",
-    "protocol",
-    "authority",
-    "userInfo",
-    "user",
-    "password",
-    "host",
-    "port",
-    "relative",
-    "path",
-    "directory",
-    "file",
-    "query",
-    "anchor"
-  ];
-  function parse(str) {
-    if (str.length > 2e3) {
-      throw "URI too long";
-    }
-    const src = str, b = str.indexOf("["), e = str.indexOf("]");
-    if (b != -1 && e != -1) {
-      str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ";") + str.substring(e, str.length);
-    }
-    let m = re.exec(str || ""), uri = {}, i2 = 14;
-    while (i2--) {
-      uri[parts[i2]] = m[i2] || "";
-    }
-    if (b != -1 && e != -1) {
-      uri.source = src;
-      uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ":");
-      uri.authority = uri.authority.replace("[", "").replace("]", "").replace(/;/g, ":");
-      uri.ipv6uri = true;
-    }
-    uri.pathNames = pathNames(uri, uri["path"]);
-    uri.queryKey = queryKey(uri, uri["query"]);
-    return uri;
-  }
-  function pathNames(obj, path) {
-    const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
-    if (path.slice(0, 1) == "/" || path.length === 0) {
-      names.splice(0, 1);
-    }
-    if (path.slice(-1) == "/") {
-      names.splice(names.length - 1, 1);
-    }
-    return names;
-  }
-  function queryKey(uri, query) {
-    const data = {};
-    query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) {
-      if ($1) {
-        data[$1] = $2;
-      }
-    });
-    return data;
-  }
-
-  // node_modules/engine.io-client/build/esm/socket.js
-  var Socket = class _Socket extends Emitter {
-    /**
-     * Socket constructor.
-     *
-     * @param {String|Object} uri - uri or options
-     * @param {Object} opts - options
-     */
-    constructor(uri, opts = {}) {
-      super();
-      this.binaryType = defaultBinaryType;
-      this.writeBuffer = [];
-      if (uri && "object" === typeof uri) {
-        opts = uri;
-        uri = null;
-      }
-      if (uri) {
-        uri = parse(uri);
-        opts.hostname = uri.host;
-        opts.secure = uri.protocol === "https" || uri.protocol === "wss";
-        opts.port = uri.port;
-        if (uri.query)
-          opts.query = uri.query;
-      } else if (opts.host) {
-        opts.hostname = parse(opts.host).host;
-      }
-      installTimerFunctions(this, opts);
-      this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol;
-      if (opts.hostname && !opts.port) {
-        opts.port = this.secure ? "443" : "80";
-      }
-      this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
-      this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : this.secure ? "443" : "80");
-      this.transports = opts.transports || [
-        "polling",
-        "websocket",
-        "webtransport"
-      ];
-      this.writeBuffer = [];
-      this.prevBufferLen = 0;
-      this.opts = Object.assign({
-        path: "/engine.io",
-        agent: false,
-        withCredentials: false,
-        upgrade: true,
-        timestampParam: "t",
-        rememberUpgrade: false,
-        addTrailingSlash: true,
-        rejectUnauthorized: true,
-        perMessageDeflate: {
-          threshold: 1024
-        },
-        transportOptions: {},
-        closeOnBeforeunload: false
-      }, opts);
-      this.opts.path = this.opts.path.replace(/\/$/, "") + (this.opts.addTrailingSlash ? "/" : "");
-      if (typeof this.opts.query === "string") {
-        this.opts.query = decode2(this.opts.query);
-      }
-      this.id = null;
-      this.upgrades = null;
-      this.pingInterval = null;
-      this.pingTimeout = null;
-      this.pingTimeoutTimer = null;
-      if (typeof addEventListener === "function") {
-        if (this.opts.closeOnBeforeunload) {
-          this.beforeunloadEventListener = () => {
-            if (this.transport) {
-              this.transport.removeAllListeners();
-              this.transport.close();
-            }
-          };
-          addEventListener("beforeunload", this.beforeunloadEventListener, false);
-        }
-        if (this.hostname !== "localhost") {
-          this.offlineEventListener = () => {
-            this.onClose("transport close", {
-              description: "network connection lost"
-            });
-          };
-          addEventListener("offline", this.offlineEventListener, false);
-        }
-      }
-      this.open();
-    }
-    /**
-     * Creates transport of the given type.
-     *
-     * @param {String} name - transport name
-     * @return {Transport}
-     * @private
-     */
-    createTransport(name) {
-      const query = Object.assign({}, this.opts.query);
-      query.EIO = protocol;
-      query.transport = name;
-      if (this.id)
-        query.sid = this.id;
-      const opts = Object.assign({}, this.opts, {
-        query,
-        socket: this,
-        hostname: this.hostname,
-        secure: this.secure,
-        port: this.port
-      }, this.opts.transportOptions[name]);
-      return new transports[name](opts);
-    }
-    /**
-     * Initializes transport to use and starts probe.
-     *
-     * @private
-     */
-    open() {
-      let transport;
-      if (this.opts.rememberUpgrade && _Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1) {
-        transport = "websocket";
-      } else if (0 === this.transports.length) {
-        this.setTimeoutFn(() => {
-          this.emitReserved("error", "No transports available");
-        }, 0);
-        return;
-      } else {
-        transport = this.transports[0];
-      }
-      this.readyState = "opening";
-      try {
-        transport = this.createTransport(transport);
-      } catch (e) {
-        this.transports.shift();
-        this.open();
-        return;
-      }
-      transport.open();
-      this.setTransport(transport);
-    }
-    /**
-     * Sets the current transport. Disables the existing one (if any).
-     *
-     * @private
-     */
-    setTransport(transport) {
-      if (this.transport) {
-        this.transport.removeAllListeners();
-      }
-      this.transport = transport;
-      transport.on("drain", this.onDrain.bind(this)).on("packet", this.onPacket.bind(this)).on("error", this.onError.bind(this)).on("close", (reason) => this.onClose("transport close", reason));
-    }
-    /**
-     * Probes a transport.
-     *
-     * @param {String} name - transport name
-     * @private
-     */
-    probe(name) {
-      let transport = this.createTransport(name);
-      let failed = false;
-      _Socket.priorWebsocketSuccess = false;
-      const onTransportOpen = () => {
-        if (failed)
-          return;
-        transport.send([{ type: "ping", data: "probe" }]);
-        transport.once("packet", (msg) => {
-          if (failed)
-            return;
-          if ("pong" === msg.type && "probe" === msg.data) {
-            this.upgrading = true;
-            this.emitReserved("upgrading", transport);
-            if (!transport)
-              return;
-            _Socket.priorWebsocketSuccess = "websocket" === transport.name;
-            this.transport.pause(() => {
-              if (failed)
-                return;
-              if ("closed" === this.readyState)
-                return;
-              cleanup();
-              this.setTransport(transport);
-              transport.send([{ type: "upgrade" }]);
-              this.emitReserved("upgrade", transport);
-              transport = null;
-              this.upgrading = false;
-              this.flush();
-            });
-          } else {
-            const err = new Error("probe error");
-            err.transport = transport.name;
-            this.emitReserved("upgradeError", err);
-          }
-        });
-      };
-      function freezeTransport() {
-        if (failed)
-          return;
-        failed = true;
-        cleanup();
-        transport.close();
-        transport = null;
-      }
-      const onerror = (err) => {
-        const error = new Error("probe error: " + err);
-        error.transport = transport.name;
-        freezeTransport();
-        this.emitReserved("upgradeError", error);
-      };
-      function onTransportClose() {
-        onerror("transport closed");
-      }
-      function onclose() {
-        onerror("socket closed");
-      }
-      function onupgrade(to) {
-        if (transport && to.name !== transport.name) {
-          freezeTransport();
-        }
-      }
-      const cleanup = () => {
-        transport.removeListener("open", onTransportOpen);
-        transport.removeListener("error", onerror);
-        transport.removeListener("close", onTransportClose);
-        this.off("close", onclose);
-        this.off("upgrading", onupgrade);
-      };
-      transport.once("open", onTransportOpen);
-      transport.once("error", onerror);
-      transport.once("close", onTransportClose);
-      this.once("close", onclose);
-      this.once("upgrading", onupgrade);
-      if (this.upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") {
-        this.setTimeoutFn(() => {
-          if (!failed) {
-            transport.open();
-          }
-        }, 200);
-      } else {
-        transport.open();
-      }
-    }
-    /**
-     * Called when connection is deemed open.
-     *
-     * @private
-     */
-    onOpen() {
-      this.readyState = "open";
-      _Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
-      this.emitReserved("open");
-      this.flush();
-      if ("open" === this.readyState && this.opts.upgrade) {
-        let i2 = 0;
-        const l = this.upgrades.length;
-        for (; i2 < l; i2++) {
-          this.probe(this.upgrades[i2]);
-        }
-      }
-    }
-    /**
-     * Handles a packet.
-     *
-     * @private
-     */
-    onPacket(packet) {
-      if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
-        this.emitReserved("packet", packet);
-        this.emitReserved("heartbeat");
-        this.resetPingTimeout();
-        switch (packet.type) {
-          case "open":
-            this.onHandshake(JSON.parse(packet.data));
-            break;
-          case "ping":
-            this.sendPacket("pong");
-            this.emitReserved("ping");
-            this.emitReserved("pong");
-            break;
-          case "error":
-            const err = new Error("server error");
-            err.code = packet.data;
-            this.onError(err);
-            break;
-          case "message":
-            this.emitReserved("data", packet.data);
-            this.emitReserved("message", packet.data);
-            break;
-        }
-      } else {
-      }
-    }
-    /**
-     * Called upon handshake completion.
-     *
-     * @param {Object} data - handshake obj
-     * @private
-     */
-    onHandshake(data) {
-      this.emitReserved("handshake", data);
-      this.id = data.sid;
-      this.transport.query.sid = data.sid;
-      this.upgrades = this.filterUpgrades(data.upgrades);
-      this.pingInterval = data.pingInterval;
-      this.pingTimeout = data.pingTimeout;
-      this.maxPayload = data.maxPayload;
-      this.onOpen();
-      if ("closed" === this.readyState)
-        return;
-      this.resetPingTimeout();
-    }
-    /**
-     * Sets and resets ping timeout timer based on server pings.
-     *
-     * @private
-     */
-    resetPingTimeout() {
-      this.clearTimeoutFn(this.pingTimeoutTimer);
-      this.pingTimeoutTimer = this.setTimeoutFn(() => {
-        this.onClose("ping timeout");
-      }, this.pingInterval + this.pingTimeout);
-      if (this.opts.autoUnref) {
-        this.pingTimeoutTimer.unref();
-      }
-    }
-    /**
-     * Called on `drain` event
-     *
-     * @private
-     */
-    onDrain() {
-      this.writeBuffer.splice(0, this.prevBufferLen);
-      this.prevBufferLen = 0;
-      if (0 === this.writeBuffer.length) {
-        this.emitReserved("drain");
-      } else {
-        this.flush();
-      }
-    }
-    /**
-     * Flush write buffers.
-     *
-     * @private
-     */
-    flush() {
-      if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
-        const packets = this.getWritablePackets();
-        this.transport.send(packets);
-        this.prevBufferLen = packets.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() {
-      const shouldCheckPayloadSize = this.maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1;
-      if (!shouldCheckPayloadSize) {
-        return this.writeBuffer;
-      }
-      let payloadSize = 1;
-      for (let i2 = 0; i2 < this.writeBuffer.length; i2++) {
-        const data = this.writeBuffer[i2].data;
-        if (data) {
-          payloadSize += byteLength(data);
-        }
-        if (i2 > 0 && payloadSize > this.maxPayload) {
-          return this.writeBuffer.slice(0, i2);
-        }
-        payloadSize += 2;
-      }
-      return this.writeBuffer;
-    }
-    /**
-     * Sends a message.
-     *
-     * @param {String} msg - message.
-     * @param {Object} options.
-     * @param {Function} callback function.
-     * @return {Socket} for chaining.
-     */
-    write(msg, options, fn) {
-      this.sendPacket("message", msg, options, fn);
-      return this;
-    }
-    send(msg, options, fn) {
-      this.sendPacket("message", msg, options, fn);
-      return this;
-    }
-    /**
-     * Sends a packet.
-     *
-     * @param {String} type: packet type.
-     * @param {String} data.
-     * @param {Object} options.
-     * @param {Function} fn - callback function.
-     * @private
-     */
-    sendPacket(type, data, options, fn) {
-      if ("function" === typeof data) {
-        fn = data;
-        data = void 0;
-      }
-      if ("function" === typeof options) {
-        fn = options;
-        options = null;
-      }
-      if ("closing" === this.readyState || "closed" === this.readyState) {
-        return;
-      }
-      options = options || {};
-      options.compress = false !== options.compress;
-      const packet = {
-        type,
-        data,
-        options
-      };
-      this.emitReserved("packetCreate", packet);
-      this.writeBuffer.push(packet);
-      if (fn)
-        this.once("flush", fn);
-      this.flush();
-    }
-    /**
-     * Closes the connection.
-     */
-    close() {
-      const close = () => {
-        this.onClose("forced close");
-        this.transport.close();
-      };
-      const cleanupAndClose = () => {
-        this.off("upgrade", cleanupAndClose);
-        this.off("upgradeError", cleanupAndClose);
-        close();
-      };
-      const waitForUpgrade = () => {
-        this.once("upgrade", cleanupAndClose);
-        this.once("upgradeError", cleanupAndClose);
-      };
-      if ("opening" === this.readyState || "open" === this.readyState) {
-        this.readyState = "closing";
-        if (this.writeBuffer.length) {
-          this.once("drain", () => {
-            if (this.upgrading) {
-              waitForUpgrade();
-            } else {
-              close();
-            }
-          });
-        } else if (this.upgrading) {
-          waitForUpgrade();
-        } else {
-          close();
-        }
-      }
-      return this;
-    }
-    /**
-     * Called upon transport error
-     *
-     * @private
-     */
-    onError(err) {
-      _Socket.priorWebsocketSuccess = false;
-      this.emitReserved("error", err);
-      this.onClose("transport error", err);
-    }
-    /**
-     * Called upon transport close.
-     *
-     * @private
-     */
-    onClose(reason, description) {
-      if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
-        this.clearTimeoutFn(this.pingTimeoutTimer);
-        this.transport.removeAllListeners("close");
-        this.transport.close();
-        this.transport.removeAllListeners();
-        if (typeof removeEventListener === "function") {
-          removeEventListener("beforeunload", this.beforeunloadEventListener, false);
-          removeEventListener("offline", this.offlineEventListener, false);
-        }
-        this.readyState = "closed";
-        this.id = null;
-        this.emitReserved("close", reason, description);
-        this.writeBuffer = [];
-        this.prevBufferLen = 0;
-      }
-    }
-    /**
-     * Filters upgrades, returning only those matching client transports.
-     *
-     * @param {Array} upgrades - server upgrades
-     * @private
-     */
-    filterUpgrades(upgrades) {
-      const filteredUpgrades = [];
-      let i2 = 0;
-      const j = upgrades.length;
-      for (; i2 < j; i2++) {
-        if (~this.transports.indexOf(upgrades[i2]))
-          filteredUpgrades.push(upgrades[i2]);
-      }
-      return filteredUpgrades;
-    }
-  };
-  Socket.protocol = protocol;
-
-  // node_modules/engine.io-client/build/esm/index.js
-  var protocol2 = Socket.protocol;
-
-  // node_modules/socket.io-client/build/esm/url.js
-  function url(uri, path = "", loc) {
-    let obj = uri;
-    loc = loc || typeof location !== "undefined" && location;
-    if (null == uri)
-      uri = loc.protocol + "//" + loc.host;
-    if (typeof uri === "string") {
-      if ("/" === uri.charAt(0)) {
-        if ("/" === uri.charAt(1)) {
-          uri = loc.protocol + uri;
-        } else {
-          uri = loc.host + uri;
-        }
-      }
-      if (!/^(https?|wss?):\/\//.test(uri)) {
-        if ("undefined" !== typeof loc) {
-          uri = loc.protocol + "//" + uri;
-        } else {
-          uri = "https://" + uri;
-        }
-      }
-      obj = parse(uri);
-    }
-    if (!obj.port) {
-      if (/^(http|ws)$/.test(obj.protocol)) {
-        obj.port = "80";
-      } else if (/^(http|ws)s$/.test(obj.protocol)) {
-        obj.port = "443";
-      }
-    }
-    obj.path = obj.path || "/";
-    const ipv6 = obj.host.indexOf(":") !== -1;
-    const host = ipv6 ? "[" + obj.host + "]" : obj.host;
-    obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
-    obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
-    return obj;
-  }
-
-  // node_modules/socket.io-parser/build/esm/index.js
-  var esm_exports = {};
-  __export(esm_exports, {
-    Decoder: () => Decoder,
-    Encoder: () => Encoder,
-    PacketType: () => PacketType,
-    protocol: () => protocol3
-  });
-
-  // node_modules/socket.io-parser/build/esm/is-binary.js
-  var withNativeArrayBuffer3 = typeof ArrayBuffer === "function";
-  var isView2 = (obj) => {
-    return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
-  };
-  var toString = Object.prototype.toString;
-  var withNativeBlob2 = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]";
-  var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]";
-  function isBinary(obj) {
-    return withNativeArrayBuffer3 && (obj instanceof ArrayBuffer || isView2(obj)) || withNativeBlob2 && obj instanceof Blob || withNativeFile && obj instanceof File;
-  }
-  function hasBinary(obj, toJSON) {
-    if (!obj || typeof obj !== "object") {
-      return false;
-    }
-    if (Array.isArray(obj)) {
-      for (let i2 = 0, l = obj.length; i2 < l; i2++) {
-        if (hasBinary(obj[i2])) {
-          return true;
-        }
-      }
-      return false;
-    }
-    if (isBinary(obj)) {
-      return true;
-    }
-    if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) {
-      return hasBinary(obj.toJSON(), true);
-    }
-    for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  // node_modules/socket.io-parser/build/esm/binary.js
-  function deconstructPacket(packet) {
-    const buffers = [];
-    const packetData = packet.data;
-    const pack = packet;
-    pack.data = _deconstructPacket(packetData, buffers);
-    pack.attachments = buffers.length;
-    return { packet: pack, buffers };
-  }
-  function _deconstructPacket(data, buffers) {
-    if (!data)
-      return data;
-    if (isBinary(data)) {
-      const placeholder = { _placeholder: true, num: buffers.length };
-      buffers.push(data);
-      return placeholder;
-    } else if (Array.isArray(data)) {
-      const newData = new Array(data.length);
-      for (let i2 = 0; i2 < data.length; i2++) {
-        newData[i2] = _deconstructPacket(data[i2], buffers);
-      }
-      return newData;
-    } else if (typeof data === "object" && !(data instanceof Date)) {
-      const newData = {};
-      for (const key in data) {
-        if (Object.prototype.hasOwnProperty.call(data, key)) {
-          newData[key] = _deconstructPacket(data[key], buffers);
-        }
-      }
-      return newData;
-    }
-    return data;
-  }
-  function reconstructPacket(packet, buffers) {
-    packet.data = _reconstructPacket(packet.data, buffers);
-    delete packet.attachments;
-    return packet;
-  }
-  function _reconstructPacket(data, buffers) {
-    if (!data)
-      return data;
-    if (data && data._placeholder === true) {
-      const isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length;
-      if (isIndexValid) {
-        return buffers[data.num];
-      } else {
-        throw new Error("illegal attachments");
-      }
-    } else if (Array.isArray(data)) {
-      for (let i2 = 0; i2 < data.length; i2++) {
-        data[i2] = _reconstructPacket(data[i2], buffers);
-      }
-    } else if (typeof data === "object") {
-      for (const key in data) {
-        if (Object.prototype.hasOwnProperty.call(data, key)) {
-          data[key] = _reconstructPacket(data[key], buffers);
-        }
-      }
-    }
-    return data;
-  }
-
-  // node_modules/socket.io-parser/build/esm/index.js
-  var RESERVED_EVENTS = [
-    "connect",
-    "connect_error",
-    "disconnect",
-    "disconnecting",
-    "newListener",
-    "removeListener"
-    // used by the Node.js EventEmitter
-  ];
-  var protocol3 = 5;
-  var PacketType;
-  (function(PacketType2) {
-    PacketType2[PacketType2["CONNECT"] = 0] = "CONNECT";
-    PacketType2[PacketType2["DISCONNECT"] = 1] = "DISCONNECT";
-    PacketType2[PacketType2["EVENT"] = 2] = "EVENT";
-    PacketType2[PacketType2["ACK"] = 3] = "ACK";
-    PacketType2[PacketType2["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
-    PacketType2[PacketType2["BINARY_EVENT"] = 5] = "BINARY_EVENT";
-    PacketType2[PacketType2["BINARY_ACK"] = 6] = "BINARY_ACK";
-  })(PacketType || (PacketType = {}));
-  var Encoder = class {
-    /**
-     * Encoder constructor
-     *
-     * @param {function} replacer - custom replacer to pass down to JSON.parse
-     */
-    constructor(replacer) {
-      this.replacer = replacer;
-    }
-    /**
-     * 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(obj) {
-      if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
-        if (hasBinary(obj)) {
-          return this.encodeAsBinary({
-            type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,
-            nsp: obj.nsp,
-            data: obj.data,
-            id: obj.id
-          });
-        }
-      }
-      return [this.encodeAsString(obj)];
-    }
-    /**
-     * Encode packet as string.
-     */
-    encodeAsString(obj) {
-      let str = "" + obj.type;
-      if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) {
-        str += obj.attachments + "-";
-      }
-      if (obj.nsp && "/" !== obj.nsp) {
-        str += obj.nsp + ",";
-      }
-      if (null != obj.id) {
-        str += obj.id;
-      }
-      if (null != obj.data) {
-        str += JSON.stringify(obj.data, this.replacer);
-      }
-      return str;
-    }
-    /**
-     * Encode packet as 'buffer sequence' by removing blobs, and
-     * deconstructing packet into object with placeholders and
-     * a list of buffers.
-     */
-    encodeAsBinary(obj) {
-      const deconstruction = deconstructPacket(obj);
-      const pack = this.encodeAsString(deconstruction.packet);
-      const buffers = deconstruction.buffers;
-      buffers.unshift(pack);
-      return buffers;
-    }
-  };
-  function isObject(value2) {
-    return Object.prototype.toString.call(value2) === "[object Object]";
-  }
-  var Decoder = class _Decoder extends Emitter {
-    /**
-     * Decoder constructor
-     *
-     * @param {function} reviver - custom reviver to pass down to JSON.stringify
-     */
-    constructor(reviver) {
-      super();
-      this.reviver = reviver;
-    }
-    /**
-     * Decodes an encoded packet string into packet JSON.
-     *
-     * @param {String} obj - encoded packet
-     */
-    add(obj) {
-      let packet;
-      if (typeof obj === "string") {
-        if (this.reconstructor) {
-          throw new Error("got plaintext data when reconstructing a packet");
-        }
-        packet = this.decodeString(obj);
-        const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
-        if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
-          packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
-          this.reconstructor = new BinaryReconstructor(packet);
-          if (packet.attachments === 0) {
-            super.emitReserved("decoded", packet);
-          }
-        } else {
-          super.emitReserved("decoded", packet);
-        }
-      } else if (isBinary(obj) || obj.base64) {
-        if (!this.reconstructor) {
-          throw new Error("got binary data when not reconstructing a packet");
-        } else {
-          packet = this.reconstructor.takeBinaryData(obj);
-          if (packet) {
-            this.reconstructor = null;
-            super.emitReserved("decoded", packet);
-          }
-        }
-      } else {
-        throw new Error("Unknown type: " + obj);
-      }
-    }
-    /**
-     * Decode a packet String (JSON data)
-     *
-     * @param {String} str
-     * @return {Object} packet
-     */
-    decodeString(str) {
-      let i2 = 0;
-      const p = {
-        type: Number(str.charAt(0))
-      };
-      if (PacketType[p.type] === void 0) {
-        throw new Error("unknown packet type " + p.type);
-      }
-      if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {
-        const start = i2 + 1;
-        while (str.charAt(++i2) !== "-" && i2 != str.length) {
-        }
-        const buf = str.substring(start, i2);
-        if (buf != Number(buf) || str.charAt(i2) !== "-") {
-          throw new Error("Illegal attachments");
-        }
-        p.attachments = Number(buf);
-      }
-      if ("/" === str.charAt(i2 + 1)) {
-        const start = i2 + 1;
-        while (++i2) {
-          const c = str.charAt(i2);
-          if ("," === c)
-            break;
-          if (i2 === str.length)
-            break;
-        }
-        p.nsp = str.substring(start, i2);
-      } else {
-        p.nsp = "/";
-      }
-      const next = str.charAt(i2 + 1);
-      if ("" !== next && Number(next) == next) {
-        const start = i2 + 1;
-        while (++i2) {
-          const c = str.charAt(i2);
-          if (null == c || Number(c) != c) {
-            --i2;
-            break;
-          }
-          if (i2 === str.length)
-            break;
-        }
-        p.id = Number(str.substring(start, i2 + 1));
-      }
-      if (str.charAt(++i2)) {
-        const payload = this.tryParse(str.substr(i2));
-        if (_Decoder.isPayloadValid(p.type, payload)) {
-          p.data = payload;
-        } else {
-          throw new Error("invalid payload");
-        }
-      }
-      return p;
-    }
-    tryParse(str) {
-      try {
-        return JSON.parse(str, this.reviver);
-      } catch (e) {
-        return false;
-      }
-    }
-    static isPayloadValid(type, payload) {
-      switch (type) {
-        case PacketType.CONNECT:
-          return isObject(payload);
-        case PacketType.DISCONNECT:
-          return payload === void 0;
-        case PacketType.CONNECT_ERROR:
-          return typeof payload === "string" || isObject(payload);
-        case PacketType.EVENT:
-        case PacketType.BINARY_EVENT:
-          return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
-        case PacketType.ACK:
-        case PacketType.BINARY_ACK:
-          return Array.isArray(payload);
-      }
-    }
-    /**
-     * Deallocates a parser's resources
-     */
-    destroy() {
-      if (this.reconstructor) {
-        this.reconstructor.finishedReconstruction();
-        this.reconstructor = null;
-      }
-    }
-  };
-  var BinaryReconstructor = class {
-    constructor(packet) {
-      this.packet = packet;
-      this.buffers = [];
-      this.reconPack = packet;
-    }
-    /**
-     * 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(binData) {
-      this.buffers.push(binData);
-      if (this.buffers.length === this.reconPack.attachments) {
-        const packet = reconstructPacket(this.reconPack, this.buffers);
-        this.finishedReconstruction();
-        return packet;
-      }
-      return null;
-    }
-    /**
-     * Cleans up binary packet reconstruction variables.
-     */
-    finishedReconstruction() {
-      this.reconPack = null;
-      this.buffers = [];
-    }
-  };
-
-  // node_modules/socket.io-client/build/esm/on.js
-  function on(obj, ev, fn) {
-    obj.on(ev, fn);
-    return function subDestroy() {
-      obj.off(ev, fn);
-    };
-  }
-
-  // node_modules/socket.io-client/build/esm/socket.js
-  var RESERVED_EVENTS2 = 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
-  });
-  var Socket2 = class extends Emitter {
-    /**
-     * `Socket` constructor.
-     */
-    constructor(io, nsp, opts) {
-      super();
-      this.connected = false;
-      this.recovered = false;
-      this.receiveBuffer = [];
-      this.sendBuffer = [];
-      this._queue = [];
-      this._queueSeq = 0;
-      this.ids = 0;
-      this.acks = {};
-      this.flags = {};
-      this.io = io;
-      this.nsp = nsp;
-      if (opts && opts.auth) {
-        this.auth = opts.auth;
-      }
-      this._opts = Object.assign({}, opts);
-      if (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 io = this.io;
-      this.subs = [
-        on(io, "open", this.onopen.bind(this)),
-        on(io, "packet", this.onpacket.bind(this)),
-        on(io, "error", this.onerror.bind(this)),
-        on(io, "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() {
-      if (this.connected)
-        return this;
-      this.subEvents();
-      if (!this.io["_reconnecting"])
-        this.io.open();
-      if ("open" === this.io._readyState)
-        this.onopen();
-      return 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(...args) {
-      args.unshift("message");
-      this.emit.apply(this, args);
-      return 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(ev, ...args) {
-      if (RESERVED_EVENTS2.hasOwnProperty(ev)) {
-        throw new Error('"' + ev.toString() + '" is a reserved event name');
-      }
-      args.unshift(ev);
-      if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
-        this._addToQueue(args);
-        return this;
-      }
-      const packet = {
-        type: PacketType.EVENT,
-        data: args
-      };
-      packet.options = {};
-      packet.options.compress = this.flags.compress !== false;
-      if ("function" === typeof args[args.length - 1]) {
-        const id = this.ids++;
-        const ack = args.pop();
-        this._registerAckCallback(id, ack);
-        packet.id = id;
-      }
-      const isTransportWritable = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable;
-      const discardPacket = this.flags.volatile && (!isTransportWritable || !this.connected);
-      if (discardPacket) {
-      } else if (this.connected) {
-        this.notifyOutgoingListeners(packet);
-        this.packet(packet);
-      } else {
-        this.sendBuffer.push(packet);
-      }
-      this.flags = {};
-      return this;
-    }
-    /**
-     * @private
-     */
-    _registerAckCallback(id, ack) {
-      var _a;
-      const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
-      if (timeout === void 0) {
-        this.acks[id] = ack;
-        return;
-      }
-      const timer = this.io.setTimeoutFn(() => {
-        delete this.acks[id];
-        for (let i2 = 0; i2 < this.sendBuffer.length; i2++) {
-          if (this.sendBuffer[i2].id === id) {
-            this.sendBuffer.splice(i2, 1);
-          }
-        }
-        ack.call(this, new Error("operation has timed out"));
-      }, timeout);
-      const fn = (...args) => {
-        this.io.clearTimeoutFn(timer);
-        ack.apply(this, args);
-      };
-      fn.withError = true;
-      this.acks[id] = fn;
-    }
-    /**
-     * 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(ev, ...args) {
-      return new Promise((resolve, reject) => {
-        const fn = (arg1, arg2) => {
-          return arg1 ? reject(arg1) : resolve(arg2);
-        };
-        fn.withError = true;
-        args.push(fn);
-        this.emit(ev, ...args);
-      });
-    }
-    /**
-     * Add the packet to the queue.
-     * @param args
-     * @private
-     */
-    _addToQueue(args) {
-      let ack;
-      if (typeof args[args.length - 1] === "function") {
-        ack = args.pop();
-      }
-      const packet = {
-        id: this._queueSeq++,
-        tryCount: 0,
-        pending: false,
-        args,
-        flags: Object.assign({ fromQueue: true }, this.flags)
-      };
-      args.push((err, ...responseArgs) => {
-        if (packet !== this._queue[0]) {
-          return;
-        }
-        const hasError = err !== null;
-        if (hasError) {
-          if (packet.tryCount > this._opts.retries) {
-            this._queue.shift();
-            if (ack) {
-              ack(err);
-            }
-          }
-        } else {
-          this._queue.shift();
-          if (ack) {
-            ack(null, ...responseArgs);
-          }
-        }
-        packet.pending = false;
-        return this._drainQueue();
-      });
-      this._queue.push(packet);
-      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(force = false) {
-      if (!this.connected || this._queue.length === 0) {
-        return;
-      }
-      const packet = this._queue[0];
-      if (packet.pending && !force) {
-        return;
-      }
-      packet.pending = true;
-      packet.tryCount++;
-      this.flags = packet.flags;
-      this.emit.apply(this, packet.args);
-    }
-    /**
-     * Sends a packet.
-     *
-     * @param packet
-     * @private
-     */
-    packet(packet) {
-      packet.nsp = this.nsp;
-      this.io._packet(packet);
-    }
-    /**
-     * Called upon engine `open`.
-     *
-     * @private
-     */
-    onopen() {
-      if (typeof this.auth == "function") {
-        this.auth((data) => {
-          this._sendConnectPacket(data);
-        });
-      } else {
-        this._sendConnectPacket(this.auth);
-      }
-    }
-    /**
-     * Sends a CONNECT packet to initiate the Socket.IO session.
-     *
-     * @param data
-     * @private
-     */
-    _sendConnectPacket(data) {
-      this.packet({
-        type: PacketType.CONNECT,
-        data: this._pid ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data) : data
-      });
-    }
-    /**
-     * Called upon engine or manager `error`.
-     *
-     * @param err
-     * @private
-     */
-    onerror(err) {
-      if (!this.connected) {
-        this.emitReserved("connect_error", err);
-      }
-    }
-    /**
-     * Called upon engine `close`.
-     *
-     * @param reason
-     * @param description
-     * @private
-     */
-    onclose(reason, description) {
-      this.connected = false;
-      delete this.id;
-      this.emitReserved("disconnect", reason, description);
-      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((id) => {
-        const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
-        if (!isBuffered) {
-          const ack = this.acks[id];
-          delete this.acks[id];
-          if (ack.withError) {
-            ack.call(this, new Error("socket has been disconnected"));
-          }
-        }
-      });
-    }
-    /**
-     * Called with socket packet.
-     *
-     * @param packet
-     * @private
-     */
-    onpacket(packet) {
-      const sameNamespace = packet.nsp === this.nsp;
-      if (!sameNamespace)
-        return;
-      switch (packet.type) {
-        case PacketType.CONNECT:
-          if (packet.data && packet.data.sid) {
-            this.onconnect(packet.data.sid, packet.data.pid);
-          } else {
-            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 PacketType.EVENT:
-        case PacketType.BINARY_EVENT:
-          this.onevent(packet);
-          break;
-        case PacketType.ACK:
-        case PacketType.BINARY_ACK:
-          this.onack(packet);
-          break;
-        case PacketType.DISCONNECT:
-          this.ondisconnect();
-          break;
-        case PacketType.CONNECT_ERROR:
-          this.destroy();
-          const err = new Error(packet.data.message);
-          err.data = packet.data.data;
-          this.emitReserved("connect_error", err);
-          break;
-      }
-    }
-    /**
-     * Called upon a server event.
-     *
-     * @param packet
-     * @private
-     */
-    onevent(packet) {
-      const args = packet.data || [];
-      if (null != packet.id) {
-        args.push(this.ack(packet.id));
-      }
-      if (this.connected) {
-        this.emitEvent(args);
-      } else {
-        this.receiveBuffer.push(Object.freeze(args));
-      }
-    }
-    emitEvent(args) {
-      if (this._anyListeners && this._anyListeners.length) {
-        const listeners = this._anyListeners.slice();
-        for (const listener of listeners) {
-          listener.apply(this, args);
-        }
-      }
-      super.emit.apply(this, args);
-      if (this._pid && args.length && typeof args[args.length - 1] === "string") {
-        this._lastOffset = args[args.length - 1];
-      }
-    }
-    /**
-     * Produces an ack callback to emit with an event.
-     *
-     * @private
-     */
-    ack(id) {
-      const self2 = this;
-      let sent = false;
-      return function(...args) {
-        if (sent)
-          return;
-        sent = true;
-        self2.packet({
-          type: PacketType.ACK,
-          id,
-          data: args
-        });
-      };
-    }
-    /**
-     * Called upon a server acknowledgement.
-     *
-     * @param packet
-     * @private
-     */
-    onack(packet) {
-      const ack = this.acks[packet.id];
-      if (typeof ack !== "function") {
-        return;
-      }
-      delete this.acks[packet.id];
-      if (ack.withError) {
-        packet.data.unshift(null);
-      }
-      ack.apply(this, packet.data);
-    }
-    /**
-     * Called upon server connect.
-     *
-     * @private
-     */
-    onconnect(id, pid) {
-      this.id = id;
-      this.recovered = pid && this._pid === pid;
-      this._pid = pid;
-      this.connected = true;
-      this.emitBuffered();
-      this.emitReserved("connect");
-      this._drainQueue(true);
-    }
-    /**
-     * Emit buffered events (received and emitted).
-     *
-     * @private
-     */
-    emitBuffered() {
-      this.receiveBuffer.forEach((args) => this.emitEvent(args));
-      this.receiveBuffer = [];
-      this.sendBuffer.forEach((packet) => {
-        this.notifyOutgoingListeners(packet);
-        this.packet(packet);
-      });
-      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() {
-      if (this.subs) {
-        this.subs.forEach((subDestroy) => subDestroy());
-        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() {
-      if (this.connected) {
-        this.packet({ type: PacketType.DISCONNECT });
-      }
-      this.destroy();
-      if (this.connected) {
-        this.onclose("io client disconnect");
-      }
-      return 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(compress) {
-      this.flags.compress = compress;
-      return 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() {
-      this.flags.volatile = true;
-      return 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(timeout) {
-      this.flags.timeout = timeout;
-      return 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(listener) {
-      this._anyListeners = this._anyListeners || [];
-      this._anyListeners.push(listener);
-      return 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(listener) {
-      this._anyListeners = this._anyListeners || [];
-      this._anyListeners.unshift(listener);
-      return 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(listener) {
-      if (!this._anyListeners) {
-        return this;
-      }
-      if (listener) {
-        const listeners = this._anyListeners;
-        for (let i2 = 0; i2 < listeners.length; i2++) {
-          if (listener === listeners[i2]) {
-            listeners.splice(i2, 1);
-            return 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(listener) {
-      this._anyOutgoingListeners = this._anyOutgoingListeners || [];
-      this._anyOutgoingListeners.push(listener);
-      return 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(listener) {
-      this._anyOutgoingListeners = this._anyOutgoingListeners || [];
-      this._anyOutgoingListeners.unshift(listener);
-      return 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(listener) {
-      if (!this._anyOutgoingListeners) {
-        return this;
-      }
-      if (listener) {
-        const listeners = this._anyOutgoingListeners;
-        for (let i2 = 0; i2 < listeners.length; i2++) {
-          if (listener === listeners[i2]) {
-            listeners.splice(i2, 1);
-            return 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(packet) {
-      if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
-        const listeners = this._anyOutgoingListeners.slice();
-        for (const listener of listeners) {
-          listener.apply(this, packet.data);
-        }
-      }
-    }
-  };
-
-  // node_modules/socket.io-client/build/esm/contrib/backo2.js
-  function Backoff(opts) {
-    opts = opts || {};
-    this.ms = opts.min || 100;
-    this.max = opts.max || 1e4;
-    this.factor = opts.factor || 2;
-    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
-    this.attempts = 0;
-  }
-  Backoff.prototype.duration = function() {
-    var ms = this.ms * Math.pow(this.factor, this.attempts++);
-    if (this.jitter) {
-      var rand = Math.random();
-      var deviation = Math.floor(rand * this.jitter * ms);
-      ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
-    }
-    return Math.min(ms, this.max) | 0;
-  };
-  Backoff.prototype.reset = function() {
-    this.attempts = 0;
-  };
-  Backoff.prototype.setMin = function(min) {
-    this.ms = min;
-  };
-  Backoff.prototype.setMax = function(max) {
-    this.max = max;
-  };
-  Backoff.prototype.setJitter = function(jitter) {
-    this.jitter = jitter;
-  };
-
-  // node_modules/socket.io-client/build/esm/manager.js
-  var Manager = class extends Emitter {
-    constructor(uri, opts) {
-      var _a;
-      super();
-      this.nsps = {};
-      this.subs = [];
-      if (uri && "object" === typeof uri) {
-        opts = uri;
-        uri = void 0;
-      }
-      opts = opts || {};
-      opts.path = opts.path || "/socket.io";
-      this.opts = opts;
-      installTimerFunctions(this, opts);
-      this.reconnection(opts.reconnection !== false);
-      this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
-      this.reconnectionDelay(opts.reconnectionDelay || 1e3);
-      this.reconnectionDelayMax(opts.reconnectionDelayMax || 5e3);
-      this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
-      this.backoff = new Backoff({
-        min: this.reconnectionDelay(),
-        max: this.reconnectionDelayMax(),
-        jitter: this.randomizationFactor()
-      });
-      this.timeout(null == opts.timeout ? 2e4 : opts.timeout);
-      this._readyState = "closed";
-      this.uri = uri;
-      const _parser = opts.parser || esm_exports;
-      this.encoder = new _parser.Encoder();
-      this.decoder = new _parser.Decoder();
-      this._autoConnect = opts.autoConnect !== false;
-      if (this._autoConnect)
-        this.open();
-    }
-    reconnection(v) {
-      if (!arguments.length)
-        return this._reconnection;
-      this._reconnection = !!v;
-      return this;
-    }
-    reconnectionAttempts(v) {
-      if (v === void 0)
-        return this._reconnectionAttempts;
-      this._reconnectionAttempts = v;
-      return this;
-    }
-    reconnectionDelay(v) {
-      var _a;
-      if (v === void 0)
-        return this._reconnectionDelay;
-      this._reconnectionDelay = v;
-      (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
-      return this;
-    }
-    randomizationFactor(v) {
-      var _a;
-      if (v === void 0)
-        return this._randomizationFactor;
-      this._randomizationFactor = v;
-      (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
-      return this;
-    }
-    reconnectionDelayMax(v) {
-      var _a;
-      if (v === void 0)
-        return this._reconnectionDelayMax;
-      this._reconnectionDelayMax = v;
-      (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
-      return this;
-    }
-    timeout(v) {
-      if (!arguments.length)
-        return this._timeout;
-      this._timeout = v;
-      return this;
-    }
-    /**
-     * Starts trying to reconnect if reconnection is enabled and we have not
-     * started reconnecting yet
-     *
-     * @private
-     */
-    maybeReconnectOnOpen() {
-      if (!this._reconnecting && this._reconnection && this.backoff.attempts === 0) {
-        this.reconnect();
-      }
-    }
-    /**
-     * Sets the current transport `socket`.
-     *
-     * @param {Function} fn - optional, callback
-     * @return self
-     * @public
-     */
-    open(fn) {
-      if (~this._readyState.indexOf("open"))
-        return this;
-      this.engine = new Socket(this.uri, this.opts);
-      const socket = this.engine;
-      const self2 = this;
-      this._readyState = "opening";
-      this.skipReconnect = false;
-      const openSubDestroy = on(socket, "open", function() {
-        self2.onopen();
-        fn && fn();
-      });
-      const onError = (err) => {
-        this.cleanup();
-        this._readyState = "closed";
-        this.emitReserved("error", err);
-        if (fn) {
-          fn(err);
-        } else {
-          this.maybeReconnectOnOpen();
-        }
-      };
-      const errorSub = on(socket, "error", onError);
-      if (false !== this._timeout) {
-        const timeout = this._timeout;
-        const timer = this.setTimeoutFn(() => {
-          openSubDestroy();
-          onError(new Error("timeout"));
-          socket.close();
-        }, timeout);
-        if (this.opts.autoUnref) {
-          timer.unref();
-        }
-        this.subs.push(() => {
-          this.clearTimeoutFn(timer);
-        });
-      }
-      this.subs.push(openSubDestroy);
-      this.subs.push(errorSub);
-      return this;
-    }
-    /**
-     * Alias for open()
-     *
-     * @return self
-     * @public
-     */
-    connect(fn) {
-      return this.open(fn);
-    }
-    /**
-     * Called upon transport open.
-     *
-     * @private
-     */
-    onopen() {
-      this.cleanup();
-      this._readyState = "open";
-      this.emitReserved("open");
-      const socket = this.engine;
-      this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), on(this.decoder, "decoded", this.ondecoded.bind(this)));
-    }
-    /**
-     * Called upon a ping.
-     *
-     * @private
-     */
-    onping() {
-      this.emitReserved("ping");
-    }
-    /**
-     * Called with data.
-     *
-     * @private
-     */
-    ondata(data) {
-      try {
-        this.decoder.add(data);
-      } catch (e) {
-        this.onclose("parse error", e);
-      }
-    }
-    /**
-     * Called when parser fully decodes a packet.
-     *
-     * @private
-     */
-    ondecoded(packet) {
-      nextTick(() => {
-        this.emitReserved("packet", packet);
-      }, this.setTimeoutFn);
-    }
-    /**
-     * Called upon socket error.
-     *
-     * @private
-     */
-    onerror(err) {
-      this.emitReserved("error", err);
-    }
-    /**
-     * Creates a new socket for the given `nsp`.
-     *
-     * @return {Socket}
-     * @public
-     */
-    socket(nsp, opts) {
-      let socket = this.nsps[nsp];
-      if (!socket) {
-        socket = new Socket2(this, nsp, opts);
-        this.nsps[nsp] = socket;
-      } else if (this._autoConnect && !socket.active) {
-        socket.connect();
-      }
-      return socket;
-    }
-    /**
-     * Called upon a socket close.
-     *
-     * @param socket
-     * @private
-     */
-    _destroy(socket) {
-      const nsps = Object.keys(this.nsps);
-      for (const nsp of nsps) {
-        const socket2 = this.nsps[nsp];
-        if (socket2.active) {
-          return;
-        }
-      }
-      this._close();
-    }
-    /**
-     * Writes a packet.
-     *
-     * @param packet
-     * @private
-     */
-    _packet(packet) {
-      const encodedPackets = this.encoder.encode(packet);
-      for (let i2 = 0; i2 < encodedPackets.length; i2++) {
-        this.engine.write(encodedPackets[i2], packet.options);
-      }
-    }
-    /**
-     * Clean up transport subscriptions and packet buffer.
-     *
-     * @private
-     */
-    cleanup() {
-      this.subs.forEach((subDestroy) => subDestroy());
-      this.subs.length = 0;
-      this.decoder.destroy();
-    }
-    /**
-     * Close the current socket.
-     *
-     * @private
-     */
-    _close() {
-      this.skipReconnect = true;
-      this._reconnecting = false;
-      this.onclose("forced close");
-      if (this.engine)
-        this.engine.close();
-    }
-    /**
-     * Alias for close()
-     *
-     * @private
-     */
-    disconnect() {
-      return this._close();
-    }
-    /**
-     * Called upon engine close.
-     *
-     * @private
-     */
-    onclose(reason, description) {
-      this.cleanup();
-      this.backoff.reset();
-      this._readyState = "closed";
-      this.emitReserved("close", reason, description);
-      if (this._reconnection && !this.skipReconnect) {
-        this.reconnect();
-      }
-    }
-    /**
-     * Attempt a reconnection.
-     *
-     * @private
-     */
-    reconnect() {
-      if (this._reconnecting || this.skipReconnect)
-        return this;
-      const self2 = this;
-      if (this.backoff.attempts >= this._reconnectionAttempts) {
-        this.backoff.reset();
-        this.emitReserved("reconnect_failed");
-        this._reconnecting = false;
-      } else {
-        const delay = this.backoff.duration();
-        this._reconnecting = true;
-        const timer = this.setTimeoutFn(() => {
-          if (self2.skipReconnect)
-            return;
-          this.emitReserved("reconnect_attempt", self2.backoff.attempts);
-          if (self2.skipReconnect)
-            return;
-          self2.open((err) => {
-            if (err) {
-              self2._reconnecting = false;
-              self2.reconnect();
-              this.emitReserved("reconnect_error", err);
-            } else {
-              self2.onreconnect();
-            }
-          });
-        }, delay);
-        if (this.opts.autoUnref) {
-          timer.unref();
-        }
-        this.subs.push(() => {
-          this.clearTimeoutFn(timer);
-        });
-      }
-    }
-    /**
-     * Called upon successful reconnect.
-     *
-     * @private
-     */
-    onreconnect() {
-      const attempt = this.backoff.attempts;
-      this._reconnecting = false;
-      this.backoff.reset();
-      this.emitReserved("reconnect", attempt);
-    }
-  };
-
-  // node_modules/socket.io-client/build/esm/index.js
-  var cache = {};
-  function lookup2(uri, opts) {
-    if (typeof uri === "object") {
-      opts = uri;
-      uri = void 0;
-    }
-    opts = opts || {};
-    const parsed = url(uri, opts.path || "/socket.io");
-    const source = parsed.source;
-    const id = parsed.id;
-    const path = parsed.path;
-    const sameNamespace = cache[id] && path in cache[id]["nsps"];
-    const newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
-    let io;
-    if (newConnection) {
-      io = new Manager(source, opts);
-    } else {
-      if (!cache[id]) {
-        cache[id] = new Manager(source, opts);
-      }
-      io = cache[id];
-    }
-    if (parsed.query && !opts.query) {
-      opts.query = parsed.queryKey;
-    }
-    return io.socket(parsed.path, opts);
-  }
-  Object.assign(lookup2, {
-    Manager,
-    Socket: Socket2,
-    io: lookup2,
-    connect: lookup2
-  });
-
-  // package.json
-  var package_default = {
-    name: "@aiqa/sdk",
-    version: "0.0.1",
-    main: "dist/index.js",
-    types: "dist/index.d.ts",
-    browser: "dist/aiqa-sdk.browser.js",
-    exports: {
-      ".": {
-        types: "./dist/index.d.ts",
-        require: "./dist/index.js",
-        browser: "./dist/aiqa-sdk.browser.js",
-        default: "./dist/index.js"
-      }
-    },
-    private: false,
-    license: "MIT",
-    scripts: {
-      build: "npm run build:server && npm run build:browser",
-      "build:browser": "esbuild src/index.ts --bundle --platform=browser --format=iife --global-name=AiQaSdk --outfile=dist/aiqa-sdk.browser.js",
-      "build:server": "tsc -p tsconfig.json --declaration --emitDeclarationOnly false",
-      test: "jest"
-    },
-    author: "AIQA",
-    description: "TypeScript/JavaScript SDK for interacting with the AIQA.",
-    keywords: [
-      "aiqa",
-      "sdk"
-    ],
-    files: [
-      "dist"
-    ],
-    devDependencies: {
-      "@jest/globals": "^29.7.0",
-      "@types/node": "^22.0.0",
-      esbuild: "^0.23.0",
-      jest: "^29.7.0",
-      "socket.io": "^4.7.5",
-      "ts-jest": "^29.2.3",
-      "ts-node": "^10.9.2",
-      typescript: "^5.5.4"
-    },
-    dependencies: {
-      "socket.io-client": "^4.7.5"
-    }
-  };
-
-  // src/index.ts
-  var SDK_VERSION = package_default.version ?? "0.0.1";
-  var DEFAULT_URL = "ws://localhost:3025/ws";
-  var DEFAULT_TIMEOUT_MS = 1e4;
-  var AiQaSdk = class {
-    constructor(applicationId, applicationSecret, url2) {
-      this.url = url2 ?? DEFAULT_URL;
-      this.internalListeners = /* @__PURE__ */ new Map();
-      this.internalEvents = /* @__PURE__ */ new Set(["authenticated"]);
-      if (applicationId || applicationSecret) {
-        this.applicationId = applicationId;
-        this.applicationSecretKey = applicationSecret;
-      } else {
-        throw new Error("Application id and application secret are required");
-      }
-    }
-    on(name, callback) {
-      if (this.internalEvents.has(name)) {
-        if (!this.internalListeners.has(name)) {
-          this.internalListeners.set(name, /* @__PURE__ */ new Set());
-        }
-        this.internalListeners.get(name).add(callback);
-        return;
-      }
-      if (!this.socket) {
-        throw new Error("Not connected");
-      }
-      if (this.isManagerEvent(name)) {
-        this.socket.io.on(name, callback);
-      } else {
-        this.socket.on(name, callback);
-      }
-    }
-    off(name, callback) {
-      if (this.internalEvents.has(name)) {
-        if (!callback) {
-          this.internalListeners.delete(name);
-          return;
-        }
-        const handlers = this.internalListeners.get(name);
-        if (handlers) {
-          handlers.delete(callback);
-          if (handlers.size === 0) {
-            this.internalListeners.delete(name);
-          }
-        }
-        return;
-      }
-      if (!this.socket) {
-        throw new Error("Not connected");
-      }
-      if (this.isManagerEvent(name)) {
-        this.socket.io.off(name, callback);
-      } else {
-        this.socket.off(name, callback);
-      }
-    }
-    connect() {
-      if (!this.url) {
-        return;
-      }
-      const url2 = new URL(this.url);
-      const socketOptions = {
-        reconnectionDelayMax: 1e4,
-        path: url2.pathname
-      };
-      this.socket = lookup2(url2.origin, socketOptions);
-      this.socket.on("connect", () => {
-        this.authenticate();
-      });
-      this.socket.on("app_version", (payload) => {
-        let versionRange = payload;
-        if (typeof payload === "string") {
-          try {
-            versionRange = JSON.parse(payload);
-          } catch (error) {
-            versionRange = payload;
-          }
-        }
-        const minVersion = versionRange?.min;
-        const maxVersion = versionRange?.max;
-        if (minVersion || maxVersion) {
-          const tooLow = minVersion ? this.compareVersions(SDK_VERSION, minVersion) < 0 : false;
-          const tooHigh = maxVersion ? this.compareVersions(SDK_VERSION, maxVersion) > 0 : false;
-          if (tooLow || tooHigh) {
-            const error = new Error(
-              `SDK version ${SDK_VERSION} is not supported. Supported range: ${minVersion || "-"} to ${maxVersion || "-"}.`
-            );
-            this.socket.disconnect();
-            this.socket.emit("error", error);
-          }
-        }
-      });
-    }
-    disconnect() {
-      if (this.socket) {
-        this.socket.disconnect();
-      }
-    }
-    sendMessage(method, data) {
-      return new Promise((resolve, reject) => {
-        if (!this.socket || !this.socket.connected) {
-          reject(new Error("Socket is not connected"));
-          return;
-        }
-        const requestId = this.createRequestId();
-        let timeout;
-        const handler = (payload2) => {
-          if (timeout) {
-            clearTimeout(timeout);
-          }
-          this.socket.off(requestId, handler);
-          let parsed = payload2;
-          if (typeof payload2 === "string") {
-            try {
-              parsed = JSON.parse(payload2);
-            } catch (error) {
-              parsed = payload2;
-            }
-          }
-          if (parsed && parsed.error !== void 0) {
-            reject(parsed.error);
-            return;
-          }
-          resolve(parsed && parsed.data !== void 0 ? parsed.data : parsed);
-        };
-        this.socket.on(requestId, handler);
-        const payload = data && typeof data === "object" ? { ...data, requestId } : { requestId, data };
-        this.socket.emit(method, JSON.stringify(payload));
-        timeout = setTimeout(() => {
-          this.socket.off(requestId, handler);
-          reject(new Error(`Request timed out for ${method}`));
-        }, DEFAULT_TIMEOUT_MS);
-      });
-    }
-    async getApplication() {
-      if (this.cachedApplication) {
-        return this.cachedApplication;
-      }
-      throw new Error("Application is not available yet. Wait for authentication to complete.");
-    }
-    async getFacts() {
-      const result = await this.sendMessage("GET_FACTS" /* GET_FACTS */);
-      return result && result.data !== void 0 ? result.data : result;
-    }
-    async addFact(fact) {
-      const payload = {
-        ...fact,
-        critical: fact.critical ?? false,
-        is_skipped: fact.is_skipped ?? false
-      };
-      const result = await this.sendMessage("ADD_FACT" /* ADD_FACT */, payload);
-      return result && result.data !== void 0 ? result.data : result;
-    }
-    async authenticate() {
-      try {
-        const result = await this.sendMessage("AUTHENTICATE" /* AUTHENTICATE */, {
-          applicationId: this.applicationId,
-          applicationSecretKey: this.applicationSecretKey
-        });
-        const application = result && result.data !== void 0 ? result.data : result;
-        this.cachedApplication = application;
-        this.emitInternal("authenticated", application);
-      } catch (error) {
-        this.socket.emit("error", error);
-      }
-    }
-    async startRecording() {
-      const result = await this.sendMessage("START_RECORDING" /* START_RECORDING */);
-      return result && result.data !== void 0 ? result.data : result;
-    }
-    async stopRecording() {
-      const result = await this.sendMessage("STOP_RECORDING" /* STOP_RECORDING */);
-      return result && result.data !== void 0 ? result.data : result;
-    }
-    async isRecordingNow() {
-      const result = await this.sendMessage("IS_RECORDING" /* IS_RECORDING */);
-      return result && result.data !== void 0 ? result.data : result;
-    }
-    compareVersions(left, right) {
-      const leftParts = left.split(".").map((part) => Number(part));
-      const rightParts = right.split(".").map((part) => Number(part));
-      const maxLength = Math.max(leftParts.length, rightParts.length);
-      for (let i2 = 0; i2 < maxLength; i2 += 1) {
-        const l = leftParts[i2] ?? 0;
-        const r = rightParts[i2] ?? 0;
-        if (l > r) {
-          return 1;
-        }
-        if (l < r) {
-          return -1;
-        }
-      }
-      return 0;
-    }
-    emitInternal(name, ...args) {
-      const handlers = this.internalListeners.get(name);
-      if (!handlers) {
-        return;
-      }
-      handlers.forEach((handler) => handler(...args));
-    }
-    createRequestId() {
-      return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-    }
-    isManagerEvent(name) {
-      return name === "reconnect_attempt" || name === "reconnect_error" || name === "reconnect_failed" || name === "error";
-    }
-  };
-  var src_default = AiQaSdk;
-  return __toCommonJS(src_exports);
-})();