@ntlab/ntjs-assets 2.0.2 → 2.0.4

package/assets/js/socket.io/socket.io.js

@@ -1,6 +1,6 @@
 /*!
- * Socket.IO v4.5.0
- * (c) 2014-2022 Guillermo Rauch
+ * Socket.IO v4.7.1
+ * (c) 2014-2023 Guillermo Rauch
  * Released under the MIT License.
  */
 (function (global, factory) {
@@ -12,64 +12,52 @@
   function _typeof(obj) {
     "@babel/helpers - typeof";
 
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function (obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function (obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+      return typeof obj;
+    } : function (obj) {
+      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    }, _typeof(obj);
   }
-
   function _classCallCheck(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
       throw new TypeError("Cannot call a class as a function");
     }
   }
-
   function _defineProperties(target, props) {
     for (var i = 0; i < props.length; i++) {
       var descriptor = props[i];
       descriptor.enumerable = descriptor.enumerable || false;
       descriptor.configurable = true;
       if ("value" in descriptor) descriptor.writable = true;
-      Object.defineProperty(target, descriptor.key, descriptor);
+      Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
     }
   }
-
   function _createClass(Constructor, protoProps, staticProps) {
     if (protoProps) _defineProperties(Constructor.prototype, protoProps);
     if (staticProps) _defineProperties(Constructor, staticProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
     return Constructor;
   }
-
   function _extends() {
-    _extends = Object.assign || function (target) {
+    _extends = Object.assign ? Object.assign.bind() : function (target) {
       for (var i = 1; i < arguments.length; i++) {
         var source = arguments[i];
-
         for (var key in source) {
           if (Object.prototype.hasOwnProperty.call(source, key)) {
             target[key] = source[key];
           }
         }
       }
-
       return target;
     };
-
     return _extends.apply(this, arguments);
   }
-
   function _inherits(subClass, superClass) {
     if (typeof superClass !== "function" && superClass !== null) {
       throw new TypeError("Super expression must either be null or a function");
     }
-
     subClass.prototype = Object.create(superClass && superClass.prototype, {
       constructor: {
         value: subClass,
@@ -77,30 +65,28 @@
         configurable: true
       }
     });
+    Object.defineProperty(subClass, "prototype", {
+      writable: false
+    });
     if (superClass) _setPrototypeOf(subClass, superClass);
   }
-
   function _getPrototypeOf(o) {
-    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
       return o.__proto__ || Object.getPrototypeOf(o);
     };
     return _getPrototypeOf(o);
   }
-
   function _setPrototypeOf(o, p) {
-    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
       o.__proto__ = p;
       return o;
     };
-
     return _setPrototypeOf(o, p);
   }
-
   function _isNativeReflectConstruct() {
     if (typeof Reflect === "undefined" || !Reflect.construct) return false;
     if (Reflect.construct.sham) return false;
     if (typeof Proxy === "function") return true;
-
     try {
       Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
       return true;
@@ -108,10 +94,9 @@
       return false;
     }
   }
-
   function _construct(Parent, args, Class) {
     if (_isNativeReflectConstruct()) {
-      _construct = Reflect.construct;
+      _construct = Reflect.construct.bind();
     } else {
       _construct = function _construct(Parent, args, Class) {
         var a = [null];
@@ -122,34 +107,25 @@
         return instance;
       };
     }
-
     return _construct.apply(null, arguments);
   }
-
   function _isNativeFunction(fn) {
     return Function.toString.call(fn).indexOf("[native code]") !== -1;
   }
-
   function _wrapNativeSuper(Class) {
     var _cache = typeof Map === "function" ? new Map() : undefined;
-
     _wrapNativeSuper = function _wrapNativeSuper(Class) {
       if (Class === null || !_isNativeFunction(Class)) return Class;
-
       if (typeof Class !== "function") {
         throw new TypeError("Super expression must either be null or a function");
       }
-
       if (typeof _cache !== "undefined") {
         if (_cache.has(Class)) return _cache.get(Class);
-
         _cache.set(Class, Wrapper);
       }
-
       function Wrapper() {
         return _construct(Class, arguments, _getPrototypeOf(this).constructor);
       }
-
       Wrapper.prototype = Object.create(Class.prototype, {
         constructor: {
           value: Wrapper,
@@ -160,77 +136,59 @@
       });
       return _setPrototypeOf(Wrapper, Class);
     };
-
     return _wrapNativeSuper(Class);
   }
-
   function _assertThisInitialized(self) {
     if (self === void 0) {
       throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
     }
-
     return self;
   }
-
   function _possibleConstructorReturn(self, call) {
     if (call && (typeof call === "object" || typeof call === "function")) {
       return call;
     } else if (call !== void 0) {
       throw new TypeError("Derived constructors may only return object or undefined");
     }
-
     return _assertThisInitialized(self);
   }
-
   function _createSuper(Derived) {
     var hasNativeReflectConstruct = _isNativeReflectConstruct();
-
     return function _createSuperInternal() {
       var Super = _getPrototypeOf(Derived),
-          result;
-
+        result;
       if (hasNativeReflectConstruct) {
         var NewTarget = _getPrototypeOf(this).constructor;
-
         result = Reflect.construct(Super, arguments, NewTarget);
       } else {
         result = Super.apply(this, arguments);
       }
-
       return _possibleConstructorReturn(this, result);
     };
   }
-
   function _superPropBase(object, property) {
     while (!Object.prototype.hasOwnProperty.call(object, property)) {
       object = _getPrototypeOf(object);
       if (object === null) break;
     }
-
     return object;
   }
-
-  function _get(target, property, receiver) {
+  function _get() {
     if (typeof Reflect !== "undefined" && Reflect.get) {
-      _get = Reflect.get;
+      _get = Reflect.get.bind();
     } else {
       _get = function _get(target, property, receiver) {
         var base = _superPropBase(target, property);
-
         if (!base) return;
         var desc = Object.getOwnPropertyDescriptor(base, property);
-
         if (desc.get) {
-          return desc.get.call(receiver);
+          return desc.get.call(arguments.length < 3 ? target : receiver);
         }
-
         return desc.value;
       };
     }
-
-    return _get(target, property, receiver || target);
+    return _get.apply(this, arguments);
   }
-
   function _unsupportedIterableToArray(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _arrayLikeToArray(o, minLen);
@@ -239,25 +197,18 @@
     if (n === "Map" || n === "Set") return Array.from(o);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
   }
-
   function _arrayLikeToArray(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
-
     for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
-
     return arr2;
   }
-
   function _createForOfIteratorHelper(o, allowArrayLike) {
     var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
-
     if (!it) {
       if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
         if (it) o = it;
         var i = 0;
-
         var F = function () {};
-
         return {
           s: F,
           n: function () {
@@ -275,13 +226,11 @@
           f: F
         };
       }
-
       throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
-
     var normalCompletion = true,
-        didErr = false,
-        err;
+      didErr = false,
+      err;
     return {
       s: function () {
         it = it.call(o);
@@ -304,9 +253,22 @@
       }
     };
   }
+  function _toPrimitive(input, hint) {
+    if (typeof input !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (typeof res !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return typeof key === "symbol" ? key : String(key);
+  }
 
   var PACKET_TYPES = Object.create(null); // no Map = no polyfill
-
   PACKET_TYPES["open"] = "0";
   PACKET_TYPES["close"] = "1";
   PACKET_TYPES["ping"] = "2";
@@ -324,16 +286,14 @@
   };
 
   var withNativeBlob$1 = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]";
-  var withNativeArrayBuffer$2 = typeof ArrayBuffer === "function"; // ArrayBuffer.isView method is not defined in IE10
-
+  var withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
+  // ArrayBuffer.isView method is not defined in IE10
   var isView$1 = function isView(obj) {
     return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer;
   };
-
   var encodePacket = function encodePacket(_ref, supportsBinary, callback) {
     var type = _ref.type,
-        data = _ref.data;
-
+      data = _ref.data;
     if (withNativeBlob$1 && data instanceof Blob) {
       if (supportsBinary) {
         return callback(data);
@@ -346,57 +306,66 @@
       } else {
         return encodeBlobAsBase64(new Blob([data]), callback);
       }
-    } // plain string
-
-
+    }
+    // plain string
     return callback(PACKET_TYPES[type] + (data || ""));
   };
-
   var encodeBlobAsBase64 = function encodeBlobAsBase64(data, callback) {
     var fileReader = new FileReader();
-
     fileReader.onload = function () {
       var content = fileReader.result.split(",")[1];
-      callback("b" + content);
+      callback("b" + (content || ""));
     };
-
     return fileReader.readAsDataURL(data);
   };
+  function toArray(data) {
+    if (data instanceof Uint8Array) {
+      return data;
+    } else if (data instanceof ArrayBuffer) {
+      return new Uint8Array(data);
+    } else {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    }
+  }
+  var TEXT_ENCODER;
+  function encodePacketToBinary(packet, callback) {
+    if (withNativeBlob$1 && packet.data instanceof Blob) {
+      return packet.data.arrayBuffer().then(toArray).then(callback);
+    } else if (withNativeArrayBuffer$2 && (packet.data instanceof ArrayBuffer || isView$1(packet.data))) {
+      return callback(toArray(packet.data));
+    }
+    encodePacket(packet, false, function (encoded) {
+      if (!TEXT_ENCODER) {
+        TEXT_ENCODER = new TextEncoder();
+      }
+      callback(TEXT_ENCODER.encode(encoded));
+    });
+  }
 
-  /*
-   * base64-arraybuffer 1.0.1 <https://github.com/niklasvh/base64-arraybuffer>
-   * Copyright (c) 2022 Niklas von Hertzen <https://hertzen.com>
-   * Released under MIT License
-   */
-  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index.
-
+  // imported from https://github.com/socketio/base64-arraybuffer
+  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$1 = function decode(base64) {
     var bufferLength = base64.length * 0.75,
-        len = base64.length,
-        i,
-        p = 0,
-        encoded1,
-        encoded2,
-        encoded3,
-        encoded4;
-
+      len = base64.length,
+      i,
+      p = 0,
+      encoded1,
+      encoded2,
+      encoded3,
+      encoded4;
     if (base64[base64.length - 1] === '=') {
       bufferLength--;
-
       if (base64[base64.length - 2] === '=') {
         bufferLength--;
       }
     }
-
     var arraybuffer = new ArrayBuffer(bufferLength),
-        bytes = new Uint8Array(arraybuffer);
-
+      bytes = new Uint8Array(arraybuffer);
     for (i = 0; i < len; i += 4) {
       encoded1 = lookup$1[base64.charCodeAt(i)];
       encoded2 = lookup$1[base64.charCodeAt(i + 1)];
@@ -406,12 +375,10 @@
       bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2;
       bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63;
     }
-
     return arraybuffer;
   };
 
   var withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
-
   var decodePacket = function decodePacket(encodedPacket, binaryType) {
     if (typeof encodedPacket !== "string") {
       return {
@@ -419,22 +386,17 @@
         data: mapBinary(encodedPacket, binaryType)
       };
     }
-
     var type = encodedPacket.charAt(0);
-
     if (type === "b") {
       return {
         type: "message",
         data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
       };
     }
-
     var packetType = PACKET_TYPES_REVERSE[type];
-
     if (!packetType) {
       return ERROR_PACKET;
     }
-
     return encodedPacket.length > 1 ? {
       type: PACKET_TYPES_REVERSE[type],
       data: encodedPacket.substring(1)
@@ -442,7 +404,6 @@
       type: PACKET_TYPES_REVERSE[type]
     };
   };
-
   var decodeBase64Packet = function decodeBase64Packet(data, binaryType) {
     if (withNativeArrayBuffer$1) {
       var decoded = decode$1(data);
@@ -458,17 +419,26 @@
   var mapBinary = function mapBinary(data, binaryType) {
     switch (binaryType) {
       case "blob":
-        return data instanceof ArrayBuffer ? new Blob([data]) : data;
-
+        if (data instanceof Blob) {
+          // from WebSocket + binaryType "blob"
+          return data;
+        } else {
+          // from HTTP long-polling or WebTransport
+          return new Blob([data]);
+        }
       case "arraybuffer":
       default:
-        return data;
-      // assuming the data is already an ArrayBuffer
+        if (data instanceof ArrayBuffer) {
+          // from HTTP long-polling (base64) or WebSocket + binaryType "arraybuffer"
+          return data;
+        } else {
+          // from WebTransport (Uint8Array)
+          return data.buffer;
+        }
     }
   };
 
   var SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
-
   var encodePayload = function encodePayload(packets, callback) {
     // some packets may be added to the array while encoding, so the initial length must be saved
     var length = packets.length;
@@ -478,30 +448,35 @@
       // force base64 encoding for binary packets
       encodePacket(packet, false, function (encodedPacket) {
         encodedPackets[i] = encodedPacket;
-
         if (++count === length) {
           callback(encodedPackets.join(SEPARATOR));
         }
       });
     });
   };
-
   var decodePayload = function decodePayload(encodedPayload, binaryType) {
     var encodedPackets = encodedPayload.split(SEPARATOR);
     var packets = [];
-
     for (var i = 0; i < encodedPackets.length; i++) {
       var decodedPacket = decodePacket(encodedPackets[i], binaryType);
       packets.push(decodedPacket);
-
       if (decodedPacket.type === "error") {
         break;
       }
     }
-
     return packets;
   };
-
+  var TEXT_DECODER;
+  function decodePacketFromBinary(data, isBinary, binaryType) {
+    if (!TEXT_DECODER) {
+      // lazily created for compatibility with old browser platforms
+      TEXT_DECODER = new TextDecoder();
+    }
+    // 48 === "0".charCodeAt(0) (OPEN packet type)
+    // 54 === "6".charCodeAt(0) (NOOP packet type)
+    var isPlainBinary = isBinary || data[0] < 48 || data[0] > 54;
+    return decodePacket(isPlainBinary ? data : TEXT_DECODER.decode(data), binaryType);
+  }
   var protocol$1 = 4;
 
   /**
@@ -509,9 +484,11 @@
    *
    * @api public
    */
+
   function Emitter(obj) {
     if (obj) return mixin(obj);
   }
+
   /**
    * Mixin the emitter properties.
    *
@@ -524,9 +501,9 @@
     for (var key in Emitter.prototype) {
       obj[key] = Emitter.prototype[key];
     }
-
     return obj;
   }
+
   /**
    * Listen on the given `event` with `fn`.
    *
@@ -536,12 +513,12 @@
    * @api public
    */
 
-
   Emitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {
     this._callbacks = this._callbacks || {};
     (this._callbacks['$' + event] = this._callbacks['$' + event] || []).push(fn);
     return this;
   };
+
   /**
    * Adds an `event` listener that will be invoked a single
    * time then automatically removed.
@@ -552,17 +529,16 @@
    * @api public
    */
 
-
   Emitter.prototype.once = function (event, fn) {
     function on() {
       this.off(event, on);
       fn.apply(this, arguments);
     }
-
     on.fn = fn;
     this.on(event, on);
     return this;
   };
+
   /**
    * Remove the given callback for `event` or all
    * registered callbacks.
@@ -573,44 +549,43 @@
    * @api public
    */
 
-
   Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {
-    this._callbacks = this._callbacks || {}; // all
+    this._callbacks = this._callbacks || {};
 
+    // all
     if (0 == arguments.length) {
       this._callbacks = {};
       return this;
-    } // specific event
-
+    }
 
+    // specific event
     var callbacks = this._callbacks['$' + event];
-    if (!callbacks) return this; // remove all handlers
+    if (!callbacks) return this;
 
+    // remove all handlers
     if (1 == arguments.length) {
       delete this._callbacks['$' + event];
       return this;
-    } // remove specific handler
-
+    }
 
+    // remove specific handler
     var cb;
-
     for (var i = 0; i < callbacks.length; i++) {
       cb = callbacks[i];
-
       if (cb === fn || cb.fn === fn) {
         callbacks.splice(i, 1);
         break;
       }
-    } // Remove event specific arrays for event types that no
-    // one is subscribed for to avoid memory leak.
-
+    }
 
+    // Remove event specific arrays for event types that no
+    // one is subscribed for to avoid memory leak.
     if (callbacks.length === 0) {
       delete this._callbacks['$' + event];
     }
-
     return this;
   };
+
   /**
    * Emit `event` with the given args.
    *
@@ -619,29 +594,25 @@
    * @return {Emitter}
    */
 
-
   Emitter.prototype.emit = function (event) {
     this._callbacks = this._callbacks || {};
     var args = new Array(arguments.length - 1),
-        callbacks = this._callbacks['$' + event];
-
+      callbacks = this._callbacks['$' + event];
     for (var i = 1; i < arguments.length; i++) {
       args[i - 1] = arguments[i];
     }
-
     if (callbacks) {
       callbacks = callbacks.slice(0);
-
       for (var i = 0, len = callbacks.length; i < len; ++i) {
         callbacks[i].apply(this, args);
       }
     }
-
     return this;
-  }; // alias used for reserved events (protected method)
-
+  };
 
