{"version":3,"sources":["src/app/sockets/socket-io.token.ts","node_modules/engine.io-parser/build/esm/commons.js","node_modules/engine.io-parser/build/esm/encodePacket.browser.js","node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js","node_modules/engine.io-parser/build/esm/decodePacket.browser.js","node_modules/engine.io-parser/build/esm/index.js","node_modules/@socket.io/component-emitter/lib/esm/index.js","node_modules/engine.io-client/build/esm/globalThis.browser.js","node_modules/engine.io-client/build/esm/util.js","node_modules/engine.io-client/build/esm/contrib/parseqs.js","node_modules/engine.io-client/build/esm/transport.js","node_modules/engine.io-client/build/esm/contrib/yeast.js","node_modules/engine.io-client/build/esm/contrib/has-cors.js","node_modules/engine.io-client/build/esm/transports/xmlhttprequest.browser.js","node_modules/engine.io-client/build/esm/transports/polling.js","node_modules/engine.io-client/build/esm/transports/websocket-constructor.browser.js","node_modules/engine.io-client/build/esm/transports/websocket.js","node_modules/engine.io-client/build/esm/transports/webtransport.js","node_modules/engine.io-client/build/esm/transports/index.js","node_modules/engine.io-client/build/esm/contrib/parseuri.js","node_modules/engine.io-client/build/esm/socket.js","node_modules/engine.io-client/build/esm/index.js","node_modules/socket.io-client/build/esm/url.js","node_modules/socket.io-parser/build/esm/index.js","node_modules/socket.io-parser/build/esm/is-binary.js","node_modules/socket.io-parser/build/esm/binary.js","node_modules/socket.io-client/build/esm/on.js","node_modules/socket.io-client/build/esm/socket.js","node_modules/socket.io-client/build/esm/contrib/backo2.js","node_modules/socket.io-client/build/esm/manager.js","node_modules/socket.io-client/build/esm/index.js","src/app/sockets/socket-io.class.ts","src/app/sockets/socket.io.service.ts"],"sourcesContent":["import { InjectionToken } from '@angular/core';\n\nimport { SocketIoConfig } from './socket-io.model';\n\nexport const SOCKET_CONFIG_TOKEN = new InjectionToken<SocketIoConfig>('__SOCKET_IO_CONFIG__');\n","const PACKET_TYPES = Object.create(null); // no Map = no polyfill\nPACKET_TYPES[\"open\"] = \"0\";\nPACKET_TYPES[\"close\"] = \"1\";\nPACKET_TYPES[\"ping\"] = \"2\";\nPACKET_TYPES[\"pong\"] = \"3\";\nPACKET_TYPES[\"message\"] = \"4\";\nPACKET_TYPES[\"upgrade\"] = \"5\";\nPACKET_TYPES[\"noop\"] = \"6\";\nconst PACKET_TYPES_REVERSE = Object.create(null);\nObject.keys(PACKET_TYPES).forEach(key => {\n  PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;\n});\nconst ERROR_PACKET = {\n  type: \"error\",\n  data: \"parser error\"\n};\nexport { PACKET_TYPES, PACKET_TYPES_REVERSE, ERROR_PACKET };","import { PACKET_TYPES } from \"./commons.js\";\nconst withNativeBlob = typeof Blob === \"function\" || typeof Blob !== \"undefined\" && Object.prototype.toString.call(Blob) === \"[object BlobConstructor]\";\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\n// ArrayBuffer.isView method is not defined in IE10\nconst isView = obj => {\n  return typeof ArrayBuffer.isView === \"function\" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer;\n};\nconst encodePacket = ({\n  type,\n  data\n}, supportsBinary, callback) => {\n  if (withNativeBlob && data instanceof Blob) {\n    if (supportsBinary) {\n      return callback(data);\n    } else {\n      return encodeBlobAsBase64(data, callback);\n    }\n  } else if (withNativeArrayBuffer && (data instanceof ArrayBuffer || isView(data))) {\n    if (supportsBinary) {\n      return callback(data);\n    } else {\n      return encodeBlobAsBase64(new Blob([data]), callback);\n    }\n  }\n  // plain string\n  return callback(PACKET_TYPES[type] + (data || \"\"));\n};\nconst encodeBlobAsBase64 = (data, callback) => {\n  const fileReader = new FileReader();\n  fileReader.onload = function () {\n    const content = fileReader.result.split(\",\")[1];\n    callback(\"b\" + (content || \"\"));\n  };\n  return fileReader.readAsDataURL(data);\n};\nfunction toArray(data) {\n  if (data instanceof Uint8Array) {\n    return data;\n  } else if (data instanceof ArrayBuffer) {\n    return new Uint8Array(data);\n  } else {\n    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n  }\n}\nlet TEXT_ENCODER;\nexport function encodePacketToBinary(packet, callback) {\n  if (withNativeBlob && packet.data instanceof Blob) {\n    return packet.data.arrayBuffer().then(toArray).then(callback);\n  } else if (withNativeArrayBuffer && (packet.data instanceof ArrayBuffer || isView(packet.data))) {\n    return callback(toArray(packet.data));\n  }\n  encodePacket(packet, false, encoded => {\n    if (!TEXT_ENCODER) {\n      TEXT_ENCODER = new TextEncoder();\n    }\n    callback(TEXT_ENCODER.encode(encoded));\n  });\n}\nexport { encodePacket };","// imported from https://github.com/socketio/base64-arraybuffer\nconst chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nconst lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (let i = 0; i < chars.length; i++) {\n  lookup[chars.charCodeAt(i)] = i;\n}\nexport const encode = arraybuffer => {\n  let bytes = new Uint8Array(arraybuffer),\n    i,\n    len = bytes.length,\n    base64 = '';\n  for (i = 0; i < len; i += 3) {\n    base64 += chars[bytes[i] >> 2];\n    base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4];\n    base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6];\n    base64 += chars[bytes[i + 2] & 63];\n  }\n  if (len % 3 === 2) {\n    base64 = base64.substring(0, base64.length - 1) + '=';\n  } else if (len % 3 === 1) {\n    base64 = base64.substring(0, base64.length - 2) + '==';\n  }\n  return base64;\n};\nexport const decode = base64 => {\n  let bufferLength = base64.length * 0.75,\n    len = base64.length,\n    i,\n    p = 0,\n    encoded1,\n    encoded2,\n    encoded3,\n    encoded4;\n  if (base64[base64.length - 1] === '=') {\n    bufferLength--;\n    if (base64[base64.length - 2] === '=') {\n      bufferLength--;\n    }\n  }\n  const arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n  for (i = 0; i < len; i += 4) {\n    encoded1 = lookup[base64.charCodeAt(i)];\n    encoded2 = lookup[base64.charCodeAt(i + 1)];\n    encoded3 = lookup[base64.charCodeAt(i + 2)];\n    encoded4 = lookup[base64.charCodeAt(i + 3)];\n    bytes[p++] = encoded1 << 2 | encoded2 >> 4;\n    bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;\n    bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;\n  }\n  return arraybuffer;\n};","import { ERROR_PACKET, PACKET_TYPES_REVERSE } from \"./commons.js\";\nimport { decode } from \"./contrib/base64-arraybuffer.js\";\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nexport const decodePacket = (encodedPacket, binaryType) => {\n  if (typeof encodedPacket !== \"string\") {\n    return {\n      type: \"message\",\n      data: mapBinary(encodedPacket, binaryType)\n    };\n  }\n  const type = encodedPacket.charAt(0);\n  if (type === \"b\") {\n    return {\n      type: \"message\",\n      data: decodeBase64Packet(encodedPacket.substring(1), binaryType)\n    };\n  }\n  const packetType = PACKET_TYPES_REVERSE[type];\n  if (!packetType) {\n    return ERROR_PACKET;\n  }\n  return encodedPacket.length > 1 ? {\n    type: PACKET_TYPES_REVERSE[type],\n    data: encodedPacket.substring(1)\n  } : {\n    type: PACKET_TYPES_REVERSE[type]\n  };\n};\nconst decodeBase64Packet = (data, binaryType) => {\n  if (withNativeArrayBuffer) {\n    const decoded = decode(data);\n    return mapBinary(decoded, binaryType);\n  } else {\n    return {\n      base64: true,\n      data\n    }; // fallback for old browsers\n  }\n};\nconst mapBinary = (data, binaryType) => {\n  switch (binaryType) {\n    case \"blob\":\n      if (data instanceof Blob) {\n        // from WebSocket + binaryType \"blob\"\n        return data;\n      } else {\n        // from HTTP long-polling or WebTransport\n        return new Blob([data]);\n      }\n    case \"arraybuffer\":\n    default:\n      if (data instanceof ArrayBuffer) {\n        // from HTTP long-polling (base64) or WebSocket + binaryType \"arraybuffer\"\n        return data;\n      } else {\n        // from WebTransport (Uint8Array)\n        return data.buffer;\n      }\n  }\n};","import { encodePacket, encodePacketToBinary } from \"./encodePacket.js\";\nimport { decodePacket } from \"./decodePacket.js\";\nimport { ERROR_PACKET } from \"./commons.js\";\nconst SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text\nconst encodePayload = (packets, callback) => {\n  // some packets may be added to the array while encoding, so the initial length must be saved\n  const length = packets.length;\n  const encodedPackets = new Array(length);\n  let count = 0;\n  packets.forEach((packet, i) => {\n    // force base64 encoding for binary packets\n    encodePacket(packet, false, encodedPacket => {\n      encodedPackets[i] = encodedPacket;\n      if (++count === length) {\n        callback(encodedPackets.join(SEPARATOR));\n      }\n    });\n  });\n};\nconst decodePayload = (encodedPayload, binaryType) => {\n  const encodedPackets = encodedPayload.split(SEPARATOR);\n  const packets = [];\n  for (let i = 0; i < encodedPackets.length; i++) {\n    const decodedPacket = decodePacket(encodedPackets[i], binaryType);\n    packets.push(decodedPacket);\n    if (decodedPacket.type === \"error\") {\n      break;\n    }\n  }\n  return packets;\n};\nexport function createPacketEncoderStream() {\n  return new TransformStream({\n    transform(packet, controller) {\n      encodePacketToBinary(packet, encodedPacket => {\n        const payloadLength = encodedPacket.length;\n        let header;\n        // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length\n        if (payloadLength < 126) {\n          header = new Uint8Array(1);\n          new DataView(header.buffer).setUint8(0, payloadLength);\n        } else if (payloadLength < 65536) {\n          header = new Uint8Array(3);\n          const view = new DataView(header.buffer);\n          view.setUint8(0, 126);\n          view.setUint16(1, payloadLength);\n        } else {\n          header = new Uint8Array(9);\n          const view = new DataView(header.buffer);\n          view.setUint8(0, 127);\n          view.setBigUint64(1, BigInt(payloadLength));\n        }\n        // first bit indicates whether the payload is plain text (0) or binary (1)\n        if (packet.data && typeof packet.data !== \"string\") {\n          header[0] |= 0x80;\n        }\n        controller.enqueue(header);\n        controller.enqueue(encodedPacket);\n      });\n    }\n  });\n}\nlet TEXT_DECODER;\nfunction totalLength(chunks) {\n  return chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n}\nfunction concatChunks(chunks, size) {\n  if (chunks[0].length === size) {\n    return chunks.shift();\n  }\n  const buffer = new Uint8Array(size);\n  let j = 0;\n  for (let i = 0; i < size; i++) {\n    buffer[i] = chunks[0][j++];\n    if (j === chunks[0].length) {\n      chunks.shift();\n      j = 0;\n    }\n  }\n  if (chunks.length && j < chunks[0].length) {\n    chunks[0] = chunks[0].slice(j);\n  }\n  return buffer;\n}\nexport function createPacketDecoderStream(maxPayload, binaryType) {\n  if (!TEXT_DECODER) {\n    TEXT_DECODER = new TextDecoder();\n  }\n  const chunks = [];\n  let state = 0 /* State.READ_HEADER */;\n  let expectedLength = -1;\n  let isBinary = false;\n  return new TransformStream({\n    transform(chunk, controller) {\n      chunks.push(chunk);\n      while (true) {\n        if (state === 0 /* State.READ_HEADER */) {\n          if (totalLength(chunks) < 1) {\n            break;\n          }\n          const header = concatChunks(chunks, 1);\n          isBinary = (header[0] & 0x80) === 0x80;\n          expectedLength = header[0] & 0x7f;\n          if (expectedLength < 126) {\n            state = 3 /* State.READ_PAYLOAD */;\n          } else if (expectedLength === 126) {\n            state = 1 /* State.READ_EXTENDED_LENGTH_16 */;\n          } else {\n            state = 2 /* State.READ_EXTENDED_LENGTH_64 */;\n          }\n        } else if (state === 1 /* State.READ_EXTENDED_LENGTH_16 */) {\n          if (totalLength(chunks) < 2) {\n            break;\n          }\n          const headerArray = concatChunks(chunks, 2);\n          expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);\n          state = 3 /* State.READ_PAYLOAD */;\n        } else if (state === 2 /* State.READ_EXTENDED_LENGTH_64 */) {\n          if (totalLength(chunks) < 8) {\n            break;\n          }\n          const headerArray = concatChunks(chunks, 8);\n          const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);\n          const n = view.getUint32(0);\n          if (n > Math.pow(2, 53 - 32) - 1) {\n            // the maximum safe integer in JavaScript is 2^53 - 1\n            controller.enqueue(ERROR_PACKET);\n            break;\n          }\n          expectedLength = n * Math.pow(2, 32) + view.getUint32(4);\n          state = 3 /* State.READ_PAYLOAD */;\n        } else {\n          if (totalLength(chunks) < expectedLength) {\n            break;\n          }\n          const data = concatChunks(chunks, expectedLength);\n          controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));\n          state = 0 /* State.READ_HEADER */;\n        }\n        if (expectedLength === 0 || expectedLength > maxPayload) {\n          controller.enqueue(ERROR_PACKET);\n          break;\n        }\n      }\n    }\n  });\n}\nexport const protocol = 4;\nexport { encodePacket, encodePayload, decodePacket, decodePayload };","/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nexport function Emitter(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || []).push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function (event, fn) {\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function (event) {\n  this._callbacks = this._callbacks || {};\n  var args = new Array(arguments.length - 1),\n    callbacks = this._callbacks['$' + event];\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n  return this;\n};\n\n// alias used for reserved events (protected method)\nEmitter.prototype.emitReserved = Emitter.prototype.emit;\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function (event) {\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function (event) {\n  return !!this.listeners(event).length;\n};","export const globalThisShim = (() => {\n  if (typeof self !== \"undefined\") {\n    return self;\n  } else if (typeof window !== \"undefined\") {\n    return window;\n  } else {\n    return Function(\"return this\")();\n  }\n})();","import { globalThisShim as globalThis } from \"./globalThis.js\";\nexport function pick(obj, ...attr) {\n  return attr.reduce((acc, k) => {\n    if (obj.hasOwnProperty(k)) {\n      acc[k] = obj[k];\n    }\n    return acc;\n  }, {});\n}\n// Keep a reference to the real timeout functions so they can be used when overridden\nconst NATIVE_SET_TIMEOUT = globalThis.setTimeout;\nconst NATIVE_CLEAR_TIMEOUT = globalThis.clearTimeout;\nexport function installTimerFunctions(obj, opts) {\n  if (opts.useNativeTimers) {\n    obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);\n    obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);\n  } else {\n    obj.setTimeoutFn = globalThis.setTimeout.bind(globalThis);\n    obj.clearTimeoutFn = globalThis.clearTimeout.bind(globalThis);\n  }\n}\n// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)\nconst BASE64_OVERHEAD = 1.33;\n// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9\nexport function byteLength(obj) {\n  if (typeof obj === \"string\") {\n    return utf8Length(obj);\n  }\n  // arraybuffer or blob\n  return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);\n}\nfunction utf8Length(str) {\n  let c = 0,\n    length = 0;\n  for (let i = 0, l = str.length; i < l; i++) {\n    c = str.charCodeAt(i);\n    if (c < 0x80) {\n      length += 1;\n    } else if (c < 0x800) {\n      length += 2;\n    } else if (c < 0xd800 || c >= 0xe000) {\n      length += 3;\n    } else {\n      i++;\n      length += 4;\n    }\n  }\n  return length;\n}","// imported from https://github.com/galkn/querystring\n/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\nexport function encode(obj) {\n  let str = '';\n  for (let i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      if (str.length) str += '&';\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n    }\n  }\n  return str;\n}\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\nexport function decode(qs) {\n  let qry = {};\n  let pairs = qs.split('&');\n  for (let i = 0, l = pairs.length; i < l; i++) {\n    let pair = pairs[i].split('=');\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n  }\n  return qry;\n}","import { decodePacket } from \"engine.io-parser\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { installTimerFunctions } from \"./util.js\";\nimport { encode } from \"./contrib/parseqs.js\";\nexport class TransportError extends Error {\n  constructor(reason, description, context) {\n    super(reason);\n    this.description = description;\n    this.context = context;\n    this.type = \"TransportError\";\n  }\n}\nexport class Transport extends Emitter {\n  /**\n   * Transport abstract constructor.\n   *\n   * @param {Object} opts - options\n   * @protected\n   */\n  constructor(opts) {\n    super();\n    this.writable = false;\n    installTimerFunctions(this, opts);\n    this.opts = opts;\n    this.query = opts.query;\n    this.socket = opts.socket;\n  }\n  /**\n   * Emits an error.\n   *\n   * @param {String} reason\n   * @param description\n   * @param context - the error context\n   * @return {Transport} for chaining\n   * @protected\n   */\n  onError(reason, description, context) {\n    super.emitReserved(\"error\", new TransportError(reason, description, context));\n    return this;\n  }\n  /**\n   * Opens the transport.\n   */\n  open() {\n    this.readyState = \"opening\";\n    this.doOpen();\n    return this;\n  }\n  /**\n   * Closes the transport.\n   */\n  close() {\n    if (this.readyState === \"opening\" || this.readyState === \"open\") {\n      this.doClose();\n      this.onClose();\n    }\n    return this;\n  }\n  /**\n   * Sends multiple packets.\n   *\n   * @param {Array} packets\n   */\n  send(packets) {\n    if (this.readyState === \"open\") {\n      this.write(packets);\n    } else {\n      // this might happen if the transport was silently closed in the beforeunload event handler\n    }\n  }\n  /**\n   * Called upon open\n   *\n   * @protected\n   */\n  onOpen() {\n    this.readyState = \"open\";\n    this.writable = true;\n    super.emitReserved(\"open\");\n  }\n  /**\n   * Called with data.\n   *\n   * @param {String} data\n   * @protected\n   */\n  onData(data) {\n    const packet = decodePacket(data, this.socket.binaryType);\n    this.onPacket(packet);\n  }\n  /**\n   * Called with a decoded packet.\n   *\n   * @protected\n   */\n  onPacket(packet) {\n    super.emitReserved(\"packet\", packet);\n  }\n  /**\n   * Called upon close.\n   *\n   * @protected\n   */\n  onClose(details) {\n    this.readyState = \"closed\";\n    super.emitReserved(\"close\", details);\n  }\n  /**\n   * Pauses the transport, in order not to lose packets during an upgrade.\n   *\n   * @param onPause\n   */\n  pause(onPause) {}\n  createUri(schema, query = {}) {\n    return schema + \"://\" + this._hostname() + this._port() + this.opts.path + this._query(query);\n  }\n  _hostname() {\n    const hostname = this.opts.hostname;\n    return hostname.indexOf(\":\") === -1 ? hostname : \"[\" + hostname + \"]\";\n  }\n  _port() {\n    if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) {\n      return \":\" + this.opts.port;\n    } else {\n      return \"\";\n    }\n  }\n  _query(query) {\n    const encodedQuery = encode(query);\n    return encodedQuery.length ? \"?\" + encodedQuery : \"\";\n  }\n}","// imported from https://github.com/unshiftio/yeast\n'use strict';\n\nconst alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split(''),\n  length = 64,\n  map = {};\nlet seed = 0,\n  i = 0,\n  prev;\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nexport function encode(num) {\n  let encoded = '';\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n  return encoded;\n}\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nexport function decode(str) {\n  let decoded = 0;\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n  return decoded;\n}\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nexport function yeast() {\n  const now = encode(+new Date());\n  if (now !== prev) return seed = 0, prev = now;\n  return now + '.' + encode(seed++);\n}\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;","// imported from https://github.com/component/has-cors\nlet value = false;\ntry {\n  value = typeof XMLHttpRequest !== 'undefined' && 'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n}\nexport const hasCORS = value;","// browser shim for xmlhttprequest module\nimport { hasCORS } from \"../contrib/has-cors.js\";\nimport { globalThisShim as globalThis } from \"../globalThis.js\";\nexport function XHR(opts) {\n  const xdomain = opts.xdomain;\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if (\"undefined\" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) {}\n  if (!xdomain) {\n    try {\n      return new globalThis[[\"Active\"].concat(\"Object\").join(\"X\")](\"Microsoft.XMLHTTP\");\n    } catch (e) {}\n  }\n}\nexport function createCookieJar() {}","import { Transport } from \"../transport.js\";\nimport { yeast } from \"../contrib/yeast.js\";\nimport { encodePayload, decodePayload } from \"engine.io-parser\";\nimport { createCookieJar, XHR as XMLHttpRequest } from \"./xmlhttprequest.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { installTimerFunctions, pick } from \"../util.js\";\nimport { globalThisShim as globalThis } from \"../globalThis.js\";\nfunction empty() {}\nconst hasXHR2 = function () {\n  const xhr = new XMLHttpRequest({\n    xdomain: false\n  });\n  return null != xhr.responseType;\n}();\nexport class Polling extends Transport {\n  /**\n   * XHR Polling constructor.\n   *\n   * @param {Object} opts\n   * @package\n   */\n  constructor(opts) {\n    super(opts);\n    this.polling = false;\n    if (typeof location !== \"undefined\") {\n      const isSSL = \"https:\" === location.protocol;\n      let port = location.port;\n      // some user agents have empty `location.port`\n      if (!port) {\n        port = isSSL ? \"443\" : \"80\";\n      }\n      this.xd = typeof location !== \"undefined\" && opts.hostname !== location.hostname || port !== opts.port;\n    }\n    /**\n     * XHR supports binary\n     */\n    const forceBase64 = opts && opts.forceBase64;\n    this.supportsBinary = hasXHR2 && !forceBase64;\n    if (this.opts.withCredentials) {\n      this.cookieJar = createCookieJar();\n    }\n  }\n  get name() {\n    return \"polling\";\n  }\n  /**\n   * Opens the socket (triggers polling). We write a PING message to determine\n   * when the transport is open.\n   *\n   * @protected\n   */\n  doOpen() {\n    this.poll();\n  }\n  /**\n   * Pauses polling.\n   *\n   * @param {Function} onPause - callback upon buffers are flushed and transport is paused\n   * @package\n   */\n  pause(onPause) {\n    this.readyState = \"pausing\";\n    const pause = () => {\n      this.readyState = \"paused\";\n      onPause();\n    };\n    if (this.polling || !this.writable) {\n      let total = 0;\n      if (this.polling) {\n        total++;\n        this.once(\"pollComplete\", function () {\n          --total || pause();\n        });\n      }\n      if (!this.writable) {\n        total++;\n        this.once(\"drain\", function () {\n          --total || pause();\n        });\n      }\n    } else {\n      pause();\n    }\n  }\n  /**\n   * Starts polling cycle.\n   *\n   * @private\n   */\n  poll() {\n    this.polling = true;\n    this.doPoll();\n    this.emitReserved(\"poll\");\n  }\n  /**\n   * Overloads onData to detect payloads.\n   *\n   * @protected\n   */\n  onData(data) {\n    const callback = packet => {\n      // if its the first message we consider the transport open\n      if (\"opening\" === this.readyState && packet.type === \"open\") {\n        this.onOpen();\n      }\n      // if its a close packet, we close the ongoing requests\n      if (\"close\" === packet.type) {\n        this.onClose({\n          description: \"transport closed by the server\"\n        });\n        return false;\n      }\n      // otherwise bypass onData and handle the message\n      this.onPacket(packet);\n    };\n    // decode payload\n    decodePayload(data, this.socket.binaryType).forEach(callback);\n    // if an event did not trigger closing\n    if (\"closed\" !== this.readyState) {\n      // if we got data we're not polling\n      this.polling = false;\n      this.emitReserved(\"pollComplete\");\n      if (\"open\" === this.readyState) {\n        this.poll();\n      } else {}\n    }\n  }\n  /**\n   * For polling, send a close packet.\n   *\n   * @protected\n   */\n  doClose() {\n    const close = () => {\n      this.write([{\n        type: \"close\"\n      }]);\n    };\n    if (\"open\" === this.readyState) {\n      close();\n    } else {\n      // in case we're trying to close while\n      // handshaking is in progress (GH-164)\n      this.once(\"open\", close);\n    }\n  }\n  /**\n   * Writes a packets payload.\n   *\n   * @param {Array} packets - data packets\n   * @protected\n   */\n  write(packets) {\n    this.writable = false;\n    encodePayload(packets, data => {\n      this.doWrite(data, () => {\n        this.writable = true;\n        this.emitReserved(\"drain\");\n      });\n    });\n  }\n  /**\n   * Generates uri for connection.\n   *\n   * @private\n   */\n  uri() {\n    const schema = this.opts.secure ? \"https\" : \"http\";\n    const query = this.query || {};\n    // cache busting is forced\n    if (false !== this.opts.timestampRequests) {\n      query[this.opts.timestampParam] = yeast();\n    }\n    if (!this.supportsBinary && !query.sid) {\n      query.b64 = 1;\n    }\n    return this.createUri(schema, query);\n  }\n  /**\n   * Creates a request.\n   *\n   * @param {String} method\n   * @private\n   */\n  request(opts = {}) {\n    Object.assign(opts, {\n      xd: this.xd,\n      cookieJar: this.cookieJar\n    }, this.opts);\n    return new Request(this.uri(), opts);\n  }\n  /**\n   * Sends data.\n   *\n   * @param {String} data to send.\n   * @param {Function} called upon flush.\n   * @private\n   */\n  doWrite(data, fn) {\n    const req = this.request({\n      method: \"POST\",\n      data: data\n    });\n    req.on(\"success\", fn);\n    req.on(\"error\", (xhrStatus, context) => {\n      this.onError(\"xhr post error\", xhrStatus, context);\n    });\n  }\n  /**\n   * Starts a poll cycle.\n   *\n   * @private\n   */\n  doPoll() {\n    const req = this.request();\n    req.on(\"data\", this.onData.bind(this));\n    req.on(\"error\", (xhrStatus, context) => {\n      this.onError(\"xhr poll error\", xhrStatus, context);\n    });\n    this.pollXhr = req;\n  }\n}\nexport let Request = /*#__PURE__*/(() => {\n  class Request extends Emitter {\n    /**\n     * Request constructor\n     *\n     * @param {Object} options\n     * @package\n     */\n    constructor(uri, opts) {\n      super();\n      installTimerFunctions(this, opts);\n      this.opts = opts;\n      this.method = opts.method || \"GET\";\n      this.uri = uri;\n      this.data = undefined !== opts.data ? opts.data : null;\n      this.create();\n    }\n    /**\n     * Creates the XHR object and sends the request.\n     *\n     * @private\n     */\n    create() {\n      var _a;\n      const opts = pick(this.opts, \"agent\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"autoUnref\");\n      opts.xdomain = !!this.opts.xd;\n      const xhr = this.xhr = new XMLHttpRequest(opts);\n      try {\n        xhr.open(this.method, this.uri, true);\n        try {\n          if (this.opts.extraHeaders) {\n            xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n            for (let i in this.opts.extraHeaders) {\n              if (this.opts.extraHeaders.hasOwnProperty(i)) {\n                xhr.setRequestHeader(i, this.opts.extraHeaders[i]);\n              }\n            }\n          }\n        } catch (e) {}\n        if (\"POST\" === this.method) {\n          try {\n            xhr.setRequestHeader(\"Content-type\", \"text/plain;charset=UTF-8\");\n          } catch (e) {}\n        }\n        try {\n          xhr.setRequestHeader(\"Accept\", \"*/*\");\n        } catch (e) {}\n        (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);\n        // ie6 check\n        if (\"withCredentials\" in xhr) {\n          xhr.withCredentials = this.opts.withCredentials;\n        }\n        if (this.opts.requestTimeout) {\n          xhr.timeout = this.opts.requestTimeout;\n        }\n        xhr.onreadystatechange = () => {\n          var _a;\n          if (xhr.readyState === 3) {\n            (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(xhr);\n          }\n          if (4 !== xhr.readyState) return;\n          if (200 === xhr.status || 1223 === xhr.status) {\n            this.onLoad();\n          } else {\n            // make sure the `error` event handler that's user-set\n            // does not throw in the same tick and gets caught here\n            this.setTimeoutFn(() => {\n              this.onError(typeof xhr.status === \"number\" ? xhr.status : 0);\n            }, 0);\n          }\n        };\n        xhr.send(this.data);\n      } catch (e) {\n        // Need to defer since .create() is called directly from the constructor\n        // and thus the 'error' event can only be only bound *after* this exception\n        // occurs.  Therefore, also, we cannot throw here at all.\n        this.setTimeoutFn(() => {\n          this.onError(e);\n        }, 0);\n        return;\n      }\n      if (typeof document !== \"undefined\") {\n        this.index = Request.requestsCount++;\n        Request.requests[this.index] = this;\n      }\n    }\n    /**\n     * Called upon error.\n     *\n     * @private\n     */\n    onError(err) {\n      this.emitReserved(\"error\", err, this.xhr);\n      this.cleanup(true);\n    }\n    /**\n     * Cleans up house.\n     *\n     * @private\n     */\n    cleanup(fromError) {\n      if (\"undefined\" === typeof this.xhr || null === this.xhr) {\n        return;\n      }\n      this.xhr.onreadystatechange = empty;\n      if (fromError) {\n        try {\n          this.xhr.abort();\n        } catch (e) {}\n      }\n      if (typeof document !== \"undefined\") {\n        delete Request.requests[this.index];\n      }\n      this.xhr = null;\n    }\n    /**\n     * Called upon load.\n     *\n     * @private\n     */\n    onLoad() {\n      const data = this.xhr.responseText;\n      if (data !== null) {\n        this.emitReserved(\"data\", data);\n        this.emitReserved(\"success\");\n        this.cleanup();\n      }\n    }\n    /**\n     * Aborts the request.\n     *\n     * @package\n     */\n    abort() {\n      this.cleanup();\n    }\n  }\n  Request.requestsCount = 0;\n  Request.requests = {};\n  /**\n   * Aborts pending requests when unloading the window. This is needed to prevent\n   * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n   * emitted.\n   */\n  return Request;\n})();\nif (typeof document !== \"undefined\") {\n  // @ts-ignore\n  if (typeof attachEvent === \"function\") {\n    // @ts-ignore\n    attachEvent(\"onunload\", unloadHandler);\n  } else if (typeof addEventListener === \"function\") {\n    const terminationEvent = \"onpagehide\" in globalThis ? \"pagehide\" : \"unload\";\n    addEventListener(terminationEvent, unloadHandler, false);\n  }\n}\nfunction unloadHandler() {\n  for (let i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}","import { globalThisShim as globalThis } from \"../globalThis.js\";\nexport const nextTick = (() => {\n  const isPromiseAvailable = typeof Promise === \"function\" && typeof Promise.resolve === \"function\";\n  if (isPromiseAvailable) {\n    return cb => Promise.resolve().then(cb);\n  } else {\n    return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);\n  }\n})();\nexport const WebSocket = globalThis.WebSocket || globalThis.MozWebSocket;\nexport const usingBrowserWebSocket = true;\nexport const defaultBinaryType = \"arraybuffer\";","import { Transport } from \"../transport.js\";\nimport { yeast } from \"../contrib/yeast.js\";\nimport { pick } from \"../util.js\";\nimport { nextTick, usingBrowserWebSocket, WebSocket } from \"./websocket-constructor.js\";\nimport { encodePacket } from \"engine.io-parser\";\n// detect ReactNative environment\nconst isReactNative = typeof navigator !== \"undefined\" && typeof navigator.product === \"string\" && navigator.product.toLowerCase() === \"reactnative\";\nexport class WS extends Transport {\n  /**\n   * WebSocket transport constructor.\n   *\n   * @param {Object} opts - connection options\n   * @protected\n   */\n  constructor(opts) {\n    super(opts);\n    this.supportsBinary = !opts.forceBase64;\n  }\n  get name() {\n    return \"websocket\";\n  }\n  doOpen() {\n    if (!this.check()) {\n      // let probe timeout\n      return;\n    }\n    const uri = this.uri();\n    const protocols = this.opts.protocols;\n    // React Native only supports the 'headers' option, and will print a warning if anything else is passed\n    const opts = isReactNative ? {} : pick(this.opts, \"agent\", \"perMessageDeflate\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"localAddress\", \"protocolVersion\", \"origin\", \"maxPayload\", \"family\", \"checkServerIdentity\");\n    if (this.opts.extraHeaders) {\n      opts.headers = this.opts.extraHeaders;\n    }\n    try {\n      this.ws = usingBrowserWebSocket && !isReactNative ? protocols ? new WebSocket(uri, protocols) : new WebSocket(uri) : new WebSocket(uri, protocols, opts);\n    } catch (err) {\n      return this.emitReserved(\"error\", err);\n    }\n    this.ws.binaryType = this.socket.binaryType;\n    this.addEventListeners();\n  }\n  /**\n   * Adds event listeners to the socket\n   *\n   * @private\n   */\n  addEventListeners() {\n    this.ws.onopen = () => {\n      if (this.opts.autoUnref) {\n        this.ws._socket.unref();\n      }\n      this.onOpen();\n    };\n    this.ws.onclose = closeEvent => this.onClose({\n      description: \"websocket connection closed\",\n      context: closeEvent\n    });\n    this.ws.onmessage = ev => this.onData(ev.data);\n    this.ws.onerror = e => this.onError(\"websocket error\", e);\n  }\n  write(packets) {\n    this.writable = false;\n    // encodePacket efficient as it uses WS framing\n    // no need for encodePayload\n    for (let i = 0; i < packets.length; i++) {\n      const packet = packets[i];\n      const lastPacket = i === packets.length - 1;\n      encodePacket(packet, this.supportsBinary, data => {\n        // always create a new object (GH-437)\n        const opts = {};\n        if (!usingBrowserWebSocket) {\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n          if (this.opts.perMessageDeflate) {\n            const len =\n            // @ts-ignore\n            \"string\" === typeof data ? Buffer.byteLength(data) : data.length;\n            if (len < this.opts.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n        // Sometimes the websocket has already been closed but the browser didn't\n        // have a chance of informing us about it yet, in that case send will\n        // throw an error\n        try {\n          if (usingBrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            this.ws.send(data);\n          } else {\n            this.ws.send(data, opts);\n          }\n        } catch (e) {}\n        if (lastPacket) {\n          // fake drain\n          // defer to next tick to allow Socket to clear writeBuffer\n          nextTick(() => {\n            this.writable = true;\n            this.emitReserved(\"drain\");\n          }, this.setTimeoutFn);\n        }\n      });\n    }\n  }\n  doClose() {\n    if (typeof this.ws !== \"undefined\") {\n      this.ws.close();\n      this.ws = null;\n    }\n  }\n  /**\n   * Generates uri for connection.\n   *\n   * @private\n   */\n  uri() {\n    const schema = this.opts.secure ? \"wss\" : \"ws\";\n    const query = this.query || {};\n    // append timestamp to URI\n    if (this.opts.timestampRequests) {\n      query[this.opts.timestampParam] = yeast();\n    }\n    // communicate binary support capabilities\n    if (!this.supportsBinary) {\n      query.b64 = 1;\n    }\n    return this.createUri(schema, query);\n  }\n  /**\n   * Feature detection for WebSocket.\n   *\n   * @return {Boolean} whether this transport is available.\n   * @private\n   */\n  check() {\n    return !!WebSocket;\n  }\n}","import { Transport } from \"../transport.js\";\nimport { nextTick } from \"./websocket-constructor.js\";\nimport { createPacketDecoderStream, createPacketEncoderStream } from \"engine.io-parser\";\nexport class WT extends Transport {\n  get name() {\n    return \"webtransport\";\n  }\n  doOpen() {\n    // @ts-ignore\n    if (typeof WebTransport !== \"function\") {\n      return;\n    }\n    // @ts-ignore\n    this.transport = new WebTransport(this.createUri(\"https\"), this.opts.transportOptions[this.name]);\n    this.transport.closed.then(() => {\n      this.onClose();\n    }).catch(err => {\n      this.onError(\"webtransport error\", err);\n    });\n    // note: we could have used async/await, but that would require some additional polyfills\n    this.transport.ready.then(() => {\n      this.transport.createBidirectionalStream().then(stream => {\n        const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);\n        const reader = stream.readable.pipeThrough(decoderStream).getReader();\n        const encoderStream = createPacketEncoderStream();\n        encoderStream.readable.pipeTo(stream.writable);\n        this.writer = encoderStream.writable.getWriter();\n        const read = () => {\n          reader.read().then(({\n            done,\n            value\n          }) => {\n            if (done) {\n              return;\n            }\n            this.onPacket(value);\n            read();\n          }).catch(err => {});\n        };\n        read();\n        const packet = {\n          type: \"open\"\n        };\n        if (this.query.sid) {\n          packet.data = `{\"sid\":\"${this.query.sid}\"}`;\n        }\n        this.writer.write(packet).then(() => this.onOpen());\n      });\n    });\n  }\n  write(packets) {\n    this.writable = false;\n    for (let i = 0; i < packets.length; i++) {\n      const packet = packets[i];\n      const lastPacket = i === packets.length - 1;\n      this.writer.write(packet).then(() => {\n        if (lastPacket) {\n          nextTick(() => {\n            this.writable = true;\n            this.emitReserved(\"drain\");\n          }, this.setTimeoutFn);\n        }\n      });\n    }\n  }\n  doClose() {\n    var _a;\n    (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();\n  }\n}","import { Polling } from \"./polling.js\";\nimport { WS } from \"./websocket.js\";\nimport { WT } from \"./webtransport.js\";\nexport const transports = {\n  websocket: WS,\n  webtransport: WT,\n  polling: Polling\n};","// imported from https://github.com/galkn/parseuri\n/**\n * Parses a URI\n *\n * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.\n *\n * See:\n * - https://developer.mozilla.org/en-US/docs/Web/API/URL\n * - https://caniuse.com/url\n * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B\n *\n * History of the parse() method:\n * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c\n * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3\n * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\nconst re = /^(?:(?![^:@\\/?#]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@\\/?#]*)(?::([^:@\\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\nconst parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'];\nexport function parse(str) {\n  if (str.length > 2000) {\n    throw \"URI too long\";\n  }\n  const src = str,\n    b = str.indexOf('['),\n    e = str.indexOf(']');\n  if (b != -1 && e != -1) {\n    str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n  }\n  let m = re.exec(str || ''),\n    uri = {},\n    i = 14;\n  while (i--) {\n    uri[parts[i]] = m[i] || '';\n  }\n  if (b != -1 && e != -1) {\n    uri.source = src;\n    uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n    uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n    uri.ipv6uri = true;\n  }\n  uri.pathNames = pathNames(uri, uri['path']);\n  uri.queryKey = queryKey(uri, uri['query']);\n  return uri;\n}\nfunction pathNames(obj, path) {\n  const regx = /\\/{2,9}/g,\n    names = path.replace(regx, \"/\").split(\"/\");\n  if (path.slice(0, 1) == '/' || path.length === 0) {\n    names.splice(0, 1);\n  }\n  if (path.slice(-1) == '/') {\n    names.splice(names.length - 1, 1);\n  }\n  return names;\n}\nfunction queryKey(uri, query) {\n  const data = {};\n  query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {\n    if ($1) {\n      data[$1] = $2;\n    }\n  });\n  return data;\n}","import { transports } from \"./transports/index.js\";\nimport { installTimerFunctions, byteLength } from \"./util.js\";\nimport { decode } from \"./contrib/parseqs.js\";\nimport { parse } from \"./contrib/parseuri.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { protocol } from \"engine.io-parser\";\nimport { defaultBinaryType } from \"./transports/websocket-constructor.js\";\nexport let Socket = /*#__PURE__*/(() => {\n  class Socket extends Emitter {\n    /**\n     * Socket constructor.\n     *\n     * @param {String|Object} uri - uri or options\n     * @param {Object} opts - options\n     */\n    constructor(uri, opts = {}) {\n      super();\n      this.binaryType = defaultBinaryType;\n      this.writeBuffer = [];\n      if (uri && \"object\" === typeof uri) {\n        opts = uri;\n        uri = null;\n      }\n      if (uri) {\n        uri = parse(uri);\n        opts.hostname = uri.host;\n        opts.secure = uri.protocol === \"https\" || uri.protocol === \"wss\";\n        opts.port = uri.port;\n        if (uri.query) opts.query = uri.query;\n      } else if (opts.host) {\n        opts.hostname = parse(opts.host).host;\n      }\n      installTimerFunctions(this, opts);\n      this.secure = null != opts.secure ? opts.secure : typeof location !== \"undefined\" && \"https:\" === location.protocol;\n      if (opts.hostname && !opts.port) {\n        // if no port is specified manually, use the protocol default\n        opts.port = this.secure ? \"443\" : \"80\";\n      }\n      this.hostname = opts.hostname || (typeof location !== \"undefined\" ? location.hostname : \"localhost\");\n      this.port = opts.port || (typeof location !== \"undefined\" && location.port ? location.port : this.secure ? \"443\" : \"80\");\n      this.transports = opts.transports || [\"polling\", \"websocket\", \"webtransport\"];\n      this.writeBuffer = [];\n      this.prevBufferLen = 0;\n      this.opts = Object.assign({\n        path: \"/engine.io\",\n        agent: false,\n        withCredentials: false,\n        upgrade: true,\n        timestampParam: \"t\",\n        rememberUpgrade: false,\n        addTrailingSlash: true,\n        rejectUnauthorized: true,\n        perMessageDeflate: {\n          threshold: 1024\n        },\n        transportOptions: {},\n        closeOnBeforeunload: false\n      }, opts);\n      this.opts.path = this.opts.path.replace(/\\/$/, \"\") + (this.opts.addTrailingSlash ? \"/\" : \"\");\n      if (typeof this.opts.query === \"string\") {\n        this.opts.query = decode(this.opts.query);\n      }\n      // set on handshake\n      this.id = null;\n      this.upgrades = null;\n      this.pingInterval = null;\n      this.pingTimeout = null;\n      // set on heartbeat\n      this.pingTimeoutTimer = null;\n      if (typeof addEventListener === \"function\") {\n        if (this.opts.closeOnBeforeunload) {\n          // Firefox closes the connection when the \"beforeunload\" event is emitted but not Chrome. This event listener\n          // ensures every browser behaves the same (no \"disconnect\" event at the Socket.IO level when the page is\n          // closed/reloaded)\n          this.beforeunloadEventListener = () => {\n            if (this.transport) {\n              // silently close the transport\n              this.transport.removeAllListeners();\n              this.transport.close();\n            }\n          };\n          addEventListener(\"beforeunload\", this.beforeunloadEventListener, false);\n        }\n        if (this.hostname !== \"localhost\") {\n          this.offlineEventListener = () => {\n            this.onClose(\"transport close\", {\n              description: \"network connection lost\"\n            });\n          };\n          addEventListener(\"offline\", this.offlineEventListener, false);\n        }\n      }\n      this.open();\n    }\n    /**\n     * Creates transport of the given type.\n     *\n     * @param {String} name - transport name\n     * @return {Transport}\n     * @private\n     */\n    createTransport(name) {\n      const query = Object.assign({}, this.opts.query);\n      // append engine.io protocol identifier\n      query.EIO = protocol;\n      // transport name\n      query.transport = name;\n      // session id if we already have one\n      if (this.id) query.sid = this.id;\n      const opts = Object.assign({}, this.opts, {\n        query,\n        socket: this,\n        hostname: this.hostname,\n        secure: this.secure,\n        port: this.port\n      }, this.opts.transportOptions[name]);\n      return new transports[name](opts);\n    }\n    /**\n     * Initializes transport to use and starts probe.\n     *\n     * @private\n     */\n    open() {\n      let transport;\n      if (this.opts.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf(\"websocket\") !== -1) {\n        transport = \"websocket\";\n      } else if (0 === this.transports.length) {\n        // Emit error on next tick so it can be listened to\n        this.setTimeoutFn(() => {\n          this.emitReserved(\"error\", \"No transports available\");\n        }, 0);\n        return;\n      } else {\n        transport = this.transports[0];\n      }\n      this.readyState = \"opening\";\n      // Retry with the next transport if the transport is disabled (jsonp: false)\n      try {\n        transport = this.createTransport(transport);\n      } catch (e) {\n        this.transports.shift();\n        this.open();\n        return;\n      }\n      transport.open();\n      this.setTransport(transport);\n    }\n    /**\n     * Sets the current transport. Disables the existing one (if any).\n     *\n     * @private\n     */\n    setTransport(transport) {\n      if (this.transport) {\n        this.transport.removeAllListeners();\n      }\n      // set up transport\n      this.transport = transport;\n      // set up transport listeners\n      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));\n    }\n    /**\n     * Probes a transport.\n     *\n     * @param {String} name - transport name\n     * @private\n     */\n    probe(name) {\n      let transport = this.createTransport(name);\n      let failed = false;\n      Socket.priorWebsocketSuccess = false;\n      const onTransportOpen = () => {\n        if (failed) return;\n        transport.send([{\n          type: \"ping\",\n          data: \"probe\"\n        }]);\n        transport.once(\"packet\", msg => {\n          if (failed) return;\n          if (\"pong\" === msg.type && \"probe\" === msg.data) {\n            this.upgrading = true;\n            this.emitReserved(\"upgrading\", transport);\n            if (!transport) return;\n            Socket.priorWebsocketSuccess = \"websocket\" === transport.name;\n            this.transport.pause(() => {\n              if (failed) return;\n              if (\"closed\" === this.readyState) return;\n              cleanup();\n              this.setTransport(transport);\n              transport.send([{\n                type: \"upgrade\"\n              }]);\n              this.emitReserved(\"upgrade\", transport);\n              transport = null;\n              this.upgrading = false;\n              this.flush();\n            });\n          } else {\n            const err = new Error(\"probe error\");\n            // @ts-ignore\n            err.transport = transport.name;\n            this.emitReserved(\"upgradeError\", err);\n          }\n        });\n      };\n      function freezeTransport() {\n        if (failed) return;\n        // Any callback called by transport should be ignored since now\n        failed = true;\n        cleanup();\n        transport.close();\n        transport = null;\n      }\n      // Handle any error that happens while probing\n      const onerror = err => {\n        const error = new Error(\"probe error: \" + err);\n        // @ts-ignore\n        error.transport = transport.name;\n        freezeTransport();\n        this.emitReserved(\"upgradeError\", error);\n      };\n      function onTransportClose() {\n        onerror(\"transport closed\");\n      }\n      // When the socket is closed while we're probing\n      function onclose() {\n        onerror(\"socket closed\");\n      }\n      // When the socket is upgraded while we're probing\n      function onupgrade(to) {\n        if (transport && to.name !== transport.name) {\n          freezeTransport();\n        }\n      }\n      // Remove all listeners on the transport and on self\n      const cleanup = () => {\n        transport.removeListener(\"open\", onTransportOpen);\n        transport.removeListener(\"error\", onerror);\n        transport.removeListener(\"close\", onTransportClose);\n        this.off(\"close\", onclose);\n        this.off(\"upgrading\", onupgrade);\n      };\n      transport.once(\"open\", onTransportOpen);\n      transport.once(\"error\", onerror);\n      transport.once(\"close\", onTransportClose);\n      this.once(\"close\", onclose);\n      this.once(\"upgrading\", onupgrade);\n      if (this.upgrades.indexOf(\"webtransport\") !== -1 && name !== \"webtransport\") {\n        // favor WebTransport\n        this.setTimeoutFn(() => {\n          if (!failed) {\n            transport.open();\n          }\n        }, 200);\n      } else {\n        transport.open();\n      }\n    }\n    /**\n     * Called when connection is deemed open.\n     *\n     * @private\n     */\n    onOpen() {\n      this.readyState = \"open\";\n      Socket.priorWebsocketSuccess = \"websocket\" === this.transport.name;\n      this.emitReserved(\"open\");\n      this.flush();\n      // we check for `readyState` in case an `open`\n      // listener already closed the socket\n      if (\"open\" === this.readyState && this.opts.upgrade) {\n        let i = 0;\n        const l = this.upgrades.length;\n        for (; i < l; i++) {\n          this.probe(this.upgrades[i]);\n        }\n      }\n    }\n    /**\n     * Handles a packet.\n     *\n     * @private\n     */\n    onPacket(packet) {\n      if (\"opening\" === this.readyState || \"open\" === this.readyState || \"closing\" === this.readyState) {\n        this.emitReserved(\"packet\", packet);\n        // Socket is live - any packet counts\n        this.emitReserved(\"heartbeat\");\n        this.resetPingTimeout();\n        switch (packet.type) {\n          case \"open\":\n            this.onHandshake(JSON.parse(packet.data));\n            break;\n          case \"ping\":\n            this.sendPacket(\"pong\");\n            this.emitReserved(\"ping\");\n            this.emitReserved(\"pong\");\n            break;\n          case \"error\":\n            const err = new Error(\"server error\");\n            // @ts-ignore\n            err.code = packet.data;\n            this.onError(err);\n            break;\n          case \"message\":\n            this.emitReserved(\"data\", packet.data);\n            this.emitReserved(\"message\", packet.data);\n            break;\n        }\n      } else {}\n    }\n    /**\n     * Called upon handshake completion.\n     *\n     * @param {Object} data - handshake obj\n     * @private\n     */\n    onHandshake(data) {\n      this.emitReserved(\"handshake\", data);\n      this.id = data.sid;\n      this.transport.query.sid = data.sid;\n      this.upgrades = this.filterUpgrades(data.upgrades);\n      this.pingInterval = data.pingInterval;\n      this.pingTimeout = data.pingTimeout;\n      this.maxPayload = data.maxPayload;\n      this.onOpen();\n      // In case open handler closes socket\n      if (\"closed\" === this.readyState) return;\n      this.resetPingTimeout();\n    }\n    /**\n     * Sets and resets ping timeout timer based on server pings.\n     *\n     * @private\n     */\n    resetPingTimeout() {\n      this.clearTimeoutFn(this.pingTimeoutTimer);\n      this.pingTimeoutTimer = this.setTimeoutFn(() => {\n        this.onClose(\"ping timeout\");\n      }, this.pingInterval + this.pingTimeout);\n      if (this.opts.autoUnref) {\n        this.pingTimeoutTimer.unref();\n      }\n    }\n    /**\n     * Called on `drain` event\n     *\n     * @private\n     */\n    onDrain() {\n      this.writeBuffer.splice(0, this.prevBufferLen);\n      // setting prevBufferLen = 0 is very important\n      // for example, when upgrading, upgrade packet is sent over,\n      // and a nonzero prevBufferLen could cause problems on `drain`\n      this.prevBufferLen = 0;\n      if (0 === this.writeBuffer.length) {\n        this.emitReserved(\"drain\");\n      } else {\n        this.flush();\n      }\n    }\n    /**\n     * Flush write buffers.\n     *\n     * @private\n     */\n    flush() {\n      if (\"closed\" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {\n        const packets = this.getWritablePackets();\n        this.transport.send(packets);\n        // keep track of current length of writeBuffer\n        // splice writeBuffer and callbackBuffer on `drain`\n        this.prevBufferLen = packets.length;\n        this.emitReserved(\"flush\");\n      }\n    }\n    /**\n     * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP\n     * long-polling)\n     *\n     * @private\n     */\n    getWritablePackets() {\n      const shouldCheckPayloadSize = this.maxPayload && this.transport.name === \"polling\" && this.writeBuffer.length > 1;\n      if (!shouldCheckPayloadSize) {\n        return this.writeBuffer;\n      }\n      let payloadSize = 1; // first packet type\n      for (let i = 0; i < this.writeBuffer.length; i++) {\n        const data = this.writeBuffer[i].data;\n        if (data) {\n          payloadSize += byteLength(data);\n        }\n        if (i > 0 && payloadSize > this.maxPayload) {\n          return this.writeBuffer.slice(0, i);\n        }\n        payloadSize += 2; // separator + packet type\n      }\n      return this.writeBuffer;\n    }\n    /**\n     * Sends a message.\n     *\n     * @param {String} msg - message.\n     * @param {Object} options.\n     * @param {Function} callback function.\n     * @return {Socket} for chaining.\n     */\n    write(msg, options, fn) {\n      this.sendPacket(\"message\", msg, options, fn);\n      return this;\n    }\n    send(msg, options, fn) {\n      this.sendPacket(\"message\", msg, options, fn);\n      return this;\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param {String} type: packet type.\n     * @param {String} data.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @private\n     */\n    sendPacket(type, data, options, fn) {\n      if (\"function\" === typeof data) {\n        fn = data;\n        data = undefined;\n      }\n      if (\"function\" === typeof options) {\n        fn = options;\n        options = null;\n      }\n      if (\"closing\" === this.readyState || \"closed\" === this.readyState) {\n        return;\n      }\n      options = options || {};\n      options.compress = false !== options.compress;\n      const packet = {\n        type: type,\n        data: data,\n        options: options\n      };\n      this.emitReserved(\"packetCreate\", packet);\n      this.writeBuffer.push(packet);\n      if (fn) this.once(\"flush\", fn);\n      this.flush();\n    }\n    /**\n     * Closes the connection.\n     */\n    close() {\n      const close = () => {\n        this.onClose(\"forced close\");\n        this.transport.close();\n      };\n      const cleanupAndClose = () => {\n        this.off(\"upgrade\", cleanupAndClose);\n        this.off(\"upgradeError\", cleanupAndClose);\n        close();\n      };\n      const waitForUpgrade = () => {\n        // wait for upgrade to finish since we can't send packets while pausing a transport\n        this.once(\"upgrade\", cleanupAndClose);\n        this.once(\"upgradeError\", cleanupAndClose);\n      };\n      if (\"opening\" === this.readyState || \"open\" === this.readyState) {\n        this.readyState = \"closing\";\n        if (this.writeBuffer.length) {\n          this.once(\"drain\", () => {\n            if (this.upgrading) {\n              waitForUpgrade();\n            } else {\n              close();\n            }\n          });\n        } else if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      }\n      return this;\n    }\n    /**\n     * Called upon transport error\n     *\n     * @private\n     */\n    onError(err) {\n      Socket.priorWebsocketSuccess = false;\n      this.emitReserved(\"error\", err);\n      this.onClose(\"transport error\", err);\n    }\n    /**\n     * Called upon transport close.\n     *\n     * @private\n     */\n    onClose(reason, description) {\n      if (\"opening\" === this.readyState || \"open\" === this.readyState || \"closing\" === this.readyState) {\n        // clear timers\n        this.clearTimeoutFn(this.pingTimeoutTimer);\n        // stop event from firing again for transport\n        this.transport.removeAllListeners(\"close\");\n        // ensure transport won't stay open\n        this.transport.close();\n        // ignore further transport communication\n        this.transport.removeAllListeners();\n        if (typeof removeEventListener === \"function\") {\n          removeEventListener(\"beforeunload\", this.beforeunloadEventListener, false);\n          removeEventListener(\"offline\", this.offlineEventListener, false);\n        }\n        // set ready state\n        this.readyState = \"closed\";\n        // clear session id\n        this.id = null;\n        // emit close event\n        this.emitReserved(\"close\", reason, description);\n        // clean buffers after, so users can still\n        // grab the buffers on `close` event\n        this.writeBuffer = [];\n        this.prevBufferLen = 0;\n      }\n    }\n    /**\n     * Filters upgrades, returning only those matching client transports.\n     *\n     * @param {Array} upgrades - server upgrades\n     * @private\n     */\n    filterUpgrades(upgrades) {\n      const filteredUpgrades = [];\n      let i = 0;\n      const j = upgrades.length;\n      for (; i < j; i++) {\n        if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]);\n      }\n      return filteredUpgrades;\n    }\n  }\n  Socket.protocol = protocol;\n  return Socket;\n})();","import { Socket } from \"./socket.js\";\nexport { Socket };\nexport const protocol = Socket.protocol;\nexport { Transport, TransportError } from \"./transport.js\";\nexport { transports } from \"./transports/index.js\";\nexport { installTimerFunctions } from \"./util.js\";\nexport { parse } from \"./contrib/parseuri.js\";\nexport { nextTick } from \"./transports/websocket-constructor.js\";","import { parse } from \"engine.io-client\";\n/**\n * URL parser.\n *\n * @param uri - url\n * @param path - the request path of the connection\n * @param loc - An object meant to mimic window.location.\n *        Defaults to window.location.\n * @public\n */\nexport function url(uri, path = \"\", loc) {\n  let obj = uri;\n  // default to window.location\n  loc = loc || typeof location !== \"undefined\" && location;\n  if (null == uri) uri = loc.protocol + \"//\" + loc.host;\n  // relative path support\n  if (typeof uri === \"string\") {\n    if (\"/\" === uri.charAt(0)) {\n      if (\"/\" === uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      if (\"undefined\" !== typeof loc) {\n        uri = loc.protocol + \"//\" + uri;\n      } else {\n        uri = \"https://\" + uri;\n      }\n    }\n    // parse\n    obj = parse(uri);\n  }\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = \"80\";\n    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = \"443\";\n    }\n  }\n  obj.path = obj.path || \"/\";\n  const ipv6 = obj.host.indexOf(\":\") !== -1;\n  const host = ipv6 ? \"[\" + obj.host + \"]\" : obj.host;\n  // define unique id\n  obj.id = obj.protocol + \"://\" + host + \":\" + obj.port + path;\n  // define href\n  obj.href = obj.protocol + \"://\" + host + (loc && loc.port === obj.port ? \"\" : \":\" + obj.port);\n  return obj;\n}","import { Emitter } from \"@socket.io/component-emitter\";\nimport { deconstructPacket, reconstructPacket } from \"./binary.js\";\nimport { isBinary, hasBinary } from \"./is-binary.js\";\n/**\n * These strings must not be used as event names, as they have a special meaning.\n */\nconst RESERVED_EVENTS = [\"connect\", \"connect_error\", \"disconnect\", \"disconnecting\", \"newListener\", \"removeListener\" // used by the Node.js EventEmitter\n];\n/**\n * Protocol version.\n *\n * @public\n */\nexport const protocol = 5;\nexport var PacketType = /*#__PURE__*/function (PacketType) {\n  PacketType[PacketType[\"CONNECT\"] = 0] = \"CONNECT\";\n  PacketType[PacketType[\"DISCONNECT\"] = 1] = \"DISCONNECT\";\n  PacketType[PacketType[\"EVENT\"] = 2] = \"EVENT\";\n  PacketType[PacketType[\"ACK\"] = 3] = \"ACK\";\n  PacketType[PacketType[\"CONNECT_ERROR\"] = 4] = \"CONNECT_ERROR\";\n  PacketType[PacketType[\"BINARY_EVENT\"] = 5] = \"BINARY_EVENT\";\n  PacketType[PacketType[\"BINARY_ACK\"] = 6] = \"BINARY_ACK\";\n  return PacketType;\n}(PacketType || {});\n/**\n * A socket.io Encoder instance\n */\nexport class Encoder {\n  /**\n   * Encoder constructor\n   *\n   * @param {function} replacer - custom replacer to pass down to JSON.parse\n   */\n  constructor(replacer) {\n    this.replacer = replacer;\n  }\n  /**\n   * Encode a packet as a single string if non-binary, or as a\n   * buffer sequence, depending on packet type.\n   *\n   * @param {Object} obj - packet object\n   */\n  encode(obj) {\n    if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {\n      if (hasBinary(obj)) {\n        return this.encodeAsBinary({\n          type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,\n          nsp: obj.nsp,\n          data: obj.data,\n          id: obj.id\n        });\n      }\n    }\n    return [this.encodeAsString(obj)];\n  }\n  /**\n   * Encode packet as string.\n   */\n  encodeAsString(obj) {\n    // first is type\n    let str = \"\" + obj.type;\n    // attachments if we have them\n    if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) {\n      str += obj.attachments + \"-\";\n    }\n    // if we have a namespace other than `/`\n    // we append it followed by a comma `,`\n    if (obj.nsp && \"/\" !== obj.nsp) {\n      str += obj.nsp + \",\";\n    }\n    // immediately followed by the id\n    if (null != obj.id) {\n      str += obj.id;\n    }\n    // json data\n    if (null != obj.data) {\n      str += JSON.stringify(obj.data, this.replacer);\n    }\n    return str;\n  }\n  /**\n   * Encode packet as 'buffer sequence' by removing blobs, and\n   * deconstructing packet into object with placeholders and\n   * a list of buffers.\n   */\n  encodeAsBinary(obj) {\n    const deconstruction = deconstructPacket(obj);\n    const pack = this.encodeAsString(deconstruction.packet);\n    const buffers = deconstruction.buffers;\n    buffers.unshift(pack); // add packet info to beginning of data list\n    return buffers; // write all the buffers\n  }\n}\n// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript\nfunction isObject(value) {\n  return Object.prototype.toString.call(value) === \"[object Object]\";\n}\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n */\nexport class Decoder extends Emitter {\n  /**\n   * Decoder constructor\n   *\n   * @param {function} reviver - custom reviver to pass down to JSON.stringify\n   */\n  constructor(reviver) {\n    super();\n    this.reviver = reviver;\n  }\n  /**\n   * Decodes an encoded packet string into packet JSON.\n   *\n   * @param {String} obj - encoded packet\n   */\n  add(obj) {\n    let packet;\n    if (typeof obj === \"string\") {\n      if (this.reconstructor) {\n        throw new Error(\"got plaintext data when reconstructing a packet\");\n      }\n      packet = this.decodeString(obj);\n      const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;\n      if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {\n        packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;\n        // binary packet's json\n        this.reconstructor = new BinaryReconstructor(packet);\n        // no attachments, labeled binary but no binary data to follow\n        if (packet.attachments === 0) {\n          super.emitReserved(\"decoded\", packet);\n        }\n      } else {\n        // non-binary full packet\n        super.emitReserved(\"decoded\", packet);\n      }\n    } else if (isBinary(obj) || obj.base64) {\n      // raw binary data\n      if (!this.reconstructor) {\n        throw new Error(\"got binary data when not reconstructing a packet\");\n      } else {\n        packet = this.reconstructor.takeBinaryData(obj);\n        if (packet) {\n          // received final buffer\n          this.reconstructor = null;\n          super.emitReserved(\"decoded\", packet);\n        }\n      }\n    } else {\n      throw new Error(\"Unknown type: \" + obj);\n    }\n  }\n  /**\n   * Decode a packet String (JSON data)\n   *\n   * @param {String} str\n   * @return {Object} packet\n   */\n  decodeString(str) {\n    let i = 0;\n    // look up type\n    const p = {\n      type: Number(str.charAt(0))\n    };\n    if (PacketType[p.type] === undefined) {\n      throw new Error(\"unknown packet type \" + p.type);\n    }\n    // look up attachments if type binary\n    if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {\n      const start = i + 1;\n      while (str.charAt(++i) !== \"-\" && i != str.length) {}\n      const buf = str.substring(start, i);\n      if (buf != Number(buf) || str.charAt(i) !== \"-\") {\n        throw new Error(\"Illegal attachments\");\n      }\n      p.attachments = Number(buf);\n    }\n    // look up namespace (if any)\n    if (\"/\" === str.charAt(i + 1)) {\n      const start = i + 1;\n      while (++i) {\n        const c = str.charAt(i);\n        if (\",\" === c) break;\n        if (i === str.length) break;\n      }\n      p.nsp = str.substring(start, i);\n    } else {\n      p.nsp = \"/\";\n    }\n    // look up id\n    const next = str.charAt(i + 1);\n    if (\"\" !== next && Number(next) == next) {\n      const start = i + 1;\n      while (++i) {\n        const c = str.charAt(i);\n        if (null == c || Number(c) != c) {\n          --i;\n          break;\n        }\n        if (i === str.length) break;\n      }\n      p.id = Number(str.substring(start, i + 1));\n    }\n    // look up json data\n    if (str.charAt(++i)) {\n      const payload = this.tryParse(str.substr(i));\n      if (Decoder.isPayloadValid(p.type, payload)) {\n        p.data = payload;\n      } else {\n        throw new Error(\"invalid payload\");\n      }\n    }\n    return p;\n  }\n  tryParse(str) {\n    try {\n      return JSON.parse(str, this.reviver);\n    } catch (e) {\n      return false;\n    }\n  }\n  static isPayloadValid(type, payload) {\n    switch (type) {\n      case PacketType.CONNECT:\n        return isObject(payload);\n      case PacketType.DISCONNECT:\n        return payload === undefined;\n      case PacketType.CONNECT_ERROR:\n        return typeof payload === \"string\" || isObject(payload);\n      case PacketType.EVENT:\n      case PacketType.BINARY_EVENT:\n        return Array.isArray(payload) && (typeof payload[0] === \"number\" || typeof payload[0] === \"string\" && RESERVED_EVENTS.indexOf(payload[0]) === -1);\n      case PacketType.ACK:\n      case PacketType.BINARY_ACK:\n        return Array.isArray(payload);\n    }\n  }\n  /**\n   * Deallocates a parser's resources\n   */\n  destroy() {\n    if (this.reconstructor) {\n      this.reconstructor.finishedReconstruction();\n      this.reconstructor = null;\n    }\n  }\n}\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n */\nclass BinaryReconstructor {\n  constructor(packet) {\n    this.packet = packet;\n    this.buffers = [];\n    this.reconPack = packet;\n  }\n  /**\n   * Method to be called when binary data received from connection\n   * after a BINARY_EVENT packet.\n   *\n   * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n   * @return {null | Object} returns null if more binary data is expected or\n   *   a reconstructed packet object if all buffers have been received.\n   */\n  takeBinaryData(binData) {\n    this.buffers.push(binData);\n    if (this.buffers.length === this.reconPack.attachments) {\n      // done with buffer list\n      const packet = reconstructPacket(this.reconPack, this.buffers);\n      this.finishedReconstruction();\n      return packet;\n    }\n    return null;\n  }\n  /**\n   * Cleans up binary packet reconstruction variables.\n   */\n  finishedReconstruction() {\n    this.reconPack = null;\n    this.buffers = [];\n  }\n}","const withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nconst isView = obj => {\n  return typeof ArrayBuffer.isView === \"function\" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;\n};\nconst toString = Object.prototype.toString;\nconst withNativeBlob = typeof Blob === \"function\" || typeof Blob !== \"undefined\" && toString.call(Blob) === \"[object BlobConstructor]\";\nconst withNativeFile = typeof File === \"function\" || typeof File !== \"undefined\" && toString.call(File) === \"[object FileConstructor]\";\n/**\n * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.\n *\n * @private\n */\nexport function isBinary(obj) {\n  return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;\n}\nexport function hasBinary(obj, toJSON) {\n  if (!obj || typeof obj !== \"object\") {\n    return false;\n  }\n  if (Array.isArray(obj)) {\n    for (let i = 0, l = obj.length; i < l; i++) {\n      if (hasBinary(obj[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n  if (isBinary(obj)) {\n    return true;\n  }\n  if (obj.toJSON && typeof obj.toJSON === \"function\" && arguments.length === 1) {\n    return hasBinary(obj.toJSON(), true);\n  }\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n      return true;\n    }\n  }\n  return false;\n}","import { isBinary } from \"./is-binary.js\";\n/**\n * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @public\n */\nexport function deconstructPacket(packet) {\n  const buffers = [];\n  const packetData = packet.data;\n  const pack = packet;\n  pack.data = _deconstructPacket(packetData, buffers);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {\n    packet: pack,\n    buffers: buffers\n  };\n}\nfunction _deconstructPacket(data, buffers) {\n  if (!data) return data;\n  if (isBinary(data)) {\n    const placeholder = {\n      _placeholder: true,\n      num: buffers.length\n    };\n    buffers.push(data);\n    return placeholder;\n  } else if (Array.isArray(data)) {\n    const newData = new Array(data.length);\n    for (let i = 0; i < data.length; i++) {\n      newData[i] = _deconstructPacket(data[i], buffers);\n    }\n    return newData;\n  } else if (typeof data === \"object\" && !(data instanceof Date)) {\n    const newData = {};\n    for (const key in data) {\n      if (Object.prototype.hasOwnProperty.call(data, key)) {\n        newData[key] = _deconstructPacket(data[key], buffers);\n      }\n    }\n    return newData;\n  }\n  return data;\n}\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @public\n */\nexport function reconstructPacket(packet, buffers) {\n  packet.data = _reconstructPacket(packet.data, buffers);\n  delete packet.attachments; // no longer useful\n  return packet;\n}\nfunction _reconstructPacket(data, buffers) {\n  if (!data) return data;\n  if (data && data._placeholder === true) {\n    const isIndexValid = typeof data.num === \"number\" && data.num >= 0 && data.num < buffers.length;\n    if (isIndexValid) {\n      return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n    } else {\n      throw new Error(\"illegal attachments\");\n    }\n  } else if (Array.isArray(data)) {\n    for (let i = 0; i < data.length; i++) {\n      data[i] = _reconstructPacket(data[i], buffers);\n    }\n  } else if (typeof data === \"object\") {\n    for (const key in data) {\n      if (Object.prototype.hasOwnProperty.call(data, key)) {\n        data[key] = _reconstructPacket(data[key], buffers);\n      }\n    }\n  }\n  return data;\n}","export function on(obj, ev, fn) {\n  obj.on(ev, fn);\n  return function subDestroy() {\n    obj.off(ev, fn);\n  };\n}","import { PacketType } from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\n/**\n * Internal events.\n * These events can't be emitted by the user.\n */\nconst RESERVED_EVENTS = Object.freeze({\n  connect: 1,\n  connect_error: 1,\n  disconnect: 1,\n  disconnecting: 1,\n  // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener\n  newListener: 1,\n  removeListener: 1\n});\n/**\n * A Socket is the fundamental class for interacting with the server.\n *\n * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.\n *\n * @example\n * const socket = io();\n *\n * socket.on(\"connect\", () => {\n *   console.log(\"connected\");\n * });\n *\n * // send an event to the server\n * socket.emit(\"foo\", \"bar\");\n *\n * socket.on(\"foobar\", () => {\n *   // an event was received from the server\n * });\n *\n * // upon disconnection\n * socket.on(\"disconnect\", (reason) => {\n *   console.log(`disconnected due to ${reason}`);\n * });\n */\nexport class Socket extends Emitter {\n  /**\n   * `Socket` constructor.\n   */\n  constructor(io, nsp, opts) {\n    super();\n    /**\n     * Whether the socket is currently connected to the server.\n     *\n     * @example\n     * const socket = io();\n     *\n     * socket.on(\"connect\", () => {\n     *   console.log(socket.connected); // true\n     * });\n     *\n     * socket.on(\"disconnect\", () => {\n     *   console.log(socket.connected); // false\n     * });\n     */\n    this.connected = false;\n    /**\n     * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will\n     * be transmitted by the server.\n     */\n    this.recovered = false;\n    /**\n     * Buffer for packets received before the CONNECT packet\n     */\n    this.receiveBuffer = [];\n    /**\n     * Buffer for packets that will be sent once the socket is connected\n     */\n    this.sendBuffer = [];\n    /**\n     * The queue of packets to be sent with retry in case of failure.\n     *\n     * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.\n     * @private\n     */\n    this._queue = [];\n    /**\n     * A sequence to generate the ID of the {@link QueuedPacket}.\n     * @private\n     */\n    this._queueSeq = 0;\n    this.ids = 0;\n    /**\n     * A map containing acknowledgement handlers.\n     *\n     * The `withError` attribute is used to differentiate handlers that accept an error as first argument:\n     *\n     * - `socket.emit(\"test\", (err, value) => { ... })` with `ackTimeout` option\n     * - `socket.timeout(5000).emit(\"test\", (err, value) => { ... })`\n     * - `const value = await socket.emitWithAck(\"test\")`\n     *\n     * From those that don't:\n     *\n     * - `socket.emit(\"test\", (value) => { ... });`\n     *\n     * In the first case, the handlers will be called with an error when:\n     *\n     * - the timeout is reached\n     * - the socket gets disconnected\n     *\n     * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive\n     * an acknowledgement from the server.\n     *\n     * @private\n     */\n    this.acks = {};\n    this.flags = {};\n    this.io = io;\n    this.nsp = nsp;\n    if (opts && opts.auth) {\n      this.auth = opts.auth;\n    }\n    this._opts = Object.assign({}, opts);\n    if (this.io._autoConnect) this.open();\n  }\n  /**\n   * Whether the socket is currently disconnected\n   *\n   * @example\n   * const socket = io();\n   *\n   * socket.on(\"connect\", () => {\n   *   console.log(socket.disconnected); // false\n   * });\n   *\n   * socket.on(\"disconnect\", () => {\n   *   console.log(socket.disconnected); // true\n   * });\n   */\n  get disconnected() {\n    return !this.connected;\n  }\n  /**\n   * Subscribe to open, close and packet events\n   *\n   * @private\n   */\n  subEvents() {\n    if (this.subs) return;\n    const io = this.io;\n    this.subs = [on(io, \"open\", this.onopen.bind(this)), on(io, \"packet\", this.onpacket.bind(this)), on(io, \"error\", this.onerror.bind(this)), on(io, \"close\", this.onclose.bind(this))];\n  }\n  /**\n   * Whether the Socket will try to reconnect when its Manager connects or reconnects.\n   *\n   * @example\n   * const socket = io();\n   *\n   * console.log(socket.active); // true\n   *\n   * socket.on(\"disconnect\", (reason) => {\n   *   if (reason === \"io server disconnect\") {\n   *     // the disconnection was initiated by the server, you need to manually reconnect\n   *     console.log(socket.active); // false\n   *   }\n   *   // else the socket will automatically try to reconnect\n   *   console.log(socket.active); // true\n   * });\n   */\n  get active() {\n    return !!this.subs;\n  }\n  /**\n   * \"Opens\" the socket.\n   *\n   * @example\n   * const socket = io({\n   *   autoConnect: false\n   * });\n   *\n   * socket.connect();\n   */\n  connect() {\n    if (this.connected) return this;\n    this.subEvents();\n    if (!this.io[\"_reconnecting\"]) this.io.open(); // ensure open\n    if (\"open\" === this.io._readyState) this.onopen();\n    return this;\n  }\n  /**\n   * Alias for {@link connect()}.\n   */\n  open() {\n    return this.connect();\n  }\n  /**\n   * Sends a `message` event.\n   *\n   * This method mimics the WebSocket.send() method.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send\n   *\n   * @example\n   * socket.send(\"hello\");\n   *\n   * // this is equivalent to\n   * socket.emit(\"message\", \"hello\");\n   *\n   * @return self\n   */\n  send(...args) {\n    args.unshift(\"message\");\n    this.emit.apply(this, args);\n    return this;\n  }\n  /**\n   * Override `emit`.\n   * If the event is in `events`, it's emitted normally.\n   *\n   * @example\n   * socket.emit(\"hello\", \"world\");\n   *\n   * // all serializable datastructures are supported (no need to call JSON.stringify)\n   * socket.emit(\"hello\", 1, \"2\", { 3: [\"4\"], 5: Uint8Array.from([6]) });\n   *\n   * // with an acknowledgement from the server\n   * socket.emit(\"hello\", \"world\", (val) => {\n   *   // ...\n   * });\n   *\n   * @return self\n   */\n  emit(ev, ...args) {\n    if (RESERVED_EVENTS.hasOwnProperty(ev)) {\n      throw new Error('\"' + ev.toString() + '\" is a reserved event name');\n    }\n    args.unshift(ev);\n    if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {\n      this._addToQueue(args);\n      return this;\n    }\n    const packet = {\n      type: PacketType.EVENT,\n      data: args\n    };\n    packet.options = {};\n    packet.options.compress = this.flags.compress !== false;\n    // event ack callback\n    if (\"function\" === typeof args[args.length - 1]) {\n      const id = this.ids++;\n      const ack = args.pop();\n      this._registerAckCallback(id, ack);\n      packet.id = id;\n    }\n    const isTransportWritable = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable;\n    const discardPacket = this.flags.volatile && (!isTransportWritable || !this.connected);\n    if (discardPacket) {} else if (this.connected) {\n      this.notifyOutgoingListeners(packet);\n      this.packet(packet);\n    } else {\n      this.sendBuffer.push(packet);\n    }\n    this.flags = {};\n    return this;\n  }\n  /**\n   * @private\n   */\n  _registerAckCallback(id, ack) {\n    var _a;\n    const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;\n    if (timeout === undefined) {\n      this.acks[id] = ack;\n      return;\n    }\n    // @ts-ignore\n    const timer = this.io.setTimeoutFn(() => {\n      delete this.acks[id];\n      for (let i = 0; i < this.sendBuffer.length; i++) {\n        if (this.sendBuffer[i].id === id) {\n          this.sendBuffer.splice(i, 1);\n        }\n      }\n      ack.call(this, new Error(\"operation has timed out\"));\n    }, timeout);\n    const fn = (...args) => {\n      // @ts-ignore\n      this.io.clearTimeoutFn(timer);\n      ack.apply(this, args);\n    };\n    fn.withError = true;\n    this.acks[id] = fn;\n  }\n  /**\n   * Emits an event and waits for an acknowledgement\n   *\n   * @example\n   * // without timeout\n   * const response = await socket.emitWithAck(\"hello\", \"world\");\n   *\n   * // with a specific timeout\n   * try {\n   *   const response = await socket.timeout(1000).emitWithAck(\"hello\", \"world\");\n   * } catch (err) {\n   *   // the server did not acknowledge the event in the given delay\n   * }\n   *\n   * @return a Promise that will be fulfilled when the server acknowledges the event\n   */\n  emitWithAck(ev, ...args) {\n    return new Promise((resolve, reject) => {\n      const fn = (arg1, arg2) => {\n        return arg1 ? reject(arg1) : resolve(arg2);\n      };\n      fn.withError = true;\n      args.push(fn);\n      this.emit(ev, ...args);\n    });\n  }\n  /**\n   * Add the packet to the queue.\n   * @param args\n   * @private\n   */\n  _addToQueue(args) {\n    let ack;\n    if (typeof args[args.length - 1] === \"function\") {\n      ack = args.pop();\n    }\n    const packet = {\n      id: this._queueSeq++,\n      tryCount: 0,\n      pending: false,\n      args,\n      flags: Object.assign({\n        fromQueue: true\n      }, this.flags)\n    };\n    args.push((err, ...responseArgs) => {\n      if (packet !== this._queue[0]) {\n        // the packet has already been acknowledged\n        return;\n      }\n      const hasError = err !== null;\n      if (hasError) {\n        if (packet.tryCount > this._opts.retries) {\n          this._queue.shift();\n          if (ack) {\n            ack(err);\n          }\n        }\n      } else {\n        this._queue.shift();\n        if (ack) {\n          ack(null, ...responseArgs);\n        }\n      }\n      packet.pending = false;\n      return this._drainQueue();\n    });\n    this._queue.push(packet);\n    this._drainQueue();\n  }\n  /**\n   * Send the first packet of the queue, and wait for an acknowledgement from the server.\n   * @param force - whether to resend a packet that has not been acknowledged yet\n   *\n   * @private\n   */\n  _drainQueue(force = false) {\n    if (!this.connected || this._queue.length === 0) {\n      return;\n    }\n    const packet = this._queue[0];\n    if (packet.pending && !force) {\n      return;\n    }\n    packet.pending = true;\n    packet.tryCount++;\n    this.flags = packet.flags;\n    this.emit.apply(this, packet.args);\n  }\n  /**\n   * Sends a packet.\n   *\n   * @param packet\n   * @private\n   */\n  packet(packet) {\n    packet.nsp = this.nsp;\n    this.io._packet(packet);\n  }\n  /**\n   * Called upon engine `open`.\n   *\n   * @private\n   */\n  onopen() {\n    if (typeof this.auth == \"function\") {\n      this.auth(data => {\n        this._sendConnectPacket(data);\n      });\n    } else {\n      this._sendConnectPacket(this.auth);\n    }\n  }\n  /**\n   * Sends a CONNECT packet to initiate the Socket.IO session.\n   *\n   * @param data\n   * @private\n   */\n  _sendConnectPacket(data) {\n    this.packet({\n      type: PacketType.CONNECT,\n      data: this._pid ? Object.assign({\n        pid: this._pid,\n        offset: this._lastOffset\n      }, data) : data\n    });\n  }\n  /**\n   * Called upon engine or manager `error`.\n   *\n   * @param err\n   * @private\n   */\n  onerror(err) {\n    if (!this.connected) {\n      this.emitReserved(\"connect_error\", err);\n    }\n  }\n  /**\n   * Called upon engine `close`.\n   *\n   * @param reason\n   * @param description\n   * @private\n   */\n  onclose(reason, description) {\n    this.connected = false;\n    delete this.id;\n    this.emitReserved(\"disconnect\", reason, description);\n    this._clearAcks();\n  }\n  /**\n   * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from\n   * the server.\n   *\n   * @private\n   */\n  _clearAcks() {\n    Object.keys(this.acks).forEach(id => {\n      const isBuffered = this.sendBuffer.some(packet => String(packet.id) === id);\n      if (!isBuffered) {\n        // note: handlers that do not accept an error as first argument are ignored here\n        const ack = this.acks[id];\n        delete this.acks[id];\n        if (ack.withError) {\n          ack.call(this, new Error(\"socket has been disconnected\"));\n        }\n      }\n    });\n  }\n  /**\n   * Called with socket packet.\n   *\n   * @param packet\n   * @private\n   */\n  onpacket(packet) {\n    const sameNamespace = packet.nsp === this.nsp;\n    if (!sameNamespace) return;\n    switch (packet.type) {\n      case PacketType.CONNECT:\n        if (packet.data && packet.data.sid) {\n          this.onconnect(packet.data.sid, packet.data.pid);\n        } else {\n          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/)\"));\n        }\n        break;\n      case PacketType.EVENT:\n      case PacketType.BINARY_EVENT:\n        this.onevent(packet);\n        break;\n      case PacketType.ACK:\n      case PacketType.BINARY_ACK:\n        this.onack(packet);\n        break;\n      case PacketType.DISCONNECT:\n        this.ondisconnect();\n        break;\n      case PacketType.CONNECT_ERROR:\n        this.destroy();\n        const err = new Error(packet.data.message);\n        // @ts-ignore\n        err.data = packet.data.data;\n        this.emitReserved(\"connect_error\", err);\n        break;\n    }\n  }\n  /**\n   * Called upon a server event.\n   *\n   * @param packet\n   * @private\n   */\n  onevent(packet) {\n    const args = packet.data || [];\n    if (null != packet.id) {\n      args.push(this.ack(packet.id));\n    }\n    if (this.connected) {\n      this.emitEvent(args);\n    } else {\n      this.receiveBuffer.push(Object.freeze(args));\n    }\n  }\n  emitEvent(args) {\n    if (this._anyListeners && this._anyListeners.length) {\n      const listeners = this._anyListeners.slice();\n      for (const listener of listeners) {\n        listener.apply(this, args);\n      }\n    }\n    super.emit.apply(this, args);\n    if (this._pid && args.length && typeof args[args.length - 1] === \"string\") {\n      this._lastOffset = args[args.length - 1];\n    }\n  }\n  /**\n   * Produces an ack callback to emit with an event.\n   *\n   * @private\n   */\n  ack(id) {\n    const self = this;\n    let sent = false;\n    return function (...args) {\n      // prevent double callbacks\n      if (sent) return;\n      sent = true;\n      self.packet({\n        type: PacketType.ACK,\n        id: id,\n        data: args\n      });\n    };\n  }\n  /**\n   * Called upon a server acknowledgement.\n   *\n   * @param packet\n   * @private\n   */\n  onack(packet) {\n    const ack = this.acks[packet.id];\n    if (typeof ack !== \"function\") {\n      return;\n    }\n    delete this.acks[packet.id];\n    // @ts-ignore FIXME ack is incorrectly inferred as 'never'\n    if (ack.withError) {\n      packet.data.unshift(null);\n    }\n    // @ts-ignore\n    ack.apply(this, packet.data);\n  }\n  /**\n   * Called upon server connect.\n   *\n   * @private\n   */\n  onconnect(id, pid) {\n    this.id = id;\n    this.recovered = pid && this._pid === pid;\n    this._pid = pid; // defined only if connection state recovery is enabled\n    this.connected = true;\n    this.emitBuffered();\n    this.emitReserved(\"connect\");\n    this._drainQueue(true);\n  }\n  /**\n   * Emit buffered events (received and emitted).\n   *\n   * @private\n   */\n  emitBuffered() {\n    this.receiveBuffer.forEach(args => this.emitEvent(args));\n    this.receiveBuffer = [];\n    this.sendBuffer.forEach(packet => {\n      this.notifyOutgoingListeners(packet);\n      this.packet(packet);\n    });\n    this.sendBuffer = [];\n  }\n  /**\n   * Called upon server disconnect.\n   *\n   * @private\n   */\n  ondisconnect() {\n    this.destroy();\n    this.onclose(\"io server disconnect\");\n  }\n  /**\n   * Called upon forced client/server side disconnections,\n   * this method ensures the manager stops tracking us and\n   * that reconnections don't get triggered for this.\n   *\n   * @private\n   */\n  destroy() {\n    if (this.subs) {\n      // clean subscriptions to avoid reconnections\n      this.subs.forEach(subDestroy => subDestroy());\n      this.subs = undefined;\n    }\n    this.io[\"_destroy\"](this);\n  }\n  /**\n   * Disconnects the socket manually. In that case, the socket will not try to reconnect.\n   *\n   * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.\n   *\n   * @example\n   * const socket = io();\n   *\n   * socket.on(\"disconnect\", (reason) => {\n   *   // console.log(reason); prints \"io client disconnect\"\n   * });\n   *\n   * socket.disconnect();\n   *\n   * @return self\n   */\n  disconnect() {\n    if (this.connected) {\n      this.packet({\n        type: PacketType.DISCONNECT\n      });\n    }\n    // remove socket from pool\n    this.destroy();\n    if (this.connected) {\n      // fire events\n      this.onclose(\"io client disconnect\");\n    }\n    return this;\n  }\n  /**\n   * Alias for {@link disconnect()}.\n   *\n   * @return self\n   */\n  close() {\n    return this.disconnect();\n  }\n  /**\n   * Sets the compress flag.\n   *\n   * @example\n   * socket.compress(false).emit(\"hello\");\n   *\n   * @param compress - if `true`, compresses the sending data\n   * @return self\n   */\n  compress(compress) {\n    this.flags.compress = compress;\n    return this;\n  }\n  /**\n   * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not\n   * ready to send messages.\n   *\n   * @example\n   * socket.volatile.emit(\"hello\"); // the server may or may not receive it\n   *\n   * @returns self\n   */\n  get volatile() {\n    this.flags.volatile = true;\n    return this;\n  }\n  /**\n   * Sets a modifier for a subsequent event emission that the callback will be called with an error when the\n   * given number of milliseconds have elapsed without an acknowledgement from the server:\n   *\n   * @example\n   * socket.timeout(5000).emit(\"my-event\", (err) => {\n   *   if (err) {\n   *     // the server did not acknowledge the event in the given delay\n   *   }\n   * });\n   *\n   * @returns self\n   */\n  timeout(timeout) {\n    this.flags.timeout = timeout;\n    return this;\n  }\n  /**\n   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n   * callback.\n   *\n   * @example\n   * socket.onAny((event, ...args) => {\n   *   console.log(`got ${event}`);\n   * });\n   *\n   * @param listener\n   */\n  onAny(listener) {\n    this._anyListeners = this._anyListeners || [];\n    this._anyListeners.push(listener);\n    return this;\n  }\n  /**\n   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n   * callback. The listener is added to the beginning of the listeners array.\n   *\n   * @example\n   * socket.prependAny((event, ...args) => {\n   *   console.log(`got event ${event}`);\n   * });\n   *\n   * @param listener\n   */\n  prependAny(listener) {\n    this._anyListeners = this._anyListeners || [];\n    this._anyListeners.unshift(listener);\n    return this;\n  }\n  /**\n   * Removes the listener that will be fired when any event is emitted.\n   *\n   * @example\n   * const catchAllListener = (event, ...args) => {\n   *   console.log(`got event ${event}`);\n   * }\n   *\n   * socket.onAny(catchAllListener);\n   *\n   * // remove a specific listener\n   * socket.offAny(catchAllListener);\n   *\n   * // or remove all listeners\n   * socket.offAny();\n   *\n   * @param listener\n   */\n  offAny(listener) {\n    if (!this._anyListeners) {\n      return this;\n    }\n    if (listener) {\n      const listeners = this._anyListeners;\n      for (let i = 0; i < listeners.length; i++) {\n        if (listener === listeners[i]) {\n          listeners.splice(i, 1);\n          return this;\n        }\n      }\n    } else {\n      this._anyListeners = [];\n    }\n    return this;\n  }\n  /**\n   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n   * e.g. to remove listeners.\n   */\n  listenersAny() {\n    return this._anyListeners || [];\n  }\n  /**\n   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n   * callback.\n   *\n   * Note: acknowledgements sent to the server are not included.\n   *\n   * @example\n   * socket.onAnyOutgoing((event, ...args) => {\n   *   console.log(`sent event ${event}`);\n   * });\n   *\n   * @param listener\n   */\n  onAnyOutgoing(listener) {\n    this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n    this._anyOutgoingListeners.push(listener);\n    return this;\n  }\n  /**\n   * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n   * callback. The listener is added to the beginning of the listeners array.\n   *\n   * Note: acknowledgements sent to the server are not included.\n   *\n   * @example\n   * socket.prependAnyOutgoing((event, ...args) => {\n   *   console.log(`sent event ${event}`);\n   * });\n   *\n   * @param listener\n   */\n  prependAnyOutgoing(listener) {\n    this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n    this._anyOutgoingListeners.unshift(listener);\n    return this;\n  }\n  /**\n   * Removes the listener that will be fired when any event is emitted.\n   *\n   * @example\n   * const catchAllListener = (event, ...args) => {\n   *   console.log(`sent event ${event}`);\n   * }\n   *\n   * socket.onAnyOutgoing(catchAllListener);\n   *\n   * // remove a specific listener\n   * socket.offAnyOutgoing(catchAllListener);\n   *\n   * // or remove all listeners\n   * socket.offAnyOutgoing();\n   *\n   * @param [listener] - the catch-all listener (optional)\n   */\n  offAnyOutgoing(listener) {\n    if (!this._anyOutgoingListeners) {\n      return this;\n    }\n    if (listener) {\n      const listeners = this._anyOutgoingListeners;\n      for (let i = 0; i < listeners.length; i++) {\n        if (listener === listeners[i]) {\n          listeners.splice(i, 1);\n          return this;\n        }\n      }\n    } else {\n      this._anyOutgoingListeners = [];\n    }\n    return this;\n  }\n  /**\n   * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n   * e.g. to remove listeners.\n   */\n  listenersAnyOutgoing() {\n    return this._anyOutgoingListeners || [];\n  }\n  /**\n   * Notify the listeners for each packet sent\n   *\n   * @param packet\n   *\n   * @private\n   */\n  notifyOutgoingListeners(packet) {\n    if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {\n      const listeners = this._anyOutgoingListeners.slice();\n      for (const listener of listeners) {\n        listener.apply(this, packet.data);\n      }\n    }\n  }\n}","/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\nexport function Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\nBackoff.prototype.duration = function () {\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand = Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\nBackoff.prototype.reset = function () {\n  this.attempts = 0;\n};\n/**\n * Set the minimum duration\n *\n * @api public\n */\nBackoff.prototype.setMin = function (min) {\n  this.ms = min;\n};\n/**\n * Set the maximum duration\n *\n * @api public\n */\nBackoff.prototype.setMax = function (max) {\n  this.max = max;\n};\n/**\n * Set the jitter\n *\n * @api public\n */\nBackoff.prototype.setJitter = function (jitter) {\n  this.jitter = jitter;\n};","import { Socket as Engine, installTimerFunctions, nextTick } from \"engine.io-client\";\nimport { Socket } from \"./socket.js\";\nimport * as parser from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport { Backoff } from \"./contrib/backo2.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nexport class Manager extends Emitter {\n  constructor(uri, opts) {\n    var _a;\n    super();\n    this.nsps = {};\n    this.subs = [];\n    if (uri && \"object\" === typeof uri) {\n      opts = uri;\n      uri = undefined;\n    }\n    opts = opts || {};\n    opts.path = opts.path || \"/socket.io\";\n    this.opts = opts;\n    installTimerFunctions(this, opts);\n    this.reconnection(opts.reconnection !== false);\n    this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n    this.reconnectionDelay(opts.reconnectionDelay || 1000);\n    this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n    this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);\n    this.backoff = new Backoff({\n      min: this.reconnectionDelay(),\n      max: this.reconnectionDelayMax(),\n      jitter: this.randomizationFactor()\n    });\n    this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n    this._readyState = \"closed\";\n    this.uri = uri;\n    const _parser = opts.parser || parser;\n    this.encoder = new _parser.Encoder();\n    this.decoder = new _parser.Decoder();\n    this._autoConnect = opts.autoConnect !== false;\n    if (this._autoConnect) this.open();\n  }\n  reconnection(v) {\n    if (!arguments.length) return this._reconnection;\n    this._reconnection = !!v;\n    return this;\n  }\n  reconnectionAttempts(v) {\n    if (v === undefined) return this._reconnectionAttempts;\n    this._reconnectionAttempts = v;\n    return this;\n  }\n  reconnectionDelay(v) {\n    var _a;\n    if (v === undefined) return this._reconnectionDelay;\n    this._reconnectionDelay = v;\n    (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);\n    return this;\n  }\n  randomizationFactor(v) {\n    var _a;\n    if (v === undefined) return this._randomizationFactor;\n    this._randomizationFactor = v;\n    (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);\n    return this;\n  }\n  reconnectionDelayMax(v) {\n    var _a;\n    if (v === undefined) return this._reconnectionDelayMax;\n    this._reconnectionDelayMax = v;\n    (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);\n    return this;\n  }\n  timeout(v) {\n    if (!arguments.length) return this._timeout;\n    this._timeout = v;\n    return this;\n  }\n  /**\n   * Starts trying to reconnect if reconnection is enabled and we have not\n   * started reconnecting yet\n   *\n   * @private\n   */\n  maybeReconnectOnOpen() {\n    // Only try to reconnect if it's the first time we're connecting\n    if (!this._reconnecting && this._reconnection && this.backoff.attempts === 0) {\n      // keeps reconnection from firing twice for the same reconnection loop\n      this.reconnect();\n    }\n  }\n  /**\n   * Sets the current transport `socket`.\n   *\n   * @param {Function} fn - optional, callback\n   * @return self\n   * @public\n   */\n  open(fn) {\n    if (~this._readyState.indexOf(\"open\")) return this;\n    this.engine = new Engine(this.uri, this.opts);\n    const socket = this.engine;\n    const self = this;\n    this._readyState = \"opening\";\n    this.skipReconnect = false;\n    // emit `open`\n    const openSubDestroy = on(socket, \"open\", function () {\n      self.onopen();\n      fn && fn();\n    });\n    const onError = err => {\n      this.cleanup();\n      this._readyState = \"closed\";\n      this.emitReserved(\"error\", err);\n      if (fn) {\n        fn(err);\n      } else {\n        // Only do this if there is no fn to handle the error\n        this.maybeReconnectOnOpen();\n      }\n    };\n    // emit `error`\n    const errorSub = on(socket, \"error\", onError);\n    if (false !== this._timeout) {\n      const timeout = this._timeout;\n      // set timer\n      const timer = this.setTimeoutFn(() => {\n        openSubDestroy();\n        onError(new Error(\"timeout\"));\n        socket.close();\n      }, timeout);\n      if (this.opts.autoUnref) {\n        timer.unref();\n      }\n      this.subs.push(() => {\n        this.clearTimeoutFn(timer);\n      });\n    }\n    this.subs.push(openSubDestroy);\n    this.subs.push(errorSub);\n    return this;\n  }\n  /**\n   * Alias for open()\n   *\n   * @return self\n   * @public\n   */\n  connect(fn) {\n    return this.open(fn);\n  }\n  /**\n   * Called upon transport open.\n   *\n   * @private\n   */\n  onopen() {\n    // clear old subs\n    this.cleanup();\n    // mark as open\n    this._readyState = \"open\";\n    this.emitReserved(\"open\");\n    // add new subs\n    const socket = this.engine;\n    this.subs.push(on(socket, \"ping\", this.onping.bind(this)), on(socket, \"data\", this.ondata.bind(this)), on(socket, \"error\", this.onerror.bind(this)), on(socket, \"close\", this.onclose.bind(this)), on(this.decoder, \"decoded\", this.ondecoded.bind(this)));\n  }\n  /**\n   * Called upon a ping.\n   *\n   * @private\n   */\n  onping() {\n    this.emitReserved(\"ping\");\n  }\n  /**\n   * Called with data.\n   *\n   * @private\n   */\n  ondata(data) {\n    try {\n      this.decoder.add(data);\n    } catch (e) {\n      this.onclose(\"parse error\", e);\n    }\n  }\n  /**\n   * Called when parser fully decodes a packet.\n   *\n   * @private\n   */\n  ondecoded(packet) {\n    // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a \"parse error\"\n    nextTick(() => {\n      this.emitReserved(\"packet\", packet);\n    }, this.setTimeoutFn);\n  }\n  /**\n   * Called upon socket error.\n   *\n   * @private\n   */\n  onerror(err) {\n    this.emitReserved(\"error\", err);\n  }\n  /**\n   * Creates a new socket for the given `nsp`.\n   *\n   * @return {Socket}\n   * @public\n   */\n  socket(nsp, opts) {\n    let socket = this.nsps[nsp];\n    if (!socket) {\n      socket = new Socket(this, nsp, opts);\n      this.nsps[nsp] = socket;\n    } else if (this._autoConnect && !socket.active) {\n      socket.connect();\n    }\n    return socket;\n  }\n  /**\n   * Called upon a socket close.\n   *\n   * @param socket\n   * @private\n   */\n  _destroy(socket) {\n    const nsps = Object.keys(this.nsps);\n    for (const nsp of nsps) {\n      const socket = this.nsps[nsp];\n      if (socket.active) {\n        return;\n      }\n    }\n    this._close();\n  }\n  /**\n   * Writes a packet.\n   *\n   * @param packet\n   * @private\n   */\n  _packet(packet) {\n    const encodedPackets = this.encoder.encode(packet);\n    for (let i = 0; i < encodedPackets.length; i++) {\n      this.engine.write(encodedPackets[i], packet.options);\n    }\n  }\n  /**\n   * Clean up transport subscriptions and packet buffer.\n   *\n   * @private\n   */\n  cleanup() {\n    this.subs.forEach(subDestroy => subDestroy());\n    this.subs.length = 0;\n    this.decoder.destroy();\n  }\n  /**\n   * Close the current socket.\n   *\n   * @private\n   */\n  _close() {\n    this.skipReconnect = true;\n    this._reconnecting = false;\n    this.onclose(\"forced close\");\n    if (this.engine) this.engine.close();\n  }\n  /**\n   * Alias for close()\n   *\n   * @private\n   */\n  disconnect() {\n    return this._close();\n  }\n  /**\n   * Called upon engine close.\n   *\n   * @private\n   */\n  onclose(reason, description) {\n    this.cleanup();\n    this.backoff.reset();\n    this._readyState = \"closed\";\n    this.emitReserved(\"close\", reason, description);\n    if (this._reconnection && !this.skipReconnect) {\n      this.reconnect();\n    }\n  }\n  /**\n   * Attempt a reconnection.\n   *\n   * @private\n   */\n  reconnect() {\n    if (this._reconnecting || this.skipReconnect) return this;\n    const self = this;\n    if (this.backoff.attempts >= this._reconnectionAttempts) {\n      this.backoff.reset();\n      this.emitReserved(\"reconnect_failed\");\n      this._reconnecting = false;\n    } else {\n      const delay = this.backoff.duration();\n      this._reconnecting = true;\n      const timer = this.setTimeoutFn(() => {\n        if (self.skipReconnect) return;\n        this.emitReserved(\"reconnect_attempt\", self.backoff.attempts);\n        // check again for the case socket closed in above events\n        if (self.skipReconnect) return;\n        self.open(err => {\n          if (err) {\n            self._reconnecting = false;\n            self.reconnect();\n            this.emitReserved(\"reconnect_error\", err);\n          } else {\n            self.onreconnect();\n          }\n        });\n      }, delay);\n      if (this.opts.autoUnref) {\n        timer.unref();\n      }\n      this.subs.push(() => {\n        this.clearTimeoutFn(timer);\n      });\n    }\n  }\n  /**\n   * Called upon successful reconnect.\n   *\n   * @private\n   */\n  onreconnect() {\n    const attempt = this.backoff.attempts;\n    this._reconnecting = false;\n    this.backoff.reset();\n    this.emitReserved(\"reconnect\", attempt);\n  }\n}","import { url } from \"./url.js\";\nimport { Manager } from \"./manager.js\";\nimport { Socket } from \"./socket.js\";\n/**\n * Managers cache.\n */\nconst cache = {};\nfunction lookup(uri, opts) {\n  if (typeof uri === \"object\") {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n  const parsed = url(uri, opts.path || \"/socket.io\");\n  const source = parsed.source;\n  const id = parsed.id;\n  const path = parsed.path;\n  const sameNamespace = cache[id] && path in cache[id][\"nsps\"];\n  const newConnection = opts.forceNew || opts[\"force new connection\"] || false === opts.multiplex || sameNamespace;\n  let io;\n  if (newConnection) {\n    io = new Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      cache[id] = new Manager(source, opts);\n    }\n    io = cache[id];\n  }\n  if (parsed.query && !opts.query) {\n    opts.query = parsed.queryKey;\n  }\n  return io.socket(parsed.path, opts);\n}\n// so that \"lookup\" can be used both as a function (e.g. `io(...)`) and as a\n// namespace (e.g. `io.connect(...)`), for backward compatibility\nObject.assign(lookup, {\n  Manager,\n  Socket,\n  io: lookup,\n  connect: lookup\n});\n/**\n * Protocol version.\n *\n * @public\n */\nexport { protocol } from \"socket.io-parser\";\n/**\n * Expose constructors for standalone build.\n *\n * @public\n */\nexport { Manager, Socket, lookup as io, lookup as connect, lookup as default };","import { Observable } from 'rxjs';\nimport { share } from 'rxjs/operators';\nimport { Socket, io } from 'socket.io-client';\nimport { IEventPayload, ResourceId, SocketIoConfig } from './socket-io.model';\n\nexport class SocketIo {\n  private subscribersCounter: Record<string, number> = {};\n  private eventObservables$: Record<string, Observable<any>> = {};\n\n  private socket: Socket;\n\n  constructor(private config: SocketIoConfig) {}\n\n  connect(featurePath?: string) {\n    let url: string;\n    if (featurePath) {\n      url = `${this.config.url}/${featurePath}`;\n    } else {\n      url = this.config.url;\n    }\n\n    // creates and connects\n    this.socket = io(url, this.config.options);\n  }\n\n  disconnect() {\n    this.socket.disconnect();\n  }\n\n  send(event: string, ...args: unknown[]) {\n    this.socket.emit(event, ...args);\n  }\n\n  join(resource: string, ids: ResourceId[]) {\n    this.socket.emit('handshake', { resource, ids });\n  }\n\n  leave(resource: string, ids: ResourceId[]) {\n    this.socket.emit('leave', { resource, ids });\n  }\n\n  unsubscribe() {\n    this.socket.emit('leave-all');\n  }\n\n  acknowledge(ids: string[]) {\n    this.socket.emit('acknowledgement', ids);\n  }\n\n  on(event: string, cb: (payload: IEventPayload<any>) => void) {\n    this.socket.on(event, (payload: IEventPayload<any>) => {\n      cb(payload);\n\n      // ack packet\n      if (payload?.ID) {\n        this.acknowledge([payload.ID]);\n      }\n    });\n  }\n\n  off(event: string, listener?: (...args: any[]) => void) {\n    if (!listener) {\n      // Remove all listeners for that event\n      return this.socket.off(event);\n    }\n\n    // Removes the specified listener from the listener array for the event named\n    return this.socket.off(event, listener);\n  }\n\n  fromEvent$(event: string): Observable<any> {\n    if (!this.subscribersCounter[event]) {\n      this.subscribersCounter[event] = 0;\n    }\n    this.subscribersCounter[event]++;\n\n    // Create a new observable if it doesn't exist\n    if (!this.eventObservables$[event]) {\n      this.eventObservables$[event] = new Observable<any>((obs) => {\n        const listener = (payload: any) => {\n          obs.next(payload.message);\n\n          // ack packet\n          if (payload?.ID) {\n            this.acknowledge([payload.ID]);\n          }\n        };\n\n        this.socket.on(event, listener);\n\n        return () => {\n          this.subscribersCounter[event]--;\n          if (this.subscribersCounter[event] === 0) {\n            this.socket.off(event, listener);\n            delete this.eventObservables$[event];\n          }\n        };\n      }).pipe(share());\n    }\n\n    // Reuse the existing observable\n    return this.eventObservables$[event];\n  }\n}\n","// Purpose: Service for handling socket.io connections.\nimport { Inject, Injectable } from '@angular/core';\n\nimport { SocketIoConfig } from './socket-io.model';\nimport { SOCKET_CONFIG_TOKEN } from './socket-io.token';\n\nimport { AuthService } from 'src/app/core/auth/auth.service';\nimport { SocketIo } from './socket-io.class';\n\n@Injectable()\nexport class SocketIoService {\n  constructor(\n    @Inject(SOCKET_CONFIG_TOKEN) private readonly config: SocketIoConfig,\n    private authService: AuthService\n  ) {}\n\n  /** Creates a new socket connection */\n  createSocket() {\n    return new SocketIo({\n      ...this.config,\n      options: {\n        ...this.config.options,\n        auth: (cb) => {\n          this.authService.getAccessToken().then((token) => cb({ token, type: 'jwt' }));\n        }\n      }\n    });\n  }\n}\n"],"mappings":"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","names":["SOCKET_CONFIG_TOKEN","InjectionToken","PACKET_TYPES","PACKET_TYPES_REVERSE","key","ERROR_PACKET","withNativeBlob","withNativeArrayBuffer","isView","obj","encodePacket","type","data","supportsBinary","callback","encodeBlobAsBase64","PACKET_TYPES","fileReader","content","toArray","TEXT_ENCODER","encodePacketToBinary","packet","encoded","chars","lookup","i","decode","base64","bufferLength","len","i","p","encoded1","encoded2","encoded3","encoded4","arraybuffer","bytes","lookup","withNativeArrayBuffer","decodePacket","encodedPacket","binaryType","mapBinary","type","decodeBase64Packet","PACKET_TYPES_REVERSE","ERROR_PACKET","data","decoded","decode","SEPARATOR","encodePayload","packets","callback","length","encodedPackets","count","packet","i","encodePacket","encodedPacket","decodePayload","encodedPayload","binaryType","decodedPacket","decodePacket","createPacketEncoderStream","controller","encodePacketToBinary","payloadLength","header","view","TEXT_DECODER","totalLength","chunks","acc","chunk","concatChunks","size","buffer","j","createPacketDecoderStream","maxPayload","state","expectedLength","isBinary","headerArray","n","ERROR_PACKET","data","protocol","Emitter","obj","mixin","key","event","fn","on","callbacks","cb","args","i","len","globalThisShim","pick","obj","attr","acc","k","NATIVE_SET_TIMEOUT","globalThisShim","NATIVE_CLEAR_TIMEOUT","installTimerFunctions","opts","BASE64_OVERHEAD","byteLength","utf8Length","str","c","length","i","l","encode","obj","str","i","decode","qs","qry","pairs","l","pair","TransportError","reason","description","context","Transport","Emitter","opts","installTimerFunctions","packets","data","packet","decodePacket","details","onPause","schema","query","hostname","encodedQuery","encode","alphabet","length","map","seed","i","prev","encode","num","encoded","yeast","now","encode","prev","seed","i","length","map","alphabet","value","hasCORS","XHR","opts","xdomain","hasCORS","globalThisShim","empty","hasXHR2","XHR","Polling","Transport","opts","isSSL","port","forceBase64","onPause","pause","total","data","callback","packet","decodePayload","close","packets","encodePayload","schema","query","yeast","Request","fn","req","xhrStatus","context","Emitter","uri","installTimerFunctions","_a","pick","xhr","i","e","err","fromError","unloadHandler","terminationEvent","globalThisShim","nextTick","cb","setTimeoutFn","WebSocket","globalThisShim","usingBrowserWebSocket","defaultBinaryType","isReactNative","WS","Transport","opts","uri","protocols","pick","usingBrowserWebSocket","WebSocket","err","closeEvent","ev","packets","i","packet","lastPacket","encodePacket","data","nextTick","schema","query","yeast","WT","Transport","err","stream","decoderStream","createPacketDecoderStream","reader","encoderStream","createPacketEncoderStream","read","done","value","packet","packets","i","lastPacket","nextTick","_a","transports","WS","WT","Polling","re","parts","parse","str","src","b","e","m","uri","i","pathNames","queryKey","obj","path","regx","names","query","data","$0","$1","$2","Socket","Emitter","uri","opts","defaultBinaryType","parse","installTimerFunctions","decode","name","query","protocol","transports","transport","reason","failed","onTransportOpen","msg","cleanup","err","freezeTransport","onerror","error","onTransportClose","onclose","onupgrade","to","i","l","packet","data","packets","payloadSize","byteLength","options","fn","type","close","cleanupAndClose","waitForUpgrade","description","upgrades","filteredUpgrades","j","protocol","Socket","url","uri","path","loc","obj","parse","host","esm_exports","__export","Decoder","Encoder","PacketType","protocol","withNativeArrayBuffer","isView","obj","toString","withNativeBlob","withNativeFile","isBinary","hasBinary","toJSON","i","l","key","deconstructPacket","packet","buffers","packetData","pack","_deconstructPacket","data","isBinary","placeholder","newData","i","key","reconstructPacket","_reconstructPacket","RESERVED_EVENTS","protocol","PacketType","Encoder","replacer","obj","hasBinary","str","deconstruction","deconstructPacket","pack","buffers","isObject","value","Decoder","_Decoder","Emitter","reviver","packet","isBinaryEvent","BinaryReconstructor","isBinary","i","p","start","buf","next","c","payload","type","binData","reconstructPacket","on","obj","ev","fn","RESERVED_EVENTS","Socket","Emitter","io","nsp","opts","on","args","ev","packet","PacketType","id","ack","isTransportWritable","_a","timeout","timer","i","fn","resolve","reject","arg1","arg2","err","responseArgs","force","data","reason","description","listeners","listener","self","sent","pid","subDestroy","compress","Backoff","opts","ms","rand","deviation","min","max","jitter","Manager","Emitter","uri","opts","_a","installTimerFunctions","Backoff","_parser","esm_exports","v","fn","Socket","socket","self","openSubDestroy","on","onError","err","errorSub","timeout","timer","data","e","packet","nextTick","nsp","nsps","encodedPackets","i","subDestroy","reason","description","delay","attempt","cache","lookup","uri","opts","parsed","url","source","id","path","sameNamespace","newConnection","io","Manager","Socket","SocketIo","constructor","config","subscribersCounter","eventObservables$","connect","featurePath","url","socket","io","options","disconnect","send","event","args","emit","join","resource","ids","leave","unsubscribe","acknowledge","on","cb","payload","ID","off","listener","fromEvent$","Observable","obs","next","message","pipe","share","SocketIoService","constructor","config","authService","createSocket","SocketIo","__spreadProps","__spreadValues","options","auth","cb","getAccessToken","then","token","type","ɵɵinject","SOCKET_CONFIG_TOKEN","AuthService","factory","ɵfac"],"x_google_ignoreList":[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]}