@kohost/api-client 3.0.0-beta.8 → 3.0.0-beta.80

package/dist/esm/SocketIoClient.js

@@ -0,0 +1,4846 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/engine.io-parser/build/cjs/commons.js
+var require_commons = __commonJS({
+  "node_modules/engine.io-parser/build/cjs/commons.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ERROR_PACKET = exports.PACKET_TYPES_REVERSE = exports.PACKET_TYPES = void 0;
+    var PACKET_TYPES = /* @__PURE__ */ Object.create(null);
+    exports.PACKET_TYPES = PACKET_TYPES;
+    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);
+    exports.PACKET_TYPES_REVERSE = PACKET_TYPES_REVERSE;
+    Object.keys(PACKET_TYPES).forEach((key) => {
+      PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
+    });
+    var ERROR_PACKET = { type: "error", data: "parser error" };
+    exports.ERROR_PACKET = ERROR_PACKET;
+  }
+});
+
+// node_modules/engine.io-parser/build/cjs/encodePacket.browser.js
+var require_encodePacket_browser = __commonJS({
+  "node_modules/engine.io-parser/build/cjs/encodePacket.browser.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.encodePacket = exports.encodePacketToBinary = void 0;
+    var commons_js_1 = require_commons();
+    var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]";
+    var withNativeArrayBuffer = typeof ArrayBuffer === "function";
+    var isView = /* @__PURE__ */ __name((obj) => {
+      return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer;
+    }, "isView");
+    var encodePacket = /* @__PURE__ */ __name(({ 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(commons_js_1.PACKET_TYPES[type] + (data || ""));
+    }, "encodePacket");
+    exports.encodePacket = encodePacket;
+    var encodeBlobAsBase64 = /* @__PURE__ */ __name((data, callback) => {
+      const fileReader = new FileReader();
+      fileReader.onload = function() {
+        const content = fileReader.result.split(",")[1];
+        callback("b" + (content || ""));
+      };
+      return fileReader.readAsDataURL(data);
+    }, "encodeBlobAsBase64");
+    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);
+      }
+    }
+    __name(toArray, "toArray");
+    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));
+      });
+    }
+    __name(encodePacketToBinary, "encodePacketToBinary");
+    exports.encodePacketToBinary = encodePacketToBinary;
+  }
+});
+
+// node_modules/engine.io-parser/build/cjs/contrib/base64-arraybuffer.js
+var require_base64_arraybuffer = __commonJS({
+  "node_modules/engine.io-parser/build/cjs/contrib/base64-arraybuffer.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decode = exports.encode = void 0;
+    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var lookup = typeof Uint8Array === "undefined" ? [] : new Uint8Array(256);
+    for (let i = 0; i < chars.length; i++) {
+      lookup[chars.charCodeAt(i)] = i;
+    }
+    var encode = /* @__PURE__ */ __name((arraybuffer) => {
+      let bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = "";
+      for (i = 0; i < len; i += 3) {
+        base64 += chars[bytes[i] >> 2];
+        base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];
+        base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];
+        base64 += chars[bytes[i + 2] & 63];
+      }
+      if (len % 3 === 2) {
+        base64 = base64.substring(0, base64.length - 1) + "=";
+      } else if (len % 3 === 1) {
+        base64 = base64.substring(0, base64.length - 2) + "==";
+      }
+      return base64;
+    }, "encode");
+    exports.encode = encode;
+    var decode = /* @__PURE__ */ __name((base64) => {
+      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] === "=") {
+          bufferLength--;
+        }
+      }
+      const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+      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;
+      }
+      return arraybuffer;
+    }, "decode");
+    exports.decode = decode;
+  }
+});
+
+// node_modules/engine.io-parser/build/cjs/decodePacket.browser.js
+var require_decodePacket_browser = __commonJS({
+  "node_modules/engine.io-parser/build/cjs/decodePacket.browser.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodePacket = void 0;
+    var commons_js_1 = require_commons();
+    var base64_arraybuffer_js_1 = require_base64_arraybuffer();
+    var withNativeArrayBuffer = typeof ArrayBuffer === "function";
+    var decodePacket = /* @__PURE__ */ __name((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 = commons_js_1.PACKET_TYPES_REVERSE[type];
+      if (!packetType) {
+        return commons_js_1.ERROR_PACKET;
+      }
+      return encodedPacket.length > 1 ? {
+        type: commons_js_1.PACKET_TYPES_REVERSE[type],
+        data: encodedPacket.substring(1)
+      } : {
+        type: commons_js_1.PACKET_TYPES_REVERSE[type]
+      };
+    }, "decodePacket");
+    exports.decodePacket = decodePacket;
+    var decodeBase64Packet = /* @__PURE__ */ __name((data, binaryType) => {
+      if (withNativeArrayBuffer) {
+        const decoded = (0, base64_arraybuffer_js_1.decode)(data);
+        return mapBinary(decoded, binaryType);
+      } else {
+        return { base64: true, data };
+      }
+    }, "decodeBase64Packet");
+    var mapBinary = /* @__PURE__ */ __name((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;
+          }
+      }
+    }, "mapBinary");
+  }
+});
+
+// node_modules/engine.io-parser/build/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/engine.io-parser/build/cjs/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decodePayload = exports.decodePacket = exports.encodePayload = exports.encodePacket = exports.protocol = exports.createPacketDecoderStream = exports.createPacketEncoderStream = void 0;
+    var encodePacket_js_1 = require_encodePacket_browser();
+    Object.defineProperty(exports, "encodePacket", { enumerable: true, get: function() {
+      return encodePacket_js_1.encodePacket;
+    } });
+    var decodePacket_js_1 = require_decodePacket_browser();
+    Object.defineProperty(exports, "decodePacket", { enumerable: true, get: function() {
+      return decodePacket_js_1.decodePacket;
+    } });
+    var commons_js_1 = require_commons();
+    var SEPARATOR = String.fromCharCode(30);
+    var encodePayload = /* @__PURE__ */ __name((packets, callback) => {
+      const length = packets.length;
+      const encodedPackets = new Array(length);
+      let count = 0;
+      packets.forEach((packet, i) => {
+        (0, encodePacket_js_1.encodePacket)(packet, false, (encodedPacket) => {
+          encodedPackets[i] = encodedPacket;
+          if (++count === length) {
+            callback(encodedPackets.join(SEPARATOR));
+          }
+        });
+      });
+    }, "encodePayload");
+    exports.encodePayload = encodePayload;
+    var decodePayload = /* @__PURE__ */ __name((encodedPayload, binaryType) => {
+      const encodedPackets = encodedPayload.split(SEPARATOR);
+      const packets = [];
+      for (let i = 0; i < encodedPackets.length; i++) {
+        const decodedPacket = (0, decodePacket_js_1.decodePacket)(encodedPackets[i], binaryType);
+        packets.push(decodedPacket);
+        if (decodedPacket.type === "error") {
+          break;
+        }
+      }
+      return packets;
+    }, "decodePayload");
+    exports.decodePayload = decodePayload;
+    function createPacketEncoderStream() {
+      return new TransformStream({
+        transform(packet, controller) {
+          (0, encodePacket_js_1.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);
+          });
+        }
+      });
+    }
+    __name(createPacketEncoderStream, "createPacketEncoderStream");
+    exports.createPacketEncoderStream = createPacketEncoderStream;
+    var TEXT_DECODER;
+    function totalLength(chunks) {
+      return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    }
+    __name(totalLength, "totalLength");
+    function concatChunks(chunks, size) {
+      if (chunks[0].length === size) {
+        return chunks.shift();
+      }
+      const buffer = new Uint8Array(size);
+      let j = 0;
+      for (let i = 0; i < size; i++) {
+        buffer[i] = 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;
+    }
+    __name(concatChunks, "concatChunks");
+    function createPacketDecoderStream(maxPayload, binaryType) {
+      if (!TEXT_DECODER) {
+        TEXT_DECODER = new TextDecoder();
+      }
+      const chunks = [];
+      let state = 0;
+      let expectedLength = -1;
+      let isBinary = 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);
+              isBinary = (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(commons_js_1.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((0, decodePacket_js_1.decodePacket)(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
+              state = 0;
+            }
+            if (expectedLength === 0 || expectedLength > maxPayload) {
+              controller.enqueue(commons_js_1.ERROR_PACKET);
+              break;
+            }
+          }
+        }
+      });
+    }
+    __name(createPacketDecoderStream, "createPacketDecoderStream");
+    exports.createPacketDecoderStream = createPacketDecoderStream;
+    exports.protocol = 4;
+  }
+});
+
+// node_modules/@socket.io/component-emitter/index.js
+var require_component_emitter = __commonJS({
+  "node_modules/@socket.io/component-emitter/index.js"(exports) {
+    exports.Emitter = Emitter;
+    function Emitter(obj) {
+      if (obj)
+        return mixin(obj);
+    }
+    __name(Emitter, "Emitter");
+    function mixin(obj) {
+      for (var key in Emitter.prototype) {
+        obj[key] = Emitter.prototype[key];
+      }
+      return obj;
+    }
+    __name(mixin, "mixin");
+    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 on() {
+        this.off(event, on);
+        fn.apply(this, arguments);
+      }
+      __name(on, "on");
+      on.fn = fn;
+      this.on(event, on);
+      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 i = 0; i < callbacks.length; i++) {
+        cb = callbacks[i];
+        if (cb === fn || cb.fn === fn) {
+          callbacks.splice(i, 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 i = 1; i < arguments.length; i++) {
+        args[i - 1] = arguments[i];
+      }
+      if (callbacks) {
+        callbacks = callbacks.slice(0);
+        for (var i = 0, len = callbacks.length; i < len; ++i) {
+          callbacks[i].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/cjs/globalThis.browser.js
+var require_globalThis_browser = __commonJS({
+  "node_modules/engine.io-client/build/cjs/globalThis.browser.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.globalThisShim = void 0;
+    exports.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/cjs/util.js
+var require_util = __commonJS({
+  "node_modules/engine.io-client/build/cjs/util.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.byteLength = exports.installTimerFunctions = exports.pick = void 0;
+    var globalThis_js_1 = require_globalThis_browser();
+    function pick(obj, ...attr) {
+      return attr.reduce((acc, k) => {
+        if (obj.hasOwnProperty(k)) {
+          acc[k] = obj[k];
+        }
+        return acc;
+      }, {});
+    }
+    __name(pick, "pick");
+    exports.pick = pick;
+    var NATIVE_SET_TIMEOUT = globalThis_js_1.globalThisShim.setTimeout;
+    var NATIVE_CLEAR_TIMEOUT = globalThis_js_1.globalThisShim.clearTimeout;
+    function installTimerFunctions(obj, opts) {
+      if (opts.useNativeTimers) {
+        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis_js_1.globalThisShim);
+        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis_js_1.globalThisShim);
+      } else {
+        obj.setTimeoutFn = globalThis_js_1.globalThisShim.setTimeout.bind(globalThis_js_1.globalThisShim);
+        obj.clearTimeoutFn = globalThis_js_1.globalThisShim.clearTimeout.bind(globalThis_js_1.globalThisShim);
+      }
+    }
+    __name(installTimerFunctions, "installTimerFunctions");
+    exports.installTimerFunctions = installTimerFunctions;
+    var BASE64_OVERHEAD = 1.33;
+    function byteLength(obj) {
+      if (typeof obj === "string") {
+        return utf8Length(obj);
+      }
+      return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
+    }
+    __name(byteLength, "byteLength");
+    exports.byteLength = byteLength;
+    function utf8Length(str) {
+      let c = 0, length = 0;
+      for (let i = 0, l = str.length; i < l; i++) {
+        c = str.charCodeAt(i);
+        if (c < 128) {
+          length += 1;
+        } else if (c < 2048) {
+          length += 2;
+        } else if (c < 55296 || c >= 57344) {
+          length += 3;
+        } else {
+          i++;
+          length += 4;
+        }
+      }
+      return length;
+    }
+    __name(utf8Length, "utf8Length");
+  }
+});
+
+// node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/ms/index.js"(exports, module) {
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    __name(parse, "parse");
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    __name(fmtShort, "fmtShort");
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    __name(fmtLong, "fmtLong");
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+    __name(plural, "plural");
+  }
+});
+
+// node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "node_modules/debug/src/common.js"(exports, module) {
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      __name(selectColor, "selectColor");
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self2 = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self2, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug.log;
+          logFn.apply(self2, args);
+        }
+        __name(debug, "debug");
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      __name(createDebug, "createDebug");
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      __name(extend, "extend");
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        let i;
+        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+        const len = split.length;
+        for (i = 0; i < len; i++) {
+          if (!split[i]) {
+            continue;
+          }
+          namespaces = split[i].replace(/\*/g, ".*?");
+          if (namespaces[0] === "-") {
+            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
+          } else {
+            createDebug.names.push(new RegExp("^" + namespaces + "$"));
+          }
+        }
+      }
+      __name(enable, "enable");
+      function disable() {
+        const namespaces = [
+          ...createDebug.names.map(toNamespace),
+          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      __name(disable, "disable");
+      function enabled(name) {
+        if (name[name.length - 1] === "*") {
+          return true;
+        }
+        let i;
+        let len;
+        for (i = 0, len = createDebug.skips.length; i < len; i++) {
+          if (createDebug.skips[i].test(name)) {
+            return false;
+          }
+        }
+        for (i = 0, len = createDebug.names.length; i < len; i++) {
+          if (createDebug.names[i].test(name)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      __name(enabled, "enabled");
+      function toNamespace(regexp) {
+        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+      }
+      __name(toNamespace, "toNamespace");
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      __name(coerce, "coerce");
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      __name(destroy, "destroy");
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    __name(setup, "setup");
+    module.exports = setup;
+  }
+});
+
+// node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/debug/src/browser.js"(exports, module) {
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    __name(useColors, "useColors");
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    __name(formatArgs, "formatArgs");
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    __name(save, "save");
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    __name(load, "load");
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    __name(localstorage, "localstorage");
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/contrib/parseqs.js
+var require_parseqs = __commonJS({
+  "node_modules/engine.io-client/build/cjs/contrib/parseqs.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.decode = exports.encode = void 0;
+    function encode(obj) {
+      let str = "";
+      for (let i in obj) {
+        if (obj.hasOwnProperty(i)) {
+          if (str.length)
+            str += "&";
+          str += encodeURIComponent(i) + "=" + encodeURIComponent(obj[i]);
+        }
+      }
+      return str;
+    }
+    __name(encode, "encode");
+    exports.encode = encode;
+    function decode(qs) {
+      let qry = {};
+      let pairs = qs.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;
+    }
+    __name(decode, "decode");
+    exports.decode = decode;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transport.js
+var require_transport = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transport.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Transport = void 0;
+    var engine_io_parser_1 = require_cjs();
+    var component_emitter_1 = require_component_emitter();
+    var util_js_1 = require_util();
+    var debug_1 = __importDefault(require_browser());
+    var parseqs_js_1 = require_parseqs();
+    var debug = (0, debug_1.default)("engine.io-client:transport");
+    var TransportError = class extends Error {
+      static {
+        __name(this, "TransportError");
+      }
+      constructor(reason, description, context) {
+        super(reason);
+        this.description = description;
+        this.context = context;
+        this.type = "TransportError";
+      }
+    };
+    var Transport = class extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Transport");
+      }
+      /**
+       * Transport abstract constructor.
+       *
+       * @param {Object} opts - options
+       * @protected
+       */
+      constructor(opts) {
+        super();
+        this.writable = false;
+        (0, util_js_1.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 {
+          debug("transport is not open, discarding packets");
+        }
+      }
+      /**
+       * 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 = (0, engine_io_parser_1.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 = (0, parseqs_js_1.encode)(query);
+        return encodedQuery.length ? "?" + encodedQuery : "";
+      }
+    };
+    exports.Transport = Transport;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/contrib/yeast.js
+var require_yeast = __commonJS({
+  "node_modules/engine.io-client/build/cjs/contrib/yeast.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.yeast = exports.decode = exports.encode = void 0;
+    var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_".split("");
+    var length = 64;
+    var map = {};
+    var seed = 0;
+    var i = 0;
+    var prev;
+    function encode(num) {
+      let encoded = "";
+      do {
+        encoded = alphabet[num % length] + encoded;
+        num = Math.floor(num / length);
+      } while (num > 0);
+      return encoded;
+    }
+    __name(encode, "encode");
+    exports.encode = encode;
+    function decode(str) {
+      let decoded = 0;
+      for (i = 0; i < str.length; i++) {
+        decoded = decoded * length + map[str.charAt(i)];
+      }
+      return decoded;
+    }
+    __name(decode, "decode");
+    exports.decode = decode;
+    function yeast() {
+      const now = encode(+/* @__PURE__ */ new Date());
+      if (now !== prev)
+        return seed = 0, prev = now;
+      return now + "." + encode(seed++);
+    }
+    __name(yeast, "yeast");
+    exports.yeast = yeast;
+    for (; i < length; i++)
+      map[alphabet[i]] = i;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/contrib/has-cors.js
+var require_has_cors = __commonJS({
+  "node_modules/engine.io-client/build/cjs/contrib/has-cors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hasCORS = void 0;
+    var value = false;
+    try {
+      value = typeof XMLHttpRequest !== "undefined" && "withCredentials" in new XMLHttpRequest();
+    } catch (err) {
+    }
+    exports.hasCORS = value;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/xmlhttprequest.browser.js
+var require_xmlhttprequest_browser = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/xmlhttprequest.browser.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createCookieJar = exports.XHR = void 0;
+    var has_cors_js_1 = require_has_cors();
+    var globalThis_js_1 = require_globalThis_browser();
+    function XHR(opts) {
+      const xdomain = opts.xdomain;
+      try {
+        if ("undefined" !== typeof XMLHttpRequest && (!xdomain || has_cors_js_1.hasCORS)) {
+          return new XMLHttpRequest();
+        }
+      } catch (e) {
+      }
+      if (!xdomain) {
+        try {
+          return new globalThis_js_1.globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+        } catch (e) {
+        }
+      }
+    }
+    __name(XHR, "XHR");
+    exports.XHR = XHR;
+    function createCookieJar() {
+    }
+    __name(createCookieJar, "createCookieJar");
+    exports.createCookieJar = createCookieJar;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/polling.js
+var require_polling = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/polling.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Request = exports.Polling = void 0;
+    var transport_js_1 = require_transport();
+    var debug_1 = __importDefault(require_browser());
+    var yeast_js_1 = require_yeast();
+    var engine_io_parser_1 = require_cjs();
+    var xmlhttprequest_js_1 = require_xmlhttprequest_browser();
+    var component_emitter_1 = require_component_emitter();
+    var util_js_1 = require_util();
+    var globalThis_js_1 = require_globalThis_browser();
+    var debug = (0, debug_1.default)("engine.io-client:polling");
+    function empty() {
+    }
+    __name(empty, "empty");
+    var hasXHR2 = function() {
+      const xhr = new xmlhttprequest_js_1.XHR({
+        xdomain: false
+      });
+      return null != xhr.responseType;
+    }();
+    var Polling = class extends transport_js_1.Transport {
+      static {
+        __name(this, "Polling");
+      }
+      /**
+       * 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 = (0, xmlhttprequest_js_1.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 = /* @__PURE__ */ __name(() => {
+          debug("paused");
+          this.readyState = "paused";
+          onPause();
+        }, "pause");
+        if (this.polling || !this.writable) {
+          let total = 0;
+          if (this.polling) {
+            debug("we are currently polling - waiting to pause");
+            total++;
+            this.once("pollComplete", function() {
+              debug("pre-pause polling complete");
+              --total || pause();
+            });
+          }
+          if (!this.writable) {
+            debug("we are currently writing - waiting to pause");
+            total++;
+            this.once("drain", function() {
+              debug("pre-pause writing complete");
+              --total || pause();
+            });
+          }
+        } else {
+          pause();
+        }
+      }
+      /**
+       * Starts polling cycle.
+       *
+       * @private
+       */
+      poll() {
+        debug("polling");
+        this.polling = true;
+        this.doPoll();
+        this.emitReserved("poll");
+      }
+      /**
+       * Overloads onData to detect payloads.
+       *
+       * @protected
+       */
+      onData(data) {
+        debug("polling got data %s", data);
+        const callback = /* @__PURE__ */ __name((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);
+        }, "callback");
+        (0, engine_io_parser_1.decodePayload)(data, this.socket.binaryType).forEach(callback);
+        if ("closed" !== this.readyState) {
+          this.polling = false;
+          this.emitReserved("pollComplete");
+          if ("open" === this.readyState) {
+            this.poll();
+          } else {
+            debug('ignoring poll - transport state "%s"', this.readyState);
+          }
+        }
+      }
+      /**
+       * For polling, send a close packet.
+       *
+       * @protected
+       */
+      doClose() {
+        const close = /* @__PURE__ */ __name(() => {
+          debug("writing close packet");
+          this.write([{ type: "close" }]);
+        }, "close");
+        if ("open" === this.readyState) {
+          debug("transport open - closing");
+          close();
+        } else {
+          debug("transport not open - deferring close");
+          this.once("open", close);
+        }
+      }
+      /**
+       * Writes a packets payload.
+       *
+       * @param {Array} packets - data packets
+       * @protected
+       */
+      write(packets) {
+        this.writable = false;
+        (0, engine_io_parser_1.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] = (0, yeast_js_1.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() {
+        debug("xhr poll");
+        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;
+      }
+    };
+    exports.Polling = Polling;
+    var Request = class _Request extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Request");
+      }
+      /**
+       * Request constructor
+       *
+       * @param {Object} options
+       * @package
+       */
+      constructor(uri, opts) {
+        super();
+        (0, util_js_1.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 = (0, util_js_1.pick)(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+        opts.xdomain = !!this.opts.xd;
+        const xhr = this.xhr = new xmlhttprequest_js_1.XHR(opts);
+        try {
+          debug("xhr open %s: %s", this.method, this.uri);
+          xhr.open(this.method, this.uri, true);
+          try {
+            if (this.opts.extraHeaders) {
+              xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
+              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) {
+            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);
+            }
+          };
+          debug("xhr data %s", this.data);
+          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();
+      }
+    };
+    exports.Request = Request;
+    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 globalThis_js_1.globalThisShim ? "pagehide" : "unload";
+        addEventListener(terminationEvent, unloadHandler, false);
+      }
+    }
+    function unloadHandler() {
+      for (let i in Request.requests) {
+        if (Request.requests.hasOwnProperty(i)) {
+          Request.requests[i].abort();
+        }
+      }
+    }
+    __name(unloadHandler, "unloadHandler");
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/websocket-constructor.browser.js
+var require_websocket_constructor_browser = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/websocket-constructor.browser.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.defaultBinaryType = exports.usingBrowserWebSocket = exports.WebSocket = exports.nextTick = void 0;
+    var globalThis_js_1 = require_globalThis_browser();
+    exports.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);
+      }
+    })();
+    exports.WebSocket = globalThis_js_1.globalThisShim.WebSocket || globalThis_js_1.globalThisShim.MozWebSocket;
+    exports.usingBrowserWebSocket = true;
+    exports.defaultBinaryType = "arraybuffer";
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/websocket.js
+var require_websocket = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/websocket.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WS = void 0;
+    var transport_js_1 = require_transport();
+    var yeast_js_1 = require_yeast();
+    var util_js_1 = require_util();
+    var websocket_constructor_js_1 = require_websocket_constructor_browser();
+    var debug_1 = __importDefault(require_browser());
+    var engine_io_parser_1 = require_cjs();
+    var debug = (0, debug_1.default)("engine.io-client:websocket");
+    var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
+    var WS = class extends transport_js_1.Transport {
+      static {
+        __name(this, "WS");
+      }
+      /**
+       * 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 ? {} : (0, util_js_1.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 = websocket_constructor_js_1.usingBrowserWebSocket && !isReactNative ? protocols ? new websocket_constructor_js_1.WebSocket(uri, protocols) : new websocket_constructor_js_1.WebSocket(uri) : new websocket_constructor_js_1.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 i = 0; i < packets.length; i++) {
+          const packet = packets[i];
+          const lastPacket = i === packets.length - 1;
+          (0, engine_io_parser_1.encodePacket)(packet, this.supportsBinary, (data) => {
+            const opts = {};
+            if (!websocket_constructor_js_1.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 (websocket_constructor_js_1.usingBrowserWebSocket) {
+                this.ws.send(data);
+              } else {
+                this.ws.send(data, opts);
+              }
+            } catch (e) {
+              debug("websocket closed before onclose event");
+            }
+            if (lastPacket) {
+              (0, websocket_constructor_js_1.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] = (0, yeast_js_1.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_constructor_js_1.WebSocket;
+      }
+    };
+    exports.WS = WS;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/webtransport.js
+var require_webtransport = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/webtransport.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WT = void 0;
+    var transport_js_1 = require_transport();
+    var websocket_constructor_js_1 = require_websocket_constructor_browser();
+    var engine_io_parser_1 = require_cjs();
+    var debug_1 = __importDefault(require_browser());
+    var debug = (0, debug_1.default)("engine.io-client:webtransport");
+    var WT = class extends transport_js_1.Transport {
+      static {
+        __name(this, "WT");
+      }
+      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(() => {
+          debug("transport closed gracefully");
+          this.onClose();
+        }).catch((err) => {
+          debug("transport closed due to %s", err);
+          this.onError("webtransport error", err);
+        });
+        this.transport.ready.then(() => {
+          this.transport.createBidirectionalStream().then((stream) => {
+            const decoderStream = (0, engine_io_parser_1.createPacketDecoderStream)(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
+            const reader = stream.readable.pipeThrough(decoderStream).getReader();
+            const encoderStream = (0, engine_io_parser_1.createPacketEncoderStream)();
+            encoderStream.readable.pipeTo(stream.writable);
+            this.writer = encoderStream.writable.getWriter();
+            const read = /* @__PURE__ */ __name(() => {
+              reader.read().then(({ done, value }) => {
+                if (done) {
+                  debug("session is closed");
+                  return;
+                }
+                debug("received chunk: %o", value);
+                this.onPacket(value);
+                read();
+              }).catch((err) => {
+                debug("an error occurred while reading: %s", err);
+              });
+            }, "read");
+            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 i = 0; i < packets.length; i++) {
+          const packet = packets[i];
+          const lastPacket = i === packets.length - 1;
+          this.writer.write(packet).then(() => {
+            if (lastPacket) {
+              (0, websocket_constructor_js_1.nextTick)(() => {
+                this.writable = true;
+                this.emitReserved("drain");
+              }, this.setTimeoutFn);
+            }
+          });
+        }
+      }
+      doClose() {
+        var _a;
+        (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+      }
+    };
+    exports.WT = WT;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/transports/index.js
+var require_transports = __commonJS({
+  "node_modules/engine.io-client/build/cjs/transports/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.transports = void 0;
+    var polling_js_1 = require_polling();
+    var websocket_js_1 = require_websocket();
+    var webtransport_js_1 = require_webtransport();
+    exports.transports = {
+      websocket: websocket_js_1.WS,
+      webtransport: webtransport_js_1.WT,
+      polling: polling_js_1.Polling
+    };
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/contrib/parseuri.js
+var require_parseuri = __commonJS({
+  "node_modules/engine.io-client/build/cjs/contrib/parseuri.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parse = void 0;
+    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) {
+      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 = {}, i = 14;
+      while (i--) {
+        uri[parts[i]] = m[i] || "";
+      }
+      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;
+    }
+    __name(parse, "parse");
+    exports.parse = parse;
+    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;
+    }
+    __name(pathNames, "pathNames");
+    function queryKey(uri, query) {
+      const data = {};
+      query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function($0, $1, $2) {
+        if ($1) {
+          data[$1] = $2;
+        }
+      });
+      return data;
+    }
+    __name(queryKey, "queryKey");
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/socket.js
+var require_socket = __commonJS({
+  "node_modules/engine.io-client/build/cjs/socket.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Socket = void 0;
+    var index_js_1 = require_transports();
+    var util_js_1 = require_util();
+    var parseqs_js_1 = require_parseqs();
+    var parseuri_js_1 = require_parseuri();
+    var debug_1 = __importDefault(require_browser());
+    var component_emitter_1 = require_component_emitter();
+    var engine_io_parser_1 = require_cjs();
+    var websocket_constructor_js_1 = require_websocket_constructor_browser();
+    var debug = (0, debug_1.default)("engine.io-client:socket");
+    var Socket = class _Socket extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Socket");
+      }
+      /**
+       * Socket constructor.
+       *
+       * @param {String|Object} uri - uri or options
+       * @param {Object} opts - options
+       */
+      constructor(uri, opts = {}) {
+        super();
+        this.binaryType = websocket_constructor_js_1.defaultBinaryType;
+        this.writeBuffer = [];
+        if (uri && "object" === typeof uri) {
+          opts = uri;
+          uri = null;
+        }
+        if (uri) {
+          uri = (0, parseuri_js_1.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 = (0, parseuri_js_1.parse)(opts.host).host;
+        }
+        (0, util_js_1.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 = (0, parseqs_js_1.decode)(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) {
+        debug('creating transport "%s"', name);
+        const query = Object.assign({}, this.opts.query);
+        query.EIO = engine_io_parser_1.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]);
+        debug("options: %j", opts);
+        return new index_js_1.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) {
+          debug("error while creating transport: %s", 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) {
+        debug("setting transport %s", transport.name);
+        if (this.transport) {
+          debug("clearing existing transport %s", this.transport.name);
+          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) {
+        debug('probing transport "%s"', name);
+        let transport = this.createTransport(name);
+        let failed = false;
+        _Socket.priorWebsocketSuccess = false;
+        const onTransportOpen = /* @__PURE__ */ __name(() => {
+          if (failed)
+            return;
+          debug('probe transport "%s" opened', name);
+          transport.send([{ type: "ping", data: "probe" }]);
+          transport.once("packet", (msg) => {
+            if (failed)
+              return;
+            if ("pong" === msg.type && "probe" === msg.data) {
+              debug('probe transport "%s" pong', name);
+              this.upgrading = true;
+              this.emitReserved("upgrading", transport);
+              if (!transport)
+                return;
+              _Socket.priorWebsocketSuccess = "websocket" === transport.name;
+              debug('pausing current transport "%s"', this.transport.name);
+              this.transport.pause(() => {
+                if (failed)
+                  return;
+                if ("closed" === this.readyState)
+                  return;
+                debug("changing transport and sending upgrade packet");
+                cleanup();
+                this.setTransport(transport);
+                transport.send([{ type: "upgrade" }]);
+                this.emitReserved("upgrade", transport);
+                transport = null;
+                this.upgrading = false;
+                this.flush();
+              });
+            } else {
+              debug('probe transport "%s" failed', name);
+              const err = new Error("probe error");
+              err.transport = transport.name;
+              this.emitReserved("upgradeError", err);
+            }
+          });
+        }, "onTransportOpen");
+        function freezeTransport() {
+          if (failed)
+            return;
+          failed = true;
+          cleanup();
+          transport.close();
+          transport = null;
+        }
+        __name(freezeTransport, "freezeTransport");
+        const onerror = /* @__PURE__ */ __name((err) => {
+          const error = new Error("probe error: " + err);
+          error.transport = transport.name;
+          freezeTransport();
+          debug('probe transport "%s" failed because of error: %s', name, err);
+          this.emitReserved("upgradeError", error);
+        }, "onerror");
+        function onTransportClose() {
+          onerror("transport closed");
+        }
+        __name(onTransportClose, "onTransportClose");
+        function onclose() {
+          onerror("socket closed");
+        }
+        __name(onclose, "onclose");
+        function onupgrade(to) {
+          if (transport && to.name !== transport.name) {
+            debug('"%s" works - aborting "%s"', to.name, transport.name);
+            freezeTransport();
+          }
+        }
+        __name(onupgrade, "onupgrade");
+        const cleanup = /* @__PURE__ */ __name(() => {
+          transport.removeListener("open", onTransportOpen);
+          transport.removeListener("error", onerror);
+          transport.removeListener("close", onTransportClose);
+          this.off("close", onclose);
+          this.off("upgrading", onupgrade);
+        }, "cleanup");
+        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() {
+        debug("socket open");
+        this.readyState = "open";
+        _Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
+        this.emitReserved("open");
+        this.flush();
+        if ("open" === this.readyState && this.opts.upgrade) {
+          debug("starting upgrade probes");
+          let i = 0;
+          const l = this.upgrades.length;
+          for (; i < l; i++) {
+            this.probe(this.upgrades[i]);
+          }
+        }
+      }
+      /**
+       * Handles a packet.
+       *
+       * @private
+       */
+      onPacket(packet) {
+        if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
+          debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
+          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 {
+          debug('packet received with socket readyState "%s"', this.readyState);
+        }
+      }
+      /**
+       * 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();
+          debug("flushing %d packets in socket", packets.length);
+          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 i = 0; i < this.writeBuffer.length; i++) {
+          const data = this.writeBuffer[i].data;
+          if (data) {
+            payloadSize += (0, util_js_1.byteLength)(data);
+          }
+          if (i > 0 && payloadSize > this.maxPayload) {
+            debug("only send %d out of %d packets", i, this.writeBuffer.length);
+            return this.writeBuffer.slice(0, i);
+          }
+          payloadSize += 2;
+        }
+        debug("payload size is %d (max: %d)", payloadSize, this.maxPayload);
+        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 = /* @__PURE__ */ __name(() => {
+          this.onClose("forced close");
+          debug("socket closing - telling transport to close");
+          this.transport.close();
+        }, "close");
+        const cleanupAndClose = /* @__PURE__ */ __name(() => {
+          this.off("upgrade", cleanupAndClose);
+          this.off("upgradeError", cleanupAndClose);
+          close();
+        }, "cleanupAndClose");
+        const waitForUpgrade = /* @__PURE__ */ __name(() => {
+          this.once("upgrade", cleanupAndClose);
+          this.once("upgradeError", cleanupAndClose);
+        }, "waitForUpgrade");
+        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) {
+        debug("socket error %j", 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) {
+          debug('socket close with reason: "%s"', reason);
+          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 i = 0;
+        const j = upgrades.length;
+        for (; i < j; i++) {
+          if (~this.transports.indexOf(upgrades[i]))
+            filteredUpgrades.push(upgrades[i]);
+        }
+        return filteredUpgrades;
+      }
+    };
+    exports.Socket = Socket;
+    Socket.protocol = engine_io_parser_1.protocol;
+  }
+});
+
+// node_modules/engine.io-client/build/cjs/index.js
+var require_cjs2 = __commonJS({
+  "node_modules/engine.io-client/build/cjs/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.nextTick = exports.parse = exports.installTimerFunctions = exports.transports = exports.Transport = exports.protocol = exports.Socket = void 0;
+    var socket_js_1 = require_socket();
+    Object.defineProperty(exports, "Socket", { enumerable: true, get: function() {
+      return socket_js_1.Socket;
+    } });
+    exports.protocol = socket_js_1.Socket.protocol;
+    var transport_js_1 = require_transport();
+    Object.defineProperty(exports, "Transport", { enumerable: true, get: function() {
+      return transport_js_1.Transport;
+    } });
+    var index_js_1 = require_transports();
+    Object.defineProperty(exports, "transports", { enumerable: true, get: function() {
+      return index_js_1.transports;
+    } });
+    var util_js_1 = require_util();
+    Object.defineProperty(exports, "installTimerFunctions", { enumerable: true, get: function() {
+      return util_js_1.installTimerFunctions;
+    } });
+    var parseuri_js_1 = require_parseuri();
+    Object.defineProperty(exports, "parse", { enumerable: true, get: function() {
+      return parseuri_js_1.parse;
+    } });
+    var websocket_constructor_js_1 = require_websocket_constructor_browser();
+    Object.defineProperty(exports, "nextTick", { enumerable: true, get: function() {
+      return websocket_constructor_js_1.nextTick;
+    } });
+  }
+});
+
+// node_modules/socket.io-client/build/cjs/url.js
+var require_url = __commonJS({
+  "node_modules/socket.io-client/build/cjs/url.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.url = void 0;
+    var engine_io_client_1 = require_cjs2();
+    var debug_1 = __importDefault(require_browser());
+    var debug = debug_1.default("socket.io-client:url");
+    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)) {
+          debug("protocol-less url %s", uri);
+          if ("undefined" !== typeof loc) {
+            uri = loc.protocol + "//" + uri;
+          } else {
+            uri = "https://" + uri;
+          }
+        }
+        debug("parse %s", uri);
+        obj = engine_io_client_1.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;
+    }
+    __name(url, "url");
+    exports.url = url;
+  }
+});
+
+// node_modules/socket.io-parser/build/cjs/is-binary.js
+var require_is_binary = __commonJS({
+  "node_modules/socket.io-parser/build/cjs/is-binary.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hasBinary = exports.isBinary = void 0;
+    var withNativeArrayBuffer = typeof ArrayBuffer === "function";
+    var isView = /* @__PURE__ */ __name((obj) => {
+      return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
+    }, "isView");
+    var toString = Object.prototype.toString;
+    var withNativeBlob = 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 withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;
+    }
+    __name(isBinary, "isBinary");
+    exports.isBinary = isBinary;
+    function hasBinary(obj, toJSON) {
+      if (!obj || typeof obj !== "object") {
+        return false;
+      }
+      if (Array.isArray(obj)) {
+        for (let i = 0, l = obj.length; i < l; i++) {
+          if (hasBinary(obj[i])) {
+            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;
+    }
+    __name(hasBinary, "hasBinary");
+    exports.hasBinary = hasBinary;
+  }
+});
+
+// node_modules/socket.io-parser/build/cjs/binary.js
+var require_binary = __commonJS({
+  "node_modules/socket.io-parser/build/cjs/binary.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.reconstructPacket = exports.deconstructPacket = void 0;
+    var is_binary_js_1 = require_is_binary();
+    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 };
+    }
+    __name(deconstructPacket, "deconstructPacket");
+    exports.deconstructPacket = deconstructPacket;
+    function _deconstructPacket(data, buffers) {
+      if (!data)
+        return data;
+      if ((0, is_binary_js_1.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 i = 0; i < data.length; i++) {
+          newData[i] = _deconstructPacket(data[i], 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;
+    }
+    __name(_deconstructPacket, "_deconstructPacket");
+    function reconstructPacket(packet, buffers) {
+      packet.data = _reconstructPacket(packet.data, buffers);
+      delete packet.attachments;
+      return packet;
+    }
+    __name(reconstructPacket, "reconstructPacket");
+    exports.reconstructPacket = reconstructPacket;
+    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 i = 0; i < data.length; i++) {
+          data[i] = _reconstructPacket(data[i], 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;
+    }
+    __name(_reconstructPacket, "_reconstructPacket");
+  }
+});
+
+// node_modules/socket.io-parser/build/cjs/index.js
+var require_cjs3 = __commonJS({
+  "node_modules/socket.io-parser/build/cjs/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Decoder = exports.Encoder = exports.PacketType = exports.protocol = void 0;
+    var component_emitter_1 = require_component_emitter();
+    var binary_js_1 = require_binary();
+    var is_binary_js_1 = require_is_binary();
+    var debug_1 = require_browser();
+    var debug = (0, debug_1.default)("socket.io-parser");
+    var RESERVED_EVENTS = [
+      "connect",
+      "connect_error",
+      "disconnect",
+      "disconnecting",
+      "newListener",
+      "removeListener"
+      // used by the Node.js EventEmitter
+    ];
+    exports.protocol = 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 = exports.PacketType || (exports.PacketType = {}));
+    var Encoder = class {
+      static {
+        __name(this, "Encoder");
+      }
+      /**
+       * 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) {
+        debug("encoding packet %j", obj);
+        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
+          if ((0, is_binary_js_1.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);
+        }
+        debug("encoded %j as %s", obj, str);
+        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 = (0, binary_js_1.deconstructPacket)(obj);
+        const pack = this.encodeAsString(deconstruction.packet);
+        const buffers = deconstruction.buffers;
+        buffers.unshift(pack);
+        return buffers;
+      }
+    };
+    exports.Encoder = Encoder;
+    function isObject(value) {
+      return Object.prototype.toString.call(value) === "[object Object]";
+    }
+    __name(isObject, "isObject");
+    var Decoder = class _Decoder extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Decoder");
+      }
+      /**
+       * 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 ((0, is_binary_js_1.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 i = 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 = i + 1;
+          while (str.charAt(++i) !== "-" && i != str.length) {
+          }
+          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(i + 1)) {
+          const start = i + 1;
+          while (++i) {
+            const c = str.charAt(i);
+            if ("," === c)
+              break;
+            if (i === str.length)
+              break;
+          }
+          p.nsp = str.substring(start, i);
+        } else {
+          p.nsp = "/";
+        }
+        const next = str.charAt(i + 1);
+        if ("" !== next && Number(next) == next) {
+          const start = i + 1;
+          while (++i) {
+            const c = str.charAt(i);
+            if (null == c || Number(c) != c) {
+              --i;
+              break;
+            }
+            if (i === str.length)
+              break;
+          }
+          p.id = Number(str.substring(start, i + 1));
+        }
+        if (str.charAt(++i)) {
+          const payload = this.tryParse(str.substr(i));
+          if (_Decoder.isPayloadValid(p.type, payload)) {
+            p.data = payload;
+          } else {
+            throw new Error("invalid payload");
+          }
+        }
+        debug("decoded %s as %j", str, p);
+        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;
+        }
+      }
+    };
+    exports.Decoder = Decoder;
+    var BinaryReconstructor = class {
+      static {
+        __name(this, "BinaryReconstructor");
+      }
+      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 = (0, binary_js_1.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/cjs/on.js
+var require_on = __commonJS({
+  "node_modules/socket.io-client/build/cjs/on.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.on = void 0;
+    function on(obj, ev, fn) {
+      obj.on(ev, fn);
+      return /* @__PURE__ */ __name(function subDestroy() {
+        obj.off(ev, fn);
+      }, "subDestroy");
+    }
+    __name(on, "on");
+    exports.on = on;
+  }
+});
+
+// node_modules/socket.io-client/build/cjs/socket.js
+var require_socket2 = __commonJS({
+  "node_modules/socket.io-client/build/cjs/socket.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Socket = void 0;
+    var socket_io_parser_1 = require_cjs3();
+    var on_js_1 = require_on();
+    var component_emitter_1 = require_component_emitter();
+    var debug_1 = __importDefault(require_browser());
+    var debug = debug_1.default("socket.io-client:socket");
+    var RESERVED_EVENTS = 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 Socket = class extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Socket");
+      }
+      /**
+       * `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_js_1.on(io, "open", this.onopen.bind(this)),
+          on_js_1.on(io, "packet", this.onpacket.bind(this)),
+          on_js_1.on(io, "error", this.onerror.bind(this)),
+          on_js_1.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_EVENTS.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: socket_io_parser_1.PacketType.EVENT,
+          data: args
+        };
+        packet.options = {};
+        packet.options.compress = this.flags.compress !== false;
+        if ("function" === typeof args[args.length - 1]) {
+          const id = this.ids++;
+          debug("emitting packet with ack id %d", id);
+          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) {
+          debug("discard packet as the transport is not currently writable");
+        } 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 i = 0; i < this.sendBuffer.length; i++) {
+            if (this.sendBuffer[i].id === id) {
+              debug("removing packet with ack id %d from the buffer", id);
+              this.sendBuffer.splice(i, 1);
+            }
+          }
+          debug("event with ack id %d has timed out after %d ms", id, timeout);
+          ack.call(this, new Error("operation has timed out"));
+        }, timeout);
+        this.acks[id] = (...args) => {
+          this.io.clearTimeoutFn(timer);
+          ack.apply(this, [null, ...args]);
+        };
+      }
+      /**
+       * 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) {
+        const withErr = this.flags.timeout !== void 0 || this._opts.ackTimeout !== void 0;
+        return new Promise((resolve, reject) => {
+          args.push((arg1, arg2) => {
+            if (withErr) {
+              return arg1 ? reject(arg1) : resolve(arg2);
+            } else {
+              return resolve(arg1);
+            }
+          });
+          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) {
+              debug("packet [%d] is discarded after %d tries", packet.id, packet.tryCount);
+              this._queue.shift();
+              if (ack) {
+                ack(err);
+              }
+            }
+          } else {
+            debug("packet [%d] was successfully sent", packet.id);
+            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) {
+        debug("draining queue");
+        if (!this.connected || this._queue.length === 0) {
+          return;
+        }
+        const packet = this._queue[0];
+        if (packet.pending && !force) {
+          debug("packet [%d] has already been sent and is waiting for an ack", packet.id);
+          return;
+        }
+        packet.pending = true;
+        packet.tryCount++;
+        debug("sending packet [%d] (try n\xB0%d)", packet.id, 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() {
+        debug("transport is open - connecting");
+        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: socket_io_parser_1.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) {
+        debug("close (%s)", reason);
+        this.connected = false;
+        delete this.id;
+        this.emitReserved("disconnect", reason, description);
+      }
+      /**
+       * Called with socket packet.
+       *
+       * @param packet
+       * @private
+       */
+      onpacket(packet) {
+        const sameNamespace = packet.nsp === this.nsp;
+        if (!sameNamespace)
+          return;
+        switch (packet.type) {
+          case socket_io_parser_1.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 socket_io_parser_1.PacketType.EVENT:
+          case socket_io_parser_1.PacketType.BINARY_EVENT:
+            this.onevent(packet);
+            break;
+          case socket_io_parser_1.PacketType.ACK:
+          case socket_io_parser_1.PacketType.BINARY_ACK:
+            this.onack(packet);
+            break;
+          case socket_io_parser_1.PacketType.DISCONNECT:
+            this.ondisconnect();
+            break;
+          case socket_io_parser_1.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 || [];
+        debug("emitting event %j", args);
+        if (null != packet.id) {
+          debug("attaching ack callback to event");
+          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;
+          debug("sending ack %j", args);
+          self2.packet({
+            type: socket_io_parser_1.PacketType.ACK,
+            id,
+            data: args
+          });
+        };
+      }
+      /**
+       * Called upon a server acknowlegement.
+       *
+       * @param packet
+       * @private
+       */
+      onack(packet) {
+        const ack = this.acks[packet.id];
+        if ("function" === typeof ack) {
+          debug("calling ack %s with %j", packet.id, packet.data);
+          ack.apply(this, packet.data);
+          delete this.acks[packet.id];
+        } else {
+          debug("bad ack %s", packet.id);
+        }
+      }
+      /**
+       * Called upon server connect.
+       *
+       * @private
+       */
+      onconnect(id, pid) {
+        debug("socket connected with id %s", id);
+        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() {
+        debug("server disconnect (%s)", this.nsp);
+        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) {
+          debug("performing disconnect (%s)", this.nsp);
+          this.packet({ type: socket_io_parser_1.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 i = 0; i < listeners.length; i++) {
+            if (listener === listeners[i]) {
+              listeners.splice(i, 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 i = 0; i < listeners.length; i++) {
+            if (listener === listeners[i]) {
+              listeners.splice(i, 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);
+          }
+        }
+      }
+    };
+    exports.Socket = Socket;
+  }
+});
+
+// node_modules/socket.io-client/build/cjs/contrib/backo2.js
+var require_backo2 = __commonJS({
+  "node_modules/socket.io-client/build/cjs/contrib/backo2.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Backoff = void 0;
+    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;
+    }
+    __name(Backoff, "Backoff");
+    exports.Backoff = Backoff;
+    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/cjs/manager.js
+var require_manager = __commonJS({
+  "node_modules/socket.io-client/build/cjs/manager.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    } : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule)
+        return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod)
+          if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+            __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Manager = void 0;
+    var engine_io_client_1 = require_cjs2();
+    var socket_js_1 = require_socket2();
+    var parser = __importStar(require_cjs3());
+    var on_js_1 = require_on();
+    var backo2_js_1 = require_backo2();
+    var component_emitter_1 = require_component_emitter();
+    var debug_1 = __importDefault(require_browser());
+    var debug = debug_1.default("socket.io-client:manager");
+    var Manager = class extends component_emitter_1.Emitter {
+      static {
+        __name(this, "Manager");
+      }
+      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;
+        engine_io_client_1.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 backo2_js_1.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 || parser;
+        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) {
+        debug("readyState %s", this._readyState);
+        if (~this._readyState.indexOf("open"))
+          return this;
+        debug("opening %s", this.uri);
+        this.engine = new engine_io_client_1.Socket(this.uri, this.opts);
+        const socket = this.engine;
+        const self2 = this;
+        this._readyState = "opening";
+        this.skipReconnect = false;
+        const openSubDestroy = on_js_1.on(socket, "open", function() {
+          self2.onopen();
+          fn && fn();
+        });
+        const onError = /* @__PURE__ */ __name((err) => {
+          debug("error");
+          this.cleanup();
+          this._readyState = "closed";
+          this.emitReserved("error", err);
+          if (fn) {
+            fn(err);
+          } else {
+            this.maybeReconnectOnOpen();
+          }
+        }, "onError");
+        const errorSub = on_js_1.on(socket, "error", onError);
+        if (false !== this._timeout) {
+          const timeout = this._timeout;
+          debug("connect attempt will timeout after %d", timeout);
+          const timer = this.setTimeoutFn(() => {
+            debug("connect attempt timed out after %d", timeout);
+            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() {
+        debug("open");
+        this.cleanup();
+        this._readyState = "open";
+        this.emitReserved("open");
+        const socket = this.engine;
+        this.subs.push(on_js_1.on(socket, "ping", this.onping.bind(this)), on_js_1.on(socket, "data", this.ondata.bind(this)), on_js_1.on(socket, "error", this.onerror.bind(this)), on_js_1.on(socket, "close", this.onclose.bind(this)), on_js_1.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) {
+        engine_io_client_1.nextTick(() => {
+          this.emitReserved("packet", packet);
+        }, this.setTimeoutFn);
+      }
+      /**
+       * Called upon socket error.
+       *
+       * @private
+       */
+      onerror(err) {
+        debug("error", 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 socket_js_1.Socket(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) {
+            debug("socket %s is still active, skipping close", nsp);
+            return;
+          }
+        }
+        this._close();
+      }
+      /**
+       * Writes a packet.
+       *
+       * @param packet
+       * @private
+       */
+      _packet(packet) {
+        debug("writing packet %j", packet);
+        const encodedPackets = this.encoder.encode(packet);
+        for (let i = 0; i < encodedPackets.length; i++) {
+          this.engine.write(encodedPackets[i], packet.options);
+        }
+      }
+      /**
+       * Clean up transport subscriptions and packet buffer.
+       *
+       * @private
+       */
+      cleanup() {
+        debug("cleanup");
+        this.subs.forEach((subDestroy) => subDestroy());
+        this.subs.length = 0;
+        this.decoder.destroy();
+      }
+      /**
+       * Close the current socket.
+       *
+       * @private
+       */
+      _close() {
+        debug("disconnect");
+        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) {
+        debug("closed due to %s", reason);
+        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) {
+          debug("reconnect failed");
+          this.backoff.reset();
+          this.emitReserved("reconnect_failed");
+          this._reconnecting = false;
+        } else {
+          const delay = this.backoff.duration();
+          debug("will wait %dms before reconnect attempt", delay);
+          this._reconnecting = true;
+          const timer = this.setTimeoutFn(() => {
+            if (self2.skipReconnect)
+              return;
+            debug("attempting reconnect");
+            this.emitReserved("reconnect_attempt", self2.backoff.attempts);
+            if (self2.skipReconnect)
+              return;
+            self2.open((err) => {
+              if (err) {
+                debug("reconnect attempt error");
+                self2._reconnecting = false;
+                self2.reconnect();
+                this.emitReserved("reconnect_error", err);
+              } else {
+                debug("reconnect success");
+                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);
+      }
+    };
+    exports.Manager = Manager;
+  }
+});
+
+// node_modules/socket.io-client/build/cjs/index.js
+var require_cjs4 = __commonJS({
+  "node_modules/socket.io-client/build/cjs/index.js"(exports, module) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default = exports.connect = exports.io = exports.Socket = exports.Manager = exports.protocol = void 0;
+    var url_js_1 = require_url();
+    var manager_js_1 = require_manager();
+    Object.defineProperty(exports, "Manager", { enumerable: true, get: function() {
+      return manager_js_1.Manager;
+    } });
+    var socket_js_1 = require_socket2();
+    Object.defineProperty(exports, "Socket", { enumerable: true, get: function() {
+      return socket_js_1.Socket;
+    } });
+    var debug_1 = __importDefault(require_browser());
+    var debug = debug_1.default("socket.io-client");
+    var cache = {};
+    function lookup(uri, opts) {
+      if (typeof uri === "object") {
+        opts = uri;
+        uri = void 0;
+      }
+      opts = opts || {};
+      const parsed = url_js_1.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) {
+        debug("ignoring socket cache for %s", source);
+        io = new manager_js_1.Manager(source, opts);
+      } else {
+        if (!cache[id]) {
+          debug("new io instance for %s", source);
+          cache[id] = new manager_js_1.Manager(source, opts);
+        }
+        io = cache[id];
+      }
+      if (parsed.query && !opts.query) {
+        opts.query = parsed.queryKey;
+      }
+      return io.socket(parsed.path, opts);
+    }
+    __name(lookup, "lookup");
+    exports.io = lookup;
+    exports.connect = lookup;
+    exports.default = lookup;
+    Object.assign(lookup, {
+      Manager: manager_js_1.Manager,
+      Socket: socket_js_1.Socket,
+      io: lookup,
+      connect: lookup
+    });
+    var socket_io_parser_1 = require_cjs3();
+    Object.defineProperty(exports, "protocol", { enumerable: true, get: function() {
+      return socket_io_parser_1.protocol;
+    } });
+    module.exports = lookup;
+  }
+});
+
+// node_modules/events/events.js
+var require_events = __commonJS({
+  "node_modules/events/events.js"(exports, module) {
+    "use strict";
+    var R = typeof Reflect === "object" ? Reflect : null;
+    var ReflectApply = R && typeof R.apply === "function" ? R.apply : /* @__PURE__ */ __name(function ReflectApply2(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    }, "ReflectApply");
+    var ReflectOwnKeys;
+    if (R && typeof R.ownKeys === "function") {
+      ReflectOwnKeys = R.ownKeys;
+    } else if (Object.getOwnPropertySymbols) {
+      ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+      }, "ReflectOwnKeys");
+    } else {
+      ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
+        return Object.getOwnPropertyNames(target);
+      }, "ReflectOwnKeys");
+    }
+    function ProcessEmitWarning(warning) {
+      if (console && console.warn)
+        console.warn(warning);
+    }
+    __name(ProcessEmitWarning, "ProcessEmitWarning");
+    var NumberIsNaN = Number.isNaN || /* @__PURE__ */ __name(function NumberIsNaN2(value) {
+      return value !== value;
+    }, "NumberIsNaN");
+    function EventEmitter() {
+      EventEmitter.init.call(this);
+    }
+    __name(EventEmitter, "EventEmitter");
+    module.exports = EventEmitter;
+    module.exports.once = once;
+    EventEmitter.EventEmitter = EventEmitter;
+    EventEmitter.prototype._events = void 0;
+    EventEmitter.prototype._eventsCount = 0;
+    EventEmitter.prototype._maxListeners = void 0;
+    var defaultMaxListeners = 10;
+    function checkListener(listener) {
+      if (typeof listener !== "function") {
+        throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+      }
+    }
+    __name(checkListener, "checkListener");
+    Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+      enumerable: true,
+      get: function() {
+        return defaultMaxListeners;
+      },
+      set: function(arg) {
+        if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+          throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+        }
+        defaultMaxListeners = arg;
+      }
+    });
+    EventEmitter.init = function() {
+      if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+      }
+      this._maxListeners = this._maxListeners || void 0;
+    };
+    EventEmitter.prototype.setMaxListeners = /* @__PURE__ */ __name(function setMaxListeners(n) {
+      if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+        throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+      }
+      this._maxListeners = n;
+      return this;
+    }, "setMaxListeners");
+    function _getMaxListeners(that) {
+      if (that._maxListeners === void 0)
+        return EventEmitter.defaultMaxListeners;
+      return that._maxListeners;
+    }
+    __name(_getMaxListeners, "_getMaxListeners");
+    EventEmitter.prototype.getMaxListeners = /* @__PURE__ */ __name(function getMaxListeners() {
+      return _getMaxListeners(this);
+    }, "getMaxListeners");
+    EventEmitter.prototype.emit = /* @__PURE__ */ __name(function emit(type) {
+      var args = [];
+      for (var i = 1; i < arguments.length; i++)
+        args.push(arguments[i]);
+      var doError = type === "error";
+      var events = this._events;
+      if (events !== void 0)
+        doError = doError && events.error === void 0;
+      else if (!doError)
+        return false;
+      if (doError) {
+        var er;
+        if (args.length > 0)
+          er = args[0];
+        if (er instanceof Error) {
+          throw er;
+        }
+        var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+        err.context = er;
+        throw err;
+      }
+      var handler = events[type];
+      if (handler === void 0)
+        return false;
+      if (typeof handler === "function") {
+        ReflectApply(handler, this, args);
+      } else {
+        var len = handler.length;
+        var listeners = arrayClone(handler, len);
+        for (var i = 0; i < len; ++i)
+          ReflectApply(listeners[i], this, args);
+      }
+      return true;
+    }, "emit");
+    function _addListener(target, type, listener, prepend) {
+      var m;
+      var events;
+      var existing;
+      checkListener(listener);
+      events = target._events;
+      if (events === void 0) {
+        events = target._events = /* @__PURE__ */ Object.create(null);
+        target._eventsCount = 0;
+      } else {
+        if (events.newListener !== void 0) {
+          target.emit(
+            "newListener",
+            type,
+            listener.listener ? listener.listener : listener
+          );
+          events = target._events;
+        }
+        existing = events[type];
+      }
+      if (existing === void 0) {
+        existing = events[type] = listener;
+        ++target._eventsCount;
+      } else {
+        if (typeof existing === "function") {
+          existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+        } else if (prepend) {
+          existing.unshift(listener);
+        } else {
+          existing.push(listener);
+        }
+        m = _getMaxListeners(target);
+        if (m > 0 && existing.length > m && !existing.warned) {
+          existing.warned = true;
+          var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+          w.name = "MaxListenersExceededWarning";
+          w.emitter = target;
+          w.type = type;
+          w.count = existing.length;
+          ProcessEmitWarning(w);
+        }
+      }
+      return target;
+    }
+    __name(_addListener, "_addListener");
+    EventEmitter.prototype.addListener = /* @__PURE__ */ __name(function addListener(type, listener) {
+      return _addListener(this, type, listener, false);
+    }, "addListener");
+    EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+    EventEmitter.prototype.prependListener = /* @__PURE__ */ __name(function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    }, "prependListener");
+    function onceWrapper() {
+      if (!this.fired) {
+        this.target.removeListener(this.type, this.wrapFn);
+        this.fired = true;
+        if (arguments.length === 0)
+          return this.listener.call(this.target);
+        return this.listener.apply(this.target, arguments);
+      }
+    }
+    __name(onceWrapper, "onceWrapper");
+    function _onceWrap(target, type, listener) {
+      var state = { fired: false, wrapFn: void 0, target, type, listener };
+      var wrapped = onceWrapper.bind(state);
+      wrapped.listener = listener;
+      state.wrapFn = wrapped;
+      return wrapped;
+    }
+    __name(_onceWrap, "_onceWrap");
+    EventEmitter.prototype.once = /* @__PURE__ */ __name(function once2(type, listener) {
+      checkListener(listener);
+      this.on(type, _onceWrap(this, type, listener));
+      return this;
+    }, "once");
+    EventEmitter.prototype.prependOnceListener = /* @__PURE__ */ __name(function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    }, "prependOnceListener");
+    EventEmitter.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+      checkListener(listener);
+      events = this._events;
+      if (events === void 0)
+        return this;
+      list = events[type];
+      if (list === void 0)
+        return this;
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = /* @__PURE__ */ Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit("removeListener", type, list.listener || listener);
+        }
+      } else if (typeof list !== "function") {
+        position = -1;
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+        if (position < 0)
+          return this;
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+        if (list.length === 1)
+          events[type] = list[0];
+        if (events.removeListener !== void 0)
+          this.emit("removeListener", type, originalListener || listener);
+      }
+      return this;
+    }, "removeListener");
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners(type) {
+      var listeners, events, i;
+      events = this._events;
+      if (events === void 0)
+        return this;
+      if (events.removeListener === void 0) {
+        if (arguments.length === 0) {
+          this._events = /* @__PURE__ */ Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== void 0) {
+          if (--this._eventsCount === 0)
+            this._events = /* @__PURE__ */ Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === "removeListener")
+            continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners("removeListener");
+        this._events = /* @__PURE__ */ Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+      listeners = events[type];
+      if (typeof listeners === "function") {
+        this.removeListener(type, listeners);
+      } else if (listeners !== void 0) {
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+      return this;
+    }, "removeAllListeners");
+    function _listeners(target, type, unwrap) {
+      var events = target._events;
+      if (events === void 0)
+        return [];
+      var evlistener = events[type];
+      if (evlistener === void 0)
+        return [];
+      if (typeof evlistener === "function")
+        return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+      return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+    }
+    __name(_listeners, "_listeners");
+    EventEmitter.prototype.listeners = /* @__PURE__ */ __name(function listeners(type) {
+      return _listeners(this, type, true);
+    }, "listeners");
+    EventEmitter.prototype.rawListeners = /* @__PURE__ */ __name(function rawListeners(type) {
+      return _listeners(this, type, false);
+    }, "rawListeners");
+    EventEmitter.listenerCount = function(emitter, type) {
+      if (typeof emitter.listenerCount === "function") {
+        return emitter.listenerCount(type);
+      } else {
+        return listenerCount.call(emitter, type);
+      }
+    };
+    EventEmitter.prototype.listenerCount = listenerCount;
+    function listenerCount(type) {
+      var events = this._events;
+      if (events !== void 0) {
+        var evlistener = events[type];
+        if (typeof evlistener === "function") {
+          return 1;
+        } else if (evlistener !== void 0) {
+          return evlistener.length;
+        }
+      }
+      return 0;
+    }
+    __name(listenerCount, "listenerCount");
+    EventEmitter.prototype.eventNames = /* @__PURE__ */ __name(function eventNames() {
+      return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+    }, "eventNames");
+    function arrayClone(arr, n) {
+      var copy = new Array(n);
+      for (var i = 0; i < n; ++i)
+        copy[i] = arr[i];
+      return copy;
+    }
+    __name(arrayClone, "arrayClone");
+    function spliceOne(list, index) {
+      for (; index + 1 < list.length; index++)
+        list[index] = list[index + 1];
+      list.pop();
+    }
+    __name(spliceOne, "spliceOne");
+    function unwrapListeners(arr) {
+      var ret = new Array(arr.length);
+      for (var i = 0; i < ret.length; ++i) {
+        ret[i] = arr[i].listener || arr[i];
+      }
+      return ret;
+    }
+    __name(unwrapListeners, "unwrapListeners");
+    function once(emitter, name) {
+      return new Promise(function(resolve, reject) {
+        function errorListener(err) {
+          emitter.removeListener(name, resolver);
+          reject(err);
+        }
+        __name(errorListener, "errorListener");
+        function resolver() {
+          if (typeof emitter.removeListener === "function") {
+            emitter.removeListener("error", errorListener);
+          }
+          resolve([].slice.call(arguments));
+        }
+        __name(resolver, "resolver");
+        ;
+        eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+        if (name !== "error") {
+          addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+        }
+      });
+    }
+    __name(once, "once");
+    function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+      if (typeof emitter.on === "function") {
+        eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+      }
+    }
+    __name(addErrorHandlerIfEventEmitter, "addErrorHandlerIfEventEmitter");
+    function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+      if (typeof emitter.on === "function") {
+        if (flags.once) {
+          emitter.once(name, listener);
+        } else {
+          emitter.on(name, listener);
+        }
+      } else if (typeof emitter.addEventListener === "function") {
+        emitter.addEventListener(name, /* @__PURE__ */ __name(function wrapListener(arg) {
+          if (flags.once) {
+            emitter.removeEventListener(name, wrapListener);
+          }
+          listener(arg);
+        }, "wrapListener"));
+      } else {
+        throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+      }
+    }
+    __name(eventTargetAgnosticAddListener, "eventTargetAgnosticAddListener");
+  }
+});
+
+// src/SocketIoClient/index.js
+var require_SocketIoClient = __commonJS({
+  "src/SocketIoClient/index.js"(exports, module) {
+    var io = require_cjs4();
+    var { EventEmitter } = require_events();
+    module.exports = class SocketIoClient extends EventEmitter {
+      static {
+        __name(this, "SocketIoClient");
+      }
+      constructor(config = { url: null, propertyId: null, options: {} }) {
+        super();
+        if (!config.url)
+          throw new Error("Websocket URL / endpoint not provided");
+        if (!config.propertyId)
+          throw new Error("Property ID not provided");
+        this.url = config.url;
+        this.propertyId = config.propertyId;
+        this.options = {
+          autoConnect: false,
+          forceNew: false,
+          reconnection: true,
+          reconnectionAttempts: Infinity,
+          reconnectionDelay: 1e3,
+          withCredentials: true,
+          transports: ["websocket", "polling"],
+          upgrade: true,
+          ...config.options
+        };
+        this.socket = io(this.url, this.options);
+        this.socket.on("connect", () => {
+          this.emit("connect", this.socket);
+        });
+        this.socket.on("disconnect", (reason) => {
+          this.emit("disconnect", reason);
+        });
+        this.socket.on("reconnect_attempt", (data) => {
+          this.emit("reconnect_attempt", data);
+        });
+        this.socket.on("connect_error", (error) => {
+          this.emit("connect_error", error);
+        });
+      }
+      get connected() {
+        return this.socket?.connected || false;
+      }
+      get disconnected() {
+        return this.socket?.disconnected || false;
+      }
+      connect() {
+        this.socket.connect();
+      }
+      disconnect() {
+        this.socket.disconnect();
+      }
+      reconnect() {
+        this.disconnect();
+        this.connect();
+      }
+      subscribe(event, callback) {
+        this.socket.on(event, callback);
+      }
+      unsubscribe(event, callback) {
+        this.socket.off(event, callback);
+      }
+      send(event, { data = {}, query = {}, ...rest }) {
+        this.socket.emit(event, { data, query, ...rest });
+      }
+    };
+  }
+});
+export default require_SocketIoClient();
+//# sourceMappingURL=SocketIoClient.js.map