+  // alias used for reserved events (protected method)
   Emitter.prototype.emitReserved = Emitter.prototype.emit;
+
   /**
    * Return array of callbacks for `event`.
    *
@@ -654,6 +625,7 @@
     this._callbacks = this._callbacks || {};
     return this._callbacks['$' + event] || [];
   };
+
   /**
    * Check if this emitter has `event` handlers.
    *
@@ -662,12 +634,11 @@
    * @api public
    */
 
-
   Emitter.prototype.hasListeners = function (event) {
     return !!this.listeners(event).length;
   };
 
-  var globalThis = (function () {
+  var globalThisShim = function () {
     if (typeof self !== "undefined") {
       return self;
     } else if (typeof window !== "undefined") {
@@ -675,52 +646,46 @@
     } else {
       return Function("return this")();
     }
-  })();
+  }();
 
   function pick(obj) {
     for (var _len = arguments.length, attr = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       attr[_key - 1] = arguments[_key];
     }
-
     return attr.reduce(function (acc, k) {
       if (obj.hasOwnProperty(k)) {
         acc[k] = obj[k];
       }
-
       return acc;
     }, {});
-  } // Keep a reference to the real timeout functions so they can be used when overridden
-
-  var NATIVE_SET_TIMEOUT = setTimeout;
-  var NATIVE_CLEAR_TIMEOUT = clearTimeout;
+  }
+  // Keep a reference to the real timeout functions so they can be used when overridden
+  var NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
+  var NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
   function installTimerFunctions(obj, opts) {
     if (opts.useNativeTimers) {
-      obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);
-      obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);
+      obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
+      obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
     } else {
-      obj.setTimeoutFn = setTimeout.bind(globalThis);
-      obj.clearTimeoutFn = clearTimeout.bind(globalThis);
+      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)
-
-  var BASE64_OVERHEAD = 1.33; // we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
-
+  }
+  // base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
+  var 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
-
-
+    }
+    // arraybuffer or blob
     return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
   }
-
   function utf8Length(str) {
     var c = 0,
-        length = 0;
-
+      length = 0;
     for (var i = 0, l = str.length; i < l; i++) {
       c = str.charCodeAt(i);
-
       if (c < 0x80) {
         length += 1;
       } else if (c < 0x800) {
@@ -732,52 +697,74 @@
         length += 4;
       }
     }
-
     return length;
   }
 
+  // imported from https://github.com/galkn/querystring
+  /**
+   * Compiles a querystring
+   * Returns string representation of the object
+   *
+   * @param {Object}
+   * @api private
+   */
+  function encode$1(obj) {
+    var str = '';
+    for (var i in obj) {
+      if (obj.hasOwnProperty(i)) {
+        if (str.length) str += '&';
+        str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
+      }
+    }
+    return str;
+  }
+  /**
+   * Parses a simple querystring into an object
+   *
+   * @param {String} qs
+   * @api private
+   */
+  function decode(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;
+  }
+
   var TransportError = /*#__PURE__*/function (_Error) {
     _inherits(TransportError, _Error);
-
     var _super = _createSuper(TransportError);
-
     function TransportError(reason, description, context) {
       var _this;
-
       _classCallCheck(this, TransportError);
-
       _this = _super.call(this, reason);
       _this.description = description;
       _this.context = context;
       _this.type = "TransportError";
       return _this;
     }
-
-    return TransportError;
+    return _createClass(TransportError);
   }( /*#__PURE__*/_wrapNativeSuper(Error));
-
   var Transport = /*#__PURE__*/function (_Emitter) {
     _inherits(Transport, _Emitter);
-
     var _super2 = _createSuper(Transport);
-
     /**
      * Transport abstract constructor.
      *
-     * @param {Object} options.
-     * @api private
+     * @param {Object} opts - options
+     * @protected
      */
     function Transport(opts) {
       var _this2;
-
       _classCallCheck(this, Transport);
-
       _this2 = _super2.call(this);
       _this2.writable = false;
       installTimerFunctions(_assertThisInitialized(_this2), opts);
       _this2.opts = opts;
       _this2.query = opts.query;
-      _this2.readyState = "";
       _this2.socket = opts.socket;
       return _this2;
     }
@@ -788,84 +775,66 @@
      * @param description
      * @param context - the error context
      * @return {Transport} for chaining
-     * @api protected
+     * @protected
      */
-
-
     _createClass(Transport, [{
       key: "onError",
       value: function onError(reason, description, context) {
         _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "error", new TransportError(reason, description, context));
-
         return this;
       }
       /**
        * Opens the transport.
-       *
-       * @api public
        */
-
     }, {
       key: "open",
       value: function open() {
-        if ("closed" === this.readyState || "" === this.readyState) {
-          this.readyState = "opening";
-          this.doOpen();
-        }
-
+        this.readyState = "opening";
+        this.doOpen();
         return this;
       }
       /**
        * Closes the transport.
-       *
-       * @api public
        */
-
     }, {
       key: "close",
       value: function close() {
-        if ("opening" === this.readyState || "open" === this.readyState) {
+        if (this.readyState === "opening" || this.readyState === "open") {
           this.doClose();
           this.onClose();
         }
-
         return this;
       }
       /**
        * Sends multiple packets.
        *
        * @param {Array} packets
-       * @api public
        */
-
     }, {
       key: "send",
       value: function send(packets) {
-        if ("open" === this.readyState) {
+        if (this.readyState === "open") {
           this.write(packets);
         }
       }
       /**
        * Called upon open
        *
-       * @api protected
+       * @protected
        */
-
     }, {
       key: "onOpen",
       value: function onOpen() {
         this.readyState = "open";
         this.writable = true;
-
         _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "open");
       }
       /**
        * Called with data.
        *
        * @param {String} data
-       * @api protected
+       * @protected
        */
-
     }, {
       key: "onData",
       value: function onData(data) {
@@ -875,9 +844,8 @@
       /**
        * Called with a decoded packet.
        *
-       * @api protected
+       * @protected
        */
-
     }, {
       key: "onPacket",
       value: function onPacket(packet) {
@@ -886,29 +854,61 @@
       /**
        * Called upon close.
        *
-       * @api protected
+       * @protected
        */
-
     }, {
       key: "onClose",
       value: function onClose(details) {
         this.readyState = "closed";
-
         _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "close", details);
       }
+      /**
+       * Pauses the transport, in order not to lose packets during an upgrade.
+       *
+       * @param onPause
+       */
+    }, {
+      key: "pause",
+      value: function pause(onPause) {}
+    }, {
+      key: "createUri",
+      value: function createUri(schema) {
+        var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query);
+      }
+    }, {
+      key: "_hostname",
+      value: function _hostname() {
+        var hostname = this.opts.hostname;
+        return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
+      }
+    }, {
+      key: "_port",
+      value: function _port() {
+        if (this.opts.port && (this.opts.secure && Number(this.opts.port !== 443) || !this.opts.secure && Number(this.opts.port) !== 80)) {
+          return ":" + this.opts.port;
+        } else {
+          return "";
+        }
+      }
+    }, {
+      key: "_query",
+      value: function _query(query) {
+        var encodedQuery = encode$1(query);
+        return encodedQuery.length ? "?" + encodedQuery : "";
+      }
     }]);
-
     return Transport;
   }(Emitter);
 
   // imported from https://github.com/unshiftio/yeast
 
   var alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split(''),
-      length = 64,
-      map = {};
+    length = 64,
+    map = {};
   var seed = 0,
-      i = 0,
-      prev;
+    i = 0,
+    prev;
   /**
    * Return a string representing the specified number.
    *
@@ -916,15 +916,12 @@
    * @returns {String} The string representation of the number.
    * @api public
    */
-
-  function encode$1(num) {
+  function encode(num) {
     var encoded = '';
-
     do {
       encoded = alphabet[num % length] + encoded;
       num = Math.floor(num / length);
     } while (num > 0);
-
     return encoded;
   }
   /**
@@ -933,140 +930,83 @@
    * @returns {String} A unique id.
    * @api public
    */
-
   function yeast() {
-    var now = encode$1(+new Date());
+    var now = encode(+new Date());
     if (now !== prev) return seed = 0, prev = now;
-    return now + '.' + encode$1(seed++);
-  } //
+    return now + '.' + encode(seed++);
+  }
+  //
   // Map each character to its index.
   //
+  for (; i < length; i++) map[alphabet[i]] = i;
 
-  for (; i < length; i++) {
-    map[alphabet[i]] = i;
+  // imported from https://github.com/component/has-cors
+  var 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
   }
-
-  // imported from https://github.com/galkn/querystring
-
-  /**
-   * Compiles a querystring
-   * Returns string representation of the object
-   *
-   * @param {Object}
-   * @api private
-   */
-  function encode(obj) {
-    var str = '';
-
-    for (var i in obj) {
-      if (obj.hasOwnProperty(i)) {
-        if (str.length) str += '&';
-        str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
-      }
-    }
-
-    return str;
-  }
-  /**
-   * Parses a simple querystring into an object
-   *
-   * @param {String} qs
-   * @api private
-   */
-
-  function decode(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
-  var 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
-  }
-
-  var hasCORS = value;
+  var hasCORS = value;
 
   // browser shim for xmlhttprequest module
-  function XMLHttpRequest$1 (opts) {
-    var xdomain = opts.xdomain; // XMLHttpRequest can be disabled on IE
-
+  function XHR(opts) {
+    var 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 globalThis[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+        return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
       } catch (e) {}
     }
   }
