@stacks/blockchain-api-client 7.1.1 → 7.2.0-beta.1

package/lib/index.umd.js

@@ -376,7 +376,7 @@
     }, check);
   }
 
-  var BASE_PATH = "https://stacks-node-api.mainnet.stacks.co".replace(/\/+$/, "");
+  var BASE_PATH = "https://api.mainnet.hiro.so".replace(/\/+$/, "");
 
   var isBlob = function isBlob(value) {
     return typeof Blob !== 'undefined' && value instanceof Blob;
@@ -2674,6 +2674,35 @@
     };
   }
 
+  /* tslint:disable */
+  function InlineResponse403FromJSON(json) {
+    return InlineResponse403FromJSONTyped(json);
+  }
+  function InlineResponse403FromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+      return json;
+    }
+
+    return {
+      'error': !exists(json, 'error') ? undefined : json['error'],
+      'success': !exists(json, 'success') ? undefined : json['success']
+    };
+  }
+  function InlineResponse403ToJSON(value) {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    return {
+      'error': value.error,
+      'success': value.success
+    };
+  }
+
   /* tslint:disable */
   function MapEntryResponseFromJSON(json) {
     return MapEntryResponseFromJSONTyped(json);
@@ -3488,6 +3517,76 @@
     };
   }
 
+  /* tslint:disable */
+  function PoolDelegationFromJSON(json) {
+    return PoolDelegationFromJSONTyped(json);
+  }
+  function PoolDelegationFromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+      return json;
+    }
+
+    return {
+      'stacker': json['stacker'],
+      'pox_addr': !exists(json, 'pox_addr') ? undefined : json['pox_addr'],
+      'amount_ustx': json['amount_ustx'],
+      'burn_block_unlock_height': !exists(json, 'burn_block_unlock_height') ? undefined : json['burn_block_unlock_height'],
+      'block_height': json['block_height'],
+      'tx_id': json['tx_id']
+    };
+  }
+  function PoolDelegationToJSON(value) {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    return {
+      'stacker': value.stacker,
+      'pox_addr': value.pox_addr,
+      'amount_ustx': value.amount_ustx,
+      'burn_block_unlock_height': value.burn_block_unlock_height,
+      'block_height': value.block_height,
+      'tx_id': value.tx_id
+    };
+  }
+
+  /* tslint:disable */
+  function PoolDelegationsResponseFromJSON(json) {
+    return PoolDelegationsResponseFromJSONTyped(json);
+  }
+  function PoolDelegationsResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json === undefined || json === null) {
+      return json;
+    }
+
+    return {
+      'limit': json['limit'],
+      'offset': json['offset'],
+      'total': json['total'],
+      'results': json['results'].map(PoolDelegationFromJSON)
+    };
+  }
+  function PoolDelegationsResponseToJSON(value) {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    return {
+      'limit': value.limit,
+      'offset': value.offset,
+      'total': value.total,
+      'results': value.results.map(PoolDelegationToJSON)
+    };
+  }
+
   /* tslint:disable */
 
   /* eslint-disable */
@@ -7325,7 +7424,7 @@
       }
     }
     /**
-     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet.
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.hiro.so/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet.
      * Get STX testnet tokens
      */
     ;
@@ -7366,7 +7465,7 @@
       }
     }
     /**
-     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.stacks.co/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet.
+     * Add 500 STX tokens to the specified testnet address. Testnet STX addresses begin with `ST`. If the `stacking` parameter is set to `true`, the faucet will add the required number of tokens for individual stacking to the specified testnet address.  The endpoint returns the transaction ID, which you can use to view the transaction in the [Stacks Explorer](https://explorer.hiro.so/?chain=testnet). The tokens are delivered once the transaction has been included in an anchor block.  A common reason for failed faucet transactions is that the faucet has run out of tokens. If you are experiencing failed faucet transactions to a testnet address, you can get help in [Discord](https://stacks.chat).  **Note:** This is a testnet only endpoint. This endpoint will not work on the mainnet.
      * Get STX testnet tokens
      */
     ;
@@ -7550,7 +7649,7 @@
     var _proto = FungibleTokensApi.prototype;
 
     /**
-     * Retrieves the metadata for fungible tokens for a given contract id
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves the metadata for fungible tokens for a given contract id
      * Fungible tokens metadata for contract id
      */
     _proto.getContractFtMetadataRaw = function getContractFtMetadataRaw(requestParameters, initOverrides) {
@@ -7578,7 +7677,7 @@
       }
     }
     /**
-     * Retrieves the metadata for fungible tokens for a given contract id
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves the metadata for fungible tokens for a given contract id
      * Fungible tokens metadata for contract id
      */
     ;
@@ -7595,7 +7694,7 @@
       }
     }
     /**
-     * Retrieves list of fungible tokens with their metadata. More information on Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#fungible-tokens).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves list of fungible tokens with their metadata. More information on Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#fungible-tokens).
      * Fungible tokens metadata list
      */
     ;
@@ -7630,7 +7729,7 @@
       }
     }
     /**
-     * Retrieves list of fungible tokens with their metadata. More information on Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#fungible-tokens).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves list of fungible tokens with their metadata. More information on Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#fungible-tokens).
      * Fungible tokens metadata list
      */
     ;
@@ -8729,7 +8828,7 @@
     var _proto = NonFungibleTokensApi.prototype;
 
     /**
-     * Retrieves metadata for non fungible tokens for a given contract id. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves metadata for non fungible tokens for a given contract id. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * Non fungible tokens metadata for contract ID
      */
     _proto.getContractNftMetadataRaw = function getContractNftMetadataRaw(requestParameters, initOverrides) {
@@ -8757,7 +8856,7 @@
       }
     }
     /**
-     * Retrieves metadata for non fungible tokens for a given contract id. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves metadata for non fungible tokens for a given contract id. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * Non fungible tokens metadata for contract ID
      */
     ;
@@ -8922,7 +9021,7 @@
       }
     }
     /**
-     * Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * Non fungible tokens metadata list
      */
     ;
@@ -8957,7 +9056,7 @@
       }
     }
     /**
-     * Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
+     * **NOTE:** This endpoint is deprecated in favor of the [Token Metadata Service](https://github.com/hirosystems/token-metadata-service).  Retrieves a list of non fungible tokens with their metadata. More information on Non-Fungible Tokens on the Stacks blockchain can be found [here](https://docs.stacks.co/write-smart-contracts/tokens#non-fungible-tokens-nfts).
      * Non fungible tokens metadata list
      */
     ;
@@ -10340,6 +10439,85 @@
     return SmartContractsApi;
   }(BaseAPI);
 
