@xapp/chat-widget 1.69.0 → 1.71.0

package/dist/index.js

@@ -2304,9 +2304,9 @@ var StentorDirectChat = /** @class */ (function () {
         return __assign(__assign({}, user), { nick: user.nick || bot.nick || "Bot", displayName: user.displayName || bot.displayName || "Bot", avatarPath: user.avatarPath || bot.avatarPath });
     };
     StentorDirectChat.prototype.sendChatMsgRequest = function (serviceRequest, cb) {
-        var _a;
         return __awaiter$1(this, void 0, void 0, function () {
             var agentResponse;
+            var _a;
             return __generator$1(this, function (_b) {
                 switch (_b.label) {
                     case 0: return [4 /*yield*/, this.postMessage(serviceRequest)];
@@ -2362,10 +2362,10 @@ var StentorDirectChat = /** @class */ (function () {
     StentorDirectChat.prototype.wakeup = function () {
     };
     StentorDirectChat.prototype.postMessage = function (message) {
-        var _a, _b, _c, _d, _e;
         return __awaiter$1(this, void 0, void 0, function () {
             var request, userId, sessionId, accessToken, attributes, now, permissionRequest, expired, text, granted, userProfile, isEmail, configurableMessages, botResponse, successResult, success, fail, i, timeout, responseMessage;
             var _this = this;
+            var _a, _b, _c, _d, _e;
             return __generator$1(this, function (_f) {
                 switch (_f.label) {
                     case 0:
@@ -3375,7 +3375,7 @@ PACKET_TYPES["message"] = "4";
 PACKET_TYPES["upgrade"] = "5";
 PACKET_TYPES["noop"] = "6";
 const PACKET_TYPES_REVERSE = Object.create(null);
-Object.keys(PACKET_TYPES).forEach(key => {
+Object.keys(PACKET_TYPES).forEach((key) => {
     PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
 });
 const ERROR_PACKET = { type: "error", data: "parser error" };
@@ -3385,7 +3385,7 @@ const withNativeBlob$1 = typeof Blob === "function" ||
         Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
 const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
 // ArrayBuffer.isView method is not defined in IE10
-const isView$1 = obj => {
+const isView$1 = (obj) => {
     return typeof ArrayBuffer.isView === "function"
         ? ArrayBuffer.isView(obj)
         : obj && obj.buffer instanceof ArrayBuffer;
@@ -3419,6 +3419,33 @@ const encodeBlobAsBase64 = (data, callback) => {
     };
     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);
+    }
+}
+let 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, (encoded) => {
+        if (!TEXT_ENCODER) {
+            TEXT_ENCODER = new TextEncoder();
+        }
+        callback(TEXT_ENCODER.encode(encoded));
+    });
+}
 
 // imported from https://github.com/socketio/base64-arraybuffer
 const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
@@ -3453,14 +3480,14 @@ const decodePacket = (encodedPacket, binaryType) => {
     if (typeof encodedPacket !== "string") {
         return {
             type: "message",
-            data: mapBinary(encodedPacket, binaryType)
+            data: mapBinary(encodedPacket, binaryType),
         };
     }
     const type = encodedPacket.charAt(0);
     if (type === "b") {
         return {
             type: "message",
-            data: decodeBase64Packet(encodedPacket.substring(1), binaryType)
+            data: decodeBase64Packet(encodedPacket.substring(1), binaryType),
         };
     }
     const packetType = PACKET_TYPES_REVERSE[type];
@@ -3470,10 +3497,10 @@ const decodePacket = (encodedPacket, binaryType) => {
     return encodedPacket.length > 1
         ? {
             type: PACKET_TYPES_REVERSE[type],
-            data: encodedPacket.substring(1)
+            data: encodedPacket.substring(1),
         }
         : {
-            type: PACKET_TYPES_REVERSE[type]
+            type: PACKET_TYPES_REVERSE[type],
         };
 };
 const decodeBase64Packet = (data, binaryType) => {
@@ -3488,10 +3515,24 @@ const decodeBase64Packet = (data, binaryType) => {
 const 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;
+            }
     }
 };
 
@@ -3503,7 +3544,7 @@ const encodePayload = (packets, callback) => {
     let count = 0;
     packets.forEach((packet, i) => {
         // force base64 encoding for binary packets
-        encodePacket(packet, false, encodedPacket => {
+        encodePacket(packet, false, (encodedPacket) => {
             encodedPackets[i] = encodedPacket;
             if (++count === length) {
                 callback(encodedPackets.join(SEPARATOR));
@@ -3523,6 +3564,131 @@ const decodePayload = (encodedPayload, binaryType) => {
     }
     return packets;
 };
+function createPacketEncoderStream() {
+    // @ts-expect-error
+    return new TransformStream({
+        transform(packet, controller) {
+            encodePacketToBinary(packet, (encodedPacket) => {
+                const payloadLength = encodedPacket.length;
+                let header;
+                // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length
+                if (payloadLength < 126) {
+                    header = new Uint8Array(1);
+                    new DataView(header.buffer).setUint8(0, payloadLength);
+                }
+                else if (payloadLength < 65536) {
+                    header = new Uint8Array(3);
+                    const view = new DataView(header.buffer);
+                    view.setUint8(0, 126);
+                    view.setUint16(1, payloadLength);
+                }
+                else {
+                    header = new Uint8Array(9);
+                    const view = new DataView(header.buffer);
+                    view.setUint8(0, 127);
+                    view.setBigUint64(1, BigInt(payloadLength));
+                }
+                // first bit indicates whether the payload is plain text (0) or binary (1)
+                if (packet.data && typeof packet.data !== "string") {
+                    header[0] |= 0x80;
+                }
+                controller.enqueue(header);
+                controller.enqueue(encodedPacket);
+            });
+        },
+    });
+}
+let TEXT_DECODER;
+function totalLength(chunks) {
+    return chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+}
+function concatChunks(chunks, size) {
+    if (chunks[0].length === size) {
+        return chunks.shift();
+    }
+    const buffer = new Uint8Array(size);
+    let j = 0;
+    for (let i = 0; i < size; i++) {
+        buffer[i] = chunks[0][j++];
+        if (j === chunks[0].length) {
+            chunks.shift();
+            j = 0;
+        }
+    }
+    if (chunks.length && j < chunks[0].length) {
+        chunks[0] = chunks[0].slice(j);
+    }
+    return buffer;
+}
+function createPacketDecoderStream(maxPayload, binaryType) {
+    if (!TEXT_DECODER) {
+        TEXT_DECODER = new TextDecoder();
+    }
+    const chunks = [];
+    let state = 0 /* READ_HEADER */;
+    let expectedLength = -1;
+    let isBinary = false;
+    // @ts-expect-error
+    return new TransformStream({
+        transform(chunk, controller) {
+            chunks.push(chunk);
+            while (true) {
+                if (state === 0 /* READ_HEADER */) {
+                    if (totalLength(chunks) < 1) {
+                        break;
+                    }
+                    const header = concatChunks(chunks, 1);
+                    isBinary = (header[0] & 0x80) === 0x80;
+                    expectedLength = header[0] & 0x7f;
+                    if (expectedLength < 126) {
+                        state = 3 /* READ_PAYLOAD */;
+                    }
+                    else if (expectedLength === 126) {
+                        state = 1 /* READ_EXTENDED_LENGTH_16 */;
+                    }
+                    else {
+                        state = 2 /* READ_EXTENDED_LENGTH_64 */;
+                    }
+                }
+                else if (state === 1 /* READ_EXTENDED_LENGTH_16 */) {
+                    if (totalLength(chunks) < 2) {
+                        break;
+                    }
+                    const headerArray = concatChunks(chunks, 2);
+                    expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);
+                    state = 3 /* READ_PAYLOAD */;
+                }
+                else if (state === 2 /* READ_EXTENDED_LENGTH_64 */) {
+                    if (totalLength(chunks) < 8) {
+                        break;
+                    }
+                    const headerArray = concatChunks(chunks, 8);
+                    const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);
+                    const n = view.getUint32(0);
+                    if (n > Math.pow(2, 53 - 32) - 1) {
+                        // the maximum safe integer in JavaScript is 2^53 - 1
+                        controller.enqueue(ERROR_PACKET);
+                        break;
+                    }
+                    expectedLength = n * Math.pow(2, 32) + view.getUint32(4);
+                    state = 3 /* READ_PAYLOAD */;
+                }
+                else {
+                    if (totalLength(chunks) < expectedLength) {
+                        break;
+                    }
+                    const data = concatChunks(chunks, expectedLength);
+                    controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));
+                    state = 0 /* READ_HEADER */;
+                }
+                if (expectedLength === 0 || expectedLength > maxPayload) {
+                    controller.enqueue(ERROR_PACKET);
+                    break;
+                }
+            }
+        },
+    });
+}
 const protocol$1 = 4;
 
 /**
@@ -3722,16 +3888,16 @@ function pick(obj, ...attr) {
     }, {});
 }
 // Keep a reference to the real timeout functions so they can be used when overridden
-const NATIVE_SET_TIMEOUT = setTimeout;
-const NATIVE_CLEAR_TIMEOUT = clearTimeout;
+const NATIVE_SET_TIMEOUT = globalThisShim.setTimeout;
+const NATIVE_CLEAR_TIMEOUT = globalThisShim.clearTimeout;
 function installTimerFunctions(obj, opts) {
     if (opts.useNativeTimers) {
         obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThisShim);
         obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThisShim);
     }
     else {
-        obj.setTimeoutFn = setTimeout.bind(globalThisShim);
-        obj.clearTimeoutFn = clearTimeout.bind(globalThisShim);
+        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)
@@ -3765,6 +3931,41 @@ function utf8Length(str) {
     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) {
+    let str = '';
+    for (let 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) {
+    let qry = {};
+    let pairs = qs.split('&');
+    for (let i = 0, l = pairs.length; i < l; i++) {
+        let pair = pairs[i].split('=');
+        qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
+    }
+    return qry;
+}
+
 class TransportError extends Error {
     constructor(reason, description, context) {
         super(reason);
@@ -3777,8 +3978,8 @@ class Transport extends Emitter_1 {
     /**
      * Transport abstract constructor.
      *
-     * @param {Object} options.
-     * @api private
+     * @param {Object} opts - options
+     * @protected
      */
     constructor(opts) {
         super();
@@ -3786,7 +3987,6 @@ class Transport extends Emitter_1 {
         installTimerFunctions(this, opts);
         this.opts = opts;
         this.query = opts.query;
-        this.readyState = "";
         this.socket = opts.socket;
     }
     /**
@@ -3796,7 +3996,7 @@ class Transport extends Emitter_1 {
      * @param description
      * @param context - the error context
      * @return {Transport} for chaining
-     * @api protected
+     * @protected
      */
     onError(reason, description, context) {
         super.emitReserved("error", new TransportError(reason, description, context));
@@ -3804,23 +4004,17 @@ class Transport extends Emitter_1 {
     }
     /**
      * Opens the transport.
-     *
-     * @api public
      */
     open() {
-        if ("closed" === this.readyState || "" === this.readyState) {
-            this.readyState = "opening";
-            this.doOpen();
-        }
+        this.readyState = "opening";
+        this.doOpen();
         return this;
     }
     /**
      * Closes the transport.
-     *
-     * @api public
      */
     close() {
-        if ("opening" === this.readyState || "open" === this.readyState) {
+        if (this.readyState === "opening" || this.readyState === "open") {
             this.doClose();
             this.onClose();
         }
@@ -3830,17 +4024,16 @@ class Transport extends Emitter_1 {
      * Sends multiple packets.
      *
      * @param {Array} packets
-     * @api public
      */
     send(packets) {
-        if ("open" === this.readyState) {
+        if (this.readyState === "open") {
             this.write(packets);
         }
     }
     /**
      * Called upon open
      *
-     * @api protected
+     * @protected
      */
     onOpen() {
         this.readyState = "open";
@@ -3851,7 +4044,7 @@ class Transport extends Emitter_1 {
      * Called with data.
      *
      * @param {String} data
-     * @api protected
+     * @protected
      */
     onData(data) {
         const packet = decodePacket(data, this.socket.binaryType);
@@ -3860,7 +4053,7 @@ class Transport extends Emitter_1 {
     /**
      * Called with a decoded packet.
      *
-     * @api protected
+     * @protected
      */
     onPacket(packet) {
         super.emitReserved("packet", packet);
@@ -3868,12 +4061,44 @@ class Transport extends Emitter_1 {
     /**
      * Called upon close.
      *
-     * @api protected
+     * @protected
      */
     onClose(details) {
         this.readyState = "closed";
         super.emitReserved("close", details);
     }
+    /**
+     * Pauses the transport, in order not to lose packets during an upgrade.
+     *
+     * @param onPause
+     */
+    pause(onPause) { }
+    createUri(schema, query = {}) {
+        return (schema +
+            "://" +
+            this._hostname() +
+            this._port() +
+            this.opts.path +
+            this._query(query));
+    }
+    _hostname() {
+        const hostname = this.opts.hostname;
+        return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
+    }
+    _port() {
+        if (this.opts.port &&
+            ((this.opts.secure && Number(this.opts.port !== 443)) ||
+                (!this.opts.secure && Number(this.opts.port) !== 80))) {
+            return ":" + this.opts.port;
+        }
+        else {
+            return "";
+        }
+    }
+    _query(query) {
+        const encodedQuery = encode$1(query);
+        return encodedQuery.length ? "?" + encodedQuery : "";
+    }
 }
 
 // imported from https://github.com/unshiftio/yeast
@@ -3886,7 +4111,7 @@ let seed = 0, i = 0, prev;
  * @returns {String} The string representation of the number.
  * @api public
  */
-function encode$1(num) {
+function encode(num) {
     let encoded = '';
     do {
         encoded = alphabet[num % length] + encoded;
@@ -3901,10 +4126,10 @@ function encode$1(num) {
  * @api public
  */
 function yeast() {
-    const now = encode$1(+new Date());
+    const 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.
@@ -3912,41 +4137,6 @@ function yeast() {
 for (; i < length; i++)
     map[alphabet[i]] = i;
 
-// imported from https://github.com/galkn/querystring
-/**
- * Compiles a querystring
- * Returns string representation of the object
- *
- * @param {Object}
- * @api private
- */
-function encode(obj) {
-    let str = '';
-    for (let i in obj) {
-        if (obj.hasOwnProperty(i)) {
-            if (str.length)
-                str += '&';
-            str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);
-        }
-    }
-    return str;
-}
-/**
- * Parses a simple querystring into an object
- *
- * @param {String} qs
- * @api private
- */
-function decode(qs) {
-    let qry = {};
-    let pairs = qs.split('&');
-    for (let i = 0, l = pairs.length; i < l; i++) {
-        let pair = pairs[i].split('=');
-        qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
-    }
-    return qry;
-}
-
 // imported from https://github.com/component/has-cors
 let value = false;
 try {
@@ -3976,11 +4166,12 @@ function XHR(opts) {
         catch (e) { }
     }
 }
+function createCookieJar() { }
 
 function empty$2() { }
 const hasXHR2 = (function () {
     const xhr = new XHR({
-        xdomain: false
+        xdomain: false,
     });
     return null != xhr.responseType;
 })();
@@ -3989,7 +4180,7 @@ class Polling extends Transport {
      * XHR Polling constructor.
      *
      * @param {Object} opts
-     * @api public
+     * @package
      */
     constructor(opts) {
         super(opts);
@@ -4005,17 +4196,16 @@ class Polling extends Transport {
                 (typeof location !== "undefined" &&
                     opts.hostname !== location.hostname) ||
                     port !== opts.port;
-            this.xs = opts.secure !== isSSL;
         }
         /**
          * XHR supports binary
          */
         const forceBase64 = opts && opts.forceBase64;
         this.supportsBinary = hasXHR2 && !forceBase64;
+        if (this.opts.withCredentials) {
+            this.cookieJar = createCookieJar();
+        }
     }
-    /**
-     * Transport name.
-     */
     get name() {
         return "polling";
     }
@@ -4023,7 +4213,7 @@ class Polling extends Transport {
      * Opens the socket (triggers polling). We write a PING message to determine
      * when the transport is open.
      *
-     * @api private
+     * @protected
      */
     doOpen() {
         this.poll();
@@ -4031,8 +4221,8 @@ class Polling extends Transport {
     /**
      * Pauses polling.
      *
-     * @param {Function} callback upon buffers are flushed and transport is paused
-     * @api private
+     * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+     * @package
      */
     pause(onPause) {
         this.readyState = "pausing";
@@ -4062,7 +4252,7 @@ class Polling extends Transport {
     /**
      * Starts polling cycle.
      *
-     * @api public
+     * @private
      */
     poll() {
         this.polling = true;
@@ -4072,10 +4262,10 @@ class Polling extends Transport {
     /**
      * Overloads onData to detect payloads.
      *
-     * @api private
+     * @protected
      */
     onData(data) {
-        const callback = packet => {
+        const callback = (packet) => {
             // if its the first message we consider the transport open
             if ("opening" === this.readyState && packet.type === "open") {
                 this.onOpen();
@@ -4103,7 +4293,7 @@ class Polling extends Transport {
     /**
      * For polling, send a close packet.
      *
-     * @api private
+     * @protected
      */
     doClose() {
         const close = () => {
@@ -4121,13 +4311,12 @@ class Polling extends Transport {
     /**
      * Writes a packets payload.
      *
-     * @param {Array} data packets
-     * @param {Function} drain callback
-     * @api private
+     * @param {Array} packets - data packets
+     * @protected
      */
     write(packets) {
         this.writable = false;
-        encodePayload(packets, data => {
+        encodePayload(packets, (data) => {
             this.doWrite(data, () => {
                 this.writable = true;
                 this.emitReserved("drain");
@@ -4137,12 +4326,11 @@ class Polling extends Transport {
     /**
      * Generates uri for connection.
      *
-     * @api private
+     * @private
      */
     uri() {
-        let query = this.query || {};
         const schema = this.opts.secure ? "https" : "http";
-        let port = "";
+        const query = this.query || {};
         // cache busting is forced
         if (false !== this.opts.timestampRequests) {
             query[this.opts.timestampParam] = yeast();
@@ -4150,29 +4338,16 @@ class Polling extends Transport {
         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;
-        }
-        const encodedQuery = encode(query);
-        const 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
      */
     request(opts = {}) {
-        Object.assign(opts, { xd: this.xd, xs: this.xs }, this.opts);
+        Object.assign(opts, { xd: this.xd, cookieJar: this.cookieJar }, this.opts);
         return new Request(this.uri(), opts);
     }
     /**
@@ -4180,12 +4355,12 @@ class Polling extends Transport {
      *
      * @param {String} data to send.
      * @param {Function} called upon flush.
-     * @api private
+     * @private
      */
     doWrite(data, fn) {
         const req = this.request({
             method: "POST",
-            data: data
+            data: data,
         });
         req.on("success", fn);
         req.on("error", (xhrStatus, context) => {
@@ -4195,7 +4370,7 @@ class Polling extends Transport {
     /**
      * Starts a poll cycle.
      *
-     * @api private
+     * @private
      */
     doPoll() {
         const req = this.request();
@@ -4211,7 +4386,7 @@ class Request extends Emitter_1 {
      * Request constructor
      *
      * @param {Object} options
-     * @api public
+     * @package
      */
     constructor(uri, opts) {
         super();
@@ -4219,22 +4394,21 @@ class Request extends Emitter_1 {
         this.opts = opts;
         this.method = opts.method || "GET";
         this.uri = uri;
-        this.async = false !== opts.async;
         this.data = undefined !== opts.data ? opts.data : null;
         this.create();
     }
     /**
      * Creates the XHR object and sends the request.
      *
-     * @api private
+     * @private
      */
     create() {
+        var _a;
         const opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
         opts.xdomain = !!this.opts.xd;
-        opts.xscheme = !!this.opts.xs;
         const xhr = (this.xhr = new 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);
@@ -4256,6 +4430,7 @@ class Request extends Emitter_1 {
                 xhr.setRequestHeader("Accept", "*/*");
             }
             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;
@@ -4264,6 +4439,10 @@ class Request extends Emitter_1 {
                 xhr.timeout = this.opts.requestTimeout;
             }
             xhr.onreadystatechange = () => {
+                var _a;
+                if (xhr.readyState === 3) {
+                    (_a = this.opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(xhr);
+                }
                 if (4 !== xhr.readyState)
                     return;
                 if (200 === xhr.status || 1223 === xhr.status) {
@@ -4296,7 +4475,7 @@ class Request extends Emitter_1 {
     /**
      * Called upon error.
      *
-     * @api private
+     * @private
      */
     onError(err) {
         this.emitReserved("error", err, this.xhr);
@@ -4305,7 +4484,7 @@ class Request extends Emitter_1 {
     /**
      * Cleans up house.
      *
-     * @api private
+     * @private
      */
     cleanup(fromError) {
         if ("undefined" === typeof this.xhr || null === this.xhr) {
@@ -4326,7 +4505,7 @@ class Request extends Emitter_1 {
     /**
      * Called upon load.
      *
-     * @api private
+     * @private
      */
     onLoad() {
         const data = this.xhr.responseText;
@@ -4339,7 +4518,7 @@ class Request extends Emitter_1 {
     /**
      * Aborts the request.
      *
-     * @api public
+     * @package
      */
     abort() {
         this.cleanup();
@@ -4374,7 +4553,7 @@ function unloadHandler() {
 const nextTick = (() => {
     const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
     if (isPromiseAvailable) {
-        return cb => Promise.resolve().then(cb);
+        return (cb) => Promise.resolve().then(cb);
     }
     else {
         return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
@@ -4392,26 +4571,16 @@ class WS extends Transport {
     /**
      * WebSocket transport constructor.
      *
-     * @api {Object} connection options
-     * @api public
+     * @param {Object} opts - connection options
+     * @protected
      */
     constructor(opts) {
         super(opts);
         this.supportsBinary = !opts.forceBase64;
     }
-    /**
-     * Transport name.
-     *
-     * @api public
-     */
     get name() {
         return "websocket";
     }
-    /**
-     * Opens socket.
-     *
-     * @api private
-     */
     doOpen() {
         if (!this.check()) {
             // let probe timeout
@@ -4437,13 +4606,13 @@ class WS extends Transport {
         catch (err) {
             return this.emitReserved("error", err);
         }
-        this.ws.binaryType = this.socket.binaryType || defaultBinaryType;
+        this.ws.binaryType = this.socket.binaryType;
         this.addEventListeners();
     }
     /**
      * Adds event listeners to the socket
      *
-     * @api private
+     * @private
      */
     addEventListeners() {
         this.ws.onopen = () => {
@@ -4452,19 +4621,13 @@ class WS extends Transport {
             }
             this.onOpen();
         };
-        this.ws.onclose = closeEvent => this.onClose({
+        this.ws.onclose = (closeEvent) => this.onClose({
             description: "websocket connection closed",
-            context: closeEvent
+            context: closeEvent,
         });
-        this.ws.onmessage = ev => this.onData(ev.data);
-        this.ws.onerror = e => this.onError("websocket error", e);
+        this.ws.onmessage = (ev) => this.onData(ev.data);
+        this.ws.onerror = (e) => this.onError("websocket error", e);
     }
-    /**
-     * Writes data to socket.
-     *
-     * @param {Array} array of packets.
-     * @api private
-     */
     write(packets) {
         this.writable = false;
         // encodePacket efficient as it uses WS framing
@@ -4472,7 +4635,7 @@ class WS extends Transport {
         for (let i = 0; i < packets.length; i++) {
             const packet = packets[i];
             const lastPacket = i === packets.length - 1;
-            encodePacket(packet, this.supportsBinary, data => {
+            encodePacket(packet, this.supportsBinary, (data) => {
                 // always create a new object (GH-437)
                 const opts = {};
                 // Sometimes the websocket has already been closed but the browser didn't
@@ -4497,11 +4660,6 @@ class WS extends Transport {
             });
         }
     }
-    /**
-     * Closes socket.
-     *
-     * @api private
-     */
     doClose() {
         if (typeof this.ws !== "undefined") {
             this.ws.close();
@@ -4511,18 +4669,11 @@ class WS extends Transport {
     /**
      * Generates uri for connection.
      *
-     * @api private
+     * @private
      */
     uri() {
-        let query = this.query || {};
         const schema = this.opts.secure ? "wss" : "ws";
-        let 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;
-        }
+        const query = this.query || {};
         // append timestamp to URI
         if (this.opts.timestampRequests) {
             query[this.opts.timestampParam] = yeast();
@@ -4531,43 +4682,121 @@ class WS extends Transport {
         if (!this.supportsBinary) {
             query.b64 = 1;
         }
-        const encodedQuery = encode(query);
-        const 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
      */
     check() {
         return !!WebSocket$1;
     }
 }
 
+class WT extends Transport {
+    get name() {
+        return "webtransport";
+    }
+    doOpen() {
+        // @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(() => {
+            this.onClose();
+        })
+            .catch((err) => {
+            this.onError("webtransport error", err);
+        });
+        // note: we could have used async/await, but that would require some additional polyfills
+        this.transport.ready.then(() => {
+            this.transport.createBidirectionalStream().then((stream) => {
+                const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);
+                const reader = stream.readable.pipeThrough(decoderStream).getReader();
+                const encoderStream = createPacketEncoderStream();
+                encoderStream.readable.pipeTo(stream.writable);
+                this.writer = encoderStream.writable.getWriter();
+                const read = () => {
+                    reader
+                        .read()
+                        .then(({ done, value }) => {
+                        if (done) {
+                            return;
+                        }
+                        this.onPacket(value);
+                        read();
+                    })
+                        .catch((err) => {
+                    });
+                };
+                read();
+                const packet = { type: "open" };
+                if (this.query.sid) {
+                    packet.data = `{"sid":"${this.query.sid}"}`;
+                }
+                this.writer.write(packet).then(() => this.onOpen());
+            });
+        });
+    }
+    write(packets) {
+        this.writable = false;
+        for (let i = 0; i < packets.length; i++) {
+            const packet = packets[i];
+            const lastPacket = i === packets.length - 1;
+            this.writer.write(packet).then(() => {
+                if (lastPacket) {
+                    nextTick(() => {
+                        this.writable = true;
+                        this.emitReserved("drain");
+                    }, this.setTimeoutFn);
+                }
+            });
+        }
+    }
+    doClose() {
+        var _a;
+        (_a = this.transport) === null || _a === void 0 ? void 0 : _a.close();
+    }
+}
+
 const transports = {
     websocket: WS,
-    polling: Polling
+    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
  */
-const re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
 const parts = [
     'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
 ];
 function parse$2(str) {
+    if (str.length > 2000) {
+        throw "URI too long";
+    }
     const src = str, b = str.indexOf('['), e = str.indexOf(']');
     if (b != -1 && e != -1) {
         str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);
@@ -4610,12 +4839,13 @@ class Socket$1 extends Emitter_1 {
     /**
      * Socket constructor.
      *
-     * @param {String|Object} uri or options
+     * @param {String|Object} uri - uri or options
      * @param {Object} opts - options
-     * @api public
      */
     constructor(uri, opts = {}) {
         super();
+        this.binaryType = defaultBinaryType;
+        this.writeBuffer = [];
         if (uri && "object" === typeof uri) {
             opts = uri;
             uri = null;
@@ -4650,8 +4880,11 @@ class Socket$1 extends Emitter_1 {
                     : 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 = Object.assign({
@@ -4661,14 +4894,17 @@ class Socket$1 extends Emitter_1 {
             upgrade: true,
             timestampParam: "t",
             rememberUpgrade: false,
+            addTrailingSlash: true,
             rejectUnauthorized: true,
             perMessageDeflate: {
-                threshold: 1024
+                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);
         }
@@ -4696,7 +4932,7 @@ class Socket$1 extends Emitter_1 {
             if (this.hostname !== "localhost") {
                 this.offlineEventListener = () => {
                     this.onClose("transport close", {
-                        description: "network connection lost"
+                        description: "network connection lost",
                     });
                 };
                 addEventListener("offline", this.offlineEventListener, false);
@@ -4707,9 +4943,9 @@ class Socket$1 extends Emitter_1 {
     /**
      * Creates transport of the given type.
      *
-     * @param {String} transport name
+     * @param {String} name - transport name
      * @return {Transport}
-     * @api private
+     * @private
      */
     createTransport(name) {
         const query = Object.assign({}, this.opts.query);
@@ -4720,19 +4956,19 @@ class Socket$1 extends Emitter_1 {
         // session id if we already have one
         if (this.id)
             query.sid = this.id;
-        const opts = Object.assign({}, this.opts.transportOptions[name], this.opts, {
+        const opts = Object.assign({}, this.opts, {
             query,
             socket: this,
             hostname: this.hostname,
             secure: this.secure,
-            port: this.port
-        });
+            port: this.port,
+        }, this.opts.transportOptions[name]);
         return new transports[name](opts);
     }
     /**
      * Initializes transport to use and starts probe.
      *
-     * @api private
+     * @private
      */
     open() {
         let transport;
@@ -4767,7 +5003,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Sets the current transport. Disables the existing one (if any).
      *
-     * @api private
+     * @private
      */
     setTransport(transport) {
         if (this.transport) {
@@ -4780,13 +5016,13 @@ class Socket$1 extends Emitter_1 {
             .on("drain", this.onDrain.bind(this))
             .on("packet", this.onPacket.bind(this))
             .on("error", this.onError.bind(this))
-            .on("close", reason => this.onClose("transport close", reason));
+            .on("close", (reason) => this.onClose("transport close", reason));
     }
     /**
      * Probes a transport.
      *
-     * @param {String} transport name
-     * @api private
+     * @param {String} name - transport name
+     * @private
      */
     probe(name) {
         let transport = this.createTransport(name);
@@ -4796,7 +5032,7 @@ class Socket$1 extends Emitter_1 {
             if (failed)
                 return;
             transport.send([{ type: "ping", data: "probe" }]);
-            transport.once("packet", msg => {
+            transport.once("packet", (msg) => {
                 if (failed)
                     return;
                 if ("pong" === msg.type && "probe" === msg.data) {
@@ -4837,7 +5073,7 @@ class Socket$1 extends Emitter_1 {
             transport = null;
         }
         // Handle any error that happens while probing
-        const onerror = err => {
+        const onerror = (err) => {
             const error = new Error("probe error: " + err);
             // @ts-ignore
             error.transport = transport.name;
@@ -4870,12 +5106,23 @@ class Socket$1 extends Emitter_1 {
         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(() => {
+                if (!failed) {
+                    transport.open();
+                }
+            }, 200);
+        }
+        else {
+            transport.open();
+        }
     }
     /**
      * Called when connection is deemed open.
      *
-     * @api private
+     * @private
      */
     onOpen() {
         this.readyState = "open";
@@ -4884,9 +5131,7 @@ class Socket$1 extends Emitter_1 {
         this.flush();
         // we check for `readyState` in case an `open`
         // listener already closed the socket
-        if ("open" === this.readyState &&
-            this.opts.upgrade &&
-            this.transport.pause) {
+        if ("open" === this.readyState && this.opts.upgrade) {
             let i = 0;
             const l = this.upgrades.length;
             for (; i < l; i++) {
@@ -4897,7 +5142,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Handles a packet.
      *
-     * @api private
+     * @private
      */
     onPacket(packet) {
         if ("opening" === this.readyState ||
@@ -4906,12 +5151,12 @@ class Socket$1 extends Emitter_1 {
             this.emitReserved("packet", packet);
             // Socket is live - any packet counts
             this.emitReserved("heartbeat");
+            this.resetPingTimeout();
             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");
@@ -4933,7 +5178,7 @@ class Socket$1 extends Emitter_1 {
      * Called upon handshake completion.
      *
      * @param {Object} data - handshake obj
-     * @api private
+     * @private
      */
     onHandshake(data) {
         this.emitReserved("handshake", data);
@@ -4952,7 +5197,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Sets and resets ping timeout timer based on server pings.
      *
-     * @api private
+     * @private
      */
     resetPingTimeout() {
         this.clearTimeoutFn(this.pingTimeoutTimer);
@@ -4966,7 +5211,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Called on `drain` event
      *
-     * @api private
+     * @private
      */
     onDrain() {
         this.writeBuffer.splice(0, this.prevBufferLen);
@@ -4984,7 +5229,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Flush write buffers.
      *
-     * @api private
+     * @private
      */
     flush() {
         if ("closed" !== this.readyState &&
@@ -5028,11 +5273,10 @@ class Socket$1 extends Emitter_1 {
     /**
      * Sends a message.
      *
-     * @param {String} message.
-     * @param {Function} callback function.
+     * @param {String} msg - message.
      * @param {Object} options.
+     * @param {Function} callback function.
      * @return {Socket} for chaining.
-     * @api public
      */
     write(msg, options, fn) {
         this.sendPacket("message", msg, options, fn);
@@ -5045,11 +5289,11 @@ class Socket$1 extends Emitter_1 {
     /**
      * Sends a packet.
      *
-     * @param {String} packet type.
+     * @param {String} type: packet type.
      * @param {String} data.
      * @param {Object} options.
-     * @param {Function} callback function.
-     * @api private
+     * @param {Function} fn - callback function.
+     * @private
      */
     sendPacket(type, data, options, fn) {
         if ("function" === typeof data) {
@@ -5068,7 +5312,7 @@ class Socket$1 extends Emitter_1 {
         const packet = {
             type: type,
             data: data,
-            options: options
+            options: options,
         };
         this.emitReserved("packetCreate", packet);
         this.writeBuffer.push(packet);
@@ -5078,8 +5322,6 @@ class Socket$1 extends Emitter_1 {
     }
     /**
      * Closes the connection.
-     *
-     * @api public
      */
     close() {
         const close = () => {
@@ -5120,7 +5362,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Called upon transport error
      *
-     * @api private
+     * @private
      */
     onError(err) {
         Socket$1.priorWebsocketSuccess = false;
@@ -5130,7 +5372,7 @@ class Socket$1 extends Emitter_1 {
     /**
      * Called upon transport close.
      *
-     * @api private
+     * @private
      */
     onClose(reason, description) {
         if ("opening" === this.readyState ||
@@ -5163,9 +5405,8 @@ class Socket$1 extends Emitter_1 {
     /**
      * Filters upgrades, returning only those matching client transports.
      *
-     * @param {Array} server upgrades
-     * @api private
-     *
+     * @param {Array} upgrades - server upgrades
+     * @private
      */
     filterUpgrades(upgrades) {
         const filteredUpgrades = [];
@@ -5375,6 +5616,17 @@ function _reconstructPacket(data, buffers) {
     return data;
 }
 
+/**
+ * These strings must not be used as event names, as they have a special meaning.
+ */
+const RESERVED_EVENTS$1 = [
+    "connect",
+    "connect_error",
+    "disconnect",
+    "disconnecting",
+    "newListener",
+    "removeListener", // used by the Node.js EventEmitter
+];
 /**
  * Protocol version.
  *
@@ -5463,6 +5715,10 @@ class Encoder {
         return buffers; // write all the buffers
     }
 }
+// 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
  *
@@ -5602,14 +5858,17 @@ class Decoder extends Emitter_1 {
     static 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);
@@ -5694,18 +5953,100 @@ const RESERVED_EVENTS = Object.freeze({
     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}`);
+ * });
+ */
 class Socket extends Emitter_1 {
     /**
      * `Socket` constructor.
-     *
-     * @public
      */
     constructor(io, nsp, opts) {
         super();
+        /**
+         * Whether the socket is currently connected to the server.
+         *
+         * @example
+         * const socket = io();
+         *
+         * socket.on("connect", () => {
+         *   console.log(socket.connected); // true
+         * });
+         *
+         * socket.on("disconnect", () => {
+         *   console.log(socket.connected); // false
+         * });
+         */
         this.connected = false;
+        /**
+         * 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;
+        /**
+         * A map containing acknowledgement handlers.
+         *
+         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:
+         *
+         * - `socket.emit("test", (err, value) => { ... })` with `ackTimeout` option
+         * - `socket.timeout(5000).emit("test", (err, value) => { ... })`
+         * - `const value = await socket.emitWithAck("test")`
+         *
+         * From those that don't:
+         *
+         * - `socket.emit("test", (value) => { ... });`
+         *
+         * In the first case, the handlers will be called with an error when:
+         *
+         * - the timeout is reached
+         * - the socket gets disconnected
+         *
+         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive
+         * an acknowledgement from the server.
+         *
+         * @private
+         */
         this.acks = {};
         this.flags = {};
         this.io = io;
@@ -5713,11 +6054,23 @@ class Socket extends Emitter_1 {
         if (opts && opts.auth) {
             this.auth = opts.auth;
         }
+        this._opts = Object.assign({}, opts);
         if (this.io._autoConnect)
             this.open();
     }
     /**
      * Whether the socket is currently disconnected
+     *
+     * @example
+     * const socket = io();
+     *
+     * socket.on("connect", () => {
+     *   console.log(socket.disconnected); // false
+     * });
+     *
+     * socket.on("disconnect", () => {
+     *   console.log(socket.disconnected); // true
+     * });
      */
     get disconnected() {
         return !this.connected;
@@ -5739,7 +6092,21 @@ class Socket extends Emitter_1 {
         ];
     }
     /**
-     * Whether the Socket will try to reconnect when its Manager connects or reconnects
+     * Whether the Socket will try to reconnect when its Manager connects or reconnects.
+     *
+     * @example
+     * const socket = io();
+     *
+     * console.log(socket.active); // true
+     *
+     * socket.on("disconnect", (reason) => {
+     *   if (reason === "io server disconnect") {
+     *     // the disconnection was initiated by the server, you need to manually reconnect
+     *     console.log(socket.active); // false
+     *   }
+     *   // else the socket will automatically try to reconnect
+     *   console.log(socket.active); // true
+     * });
      */
     get active() {
         return !!this.subs;
@@ -5747,7 +6114,12 @@ class Socket extends Emitter_1 {
     /**
      * "Opens" the socket.
      *
-     * @public
+     * @example
+     * const socket = io({
+     *   autoConnect: false
+     * });
+     *
+     * socket.connect();
      */
     connect() {
         if (this.connected)
@@ -5760,7 +6132,7 @@ class Socket extends Emitter_1 {
         return this;
     }
     /**
-     * Alias for connect()
+     * Alias for {@link connect()}.
      */
     open() {
         return this.connect();
@@ -5768,8 +6140,17 @@ class Socket extends Emitter_1 {
     /**
      * Sends a `message` event.
      *
+     * This method mimics the WebSocket.send() method.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+     *
+     * @example
+     * socket.send("hello");
+     *
+     * // this is equivalent to
+     * socket.emit("message", "hello");
+     *
      * @return self
-     * @public
      */
     send(...args) {
         args.unshift("message");
@@ -5780,14 +6161,28 @@ class Socket extends Emitter_1 {
      * Override `emit`.
      * If the event is in `events`, it's emitted normally.
      *
+     * @example
+     * socket.emit("hello", "world");
+     *
+     * // all serializable datastructures are supported (no need to call JSON.stringify)
+     * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+     *
+     * // with an acknowledgement from the server
+     * socket.emit("hello", "world", (val) => {
+     *   // ...
+     * });
+     *
      * @return self
-     * @public
      */
     emit(ev, ...args) {
         if (RESERVED_EVENTS.hasOwnProperty(ev)) {
-            throw new Error('"' + ev + '" is a reserved event name');
+            throw new Error('"' + ev.toString() + '" is a reserved event name');
         }
         args.unshift(ev);
+        if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
+            this._addToQueue(args);
+            return this;
+        }
         const packet = {
             type: PacketType.EVENT,
             data: args,
@@ -5820,7 +6215,8 @@ class Socket extends Emitter_1 {
      * @private
      */
     _registerAckCallback(id, ack) {
-        const timeout = this.flags.timeout;
+        var _a;
+        const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
         if (timeout === undefined) {
             this.acks[id] = ack;
             return;
@@ -5835,11 +6231,101 @@ class Socket extends Emitter_1 {
             }
             ack.call(this, new Error("operation has timed out"));
         }, timeout);
-        this.acks[id] = (...args) => {
+        const fn = (...args) => {
             // @ts-ignore
             this.io.clearTimeoutFn(timer);
-            ack.apply(this, [null, ...args]);
+            ack.apply(this, args);
+        };
+        fn.withError = true;
+        this.acks[id] = fn;
+    }
+    /**
+     * Emits an event and waits for an acknowledgement
+     *
+     * @example
+     * // without timeout
+     * const response = await socket.emitWithAck("hello", "world");
+     *
+     * // with a specific timeout
+     * try {
+     *   const response = await socket.timeout(1000).emitWithAck("hello", "world");
+     * } catch (err) {
+     *   // the server did not acknowledge the event in the given delay
+     * }
+     *
+     * @return a Promise that will be fulfilled when the server acknowledges the event
+     */
+    emitWithAck(ev, ...args) {
+        return new Promise((resolve, reject) => {
+            const fn = (arg1, arg2) => {
+                return arg1 ? reject(arg1) : resolve(arg2);
+            };
+            fn.withError = true;
+            args.push(fn);
+            this.emit(ev, ...args);
+        });
+    }
+    /**
+     * Add the packet to the queue.
+     * @param args
+     * @private
+     */
+    _addToQueue(args) {
+        let ack;
+        if (typeof args[args.length - 1] === "function") {
+            ack = args.pop();
+        }
+        const packet = {
+            id: this._queueSeq++,
+            tryCount: 0,
+            pending: false,
+            args,
+            flags: Object.assign({ fromQueue: true }, this.flags),
         };
+        args.push((err, ...responseArgs) => {
+            if (packet !== this._queue[0]) {
+                // the packet has already been acknowledged
+                return;
+            }
+            const hasError = err !== null;
+            if (hasError) {
+                if (packet.tryCount > this._opts.retries) {
+                    this._queue.shift();
+                    if (ack) {
+                        ack(err);
+                    }
+                }
+            }
+            else {
+                this._queue.shift();
+                if (ack) {
+                    ack(null, ...responseArgs);
+                }
+            }
+            packet.pending = false;
+            return this._drainQueue();
+        });
+        this._queue.push(packet);
+        this._drainQueue();
+    }
+    /**
+     * Send the first packet of the queue, and wait for an acknowledgement from the server.
+     * @param force - whether to resend a packet that has not been acknowledged yet
+     *
+     * @private
+     */
+    _drainQueue(force = false) {
+        if (!this.connected || this._queue.length === 0) {
+            return;
+        }
+        const packet = this._queue[0];
+        if (packet.pending && !force) {
+            return;
+        }
+        packet.pending = true;
+        packet.tryCount++;
+        this.flags = packet.flags;
+        this.emit.apply(this, packet.args);
     }
     /**
      * Sends a packet.
@@ -5859,13 +6345,27 @@ class Socket extends Emitter_1 {
     onopen() {
         if (typeof this.auth == "function") {
             this.auth((data) => {
-                this.packet({ type: PacketType.CONNECT, data });
+                this._sendConnectPacket(data);
             });
         }
         else {
-            this.packet({ type: PacketType.CONNECT, data: this.auth });
+            this._sendConnectPacket(this.auth);
         }
     }
+    /**
+     * Sends a CONNECT packet to initiate the Socket.IO session.
+     *
+     * @param data
+     * @private
+     */
+    _sendConnectPacket(data) {
+        this.packet({
+            type: PacketType.CONNECT,
+            data: this._pid
+                ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
+                : data,
+        });
+    }
     /**
      * Called upon engine or manager `error`.
      *
@@ -5888,6 +6388,26 @@ class Socket extends Emitter_1 {
         this.connected = false;
         delete this.id;
         this.emitReserved("disconnect", reason, description);
+        this._clearAcks();
+    }
+    /**
+     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from
+     * the server.
+     *
+     * @private
+     */
+    _clearAcks() {
+        Object.keys(this.acks).forEach((id) => {
+            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);
+            if (!isBuffered) {
+                // note: handlers that do not accept an error as first argument are ignored here
+                const ack = this.acks[id];
+                delete this.acks[id];
+                if (ack.withError) {
+                    ack.call(this, new Error("socket has been disconnected"));
+                }
+            }
+        });
     }
     /**
      * Called with socket packet.
@@ -5902,8 +6422,7 @@ class Socket extends Emitter_1 {
         switch (packet.type) {
             case PacketType.CONNECT:
                 if (packet.data && packet.data.sid) {
-                    const id = packet.data.sid;
-                    this.onconnect(id);
+                    this.onconnect(packet.data.sid, packet.data.pid);
                 }
                 else {
                     this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
@@ -5955,6 +6474,9 @@ class Socket extends Emitter_1 {
             }
         }
         super.emit.apply(this, args);
+        if (this._pid && args.length && typeof args[args.length - 1] === "string") {
+            this._lastOffset = args[args.length - 1];
+        }
     }
     /**
      * Produces an ack callback to emit with an event.
@@ -5977,28 +6499,37 @@ class Socket extends Emitter_1 {
         };
     }
     /**
-     * Called upon a server acknowlegement.
+     * Called upon a server acknowledgement.
      *
      * @param packet
      * @private
      */
     onack(packet) {
         const ack = this.acks[packet.id];
-        if ("function" === typeof ack) {
-            ack.apply(this, packet.data);
-            delete this.acks[packet.id];
+        if (typeof ack !== "function") {
+            return;
+        }
+        delete this.acks[packet.id];
+        // @ts-ignore FIXME ack is incorrectly inferred as 'never'
+        if (ack.withError) {
+            packet.data.unshift(null);
         }
+        // @ts-ignore
+        ack.apply(this, packet.data);
     }
     /**
      * Called upon server connect.
      *
      * @private
      */
-    onconnect(id) {
+    onconnect(id, pid) {
         this.id = id;
+        this.recovered = pid && this._pid === pid;
+        this._pid = pid; // defined only if connection state recovery is enabled
         this.connected = true;
         this.emitBuffered();
         this.emitReserved("connect");
+        this._drainQueue(true);
     }
     /**
      * Emit buffered events (received and emitted).
@@ -6039,10 +6570,20 @@ class Socket extends Emitter_1 {
         this.io["_destroy"](this);
     }
     /**
-     * Disconnects the socket manually.
+     * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+     *
+     * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+     *
+     * @example
+     * const socket = io();
+     *
+     * socket.on("disconnect", (reason) => {
+     *   // console.log(reason); prints "io client disconnect"
+     * });
+     *
+     * socket.disconnect();
      *
      * @return self
-     * @public
      */
     disconnect() {
         if (this.connected) {
@@ -6057,10 +6598,9 @@ class Socket extends Emitter_1 {
         return this;
     }
     /**
-     * Alias for disconnect()
+     * Alias for {@link disconnect()}.
      *
      * @return self
-     * @public
      */
     close() {
         return this.disconnect();
@@ -6068,9 +6608,11 @@ class Socket extends Emitter_1 {
     /**
      * Sets the compress flag.
      *
+     * @example
+     * socket.compress(false).emit("hello");
+     *
      * @param compress - if `true`, compresses the sending data
      * @return self
-     * @public
      */
     compress(compress) {
         this.flags.compress = compress;
@@ -6080,8 +6622,10 @@ class Socket extends Emitter_1 {
      * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
      * ready to send messages.
      *
+     * @example
+     * socket.volatile.emit("hello"); // the server may or may not receive it
+     *
      * @returns self
-     * @public
      */
     get volatile() {
         this.flags.volatile = true;
@@ -6091,16 +6635,14 @@ class Socket extends Emitter_1 {
      * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
      * given number of milliseconds have elapsed without an acknowledgement from the server:
      *
-     * ```
+     * @example
      * socket.timeout(5000).emit("my-event", (err) => {
      *   if (err) {
      *     // the server did not acknowledge the event in the given delay
      *   }
      * });
-     * ```
      *
      * @returns self
-     * @public
      */
     timeout(timeout) {
         this.flags.timeout = timeout;
@@ -6110,8 +6652,12 @@ class Socket extends Emitter_1 {
      * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
      * callback.
      *
+     * @example
+     * socket.onAny((event, ...args) => {
+     *   console.log(`got ${event}`);
+     * });
+     *
      * @param listener
-     * @public
      */
     onAny(listener) {
         this._anyListeners = this._anyListeners || [];
@@ -6122,8 +6668,12 @@ class Socket extends Emitter_1 {
      * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
      * callback. The listener is added to the beginning of the listeners array.
      *
+     * @example
+     * socket.prependAny((event, ...args) => {
+     *   console.log(`got event ${event}`);
+     * });
+     *
      * @param listener
-     * @public
      */
     prependAny(listener) {
         this._anyListeners = this._anyListeners || [];
@@ -6133,8 +6683,20 @@ class Socket extends Emitter_1 {
     /**
      * Removes the listener that will be fired when any event is emitted.
      *
+     * @example
+     * const catchAllListener = (event, ...args) => {
+     *   console.log(`got event ${event}`);
+     * }
+     *
+     * socket.onAny(catchAllListener);
+     *
+     * // remove a specific listener
+     * socket.offAny(catchAllListener);
+     *
+     * // or remove all listeners
+     * socket.offAny();
+     *
      * @param listener
-     * @public
      */
     offAny(listener) {
         if (!this._anyListeners) {
@@ -6157,8 +6719,6 @@ class Socket extends Emitter_1 {
     /**
      * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
      * e.g. to remove listeners.
-     *
-     * @public
      */
     listenersAny() {
         return this._anyListeners || [];
@@ -6167,17 +6727,14 @@ class Socket extends Emitter_1 {
      * 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
      */
     onAnyOutgoing(listener) {
         this._anyOutgoingListeners = this._anyOutgoingListeners || [];
@@ -6188,17 +6745,14 @@ class Socket extends Emitter_1 {
      * 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
      */
     prependAnyOutgoing(listener) {
         this._anyOutgoingListeners = this._anyOutgoingListeners || [];
@@ -6208,22 +6762,20 @@ class Socket extends Emitter_1 {
     /**
      * 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)
      */
     offAnyOutgoing(listener) {
         if (!this._anyOutgoingListeners) {
@@ -6246,8 +6798,6 @@ class Socket extends Emitter_1 {
     /**
      * 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
      */
     listenersAnyOutgoing() {
         return this._anyOutgoingListeners || [];
@@ -6447,36 +6997,33 @@ class Manager extends Emitter_1 {
             self.onopen();
             fn && fn();
         });
-        // emit `error`
-        const errorSub = on(socket, "error", (err) => {
-            self.cleanup();
-            self._readyState = "closed";
+        const onError = (err) => {
+            this.cleanup();
+            this._readyState = "closed";
             this.emitReserved("error", err);
             if (fn) {
                 fn(err);
             }
             else {
                 // Only do this if there is no fn to handle the error
-                self.maybeReconnectOnOpen();
+                this.maybeReconnectOnOpen();
             }
-        });
+        };
+        // emit `error`
+        const errorSub = on(socket, "error", onError);
         if (false !== this._timeout) {
             const timeout = this._timeout;
-            if (timeout === 0) {
-                openSubDestroy(); // prevents a race condition with the 'open' event
-            }
             // set timer
             const timer = this.setTimeoutFn(() => {
                 openSubDestroy();
+                onError(new Error("timeout"));
                 socket.close();
-                // @ts-ignore
-                socket.emit("error", new Error("timeout"));
             }, timeout);
             if (this.opts.autoUnref) {
                 timer.unref();
             }
-            this.subs.push(function subDestroy() {
-                clearTimeout(timer);
+            this.subs.push(() => {
+                this.clearTimeoutFn(timer);
             });
         }
         this.subs.push(openSubDestroy);
@@ -6521,7 +7068,12 @@ class Manager extends Emitter_1 {
      * @private
      */
     ondata(data) {
-        this.decoder.add(data);
+        try {
+            this.decoder.add(data);
+        }
+        catch (e) {
+            this.onclose("parse error", e);
+        }
     }
     /**
      * Called when parser fully decodes a packet.
@@ -6529,7 +7081,10 @@ class Manager extends Emitter_1 {
      * @private
      */
     ondecoded(packet) {
-        this.emitReserved("packet", packet);
+        // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error"
+        nextTick(() => {
+            this.emitReserved("packet", packet);
+        }, this.setTimeoutFn);
     }
     /**
      * Called upon socket error.
@@ -6551,6 +7106,9 @@ class Manager extends Emitter_1 {
             socket = new Socket(this, nsp, opts);
             this.nsps[nsp] = socket;
         }
+        else if (this._autoConnect && !socket.active) {
+            socket.connect();
+        }
         return socket;
     }
     /**
@@ -6663,8 +7221,8 @@ class Manager extends Emitter_1 {
             if (this.opts.autoUnref) {
                 timer.unref();
             }
-            this.subs.push(function subDestroy() {
-                clearTimeout(timer);
+            this.subs.push(() => {
+                this.clearTimeoutFn(timer);
             });
         }
     }