+  function createCookieJar() {}
 
   function empty() {}
-
   var hasXHR2 = function () {
-    var xhr = new XMLHttpRequest$1({
+    var xhr = new XHR({
       xdomain: false
     });
     return null != xhr.responseType;
   }();
-
   var Polling = /*#__PURE__*/function (_Transport) {
     _inherits(Polling, _Transport);
-
     var _super = _createSuper(Polling);
-
     /**
      * XHR Polling constructor.
      *
      * @param {Object} opts
-     * @api public
+     * @package
      */
     function Polling(opts) {
       var _this;
-
       _classCallCheck(this, Polling);
-
       _this = _super.call(this, opts);
       _this.polling = false;
-
       if (typeof location !== "undefined") {
         var isSSL = "https:" === location.protocol;
-        var port = location.port; // some user agents have empty `location.port`
-
+        var 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
        */
-
-
       var forceBase64 = opts && opts.forceBase64;
       _this.supportsBinary = hasXHR2 && !forceBase64;
+      if (_this.opts.withCredentials) {
+        _this.cookieJar = createCookieJar();
+      }
       return _this;
     }
-    /**
-     * Transport name.
-     */
-
-
     _createClass(Polling, [{
       key: "name",
       get: function get() {
@@ -1076,9 +1016,8 @@
        * Opens the socket (triggers polling). We write a PING message to determine
        * when the transport is open.
        *
-       * @api private
+       * @protected
        */
-
     }, {
       key: "doOpen",
       value: function doOpen() {
@@ -1087,32 +1026,26 @@
       /**
        * 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
        */
-
     }, {
       key: "pause",
       value: function pause(onPause) {
         var _this2 = this;
-
         this.readyState = "pausing";
-
         var pause = function pause() {
           _this2.readyState = "paused";
           onPause();
         };
-
         if (this.polling || !this.writable) {
           var total = 0;
-
           if (this.polling) {
             total++;
             this.once("pollComplete", function () {
               --total || pause();
             });
           }
-
           if (!this.writable) {
             total++;
             this.once("drain", function () {
@@ -1126,9 +1059,8 @@
       /**
        * Starts polling cycle.
        *
-       * @api public
+       * @private
        */
-
     }, {
       key: "poll",
       value: function poll() {
@@ -1139,41 +1071,34 @@
       /**
        * Overloads onData to detect payloads.
        *
-       * @api private
+       * @protected
        */
-
     }, {
       key: "onData",
       value: function onData(data) {
         var _this3 = this;
-
         var callback = function callback(packet) {
           // if its the first message we consider the transport open
           if ("opening" === _this3.readyState && packet.type === "open") {
             _this3.onOpen();
-          } // if its a close packet, we close the ongoing requests
-
-
+          }
+          // if its a close packet, we close the ongoing requests
           if ("close" === packet.type) {
             _this3.onClose({
               description: "transport closed by the server"
             });
-
             return false;
-          } // otherwise bypass onData and handle the message
-
-
+          }
+          // otherwise bypass onData and handle the message
           _this3.onPacket(packet);
-        }; // decode payload
-
-
-        decodePayload(data, this.socket.binaryType).forEach(callback); // if an event did not trigger closing
-
+        };
+        // decode payload
+        decodePayload(data, this.socket.binaryType).forEach(callback);
+        // if an event did not trigger closing
         if ("closed" !== this.readyState) {
           // if we got data we're not polling
           this.polling = false;
           this.emitReserved("pollComplete");
-
           if ("open" === this.readyState) {
             this.poll();
           }
@@ -1182,20 +1107,17 @@
       /**
        * For polling, send a close packet.
        *
-       * @api private
+       * @protected
        */
-
     }, {
       key: "doClose",
       value: function doClose() {
         var _this4 = this;
-
         var close = function close() {
           _this4.write([{
             type: "close"
           }]);
         };
-
         if ("open" === this.readyState) {
           close();
         } else {
@@ -1207,21 +1129,17 @@
       /**
        * Writes a packets payload.
        *
-       * @param {Array} data packets
-       * @param {Function} drain callback
-       * @api private
+       * @param {Array} packets - data packets
+       * @protected
        */
-
     }, {
       key: "write",
       value: function write(packets) {
         var _this5 = this;
-
         this.writable = false;
         encodePayload(packets, function (data) {
           _this5.doWrite(data, function () {
             _this5.writable = true;
-
             _this5.emitReserved("drain");
           });
         });
@@ -1229,50 +1147,36 @@
       /**
        * Generates uri for connection.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "uri",
       value: function uri() {
-        var query = this.query || {};
         var schema = this.opts.secure ? "https" : "http";
-        var port = ""; // cache busting is forced
-
+        var query = this.query || {};
+        // cache busting is forced
         if (false !== this.opts.timestampRequests) {
           query[this.opts.timestampParam] = yeast();
         }
-
         if (!this.supportsBinary && !query.sid) {
           query.b64 = 1;
-        } // avoid port if default for schema
-
-
-        if (this.opts.port && ("https" === schema && Number(this.opts.port) !== 443 || "http" === schema && Number(this.opts.port) !== 80)) {
-          port = ":" + this.opts.port;
         }
-
-        var encodedQuery = encode(query);
-        var ipv6 = this.opts.hostname.indexOf(":") !== -1;
-        return schema + "://" + (ipv6 ? "[" + this.opts.hostname + "]" : this.opts.hostname) + port + this.opts.path + (encodedQuery.length ? "?" + encodedQuery : "");
+        return this.createUri(schema, query);
       }
       /**
        * Creates a request.
        *
        * @param {String} method
-       * @api private
+       * @private
        */
-
     }, {
       key: "request",
       value: function request() {
         var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
         _extends(opts, {
           xd: this.xd,
-          xs: this.xs
+          cookieJar: this.cookieJar
         }, this.opts);
-
         return new Request(this.uri(), opts);
       }
       /**
@@ -1280,14 +1184,12 @@
        *
        * @param {String} data to send.
        * @param {Function} called upon flush.
-       * @api private
+       * @private
        */
-
     }, {
       key: "doWrite",
       value: function doWrite(data, fn) {
         var _this6 = this;
-
         var req = this.request({
           method: "POST",
           data: data
@@ -1300,14 +1202,12 @@
       /**
        * Starts a poll cycle.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "doPoll",
       value: function doPoll() {
         var _this7 = this;
-
         var req = this.request();
         req.on("data", this.onData.bind(this));
         req.on("error", function (xhrStatus, context) {
@@ -1316,61 +1216,47 @@
         this.pollXhr = req;
       }
     }]);
-
     return Polling;
   }(Transport);
   var Request = /*#__PURE__*/function (_Emitter) {
     _inherits(Request, _Emitter);
-
     var _super2 = _createSuper(Request);
-
     /**
      * Request constructor
      *
      * @param {Object} options
-     * @api public
+     * @package
      */
     function Request(uri, opts) {
       var _this8;
-
       _classCallCheck(this, Request);
-
       _this8 = _super2.call(this);
       installTimerFunctions(_assertThisInitialized(_this8), opts);
       _this8.opts = opts;
       _this8.method = opts.method || "GET";
       _this8.uri = uri;
-      _this8.async = false !== opts.async;
       _this8.data = undefined !== opts.data ? opts.data : null;
-
       _this8.create();
-
       return _this8;
     }
     /**
      * Creates the XHR object and sends the request.
      *
-     * @api private
+     * @private
      */
-
-
     _createClass(Request, [{
       key: "create",
       value: function create() {
         var _this9 = this;
-
+        var _a;
         var opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
         opts.xdomain = !!this.opts.xd;
-        opts.xscheme = !!this.opts.xs;
-        var xhr = this.xhr = new XMLHttpRequest$1(opts);
-
+        var xhr = this.xhr = new XHR(opts);
         try {
-          xhr.open(this.method, this.uri, this.async);
-
+          xhr.open(this.method, this.uri, true);
           try {
             if (this.opts.extraHeaders) {
               xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
-
               for (var i in this.opts.extraHeaders) {
                 if (this.opts.extraHeaders.hasOwnProperty(i)) {
                   xhr.setRequestHeader(i, this.opts.extraHeaders[i]);
@@ -1378,29 +1264,28 @@
               }
             }
           } catch (e) {}
-
           if ("POST" === this.method) {
             try {
               xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
             } catch (e) {}
           }
-
           try {
             xhr.setRequestHeader("Accept", "*/*");
-          } catch (e) {} // ie6 check
-
-
+          } catch (e) {}
+          (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
+          // ie6 check
           if ("withCredentials" in xhr) {
             xhr.withCredentials = this.opts.withCredentials;
           }
-
           if (this.opts.requestTimeout) {
             xhr.timeout = this.opts.requestTimeout;
           }
-
           xhr.onreadystatechange = function () {
+            var _a;
+            if (xhr.readyState === 3) {
+              (_a = _this9.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(xhr);
+            }
             if (4 !== xhr.readyState) return;
-
             if (200 === xhr.status || 1223 === xhr.status) {
               _this9.onLoad();
             } else {
@@ -1411,7 +1296,6 @@
               }, 0);
             }
           };
-
           xhr.send(this.data);
         } catch (e) {
           // Need to defer since .create() is called directly from the constructor
@@ -1422,7 +1306,6 @@
           }, 0);
           return;
         }
-
         if (typeof document !== "undefined") {
           this.index = Request.requestsCount++;
           Request.requests[this.index] = this;
@@ -1431,9 +1314,8 @@
       /**
        * Called upon error.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onError",
       value: function onError(err) {
@@ -1443,41 +1325,34 @@
       /**
        * Cleans up house.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "cleanup",
       value: function cleanup(fromError) {
         if ("undefined" === typeof this.xhr || null === this.xhr) {
           return;
         }
-
         this.xhr.onreadystatechange = empty;
-
         if (fromError) {
           try {
             this.xhr.abort();
           } catch (e) {}
         }
-
         if (typeof document !== "undefined") {
           delete Request.requests[this.index];
         }
-
         this.xhr = null;
       }
       /**
        * Called upon load.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onLoad",
       value: function onLoad() {
         var data = this.xhr.responseText;
-
         if (data !== null) {
           this.emitReserved("data", data);
           this.emitReserved("success");
@@ -1487,16 +1362,14 @@
       /**
        * Aborts the request.
        *
-       * @api public
+       * @package
        */
-
     }, {
       key: "abort",
       value: function abort() {
         this.cleanup();
       }
     }]);
-
     return Request;
   }(Emitter);
   Request.requestsCount = 0;
@@ -1506,18 +1379,16 @@
    * memory leaks (e.g. when using IE) and to ensure that no spurious error is
    * emitted.
    */
-
   if (typeof document !== "undefined") {
     // @ts-ignore
     if (typeof attachEvent === "function") {
       // @ts-ignore
       attachEvent("onunload", unloadHandler);
     } else if (typeof addEventListener === "function") {
-      var terminationEvent = "onpagehide" in globalThis ? "pagehide" : "unload";
+      var terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
       addEventListener(terminationEvent, unloadHandler, false);
     }
   }
-
   function unloadHandler() {
     for (var i in Request.requests) {
       if (Request.requests.hasOwnProperty(i)) {
@@ -1528,7 +1399,6 @@
 
   var nextTick = function () {
     var isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
-
     if (isPromiseAvailable) {
       return function (cb) {
         return Promise.resolve().then(cb);
@@ -1539,49 +1409,33 @@
       };
     }
   }();
-  var WebSocket = globalThis.WebSocket || globalThis.MozWebSocket;
+  var WebSocket = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
   var usingBrowserWebSocket = true;
   var defaultBinaryType = "arraybuffer";
 
+  // detect ReactNative environment
   var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative";
   var WS = /*#__PURE__*/function (_Transport) {
     _inherits(WS, _Transport);
-
     var _super = _createSuper(WS);
-
     /**
      * WebSocket transport constructor.
      *
-     * @api {Object} connection options
-     * @api public
+     * @param {Object} opts - connection options
+     * @protected
      */
     function WS(opts) {
       var _this;
-
       _classCallCheck(this, WS);
-
       _this = _super.call(this, opts);
       _this.supportsBinary = !opts.forceBase64;
       return _this;
     }
-    /**
-     * Transport name.
-     *
-     * @api public
-     */
-
-
     _createClass(WS, [{
       key: "name",
       get: function get() {
         return "websocket";
       }
-      /**
-       * Opens socket.
-       *
-       * @api private
-       */
-
     }, {
       key: "doOpen",
       value: function doOpen() {
@@ -1589,113 +1443,85 @@
           // let probe timeout
           return;
         }
-
         var uri = this.uri();
-        var protocols = this.opts.protocols; // React Native only supports the 'headers' option, and will print a warning if anything else is passed
-
+        var protocols = this.opts.protocols;
+        // React Native only supports the 'headers' option, and will print a warning if anything else is passed
         var opts = isReactNative ? {} : pick(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity");
-
         if (this.opts.extraHeaders) {
           opts.headers = this.opts.extraHeaders;
         }
-
         try {
           this.ws = usingBrowserWebSocket && !isReactNative ? protocols ? new WebSocket(uri, protocols) : new WebSocket(uri) : new WebSocket(uri, protocols, opts);
         } catch (err) {
           return this.emitReserved("error", err);
         }
-
         this.ws.binaryType = this.socket.binaryType || defaultBinaryType;
         this.addEventListeners();
       }
       /**
        * Adds event listeners to the socket
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "addEventListeners",
       value: function addEventListeners() {
         var _this2 = this;
-
         this.ws.onopen = function () {
           if (_this2.opts.autoUnref) {
             _this2.ws._socket.unref();
           }
-
           _this2.onOpen();
         };
-
         this.ws.onclose = function (closeEvent) {
           return _this2.onClose({
             description: "websocket connection closed",
             context: closeEvent
           });
         };
-
         this.ws.onmessage = function (ev) {
           return _this2.onData(ev.data);
         };
-
         this.ws.onerror = function (e) {
           return _this2.onError("websocket error", e);
         };
       }
-      /**
-       * Writes data to socket.
-       *
-       * @param {Array} array of packets.
-       * @api private
-       */
-
     }, {
       key: "write",
       value: function write(packets) {
         var _this3 = this;
-
-        this.writable = false; // encodePacket efficient as it uses WS framing
+        this.writable = false;
+        // encodePacket efficient as it uses WS framing
         // no need for encodePayload
-
-        var _loop = function _loop(i) {
+        var _loop = function _loop() {
           var packet = packets[i];
           var lastPacket = i === packets.length - 1;
           encodePacket(packet, _this3.supportsBinary, function (data) {
             // always create a new object (GH-437)
             var opts = {};
+            // Sometimes the websocket has already been closed but the browser didn't
             // have a chance of informing us about it yet, in that case send will
             // throw an error
-
-
             try {
               if (usingBrowserWebSocket) {
                 // TypeError is thrown when passing the second argument on Safari
                 _this3.ws.send(data);
               }
             } catch (e) {}
-
             if (lastPacket) {
               // fake drain
               // defer to next tick to allow Socket to clear writeBuffer
               nextTick(function () {
                 _this3.writable = true;
-
                 _this3.emitReserved("drain");
               }, _this3.setTimeoutFn);
             }
           });
         };
-
         for (var i = 0; i < packets.length; i++) {
-          _loop(i);
+          _loop();
         }
       }
-      /**
-       * Closes socket.
-       *
-       * @api private
-       */
-
     }, {
       key: "doClose",
       value: function doClose() {
@@ -1707,110 +1533,198 @@
       /**
        * Generates uri for connection.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "uri",
       value: function uri() {
-        var query = this.query || {};
         var schema = this.opts.secure ? "wss" : "ws";
-        var port = ""; // avoid port if default for schema
-
-        if (this.opts.port && ("wss" === schema && Number(this.opts.port) !== 443 || "ws" === schema && Number(this.opts.port) !== 80)) {
-          port = ":" + this.opts.port;
-        } // append timestamp to URI
-
-
+        var query = this.query || {};
+        // append timestamp to URI
         if (this.opts.timestampRequests) {
           query[this.opts.timestampParam] = yeast();
-        } // communicate binary support capabilities
-
-
+        }
+        // communicate binary support capabilities
         if (!this.supportsBinary) {
           query.b64 = 1;
         }
-
-        var encodedQuery = encode(query);
-        var ipv6 = this.opts.hostname.indexOf(":") !== -1;
-        return schema + "://" + (ipv6 ? "[" + this.opts.hostname + "]" : this.opts.hostname) + port + this.opts.path + (encodedQuery.length ? "?" + encodedQuery : "");
+        return this.createUri(schema, query);
       }
       /**
        * Feature detection for WebSocket.
        *
        * @return {Boolean} whether this transport is available.
-       * @api public
+       * @private
        */
-
     }, {
       key: "check",
       value: function check() {
-        return !!WebSocket && !("__initialize" in WebSocket && this.name === WS.prototype.name);
+        return !!WebSocket;
       }
     }]);
-
     return WS;
   }(Transport);
 
+  function shouldIncludeBinaryHeader(packet, encoded) {
+    // 48 === "0".charCodeAt(0) (OPEN packet type)
+    // 54 === "6".charCodeAt(0) (NOOP packet type)
+    return packet.type === "message" && typeof packet.data !== "string" && encoded[0] >= 48 && encoded[0] <= 54;
+  }
+  var WT = /*#__PURE__*/function (_Transport) {
+    _inherits(WT, _Transport);
+    var _super = _createSuper(WT);
+    function WT() {
+      _classCallCheck(this, WT);
+      return _super.apply(this, arguments);
+    }
+    _createClass(WT, [{
+      key: "name",
+      get: function get() {
+        return "webtransport";
+      }
+    }, {
+      key: "doOpen",
+      value: function doOpen() {
+        var _this = this;
+        // @ts-ignore
+        if (typeof WebTransport !== "function") {
+          return;
+        }
+        // @ts-ignore
+        this.transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+        this.transport.closed.then(function () {
+          _this.onClose();
+        })["catch"](function (err) {
+          _this.onError("webtransport error", err);
+        });
+        // note: we could have used async/await, but that would require some additional polyfills
+        this.transport.ready.then(function () {
+          _this.transport.createBidirectionalStream().then(function (stream) {
+            var reader = stream.readable.getReader();
+            _this.writer = stream.writable.getWriter();
+            var binaryFlag;
+            var read = function read() {
+              reader.read().then(function (_ref) {
+                var done = _ref.done,
+                  value = _ref.value;
+                if (done) {
+                  return;
+                }
+                if (!binaryFlag && value.byteLength === 1 && value[0] === 54) {
+                  binaryFlag = true;
+                } else {
+                  // TODO expose binarytype
+                  _this.onPacket(decodePacketFromBinary(value, binaryFlag, "arraybuffer"));
+                  binaryFlag = false;
+                }
+                read();
+              })["catch"](function (err) {});
+            };
+            read();
+            var handshake = _this.query.sid ? "0{\"sid\":\"".concat(_this.query.sid, "\"}") : "0";
+            _this.writer.write(new TextEncoder().encode(handshake)).then(function () {
+              return _this.onOpen();
+            });
+          });
+        });
+      }
+    }, {
+      key: "write",
+      value: function write(packets) {
+        var _this2 = this;
+        this.writable = false;
+        var _loop = function _loop() {
+          var packet = packets[i];
+          var lastPacket = i === packets.length - 1;
+          encodePacketToBinary(packet, function (data) {
+            if (shouldIncludeBinaryHeader(packet, data)) {
+              _this2.writer.write(Uint8Array.of(54));
+            }
+            _this2.writer.write(data).then(function () {
+              if (lastPacket) {
+                nextTick(function () {
+                  _this2.writable = true;
+                  _this2.emitReserved("drain");
+                }, _this2.setTimeoutFn);
+              }
+            });
+          });
+        };
+        for (var i = 0; i < packets.length; i++) {
+          _loop();
+        }
+      }
+    }, {
+      key: "doClose",
+      value: function doClose() {
+        var _a;
+        (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+      }
+    }]);
+    return WT;
+  }(Transport);
+
   var transports = {
     websocket: WS,
+    webtransport: WT,
     polling: Polling
   };
 
   // imported from https://github.com/galkn/parseuri
-
   /**
-   * Parses an URI
+   * 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
    */
-  var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+  var re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
   var parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'];
   function parse(str) {
     var src = str,
-        b = str.indexOf('['),
-        e = str.indexOf(']');
-
+      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);
     }
-
     var m = re.exec(str || ''),
-        uri = {},
-        i = 14;
-
+      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) {
     var regx = /\/{2,9}/g,
-        names = path.replace(regx, "/").split("/");
-
-    if (path.substr(0, 1) == '/' || path.length === 0) {
+      names = path.replace(regx, "/").split("/");
+    if (path.slice(0, 1) == '/' || path.length === 0) {
       names.splice(0, 1);
     }
-
-    if (path.substr(path.length - 1, 1) == '/') {
+    if (path.slice(-1) == '/') {
       names.splice(names.length - 1, 1);
     }
-
     return names;
   }
-
   function queryKey(uri, query) {
     var data = {};
     query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
@@ -1823,30 +1737,23 @@
 
   var Socket$1 = /*#__PURE__*/function (_Emitter) {
     _inherits(Socket, _Emitter);
-
     var _super = _createSuper(Socket);
-
     /**
      * Socket constructor.
      *
-     * @param {String|Object} uri or options
+     * @param {String|Object} uri - uri or options
      * @param {Object} opts - options
-     * @api public
      */
     function Socket(uri) {
       var _this;
-
       var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
       _classCallCheck(this, Socket);
-
       _this = _super.call(this);
-
+      _this.writeBuffer = [];
       if (uri && "object" === _typeof(uri)) {
         opts = uri;
         uri = null;
       }
-
       if (uri) {
         uri = parse(uri);
         opts.hostname = uri.host;
@@ -1856,19 +1763,15 @@
       } else if (opts.host) {
         opts.hostname = parse(opts.host).host;
       }
-
       installTimerFunctions(_assertThisInitialized(_this), opts);
       _this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol;
-
       if (opts.hostname && !opts.port) {
         // if no port is specified manually, use the protocol default
         opts.port = _this.secure ? "443" : "80";
       }
-
       _this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
       _this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : _this.secure ? "443" : "80");
-      _this.transports = opts.transports || ["polling", "websocket"];
-      _this.readyState = "";
+      _this.transports = opts.transports || ["polling", "websocket", "webtransport"];
       _this.writeBuffer = [];
       _this.prevBufferLen = 0;
       _this.opts = _extends({
@@ -1878,101 +1781,87 @@
         upgrade: true,
         timestampParam: "t",
         rememberUpgrade: false,
+        addTrailingSlash: true,
         rejectUnauthorized: true,
         perMessageDeflate: {
           threshold: 1024
         },
         transportOptions: {},
-        closeOnBeforeunload: true
+        closeOnBeforeunload: false
       }, 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 = decode(_this.opts.query);
-      } // set on handshake
-
-
+      }
+      // set on handshake
       _this.id = null;
       _this.upgrades = null;
       _this.pingInterval = null;
-      _this.pingTimeout = null; // set on heartbeat
-
+      _this.pingTimeout = null;
+      // set on heartbeat
       _this.pingTimeoutTimer = null;
-
       if (typeof addEventListener === "function") {
         if (_this.opts.closeOnBeforeunload) {
           // 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", function () {
+          _this.beforeunloadEventListener = function () {
             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 = function () {
             _this.onClose("transport close", {
               description: "network connection lost"
             });
           };
-
           addEventListener("offline", _this.offlineEventListener, false);
         }
       }
-
       _this.open();
-
       return _this;
     }
     /**
      * Creates transport of the given type.
      *
-     * @param {String} transport name
+     * @param {String} name - transport name
      * @return {Transport}
-     * @api private
+     * @private
      */
-
-
     _createClass(Socket, [{
       key: "createTransport",
       value: function createTransport(name) {
-        var query = _extends({}, this.opts.query); // append engine.io protocol identifier
-
-
-        query.EIO = protocol$1; // transport name
-
-        query.transport = name; // session id if we already have one
-
+        var query = _extends({}, this.opts.query);
+        // append engine.io protocol identifier
+        query.EIO = protocol$1;
+        // transport name
+        query.transport = name;
+        // session id if we already have one
         if (this.id) query.sid = this.id;
-
-        var opts = _extends({}, this.opts.transportOptions[name], this.opts, {
+        var opts = _extends({}, this.opts, {
           query: query,
           socket: this,
           hostname: this.hostname,
           secure: this.secure,
           port: this.port
-        });
-
+        }, this.opts.transportOptions[name]);
         return new transports[name](opts);
       }
       /**
        * Initializes transport to use and starts probe.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "open",
       value: function open() {
         var _this2 = this;
-
         var transport;
-
         if (this.opts.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1) {
           transport = "websocket";
         } else if (0 === this.transports.length) {
@@ -1984,9 +1873,8 @@
         } else {
           transport = this.transports[0];
         }
-
-        this.readyState = "opening"; // Retry with the next transport if the transport is disabled (jsonp: false)
-
+        this.readyState = "opening";
+        // Retry with the next transport if the transport is disabled (jsonp: false)
         try {
           transport = this.createTransport(transport);
         } catch (e) {
@@ -1994,28 +1882,24 @@
           this.open();
           return;
         }
-
         transport.open();
         this.setTransport(transport);
       }
       /**
        * Sets the current transport. Disables the existing one (if any).
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "setTransport",
       value: function setTransport(transport) {
         var _this3 = this;
-
         if (this.transport) {
           this.transport.removeAllListeners();
-        } // set up transport
-
-
-        this.transport = transport; // set up transport listeners
-
+        }
+        // set up transport
+        this.transport = transport;
+        // set up transport listeners
         transport.on("drain", this.onDrain.bind(this)).on("packet", this.onPacket.bind(this)).on("error", this.onError.bind(this)).on("close", function (reason) {
           return _this3.onClose("transport close", reason);
         });
@@ -2023,19 +1907,16 @@
       /**
        * Probes a transport.
        *
-       * @param {String} transport name
-       * @api private
+       * @param {String} name - transport name
+       * @private
        */
-
     }, {
       key: "probe",
       value: function probe(name) {
         var _this4 = this;
-
         var transport = this.createTransport(name);
         var failed = false;
         Socket.priorWebsocketSuccess = false;
-
         var onTransportOpen = function onTransportOpen() {
           if (failed) return;
           transport.send([{
@@ -2044,115 +1925,102 @@
           }]);
           transport.once("packet", function (msg) {
             if (failed) return;
-
             if ("pong" === msg.type && "probe" === msg.data) {
               _this4.upgrading = true;
-
               _this4.emitReserved("upgrading", transport);
-
               if (!transport) return;
               Socket.priorWebsocketSuccess = "websocket" === transport.name;
-
               _this4.transport.pause(function () {
                 if (failed) return;
                 if ("closed" === _this4.readyState) return;
                 cleanup();
-
                 _this4.setTransport(transport);
-
                 transport.send([{
                   type: "upgrade"
                 }]);
-
                 _this4.emitReserved("upgrade", transport);
-
                 transport = null;
                 _this4.upgrading = false;
-
                 _this4.flush();
               });
             } else {
-              var err = new Error("probe error"); // @ts-ignore
-
+              var err = new Error("probe error");
+              // @ts-ignore
               err.transport = transport.name;
-
               _this4.emitReserved("upgradeError", err);
             }
           });
         };
-
         function freezeTransport() {
-          if (failed) return; // Any callback called by transport should be ignored since now
-
+          if (failed) return;
+          // Any callback called by transport should be ignored since now
           failed = true;
           cleanup();
           transport.close();
           transport = null;
-        } // Handle any error that happens while probing
-
-
+        }
+        // Handle any error that happens while probing
         var onerror = function onerror(err) {
-          var error = new Error("probe error: " + err); // @ts-ignore
-
+          var error = new Error("probe error: " + err);
+          // @ts-ignore
           error.transport = transport.name;
           freezeTransport();
-
           _this4.emitReserved("upgradeError", error);
         };
-
         function onTransportClose() {
           onerror("transport closed");
-        } // When the socket is closed while we're probing
-
-
+        }
+        // When the socket is closed while we're probing
         function onclose() {
           onerror("socket closed");
-        } // When the socket is upgraded while we're probing
-
-
+        }
+        // When the socket is upgraded while we're probing
         function onupgrade(to) {
           if (transport && to.name !== transport.name) {
             freezeTransport();
           }
-        } // Remove all listeners on the transport and on self
-
-
+        }
+        // Remove all listeners on the transport and on self
         var cleanup = function cleanup() {
           transport.removeListener("open", onTransportOpen);
           transport.removeListener("error", onerror);
           transport.removeListener("close", onTransportClose);
-
           _this4.off("close", onclose);
-
           _this4.off("upgrading", onupgrade);
         };
-
         transport.once("open", onTransportOpen);
         transport.once("error", onerror);
         transport.once("close", onTransportClose);
         this.once("close", onclose);
         this.once("upgrading", onupgrade);
-        transport.open();
+        if (this.upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") {
+          // favor WebTransport
+          this.setTimeoutFn(function () {
+            if (!failed) {
+              transport.open();
+            }
+          }, 200);
+        } else {
+          transport.open();
+        }
       }
       /**
        * Called when connection is deemed open.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onOpen",
       value: function onOpen() {
         this.readyState = "open";
         Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
         this.emitReserved("open");
-        this.flush(); // we check for `readyState` in case an `open`
+        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) {
           var i = 0;
           var l = this.upgrades.length;
-
           for (; i < l; i++) {
             this.probe(this.upgrades[i]);
           }
@@ -2161,36 +2029,31 @@
       /**
        * Handles a packet.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onPacket",
       value: function onPacket(packet) {
         if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
-          this.emitReserved("packet", packet); // Socket is live - any packet counts
-
+          this.emitReserved("packet", packet);
+          // Socket is live - any packet counts
           this.emitReserved("heartbeat");
-
           switch (packet.type) {
             case "open":
               this.onHandshake(JSON.parse(packet.data));
               break;
-
             case "ping":
               this.resetPingTimeout();
               this.sendPacket("pong");
               this.emitReserved("ping");
               this.emitReserved("pong");
               break;
-
             case "error":
-              var err = new Error("server error"); // @ts-ignore
-
+              var err = new Error("server error");
+              // @ts-ignore
               err.code = packet.data;
               this.onError(err);
               break;
-
             case "message":
               this.emitReserved("data", packet.data);
               this.emitReserved("message", packet.data);
@@ -2202,9 +2065,8 @@
        * Called upon handshake completion.
        *
        * @param {Object} data - handshake obj
-       * @api private
+       * @private
        */
-
     }, {
       key: "onHandshake",
       value: function onHandshake(data) {
@@ -2215,27 +2077,24 @@
         this.pingInterval = data.pingInterval;
         this.pingTimeout = data.pingTimeout;
         this.maxPayload = data.maxPayload;
-        this.onOpen(); // In case open handler closes socket
-
+        this.onOpen();
+        // In case open handler closes socket
         if ("closed" === this.readyState) return;
         this.resetPingTimeout();
       }
       /**
        * Sets and resets ping timeout timer based on server pings.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "resetPingTimeout",
       value: function resetPingTimeout() {
         var _this5 = this;
-
         this.clearTimeoutFn(this.pingTimeoutTimer);
         this.pingTimeoutTimer = this.setTimeoutFn(function () {
           _this5.onClose("ping timeout");
         }, this.pingInterval + this.pingTimeout);
-
         if (this.opts.autoUnref) {
           this.pingTimeoutTimer.unref();
         }
@@ -2243,18 +2102,16 @@
       /**
        * Called on `drain` event
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onDrain",
       value: function onDrain() {
-        this.writeBuffer.splice(0, this.prevBufferLen); // setting prevBufferLen = 0 is very important
+        this.writeBuffer.splice(0, this.prevBufferLen);
+        // setting prevBufferLen = 0 is very important
         // for example, when upgrading, upgrade packet is sent over,
         // and a nonzero prevBufferLen could cause problems on `drain`
-
         this.prevBufferLen = 0;
-
         if (0 === this.writeBuffer.length) {
           this.emitReserved("drain");
         } else {
@@ -2264,17 +2121,16 @@
       /**
        * Flush write buffers.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "flush",
       value: function flush() {
         if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
           var packets = this.getWritablePackets();
-          this.transport.send(packets); // keep track of current length of writeBuffer
+          this.transport.send(packets);
+          // keep track of current length of writeBuffer
           // splice writeBuffer and callbackBuffer on `drain`
-
           this.prevBufferLen = packets.length;
           this.emitReserved("flush");
         }
@@ -2285,29 +2141,22 @@
        *
        * @private
        */
-
     }, {
       key: "getWritablePackets",
       value: function getWritablePackets() {
         var shouldCheckPayloadSize = this.maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1;
-
         if (!shouldCheckPayloadSize) {
           return this.writeBuffer;
         }
-
         var payloadSize = 1; // first packet type
-
         for (var i = 0; i < this.writeBuffer.length; i++) {
           var 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
         }
 
@@ -2316,13 +2165,11 @@
       /**
        * 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
        */
-
     }, {
       key: "write",
       value: function write(msg, options, fn) {
@@ -2338,13 +2185,12 @@
       /**
        * 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
        */
-
     }, {
       key: "sendPacket",
       value: function sendPacket(type, data, options, fn) {
@@ -2352,16 +2198,13 @@
           fn = data;
           data = undefined;
         }
-
         if ("function" === typeof options) {
           fn = options;
           options = null;
         }
-
         if ("closing" === this.readyState || "closed" === this.readyState) {
           return;
         }
-
         options = options || {};
         options.compress = false !== options.compress;
         var packet = {
@@ -2376,39 +2219,27 @@
       }
       /**
        * Closes the connection.
-       *
-       * @api public
        */
-
     }, {
       key: "close",
       value: function close() {
         var _this6 = this;
-
         var close = function close() {
           _this6.onClose("forced close");
-
           _this6.transport.close();
         };
-
         var cleanupAndClose = function cleanupAndClose() {
           _this6.off("upgrade", cleanupAndClose);
-
           _this6.off("upgradeError", cleanupAndClose);
-
           close();
         };
-
         var waitForUpgrade = function waitForUpgrade() {
           // wait for upgrade to finish since we can't send packets while pausing a transport
           _this6.once("upgrade", cleanupAndClose);
-
           _this6.once("upgradeError", cleanupAndClose);
         };
-
         if ("opening" === this.readyState || "open" === this.readyState) {
           this.readyState = "closing";
-
           if (this.writeBuffer.length) {
             this.once("drain", function () {
               if (_this6.upgrading) {
@@ -2423,15 +2254,13 @@
             close();
           }
         }
-
         return this;
       }
       /**
        * Called upon transport error
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onError",
       value: function onError(err) {
@@ -2442,34 +2271,32 @@
       /**
        * Called upon transport close.
        *
-       * @api private
+       * @private
        */
-
     }, {
       key: "onClose",
       value: function onClose(reason, description) {
-        if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
-          // clear timers
-          this.clearTimeoutFn(this.pingTimeoutTimer); // stop event from firing again for transport
-
-          this.transport.removeAllListeners("close"); // ensure transport won't stay open
-
-          this.transport.close(); // ignore further transport communication
-
+        if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
+          // clear timers
+          this.clearTimeoutFn(this.pingTimeoutTimer);
+          // stop event from firing again for transport
+          this.transport.removeAllListeners("close");
+          // ensure transport won't stay open
+          this.transport.close();
+          // ignore further transport communication
           this.transport.removeAllListeners();
-
           if (typeof removeEventListener === "function") {
+            removeEventListener("beforeunload", this.beforeunloadEventListener, false);
             removeEventListener("offline", this.offlineEventListener, false);
-          } // set ready state
-
-
-          this.readyState = "closed"; // clear session id
-
-          this.id = null; // emit close event
-
-          this.emitReserved("close", reason, description); // clean buffers after, so users can still
+          }
+          // set ready state
+          this.readyState = "closed";
+          // clear session id
+          this.id = null;
+          // emit close event
+          this.emitReserved("close", reason, description);
+          // clean buffers after, so users can still
           // grab the buffers on `close` event
-
           this.writeBuffer = [];
           this.prevBufferLen = 0;
         }
@@ -2477,30 +2304,27 @@
       /**
        * Filters upgrades, returning only those matching client transports.
        *
-       * @param {Array} server upgrades
-       * @api private
-       *
+       * @param {Array} upgrades - server upgrades
+       * @private
        */
-
     }, {
       key: "filterUpgrades",
       value: function filterUpgrades(upgrades) {
         var filteredUpgrades = [];
         var i = 0;
         var j = upgrades.length;
-
         for (; i < j; i++) {
           if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]);
         }
-
         return filteredUpgrades;
       }
     }]);
-
     return Socket;
   }(Emitter);
   Socket$1.protocol = protocol$1;
 
+  Socket$1.protocol;
+
   /**
    * URL parser.
    *
@@ -2510,15 +2334,14 @@
    *        Defaults to window.location.
    * @public
    */
-
   function url(uri) {
     var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
     var loc = arguments.length > 2 ? arguments[2] : undefined;
-    var obj = uri; // default to window.location
-
+    var obj = uri;
+    // default to window.location
     loc = loc || typeof location !== "undefined" && location;
-    if (null == uri) uri = loc.protocol + "//" + loc.host; // relative path support
-
+    if (null == uri) uri = loc.protocol + "//" + loc.host;
+    // relative path support
     if (typeof uri === "string") {
       if ("/" === uri.charAt(0)) {
         if ("/" === uri.charAt(1)) {
@@ -2527,20 +2350,17 @@
           uri = loc.host + uri;
         }
       }
-
       if (!/^(https?|wss?):\/\//.test(uri)) {
         if ("undefined" !== typeof loc) {
           uri = loc.protocol + "//" + uri;
         } else {
           uri = "https://" + uri;
         }
-      } // parse
-
-
+      }
+      // parse
       obj = parse(uri);
-    } // make sure we treat `localhost:80` and `localhost` equally
-
-
+    }
+    // make sure we treat `localhost:80` and `localhost` equally
     if (!obj.port) {
       if (/^(http|ws)$/.test(obj.protocol)) {
         obj.port = "80";
@@ -2548,23 +2368,20 @@
         obj.port = "443";
       }
     }
-
     obj.path = obj.path || "/";
     var ipv6 = obj.host.indexOf(":") !== -1;
-    var host = ipv6 ? "[" + obj.host + "]" : obj.host; // define unique id
-
-    obj.id = obj.protocol + "://" + host + ":" + obj.port + path; // define href
-
+    var 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 withNativeArrayBuffer = typeof ArrayBuffer === "function";
-
   var isView = function isView(obj) {
     return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer;
   };
-
   var toString = Object.prototype.toString;
   var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]";
   var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]";
@@ -2573,7 +2390,6 @@
    *
    * @private
    */
-
   function isBinary(obj) {
     return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File;
   }
@@ -2581,31 +2397,25 @@
     if (!obj || _typeof(obj) !== "object") {
       return false;
     }
-
     if (Array.isArray(obj)) {
       for (var i = 0, l = obj.length; i < l; i++) {
         if (hasBinary(obj[i])) {
           return true;
         }
       }
-
       return false;
     }
-
     if (isBinary(obj)) {
       return true;
     }
-
     if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) {
       return hasBinary(obj.toJSON(), true);
     }
-
     for (var key in obj) {
       if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
         return true;
       }
     }
-
     return false;
   }
 
@@ -2616,23 +2426,19 @@
    * @return {Object} with deconstructed packet and list of buffers
    * @public
    */
-
   function deconstructPacket(packet) {
     var buffers = [];
     var packetData = packet.data;
     var pack = packet;
     pack.data = _deconstructPacket(packetData, buffers);
     pack.attachments = buffers.length; // number of binary 'attachments'
-
     return {
       packet: pack,
       buffers: buffers
     };
   }
-
   function _deconstructPacket(data, buffers) {
     if (!data) return data;
-
     if (isBinary(data)) {
       var placeholder = {
         _placeholder: true,
@@ -2642,24 +2448,19 @@
       return placeholder;
     } else if (Array.isArray(data)) {
       var newData = new Array(data.length);
-
       for (var i = 0; i < data.length; i++) {
         newData[i] = _deconstructPacket(data[i], buffers);
       }
-
       return newData;
     } else if (_typeof(data) === "object" && !(data instanceof Date)) {
       var _newData = {};
-
       for (var key in data) {
         if (Object.prototype.hasOwnProperty.call(data, key)) {
           _newData[key] = _deconstructPacket(data[key], buffers);
         }
       }
-
       return _newData;
     }
-
     return data;
   }
   /**
@@ -2670,20 +2471,20 @@
    * @return {Object} reconstructed packet
    * @public
    */
-
-
   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) {
+      var 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 (var i = 0; i < data.length; i++) {
         data[i] = _reconstructPacket(data[i], buffers);
@@ -2695,19 +2496,21 @@
         }
       }
     }
-
     return data;
   }
 
+  /**
+   * These strings must not be used as event names, as they have a special meaning.
+   */
+  var RESERVED_EVENTS$1 = ["connect", "connect_error", "disconnect", "disconnecting", "newListener", "removeListener" // used by the Node.js EventEmitter
+  ];
   /**
    * Protocol version.
    *
    * @public
    */
-
   var protocol = 5;
   var PacketType;
-
   (function (PacketType) {
     PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
     PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
@@ -2720,8 +2523,6 @@
   /**
    * A socket.io Encoder instance
    */
-
-
   var Encoder = /*#__PURE__*/function () {
     /**
      * Encoder constructor
@@ -2730,7 +2531,6 @@
      */
     function Encoder(replacer) {
       _classCallCheck(this, Encoder);
-
       this.replacer = replacer;
     }
     /**
@@ -2739,50 +2539,46 @@
      *
      * @param {Object} obj - packet object
      */
-
-
     _createClass(Encoder, [{
       key: "encode",
       value: function encode(obj) {
         if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
           if (hasBinary(obj)) {
-            obj.type = obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK;
-            return this.encodeAsBinary(obj);
+            return this.encodeAsBinary({
+              type: obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK,
+              nsp: obj.nsp,
+              data: obj.data,
+              id: obj.id
+            });
           }
         }
-
         return [this.encodeAsString(obj)];
       }
       /**
        * Encode packet as string.
        */
-
     }, {
       key: "encodeAsString",
       value: function encodeAsString(obj) {
         // first is type
-        var str = "" + obj.type; // attachments if we have them
-
+        var str = "" + obj.type;
+        // attachments if we have them
         if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) {
           str += obj.attachments + "-";
-        } // if we have a namespace other than `/`
+        }
+        // if we have a namespace other than `/`
         // we append it followed by a comma `,`
-
-
         if (obj.nsp && "/" !== obj.nsp) {
           str += obj.nsp + ",";
-        } // immediately followed by the id
-
-
+        }
+        // immediately followed by the id
         if (null != obj.id) {
           str += obj.id;
-        } // json data
-
-
+        }
+        // json data
         if (null != obj.data) {
           str += JSON.stringify(obj.data, this.replacer);
         }
-
         return str;
       }
       /**
@@ -2790,7 +2586,6 @@
        * deconstructing packet into object with placeholders and
        * a list of buffers.
        */
-
     }, {
       key: "encodeAsBinary",
       value: function encodeAsBinary(obj) {
@@ -2798,24 +2593,23 @@
         var pack = this.encodeAsString(deconstruction.packet);
         var buffers = deconstruction.buffers;
         buffers.unshift(pack); // add packet info to beginning of data list
-
         return buffers; // write all the buffers
       }
     }]);
-
     return Encoder;
   }();
+  // see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript
+  function isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  }
   /**
    * A socket.io Decoder instance
    *
    * @return {Object} decoder
    */
-
   var Decoder = /*#__PURE__*/function (_Emitter) {
     _inherits(Decoder, _Emitter);
-
     var _super = _createSuper(Decoder);
-
     /**
      * Decoder constructor
      *
@@ -2823,9 +2617,7 @@
      */
     function Decoder(reviver) {
       var _this;
-
       _classCallCheck(this, Decoder);
-
       _this = _super.call(this);
       _this.reviver = reviver;
       return _this;
@@ -2835,20 +2627,21 @@
      *
      * @param {String} obj - encoded packet
      */
-
-
     _createClass(Decoder, [{
       key: "add",
       value: function add(obj) {
         var 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) {
+          var 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
-
+            this.reconstructor = new BinaryReconstructor(packet);
+            // no attachments, labeled binary but no binary data to follow
             if (packet.attachments === 0) {
               _get(_getPrototypeOf(Decoder.prototype), "emitReserved", this).call(this, "decoded", packet);
             }
@@ -2862,11 +2655,9 @@
             throw new Error("got binary data when not reconstructing a packet");
           } else {
             packet = this.reconstructor.takeBinaryData(obj);
-
             if (packet) {
               // received final buffer
               this.reconstructor = null;
-
               _get(_getPrototypeOf(Decoder.prototype), "emitReserved", this).call(this, "decoded", packet);
             }
           }
@@ -2880,81 +2671,62 @@
        * @param {String} str
        * @return {Object} packet
        */
-
     }, {
       key: "decodeString",
       value: function decodeString(str) {
-        var i = 0; // look up type
-
+        var i = 0;
+        // look up type
         var p = {
           type: Number(str.charAt(0))
         };
-
         if (PacketType[p.type] === undefined) {
           throw new Error("unknown packet type " + p.type);
-        } // look up attachments if type binary
-
-
+        }
+        // look up attachments if type binary
         if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) {
           var start = i + 1;
-
           while (str.charAt(++i) !== "-" && i != str.length) {}
-
           var buf = str.substring(start, i);
-
           if (buf != Number(buf) || str.charAt(i) !== "-") {
             throw new Error("Illegal attachments");
           }
-
           p.attachments = Number(buf);
-        } // look up namespace (if any)
-
-
+        }
+        // look up namespace (if any)
         if ("/" === str.charAt(i + 1)) {
           var _start = i + 1;
-
           while (++i) {
             var c = str.charAt(i);
             if ("," === c) break;
             if (i === str.length) break;
           }
-
           p.nsp = str.substring(_start, i);
         } else {
           p.nsp = "/";
-        } // look up id
-
-
+        }
+        // look up id
         var next = str.charAt(i + 1);
-
         if ("" !== next && Number(next) == next) {
           var _start2 = i + 1;
-
           while (++i) {
             var _c = str.charAt(i);
-
             if (null == _c || Number(_c) != _c) {
               --i;
               break;
             }
-
             if (i === str.length) break;
           }
-
           p.id = Number(str.substring(_start2, i + 1));
-        } // look up json data
-
-
+        }
+        // look up json data
         if (str.charAt(++i)) {
           var payload = this.tryParse(str.substr(i));
-
           if (Decoder.isPayloadValid(p.type, payload)) {
             p.data = payload;
           } else {
             throw new Error("invalid payload");
           }
         }
-
         return p;
       }
     }, {
@@ -2975,6 +2747,7 @@
       function destroy() {
         if (this.reconstructor) {
           this.reconstructor.finishedReconstruction();
+          this.reconstructor = null;
         }
       }
     }], [{
@@ -2982,25 +2755,20 @@
       value: function isPayloadValid(type, payload) {
         switch (type) {
           case PacketType.CONNECT:
-            return _typeof(payload) === "object";
-
+            return isObject(payload);
           case PacketType.DISCONNECT:
             return payload === undefined;
-
           case PacketType.CONNECT_ERROR:
-            return typeof payload === "string" || _typeof(payload) === "object";
-
+            return typeof payload === "string" || isObject(payload);
           case PacketType.EVENT:
           case PacketType.BINARY_EVENT:
-            return Array.isArray(payload) && payload.length > 0;
-
+            return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS$1.indexOf(payload[0]) === -1);
           case PacketType.ACK:
           case PacketType.BINARY_ACK:
             return Array.isArray(payload);
         }
       }
     }]);
-
     return Decoder;
   }(Emitter);
   /**
@@ -3011,11 +2779,9 @@
    * @param {Object} packet
    * @return {BinaryReconstructor} initialized reconstructor
    */
-
   var BinaryReconstructor = /*#__PURE__*/function () {
     function BinaryReconstructor(packet) {
       _classCallCheck(this, BinaryReconstructor);
-
       this.packet = packet;
       this.buffers = [];
       this.reconPack = packet;
@@ -3028,26 +2794,21 @@
      * @return {null | Object} returns null if more binary data is expected or
      *   a reconstructed packet object if all buffers have been received.
      */
-
-
     _createClass(BinaryReconstructor, [{
       key: "takeBinaryData",
       value: function takeBinaryData(binData) {
         this.buffers.push(binData);
-
         if (this.buffers.length === this.reconPack.attachments) {
           // done with buffer list
           var packet = reconstructPacket(this.reconPack, this.buffers);
           this.finishedReconstruction();
           return packet;
         }
-
         return null;
       }
       /**
        * Cleans up binary packet reconstruction variables.
        */
-
     }, {
       key: "finishedReconstruction",
       value: function finishedReconstruction() {
@@ -3055,7 +2816,6 @@
         this.buffers = [];
       }
     }]);
-
     return BinaryReconstructor;
   }();
 
@@ -3078,7 +2838,6 @@
    * Internal events.
    * These events can't be emitted by the user.
    */
-
   var RESERVED_EVENTS = Object.freeze({
     connect: 1,
     connect_error: 1,
@@ -3088,43 +2847,106 @@
     newListener: 1,
     removeListener: 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}`);
+   * });
+   */
   var Socket = /*#__PURE__*/function (_Emitter) {
     _inherits(Socket, _Emitter);
-
     var _super = _createSuper(Socket);
-
     /**
      * `Socket` constructor.
-     *
-     * @public
      */
     function Socket(io, nsp, opts) {
       var _this;
-
       _classCallCheck(this, Socket);
-
       _this = _super.call(this);
+      /**
+       * 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;
+      /**
+       * 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 = {};
       _this.io = io;
       _this.nsp = nsp;
-
       if (opts && opts.auth) {
         _this.auth = opts.auth;
       }
-
+      _this._opts = _extends({}, opts);
       if (_this.io._autoConnect) _this.open();
       return _this;
     }
     /**
      * 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
+     * });
      */
-
-
     _createClass(Socket, [{
       key: "disconnected",
       get: function get() {
@@ -3135,7 +2957,6 @@
        *
        * @private
        */
-
     }, {
       key: "subEvents",
       value: function subEvents() {
@@ -3144,9 +2965,22 @@
         this.subs = [on(io, "open", this.onopen.bind(this)), on(io, "packet", this.onpacket.bind(this)), on(io, "error", this.onerror.bind(this)), on(io, "close", this.onclose.bind(this))];
       }
       /**
-       * Whether the Socket will try to reconnect when its Manager connects or reconnects
+       * 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
+       * });
        */
-
     }, {
       key: "active",
       get: function get() {
@@ -3155,23 +2989,25 @@
       /**
        * "Opens" the socket.
        *
-       * @public
+       * @example
+       * const socket = io({
+       *   autoConnect: false
+       * });
+       *
+       * socket.connect();
        */
-
     }, {
       key: "connect",
       value: function connect() {
         if (this.connected) return this;
         this.subEvents();
         if (!this.io["_reconnecting"]) this.io.open(); // ensure open
-
         if ("open" === this.io._readyState) this.onopen();
         return this;
       }
       /**
-       * Alias for connect()
+       * Alias for {@link connect()}.
        */
-
     }, {
       key: "open",
       value: function open() {
@@ -3180,17 +3016,24 @@
       /**
        * 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
        */
-
     }, {
       key: "send",
       value: function send() {
         for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
           args[_key] = arguments[_key];
         }
-
         args.unshift("message");
         this.emit.apply(this, args);
         return this;
@@ -3199,90 +3042,196 @@
        * 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
        */
-
     }, {
       key: "emit",
       value: function emit(ev) {
         if (RESERVED_EVENTS.hasOwnProperty(ev)) {
-          throw new Error('"' + ev + '" is a reserved event name');
+          throw new Error('"' + ev.toString() + '" is a reserved event name');
         }
-
         for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
           args[_key2 - 1] = arguments[_key2];
         }
-
         args.unshift(ev);
+        if (this._opts.retries && !this.flags.fromQueue && !this.flags["volatile"]) {
+          this._addToQueue(args);
+          return this;
+        }
         var packet = {
           type: PacketType.EVENT,
           data: args
         };
         packet.options = {};
-        packet.options.compress = this.flags.compress !== false; // event ack callback
-
+        packet.options.compress = this.flags.compress !== false;
+        // event ack callback
         if ("function" === typeof args[args.length - 1]) {
           var id = this.ids++;
           var ack = args.pop();
-
           this._registerAckCallback(id, ack);
-
           packet.id = id;
         }
-
         var isTransportWritable = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable;
         var discardPacket = this.flags["volatile"] && (!isTransportWritable || !this.connected);
-
         if (discardPacket) ; else if (this.connected) {
           this.notifyOutgoingListeners(packet);
           this.packet(packet);
         } else {
           this.sendBuffer.push(packet);
         }
-
         this.flags = {};
         return this;
       }
       /**
        * @private
        */
-
     }, {
       key: "_registerAckCallback",
       value: function _registerAckCallback(id, ack) {
         var _this2 = this;
-
-        var timeout = this.flags.timeout;
-
+        var _a;
+        var timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
         if (timeout === undefined) {
           this.acks[id] = ack;
           return;
-        } // @ts-ignore
-
-
+        }
+        // @ts-ignore
         var timer = this.io.setTimeoutFn(function () {
           delete _this2.acks[id];
-
           for (var i = 0; i < _this2.sendBuffer.length; i++) {
             if (_this2.sendBuffer[i].id === id) {
               _this2.sendBuffer.splice(i, 1);
             }
           }
-
-          ack.call(_this2, new Error("operation has timed out"));
-        }, timeout);
-
-        this.acks[id] = function () {
-          // @ts-ignore
-          _this2.io.clearTimeoutFn(timer);
-
-          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-            args[_key3] = arguments[_key3];
+          ack.call(_this2, new Error("operation has timed out"));
+        }, timeout);
+        this.acks[id] = function () {
+          // @ts-ignore
+          _this2.io.clearTimeoutFn(timer);
+          for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+            args[_key3] = arguments[_key3];
+          }
+          ack.apply(_this2, [null].concat(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
+       */
+    }, {
+      key: "emitWithAck",
+      value: function emitWithAck(ev) {
+        var _this3 = this;
+        for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+          args[_key4 - 1] = arguments[_key4];
+        }
+        // the timeout flag is optional
+        var withErr = this.flags.timeout !== undefined || this._opts.ackTimeout !== undefined;
+        return new Promise(function (resolve, reject) {
+          args.push(function (arg1, arg2) {
+            if (withErr) {
+              return arg1 ? reject(arg1) : resolve(arg2);
+            } else {
+              return resolve(arg1);
+            }
+          });
+          _this3.emit.apply(_this3, [ev].concat(args));
+        });
+      }
+      /**
+       * Add the packet to the queue.
+       * @param args
+       * @private
+       */
+    }, {
+      key: "_addToQueue",
+      value: function _addToQueue(args) {
+        var _this4 = this;
+        var ack;
+        if (typeof args[args.length - 1] === "function") {
+          ack = args.pop();
+        }
+        var packet = {
+          id: this._queueSeq++,
+          tryCount: 0,
+          pending: false,
+          args: args,
+          flags: _extends({
+            fromQueue: true
+          }, this.flags)
+        };
+        args.push(function (err) {
+          if (packet !== _this4._queue[0]) {
+            // the packet has already been acknowledged
+            return;
+          }
+          var hasError = err !== null;
+          if (hasError) {
+            if (packet.tryCount > _this4._opts.retries) {
+              _this4._queue.shift();
+              if (ack) {
+                ack(err);
+              }
+            }
+          } else {
+            _this4._queue.shift();
+            if (ack) {
+              for (var _len5 = arguments.length, responseArgs = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+                responseArgs[_key5 - 1] = arguments[_key5];
+              }
+              ack.apply(void 0, [null].concat(responseArgs));
+            }
           }
-
-          ack.apply(_this2, [null].concat(args));
-        };
+          packet.pending = false;
+          return _this4._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
+       */
+    }, {
+      key: "_drainQueue",
+      value: function _drainQueue() {
+        var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+        if (!this.connected || this._queue.length === 0) {
+          return;
+        }
+        var 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.
@@ -3290,12 +3239,10 @@
        * @param packet
        * @private
        */
-
     }, {
       key: "packet",
       value: function packet(_packet) {
         _packet.nsp = this.nsp;
-
         this.io._packet(_packet);
       }
       /**
@@ -3303,33 +3250,41 @@
        *
        * @private
        */
-
     }, {
       key: "onopen",
       value: function onopen() {
-        var _this3 = this;
-
+        var _this5 = this;
         if (typeof this.auth == "function") {
           this.auth(function (data) {
-            _this3.packet({
-              type: PacketType.CONNECT,
-              data: data
-            });
+            _this5._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
+       */
+    }, {
+      key: "_sendConnectPacket",
+      value: function _sendConnectPacket(data) {
+        this.packet({
+          type: PacketType.CONNECT,
+          data: this._pid ? _extends({
+            pid: this._pid,
+            offset: this._lastOffset
+          }, data) : data
+        });
+      }
       /**
        * Called upon engine or manager `error`.
        *
        * @param err
        * @private
        */
-
     }, {
       key: "onerror",
       value: function onerror(err) {
@@ -3344,7 +3299,6 @@
        * @param description
        * @private
        */
-
     }, {
       key: "onclose",
       value: function onclose(reason, description) {
@@ -3358,42 +3312,34 @@
        * @param packet
        * @private
        */
-
     }, {
       key: "onpacket",
       value: function onpacket(packet) {
         var sameNamespace = packet.nsp === this.nsp;
         if (!sameNamespace) return;
-
         switch (packet.type) {
           case PacketType.CONNECT:
             if (packet.data && packet.data.sid) {
-              var 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:
           case PacketType.BINARY_EVENT:
             this.onevent(packet);
             break;
-
           case PacketType.ACK:
           case PacketType.BINARY_ACK:
             this.onack(packet);
             break;
-
           case PacketType.DISCONNECT:
             this.ondisconnect();
             break;
-
           case PacketType.CONNECT_ERROR:
             this.destroy();
-            var err = new Error(packet.data.message); // @ts-ignore
-
+            var err = new Error(packet.data.message);
+            // @ts-ignore
             err.data = packet.data.data;
             this.emitReserved("connect_error", err);
             break;
@@ -3405,16 +3351,13 @@
        * @param packet
        * @private
        */
-
     }, {
       key: "onevent",
       value: function onevent(packet) {
         var args = packet.data || [];
-
         if (null != packet.id) {
           args.push(this.ack(packet.id));
         }
-
         if (this.connected) {
           this.emitEvent(args);
         } else {
@@ -3426,10 +3369,8 @@
       value: function emitEvent(args) {
         if (this._anyListeners && this._anyListeners.length) {
           var listeners = this._anyListeners.slice();
-
           var _iterator = _createForOfIteratorHelper(listeners),
-              _step;
-
+            _step;
           try {
             for (_iterator.s(); !(_step = _iterator.n()).done;) {
               var listener = _step.value;
@@ -3441,15 +3382,16 @@
             _iterator.f();
           }
         }
-
         _get(_getPrototypeOf(Socket.prototype), "emit", this).apply(this, args);
+        if (this._pid && args.length && typeof args[args.length - 1] === "string") {
+          this._lastOffset = args[args.length - 1];
+        }
       }
       /**
        * Produces an ack callback to emit with an event.
        *
        * @private
        */
-
     }, {
       key: "ack",
       value: function ack(id) {
@@ -3459,11 +3401,9 @@
           // prevent double callbacks
           if (sent) return;
           sent = true;
-
-          for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-            args[_key4] = arguments[_key4];
+          for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+            args[_key6] = arguments[_key6];
           }
-
           self.packet({
             type: PacketType.ACK,
             id: id,
@@ -3477,12 +3417,10 @@
        * @param packet
        * @private
        */
-
     }, {
       key: "onack",
       value: function onack(packet) {
         var ack = this.acks[packet.id];
-
         if ("function" === typeof ack) {
           ack.apply(this, packet.data);
           delete this.acks[packet.id];
@@ -3493,34 +3431,33 @@
        *
        * @private
        */
-
     }, {
       key: "onconnect",
-      value: function onconnect(id) {
+      value: function 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.emitBuffered();
         this.emitReserved("connect");
+        this._drainQueue(true);
       }
       /**
        * Emit buffered events (received and emitted).
        *
        * @private
        */
-
     }, {
       key: "emitBuffered",
       value: function emitBuffered() {
-        var _this4 = this;
-
+        var _this6 = this;
         this.receiveBuffer.forEach(function (args) {
-          return _this4.emitEvent(args);
+          return _this6.emitEvent(args);
         });
         this.receiveBuffer = [];
         this.sendBuffer.forEach(function (packet) {
-          _this4.notifyOutgoingListeners(packet);
-
-          _this4.packet(packet);
+          _this6.notifyOutgoingListeners(packet);
+          _this6.packet(packet);
         });
         this.sendBuffer = [];
       }
@@ -3529,7 +3466,6 @@
        *
        * @private
        */
-
     }, {
       key: "ondisconnect",
       value: function ondisconnect() {
@@ -3543,7 +3479,6 @@
        *
        * @private
        */
-
     }, {
       key: "destroy",
       value: function destroy() {
@@ -3554,16 +3489,24 @@
           });
           this.subs = undefined;
         }
-
         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
        */
-
     }, {
       key: "disconnect",
       value: function disconnect() {
@@ -3571,25 +3514,20 @@
           this.packet({
             type: PacketType.DISCONNECT
           });
-        } // remove socket from pool
-
-
+        }
+        // remove socket from pool
         this.destroy();
-
         if (this.connected) {
           // fire events
           this.onclose("io client disconnect");
         }
-
         return this;
       }
       /**
-       * Alias for disconnect()
+       * Alias for {@link disconnect()}.
        *
        * @return self
-       * @public
        */
-
     }, {
       key: "close",
       value: function close() {
@@ -3598,11 +3536,12 @@
       /**
        * Sets the compress flag.
        *
+       * @example
+       * socket.compress(false).emit("hello");
+       *
        * @param compress - if `true`, compresses the sending data
        * @return self
-       * @public
        */
-
     }, {
       key: "compress",
       value: function compress(_compress) {
@@ -3613,10 +3552,11 @@
        * 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
        */
-
     }, {
       key: "volatile",
       get: function get() {
@@ -3627,18 +3567,15 @@
        * 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
        */
-
     }, {
       key: "timeout",
       value: function timeout(_timeout) {
@@ -3649,53 +3586,64 @@
        * 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
        */
-
     }, {
       key: "onAny",
       value: function onAny(listener) {
         this._anyListeners = this._anyListeners || [];
-
         this._anyListeners.push(listener);
-
         return this;
       }
       /**
        * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
        * callback. The listener is added to the beginning of the listeners array.
        *
+       * @example
+       * socket.prependAny((event, ...args) => {
+       *   console.log(`got event ${event}`);
+       * });
+       *
        * @param listener
-       * @public
        */
-
     }, {
       key: "prependAny",
       value: function prependAny(listener) {
         this._anyListeners = this._anyListeners || [];
-
         this._anyListeners.unshift(listener);
-
         return this;
       }
       /**
        * Removes the listener that will be fired when any event is emitted.
        *
+       * @example
+       * const catchAllListener = (event, ...args) => {
+       *   console.log(`got event ${event}`);
+       * }
+       *
+       * socket.onAny(catchAllListener);
+       *
+       * // remove a specific listener
+       * socket.offAny(catchAllListener);
+       *
+       * // or remove all listeners
+       * socket.offAny();
+       *
        * @param listener
-       * @public
        */
-
     }, {
       key: "offAny",
       value: function offAny(listener) {
         if (!this._anyListeners) {
           return this;
         }
-
         if (listener) {
           var listeners = this._anyListeners;
-
           for (var i = 0; i < listeners.length; i++) {
             if (listener === listeners[i]) {
               listeners.splice(i, 1);
@@ -3705,16 +3653,12 @@
         } else {
           this._anyListeners = [];
         }
-
         return this;
       }
       /**
        * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
        * e.g. to remove listeners.
-       *
-       * @public
        */
-
     }, {
       key: "listenersAny",
       value: function listenersAny() {
@@ -3724,85 +3668,68 @@
        * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
        * callback.
        *
-       * @param listener
-       *
-       * <pre><code>
+       * Note: acknowledgements sent to the server are not included.
        *
+       * @example
        * socket.onAnyOutgoing((event, ...args) => {
-       *   console.log(event);
+       *   console.log(`sent event ${event}`);
        * });
        *
-       * </pre></code>
-       *
-       * @public
+       * @param listener
        */
-
     }, {
       key: "onAnyOutgoing",
       value: function 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.
        *
-       * @param listener
-       *
-       * <pre><code>
+       * Note: acknowledgements sent to the server are not included.
        *
+       * @example
        * socket.prependAnyOutgoing((event, ...args) => {
-       *   console.log(event);
+       *   console.log(`sent event ${event}`);
        * });
        *
-       * </pre></code>
-       *
-       * @public
+       * @param listener
        */
-
     }, {
       key: "prependAnyOutgoing",
       value: function prependAnyOutgoing(listener) {
         this._anyOutgoingListeners = this._anyOutgoingListeners || [];
-
         this._anyOutgoingListeners.unshift(listener);
-
         return this;
       }
       /**
        * Removes the listener that will be fired when any event is emitted.
        *
-       * @param listener
-       *
-       * <pre><code>
-       *
-       * const handler = (event, ...args) => {
-       *   console.log(event);
+       * @example
+       * const catchAllListener = (event, ...args) => {
+       *   console.log(`sent event ${event}`);
        * }
        *
-       * socket.onAnyOutgoing(handler);
+       * socket.onAnyOutgoing(catchAllListener);
        *
-       * // then later
-       * socket.offAnyOutgoing(handler);
+       * // remove a specific listener
+       * socket.offAnyOutgoing(catchAllListener);
        *
-       * </pre></code>
+       * // or remove all listeners
+       * socket.offAnyOutgoing();
        *
-       * @public
+       * @param [listener] - the catch-all listener (optional)
        */
-
     }, {
       key: "offAnyOutgoing",
       value: function offAnyOutgoing(listener) {
         if (!this._anyOutgoingListeners) {
           return this;
         }
-
         if (listener) {
           var listeners = this._anyOutgoingListeners;
-
           for (var i = 0; i < listeners.length; i++) {
             if (listener === listeners[i]) {
               listeners.splice(i, 1);
@@ -3812,16 +3739,12 @@
         } 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.
-       *
-       * @public
        */
-
     }, {
       key: "listenersAnyOutgoing",
       value: function listenersAnyOutgoing() {
@@ -3834,16 +3757,13 @@
        *
        * @private
        */
-
     }, {
       key: "notifyOutgoingListeners",
       value: function notifyOutgoingListeners(packet) {
         if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
           var listeners = this._anyOutgoingListeners.slice();
-
           var _iterator2 = _createForOfIteratorHelper(listeners),
-              _step2;
-
+            _step2;
           try {
             for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
               var listener = _step2.value;
@@ -3857,7 +3777,6 @@
         }
       }
     }]);
-
     return Socket;
   }(Emitter);
 
@@ -3886,16 +3805,13 @@
    * @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;
   };
   /**
@@ -3903,8 +3819,6 @@
    *
    * @api public
    */
-
-
   Backoff.prototype.reset = function () {
     this.attempts = 0;
   };
@@ -3913,8 +3827,6 @@
    *
    * @api public
    */
-
-
   Backoff.prototype.setMin = function (min) {
     this.ms = min;
   };
@@ -3923,8 +3835,6 @@
    *
    * @api public
    */
-
-
   Backoff.prototype.setMax = function (max) {
     this.max = max;
   };
@@ -3933,68 +3843,48 @@
    *
    * @api public
    */
-
-
   Backoff.prototype.setJitter = function (jitter) {
     this.jitter = jitter;
   };
 
   var Manager = /*#__PURE__*/function (_Emitter) {
     _inherits(Manager, _Emitter);
-
     var _super = _createSuper(Manager);
-
     function Manager(uri, opts) {
       var _this;
-
       _classCallCheck(this, Manager);
-
       var _a;
-
       _this = _super.call(this);
       _this.nsps = {};
       _this.subs = [];
-
       if (uri && "object" === _typeof(uri)) {
         opts = uri;
         uri = undefined;
       }
-
       opts = opts || {};
       opts.path = opts.path || "/socket.io";
       _this.opts = opts;
       installTimerFunctions(_assertThisInitialized(_this), opts);
-
       _this.reconnection(opts.reconnection !== false);
-
       _this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
-
       _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 Backoff({
         min: _this.reconnectionDelay(),
         max: _this.reconnectionDelayMax(),
         jitter: _this.randomizationFactor()
       });
-
       _this.timeout(null == opts.timeout ? 20000 : opts.timeout);
-
       _this._readyState = "closed";
       _this.uri = uri;
-
       var _parser = opts.parser || parser;
-
       _this.encoder = new _parser.Encoder();
       _this.decoder = new _parser.Decoder();
       _this._autoConnect = opts.autoConnect !== false;
       if (_this._autoConnect) _this.open();
       return _this;
     }
-
     _createClass(Manager, [{
       key: "reconnection",
       value: function reconnection(v) {
@@ -4013,7 +3903,6 @@
       key: "reconnectionDelay",
       value: function reconnectionDelay(v) {
         var _a;
-
         if (v === undefined) return this._reconnectionDelay;
         this._reconnectionDelay = v;
         (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);
@@ -4023,7 +3912,6 @@
       key: "randomizationFactor",
       value: function randomizationFactor(v) {
         var _a;
-
         if (v === undefined) return this._randomizationFactor;
         this._randomizationFactor = v;
         (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);
@@ -4033,7 +3921,6 @@
       key: "reconnectionDelayMax",
       value: function reconnectionDelayMax(v) {
         var _a;
-
         if (v === undefined) return this._reconnectionDelayMax;
         this._reconnectionDelayMax = v;
         (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);
@@ -4052,7 +3939,6 @@
        *
        * @private
        */
-
     }, {
       key: "maybeReconnectOnOpen",
       value: function maybeReconnectOnOpen() {
@@ -4069,62 +3955,49 @@
        * @return self
        * @public
        */
-
     }, {
       key: "open",
       value: function open(fn) {
         var _this2 = this;
-
         if (~this._readyState.indexOf("open")) return this;
         this.engine = new Socket$1(this.uri, this.opts);
         var socket = this.engine;
         var self = this;
         this._readyState = "opening";
-        this.skipReconnect = false; // emit `open`
-
+        this.skipReconnect = false;
+        // emit `open`
         var openSubDestroy = on(socket, "open", function () {
           self.onopen();
           fn && fn();
-        }); // emit `error`
-
-        var errorSub = on(socket, "error", function (err) {
-          self.cleanup();
-          self._readyState = "closed";
-
+        });
+        var onError = function onError(err) {
+          _this2.cleanup();
+          _this2._readyState = "closed";
           _this2.emitReserved("error", err);
-
           if (fn) {
             fn(err);
           } else {
             // Only do this if there is no fn to handle the error
-            self.maybeReconnectOnOpen();
+            _this2.maybeReconnectOnOpen();
           }
-        });
-
+        };
+        // emit `error`
+        var errorSub = on(socket, "error", onError);
         if (false !== this._timeout) {
           var timeout = this._timeout;
-
-          if (timeout === 0) {
-            openSubDestroy(); // prevents a race condition with the 'open' event
-          } // set timer
-
-
+          // set timer
           var timer = this.setTimeoutFn(function () {
             openSubDestroy();
-            socket.close(); // @ts-ignore
-
-            socket.emit("error", new Error("timeout"));
+            onError(new Error("timeout"));
+            socket.close();
           }, timeout);
-
           if (this.opts.autoUnref) {
             timer.unref();
           }
-
-          this.subs.push(function subDestroy() {
-            clearTimeout(timer);
+          this.subs.push(function () {
+            _this2.clearTimeoutFn(timer);
           });
         }
-
         this.subs.push(openSubDestroy);
         this.subs.push(errorSub);
         return this;
@@ -4135,7 +4008,6 @@
        * @return self
        * @public
        */
-
     }, {
       key: "connect",
       value: function connect(fn) {
@@ -4146,16 +4018,15 @@
        *
        * @private
        */
-
     }, {
       key: "onopen",
       value: function onopen() {
         // clear old subs
-        this.cleanup(); // mark as open
-
+        this.cleanup();
+        // mark as open
         this._readyState = "open";
-        this.emitReserved("open"); // add new subs
-
+        this.emitReserved("open");
+        // add new subs
         var socket = this.engine;
         this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), on(this.decoder, "decoded", this.ondecoded.bind(this)));
       }
@@ -4164,7 +4035,6 @@
        *
        * @private
        */
-
     }, {
       key: "onping",
       value: function onping() {
@@ -4175,29 +4045,34 @@
        *
        * @private
        */
-
     }, {
       key: "ondata",
       value: function 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.
        *
        * @private
        */
-
     }, {
       key: "ondecoded",
       value: function ondecoded(packet) {
-        this.emitReserved("packet", packet);
+        var _this3 = this;
+        // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
+        nextTick(function () {
+          _this3.emitReserved("packet", packet);
+        }, this.setTimeoutFn);
       }
       /**
        * Called upon socket error.
        *
        * @private
        */
-
     }, {
       key: "onerror",
       value: function onerror(err) {
@@ -4209,17 +4084,16 @@
        * @return {Socket}
        * @public
        */
-
     }, {
       key: "socket",
       value: function socket(nsp, opts) {
         var socket = this.nsps[nsp];
-
         if (!socket) {
           socket = new Socket(this, nsp, opts);
           this.nsps[nsp] = socket;
+        } else if (this._autoConnect && !socket.active) {
+          socket.connect();
         }
-
         return socket;
       }
       /**
@@ -4228,21 +4102,17 @@
        * @param socket
        * @private
        */
-
     }, {
       key: "_destroy",
       value: function _destroy(socket) {
         var nsps = Object.keys(this.nsps);
-
         for (var _i = 0, _nsps = nsps; _i < _nsps.length; _i++) {
           var nsp = _nsps[_i];
           var _socket = this.nsps[nsp];
-
           if (_socket.active) {
             return;
           }
         }
-
         this._close();
       }
       /**
@@ -4251,12 +4121,10 @@
        * @param packet
        * @private
        */
-
     }, {
       key: "_packet",
       value: function _packet(packet) {
         var encodedPackets = this.encoder.encode(packet);
-
         for (var i = 0; i < encodedPackets.length; i++) {
           this.engine.write(encodedPackets[i], packet.options);
         }
@@ -4266,7 +4134,6 @@
        *
        * @private
        */
-
     }, {
       key: "cleanup",
       value: function cleanup() {
@@ -4281,7 +4148,6 @@
        *
        * @private
        */
-
     }, {
       key: "_close",
       value: function _close() {
@@ -4295,7 +4161,6 @@
        *
        * @private
        */
-
     }, {
       key: "disconnect",
       value: function disconnect() {
@@ -4306,7 +4171,6 @@
        *
        * @private
        */
-
     }, {
       key: "onclose",
       value: function onclose(reason, description) {
@@ -4314,7 +4178,6 @@
         this.backoff.reset();
         this._readyState = "closed";
         this.emitReserved("close", reason, description);
-
         if (this._reconnection && !this.skipReconnect) {
           this.reconnect();
         }
@@ -4324,15 +4187,12 @@
        *
        * @private
        */
-
     }, {
       key: "reconnect",
       value: function reconnect() {
-        var _this3 = this;
-
+        var _this4 = this;
         if (this._reconnecting || this.skipReconnect) return this;
         var self = this;
-
         if (this.backoff.attempts >= this._reconnectionAttempts) {
           this.backoff.reset();
           this.emitReserved("reconnect_failed");
@@ -4342,29 +4202,24 @@
           this._reconnecting = true;
           var timer = this.setTimeoutFn(function () {
             if (self.skipReconnect) return;
-
-            _this3.emitReserved("reconnect_attempt", self.backoff.attempts); // check again for the case socket closed in above events
-
-
+            _this4.emitReserved("reconnect_attempt", self.backoff.attempts);
+            // check again for the case socket closed in above events
             if (self.skipReconnect) return;
             self.open(function (err) {
               if (err) {
                 self._reconnecting = false;
                 self.reconnect();
-
-                _this3.emitReserved("reconnect_error", err);
+                _this4.emitReserved("reconnect_error", err);
               } else {
                 self.onreconnect();
               }
             });
           }, delay);
-
           if (this.opts.autoUnref) {
             timer.unref();
           }
-
-          this.subs.push(function subDestroy() {
-            clearTimeout(timer);
+          this.subs.push(function () {
+            _this4.clearTimeoutFn(timer);
           });
         }
       }
@@ -4373,7 +4228,6 @@
        *
        * @private
        */
-
     }, {
       key: "onreconnect",
       value: function onreconnect() {
@@ -4383,22 +4237,18 @@
         this.emitReserved("reconnect", attempt);
       }
     }]);
-
     return Manager;
   }(Emitter);
 
   /**
    * Managers cache.
    */
-
   var cache = {};
-
   function lookup(uri, opts) {
     if (_typeof(uri) === "object") {
       opts = uri;
       uri = undefined;
     }
-
     opts = opts || {};
     var parsed = url(uri, opts.path || "/socket.io");
     var source = parsed.source;
@@ -4407,26 +4257,21 @@
     var sameNamespace = cache[id] && path in cache[id]["nsps"];
     var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace;
     var io;
-
     if (newConnection) {
       io = new Manager(source, opts);
     } else {
       if (!cache[id]) {
         cache[id] = new Manager(source, opts);
       }
-
       io = cache[id];
     }
-
     if (parsed.query && !opts.query) {
       opts.query = parsed.queryKey;
     }
-
     return io.socket(parsed.path, opts);
-  } // so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
+  }
+  // so that "lookup" can be used both as a function (e.g. `io(...)`) and as a
   // namespace (e.g. `io.connect(...)`), for backward compatibility
-
-
   _extends(lookup, {
     Manager: Manager,
     Socket: Socket,