@aiqa/sdk 0.0.2 → 0.0.3

package/dist/browser/browser.mjs

@@ -76,11 +76,11 @@ function encodePacketToBinary(packet, callback) {
 // 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;
+for (let i = 0; i < chars.length; i++) {
+  lookup[chars.charCodeAt(i)] = i;
 }
 var decode = (base64) => {
-  let bufferLength = base64.length * 0.75, len = base64.length, i2, p = 0, encoded1, encoded2, encoded3, encoded4;
+  let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
   if (base64[base64.length - 1] === "=") {
     bufferLength--;
     if (base64[base64.length - 2] === "=") {
@@ -88,11 +88,11 @@ var decode = (base64) => {
     }
   }
   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)];
+  for (i = 0; i < len; i += 4) {
+    encoded1 = lookup[base64.charCodeAt(i)];
+    encoded2 = lookup[base64.charCodeAt(i + 1)];
+    encoded3 = lookup[base64.charCodeAt(i + 2)];
+    encoded4 = lookup[base64.charCodeAt(i + 3)];
     bytes[p++] = encoded1 << 2 | encoded2 >> 4;
     bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
     bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
@@ -156,13 +156,13 @@ var mapBinary = (data, binaryType) => {
 // 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);
+  const length = packets.length;
+  const encodedPackets = new Array(length);
   let count = 0;
-  packets.forEach((packet, i2) => {
+  packets.forEach((packet, i) => {
     encodePacket(packet, false, (encodedPacket) => {
-      encodedPackets[i2] = encodedPacket;
-      if (++count === length2) {
+      encodedPackets[i] = encodedPacket;
+      if (++count === length) {
         callback(encodedPackets.join(SEPARATOR));
       }
     });
@@ -171,8 +171,8 @@ var encodePayload = (packets, callback) => {
 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);
+  for (let i = 0; i < encodedPackets.length; i++) {
+    const decodedPacket = decodePacket(encodedPackets[i], binaryType);
     packets.push(decodedPacket);
     if (decodedPacket.type === "error") {
       break;
@@ -219,8 +219,8 @@ function concatChunks(chunks, size) {
   }
   const buffer = new Uint8Array(size);
   let j = 0;
-  for (let i2 = 0; i2 < size; i2++) {
-    buffer[i2] = chunks[0][j++];
+  for (let i = 0; i < size; i++) {
+    buffer[i] = chunks[0][j++];
     if (j === chunks[0].length) {
       chunks.shift();
       j = 0;
@@ -332,10 +332,10 @@ Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.rem
     return this;
   }
   var cb;
-  for (var i2 = 0; i2 < callbacks.length; i2++) {
-    cb = callbacks[i2];
+  for (var i = 0; i < callbacks.length; i++) {
+    cb = callbacks[i];
     if (cb === fn || cb.fn === fn) {
-      callbacks.splice(i2, 1);
+      callbacks.splice(i, 1);
       break;
     }
   }
@@ -347,13 +347,13 @@ Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.rem
 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];
+  for (var i = 1; i < arguments.length; i++) {
+    args[i - 1] = arguments[i];
   }
   if (callbacks) {
     callbacks = callbacks.slice(0);
-    for (var i2 = 0, len = callbacks.length; i2 < len; ++i2) {
-      callbacks[i2].apply(this, args);
+    for (var i = 0, len = callbacks.length; i < len; ++i) {
+      callbacks[i].apply(this, args);
     }
   }
   return this;
@@ -367,7 +367,15 @@ Emitter.prototype.hasListeners = function(event) {
   return !!this.listeners(event).length;
 };
 
-// node_modules/engine.io-client/build/esm/globalThis.browser.js
+// node_modules/engine.io-client/build/esm/globals.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 globalThisShim = (() => {
   if (typeof self !== "undefined") {
     return self;
@@ -377,6 +385,9 @@ var globalThisShim = (() => {
     return Function("return this")();
   }
 })();
+var defaultBinaryType = "arraybuffer";
+function createCookieJar() {
+}
 
 // node_modules/engine.io-client/build/esm/util.js
 function pick(obj, ...attr) {
@@ -406,31 +417,34 @@ function byteLength(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);
+  let c = 0, length = 0;
+  for (let i = 0, l = str.length; i < l; i++) {
+    c = str.charCodeAt(i);
     if (c < 128) {
-      length2 += 1;
+      length += 1;
     } else if (c < 2048) {
-      length2 += 2;
+      length += 2;
     } else if (c < 55296 || c >= 57344) {
-      length2 += 3;
+      length += 3;
     } else {
-      i2++;
-      length2 += 4;
+      i++;
+      length += 4;
     }
   }
-  return length2;
+  return length;
+}
+function randomString() {
+  return Date.now().toString(36).substring(3) + Math.random().toString(36).substring(2, 5);
 }
 
 // node_modules/engine.io-client/build/esm/contrib/parseqs.js
 function encode(obj) {
   let str = "";
-  for (let i2 in obj) {
-    if (obj.hasOwnProperty(i2)) {
+  for (let i in obj) {
+    if (obj.hasOwnProperty(i)) {
       if (str.length)
         str += "&";
-      str += encodeURIComponent(i2) + "=" + encodeURIComponent(obj[i2]);
+      str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
     }
   }
   return str;
@@ -438,8 +452,8 @@ function encode(obj) {
 function decode2(qs) {
   let qry = {};
   let pairs = qs.split("&");
-  for (let i2 = 0, l = pairs.length; i2 < l; i2++) {
-    let pair = pairs[i2].split("=");
+  for (let i = 0, l = pairs.length; i < l; i++) {
+    let pair = pairs[i].split("=");
     qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
   }
   return qry;
@@ -468,6 +482,7 @@ var Transport = class extends Emitter {
     this.opts = opts;
     this.query = opts.query;
     this.socket = opts.socket;
+    this.supportsBinary = !opts.forceBase64;
   }
   /**
    * Emits an error.
@@ -563,7 +578,7 @@ var Transport = class extends Emitter {
     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)) {
+    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 "";
@@ -575,89 +590,11 @@ var Transport = class extends Emitter {
   }
 };
 
-// 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();
-    }
+  constructor() {
+    super(...arguments);
+    this._polling = false;
   }
   get name() {
     return "polling";
@@ -669,7 +606,7 @@ var Polling = class extends Transport {
    * @protected
    */
   doOpen() {
-    this.poll();
+    this._poll();
   }
   /**
    * Pauses polling.
@@ -683,9 +620,9 @@ var Polling = class extends Transport {
       this.readyState = "paused";
       onPause();
     };
-    if (this.polling || !this.writable) {
+    if (this._polling || !this.writable) {
       let total = 0;
-      if (this.polling) {
+      if (this._polling) {
         total++;
         this.once("pollComplete", function() {
           --total || pause();
@@ -706,8 +643,8 @@ var Polling = class extends Transport {
    *
    * @private
    */
-  poll() {
-    this.polling = true;
+  _poll() {
+    this._polling = true;
     this.doPoll();
     this.emitReserved("poll");
   }
@@ -729,10 +666,10 @@ var Polling = class extends Transport {
     };
     decodePayload(data, this.socket.binaryType).forEach(callback);
     if ("closed" !== this.readyState) {
-      this.polling = false;
+      this._polling = false;
       this.emitReserved("pollComplete");
       if ("open" === this.readyState) {
-        this.poll();
+        this._poll();
       } else {
       }
     }
@@ -776,22 +713,43 @@ var Polling = class extends Transport {
     const schema = this.opts.secure ? "https" : "http";
     const query = this.query || {};
     if (false !== this.opts.timestampRequests) {
-      query[this.opts.timestampParam] = yeast();
+      query[this.opts.timestampParam] = randomString();
     }
     if (!this.supportsBinary && !query.sid) {
       query.b64 = 1;
     }
     return this.createUri(schema, query);
   }
+};
+
+// 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/polling-xhr.js
+function empty() {
+}
+var BaseXHR = class extends Polling {
   /**
-   * Creates a request.
+   * XHR Polling constructor.
    *
-   * @param {String} method
-   * @private
+   * @param {Object} opts
+   * @package
    */
-  request(opts = {}) {
-    Object.assign(opts, { xd: this.xd, cookieJar: this.cookieJar }, this.opts);
-    return new Request(this.uri(), opts);
+  constructor(opts) {
+    super(opts);
+    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;
+    }
   }
   /**
    * Sends data.
@@ -831,39 +789,40 @@ var Request = class _Request extends Emitter {
    * @param {Object} options
    * @package
    */
-  constructor(uri, opts) {
+  constructor(createRequest, uri, opts) {
     super();
+    this.createRequest = createRequest;
     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();
+    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() {
+  _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);
+    const opts = pick(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+    opts.xdomain = !!this._opts.xd;
+    const xhr = this._xhr = this.createRequest(opts);
     try {
-      xhr.open(this.method, this.uri, true);
+      xhr.open(this._method, this._uri, true);
       try {
-        if (this.opts.extraHeaders) {
+        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]);
+          for (let i in this._opts.extraHeaders) {
+            if (this._opts.extraHeaders.hasOwnProperty(i)) {
+              xhr.setRequestHeader(i, this._opts.extraHeaders[i]);
             }
           }
         }
       } catch (e) {
       }
-      if ("POST" === this.method) {
+      if ("POST" === this._method) {
         try {
           xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
         } catch (e) {
@@ -873,38 +832,41 @@ var Request = class _Request extends Emitter {
         xhr.setRequestHeader("Accept", "*/*");
       } catch (e) {
       }
-      (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
+      (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
       if ("withCredentials" in xhr) {
-        xhr.withCredentials = this.opts.withCredentials;
+        xhr.withCredentials = this._opts.withCredentials;
       }
-      if (this.opts.requestTimeout) {
-        xhr.timeout = this.opts.requestTimeout;
+      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);
+          (_a2 = this._opts.cookieJar) === null || _a2 === void 0 ? void 0 : _a2.parseCookies(
+            // @ts-ignore
+            xhr.getResponseHeader("set-cookie")
+          );
         }
         if (4 !== xhr.readyState)
           return;
         if (200 === xhr.status || 1223 === xhr.status) {
-          this.onLoad();
+          this._onLoad();
         } else {
           this.setTimeoutFn(() => {
-            this.onError(typeof xhr.status === "number" ? xhr.status : 0);
+            this._onError(typeof xhr.status === "number" ? xhr.status : 0);
           }, 0);
         }
       };
-      xhr.send(this.data);
+      xhr.send(this._data);
     } catch (e) {
       this.setTimeoutFn(() => {
-        this.onError(e);
+        this._onError(e);
       }, 0);
       return;
     }
     if (typeof document !== "undefined") {
-      this.index = _Request.requestsCount++;
-      _Request.requests[this.index] = this;
+      this._index = _Request.requestsCount++;
+      _Request.requests[this._index] = this;
     }
   }
   /**
@@ -912,42 +874,42 @@ var Request = class _Request extends Emitter {
    *
    * @private
    */
-  onError(err) {
-    this.emitReserved("error", err, this.xhr);
-    this.cleanup(true);
+  _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) {
+  _cleanup(fromError) {
+    if ("undefined" === typeof this._xhr || null === this._xhr) {
       return;
     }
-    this.xhr.onreadystatechange = empty;
+    this._xhr.onreadystatechange = empty;
     if (fromError) {
       try {
-        this.xhr.abort();
+        this._xhr.abort();
       } catch (e) {
       }
     }
     if (typeof document !== "undefined") {
-      delete _Request.requests[this.index];
+      delete _Request.requests[this._index];
     }
-    this.xhr = null;
+    this._xhr = null;
   }
   /**
    * Called upon load.
    *
    * @private
    */
-  onLoad() {
-    const data = this.xhr.responseText;
+  _onLoad() {
+    const data = this._xhr.responseText;
     if (data !== null) {
       this.emitReserved("data", data);
       this.emitReserved("success");
-      this.cleanup();
+      this._cleanup();
     }
   }
   /**
@@ -956,7 +918,7 @@ var Request = class _Request extends Emitter {
    * @package
    */
   abort() {
-    this.cleanup();
+    this._cleanup();
   }
 };
 Request.requestsCount = 0;
@@ -970,46 +932,52 @@ if (typeof document !== "undefined") {
   }
 }
 function unloadHandler() {
-  for (let i2 in Request.requests) {
-    if (Request.requests.hasOwnProperty(i2)) {
-      Request.requests[i2].abort();
+  for (let i in Request.requests) {
+    if (Request.requests.hasOwnProperty(i)) {
+      Request.requests[i].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 hasXHR2 = (function() {
+  const xhr = newRequest({
+    xdomain: false
+  });
+  return xhr && xhr.responseType !== null;
 })();
-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
-   */
+var XHR = class extends BaseXHR {
   constructor(opts) {
     super(opts);
-    this.supportsBinary = !opts.forceBase64;
+    const forceBase64 = opts && opts.forceBase64;
+    this.supportsBinary = hasXHR2 && !forceBase64;
   }
+  request(opts = {}) {
+    Object.assign(opts, { xd: this.xd }, this.opts);
+    return new Request(newRequest, this.uri(), opts);
+  }
+};
+function newRequest(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) {
+    }
+  }
+}
+
+// node_modules/engine.io-client/build/esm/transports/websocket.js
+var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
+var BaseWS = class extends Transport {
   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");
@@ -1017,7 +985,7 @@ var WS = class extends Transport {
       opts.headers = this.opts.extraHeaders;
     }
     try {
-      this.ws = usingBrowserWebSocket && !isReactNative ? protocols ? new WebSocket(uri, protocols) : new WebSocket(uri) : new WebSocket(uri, protocols, opts);
+      this.ws = this.createSocket(uri, protocols, opts);
     } catch (err) {
       return this.emitReserved("error", err);
     }
@@ -1045,31 +1013,12 @@ var WS = class extends Transport {
   }
   write(packets) {
     this.writable = false;
-    for (let i2 = 0; i2 < packets.length; i2++) {
-      const packet = packets[i2];
-      const lastPacket = i2 === packets.length - 1;
+    for (let i = 0; i < packets.length; i++) {
+      const packet = packets[i];
+      const lastPacket = i === 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);
-          }
+          this.doWrite(packet, data);
         } catch (e) {
         }
         if (lastPacket) {
@@ -1083,6 +1032,8 @@ var WS = class extends Transport {
   }
   doClose() {
     if (typeof this.ws !== "undefined") {
+      this.ws.onerror = () => {
+      };
       this.ws.close();
       this.ws = null;
     }
@@ -1096,21 +1047,21 @@ var WS = class extends Transport {
     const schema = this.opts.secure ? "wss" : "ws";
     const query = this.query || {};
     if (this.opts.timestampRequests) {
-      query[this.opts.timestampParam] = yeast();
+      query[this.opts.timestampParam] = randomString();
     }
     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;
+};
+var WebSocketCtor = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
+var WS = class extends BaseWS {
+  createSocket(uri, protocols, opts) {
+    return !isReactNative ? protocols ? new WebSocketCtor(uri, protocols) : new WebSocketCtor(uri) : new WebSocketCtor(uri, protocols, opts);
+  }
+  doWrite(_packet, data) {
+    this.ws.send(data);
   }
 };
 
@@ -1120,22 +1071,23 @@ var WT = class extends Transport {
     return "webtransport";
   }
   doOpen() {
-    if (typeof WebTransport !== "function") {
-      return;
+    try {
+      this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+    } catch (err) {
+      return this.emitReserved("error", err);
     }
-    this.transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
-    this.transport.closed.then(() => {
+    this._transport.closed.then(() => {
       this.onClose();
     }).catch((err) => {
       this.onError("webtransport error", err);
     });
-    this.transport.ready.then(() => {
-      this.transport.createBidirectionalStream().then((stream) => {
+    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();
+        this._writer = encoderStream.writable.getWriter();
         const read = () => {
           reader.read().then(({ done, value: value2 }) => {
             if (done) {
@@ -1151,16 +1103,16 @@ var WT = class extends Transport {
         if (this.query.sid) {
           packet.data = `{"sid":"${this.query.sid}"}`;
         }
-        this.writer.write(packet).then(() => this.onOpen());
+        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(() => {
+    for (let i = 0; i < packets.length; i++) {
+      const packet = packets[i];
+      const lastPacket = i === packets.length - 1;
+      this._writer.write(packet).then(() => {
         if (lastPacket) {
           nextTick(() => {
             this.writable = true;
@@ -1172,7 +1124,7 @@ var WT = class extends Transport {
   }
   doClose() {
     var _a;
-    (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+    (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close();
   }
 };
 
@@ -1180,7 +1132,7 @@ var WT = class extends Transport {
 var transports = {
   websocket: WS,
   webtransport: WT,
-  polling: Polling
+  polling: XHR
 };
 
 // node_modules/engine.io-client/build/esm/contrib/parseuri.js
@@ -1202,16 +1154,16 @@ var parts = [
   "anchor"
 ];
 function parse(str) {
-  if (str.length > 2e3) {
+  if (str.length > 8e3) {
     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] || "";
+  let m = re.exec(str || ""), uri = {}, i = 14;
+  while (i--) {
+    uri[parts[i]] = m[i] || "";
   }
   if (b != -1 && e != -1) {
     uri.source = src;
@@ -1244,28 +1196,40 @@ function queryKey(uri, query) {
 }
 
 // node_modules/engine.io-client/build/esm/socket.js
-var Socket = class _Socket extends Emitter {
+var withEventListeners = typeof addEventListener === "function" && typeof removeEventListener === "function";
+var OFFLINE_EVENT_LISTENERS = [];
+if (withEventListeners) {
+  addEventListener("offline", () => {
+    OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
+  }, false);
+}
+var SocketWithoutUpgrade = class _SocketWithoutUpgrade extends Emitter {
   /**
    * Socket constructor.
    *
    * @param {String|Object} uri - uri or options
    * @param {Object} opts - options
    */
-  constructor(uri, opts = {}) {
+  constructor(uri, opts) {
     super();
     this.binaryType = defaultBinaryType;
     this.writeBuffer = [];
+    this._prevBufferLen = 0;
+    this._pingInterval = -1;
+    this._pingTimeout = -1;
+    this._maxPayload = -1;
+    this._pingTimeoutTime = Infinity;
     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;
+      const parsedUri = parse(uri);
+      opts.hostname = parsedUri.host;
+      opts.secure = parsedUri.protocol === "https" || parsedUri.protocol === "wss";
+      opts.port = parsedUri.port;
+      if (parsedUri.query)
+        opts.query = parsedUri.query;
     } else if (opts.host) {
       opts.hostname = parse(opts.host).host;
     }
@@ -1276,13 +1240,13 @@ var Socket = class _Socket extends Emitter {
     }
     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.transports = [];
+    this._transportsByName = {};
+    opts.transports.forEach((t) => {
+      const transportName = t.prototype.name;
+      this.transports.push(transportName);
+      this._transportsByName[transportName] = t;
+    });
     this.opts = Object.assign({
       path: "/engine.io",
       agent: false,
@@ -1302,31 +1266,29 @@ var Socket = class _Socket extends Emitter {
     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 (withEventListeners) {
       if (this.opts.closeOnBeforeunload) {
-        this.beforeunloadEventListener = () => {
+        this._beforeunloadEventListener = () => {
           if (this.transport) {
             this.transport.removeAllListeners();
             this.transport.close();
           }
         };
-        addEventListener("beforeunload", this.beforeunloadEventListener, false);
+        addEventListener("beforeunload", this._beforeunloadEventListener, false);
       }
       if (this.hostname !== "localhost") {
-        this.offlineEventListener = () => {
-          this.onClose("transport close", {
+        this._offlineEventListener = () => {
+          this._onClose("transport close", {
             description: "network connection lost"
           });
         };
-        addEventListener("offline", this.offlineEventListener, false);
+        OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
       }
     }
-    this.open();
+    if (this.opts.withCredentials) {
+      this._cookieJar = createCookieJar();
+    }
+    this._open();
   }
   /**
    * Creates transport of the given type.
@@ -1348,33 +1310,23 @@ var Socket = class _Socket extends Emitter {
       secure: this.secure,
       port: this.port
     }, this.opts.transportOptions[name]);
-    return new transports[name](opts);
+    return new this._transportsByName[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) {
+  _open() {
+    if (this.transports.length === 0) {
       this.setTimeoutFn(() => {
         this.emitReserved("error", "No transports available");
       }, 0);
       return;
-    } else {
-      transport = this.transports[0];
     }
+    const transportName = this.opts.rememberUpgrade && _SocketWithoutUpgrade.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0];
     this.readyState = "opening";
-    try {
-      transport = this.createTransport(transport);
-    } catch (e) {
-      this.transports.shift();
-      this.open();
-      return;
-    }
+    const transport = this.createTransport(transportName);
     transport.open();
     this.setTransport(transport);
   }
@@ -1388,97 +1340,7 @@ var Socket = class _Socket extends Emitter {
       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();
-    }
+    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));
   }
   /**
    * Called when connection is deemed open.
@@ -1487,40 +1349,33 @@ var Socket = class _Socket extends Emitter {
    */
   onOpen() {
     this.readyState = "open";
-    _Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
+    _SocketWithoutUpgrade.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) {
+  _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._sendPacket("pong");
           this.emitReserved("ping");
           this.emitReserved("pong");
+          this._resetPingTimeout();
           break;
         case "error":
           const err = new Error("server error");
           err.code = packet.data;
-          this.onError(err);
+          this._onError(err);
           break;
         case "message":
           this.emitReserved("data", packet.data);
@@ -1540,27 +1395,28 @@ var Socket = class _Socket extends Emitter {
     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._pingInterval = data.pingInterval;
+    this._pingTimeout = data.pingTimeout;
+    this._maxPayload = data.maxPayload;
     this.onOpen();
     if ("closed" === this.readyState)
       return;
-    this.resetPingTimeout();
+    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);
+  _resetPingTimeout() {
+    this.clearTimeoutFn(this._pingTimeoutTimer);
+    const delay = this._pingInterval + this._pingTimeout;
+    this._pingTimeoutTime = Date.now() + delay;
+    this._pingTimeoutTimer = this.setTimeoutFn(() => {
+      this._onClose("ping timeout");
+    }, delay);
     if (this.opts.autoUnref) {
-      this.pingTimeoutTimer.unref();
+      this._pingTimeoutTimer.unref();
     }
   }
   /**
@@ -1568,9 +1424,9 @@ var Socket = class _Socket extends Emitter {
    *
    * @private
    */
-  onDrain() {
-    this.writeBuffer.splice(0, this.prevBufferLen);
-    this.prevBufferLen = 0;
+  _onDrain() {
+    this.writeBuffer.splice(0, this._prevBufferLen);
+    this._prevBufferLen = 0;
     if (0 === this.writeBuffer.length) {
       this.emitReserved("drain");
     } else {
@@ -1584,9 +1440,9 @@ var Socket = class _Socket extends Emitter {
    */
   flush() {
     if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
-      const packets = this.getWritablePackets();
+      const packets = this._getWritablePackets();
       this.transport.send(packets);
-      this.prevBufferLen = packets.length;
+      this._prevBufferLen = packets.length;
       this.emitReserved("flush");
     }
   }
@@ -1596,38 +1452,68 @@ var Socket = class _Socket extends Emitter {
    *
    * @private
    */
-  getWritablePackets() {
-    const shouldCheckPayloadSize = this.maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1;
+  _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;
+    for (let i = 0; i < this.writeBuffer.length; i++) {
+      const data = this.writeBuffer[i].data;
       if (data) {
         payloadSize += byteLength(data);
       }
-      if (i2 > 0 && payloadSize > this.maxPayload) {
-        return this.writeBuffer.slice(0, i2);
+      if (i > 0 && payloadSize > this._maxPayload) {
+        return this.writeBuffer.slice(0, i);
       }
       payloadSize += 2;
     }
     return this.writeBuffer;
   }
+  /**
+   * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+   *
+   * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+   * `write()` method then the message would not be buffered by the Socket.IO client.
+   *
+   * @return {boolean}
+   * @private
+   */
+  /* private */
+  _hasPingExpired() {
+    if (!this._pingTimeoutTime)
+      return true;
+    const hasExpired = Date.now() > this._pingTimeoutTime;
+    if (hasExpired) {
+      this._pingTimeoutTime = 0;
+      nextTick(() => {
+        this._onClose("ping timeout");
+      }, this.setTimeoutFn);
+    }
+    return hasExpired;
+  }
   /**
    * Sends a message.
    *
    * @param {String} msg - message.
    * @param {Object} options.
-   * @param {Function} callback function.
+   * @param {Function} fn - callback function.
    * @return {Socket} for chaining.
    */
   write(msg, options, fn) {
-    this.sendPacket("message", msg, options, fn);
+    this._sendPacket("message", msg, options, fn);
     return this;
   }
+  /**
+   * Sends a message. Alias of {@link Socket#write}.
+   *
+   * @param {String} msg - message.
+   * @param {Object} options.
+   * @param {Function} fn - callback function.
+   * @return {Socket} for chaining.
+   */
   send(msg, options, fn) {
-    this.sendPacket("message", msg, options, fn);
+    this._sendPacket("message", msg, options, fn);
     return this;
   }
   /**
@@ -1639,7 +1525,7 @@ var Socket = class _Socket extends Emitter {
    * @param {Function} fn - callback function.
    * @private
    */
-  sendPacket(type, data, options, fn) {
+  _sendPacket(type, data, options, fn) {
     if ("function" === typeof data) {
       fn = data;
       data = void 0;
@@ -1669,7 +1555,7 @@ var Socket = class _Socket extends Emitter {
    */
   close() {
     const close = () => {
-      this.onClose("forced close");
+      this._onClose("forced close");
       this.transport.close();
     };
     const cleanupAndClose = () => {
@@ -1704,51 +1590,177 @@ var Socket = class _Socket extends Emitter {
    *
    * @private
    */
-  onError(err) {
-    _Socket.priorWebsocketSuccess = false;
+  _onError(err) {
+    _SocketWithoutUpgrade.priorWebsocketSuccess = false;
+    if (this.opts.tryAllTransports && this.transports.length > 1 && this.readyState === "opening") {
+      this.transports.shift();
+      return this._open();
+    }
     this.emitReserved("error", err);
-    this.onClose("transport error", err);
+    this._onClose("transport error", err);
   }
   /**
    * Called upon transport close.
    *
    * @private
    */
-  onClose(reason, description) {
+  _onClose(reason, description) {
     if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
-      this.clearTimeoutFn(this.pingTimeoutTimer);
+      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);
+      if (withEventListeners) {
+        if (this._beforeunloadEventListener) {
+          removeEventListener("beforeunload", this._beforeunloadEventListener, false);
+        }
+        if (this._offlineEventListener) {
+          const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
+          if (i !== -1) {
+            OFFLINE_EVENT_LISTENERS.splice(i, 1);
+          }
+        }
       }
       this.readyState = "closed";
       this.id = null;
       this.emitReserved("close", reason, description);
       this.writeBuffer = [];
-      this.prevBufferLen = 0;
+      this._prevBufferLen = 0;
+    }
+  }
+};
+SocketWithoutUpgrade.protocol = protocol;
+var SocketWithUpgrade = class extends SocketWithoutUpgrade {
+  constructor() {
+    super(...arguments);
+    this._upgrades = [];
+  }
+  onOpen() {
+    super.onOpen();
+    if ("open" === this.readyState && this.opts.upgrade) {
+      for (let i = 0; i < this._upgrades.length; i++) {
+        this._probe(this._upgrades[i]);
+      }
     }
   }
+  /**
+   * Probes a transport.
+   *
+   * @param {String} name - transport name
+   * @private
+   */
+  _probe(name) {
+    let transport = this.createTransport(name);
+    let failed = false;
+    SocketWithoutUpgrade.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;
+          SocketWithoutUpgrade.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();
+    }
+  }
+  onHandshake(data) {
+    this._upgrades = this._filterUpgrades(data.upgrades);
+    super.onHandshake(data);
+  }
   /**
    * Filters upgrades, returning only those matching client transports.
    *
    * @param {Array} upgrades - server upgrades
    * @private
    */
-  filterUpgrades(upgrades) {
+  _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]);
+    for (let i = 0; i < upgrades.length; i++) {
+      if (~this.transports.indexOf(upgrades[i]))
+        filteredUpgrades.push(upgrades[i]);
     }
     return filteredUpgrades;
   }
 };
-Socket.protocol = protocol;
+var Socket = class extends SocketWithUpgrade {
+  constructor(uri, opts = {}) {
+    const o = typeof uri === "object" ? uri : opts;
+    if (!o.transports || o.transports && typeof o.transports[0] === "string") {
+      o.transports = (o.transports || ["polling", "websocket", "webtransport"]).map((transportName) => transports[transportName]).filter((t) => !!t);
+    }
+    super(uri, o);
+  }
+};
 
 // node_modules/engine.io-client/build/esm/index.js
 var protocol2 = Socket.protocol;
@@ -1797,6 +1809,7 @@ __export(esm_exports, {
   Decoder: () => Decoder,
   Encoder: () => Encoder,
   PacketType: () => PacketType,
+  isPacketValid: () => isPacketValid,
   protocol: () => protocol3
 });
 
@@ -1816,8 +1829,8 @@ function hasBinary(obj, toJSON) {
     return false;
   }
   if (Array.isArray(obj)) {
-    for (let i2 = 0, l = obj.length; i2 < l; i2++) {
-      if (hasBinary(obj[i2])) {
+    for (let i = 0, l = obj.length; i < l; i++) {
+      if (hasBinary(obj[i])) {
         return true;
       }
     }
@@ -1855,8 +1868,8 @@ function _deconstructPacket(data, buffers) {
     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);
+    for (let i = 0; i < data.length; i++) {
+      newData[i] = _deconstructPacket(data[i], buffers);
     }
     return newData;
   } else if (typeof data === "object" && !(data instanceof Date)) {
@@ -1886,8 +1899,8 @@ function _reconstructPacket(data, buffers) {
       throw new Error("illegal attachments");
     }
   } else if (Array.isArray(data)) {
-    for (let i2 = 0; i2 < data.length; i2++) {
-      data[i2] = _reconstructPacket(data[i2], buffers);
+    for (let i = 0; i < data.length; i++) {
+      data[i] = _reconstructPacket(data[i], buffers);
     }
   } else if (typeof data === "object") {
     for (const key in data) {
@@ -1902,10 +1915,15 @@ function _reconstructPacket(data, buffers) {
 // node_modules/socket.io-parser/build/esm/index.js
 var RESERVED_EVENTS = [
   "connect",
+  // used on the client side
   "connect_error",
+  // used on the client side
   "disconnect",
+  // used on both sides
   "disconnecting",
+  // used on the server side
   "newListener",
+  // used by the Node.js EventEmitter
   "removeListener"
   // used by the Node.js EventEmitter
 ];
@@ -1980,9 +1998,6 @@ var Encoder = class {
     return buffers;
   }
 };
-function isObject(value2) {
-  return Object.prototype.toString.call(value2) === "[object Object]";
-}
 var Decoder = class _Decoder extends Emitter {
   /**
    * Decoder constructor
@@ -2036,7 +2051,7 @@ var Decoder = class _Decoder extends Emitter {
    * @return {Object} packet
    */
   decodeString(str) {
-    let i2 = 0;
+    let i = 0;
     const p = {
       type: Number(str.charAt(0))
     };
@@ -2044,44 +2059,44 @@ var Decoder = class _Decoder extends Emitter {
       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 start = i + 1;
+      while (str.charAt(++i) !== "-" && i != str.length) {
       }
-      const buf = str.substring(start, i2);
-      if (buf != Number(buf) || str.charAt(i2) !== "-") {
+      const buf = str.substring(start, i);
+      if (buf != Number(buf) || str.charAt(i) !== "-") {
         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 ("/" === str.charAt(i + 1)) {
+      const start = i + 1;
+      while (++i) {
+        const c = str.charAt(i);
         if ("," === c)
           break;
-        if (i2 === str.length)
+        if (i === str.length)
           break;
       }
-      p.nsp = str.substring(start, i2);
+      p.nsp = str.substring(start, i);
     } else {
       p.nsp = "/";
     }
-    const next = str.charAt(i2 + 1);
+    const next = str.charAt(i + 1);
     if ("" !== next && Number(next) == next) {
-      const start = i2 + 1;
-      while (++i2) {
-        const c = str.charAt(i2);
+      const start = i + 1;
+      while (++i) {
+        const c = str.charAt(i);
         if (null == c || Number(c) != c) {
-          --i2;
+          --i;
           break;
         }
-        if (i2 === str.length)
+        if (i === str.length)
           break;
       }
-      p.id = Number(str.substring(start, i2 + 1));
+      p.id = Number(str.substring(start, i + 1));
     }
-    if (str.charAt(++i2)) {
-      const payload = this.tryParse(str.substr(i2));
+    if (str.charAt(++i)) {
+      const payload = this.tryParse(str.substr(i));
       if (_Decoder.isPayloadValid(p.type, payload)) {
         p.data = payload;
       } else {
@@ -2154,6 +2169,37 @@ var BinaryReconstructor = class {
     this.buffers = [];
   }
 };
+function isNamespaceValid(nsp) {
+  return typeof nsp === "string";
+}
+var isInteger = Number.isInteger || function(value2) {
+  return typeof value2 === "number" && isFinite(value2) && Math.floor(value2) === value2;
+};
+function isAckIdValid(id) {
+  return id === void 0 || isInteger(id);
+}
+function isObject(value2) {
+  return Object.prototype.toString.call(value2) === "[object Object]";
+}
+function isDataValid(type, payload) {
+  switch (type) {
+    case PacketType.CONNECT:
+      return payload === void 0 || isObject(payload);
+    case PacketType.DISCONNECT:
+      return payload === void 0;
+    case PacketType.EVENT:
+      return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS.indexOf(payload[0]) === -1);
+    case PacketType.ACK:
+      return Array.isArray(payload);
+    case PacketType.CONNECT_ERROR:
+      return typeof payload === "string" || isObject(payload);
+    default:
+      return false;
+  }
+}
+function isPacketValid(packet) {
+  return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data);
+}
 
 // node_modules/socket.io-client/build/esm/on.js
 function on(obj, ev, fn) {
@@ -2314,6 +2360,7 @@ var Socket2 = class extends Emitter {
    * @return self
    */
   emit(ev, ...args) {
+    var _a, _b, _c;
     if (RESERVED_EVENTS2.hasOwnProperty(ev)) {
       throw new Error('"' + ev.toString() + '" is a reserved event name');
     }
@@ -2334,10 +2381,11 @@ var Socket2 = class extends Emitter {
       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);
+    const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
+    const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
+    const discardPacket = this.flags.volatile && !isTransportWritable;
     if (discardPacket) {
-    } else if (this.connected) {
+    } else if (isConnected) {
       this.notifyOutgoingListeners(packet);
       this.packet(packet);
     } else {
@@ -2358,9 +2406,9 @@ var Socket2 = class extends Emitter {
     }
     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);
+      for (let i = 0; i < this.sendBuffer.length; i++) {
+        if (this.sendBuffer[i].id === id) {
+          this.sendBuffer.splice(i, 1);
         }
       }
       ack.call(this, new Error("operation has timed out"));
@@ -2417,7 +2465,6 @@ var Socket2 = class extends Emitter {
     };
     args.push((err, ...responseArgs) => {
       if (packet !== this._queue[0]) {
-        return;
       }
       const hasError = err !== null;
       if (hasError) {
@@ -2649,8 +2696,8 @@ var Socket2 = class extends Emitter {
     this._pid = pid;
     this.connected = true;
     this.emitBuffered();
-    this.emitReserved("connect");
     this._drainQueue(true);
+    this.emitReserved("connect");
   }
   /**
    * Emit buffered events (received and emitted).
@@ -2822,9 +2869,9 @@ var Socket2 = class extends Emitter {
     }
     if (listener) {
       const listeners = this._anyListeners;
-      for (let i2 = 0; i2 < listeners.length; i2++) {
-        if (listener === listeners[i2]) {
-          listeners.splice(i2, 1);
+      for (let i = 0; i < listeners.length; i++) {
+        if (listener === listeners[i]) {
+          listeners.splice(i, 1);
           return this;
         }
       }
@@ -2900,9 +2947,9 @@ var Socket2 = class extends Emitter {
     }
     if (listener) {
       const listeners = this._anyOutgoingListeners;
-      for (let i2 = 0; i2 < listeners.length; i2++) {
-        if (listener === listeners[i2]) {
-          listeners.splice(i2, 1);
+      for (let i = 0; i < listeners.length; i++) {
+        if (listener === listeners[i]) {
+          listeners.splice(i, 1);
           return this;
         }
       }
@@ -3005,6 +3052,9 @@ var Manager = class extends Emitter {
     if (!arguments.length)
       return this._reconnection;
     this._reconnection = !!v;
+    if (!v) {
+      this.skipReconnect = true;
+    }
     return this;
   }
   reconnectionAttempts(v) {
@@ -3121,7 +3171,14 @@ var Manager = class extends Emitter {
     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)));
+    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)),
+      // @ts-ignore
+      on(this.decoder, "decoded", this.ondecoded.bind(this))
+    );
   }
   /**
    * Called upon a ping.
@@ -3201,8 +3258,8 @@ var Manager = class extends Emitter {
    */
   _packet(packet) {
     const encodedPackets = this.encoder.encode(packet);
-    for (let i2 = 0; i2 < encodedPackets.length; i2++) {
-      this.engine.write(encodedPackets[i2], packet.options);
+    for (let i = 0; i < encodedPackets.length; i++) {
+      this.engine.write(encodedPackets[i], packet.options);
     }
   }
   /**
@@ -3224,8 +3281,6 @@ var Manager = class extends Emitter {
     this.skipReconnect = true;
     this._reconnecting = false;
     this.onclose("forced close");
-    if (this.engine)
-      this.engine.close();
   }
   /**
    * Alias for close()
@@ -3236,12 +3291,18 @@ var Manager = class extends Emitter {
     return this._close();
   }
   /**
-   * Called upon engine close.
+   * Called when:
+   *
+   * - the low-level engine is closed
+   * - the parser encountered a badly formatted packet
+   * - all sockets are disconnected
    *
    * @private
    */
   onclose(reason, description) {
+    var _a;
     this.cleanup();
+    (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();
     this.backoff.reset();
     this._readyState = "closed";
     this.emitReserved("close", reason, description);
@@ -3340,10 +3401,11 @@ Object.assign(lookup2, {
 // package.json
 var package_default = {
   name: "@aiqa/sdk",
-  version: "0.0.2",
+  version: "0.0.3",
   main: "dist/node/node.js",
   module: "dist/node/node.js",
   types: "dist/node/node.d.ts",
+  engines: { node: ">=18" },
   scripts: {
     build: "tsup",
     "dev:node": "tsx src/node.ts",