+  /**
+   *
+   */
+
+  var StackingApi = /*#__PURE__*/function (_runtime$BaseAPI) {
+    _inheritsLoose(StackingApi, _runtime$BaseAPI);
+
+    function StackingApi() {
+      return _runtime$BaseAPI.apply(this, arguments) || this;
+    }
+
+    var _proto = StackingApi.prototype;
+
+    /**
+     * Retrieves the list of stacking pool members for a given delegator principal.
+     * Stacking pool members
+     */
+    _proto.getPoolDelegationsRaw = function getPoolDelegationsRaw(requestParameters, initOverrides) {
+      try {
+        var _this2 = this;
+
+        if (requestParameters.poolPrincipal === null || requestParameters.poolPrincipal === undefined) {
+          throw new RequiredError('poolPrincipal', 'Required parameter requestParameters.poolPrincipal was null or undefined when calling getPoolDelegations.');
+        }
+
+        var queryParameters = {};
+
+        if (requestParameters.afterBlock !== undefined) {
+          queryParameters['after_block'] = requestParameters.afterBlock;
+        }
+
+        if (requestParameters.unanchored !== undefined) {
+          queryParameters['unanchored'] = requestParameters.unanchored;
+        }
+
+        if (requestParameters.limit !== undefined) {
+          queryParameters['limit'] = requestParameters.limit;
+        }
+
+        if (requestParameters.offset !== undefined) {
+          queryParameters['offset'] = requestParameters.offset;
+        }
+
+        var headerParameters = {};
+        return Promise.resolve(_this2.request({
+          path: "/extended/beta/stacking/{pool_principal}/delegations".replace("{" + "pool_principal" + "}", encodeURIComponent(String(requestParameters.poolPrincipal))),
+          method: 'GET',
+          headers: headerParameters,
+          query: queryParameters
+        }, initOverrides)).then(function (response) {
+          return new JSONApiResponse(response, function (jsonValue) {
+            return PoolDelegationsResponseFromJSON(jsonValue);
+          });
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    }
+    /**
+     * Retrieves the list of stacking pool members for a given delegator principal.
+     * Stacking pool members
+     */
+    ;
+
+    _proto.getPoolDelegations = function getPoolDelegations(requestParameters, initOverrides) {
+      try {
+        var _this4 = this;
+
+        return Promise.resolve(_this4.getPoolDelegationsRaw(requestParameters, initOverrides)).then(function (response) {
+          return Promise.resolve(response.value());
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+
+    return StackingApi;
+  }(BaseAPI);
+
   /**
    *
    */
@@ -11441,7 +11619,7 @@
       validateMessage(object, true);
       return object;
   }
-  function parse(message) {
+  function parse$1(message) {
       if (!isString(message)) {
           return new JsonRpcParsed(JsonRpcError.invalidRequest(message), "invalid" /* invalid */);
       }
@@ -12043,7 +12221,7 @@
       this.eventEmitter = new eventemitter3.EventEmitter();
       this.webSocket = webSocket;
       webSocket.addEventListener('message', function (event) {
-        var parsed = parse(event.data);
+        var parsed = parse$1(event.data);
         var rpcObjects = Array.isArray(parsed) ? parsed : [parsed];
         rpcObjects.forEach(function (obj) {
           if (obj.type === "notification"
@@ -12410,209 +12588,164 @@
     }
   }
 
-  /**
-   * Parses an URI
-   *
-   * @author Steven Levithan <stevenlevithan.com> (MIT license)
-   * @api private
-   */
-  var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
-
-  var parts = [
-      'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
-  ];
-
-  var parseuri = function parseuri(str) {
-      var src = str,
-          b = str.indexOf('['),
-          e = str.indexOf(']');
+  const PACKET_TYPES = Object.create(null); // no Map = no polyfill
+  PACKET_TYPES["open"] = "0";
+  PACKET_TYPES["close"] = "1";
+  PACKET_TYPES["ping"] = "2";
+  PACKET_TYPES["pong"] = "3";
+  PACKET_TYPES["message"] = "4";
+  PACKET_TYPES["upgrade"] = "5";
+  PACKET_TYPES["noop"] = "6";
+  const PACKET_TYPES_REVERSE = Object.create(null);
+  Object.keys(PACKET_TYPES).forEach(key => {
+      PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
+  });
+  const ERROR_PACKET = { type: "error", data: "parser error" };
 
-      if (b != -1 && e != -1) {
-          str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
+  const withNativeBlob$1 = typeof Blob === "function" ||
+      (typeof Blob !== "undefined" &&
+          Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
+  const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
+  // ArrayBuffer.isView method is not defined in IE10
+  const isView$1 = obj => {
+      return typeof ArrayBuffer.isView === "function"
+          ? ArrayBuffer.isView(obj)
+          : obj && obj.buffer instanceof ArrayBuffer;
+  };
+  const encodePacket = ({ type, data }, supportsBinary, callback) => {
+      if (withNativeBlob$1 && data instanceof Blob) {
+          if (supportsBinary) {
+              return callback(data);
+          }
+          else {
+              return encodeBlobAsBase64(data, callback);
+          }
       }
-
-      var m = re.exec(str || ''),
-          uri = {},
-          i = 14;
-
-      while (i--) {
-          uri[parts[i]] = m[i] || '';
+      else if (withNativeArrayBuffer$2 &&
+          (data instanceof ArrayBuffer || isView$1(data))) {
+          if (supportsBinary) {
+              return callback(data);
+          }
+          else {
+              return encodeBlobAsBase64(new Blob([data]), callback);
+          }
       }
+      // plain string
+      return callback(PACKET_TYPES[type] + (data || ""));
+  };
+  const encodeBlobAsBase64 = (data, callback) => {
+      const fileReader = new FileReader();
+      fileReader.onload = function () {
+          const content = fileReader.result.split(",")[1];
+          callback("b" + (content || ""));
+      };
+      return fileReader.readAsDataURL(data);
+  };
 
-      if (b != -1 && e != -1) {
-          uri.source = src;
-          uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
-          uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
-          uri.ipv6uri = true;
+  // imported from https://github.com/socketio/base64-arraybuffer
+  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  // Use a lookup table to find the index.
+  const lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+  for (let i = 0; i < chars.length; i++) {
+      lookup$1[chars.charCodeAt(i)] = i;
+  }
+  const decode$1 = (base64) => {
+      let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
+      if (base64[base64.length - 1] === '=') {
+          bufferLength--;
+          if (base64[base64.length - 2] === '=') {
+              bufferLength--;
+          }
       }
-
-      uri.pathNames = pathNames(uri, uri['path']);
-      uri.queryKey = queryKey(uri, uri['query']);
-
-      return uri;
+      const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+      for (i = 0; i < len; i += 4) {
+          encoded1 = lookup$1[base64.charCodeAt(i)];
+          encoded2 = lookup$1[base64.charCodeAt(i + 1)];
+          encoded3 = lookup$1[base64.charCodeAt(i + 2)];
+          encoded4 = lookup$1[base64.charCodeAt(i + 3)];
+          bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+          bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+          bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+      }
+      return arraybuffer;
   };
 
-  function pathNames(obj, path) {
-      var regx = /\/{2,9}/g,
-          names = path.replace(regx, "/").split("/");
-
-      if (path.substr(0, 1) == '/' || path.length === 0) {
-          names.splice(0, 1);
+  const withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
+  const decodePacket = (encodedPacket, binaryType) => {
+      if (typeof encodedPacket !== "string") {
+          return {
+              type: "message",
+              data: mapBinary(encodedPacket, binaryType)
+          };
       }
-      if (path.substr(path.length - 1, 1) == '/') {
-          names.splice(names.length - 1, 1);
+      const type = encodedPacket.charAt(0);
+      if (type === "b") {
+          return {
+              type: "message",
+              data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
+          };
       }
-
-      return names;
-  }
-
-  function queryKey(uri, query) {
-      var data = {};
-
-      query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
-          if ($1) {
-              data[$1] = $2;
-          }
-      });
-
-      return data;
-  }
-
-  /**
-   * URL parser.
-   *
-   * @param uri - url
-   * @param path - the request path of the connection
-   * @param loc - An object meant to mimic window.location.
-   *        Defaults to window.location.
-   * @public
-   */
-  function url(uri, path = "", loc) {
-      let obj = uri;
-      // default to window.location
-      loc = loc || (typeof location !== "undefined" && location);
-      if (null == uri)
-          uri = loc.protocol + "//" + loc.host;
-      // relative path support
-      if (typeof uri === "string") {
-          if ("/" === uri.charAt(0)) {
-              if ("/" === uri.charAt(1)) {
-                  uri = loc.protocol + uri;
-              }
-              else {
-                  uri = loc.host + uri;
-              }
-          }
-          if (!/^(https?|wss?):\/\//.test(uri)) {
-              if ("undefined" !== typeof loc) {
-                  uri = loc.protocol + "//" + uri;
-              }
-              else {
-                  uri = "https://" + uri;
-              }
-          }
-          // parse
-          obj = parseuri(uri);
+      const packetType = PACKET_TYPES_REVERSE[type];
+      if (!packetType) {
+          return ERROR_PACKET;
       }
-      // make sure we treat `localhost:80` and `localhost` equally
-      if (!obj.port) {
-          if (/^(http|ws)$/.test(obj.protocol)) {
-              obj.port = "80";
-          }
-          else if (/^(http|ws)s$/.test(obj.protocol)) {
-              obj.port = "443";
+      return encodedPacket.length > 1
+          ? {
+              type: PACKET_TYPES_REVERSE[type],
+              data: encodedPacket.substring(1)
           }
-      }
-      obj.path = obj.path || "/";
-      const ipv6 = obj.host.indexOf(":") !== -1;
-      const host = ipv6 ? "[" + obj.host + "]" : obj.host;
-      // define unique id
-      obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
-      // define href
-      obj.href =
-          obj.protocol +
-              "://" +
-              host +
-              (loc && loc.port === obj.port ? "" : ":" + obj.port);
-      return obj;
-  }
-
-  var hasCors = createCommonjsModule(function (module) {
-  /**
-   * Module exports.
-   *
-   * Logic borrowed from Modernizr:
-   *
-   *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js
-   */
-
-  try {
-    module.exports = typeof XMLHttpRequest !== 'undefined' &&
-      'withCredentials' in new XMLHttpRequest();
-  } catch (err) {
-    // if XMLHttp support is disabled in IE then it will throw
-    // when trying to create
-    module.exports = false;
-  }
-  });
-
-  var globalThis = (() => {
-      if (typeof self !== "undefined") {
-          return self;
-      }
-      else if (typeof window !== "undefined") {
-          return window;
+          : {
+              type: PACKET_TYPES_REVERSE[type]
+          };
+  };
+  const decodeBase64Packet = (data, binaryType) => {
+      if (withNativeArrayBuffer$1) {
+          const decoded = decode$1(data);
+          return mapBinary(decoded, binaryType);
       }
       else {
-          return Function("return this")();
-      }
-  })();
-
-  // browser shim for xmlhttprequest module
-  function XMLHttpRequest$1 (opts) {
-      const xdomain = opts.xdomain;
-      // XMLHttpRequest can be disabled on IE
-      try {
-          if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCors)) {
-              return new XMLHttpRequest();
-          }
+          return { base64: true, data }; // fallback for old browsers
       }
-      catch (e) { }
-      if (!xdomain) {
-          try {
-              return new globalThis[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
-          }
-          catch (e) { }
+  };
+  const mapBinary = (data, binaryType) => {
+      switch (binaryType) {
+          case "blob":
+              return data instanceof ArrayBuffer ? new Blob([data]) : data;
+          case "arraybuffer":
+          default:
+              return data; // assuming the data is already an ArrayBuffer
       }
-  }
+  };
 
-  function pick(obj, ...attr) {
-      return attr.reduce((acc, k) => {
-          if (obj.hasOwnProperty(k)) {
-              acc[k] = obj[k];
+  const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
+  const encodePayload = (packets, callback) => {
+      // some packets may be added to the array while encoding, so the initial length must be saved
+      const length = packets.length;
+      const encodedPackets = new Array(length);
+      let count = 0;
+      packets.forEach((packet, i) => {
+          // force base64 encoding for binary packets
+          encodePacket(packet, false, encodedPacket => {
+              encodedPackets[i] = encodedPacket;
+              if (++count === length) {
+                  callback(encodedPackets.join(SEPARATOR));
+              }
+          });
+      });
+  };
+  const decodePayload = (encodedPayload, binaryType) => {
+      const encodedPackets = encodedPayload.split(SEPARATOR);
+      const packets = [];
+      for (let i = 0; i < encodedPackets.length; i++) {
+          const decodedPacket = decodePacket(encodedPackets[i], binaryType);
+          packets.push(decodedPacket);
+          if (decodedPacket.type === "error") {
+              break;
           }
-          return acc;
-      }, {});
-  }
-  // Keep a reference to the real timeout functions so they can be used when overridden
-  const NATIVE_SET_TIMEOUT = setTimeout;
-  const NATIVE_CLEAR_TIMEOUT = clearTimeout;
-  function installTimerFunctions(obj, opts) {
-      if (opts.useNativeTimers) {
-          obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);
-          obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);
-      }
-      else {
-          obj.setTimeoutFn = setTimeout.bind(globalThis);
-          obj.clearTimeoutFn = clearTimeout.bind(globalThis);
       }
-  }
-
-  /**
-   * Expose `Emitter`.
-   */
-
-  var Emitter_1 = Emitter;
+      return packets;
+  };
+  const protocol$1 = 4;
 
   /**
    * Initialize a new `Emitter`.
@@ -12784,175 +12917,84 @@
     return !! this.listeners(event).length;
   };
 
-  const PACKET_TYPES = Object.create(null); // no Map = no polyfill
-  PACKET_TYPES["open"] = "0";
-  PACKET_TYPES["close"] = "1";
-  PACKET_TYPES["ping"] = "2";
-  PACKET_TYPES["pong"] = "3";
-  PACKET_TYPES["message"] = "4";
-  PACKET_TYPES["upgrade"] = "5";
-  PACKET_TYPES["noop"] = "6";
-  const PACKET_TYPES_REVERSE = Object.create(null);
-  Object.keys(PACKET_TYPES).forEach(key => {
-      PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
-  });
-  const ERROR_PACKET = { type: "error", data: "parser error" };
-
-  const withNativeBlob$1 = typeof Blob === "function" ||
-      (typeof Blob !== "undefined" &&
-          Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
-  const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
-  // ArrayBuffer.isView method is not defined in IE10
-  const isView$1 = obj => {
-      return typeof ArrayBuffer.isView === "function"
-          ? ArrayBuffer.isView(obj)
-          : obj && obj.buffer instanceof ArrayBuffer;
-  };
-  const encodePacket = ({ type, data }, supportsBinary, callback) => {
-      if (withNativeBlob$1 && data instanceof Blob) {
-          if (supportsBinary) {
-              return callback(data);
-          }
-          else {
-              return encodeBlobAsBase64(data, callback);
-          }
-      }
-      else if (withNativeArrayBuffer$2 &&
-          (data instanceof ArrayBuffer || isView$1(data))) {
-          if (supportsBinary) {
-              return callback(data);
-          }
-          else {
-              return encodeBlobAsBase64(new Blob([data]), callback);
-          }
+  const globalThisShim = (() => {
+      if (typeof self !== "undefined") {
+          return self;
       }
-      // plain string
-      return callback(PACKET_TYPES[type] + (data || ""));
-  };
-  const encodeBlobAsBase64 = (data, callback) => {
-      const fileReader = new FileReader();
-      fileReader.onload = function () {
-          const content = fileReader.result.split(",")[1];
-          callback("b" + content);
-      };
-      return fileReader.readAsDataURL(data);
-  };
-
-  /*
-   * base64-arraybuffer 1.0.1 <https://github.com/niklasvh/base64-arraybuffer>
-   * Copyright (c) 2021 Niklas von Hertzen <https://hertzen.com>
-   * Released under MIT License
-   */
-  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-  // Use a lookup table to find the index.
-  var lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
-  for (var i$1 = 0; i$1 < chars.length; i$1++) {
-      lookup$1[chars.charCodeAt(i$1)] = i$1;
-  }
-  var decode$2 = function (base64) {
-      var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
-      if (base64[base64.length - 1] === '=') {
-          bufferLength--;
-          if (base64[base64.length - 2] === '=') {
-              bufferLength--;
-          }
+      else if (typeof window !== "undefined") {
+          return window;
       }
-      var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
-      for (i = 0; i < len; i += 4) {
-          encoded1 = lookup$1[base64.charCodeAt(i)];
-          encoded2 = lookup$1[base64.charCodeAt(i + 1)];
-          encoded3 = lookup$1[base64.charCodeAt(i + 2)];
-          encoded4 = lookup$1[base64.charCodeAt(i + 3)];
-          bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
-          bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
-          bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+      else {
+          return Function("return this")();
       }
-      return arraybuffer;
-  };
+  })();
 
-  const withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
-  const decodePacket = (encodedPacket, binaryType) => {
-      if (typeof encodedPacket !== "string") {
-          return {
-              type: "message",
-              data: mapBinary(encodedPacket, binaryType)
-          };
-      }
-      const type = encodedPacket.charAt(0);
-      if (type === "b") {
-          return {
-              type: "message",
-              data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
-          };
-      }
-      const packetType = PACKET_TYPES_REVERSE[type];
-      if (!packetType) {
-          return ERROR_PACKET;
-      }
-      return encodedPacket.length > 1
-          ? {
-              type: PACKET_TYPES_REVERSE[type],
-              data: encodedPacket.substring(1)
+  function pick(obj, ...attr) {
+      return attr.reduce((acc, k) => {
+          if (obj.hasOwnProperty(k)) {
+              acc[k] = obj[k];
           }
-          : {
-              type: PACKET_TYPES_REVERSE[type]
-          };
-  };
-  const decodeBase64Packet = (data, binaryType) => {
-      if (withNativeArrayBuffer$1) {
-          const decoded = decode$2(data);
-          return mapBinary(decoded, binaryType);
+          return acc;
+      }, {});
+  }
+  // Keep a reference to the real timeout functions so they can be used when overridden
+  const NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
+  const NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
+  function installTimerFunctions(obj, opts) {
+      if (opts.useNativeTimers) {
+          obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
+          obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
       }
       else {
-          return { base64: true, data }; // fallback for old browsers
-      }
-  };
-  const mapBinary = (data, binaryType) => {
-      switch (binaryType) {
-          case "blob":
-              return data instanceof ArrayBuffer ? new Blob([data]) : data;
-          case "arraybuffer":
-          default:
-              return data; // assuming the data is already an ArrayBuffer
-      }
-  };
-
-  const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
-  const encodePayload = (packets, callback) => {
-      // some packets may be added to the array while encoding, so the initial length must be saved
-      const length = packets.length;
-      const encodedPackets = new Array(length);
-      let count = 0;
-      packets.forEach((packet, i) => {
-          // force base64 encoding for binary packets
-          encodePacket(packet, false, encodedPacket => {
-              encodedPackets[i] = encodedPacket;
-              if (++count === length) {
-                  callback(encodedPackets.join(SEPARATOR));
-              }
-          });
-      });
-  };
-  const decodePayload = (encodedPayload, binaryType) => {
-      const encodedPackets = encodedPayload.split(SEPARATOR);
-      const packets = [];
-      for (let i = 0; i < encodedPackets.length; i++) {
-          const decodedPacket = decodePacket(encodedPackets[i], binaryType);
-          packets.push(decodedPacket);
-          if (decodedPacket.type === "error") {
-              break;
+          obj.setTimeoutFn = globalThisShim.setTimeout.bind(globalThisShim);
+          obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
+      }
+  }
+  // base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
+  const BASE64_OVERHEAD = 1.33;
+  // we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
+  function byteLength(obj) {
+      if (typeof obj === "string") {
+          return utf8Length(obj);
+      }
+      // arraybuffer or blob
+      return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
+  }
+  function utf8Length(str) {
+      let c = 0, length = 0;
+      for (let i = 0, l = str.length; i < l; i++) {
+          c = str.charCodeAt(i);
+          if (c < 0x80) {
+              length += 1;
+          }
+          else if (c < 0x800) {
+              length += 2;
+          }
+          else if (c < 0xd800 || c >= 0xe000) {
+              length += 3;
+          }
+          else {
+              i++;
+              length += 4;
           }
       }
-      return packets;
-  };
-  const protocol$1 = 4;
+      return length;
+  }
 
-  class Transport extends Emitter_1 {
+  class TransportError extends Error {
+      constructor(reason, description, context) {
+          super(reason);
+          this.description = description;
+          this.context = context;
+          this.type = "TransportError";
+      }
+  }
+  class Transport extends Emitter {
       /**
        * Transport abstract constructor.
        *
-       * @param {Object} options.
-       * @api private
+       * @param {Object} opts - options
+       * @protected
        */
       constructor(opts) {
           super();
@@ -12960,44 +13002,34 @@
           installTimerFunctions(this, opts);
           this.opts = opts;
           this.query = opts.query;
-          this.readyState = "";
           this.socket = opts.socket;
       }
       /**
        * Emits an error.
        *
-       * @param {String} str
+       * @param {String} reason
+       * @param description
+       * @param context - the error context
        * @return {Transport} for chaining
-       * @api protected
+       * @protected
        */
-      onError(msg, desc) {
-          const err = new Error(msg);
-          // @ts-ignore
-          err.type = "TransportError";
-          // @ts-ignore
-          err.description = desc;
-          super.emit("error", err);
+      onError(reason, description, context) {
+          super.emitReserved("error", new TransportError(reason, description, context));
           return this;
       }
       /**
        * Opens the transport.
-       *
-       * @api public
        */
       open() {
-          if ("closed" === this.readyState || "" === this.readyState) {
-              this.readyState = "opening";
-              this.doOpen();
-          }
+          this.readyState = "opening";
+          this.doOpen();
           return this;
       }
       /**
        * Closes the transport.
-       *
-       * @api public
        */
       close() {
-          if ("opening" === this.readyState || "open" === this.readyState) {
+          if (this.readyState === "opening" || this.readyState === "open") {
               this.doClose();
               this.onClose();
           }
@@ -13007,28 +13039,27 @@
        * Sends multiple packets.
        *
        * @param {Array} packets
-       * @api public
        */
       send(packets) {
-          if ("open" === this.readyState) {
+          if (this.readyState === "open") {
               this.write(packets);
           }
       }
       /**
        * Called upon open
        *
-       * @api protected
+       * @protected
        */
       onOpen() {
           this.readyState = "open";
           this.writable = true;
-          super.emit("open");
+          super.emitReserved("open");
       }
       /**
        * Called with data.
        *
        * @param {String} data
-       * @api protected
+       * @protected
        */
       onData(data) {
           const packet = decodePacket(data, this.socket.binaryType);
@@ -13037,64 +13068,46 @@
       /**
        * Called with a decoded packet.
        *
-       * @api protected
+       * @protected
        */
       onPacket(packet) {
-          super.emit("packet", packet);
+          super.emitReserved("packet", packet);
       }
       /**
        * Called upon close.
        *
-       * @api protected
+       * @protected
        */
-      onClose() {
+      onClose(details) {
           this.readyState = "closed";
-          super.emit("close");
+          super.emitReserved("close", details);
       }
+      /**
+       * Pauses the transport, in order not to lose packets during an upgrade.
+       *
+       * @param onPause
+       */
+      pause(onPause) { }
   }
 
-  var alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')
-    , length = 64
-    , map = {}
-    , seed = 0
-    , i = 0
-    , prev;
-
+  // imported from https://github.com/unshiftio/yeast
+  const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split(''), length = 64, map = {};
+  let seed = 0, i = 0, prev;
   /**
    * Return a string representing the specified number.
    *
    * @param {Number} num The number to convert.
    * @returns {String} The string representation of the number.
-   * @api public
-   */
-  function encode$1(num) {
-    var encoded = '';
-
-    do {
-      encoded = alphabet[num % length] + encoded;
-      num = Math.floor(num / length);
-    } while (num > 0);
-
-    return encoded;
-  }
-
-  /**
-   * Return the integer value specified by the given string.
-   *
-   * @param {String} str The string to convert.
-   * @returns {Number} The integer value represented by the string.
-   * @api public
-   */
-  function decode$1(str) {
-    var decoded = 0;
-
-    for (i = 0; i < str.length; i++) {
-      decoded = decoded * length + map[str.charAt(i)];
-    }
-
-    return decoded;
+   * @api public
+   */
+  function encode$1(num) {
+      let encoded = '';
+      do {
+          encoded = alphabet[num % length] + encoded;
+          num = Math.floor(num / length);
+      } while (num > 0);
+      return encoded;
   }
-
   /**
    * Yeast: A tiny growing id generator.
    *
@@ -13102,24 +13115,18 @@
    * @api public
    */
   function yeast() {
-    var now = encode$1(+new Date());
-
-    if (now !== prev) return seed = 0, prev = now;
-    return now +'.'+ encode$1(seed++);
+      const now = encode$1(+new Date());
+      if (now !== prev)
+          return seed = 0, prev = now;
+      return now + '.' + encode$1(seed++);
   }
-
   //
   // Map each character to its index.
   //
-  for (; i < length; i++) map[alphabet[i]] = i;
-
-  //
-  // Expose the `yeast`, `encode` and `decode` functions.
-  //
-  yeast.encode = encode$1;
-  yeast.decode = decode$1;
-  var yeast_1 = yeast;
+  for (; i < length; i++)
+      map[alphabet[i]] = i;
 
+  // imported from https://github.com/galkn/querystring
   /**
    * Compiles a querystring
    * Returns string representation of the object
@@ -13127,49 +13134,99 @@
    * @param {Object}
    * @api private
    */
-  var encode = function (obj) {
-    var str = '';
-
-    for (var i in obj) {
-      if (obj.hasOwnProperty(i)) {
-        if (str.length) str += '&';
-        str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
+  function encode(obj) {
+      let str = '';
+      for (let i in obj) {
+          if (obj.hasOwnProperty(i)) {
+              if (str.length)
+                  str += '&';
+              str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
+          }
       }
-    }
-
-    return str;
-  };
-
+      return str;
+  }
   /**
    * Parses a simple querystring into an object
    *
    * @param {String} qs
    * @api private
    */
+  function decode(qs) {
+      let qry = {};
+      let pairs = qs.split('&');
+      for (let i = 0, l = pairs.length; i < l; i++) {
+          let pair = pairs[i].split('=');
+          qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+      }
+      return qry;
+  }
 
-  var decode = function(qs){
-    var qry = {};
-    var pairs = qs.split('&');
-    for (var i = 0, l = pairs.length; i < l; i++) {
-      var pair = pairs[i].split('=');
-      qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
-    }
-    return qry;
-  };
+  // imported from https://github.com/component/has-cors
+  let value = false;
+  try {
+      value = typeof XMLHttpRequest !== 'undefined' &&
+          'withCredentials' in new XMLHttpRequest();
+  }
+  catch (err) {
+      // if XMLHttp support is disabled in IE then it will throw
+      // when trying to create
+  }
+  const hasCORS = value;
 
-  var parseqs = {
-  	encode: encode,
-  	decode: decode
-  };
+  // browser shim for xmlhttprequest module
+  function XHR(opts) {
+      const xdomain = opts.xdomain;
+      // XMLHttpRequest can be disabled on IE
+      try {
+          if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {
+              return new XMLHttpRequest();
+          }
+      }
+      catch (e) { }
+      if (!xdomain) {
+          try {
+              return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+          }
+          catch (e) { }
+      }
+  }
 
+  function empty() { }
+  const hasXHR2 = (function () {
+      const xhr = new XHR({
+          xdomain: false,
+      });
+      return null != xhr.responseType;
+  })();
   class Polling extends Transport {
-      constructor() {
-          super(...arguments);
-          this.polling = false;
-      }
       /**
-       * Transport name.
+       * XHR Polling constructor.
+       *
+       * @param {Object} opts
+       * @package
        */
+      constructor(opts) {
+          super(opts);
+          this.polling = false;
+          if (typeof location !== "undefined") {
+              const isSSL = "https:" === location.protocol;
+              let port = location.port;
+              // some user agents have empty `location.port`
+              if (!port) {
+                  port = isSSL ? "443" : "80";
+              }
+              this.xd =
+                  (typeof location !== "undefined" &&
+                      opts.hostname !== location.hostname) ||
+                      port !== opts.port;
+              this.xs = opts.secure !== isSSL;
+          }
+          /**
+           * XHR supports binary
+           */
+          const forceBase64 = opts && opts.forceBase64;
+          this.supportsBinary = hasXHR2 && !forceBase64;
+      }
       get name() {
           return "polling";
       }
@@ -13177,7 +13234,7 @@
        * Opens the socket (triggers polling). We write a PING message to determine
        * when the transport is open.
        *
-       * @api private
+       * @protected
        */
       doOpen() {
           this.poll();
@@ -13185,8 +13242,8 @@
       /**
        * Pauses polling.
        *
-       * @param {Function} callback upon buffers are flushed and transport is paused
-       * @api private
+       * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+       * @package
        */
       pause(onPause) {
           this.readyState = "pausing";
@@ -13216,27 +13273,27 @@
       /**
        * Starts polling cycle.
        *
-       * @api public
+       * @private
        */
       poll() {
           this.polling = true;
           this.doPoll();
-          this.emit("poll");
+          this.emitReserved("poll");
       }
       /**
        * Overloads onData to detect payloads.
        *
-       * @api private
+       * @protected
        */
       onData(data) {
-          const callback = packet => {
+          const callback = (packet) => {
               // if its the first message we consider the transport open
               if ("opening" === this.readyState && packet.type === "open") {
                   this.onOpen();
               }
               // if its a close packet, we close the ongoing requests
               if ("close" === packet.type) {
-                  this.onClose();
+                  this.onClose({ description: "transport closed by the server" });
                   return false;
               }
               // otherwise bypass onData and handle the message
@@ -13248,7 +13305,7 @@
           if ("closed" !== this.readyState) {
               // if we got data we're not polling
               this.polling = false;
-              this.emit("pollComplete");
+              this.emitReserved("pollComplete");
               if ("open" === this.readyState) {
                   this.poll();
               }
@@ -13257,7 +13314,7 @@
       /**
        * For polling, send a close packet.
        *
-       * @api private
+       * @protected
        */
       doClose() {
           const close = () => {
@@ -13275,23 +13332,22 @@
       /**
        * Writes a packets payload.
        *
-       * @param {Array} data packets
-       * @param {Function} drain callback
-       * @api private
+       * @param {Array} packets - data packets
+       * @protected
        */
       write(packets) {
           this.writable = false;
-          encodePayload(packets, data => {
+          encodePayload(packets, (data) => {
               this.doWrite(data, () => {
                   this.writable = true;
-                  this.emit("drain");
+                  this.emitReserved("drain");
               });
           });
       }
       /**
        * Generates uri for connection.
        *
-       * @api private
+       * @private
        */
       uri() {
           let query = this.query || {};
@@ -13299,7 +13355,7 @@
           let port = "";
           // cache busting is forced
           if (false !== this.opts.timestampRequests) {
-              query[this.opts.timestampParam] = yeast_1();
+              query[this.opts.timestampParam] = yeast();
           }
           if (!this.supportsBinary && !query.sid) {
               query.b64 = 1;
@@ -13310,7 +13366,7 @@
                   ("http" === schema && Number(this.opts.port) !== 80))) {
               port = ":" + this.opts.port;
           }
-          const encodedQuery = parseqs.encode(query);
+          const encodedQuery = encode(query);
           const ipv6 = this.opts.hostname.indexOf(":") !== -1;
           return (schema +
               "://" +
@@ -13319,52 +13375,11 @@
               this.opts.path +
               (encodedQuery.length ? "?" + encodedQuery : ""));
       }
-  }
-
-  /* global attachEvent */
-  /**
-   * Empty function
-   */
-  function empty() { }
-  const hasXHR2 = (function () {
-      const xhr = new XMLHttpRequest$1({
-          xdomain: false
-      });
-      return null != xhr.responseType;
-  })();
-  class XHR extends Polling {
-      /**
-       * XHR Polling constructor.
-       *
-       * @param {Object} opts
-       * @api public
-       */
-      constructor(opts) {
-          super(opts);
-          if (typeof location !== "undefined") {
-              const isSSL = "https:" === location.protocol;
-              let port = location.port;
-              // some user agents have empty `location.port`
-              if (!port) {
-                  port = isSSL ? "443" : "80";
-              }
-              this.xd =
-                  (typeof location !== "undefined" &&
-                      opts.hostname !== location.hostname) ||
-                      port !== opts.port;
-              this.xs = opts.secure !== isSSL;
-          }
-          /**
-           * XHR supports binary
-           */
-          const forceBase64 = opts && opts.forceBase64;
-          this.supportsBinary = hasXHR2 && !forceBase64;
-      }
       /**
        * Creates a request.
        *
        * @param {String} method
-       * @api private
+       * @private
        */
       request(opts = {}) {
           Object.assign(opts, { xd: this.xd, xs: this.xs }, this.opts);
@@ -13375,38 +13390,38 @@
        *
        * @param {String} data to send.
        * @param {Function} called upon flush.
-       * @api private
+       * @private
        */
       doWrite(data, fn) {
           const req = this.request({
               method: "POST",
-              data: data
+              data: data,
           });
           req.on("success", fn);
-          req.on("error", err => {
-              this.onError("xhr post error", err);
+          req.on("error", (xhrStatus, context) => {
+              this.onError("xhr post error", xhrStatus, context);
           });
       }
       /**
        * Starts a poll cycle.
        *
-       * @api private
+       * @private
        */
       doPoll() {
           const req = this.request();
           req.on("data", this.onData.bind(this));
-          req.on("error", err => {
-              this.onError("xhr poll error", err);
+          req.on("error", (xhrStatus, context) => {
+              this.onError("xhr poll error", xhrStatus, context);
           });
           this.pollXhr = req;
       }
   }
-  class Request extends Emitter_1 {
+  class Request extends Emitter {
       /**
        * Request constructor
        *
        * @param {Object} options
-       * @api public
+       * @package
        */
       constructor(uri, opts) {
           super();
@@ -13421,13 +13436,13 @@
       /**
        * Creates the XHR object and sends the request.
        *
-       * @api private
+       * @private
        */
       create() {
           const opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
           opts.xdomain = !!this.opts.xd;
           opts.xscheme = !!this.opts.xs;
-          const xhr = (this.xhr = new XMLHttpRequest$1(opts));
+          const xhr = (this.xhr = new XHR(opts));
           try {
               xhr.open(this.method, this.uri, this.async);
               try {
@@ -13488,37 +13503,19 @@
               Request.requests[this.index] = this;
           }
       }
-      /**
-       * Called upon successful response.
-       *
-       * @api private
-       */
-      onSuccess() {
-          this.emit("success");
-          this.cleanup();
-      }
-      /**
-       * Called if we have data.
-       *
-       * @api private
-       */
-      onData(data) {
-          this.emit("data", data);
-          this.onSuccess();
-      }
       /**
        * Called upon error.
        *
-       * @api private
+       * @private
        */
       onError(err) {
-          this.emit("error", err);
+          this.emitReserved("error", err, this.xhr);
           this.cleanup(true);
       }
       /**
        * Cleans up house.
        *
-       * @api private
+       * @private
        */
       cleanup(fromError) {
           if ("undefined" === typeof this.xhr || null === this.xhr) {
@@ -13539,18 +13536,20 @@
       /**
        * Called upon load.
        *
-       * @api private
+       * @private
        */
       onLoad() {
           const data = this.xhr.responseText;
           if (data !== null) {
-              this.onData(data);
+              this.emitReserved("data", data);
+              this.emitReserved("success");
+              this.cleanup();
           }
       }
       /**
        * Aborts the request.
        *
-       * @api public
+       * @package
        */
       abort() {
           this.cleanup();
@@ -13570,7 +13569,7 @@
           attachEvent("onunload", unloadHandler);
       }
       else if (typeof addEventListener === "function") {
-          const terminationEvent = "onpagehide" in globalThis ? "pagehide" : "unload";
+          const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
           addEventListener(terminationEvent, unloadHandler, false);
       }
   }
@@ -13585,13 +13584,13 @@
   const nextTick = (() => {
       const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
       if (isPromiseAvailable) {
-          return cb => Promise.resolve().then(cb);
+          return (cb) => Promise.resolve().then(cb);
       }
       else {
           return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
       }
   })();
-  const WebSocket$1 = globalThis.WebSocket || globalThis.MozWebSocket;
+  const WebSocket$1 = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
   const usingBrowserWebSocket = true;
   const defaultBinaryType = "arraybuffer";
 
@@ -13603,26 +13602,16 @@
       /**
        * WebSocket transport constructor.
        *
-       * @api {Object} connection options
-       * @api public
+       * @param {Object} opts - connection options
+       * @protected
        */
       constructor(opts) {
           super(opts);
           this.supportsBinary = !opts.forceBase64;
       }
-      /**
-       * Transport name.
-       *
-       * @api public
-       */
       get name() {
           return "websocket";
       }
-      /**
-       * Opens socket.
-       *
-       * @api private
-       */
       doOpen() {
           if (!this.check()) {
               // let probe timeout
@@ -13646,7 +13635,7 @@
                       : new WebSocket$1(uri, protocols, opts);
           }
           catch (err) {
-              return this.emit("error", err);
+              return this.emitReserved("error", err);
           }
           this.ws.binaryType = this.socket.binaryType || defaultBinaryType;
           this.addEventListeners();
@@ -13654,7 +13643,7 @@
       /**
        * Adds event listeners to the socket
        *
-       * @api private
+       * @private
        */
       addEventListeners() {
           this.ws.onopen = () => {
@@ -13663,16 +13652,13 @@
               }
               this.onOpen();
           };
-          this.ws.onclose = this.onClose.bind(this);
-          this.ws.onmessage = ev => this.onData(ev.data);
-          this.ws.onerror = e => this.onError("websocket error", e);
+          this.ws.onclose = (closeEvent) => this.onClose({
+              description: "websocket connection closed",
+              context: closeEvent,
+          });
+          this.ws.onmessage = (ev) => this.onData(ev.data);
+          this.ws.onerror = (e) => this.onError("websocket error", e);
       }
-      /**
-       * Writes data to socket.
-       *
-       * @param {Array} array of packets.
-       * @api private
-       */
       write(packets) {
           this.writable = false;
           // encodePacket efficient as it uses WS framing
@@ -13680,7 +13666,7 @@
           for (let i = 0; i < packets.length; i++) {
               const packet = packets[i];
               const lastPacket = i === packets.length - 1;
-              encodePacket(packet, this.supportsBinary, data => {
+              encodePacket(packet, this.supportsBinary, (data) => {
                   // always create a new object (GH-437)
                   const opts = {};
                   // Sometimes the websocket has already been closed but the browser didn't
@@ -13699,17 +13685,12 @@
                       // defer to next tick to allow Socket to clear writeBuffer
                       nextTick(() => {
                           this.writable = true;
-                          this.emit("drain");
+                          this.emitReserved("drain");
                       }, this.setTimeoutFn);
                   }
               });
           }
       }
-      /**
-       * Closes socket.
-       *
-       * @api private
-       */
       doClose() {
           if (typeof this.ws !== "undefined") {
               this.ws.close();
@@ -13719,7 +13700,7 @@
       /**
        * Generates uri for connection.
        *
-       * @api private
+       * @private
        */
       uri() {
           let query = this.query || {};
@@ -13733,13 +13714,13 @@
           }
           // append timestamp to URI
           if (this.opts.timestampRequests) {
-              query[this.opts.timestampParam] = yeast_1();
+              query[this.opts.timestampParam] = yeast();
           }
           // communicate binary support capabilities
           if (!this.supportsBinary) {
               query.b64 = 1;
           }
-          const encodedQuery = parseqs.encode(query);
+          const encodedQuery = encode(query);
           const ipv6 = this.opts.hostname.indexOf(":") !== -1;
           return (schema +
               "://" +
@@ -13752,35 +13733,96 @@
        * Feature detection for WebSocket.
        *
        * @return {Boolean} whether this transport is available.
-       * @api public
+       * @private
        */
       check() {
-          return (!!WebSocket$1 &&
-              !("__initialize" in WebSocket$1 && this.name === WS.prototype.name));
+          return !!WebSocket$1;
       }
   }
 
   const transports = {
       websocket: WS,
-      polling: XHR
+      polling: Polling,
   };
 
-  class Socket$1 extends Emitter_1 {
+  // imported from https://github.com/galkn/parseuri
+  /**
+   * Parses a URI
+   *
+   * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
+   *
+   * See:
+   * - https://developer.mozilla.org/en-US/docs/Web/API/URL
+   * - https://caniuse.com/url
+   * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+   *
+   * History of the parse() method:
+   * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
+   * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
+   * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
+   *
+   * @author Steven Levithan <stevenlevithan.com> (MIT license)
+   * @api private
+   */
+  const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+  const parts = [
+      'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
+  ];
+  function parse(str) {
+      const src = str, b = str.indexOf('['), e = str.indexOf(']');
+      if (b != -1 && e != -1) {
+          str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
+      }
+      let m = re.exec(str || ''), uri = {}, i = 14;
+      while (i--) {
+          uri[parts[i]] = m[i] || '';
+      }
+      if (b != -1 && e != -1) {
+          uri.source = src;
+          uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
+          uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
+          uri.ipv6uri = true;
+      }
+      uri.pathNames = pathNames(uri, uri['path']);
+      uri.queryKey = queryKey(uri, uri['query']);
+      return uri;
+  }
+  function pathNames(obj, path) {
+      const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
+      if (path.slice(0, 1) == '/' || path.length === 0) {
+          names.splice(0, 1);
+      }
+      if (path.slice(-1) == '/') {
+          names.splice(names.length - 1, 1);
+      }
+      return names;
+  }
+  function queryKey(uri, query) {
+      const data = {};
+      query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
+          if ($1) {
+              data[$1] = $2;
+          }
+      });
+      return data;
+  }
+
+  class Socket$1 extends Emitter {
       /**
        * Socket constructor.
        *
-       * @param {String|Object} uri or options
+       * @param {String|Object} uri - uri or options
        * @param {Object} opts - options
-       * @api public
        */
       constructor(uri, opts = {}) {
           super();
+          this.writeBuffer = [];
           if (uri && "object" === typeof uri) {
               opts = uri;
               uri = null;
           }
           if (uri) {
-              uri = parseuri(uri);
+              uri = parse(uri);
               opts.hostname = uri.host;
               opts.secure = uri.protocol === "https" || uri.protocol === "wss";
               opts.port = uri.port;
@@ -13788,7 +13830,7 @@
                   opts.query = uri.query;
           }
           else if (opts.host) {
-              opts.hostname = parseuri(opts.host).host;
+              opts.hostname = parse(opts.host).host;
           }
           installTimerFunctions(this, opts);
           this.secure =
@@ -13810,7 +13852,6 @@
                           ? "443"
                           : "80");
           this.transports = opts.transports || ["polling", "websocket"];
-          this.readyState = "";
           this.writeBuffer = [];
           this.prevBufferLen = 0;
           this.opts = Object.assign({
@@ -13820,16 +13861,19 @@
               upgrade: true,
               timestampParam: "t",
               rememberUpgrade: false,
+              addTrailingSlash: true,
               rejectUnauthorized: true,
               perMessageDeflate: {
-                  threshold: 1024
+                  threshold: 1024,
               },
               transportOptions: {},
-              closeOnBeforeunload: true
+              closeOnBeforeunload: true,
           }, opts);
-          this.opts.path = this.opts.path.replace(/\/$/, "") + "/";
+          this.opts.path =
+              this.opts.path.replace(/\/$/, "") +
+                  (this.opts.addTrailingSlash ? "/" : "");
           if (typeof this.opts.query === "string") {
-              this.opts.query = parseqs.decode(this.opts.query);
+              this.opts.query = decode(this.opts.query);
           }
           // set on handshake
           this.id = null;
@@ -13843,17 +13887,20 @@
                   // Firefox closes the connection when the "beforeunload" event is emitted but not Chrome. This event listener
                   // ensures every browser behaves the same (no "disconnect" event at the Socket.IO level when the page is
                   // closed/reloaded)
-                  addEventListener("beforeunload", () => {
+                  this.beforeunloadEventListener = () => {
                       if (this.transport) {
                           // silently close the transport
                           this.transport.removeAllListeners();
                           this.transport.close();
                       }
-                  }, false);
+                  };
+                  addEventListener("beforeunload", this.beforeunloadEventListener, false);
               }
               if (this.hostname !== "localhost") {
                   this.offlineEventListener = () => {
-                      this.onClose("transport close");
+                      this.onClose("transport close", {
+                          description: "network connection lost",
+                      });
                   };
                   addEventListener("offline", this.offlineEventListener, false);
               }
@@ -13863,12 +13910,12 @@
       /**
        * Creates transport of the given type.
        *
-       * @param {String} transport name
+       * @param {String} name - transport name
        * @return {Transport}
-       * @api private
+       * @private
        */
       createTransport(name) {
-          const query = clone(this.opts.query);
+          const query = Object.assign({}, this.opts.query);
           // append engine.io protocol identifier
           query.EIO = protocol$1;
           // transport name
@@ -13881,14 +13928,14 @@
               socket: this,
               hostname: this.hostname,
               secure: this.secure,
-              port: this.port
+              port: this.port,
           });
           return new transports[name](opts);
       }
       /**
        * Initializes transport to use and starts probe.
        *
-       * @api private
+       * @private
        */
       open() {
           let transport;
@@ -13923,7 +13970,7 @@
       /**
        * Sets the current transport. Disables the existing one (if any).
        *
-       * @api private
+       * @private
        */
       setTransport(transport) {
           if (this.transport) {
@@ -13936,15 +13983,13 @@
               .on("drain", this.onDrain.bind(this))
               .on("packet", this.onPacket.bind(this))
               .on("error", this.onError.bind(this))
-              .on("close", () => {
-              this.onClose("transport close");
-          });
+              .on("close", (reason) => this.onClose("transport close", reason));
       }
       /**
        * Probes a transport.
        *
-       * @param {String} transport name
-       * @api private
+       * @param {String} name - transport name
+       * @private
        */
       probe(name) {
           let transport = this.createTransport(name);
@@ -13954,7 +13999,7 @@
               if (failed)
                   return;
               transport.send([{ type: "ping", data: "probe" }]);
-              transport.once("packet", msg => {
+              transport.once("packet", (msg) => {
                   if (failed)
                       return;
                   if ("pong" === msg.type && "probe" === msg.data) {
@@ -13995,7 +14040,7 @@
               transport = null;
           }
           // Handle any error that happens while probing
-          const onerror = err => {
+          const onerror = (err) => {
               const error = new Error("probe error: " + err);
               // @ts-ignore
               error.transport = transport.name;
@@ -14033,7 +14078,7 @@
       /**
        * Called when connection is deemed open.
        *
-       * @api private
+       * @private
        */
       onOpen() {
           this.readyState = "open";
@@ -14042,9 +14087,7 @@
           this.flush();
           // we check for `readyState` in case an `open`
           // listener already closed the socket
-          if ("open" === this.readyState &&
-              this.opts.upgrade &&
-              this.transport.pause) {
+          if ("open" === this.readyState && this.opts.upgrade) {
               let i = 0;
               const l = this.upgrades.length;
               for (; i < l; i++) {
@@ -14055,7 +14098,7 @@
       /**
        * Handles a packet.
        *
-       * @api private
+       * @private
        */
       onPacket(packet) {
           if ("opening" === this.readyState ||
@@ -14091,7 +14134,7 @@
        * Called upon handshake completion.
        *
        * @param {Object} data - handshake obj
-       * @api private
+       * @private
        */
       onHandshake(data) {
           this.emitReserved("handshake", data);
@@ -14100,6 +14143,7 @@
           this.upgrades = this.filterUpgrades(data.upgrades);
           this.pingInterval = data.pingInterval;
           this.pingTimeout = data.pingTimeout;
+          this.maxPayload = data.maxPayload;
           this.onOpen();
           // In case open handler closes socket
           if ("closed" === this.readyState)
@@ -14109,7 +14153,7 @@
       /**
        * Sets and resets ping timeout timer based on server pings.
        *
-       * @api private
+       * @private
        */
       resetPingTimeout() {
           this.clearTimeoutFn(this.pingTimeoutTimer);
@@ -14123,7 +14167,7 @@
       /**
        * Called on `drain` event
        *
-       * @api private
+       * @private
        */
       onDrain() {
           this.writeBuffer.splice(0, this.prevBufferLen);
@@ -14141,28 +14185,54 @@
       /**
        * Flush write buffers.
        *
-       * @api private
+       * @private
        */
       flush() {
           if ("closed" !== this.readyState &&
               this.transport.writable &&
               !this.upgrading &&
               this.writeBuffer.length) {
-              this.transport.send(this.writeBuffer);
+              const packets = this.getWritablePackets();
+              this.transport.send(packets);
               // keep track of current length of writeBuffer
               // splice writeBuffer and callbackBuffer on `drain`
-              this.prevBufferLen = this.writeBuffer.length;
+              this.prevBufferLen = packets.length;
               this.emitReserved("flush");
           }
       }
+      /**
+       * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+       * long-polling)
+       *
+       * @private
+       */
+      getWritablePackets() {
+          const shouldCheckPayloadSize = this.maxPayload &&
+              this.transport.name === "polling" &&
+              this.writeBuffer.length > 1;
+          if (!shouldCheckPayloadSize) {
+              return this.writeBuffer;
+          }
+          let payloadSize = 1; // first packet type
+          for (let i = 0; i < this.writeBuffer.length; i++) {
+              const data = this.writeBuffer[i].data;
+              if (data) {
+                  payloadSize += byteLength(data);
+              }
+              if (i > 0 && payloadSize > this.maxPayload) {
+                  return this.writeBuffer.slice(0, i);
+              }
+              payloadSize += 2; // separator + packet type
+          }
+          return this.writeBuffer;
+      }
       /**
        * Sends a message.
        *
-       * @param {String} message.
-       * @param {Function} callback function.
+       * @param {String} msg - message.
        * @param {Object} options.
+       * @param {Function} callback function.
        * @return {Socket} for chaining.
-       * @api public
        */
       write(msg, options, fn) {
           this.sendPacket("message", msg, options, fn);
@@ -14175,11 +14245,11 @@
       /**
        * Sends a packet.
        *
-       * @param {String} packet type.
+       * @param {String} type: packet type.
        * @param {String} data.
        * @param {Object} options.
-       * @param {Function} callback function.
-       * @api private
+       * @param {Function} fn - callback function.
+       * @private
        */
       sendPacket(type, data, options, fn) {
           if ("function" === typeof data) {
@@ -14198,7 +14268,7 @@
           const packet = {
               type: type,
               data: data,
-              options: options
+              options: options,
           };
           this.emitReserved("packetCreate", packet);
           this.writeBuffer.push(packet);
@@ -14208,8 +14278,6 @@
       }
       /**
        * Closes the connection.
-       *
-       * @api public
        */
       close() {
           const close = () => {
@@ -14250,7 +14318,7 @@
       /**
        * Called upon transport error
        *
-       * @api private
+       * @private
        */
       onError(err) {
           Socket$1.priorWebsocketSuccess = false;
@@ -14260,9 +14328,9 @@
       /**
        * Called upon transport close.
        *
-       * @api private
+       * @private
        */
-      onClose(reason, desc) {
+      onClose(reason, description) {
           if ("opening" === this.readyState ||
               "open" === this.readyState ||
               "closing" === this.readyState) {
@@ -14275,6 +14343,7 @@
               // ignore further transport communication
               this.transport.removeAllListeners();
               if (typeof removeEventListener === "function") {
+                  removeEventListener("beforeunload", this.beforeunloadEventListener, false);
                   removeEventListener("offline", this.offlineEventListener, false);
               }
               // set ready state
@@ -14282,7 +14351,7 @@
               // clear session id
               this.id = null;
               // emit close event
-              this.emitReserved("close", reason, desc);
+              this.emitReserved("close", reason, description);
               // clean buffers after, so users can still
               // grab the buffers on `close` event
               this.writeBuffer = [];
@@ -14292,9 +14361,8 @@
       /**
        * Filters upgrades, returning only those matching client transports.
        *
-       * @param {Array} server upgrades
-       * @api private
-       *
+       * @param {Array} upgrades - server upgrades
+       * @private
        */
       filterUpgrades(upgrades) {
           const filteredUpgrades = [];
@@ -14304,18 +14372,68 @@
               if (~this.transports.indexOf(upgrades[i]))
                   filteredUpgrades.push(upgrades[i]);
           }
-          return filteredUpgrades;
+          return filteredUpgrades;
+      }
+  }
+  Socket$1.protocol = protocol$1;
+
+  /**
+   * URL parser.
+   *
+   * @param uri - url
+   * @param path - the request path of the connection
+   * @param loc - An object meant to mimic window.location.
+   *        Defaults to window.location.
+   * @public
+   */
+  function url(uri, path = "", loc) {
+      let obj = uri;
+      // default to window.location
+      loc = loc || (typeof location !== "undefined" && location);
+      if (null == uri)
+          uri = loc.protocol + "//" + loc.host;
+      // relative path support
+      if (typeof uri === "string") {
+          if ("/" === uri.charAt(0)) {
+              if ("/" === uri.charAt(1)) {
+                  uri = loc.protocol + uri;
+              }
+              else {
+                  uri = loc.host + uri;
+              }
+          }
+          if (!/^(https?|wss?):\/\//.test(uri)) {
+              if ("undefined" !== typeof loc) {
+                  uri = loc.protocol + "//" + uri;
+              }
+              else {
+                  uri = "https://" + uri;
+              }
+          }
+          // parse
+          obj = parse(uri);
       }
-  }
-  Socket$1.protocol = protocol$1;
-  function clone(obj) {
-      const o = {};
-      for (let i in obj) {
-          if (obj.hasOwnProperty(i)) {
-              o[i] = obj[i];
+      // make sure we treat `localhost:80` and `localhost` equally
+      if (!obj.port) {
+          if (/^(http|ws)$/.test(obj.protocol)) {
+              obj.port = "80";
+          }
+          else if (/^(http|ws)s$/.test(obj.protocol)) {
+              obj.port = "443";
           }
       }
-      return o;
+      obj.path = obj.path || "/";
+      const ipv6 = obj.host.indexOf(":") !== -1;
+      const host = ipv6 ? "[" + obj.host + "]" : obj.host;
+      // define unique id
+      obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
+      // define href
+      obj.href =
+          obj.protocol +
+              "://" +
+              host +
+              (loc && loc.port === obj.port ? "" : ":" + obj.port);
+      return obj;
   }
 
   const withNativeArrayBuffer = typeof ArrayBuffer === "function";
@@ -14402,7 +14520,7 @@
       else if (typeof data === "object" && !(data instanceof Date)) {
           const newData = {};
           for (const key in data) {
-              if (data.hasOwnProperty(key)) {
+              if (Object.prototype.hasOwnProperty.call(data, key)) {
                   newData[key] = _deconstructPacket(data[key], buffers);
               }
           }
@@ -14420,14 +14538,22 @@
    */
   function reconstructPacket(packet, buffers) {
       packet.data = _reconstructPacket(packet.data, buffers);
-      packet.attachments = undefined; // no longer useful
+      delete packet.attachments; // no longer useful
       return packet;
   }
   function _reconstructPacket(data, buffers) {
       if (!data)
           return data;
-      if (data && data._placeholder) {
-          return buffers[data.num]; // appropriate buffer (should be natural order anyway)
+      if (data && data._placeholder === true) {
+          const isIndexValid = typeof data.num === "number" &&
+              data.num >= 0 &&
+              data.num < buffers.length;
+          if (isIndexValid) {
+              return buffers[data.num]; // appropriate buffer (should be natural order anyway)
+          }
+          else {
+              throw new Error("illegal attachments");
+          }
       }
       else if (Array.isArray(data)) {
           for (let i = 0; i < data.length; i++) {
@@ -14436,7 +14562,7 @@
       }
       else if (typeof data === "object") {
           for (const key in data) {
-              if (data.hasOwnProperty(key)) {
+              if (Object.prototype.hasOwnProperty.call(data, key)) {
                   data[key] = _reconstructPacket(data[key], buffers);
               }
           }
@@ -14464,6 +14590,14 @@
    * A socket.io Encoder instance
    */
   class Encoder {
+      /**
+       * Encoder constructor
+       *
+       * @param {function} replacer - custom replacer to pass down to JSON.parse
+       */
+      constructor(replacer) {
+          this.replacer = replacer;
+      }
       /**
        * Encode a packet as a single string if non-binary, or as a
        * buffer sequence, depending on packet type.
@@ -14473,11 +14607,14 @@
       encode(obj) {
           if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
               if (hasBinary(obj)) {
-                  obj.type =
-                      obj.type === PacketType.EVENT
+                  return this.encodeAsBinary({
+                      type: obj.type === PacketType.EVENT
                           ? PacketType.BINARY_EVENT
-                          : PacketType.BINARY_ACK;
-                  return this.encodeAsBinary(obj);
+                          : PacketType.BINARY_ACK,
+                      nsp: obj.nsp,
+                      data: obj.data,
+                      id: obj.id,
+                  });
               }
           }
           return [this.encodeAsString(obj)];
@@ -14504,7 +14641,7 @@
           }
           // json data
           if (null != obj.data) {
-              str += JSON.stringify(obj.data);
+              str += JSON.stringify(obj.data, this.replacer);
           }
           return str;
       }
@@ -14526,9 +14663,15 @@
    *
    * @return {Object} decoder
    */
-  class Decoder extends Emitter_1 {
-      constructor() {
+  class Decoder extends Emitter {
+      /**
+       * Decoder constructor
+       *
+       * @param {function} reviver - custom reviver to pass down to JSON.stringify
+       */
+      constructor(reviver) {
           super();
+          this.reviver = reviver;
       }
       /**
        * Decodes an encoded packet string into packet JSON.
@@ -14538,9 +14681,13 @@
       add(obj) {
           let packet;
           if (typeof obj === "string") {
+              if (this.reconstructor) {
+                  throw new Error("got plaintext data when reconstructing a packet");
+              }
               packet = this.decodeString(obj);
-              if (packet.type === PacketType.BINARY_EVENT ||
-                  packet.type === PacketType.BINARY_ACK) {
+              const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
+              if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
+                  packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
                   // binary packet's json
                   this.reconstructor = new BinaryReconstructor(packet);
                   // no attachments, labeled binary but no binary data to follow
@@ -14629,7 +14776,7 @@
           }
           // look up json data
           if (str.charAt(++i)) {
-              const payload = tryParse(str.substr(i));
+              const payload = this.tryParse(str.substr(i));
               if (Decoder.isPayloadValid(p.type, payload)) {
                   p.data = payload;
               }
@@ -14639,6 +14786,14 @@
           }
           return p;
       }
+      tryParse(str) {
+          try {
+              return JSON.parse(str, this.reviver);
+          }
+          catch (e) {
+              return false;
+          }
+      }
       static isPayloadValid(type, payload) {
           switch (type) {
               case PacketType.CONNECT:
@@ -14661,17 +14816,10 @@
       destroy() {
           if (this.reconstructor) {
               this.reconstructor.finishedReconstruction();
+              this.reconstructor = null;
           }
       }
   }
-  function tryParse(str) {
-      try {
-          return JSON.parse(str);
-      }
-      catch (e) {
-          return false;
-      }
-  }
   /**
    * A manager of a binary event's 'buffer sequence'. Should
    * be constructed whenever a packet of type BINARY_EVENT is
@@ -14741,18 +14889,76 @@
       newListener: 1,
       removeListener: 1,
   });
-  class Socket extends Emitter_1 {
+  /**
+   * A Socket is the fundamental class for interacting with the server.
+   *
+   * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
+   *
+   * @example
+   * const socket = io();
+   *
+   * socket.on("connect", () => {
+   *   console.log("connected");
+   * });
+   *
+   * // send an event to the server
+   * socket.emit("foo", "bar");
+   *
+   * socket.on("foobar", () => {
+   *   // an event was received from the server
+   * });
+   *
+   * // upon disconnection
+   * socket.on("disconnect", (reason) => {
+   *   console.log(`disconnected due to ${reason}`);
+   * });
+   */
+  class Socket extends Emitter {
       /**
        * `Socket` constructor.
-       *
-       * @public
        */
       constructor(io, nsp, opts) {
           super();
+          /**
+           * Whether the socket is currently connected to the server.
+           *
+           * @example
+           * const socket = io();
+           *
+           * socket.on("connect", () => {
+           *   console.log(socket.connected); // true
+           * });
+           *
+           * socket.on("disconnect", () => {
+           *   console.log(socket.connected); // false
+           * });
+           */
           this.connected = false;
-          this.disconnected = true;
+          /**
+           * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will
+           * be transmitted by the server.
+           */
+          this.recovered = false;
+          /**
+           * Buffer for packets received before the CONNECT packet
+           */
           this.receiveBuffer = [];
+          /**
+           * Buffer for packets that will be sent once the socket is connected
+           */
           this.sendBuffer = [];
+          /**
+           * The queue of packets to be sent with retry in case of failure.
+           *
+           * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.
+           * @private
+           */
+          this._queue = [];
+          /**
+           * A sequence to generate the ID of the {@link QueuedPacket}.
+           * @private
+           */
+          this._queueSeq = 0;
           this.ids = 0;
           this.acks = {};
           this.flags = {};
@@ -14761,9 +14967,27 @@
           if (opts && opts.auth) {
               this.auth = opts.auth;
           }
+          this._opts = Object.assign({}, opts);
           if (this.io._autoConnect)
               this.open();
       }
+      /**
+       * Whether the socket is currently disconnected
+       *
+       * @example
+       * const socket = io();
+       *
+       * socket.on("connect", () => {
+       *   console.log(socket.disconnected); // false
+       * });
+       *
+       * socket.on("disconnect", () => {
+       *   console.log(socket.disconnected); // true
+       * });
+       */
+      get disconnected() {
+          return !this.connected;
+      }
       /**
        * Subscribe to open, close and packet events
        *
@@ -14781,7 +15005,21 @@
           ];
       }
       /**
-       * Whether the Socket will try to reconnect when its Manager connects or reconnects
+       * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+       *
+       * @example
+       * const socket = io();
+       *
+       * console.log(socket.active); // true
+       *
+       * socket.on("disconnect", (reason) => {
+       *   if (reason === "io server disconnect") {
+       *     // the disconnection was initiated by the server, you need to manually reconnect
+       *     console.log(socket.active); // false
+       *   }
+       *   // else the socket will automatically try to reconnect
+       *   console.log(socket.active); // true
+       * });
        */
       get active() {
           return !!this.subs;
@@ -14789,7 +15027,12 @@
       /**
        * "Opens" the socket.
        *
-       * @public
+       * @example
+       * const socket = io({
+       *   autoConnect: false
+       * });
+       *
+       * socket.connect();
        */
       connect() {
           if (this.connected)
@@ -14802,7 +15045,7 @@
           return this;
       }
       /**
-       * Alias for connect()
+       * Alias for {@link connect()}.
        */
       open() {
           return this.connect();
@@ -14810,8 +15053,17 @@
       /**
        * Sends a `message` event.
        *
+       * This method mimics the WebSocket.send() method.
+       *
+       * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+       *
+       * @example
+       * socket.send("hello");
+       *
+       * // this is equivalent to
+       * socket.emit("message", "hello");
+       *
        * @return self
-       * @public
        */
       send(...args) {
           args.unshift("message");
@@ -14822,14 +15074,28 @@
        * Override `emit`.
        * If the event is in `events`, it's emitted normally.
        *
+       * @example
+       * socket.emit("hello", "world");
+       *
+       * // all serializable datastructures are supported (no need to call JSON.stringify)
+       * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+       *
+       * // with an acknowledgement from the server
+       * socket.emit("hello", "world", (val) => {
+       *   // ...
+       * });
+       *
        * @return self
-       * @public
        */
       emit(ev, ...args) {
           if (RESERVED_EVENTS.hasOwnProperty(ev)) {
-              throw new Error('"' + ev + '" is a reserved event name');
+              throw new Error('"' + ev.toString() + '" is a reserved event name');
           }
           args.unshift(ev);
+          if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
+              this._addToQueue(args);
+              return this;
+          }
           const packet = {
               type: PacketType.EVENT,
               data: args,
@@ -14849,6 +15115,7 @@
           const discardPacket = this.flags.volatile && (!isTransportWritable || !this.connected);
           if (discardPacket) ;
           else if (this.connected) {
+              this.notifyOutgoingListeners(packet);
               this.packet(packet);
           }
           else {
@@ -14861,7 +15128,8 @@
        * @private
        */
       _registerAckCallback(id, ack) {
-          const timeout = this.flags.timeout;
+          var _a;
+          const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
           if (timeout === undefined) {
               this.acks[id] = ack;
               return;
@@ -14882,6 +15150,99 @@
               ack.apply(this, [null, ...args]);
           };
       }
+      /**
+       * Emits an event and waits for an acknowledgement
+       *
+       * @example
+       * // without timeout
+       * const response = await socket.emitWithAck("hello", "world");
+       *
+       * // with a specific timeout
+       * try {
+       *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+       * } catch (err) {
+       *   // the server did not acknowledge the event in the given delay
+       * }
+       *
+       * @return a Promise that will be fulfilled when the server acknowledges the event
+       */
+      emitWithAck(ev, ...args) {
+          // the timeout flag is optional
+          const withErr = this.flags.timeout !== undefined || this._opts.ackTimeout !== undefined;
+          return new Promise((resolve, reject) => {
+              args.push((arg1, arg2) => {
+                  if (withErr) {
+                      return arg1 ? reject(arg1) : resolve(arg2);
+                  }
+                  else {
+                      return resolve(arg1);
+                  }
+              });
+              this.emit(ev, ...args);
+          });
+      }
+      /**
+       * Add the packet to the queue.
+       * @param args
+       * @private
+       */
+      _addToQueue(args) {
+          let ack;
+          if (typeof args[args.length - 1] === "function") {
+              ack = args.pop();
+          }
+          const packet = {
+              id: this._queueSeq++,
+              tryCount: 0,
+              pending: false,
+              args,
+              flags: Object.assign({ fromQueue: true }, this.flags),
+          };
+          args.push((err, ...responseArgs) => {
+              if (packet !== this._queue[0]) {
+                  // the packet has already been acknowledged
+                  return;
+              }
+              const hasError = err !== null;
+              if (hasError) {
+                  if (packet.tryCount > this._opts.retries) {
+                      this._queue.shift();
+                      if (ack) {
+                          ack(err);
+                      }
+                  }
+              }
+              else {
+                  this._queue.shift();
+                  if (ack) {
+                      ack(null, ...responseArgs);
+                  }
+              }
+              packet.pending = false;
+              return this._drainQueue();
+          });
+          this._queue.push(packet);
+          this._drainQueue();
+      }
+      /**
+       * Send the first packet of the queue, and wait for an acknowledgement from the server.
+       * @param force - whether to resend a packet that has not been acknowledged yet
+       *
+       * @private
+       */
+      _drainQueue(force = false) {
+          if (!this.connected || this._queue.length === 0) {
+              return;
+          }
+          const packet = this._queue[0];
+          if (packet.pending && !force) {
+              return;
+          }
+          packet.pending = true;
+          packet.tryCount++;
+          this.flags = packet.flags;
+          this.emit.apply(this, packet.args);
+      }
       /**
        * Sends a packet.
        *
@@ -14900,13 +15261,27 @@
       onopen() {
           if (typeof this.auth == "function") {
               this.auth((data) => {
-                  this.packet({ type: PacketType.CONNECT, data });
+                  this._sendConnectPacket(data);
               });
           }
           else {
-              this.packet({ type: PacketType.CONNECT, data: this.auth });
+              this._sendConnectPacket(this.auth);
           }
       }
+      /**
+       * Sends a CONNECT packet to initiate the Socket.IO session.
+       *
+       * @param data
+       * @private
+       */
+      _sendConnectPacket(data) {
+          this.packet({
+              type: PacketType.CONNECT,
+              data: this._pid
+                  ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
+                  : data,
+          });
+      }
       /**
        * Called upon engine or manager `error`.
        *
@@ -14922,13 +15297,13 @@
        * Called upon engine `close`.
        *
        * @param reason
+       * @param description
        * @private
        */
-      onclose(reason) {
+      onclose(reason, description) {
           this.connected = false;
-          this.disconnected = true;
           delete this.id;
-          this.emitReserved("disconnect", reason);
+          this.emitReserved("disconnect", reason, description);
       }
       /**
        * Called with socket packet.
@@ -14943,22 +15318,17 @@
           switch (packet.type) {
               case PacketType.CONNECT:
                   if (packet.data && packet.data.sid) {
-                      const id = packet.data.sid;
-                      this.onconnect(id);
+                      this.onconnect(packet.data.sid, packet.data.pid);
                   }
                   else {
                       this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
                   }
                   break;
               case PacketType.EVENT:
-                  this.onevent(packet);
-                  break;
               case PacketType.BINARY_EVENT:
                   this.onevent(packet);
                   break;
               case PacketType.ACK:
-                  this.onack(packet);
-                  break;
               case PacketType.BINARY_ACK:
                   this.onack(packet);
                   break;
@@ -15000,6 +15370,9 @@
               }
           }
           super.emit.apply(this, args);
+          if (this._pid && args.length && typeof args[args.length - 1] === "string") {
+              this._lastOffset = args[args.length - 1];
+          }
       }
       /**
        * Produces an ack callback to emit with an event.
@@ -15039,12 +15412,14 @@
        *
        * @private
        */
-      onconnect(id) {
+      onconnect(id, pid) {
           this.id = id;
+          this.recovered = pid && this._pid === pid;
+          this._pid = pid; // defined only if connection state recovery is enabled
           this.connected = true;
-          this.disconnected = false;
           this.emitBuffered();
           this.emitReserved("connect");
+          this._drainQueue(true);
       }
       /**
        * Emit buffered events (received and emitted).
@@ -15054,7 +15429,10 @@
       emitBuffered() {
           this.receiveBuffer.forEach((args) => this.emitEvent(args));
           this.receiveBuffer = [];
-          this.sendBuffer.forEach((packet) => this.packet(packet));
+          this.sendBuffer.forEach((packet) => {
+              this.notifyOutgoingListeners(packet);
+              this.packet(packet);
+          });
           this.sendBuffer = [];
       }
       /**
@@ -15082,10 +15460,20 @@
           this.io["_destroy"](this);
       }
       /**
-       * Disconnects the socket manually.
+       * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+       *
+       * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+       *
+       * @example
+       * const socket = io();
+       *
+       * socket.on("disconnect", (reason) => {
+       *   // console.log(reason); prints "io client disconnect"
+       * });
+       *
+       * socket.disconnect();
        *
        * @return self
-       * @public
        */
       disconnect() {
           if (this.connected) {
@@ -15100,10 +15488,9 @@
           return this;
       }
       /**
-       * Alias for disconnect()
+       * Alias for {@link disconnect()}.
        *
        * @return self
-       * @public
        */
       close() {
           return this.disconnect();
@@ -15111,9 +15498,11 @@
       /**
        * Sets the compress flag.
        *
+       * @example
+       * socket.compress(false).emit("hello");
+       *
        * @param compress - if `true`, compresses the sending data
        * @return self
-       * @public
        */
       compress(compress) {
           this.flags.compress = compress;
@@ -15123,8 +15512,10 @@
        * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
        * ready to send messages.
        *
+       * @example
+       * socket.volatile.emit("hello"); // the server may or may not receive it
+       *
        * @returns self
-       * @public
        */
       get volatile() {
           this.flags.volatile = true;
@@ -15134,16 +15525,14 @@
        * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
        * given number of milliseconds have elapsed without an acknowledgement from the server:
        *
-       * ```
+       * @example
        * socket.timeout(5000).emit("my-event", (err) => {
        *   if (err) {
        *     // the server did not acknowledge the event in the given delay
        *   }
        * });
-       * ```
        *
        * @returns self
-       * @public
        */
       timeout(timeout) {
           this.flags.timeout = timeout;
@@ -15153,8 +15542,12 @@
        * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
        * callback.
        *
+       * @example
+       * socket.onAny((event, ...args) => {
+       *   console.log(`got ${event}`);
+       * });
+       *
        * @param listener
-       * @public
        */
       onAny(listener) {
           this._anyListeners = this._anyListeners || [];
@@ -15165,8 +15558,12 @@
        * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
        * callback. The listener is added to the beginning of the listeners array.
        *
+       * @example
+       * socket.prependAny((event, ...args) => {
+       *   console.log(`got event ${event}`);
+       * });
+       *
        * @param listener
-       * @public
        */
       prependAny(listener) {
           this._anyListeners = this._anyListeners || [];
@@ -15176,8 +15573,20 @@
       /**
        * Removes the listener that will be fired when any event is emitted.
        *
+       * @example
+       * const catchAllListener = (event, ...args) => {
+       *   console.log(`got event ${event}`);
+       * }
+       *
+       * socket.onAny(catchAllListener);
+       *
+       * // remove a specific listener
+       * socket.offAny(catchAllListener);
+       *
+       * // or remove all listeners
+       * socket.offAny();
+       *
        * @param listener
-       * @public
        */
       offAny(listener) {
           if (!this._anyListeners) {
@@ -15200,20 +15609,106 @@
       /**
        * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
        * e.g. to remove listeners.
-       *
-       * @public
        */
       listenersAny() {
           return this._anyListeners || [];
       }
+      /**
+       * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+       * callback.
+       *
+       * Note: acknowledgements sent to the server are not included.
+       *
+       * @example
+       * socket.onAnyOutgoing((event, ...args) => {
+       *   console.log(`sent event ${event}`);
+       * });
+       *
+       * @param listener
+       */
+      onAnyOutgoing(listener) {
+          this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+          this._anyOutgoingListeners.push(listener);
+          return this;
+      }
+      /**
+       * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+       * callback. The listener is added to the beginning of the listeners array.
+       *
+       * Note: acknowledgements sent to the server are not included.
+       *
+       * @example
+       * socket.prependAnyOutgoing((event, ...args) => {
+       *   console.log(`sent event ${event}`);
+       * });
+       *
+       * @param listener
+       */
+      prependAnyOutgoing(listener) {
+          this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+          this._anyOutgoingListeners.unshift(listener);
+          return this;
+      }
+      /**
+       * Removes the listener that will be fired when any event is emitted.
+       *
+       * @example
+       * const catchAllListener = (event, ...args) => {
+       *   console.log(`sent event ${event}`);
+       * }
+       *
+       * socket.onAnyOutgoing(catchAllListener);
+       *
+       * // remove a specific listener
+       * socket.offAnyOutgoing(catchAllListener);
+       *
+       * // or remove all listeners
+       * socket.offAnyOutgoing();
+       *
+       * @param [listener] - the catch-all listener (optional)
+       */
+      offAnyOutgoing(listener) {
+          if (!this._anyOutgoingListeners) {
+              return this;
+          }
+          if (listener) {
+              const listeners = this._anyOutgoingListeners;
+              for (let i = 0; i < listeners.length; i++) {
+                  if (listener === listeners[i]) {
+                      listeners.splice(i, 1);
+                      return this;
+                  }
+              }
+          }
+          else {
+              this._anyOutgoingListeners = [];
+          }
+          return this;
+      }
+      /**
+       * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+       * e.g. to remove listeners.
+       */
+      listenersAnyOutgoing() {
+          return this._anyOutgoingListeners || [];
+      }
+      /**
+       * Notify the listeners for each packet sent
+       *
+       * @param packet
+       *
+       * @private
+       */
+      notifyOutgoingListeners(packet) {
+          if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+              const listeners = this._anyOutgoingListeners.slice();
+              for (const listener of listeners) {
+                  listener.apply(this, packet.data);
+              }
+          }
+      }
   }
 
-  /**
-   * Expose `Backoff`.
-   */
-
-  var backo2 = Backoff;
-
   /**
    * Initialize backoff timer with `opts`.
    *
@@ -15225,74 +15720,63 @@
    * @param {Object} opts
    * @api public
    */
-
   function Backoff(opts) {
-    opts = opts || {};
-    this.ms = opts.min || 100;
-    this.max = opts.max || 10000;
-    this.factor = opts.factor || 2;
-    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
-    this.attempts = 0;
+      opts = opts || {};
+      this.ms = opts.min || 100;
+      this.max = opts.max || 10000;
+      this.factor = opts.factor || 2;
+      this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+      this.attempts = 0;
   }
-
   /**
    * Return the backoff duration.
    *
    * @return {Number}
    * @api public
    */
-
-  Backoff.prototype.duration = function(){
-    var ms = this.ms * Math.pow(this.factor, this.attempts++);
-    if (this.jitter) {
-      var rand =  Math.random();
-      var deviation = Math.floor(rand * this.jitter * ms);
-      ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;
-    }
-    return Math.min(ms, this.max) | 0;
+  Backoff.prototype.duration = function () {
+      var ms = this.ms * Math.pow(this.factor, this.attempts++);
+      if (this.jitter) {
+          var rand = Math.random();
+          var deviation = Math.floor(rand * this.jitter * ms);
+          ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+      }
+      return Math.min(ms, this.max) | 0;
   };
-
   /**
    * Reset the number of attempts.
    *
    * @api public
    */
-
-  Backoff.prototype.reset = function(){
-    this.attempts = 0;
+  Backoff.prototype.reset = function () {
+      this.attempts = 0;
   };
-
   /**
    * Set the minimum duration
    *
    * @api public
    */
-
-  Backoff.prototype.setMin = function(min){
-    this.ms = min;
+  Backoff.prototype.setMin = function (min) {
+      this.ms = min;
   };
-
   /**
    * Set the maximum duration
    *
    * @api public
    */
-
-  Backoff.prototype.setMax = function(max){
-    this.max = max;
+  Backoff.prototype.setMax = function (max) {
+      this.max = max;
   };
-
   /**
    * Set the jitter
    *
    * @api public
    */
-
-  Backoff.prototype.setJitter = function(jitter){
-    this.jitter = jitter;
+  Backoff.prototype.setJitter = function (jitter) {
+      this.jitter = jitter;
   };
 
-  class Manager extends Emitter_1 {
+  class Manager extends Emitter {
       constructor(uri, opts) {
           var _a;
           super();
@@ -15311,7 +15795,7 @@
           this.reconnectionDelay(opts.reconnectionDelay || 1000);
           this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
           this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);
-          this.backoff = new backo2({
+          this.backoff = new Backoff({
               min: this.reconnectionDelay(),
               max: this.reconnectionDelayMax(),
               jitter: this.randomizationFactor(),
@@ -15477,7 +15961,12 @@
        * @private
        */
       ondata(data) {
-          this.decoder.add(data);
+          try {
+              this.decoder.add(data);
+          }
+          catch (e) {
+              this.onclose("parse error", e);
+          }
       }
       /**
        * Called when parser fully decodes a packet.
@@ -15485,7 +15974,10 @@
        * @private
        */
       ondecoded(packet) {
-          this.emitReserved("packet", packet);
+          // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
+          nextTick(() => {
+              this.emitReserved("packet", packet);
+          }, this.setTimeoutFn);
       }
       /**
        * Called upon socket error.
@@ -15507,6 +15999,9 @@
               socket = new Socket(this, nsp, opts);
               this.nsps[nsp] = socket;
           }
+          else if (this._autoConnect && !socket.active) {
+              socket.connect();
+          }
           return socket;
       }
       /**
@@ -15572,11 +16067,11 @@
        *
        * @private
        */
-      onclose(reason) {
+      onclose(reason, description) {
           this.cleanup();
           this.backoff.reset();
           this._readyState = "closed";
-          this.emitReserved("close", reason);
+          this.emitReserved("close", reason, description);
           if (this._reconnection && !this.skipReconnect) {
               this.reconnect();
           }
@@ -16012,6 +16507,9 @@
   exports.InlineObjectFromJSON = InlineObjectFromJSON;
   exports.InlineObjectFromJSONTyped = InlineObjectFromJSONTyped;
   exports.InlineObjectToJSON = InlineObjectToJSON;
+  exports.InlineResponse403FromJSON = InlineResponse403FromJSON;
+  exports.InlineResponse403FromJSONTyped = InlineResponse403FromJSONTyped;
+  exports.InlineResponse403ToJSON = InlineResponse403ToJSON;
   exports.JSONApiResponse = JSONApiResponse;
   exports.MapEntryResponseFromJSON = MapEntryResponseFromJSON;
   exports.MapEntryResponseFromJSONTyped = MapEntryResponseFromJSONTyped;
@@ -16076,6 +16574,12 @@
   exports.OtherTransactionIdentifierFromJSON = OtherTransactionIdentifierFromJSON;
   exports.OtherTransactionIdentifierFromJSONTyped = OtherTransactionIdentifierFromJSONTyped;
   exports.OtherTransactionIdentifierToJSON = OtherTransactionIdentifierToJSON;
+  exports.PoolDelegationFromJSON = PoolDelegationFromJSON;
+  exports.PoolDelegationFromJSONTyped = PoolDelegationFromJSONTyped;
+  exports.PoolDelegationToJSON = PoolDelegationToJSON;
+  exports.PoolDelegationsResponseFromJSON = PoolDelegationsResponseFromJSON;
+  exports.PoolDelegationsResponseFromJSONTyped = PoolDelegationsResponseFromJSONTyped;
+  exports.PoolDelegationsResponseToJSON = PoolDelegationsResponseToJSON;
   exports.PostCoreNodeTransactionsErrorFromJSON = PostCoreNodeTransactionsErrorFromJSON;
   exports.PostCoreNodeTransactionsErrorFromJSONTyped = PostCoreNodeTransactionsErrorFromJSONTyped;
   exports.PostCoreNodeTransactionsErrorToJSON = PostCoreNodeTransactionsErrorToJSON;
@@ -16296,6 +16800,7 @@
   exports.SmartContractFromJSONTyped = SmartContractFromJSONTyped;
   exports.SmartContractToJSON = SmartContractToJSON;
   exports.SmartContractsApi = SmartContractsApi;
+  exports.StackingApi = StackingApi;
   exports.StackingRewardsApi = StackingRewardsApi;
   exports.StacksApiSocketClient = StacksApiSocketClient;
   exports.StacksApiWebSocketClient = StacksApiWebSocketClient;