@oox/socketio-client 1.0.0

package/browser.js

@@ -0,0 +1,4150 @@
+var OOXSocketIOClient = (function (exports, oox) {
+    'use strict';
+
+    function _interopNamespaceDefault(e) {
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n.default = e;
+        return Object.freeze(n);
+    }
+
+    var oox__namespace = /*#__PURE__*/_interopNamespaceDefault(oox);
+
+    const OOXEvent = {
+        CONNECT: 'connect',
+        DISCONNECT: 'disconnect',
+        ERROR: 'connect_error',
+        CALL: 'call',
+        READY: 'oox:ready',
+        ENABLED: 'oox:enabled',
+        DISABLED: 'oox:disabled',
+        REGISTRY_SYNC_CONNECTIONS: 'oox:registry:sync_connections',
+        REGISTRY_SUBSCRIBE: 'oox:registry:subscribe',
+        REGISTRY_NOTIFY: 'oox:registry:notify',
+    };
+    function isWebSocketURL(url) {
+        if ('string' === typeof url) {
+            return /^wss?:\/\/.+$/.test(url);
+        }
+        else {
+            return url.protocol === 'ws:' || url.protocol === 'wss:';
+        }
+    }
+    function genWebSocketURL(url) {
+        // :6000
+        if (url.startsWith(':'))
+            url = 'ws://localhost' + url;
+        // 127.0.0.1:6000
+        if (!/^\w+?:\/.+$/.test(url))
+            url = 'ws://' + url;
+        const urlObject = new URL(url);
+        // :8000 => :8000/ws
+        const notSetPath = !urlObject.pathname || (urlObject.pathname === '/'
+            && !url.endsWith('/')
+            && !urlObject.search
+            && !urlObject.hash);
+        if (notSetPath) {
+            urlObject.pathname = '/socket.io';
+        }
+        if (urlObject.protocol !== 'wss:') {
+            if (urlObject.port === '443')
+                urlObject.protocol = 'wss:';
+            else
+                urlObject.protocol = 'ws:';
+        }
+        return urlObject;
+    }
+
+    const PACKET_TYPES = Object.create(null); // no Map = no polyfill
+    PACKET_TYPES["open"] = "0";
+    PACKET_TYPES["close"] = "1";
+    PACKET_TYPES["ping"] = "2";
+    PACKET_TYPES["pong"] = "3";
+    PACKET_TYPES["message"] = "4";
+    PACKET_TYPES["upgrade"] = "5";
+    PACKET_TYPES["noop"] = "6";
+    const PACKET_TYPES_REVERSE = Object.create(null);
+    Object.keys(PACKET_TYPES).forEach((key) => {
+        PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;
+    });
+    const ERROR_PACKET = { type: "error", data: "parser error" };
+
+    const withNativeBlob$1 = typeof Blob === "function" ||
+        (typeof Blob !== "undefined" &&
+            Object.prototype.toString.call(Blob) === "[object BlobConstructor]");
+    const withNativeArrayBuffer$2 = typeof ArrayBuffer === "function";
+    // ArrayBuffer.isView method is not defined in IE10
+    const isView$1 = (obj) => {
+        return typeof ArrayBuffer.isView === "function"
+            ? ArrayBuffer.isView(obj)
+            : obj && obj.buffer instanceof ArrayBuffer;
+    };
+    const encodePacket = ({ type, data }, supportsBinary, callback) => {
+        if (withNativeBlob$1 && data instanceof Blob) {
+            if (supportsBinary) {
+                return callback(data);
+            }
+            else {
+                return encodeBlobAsBase64(data, callback);
+            }
+        }
+        else if (withNativeArrayBuffer$2 &&
+            (data instanceof ArrayBuffer || isView$1(data))) {
+            if (supportsBinary) {
+                return callback(data);
+            }
+            else {
+                return encodeBlobAsBase64(new Blob([data]), callback);
+            }
+        }
+        // plain string
+        return callback(PACKET_TYPES[type] + (data || ""));
+    };
+    const encodeBlobAsBase64 = (data, callback) => {
+        const fileReader = new FileReader();
+        fileReader.onload = function () {
+            const content = fileReader.result.split(",")[1];
+            callback("b" + (content || ""));
+        };
+        return fileReader.readAsDataURL(data);
+    };
+    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+/';
+    // Use a lookup table to find the index.
+    const lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+    for (let i = 0; i < chars.length; i++) {
+        lookup$1[chars.charCodeAt(i)] = i;
+    }
+    const decode$1 = (base64) => {
+        let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
+        if (base64[base64.length - 1] === '=') {
+            bufferLength--;
+            if (base64[base64.length - 2] === '=') {
+                bufferLength--;
+            }
+        }
+        const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+        for (i = 0; i < len; i += 4) {
+            encoded1 = lookup$1[base64.charCodeAt(i)];
+            encoded2 = lookup$1[base64.charCodeAt(i + 1)];
+            encoded3 = lookup$1[base64.charCodeAt(i + 2)];
+            encoded4 = lookup$1[base64.charCodeAt(i + 3)];
+            bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+            bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+            bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+        }
+        return arraybuffer;
+    };
+
+    const withNativeArrayBuffer$1 = typeof ArrayBuffer === "function";
+    const decodePacket = (encodedPacket, binaryType) => {
+        if (typeof encodedPacket !== "string") {
+            return {
+                type: "message",
+                data: mapBinary(encodedPacket, binaryType),
+            };
+        }
+        const type = encodedPacket.charAt(0);
+        if (type === "b") {
+            return {
+                type: "message",
+                data: decodeBase64Packet(encodedPacket.substring(1), binaryType),
+            };
+        }
+        const packetType = PACKET_TYPES_REVERSE[type];
+        if (!packetType) {
+            return ERROR_PACKET;
+        }
+        return encodedPacket.length > 1
+            ? {
+                type: PACKET_TYPES_REVERSE[type],
+                data: encodedPacket.substring(1),
+            }
+            : {
+                type: PACKET_TYPES_REVERSE[type],
+            };
+    };
+    const decodeBase64Packet = (data, binaryType) => {
+        if (withNativeArrayBuffer$1) {
+            const decoded = decode$1(data);
+            return mapBinary(decoded, binaryType);
+        }
+        else {
+            return { base64: true, data }; // fallback for old browsers
+        }
+    };
+    const mapBinary = (data, binaryType) => {
+        switch (binaryType) {
+            case "blob":
+                if (data instanceof Blob) {
+                    // from WebSocket + binaryType "blob"
+                    return data;
+                }
+                else {
+                    // from HTTP long-polling or WebTransport
+                    return new Blob([data]);
+                }
+            case "arraybuffer":
+            default:
+                if (data instanceof ArrayBuffer) {
+                    // from HTTP long-polling (base64) or WebSocket + binaryType "arraybuffer"
+                    return data;
+                }
+                else {
+                    // from WebTransport (Uint8Array)
+                    return data.buffer;
+                }
+        }
+    };
+
+    const SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text
+    const encodePayload = (packets, callback) => {
+        // some packets may be added to the array while encoding, so the initial length must be saved
+        const length = packets.length;
+        const encodedPackets = new Array(length);
+        let count = 0;
+        packets.forEach((packet, i) => {
+            // force base64 encoding for binary packets
+            encodePacket(packet, false, (encodedPacket) => {
+                encodedPackets[i] = encodedPacket;
+                if (++count === length) {
+                    callback(encodedPackets.join(SEPARATOR));
+                }
+            });
+        });
+    };
+    const decodePayload = (encodedPayload, binaryType) => {
+        const encodedPackets = encodedPayload.split(SEPARATOR);
+        const packets = [];
+        for (let i = 0; i < encodedPackets.length; i++) {
+            const decodedPacket = decodePacket(encodedPackets[i], binaryType);
+            packets.push(decodedPacket);
+            if (decodedPacket.type === "error") {
+                break;
+            }
+        }
+        return packets;
+    };
+    function createPacketEncoderStream() {
+        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 /* State.READ_HEADER */;
+        let expectedLength = -1;
+        let isBinary = false;
+        return new TransformStream({
+            transform(chunk, controller) {
+                chunks.push(chunk);
+                while (true) {
+                    if (state === 0 /* State.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 /* State.READ_PAYLOAD */;
+                        }
+                        else if (expectedLength === 126) {
+                            state = 1 /* State.READ_EXTENDED_LENGTH_16 */;
+                        }
+                        else {
+                            state = 2 /* State.READ_EXTENDED_LENGTH_64 */;
+                        }
+                    }
+                    else if (state === 1 /* State.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 /* State.READ_PAYLOAD */;
+                    }
+                    else if (state === 2 /* State.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 /* State.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 /* State.READ_HEADER */;
+                    }
+                    if (expectedLength === 0 || expectedLength > maxPayload) {
+                        controller.enqueue(ERROR_PACKET);
+                        break;
+                    }
+                }
+            },
+        });
+    }
+    const protocol = 4;
+
+    /**
+     * Initialize a new `Emitter`.
+     *
+     * @api public
+     */
+
+    function Emitter(obj) {
+      if (obj) return mixin(obj);
+    }
+
+    /**
+     * Mixin the emitter properties.
+     *
+     * @param {Object} obj
+     * @return {Object}
+     * @api private
+     */
+
+    function mixin(obj) {
+      for (var key in Emitter.prototype) {
+        obj[key] = Emitter.prototype[key];
+      }
+      return obj;
+    }
+
+    /**
+     * Listen on the given `event` with `fn`.
+     *
+     * @param {String} event
+     * @param {Function} fn
+     * @return {Emitter}
+     * @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.
+     *
+     * @param {String} event
+     * @param {Function} fn
+     * @return {Emitter}
+     * @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.
+     *
+     * @param {String} event
+     * @param {Function} fn
+     * @return {Emitter}
+     * @api public
+     */
+
+    Emitter.prototype.off =
+    Emitter.prototype.removeListener =
+    Emitter.prototype.removeAllListeners =
+    Emitter.prototype.removeEventListener = function(event, fn){
+      this._callbacks = this._callbacks || {};
+
+      // all
+      if (0 == arguments.length) {
+        this._callbacks = {};
+        return this;
+      }
+
+      // specific event
+      var callbacks = this._callbacks['$' + event];
+      if (!callbacks) return this;
+
+      // remove all handlers
+      if (1 == arguments.length) {
+        delete this._callbacks['$' + event];
+        return this;
+      }
+
+      // 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.
+      if (callbacks.length === 0) {
+        delete this._callbacks['$' + event];
+      }
+
+      return this;
+    };
+
+    /**
+     * Emit `event` with the given args.
+     *
+     * @param {String} event
+     * @param {Mixed} ...
+     * @return {Emitter}
+     */
+
+    Emitter.prototype.emit = function(event){
+      this._callbacks = this._callbacks || {};
+
+      var args = new Array(arguments.length - 1)
+        , callbacks = this._callbacks['$' + event];
+
+      for (var i = 1; i < arguments.length; i++) {
+        args[i - 1] = arguments[i];
+      }
+
+      if (callbacks) {
+        callbacks = callbacks.slice(0);
+        for (var i = 0, len = callbacks.length; i < len; ++i) {
+          callbacks[i].apply(this, args);
+        }
+      }
+
+      return this;
+    };
+
+    // alias used for reserved events (protected method)
+    Emitter.prototype.emitReserved = Emitter.prototype.emit;
+
+    /**
+     * Return array of callbacks for `event`.
+     *
+     * @param {String} event
+     * @return {Array}
+     * @api public
+     */
+
+    Emitter.prototype.listeners = function(event){
+      this._callbacks = this._callbacks || {};
+      return this._callbacks['$' + event] || [];
+    };
+
+    /**
+     * Check if this emitter has `event` handlers.
+     *
+     * @param {String} event
+     * @return {Boolean}
+     * @api public
+     */
+
+    Emitter.prototype.hasListeners = function(event){
+      return !! this.listeners(event).length;
+    };
+
+    const nextTick = (() => {
+        const isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function";
+        if (isPromiseAvailable) {
+            return (cb) => Promise.resolve().then(cb);
+        }
+        else {
+            return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);
+        }
+    })();
+    const globalThisShim = (() => {
+        if (typeof self !== "undefined") {
+            return self;
+        }
+        else if (typeof window !== "undefined") {
+            return window;
+        }
+        else {
+            return Function("return this")();
+        }
+    })();
+    const defaultBinaryType = "arraybuffer";
+    function createCookieJar() { }
+
+    function pick(obj, ...attr) {
+        return attr.reduce((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
+    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 = globalThisShim.setTimeout.bind(globalThisShim);
+            obj.clearTimeoutFn = globalThisShim.clearTimeout.bind(globalThisShim);
+        }
+    }
+    // base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)
+    const BASE64_OVERHEAD = 1.33;
+    // we could also have used `new Blob([obj]).size`, but it isn't supported in IE9
+    function byteLength(obj) {
+        if (typeof obj === "string") {
+            return utf8Length(obj);
+        }
+        // arraybuffer or blob
+        return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);
+    }
+    function utf8Length(str) {
+        let c = 0, length = 0;
+        for (let i = 0, l = str.length; i < l; i++) {
+            c = str.charCodeAt(i);
+            if (c < 0x80) {
+                length += 1;
+            }
+            else if (c < 0x800) {
+                length += 2;
+            }
+            else if (c < 0xd800 || c >= 0xe000) {
+                length += 3;
+            }
+            else {
+                i++;
+                length += 4;
+            }
+        }
+        return length;
+    }
+    /**
+     * Generates a random 8-characters string.
+     */
+    function randomString() {
+        return (Date.now().toString(36).substring(3) +
+            Math.random().toString(36).substring(2, 5));
+    }
+
+    // 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;
+    }
+
+    class TransportError extends Error {
+        constructor(reason, description, context) {
+            super(reason);
+            this.description = description;
+            this.context = context;
+            this.type = "TransportError";
+        }
+    }
+    class Transport extends Emitter {
+        /**
+         * Transport abstract constructor.
+         *
+         * @param {Object} opts - options
+         * @protected
+         */
+        constructor(opts) {
+            super();
+            this.writable = false;
+            installTimerFunctions(this, opts);
+            this.opts = opts;
+            this.query = opts.query;
+            this.socket = opts.socket;
+            this.supportsBinary = !opts.forceBase64;
+        }
+        /**
+         * Emits an error.
+         *
+         * @param {String} reason
+         * @param description
+         * @param context - the error context
+         * @return {Transport} for chaining
+         * @protected
+         */
+        onError(reason, description, context) {
+            super.emitReserved("error", new TransportError(reason, description, context));
+            return this;
+        }
+        /**
+         * Opens the transport.
+         */
+        open() {
+            this.readyState = "opening";
+            this.doOpen();
+            return this;
+        }
+        /**
+         * Closes the transport.
+         */
+        close() {
+            if (this.readyState === "opening" || this.readyState === "open") {
+                this.doClose();
+                this.onClose();
+            }
+            return this;
+        }
+        /**
+         * Sends multiple packets.
+         *
+         * @param {Array} packets
+         */
+        send(packets) {
+            if (this.readyState === "open") {
+                this.write(packets);
+            }
+        }
+        /**
+         * Called upon open
+         *
+         * @protected
+         */
+        onOpen() {
+            this.readyState = "open";
+            this.writable = true;
+            super.emitReserved("open");
+        }
+        /**
+         * Called with data.
+         *
+         * @param {String} data
+         * @protected
+         */
+        onData(data) {
+            const packet = decodePacket(data, this.socket.binaryType);
+            this.onPacket(packet);
+        }
+        /**
+         * Called with a decoded packet.
+         *
+         * @protected
+         */
+        onPacket(packet) {
+            super.emitReserved("packet", packet);
+        }
+        /**
+         * Called upon close.
+         *
+         * @protected
+         */
+        onClose(details) {
+            this.readyState = "closed";
+            super.emitReserved("close", details);
+        }
+        /**
+         * Pauses the transport, in order not to lose packets during an upgrade.
+         *
+         * @param onPause
+         */
+        pause(onPause) { }
+        createUri(schema, query = {}) {
+            return (schema +
+                "://" +
+                this._hostname() +
+                this._port() +
+                this.opts.path +
+                this._query(query));
+        }
+        _hostname() {
+            const hostname = this.opts.hostname;
+            return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]";
+        }
+        _port() {
+            if (this.opts.port &&
+                ((this.opts.secure && Number(this.opts.port) !== 443) ||
+                    (!this.opts.secure && Number(this.opts.port) !== 80))) {
+                return ":" + this.opts.port;
+            }
+            else {
+                return "";
+            }
+        }
+        _query(query) {
+            const encodedQuery = encode(query);
+            return encodedQuery.length ? "?" + encodedQuery : "";
+        }
+    }
+
+    class Polling extends Transport {
+        constructor() {
+            super(...arguments);
+            this._polling = false;
+        }
+        get name() {
+            return "polling";
+        }
+        /**
+         * Opens the socket (triggers polling). We write a PING message to determine
+         * when the transport is open.
+         *
+         * @protected
+         */
+        doOpen() {
+            this._poll();
+        }
+        /**
+         * Pauses polling.
+         *
+         * @param {Function} onPause - callback upon buffers are flushed and transport is paused
+         * @package
+         */
+        pause(onPause) {
+            this.readyState = "pausing";
+            const pause = () => {
+                this.readyState = "paused";
+                onPause();
+            };
+            if (this._polling || !this.writable) {
+                let total = 0;
+                if (this._polling) {
+                    total++;
+                    this.once("pollComplete", function () {
+                        --total || pause();
+                    });
+                }
+                if (!this.writable) {
+                    total++;
+                    this.once("drain", function () {
+                        --total || pause();
+                    });
+                }
+            }
+            else {
+                pause();
+            }
+        }
+        /**
+         * Starts polling cycle.
+         *
+         * @private
+         */
+        _poll() {
+            this._polling = true;
+            this.doPoll();
+            this.emitReserved("poll");
+        }
+        /**
+         * Overloads onData to detect payloads.
+         *
+         * @protected
+         */
+        onData(data) {
+            const callback = (packet) => {
+                // if its the first message we consider the transport open
+                if ("opening" === this.readyState && packet.type === "open") {
+                    this.onOpen();
+                }
+                // if its a close packet, we close the ongoing requests
+                if ("close" === packet.type) {
+                    this.onClose({ description: "transport closed by the server" });
+                    return false;
+                }
+                // otherwise bypass onData and handle the message
+                this.onPacket(packet);
+            };
+            // 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();
+                }
+            }
+        }
+        /**
+         * For polling, send a close packet.
+         *
+         * @protected
+         */
+        doClose() {
+            const close = () => {
+                this.write([{ type: "close" }]);
+            };
+            if ("open" === this.readyState) {
+                close();
+            }
+            else {
+                // in case we're trying to close while
+                // handshaking is in progress (GH-164)
+                this.once("open", close);
+            }
+        }
+        /**
+         * Writes a packets payload.
+         *
+         * @param {Array} packets - data packets
+         * @protected
+         */
+        write(packets) {
+            this.writable = false;
+            encodePayload(packets, (data) => {
+                this.doWrite(data, () => {
+                    this.writable = true;
+                    this.emitReserved("drain");
+                });
+            });
+        }
+        /**
+         * Generates uri for connection.
+         *
+         * @private
+         */
+        uri() {
+            const schema = this.opts.secure ? "https" : "http";
+            const query = this.query || {};
+            // cache busting is forced
+            if (false !== this.opts.timestampRequests) {
+                query[this.opts.timestampParam] = randomString();
+            }
+            if (!this.supportsBinary && !query.sid) {
+                query.b64 = 1;
+            }
+            return this.createUri(schema, query);
+        }
+    }
+
+    // imported from https://github.com/component/has-cors
+    let value = false;
+    try {
+        value = typeof XMLHttpRequest !== 'undefined' &&
+            'withCredentials' in new XMLHttpRequest();
+    }
+    catch (err) {
+        // if XMLHttp support is disabled in IE then it will throw
+        // when trying to create
+    }
+    const hasCORS = value;
+
+    function empty() { }
+    class BaseXHR extends Polling {
+        /**
+         * XHR Polling constructor.
+         *
+         * @param {Object} opts
+         * @package
+         */
+        constructor(opts) {
+            super(opts);
+            if (typeof location !== "undefined") {
+                const isSSL = "https:" === location.protocol;
+                let port = location.port;
+                // some user agents have empty `location.port`
+                if (!port) {
+                    port = isSSL ? "443" : "80";
+                }
+                this.xd =
+                    (typeof location !== "undefined" &&
+                        opts.hostname !== location.hostname) ||
+                        port !== opts.port;
+            }
+        }
+        /**
+         * Sends data.
+         *
+         * @param {String} data to send.
+         * @param {Function} called upon flush.
+         * @private
+         */
+        doWrite(data, fn) {
+            const req = this.request({
+                method: "POST",
+                data: data,
+            });
+            req.on("success", fn);
+            req.on("error", (xhrStatus, context) => {
+                this.onError("xhr post error", xhrStatus, context);
+            });
+        }
+        /**
+         * Starts a poll cycle.
+         *
+         * @private
+         */
+        doPoll() {
+            const req = this.request();
+            req.on("data", this.onData.bind(this));
+            req.on("error", (xhrStatus, context) => {
+                this.onError("xhr poll error", xhrStatus, context);
+            });
+            this.pollXhr = req;
+        }
+    }
+    class Request extends Emitter {
+        /**
+         * Request constructor
+         *
+         * @param {Object} options
+         * @package
+         */
+        constructor(createRequest, uri, opts) {
+            super();
+            this.createRequest = createRequest;
+            installTimerFunctions(this, opts);
+            this._opts = opts;
+            this._method = opts.method || "GET";
+            this._uri = uri;
+            this._data = undefined !== opts.data ? opts.data : null;
+            this._create();
+        }
+        /**
+         * Creates the XHR object and sends the request.
+         *
+         * @private
+         */
+        _create() {
+            var _a;
+            const opts = pick(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref");
+            opts.xdomain = !!this._opts.xd;
+            const xhr = (this._xhr = this.createRequest(opts));
+            try {
+                xhr.open(this._method, this._uri, true);
+                try {
+                    if (this._opts.extraHeaders) {
+                        // @ts-ignore
+                        xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);
+                        for (let i in this._opts.extraHeaders) {
+                            if (this._opts.extraHeaders.hasOwnProperty(i)) {
+                                xhr.setRequestHeader(i, this._opts.extraHeaders[i]);
+                            }
+                        }
+                    }
+                }
+                catch (e) { }
+                if ("POST" === this._method) {
+                    try {
+                        xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8");
+                    }
+                    catch (e) { }
+                }
+                try {
+                    xhr.setRequestHeader("Accept", "*/*");
+                }
+                catch (e) { }
+                (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);
+                // ie6 check
+                if ("withCredentials" in xhr) {
+                    xhr.withCredentials = this._opts.withCredentials;
+                }
+                if (this._opts.requestTimeout) {
+                    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(
+                        // @ts-ignore
+                        xhr.getResponseHeader("set-cookie"));
+                    }
+                    if (4 !== xhr.readyState)
+                        return;
+                    if (200 === xhr.status || 1223 === xhr.status) {
+                        this._onLoad();
+                    }
+                    else {
+                        // make sure the `error` event handler that's user-set
+                        // does not throw in the same tick and gets caught here
+                        this.setTimeoutFn(() => {
+                            this._onError(typeof xhr.status === "number" ? xhr.status : 0);
+                        }, 0);
+                    }
+                };
+                xhr.send(this._data);
+            }
+            catch (e) {
+                // Need to defer since .create() is called directly from the constructor
+                // and thus the 'error' event can only be only bound *after* this exception
+                // occurs.  Therefore, also, we cannot throw here at all.
+                this.setTimeoutFn(() => {
+                    this._onError(e);
+                }, 0);
+                return;
+            }
+            if (typeof document !== "undefined") {
+                this._index = Request.requestsCount++;
+                Request.requests[this._index] = this;
+            }
+        }
+        /**
+         * Called upon error.
+         *
+         * @private
+         */
+        _onError(err) {
+            this.emitReserved("error", err, this._xhr);
+            this._cleanup(true);
+        }
+        /**
+         * Cleans up house.
+         *
+         * @private
+         */
+        _cleanup(fromError) {
+            if ("undefined" === typeof this._xhr || null === this._xhr) {
+                return;
+            }
+            this._xhr.onreadystatechange = empty;
+            if (fromError) {
+                try {
+                    this._xhr.abort();
+                }
+                catch (e) { }
+            }
+            if (typeof document !== "undefined") {
+                delete Request.requests[this._index];
+            }
+            this._xhr = null;
+        }
+        /**
+         * Called upon load.
+         *
+         * @private
+         */
+        _onLoad() {
+            const data = this._xhr.responseText;
+            if (data !== null) {
+                this.emitReserved("data", data);
+                this.emitReserved("success");
+                this._cleanup();
+            }
+        }
+        /**
+         * Aborts the request.
+         *
+         * @package
+         */
+        abort() {
+            this._cleanup();
+        }
+    }
+    Request.requestsCount = 0;
+    Request.requests = {};
+    /**
+     * Aborts pending requests when unloading the window. This is needed to prevent
+     * 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") {
+            const terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload";
+            addEventListener(terminationEvent, unloadHandler, false);
+        }
+    }
+    function unloadHandler() {
+        for (let i in Request.requests) {
+            if (Request.requests.hasOwnProperty(i)) {
+                Request.requests[i].abort();
+            }
+        }
+    }
+    const hasXHR2 = (function () {
+        const xhr = newRequest({
+            xdomain: false,
+        });
+        return xhr && xhr.responseType !== null;
+    })();
+    /**
+     * HTTP long-polling based on the built-in `XMLHttpRequest` object.
+     *
+     * Usage: browser
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+     */
+    class XHR extends BaseXHR {
+        constructor(opts) {
+            super(opts);
+            const forceBase64 = opts && opts.forceBase64;
+            this.supportsBinary = hasXHR2 && !forceBase64;
+        }
+        request(opts = {}) {
+            Object.assign(opts, { xd: this.xd }, this.opts);
+            return new Request(newRequest, this.uri(), opts);
+        }
+    }
+    function newRequest(opts) {
+        const xdomain = opts.xdomain;
+        // XMLHttpRequest can be disabled on IE
+        try {
+            if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {
+                return new XMLHttpRequest();
+            }
+        }
+        catch (e) { }
+        if (!xdomain) {
+            try {
+                return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP");
+            }
+            catch (e) { }
+        }
+    }
+
+    // detect ReactNative environment
+    const isReactNative = typeof navigator !== "undefined" &&
+        typeof navigator.product === "string" &&
+        navigator.product.toLowerCase() === "reactnative";
+    class BaseWS extends Transport {
+        get name() {
+            return "websocket";
+        }
+        doOpen() {
+            const uri = this.uri();
+            const protocols = this.opts.protocols;
+            // React Native only supports the 'headers' option, and will print a warning if anything else is passed
+            const 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 = this.createSocket(uri, protocols, opts);
+            }
+            catch (err) {
+                return this.emitReserved("error", err);
+            }
+            this.ws.binaryType = this.socket.binaryType;
+            this.addEventListeners();
+        }
+        /**
+         * Adds event listeners to the socket
+         *
+         * @private
+         */
+        addEventListeners() {
+            this.ws.onopen = () => {
+                if (this.opts.autoUnref) {
+                    this.ws._socket.unref();
+                }
+                this.onOpen();
+            };
+            this.ws.onclose = (closeEvent) => this.onClose({
+                description: "websocket connection closed",
+                context: closeEvent,
+            });
+            this.ws.onmessage = (ev) => this.onData(ev.data);
+            this.ws.onerror = (e) => this.onError("websocket error", e);
+        }
+        write(packets) {
+            this.writable = false;
+            // encodePacket efficient as it uses WS framing
+            // no need for encodePayload
+            for (let i = 0; i < packets.length; i++) {
+                const packet = packets[i];
+                const lastPacket = i === packets.length - 1;
+                encodePacket(packet, this.supportsBinary, (data) => {
+                    // 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 {
+                        this.doWrite(packet, data);
+                    }
+                    catch (e) {
+                    }
+                    if (lastPacket) {
+                        // fake drain
+                        // defer to next tick to allow Socket to clear writeBuffer
+                        nextTick(() => {
+                            this.writable = true;
+                            this.emitReserved("drain");
+                        }, this.setTimeoutFn);
+                    }
+                });
+            }
+        }
+        doClose() {
+            if (typeof this.ws !== "undefined") {
+                this.ws.onerror = () => { };
+                this.ws.close();
+                this.ws = null;
+            }
+        }
+        /**
+         * Generates uri for connection.
+         *
+         * @private
+         */
+        uri() {
+            const schema = this.opts.secure ? "wss" : "ws";
+            const query = this.query || {};
+            // append timestamp to URI
+            if (this.opts.timestampRequests) {
+                query[this.opts.timestampParam] = randomString();
+            }
+            // communicate binary support capabilities
+            if (!this.supportsBinary) {
+                query.b64 = 1;
+            }
+            return this.createUri(schema, query);
+        }
+    }
+    const WebSocketCtor = globalThisShim.WebSocket || globalThisShim.MozWebSocket;
+    /**
+     * WebSocket transport based on the built-in `WebSocket` object.
+     *
+     * Usage: browser, Node.js (since v21), Deno, Bun
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+     * @see https://caniuse.com/mdn-api_websocket
+     * @see https://nodejs.org/api/globals.html#websocket
+     */
+    class WS extends BaseWS {
+        createSocket(uri, protocols, opts) {
+            return !isReactNative
+                ? protocols
+                    ? new WebSocketCtor(uri, protocols)
+                    : new WebSocketCtor(uri)
+                : new WebSocketCtor(uri, protocols, opts);
+        }
+        doWrite(_packet, data) {
+            this.ws.send(data);
+        }
+    }
+
+    /**
+     * WebTransport transport based on the built-in `WebTransport` object.
+     *
+     * Usage: browser, Node.js (with the `@fails-components/webtransport` package)
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport
+     * @see https://caniuse.com/webtransport
+     */
+    class WT extends Transport {
+        get name() {
+            return "webtransport";
+        }
+        doOpen() {
+            try {
+                // @ts-ignore
+                this._transport = new WebTransport(this.createUri("https"), this.opts.transportOptions[this.name]);
+            }
+            catch (err) {
+                return this.emitReserved("error", err);
+            }
+            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,
+        webtransport: WT,
+        polling: XHR,
+    };
+
+    // imported from https://github.com/galkn/parseuri
+    /**
+     * Parses a URI
+     *
+     * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.
+     *
+     * See:
+     * - https://developer.mozilla.org/en-US/docs/Web/API/URL
+     * - https://caniuse.com/url
+     * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B
+     *
+     * History of the parse() method:
+     * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c
+     * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3
+     * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242
+     *
+     * @author Steven Levithan <stevenlevithan.com> (MIT license)
+     * @api private
+     */
+    const re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/;
+    const parts = [
+        'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'
+    ];
+    function parse(str) {
+        if (str.length > 8000) {
+            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);
+        }
+        let m = re.exec(str || ''), uri = {}, i = 14;
+        while (i--) {
+            uri[parts[i]] = m[i] || '';
+        }
+        if (b != -1 && e != -1) {
+            uri.source = src;
+            uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');
+            uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');
+            uri.ipv6uri = true;
+        }
+        uri.pathNames = pathNames(uri, uri['path']);
+        uri.queryKey = queryKey(uri, uri['query']);
+        return uri;
+    }
+    function pathNames(obj, path) {
+        const regx = /\/{2,9}/g, names = path.replace(regx, "/").split("/");
+        if (path.slice(0, 1) == '/' || path.length === 0) {
+            names.splice(0, 1);
+        }
+        if (path.slice(-1) == '/') {
+            names.splice(names.length - 1, 1);
+        }
+        return names;
+    }
+    function queryKey(uri, query) {
+        const data = {};
+        query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {
+            if ($1) {
+                data[$1] = $2;
+            }
+        });
+        return data;
+    }
+
+    const withEventListeners = typeof addEventListener === "function" &&
+        typeof removeEventListener === "function";
+    const OFFLINE_EVENT_LISTENERS = [];
+    if (withEventListeners) {
+        // within a ServiceWorker, any event handler for the 'offline' event must be added on the initial evaluation of the
+        // script, so we create one single event listener here which will forward the event to the socket instances
+        addEventListener("offline", () => {
+            OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());
+        }, false);
+    }
+    /**
+     * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+     * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+     *
+     * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that
+     * successfully establishes the connection.
+     *
+     * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+     *
+     * @example
+     * import { SocketWithoutUpgrade, WebSocket } from "engine.io-client";
+     *
+     * const socket = new SocketWithoutUpgrade({
+     *   transports: [WebSocket]
+     * });
+     *
+     * socket.on("open", () => {
+     *   socket.send("hello");
+     * });
+     *
+     * @see SocketWithUpgrade
+     * @see Socket
+     */
+    class SocketWithoutUpgrade extends Emitter {
+        /**
+         * Socket constructor.
+         *
+         * @param {String|Object} uri - uri or options
+         * @param {Object} opts - options
+         */
+        constructor(uri, opts) {
+            super();
+            this.binaryType = defaultBinaryType;
+            this.writeBuffer = [];
+            this._prevBufferLen = 0;
+            this._pingInterval = -1;
+            this._pingTimeout = -1;
+            this._maxPayload = -1;
+            /**
+             * The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the
+             * callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.
+             */
+            this._pingTimeoutTime = Infinity;
+            if (uri && "object" === typeof uri) {
+                opts = uri;
+                uri = null;
+            }
+            if (uri) {
+                const parsedUri = parse(uri);
+                opts.hostname = parsedUri.host;
+                opts.secure =
+                    parsedUri.protocol === "https" || parsedUri.protocol === "wss";
+                opts.port = parsedUri.port;
+                if (parsedUri.query)
+                    opts.query = parsedUri.query;
+            }
+            else if (opts.host) {
+                opts.hostname = parse(opts.host).host;
+            }
+            installTimerFunctions(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 = [];
+            this._transportsByName = {};
+            opts.transports.forEach((t) => {
+                const transportName = t.prototype.name;
+                this.transports.push(transportName);
+                this._transportsByName[transportName] = t;
+            });
+            this.opts = Object.assign({
+                path: "/engine.io",
+                agent: false,
+                withCredentials: false,
+                upgrade: true,
+                timestampParam: "t",
+                rememberUpgrade: false,
+                addTrailingSlash: true,
+                rejectUnauthorized: true,
+                perMessageDeflate: {
+                    threshold: 1024,
+                },
+                transportOptions: {},
+                closeOnBeforeunload: false,
+            }, opts);
+            this.opts.path =
+                this.opts.path.replace(/\/$/, "") +
+                    (this.opts.addTrailingSlash ? "/" : "");
+            if (typeof this.opts.query === "string") {
+                this.opts.query = decode(this.opts.query);
+            }
+            if (withEventListeners) {
+                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)
+                    this._beforeunloadEventListener = () => {
+                        if (this.transport) {
+                            // silently close the transport
+                            this.transport.removeAllListeners();
+                            this.transport.close();
+                        }
+                    };
+                    addEventListener("beforeunload", this._beforeunloadEventListener, false);
+                }
+                if (this.hostname !== "localhost") {
+                    this._offlineEventListener = () => {
+                        this._onClose("transport close", {
+                            description: "network connection lost",
+                        });
+                    };
+                    OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);
+                }
+            }
+            if (this.opts.withCredentials) {
+                this._cookieJar = createCookieJar();
+            }
+            this._open();
+        }
+        /**
+         * Creates transport of the given type.
+         *
+         * @param {String} name - transport name
+         * @return {Transport}
+         * @private
+         */
+        createTransport(name) {
+            const query = Object.assign({}, this.opts.query);
+            // append engine.io protocol identifier
+            query.EIO = protocol;
+            // transport name
+            query.transport = name;
+            // session id if we already have one
+            if (this.id)
+                query.sid = this.id;
+            const opts = Object.assign({}, this.opts, {
+                query,
+                socket: this,
+                hostname: this.hostname,
+                secure: this.secure,
+                port: this.port,
+            }, this.opts.transportOptions[name]);
+            return new this._transportsByName[name](opts);
+        }
+        /**
+         * Initializes transport to use and starts probe.
+         *
+         * @private
+         */
+        _open() {
+            if (this.transports.length === 0) {
+                // Emit error on next tick so it can be listened to
+                this.setTimeoutFn(() => {
+                    this.emitReserved("error", "No transports available");
+                }, 0);
+                return;
+            }
+            const transportName = this.opts.rememberUpgrade &&
+                SocketWithoutUpgrade.priorWebsocketSuccess &&
+                this.transports.indexOf("websocket") !== -1
+                ? "websocket"
+                : this.transports[0];
+            this.readyState = "opening";
+            const transport = this.createTransport(transportName);
+            transport.open();
+            this.setTransport(transport);
+        }
+        /**
+         * Sets the current transport. Disables the existing one (if any).
+         *
+         * @private
+         */
+        setTransport(transport) {
+            if (this.transport) {
+                this.transport.removeAllListeners();
+            }
+            // 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", (reason) => this._onClose("transport close", reason));
+        }
+        /**
+         * Called when connection is deemed open.
+         *
+         * @private
+         */
+        onOpen() {
+            this.readyState = "open";
+            SocketWithoutUpgrade.priorWebsocketSuccess =
+                "websocket" === this.transport.name;
+            this.emitReserved("open");
+            this.flush();
+        }
+        /**
+         * Handles a packet.
+         *
+         * @private
+         */
+        _onPacket(packet) {
+            if ("opening" === this.readyState ||
+                "open" === this.readyState ||
+                "closing" === this.readyState) {
+                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._sendPacket("pong");
+                        this.emitReserved("ping");
+                        this.emitReserved("pong");
+                        this._resetPingTimeout();
+                        break;
+                    case "error":
+                        const 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);
+                        break;
+                }
+            }
+        }
+        /**
+         * Called upon handshake completion.
+         *
+         * @param {Object} data - handshake obj
+         * @private
+         */
+        onHandshake(data) {
+            this.emitReserved("handshake", data);
+            this.id = data.sid;
+            this.transport.query.sid = data.sid;
+            this._pingInterval = data.pingInterval;
+            this._pingTimeout = data.pingTimeout;
+            this._maxPayload = data.maxPayload;
+            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.
+         *
+         * @private
+         */
+        _resetPingTimeout() {
+            this.clearTimeoutFn(this._pingTimeoutTimer);
+            const delay = this._pingInterval + this._pingTimeout;
+            this._pingTimeoutTime = Date.now() + delay;
+            this._pingTimeoutTimer = this.setTimeoutFn(() => {
+                this._onClose("ping timeout");
+            }, delay);
+            if (this.opts.autoUnref) {
+                this._pingTimeoutTimer.unref();
+            }
+        }
+        /**
+         * Called on `drain` event
+         *
+         * @private
+         */
+        _onDrain() {
+            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 {
+                this.flush();
+            }
+        }
+        /**
+         * Flush write buffers.
+         *
+         * @private
+         */
+        flush() {
+            if ("closed" !== this.readyState &&
+                this.transport.writable &&
+                !this.upgrading &&
+                this.writeBuffer.length) {
+                const packets = this._getWritablePackets();
+                this.transport.send(packets);
+                // keep track of current length of writeBuffer
+                // splice writeBuffer and callbackBuffer on `drain`
+                this._prevBufferLen = packets.length;
+                this.emitReserved("flush");
+            }
+        }
+        /**
+         * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP
+         * long-polling)
+         *
+         * @private
+         */
+        _getWritablePackets() {
+            const shouldCheckPayloadSize = this._maxPayload &&
+                this.transport.name === "polling" &&
+                this.writeBuffer.length > 1;
+            if (!shouldCheckPayloadSize) {
+                return this.writeBuffer;
+            }
+            let payloadSize = 1; // first packet type
+            for (let i = 0; i < this.writeBuffer.length; i++) {
+                const data = this.writeBuffer[i].data;
+                if (data) {
+                    payloadSize += byteLength(data);
+                }
+                if (i > 0 && payloadSize > this._maxPayload) {
+                    return this.writeBuffer.slice(0, i);
+                }
+                payloadSize += 2; // separator + packet type
+            }
+            return this.writeBuffer;
+        }
+        /**
+         * Checks whether the heartbeat timer has expired but the socket has not yet been notified.
+         *
+         * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the
+         * `write()` method then the message would not be buffered by the Socket.IO client.
+         *
+         * @return {boolean}
+         * @private
+         */
+        /* private */ _hasPingExpired() {
+            if (!this._pingTimeoutTime)
+                return true;
+            const hasExpired = Date.now() > this._pingTimeoutTime;
+            if (hasExpired) {
+                this._pingTimeoutTime = 0;
+                nextTick(() => {
+                    this._onClose("ping timeout");
+                }, this.setTimeoutFn);
+            }
+            return hasExpired;
+        }
+        /**
+         * Sends a message.
+         *
+         * @param {String} msg - message.
+         * @param {Object} options.
+         * @param {Function} fn - callback function.
+         * @return {Socket} for chaining.
+         */
+        write(msg, options, fn) {
+            this._sendPacket("message", msg, options, fn);
+            return this;
+        }
+        /**
+         * Sends a message. Alias of {@link Socket#write}.
+         *
+         * @param {String} msg - message.
+         * @param {Object} options.
+         * @param {Function} fn - callback function.
+         * @return {Socket} for chaining.
+         */
+        send(msg, options, fn) {
+            this._sendPacket("message", msg, options, fn);
+            return this;
+        }
+        /**
+         * Sends a packet.
+         *
+         * @param {String} type: packet type.
+         * @param {String} data.
+         * @param {Object} options.
+         * @param {Function} fn - callback function.
+         * @private
+         */
+        _sendPacket(type, data, options, fn) {
+            if ("function" === typeof data) {
+                fn = data;
+                data = undefined;
+            }
+            if ("function" === typeof options) {
+                fn = options;
+                options = null;
+            }
+            if ("closing" === this.readyState || "closed" === this.readyState) {
+                return;
+            }
+            options = options || {};
+            options.compress = false !== options.compress;
+            const packet = {
+                type: type,
+                data: data,
+                options: options,
+            };
+            this.emitReserved("packetCreate", packet);
+            this.writeBuffer.push(packet);
+            if (fn)
+                this.once("flush", fn);
+            this.flush();
+        }
+        /**
+         * Closes the connection.
+         */
+        close() {
+            const close = () => {
+                this._onClose("forced close");
+                this.transport.close();
+            };
+            const cleanupAndClose = () => {
+                this.off("upgrade", cleanupAndClose);
+                this.off("upgradeError", cleanupAndClose);
+                close();
+            };
+            const waitForUpgrade = () => {
+                // wait for upgrade to finish since we can't send packets while pausing a transport
+                this.once("upgrade", cleanupAndClose);
+                this.once("upgradeError", cleanupAndClose);
+            };
+            if ("opening" === this.readyState || "open" === this.readyState) {
+                this.readyState = "closing";
+                if (this.writeBuffer.length) {
+                    this.once("drain", () => {
+                        if (this.upgrading) {
+                            waitForUpgrade();
+                        }
+                        else {
+                            close();
+                        }
+                    });
+                }
+                else if (this.upgrading) {
+                    waitForUpgrade();
+                }
+                else {
+                    close();
+                }
+            }
+            return this;
+        }
+        /**
+         * Called upon transport error
+         *
+         * @private
+         */
+        _onError(err) {
+            SocketWithoutUpgrade.priorWebsocketSuccess = false;
+            if (this.opts.tryAllTransports &&
+                this.transports.length > 1 &&
+                this.readyState === "opening") {
+                this.transports.shift();
+                return this._open();
+            }
+            this.emitReserved("error", err);
+            this._onClose("transport error", err);
+        }
+        /**
+         * Called upon transport close.
+         *
+         * @private
+         */
+        _onClose(reason, description) {
+            if ("opening" === this.readyState ||
+                "open" === this.readyState ||
+                "closing" === this.readyState) {
+                // 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 (withEventListeners) {
+                    if (this._beforeunloadEventListener) {
+                        removeEventListener("beforeunload", this._beforeunloadEventListener, false);
+                    }
+                    if (this._offlineEventListener) {
+                        const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);
+                        if (i !== -1) {
+                            OFFLINE_EVENT_LISTENERS.splice(i, 1);
+                        }
+                    }
+                }
+                // 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;
+            }
+        }
+    }
+    SocketWithoutUpgrade.protocol = protocol;
+    /**
+     * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+     * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+     *
+     * This class comes with an upgrade mechanism, which means that once the connection is established with the first
+     * low-level transport, it will try to upgrade to a better transport.
+     *
+     * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.
+     *
+     * @example
+     * import { SocketWithUpgrade, WebSocket } from "engine.io-client";
+     *
+     * const socket = new SocketWithUpgrade({
+     *   transports: [WebSocket]
+     * });
+     *
+     * socket.on("open", () => {
+     *   socket.send("hello");
+     * });
+     *
+     * @see SocketWithoutUpgrade
+     * @see Socket
+     */
+    class SocketWithUpgrade extends SocketWithoutUpgrade {
+        constructor() {
+            super(...arguments);
+            this._upgrades = [];
+        }
+        onOpen() {
+            super.onOpen();
+            if ("open" === this.readyState && this.opts.upgrade) {
+                for (let i = 0; i < this._upgrades.length; i++) {
+                    this._probe(this._upgrades[i]);
+                }
+            }
+        }
+        /**
+         * Probes a transport.
+         *
+         * @param {String} name - transport name
+         * @private
+         */
+        _probe(name) {
+            let transport = this.createTransport(name);
+            let failed = false;
+            SocketWithoutUpgrade.priorWebsocketSuccess = false;
+            const onTransportOpen = () => {
+                if (failed)
+                    return;
+                transport.send([{ type: "ping", data: "probe" }]);
+                transport.once("packet", (msg) => {
+                    if (failed)
+                        return;
+                    if ("pong" === msg.type && "probe" === msg.data) {
+                        this.upgrading = true;
+                        this.emitReserved("upgrading", transport);
+                        if (!transport)
+                            return;
+                        SocketWithoutUpgrade.priorWebsocketSuccess =
+                            "websocket" === transport.name;
+                        this.transport.pause(() => {
+                            if (failed)
+                                return;
+                            if ("closed" === this.readyState)
+                                return;
+                            cleanup();
+                            this.setTransport(transport);
+                            transport.send([{ type: "upgrade" }]);
+                            this.emitReserved("upgrade", transport);
+                            transport = null;
+                            this.upgrading = false;
+                            this.flush();
+                        });
+                    }
+                    else {
+                        const err = new Error("probe error");
+                        // @ts-ignore
+                        err.transport = transport.name;
+                        this.emitReserved("upgradeError", err);
+                    }
+                });
+            };
+            function freezeTransport() {
+                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
+            const onerror = (err) => {
+                const error = new Error("probe error: " + err);
+                // @ts-ignore
+                error.transport = transport.name;
+                freezeTransport();
+                this.emitReserved("upgradeError", error);
+            };
+            function onTransportClose() {
+                onerror("transport closed");
+            }
+            // When the socket is closed while we're probing
+            function onclose() {
+                onerror("socket closed");
+            }
+            // 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
+            const cleanup = () => {
+                transport.removeListener("open", onTransportOpen);
+                transport.removeListener("error", onerror);
+                transport.removeListener("close", onTransportClose);
+                this.off("close", onclose);
+                this.off("upgrading", onupgrade);
+            };
+            transport.once("open", onTransportOpen);
+            transport.once("error", onerror);
+            transport.once("close", onTransportClose);
+            this.once("close", onclose);
+            this.once("upgrading", onupgrade);
+            if (this._upgrades.indexOf("webtransport") !== -1 &&
+                name !== "webtransport") {
+                // favor WebTransport
+                this.setTimeoutFn(() => {
+                    if (!failed) {
+                        transport.open();
+                    }
+                }, 200);
+            }
+            else {
+                transport.open();
+            }
+        }
+        onHandshake(data) {
+            this._upgrades = this._filterUpgrades(data.upgrades);
+            super.onHandshake(data);
+        }
+        /**
+         * Filters upgrades, returning only those matching client transports.
+         *
+         * @param {Array} upgrades - server upgrades
+         * @private
+         */
+        _filterUpgrades(upgrades) {
+            const filteredUpgrades = [];
+            for (let i = 0; i < upgrades.length; i++) {
+                if (~this.transports.indexOf(upgrades[i]))
+                    filteredUpgrades.push(upgrades[i]);
+            }
+            return filteredUpgrades;
+        }
+    }
+    /**
+     * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established
+     * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.
+     *
+     * This class comes with an upgrade mechanism, which means that once the connection is established with the first
+     * low-level transport, it will try to upgrade to a better transport.
+     *
+     * @example
+     * import { Socket } from "engine.io-client";
+     *
+     * const socket = new Socket();
+     *
+     * socket.on("open", () => {
+     *   socket.send("hello");
+     * });
+     *
+     * @see SocketWithoutUpgrade
+     * @see SocketWithUpgrade
+     */
+    let Socket$1 = class Socket extends SocketWithUpgrade {
+        constructor(uri, opts = {}) {
+            const o = typeof uri === "object" ? uri : opts;
+            if (!o.transports ||
+                (o.transports && typeof o.transports[0] === "string")) {
+                o.transports = (o.transports || ["polling", "websocket", "webtransport"])
+                    .map((transportName) => transports[transportName])
+                    .filter((t) => !!t);
+            }
+            super(uri, o);
+        }
+    };
+
+    /**
+     * URL parser.
+     *
+     * @param uri - url
+     * @param path - the request path of the connection
+     * @param loc - An object meant to mimic window.location.
+     *        Defaults to window.location.
+     * @public
+     */
+    function url(uri, path = "", loc) {
+        let obj = uri;
+        // default to window.location
+        loc = loc || (typeof location !== "undefined" && location);
+        if (null == uri)
+            uri = loc.protocol + "//" + loc.host;
+        // relative path support
+        if (typeof uri === "string") {
+            if ("/" === uri.charAt(0)) {
+                if ("/" === uri.charAt(1)) {
+                    uri = loc.protocol + uri;
+                }
+                else {
+                    uri = loc.host + uri;
+                }
+            }
+            if (!/^(https?|wss?):\/\//.test(uri)) {
+                if ("undefined" !== typeof loc) {
+                    uri = loc.protocol + "//" + uri;
+                }
+                else {
+                    uri = "https://" + uri;
+                }
+            }
+            // parse
+            obj = parse(uri);
+        }
+        // make sure we treat `localhost:80` and `localhost` equally
+        if (!obj.port) {
+            if (/^(http|ws)$/.test(obj.protocol)) {
+                obj.port = "80";
+            }
+            else if (/^(http|ws)s$/.test(obj.protocol)) {
+                obj.port = "443";
+            }
+        }
+        obj.path = obj.path || "/";
+        const ipv6 = obj.host.indexOf(":") !== -1;
+        const host = ipv6 ? "[" + obj.host + "]" : obj.host;
+        // define unique id
+        obj.id = obj.protocol + "://" + host + ":" + obj.port + path;
+        // define href
+        obj.href =
+            obj.protocol +
+                "://" +
+                host +
+                (loc && loc.port === obj.port ? "" : ":" + obj.port);
+        return obj;
+    }
+
+    const withNativeArrayBuffer = typeof ArrayBuffer === "function";
+    const isView = (obj) => {
+        return typeof ArrayBuffer.isView === "function"
+            ? ArrayBuffer.isView(obj)
+            : obj.buffer instanceof ArrayBuffer;
+    };
+    const toString = Object.prototype.toString;
+    const withNativeBlob = typeof Blob === "function" ||
+        (typeof Blob !== "undefined" &&
+            toString.call(Blob) === "[object BlobConstructor]");
+    const withNativeFile = typeof File === "function" ||
+        (typeof File !== "undefined" &&
+            toString.call(File) === "[object FileConstructor]");
+    /**
+     * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.
+     *
+     * @private
+     */
+    function isBinary(obj) {
+        return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||
+            (withNativeBlob && obj instanceof Blob) ||
+            (withNativeFile && obj instanceof File));
+    }
+    function hasBinary(obj, toJSON) {
+        if (!obj || typeof obj !== "object") {
+            return false;
+        }
+        if (Array.isArray(obj)) {
+            for (let i = 0, l = obj.length; i < l; i++) {
+                if (hasBinary(obj[i])) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (isBinary(obj)) {
+            return true;
+        }
+        if (obj.toJSON &&
+            typeof obj.toJSON === "function" &&
+            arguments.length === 1) {
+            return hasBinary(obj.toJSON(), true);
+        }
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.
+     *
+     * @param {Object} packet - socket.io event packet
+     * @return {Object} with deconstructed packet and list of buffers
+     * @public
+     */
+    function deconstructPacket(packet) {
+        const buffers = [];
+        const packetData = packet.data;
+        const 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)) {
+            const placeholder = { _placeholder: true, num: buffers.length };
+            buffers.push(data);
+            return placeholder;
+        }
+        else if (Array.isArray(data)) {
+            const newData = new Array(data.length);
+            for (let i = 0; i < data.length; i++) {
+                newData[i] = _deconstructPacket(data[i], buffers);
+            }
+            return newData;
+        }
+        else if (typeof data === "object" && !(data instanceof Date)) {
+            const newData = {};
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    newData[key] = _deconstructPacket(data[key], buffers);
+                }
+            }
+            return newData;
+        }
+        return data;
+    }
+    /**
+     * Reconstructs a binary packet from its placeholder packet and buffers
+     *
+     * @param {Object} packet - event packet with placeholders
+     * @param {Array} buffers - binary buffers to put in placeholder positions
+     * @return {Object} reconstructed packet
+     * @public
+     */
+    function reconstructPacket(packet, buffers) {
+        packet.data = _reconstructPacket(packet.data, buffers);
+        delete packet.attachments; // no longer useful
+        return packet;
+    }
+    function _reconstructPacket(data, buffers) {
+        if (!data)
+            return data;
+        if (data && data._placeholder === true) {
+            const isIndexValid = typeof data.num === "number" &&
+                data.num >= 0 &&
+                data.num < buffers.length;
+            if (isIndexValid) {
+                return buffers[data.num]; // appropriate buffer (should be natural order anyway)
+            }
+            else {
+                throw new Error("illegal attachments");
+            }
+        }
+        else if (Array.isArray(data)) {
+            for (let i = 0; i < data.length; i++) {
+                data[i] = _reconstructPacket(data[i], buffers);
+            }
+        }
+        else if (typeof data === "object") {
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    data[key] = _reconstructPacket(data[key], buffers);
+                }
+            }
+        }
+        return data;
+    }
+
+    /**
+     * These strings must not be used as event names, as they have a special meaning.
+     */
+    const RESERVED_EVENTS$1 = [
+        "connect", // used on the client side
+        "connect_error", // used on the client side
+        "disconnect", // used on both sides
+        "disconnecting", // used on the server side
+        "newListener", // used by the Node.js EventEmitter
+        "removeListener", // used by the Node.js EventEmitter
+    ];
+    var PacketType;
+    (function (PacketType) {
+        PacketType[PacketType["CONNECT"] = 0] = "CONNECT";
+        PacketType[PacketType["DISCONNECT"] = 1] = "DISCONNECT";
+        PacketType[PacketType["EVENT"] = 2] = "EVENT";
+        PacketType[PacketType["ACK"] = 3] = "ACK";
+        PacketType[PacketType["CONNECT_ERROR"] = 4] = "CONNECT_ERROR";
+        PacketType[PacketType["BINARY_EVENT"] = 5] = "BINARY_EVENT";
+        PacketType[PacketType["BINARY_ACK"] = 6] = "BINARY_ACK";
+    })(PacketType || (PacketType = {}));
+    /**
+     * A socket.io Encoder instance
+     */
+    class Encoder {
+        /**
+         * Encoder constructor
+         *
+         * @param {function} replacer - custom replacer to pass down to JSON.parse
+         */
+        constructor(replacer) {
+            this.replacer = replacer;
+        }
+        /**
+         * Encode a packet as a single string if non-binary, or as a
+         * buffer sequence, depending on packet type.
+         *
+         * @param {Object} obj - packet object
+         */
+        encode(obj) {
+            if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {
+                if (hasBinary(obj)) {
+                    return this.encodeAsBinary({
+                        type: obj.type === PacketType.EVENT
+                            ? PacketType.BINARY_EVENT
+                            : PacketType.BINARY_ACK,
+                        nsp: obj.nsp,
+                        data: obj.data,
+                        id: obj.id,
+                    });
+                }
+            }
+            return [this.encodeAsString(obj)];
+        }
+        /**
+         * Encode packet as string.
+         */
+        encodeAsString(obj) {
+            // first is type
+            let 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 `/`
+            // we append it followed by a comma `,`
+            if (obj.nsp && "/" !== obj.nsp) {
+                str += obj.nsp + ",";
+            }
+            // immediately followed by the id
+            if (null != obj.id) {
+                str += obj.id;
+            }
+            // json data
+            if (null != obj.data) {
+                str += JSON.stringify(obj.data, this.replacer);
+            }
+            return str;
+        }
+        /**
+         * Encode packet as 'buffer sequence' by removing blobs, and
+         * deconstructing packet into object with placeholders and
+         * a list of buffers.
+         */
+        encodeAsBinary(obj) {
+            const deconstruction = deconstructPacket(obj);
+            const pack = this.encodeAsString(deconstruction.packet);
+            const buffers = deconstruction.buffers;
+            buffers.unshift(pack); // add packet info to beginning of data list
+            return buffers; // write all the buffers
+        }
+    }
+    /**
+     * A socket.io Decoder instance
+     *
+     * @return {Object} decoder
+     */
+    class Decoder extends Emitter {
+        /**
+         * Decoder constructor
+         */
+        constructor(opts) {
+            super();
+            this.opts = Object.assign({
+                reviver: undefined,
+                maxAttachments: 10,
+            }, typeof opts === "function" ? { reviver: opts } : opts);
+        }
+        /**
+         * Decodes an encoded packet string into packet JSON.
+         *
+         * @param {String} obj - encoded packet
+         */
+        add(obj) {
+            let packet;
+            if (typeof obj === "string") {
+                if (this.reconstructor) {
+                    throw new Error("got plaintext data when reconstructing a packet");
+                }
+                packet = this.decodeString(obj);
+                const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;
+                if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {
+                    packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;
+                    // binary packet's json
+                    this.reconstructor = new BinaryReconstructor(packet);
+                    // no attachments, labeled binary but no binary data to follow
+                    if (packet.attachments === 0) {
+                        super.emitReserved("decoded", packet);
+                    }
+                }
+                else {
+                    // non-binary full packet
+                    super.emitReserved("decoded", packet);
+                }
+            }
+            else if (isBinary(obj) || obj.base64) {
+                // raw binary data
+                if (!this.reconstructor) {
+                    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;
+                        super.emitReserved("decoded", packet);
+                    }
+                }
+            }
+            else {
+                throw new Error("Unknown type: " + obj);
+            }
+        }
+        /**
+         * Decode a packet String (JSON data)
+         *
+         * @param {String} str
+         * @return {Object} packet
+         */
+        decodeString(str) {
+            let i = 0;
+            // look up type
+            const 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
+            if (p.type === PacketType.BINARY_EVENT ||
+                p.type === PacketType.BINARY_ACK) {
+                const start = i + 1;
+                while (str.charAt(++i) !== "-" && i != str.length) { }
+                const buf = str.substring(start, i);
+                if (buf != Number(buf) || str.charAt(i) !== "-") {
+                    throw new Error("Illegal attachments");
+                }
+                const n = Number(buf);
+                if (!isInteger(n) || n < 0) {
+                    throw new Error("Illegal attachments");
+                }
+                else if (n > this.opts.maxAttachments) {
+                    throw new Error("too many attachments");
+                }
+                p.attachments = n;
+            }
+            // look up namespace (if any)
+            if ("/" === str.charAt(i + 1)) {
+                const start = i + 1;
+                while (++i) {
+                    const c = str.charAt(i);
+                    if ("," === c)
+                        break;
+                    if (i === str.length)
+                        break;
+                }
+                p.nsp = str.substring(start, i);
+            }
+            else {
+                p.nsp = "/";
+            }
+            // look up id
+            const next = str.charAt(i + 1);
+            if ("" !== next && Number(next) == next) {
+                const start = i + 1;
+                while (++i) {
+                    const c = str.charAt(i);
+                    if (null == c || Number(c) != c) {
+                        --i;
+                        break;
+                    }
+                    if (i === str.length)
+                        break;
+                }
+                p.id = Number(str.substring(start, i + 1));
+            }
+            // look up json data
+            if (str.charAt(++i)) {
+                const payload = this.tryParse(str.substr(i));
+                if (Decoder.isPayloadValid(p.type, payload)) {
+                    p.data = payload;
+                }
+                else {
+                    throw new Error("invalid payload");
+                }
+            }
+            return p;
+        }
+        tryParse(str) {
+            try {
+                return JSON.parse(str, this.opts.reviver);
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        static isPayloadValid(type, payload) {
+            switch (type) {
+                case PacketType.CONNECT:
+                    return isObject(payload);
+                case PacketType.DISCONNECT:
+                    return payload === undefined;
+                case PacketType.CONNECT_ERROR:
+                    return typeof payload === "string" || isObject(payload);
+                case PacketType.EVENT:
+                case PacketType.BINARY_EVENT:
+                    return (Array.isArray(payload) &&
+                        (typeof payload[0] === "number" ||
+                            (typeof payload[0] === "string" &&
+                                RESERVED_EVENTS$1.indexOf(payload[0]) === -1)));
+                case PacketType.ACK:
+                case PacketType.BINARY_ACK:
+                    return Array.isArray(payload);
+            }
+        }
+        /**
+         * Deallocates a parser's resources
+         */
+        destroy() {
+            if (this.reconstructor) {
+                this.reconstructor.finishedReconstruction();
+                this.reconstructor = null;
+            }
+        }
+    }
+    /**
+     * A manager of a binary event's 'buffer sequence'. Should
+     * be constructed whenever a packet of type BINARY_EVENT is
+     * decoded.
+     *
+     * @param {Object} packet
+     * @return {BinaryReconstructor} initialized reconstructor
+     */
+    class BinaryReconstructor {
+        constructor(packet) {
+            this.packet = packet;
+            this.buffers = [];
+            this.reconPack = packet;
+        }
+        /**
+         * Method to be called when binary data received from connection
+         * after a BINARY_EVENT packet.
+         *
+         * @param {Buffer | ArrayBuffer} binData - the raw binary data received
+         * @return {null | Object} returns null if more binary data is expected or
+         *   a reconstructed packet object if all buffers have been received.
+         */
+        takeBinaryData(binData) {
+            this.buffers.push(binData);
+            if (this.buffers.length === this.reconPack.attachments) {
+                // done with buffer list
+                const packet = reconstructPacket(this.reconPack, this.buffers);
+                this.finishedReconstruction();
+                return packet;
+            }
+            return null;
+        }
+        /**
+         * Cleans up binary packet reconstruction variables.
+         */
+        finishedReconstruction() {
+            this.reconPack = null;
+            this.buffers = [];
+        }
+    }
+    // see https://caniuse.com/mdn-javascript_builtins_number_isinteger
+    const isInteger = Number.isInteger ||
+        function (value) {
+            return (typeof value === "number" &&
+                isFinite(value) &&
+                Math.floor(value) === value);
+        };
+    // 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]";
+    }
+
+    var parser = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        Decoder: Decoder,
+        Encoder: Encoder,
+        get PacketType () { return PacketType; }
+    });
+
+    function on(obj, ev, fn) {
+        obj.on(ev, fn);
+        return function subDestroy() {
+            obj.off(ev, fn);
+        };
+    }
+
+    /**
+     * Internal events.
+     * These events can't be emitted by the user.
+     */
+    const RESERVED_EVENTS = Object.freeze({
+        connect: 1,
+        connect_error: 1,
+        disconnect: 1,
+        disconnecting: 1,
+        // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener
+        newListener: 1,
+        removeListener: 1,
+    });
+    /**
+     * A Socket is the fundamental class for interacting with the server.
+     *
+     * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.
+     *
+     * @example
+     * const socket = io();
+     *
+     * socket.on("connect", () => {
+     *   console.log("connected");
+     * });
+     *
+     * // send an event to the server
+     * socket.emit("foo", "bar");
+     *
+     * socket.on("foobar", () => {
+     *   // an event was received from the server
+     * });
+     *
+     * // upon disconnection
+     * socket.on("disconnect", (reason) => {
+     *   console.log(`disconnected due to ${reason}`);
+     * });
+     */
+    class Socket extends Emitter {
+        /**
+         * `Socket` constructor.
+         */
+        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;
+            this.nsp = nsp;
+            if (opts && opts.auth) {
+                this.auth = opts.auth;
+            }
+            this._opts = Object.assign({}, opts);
+            if (this.io._autoConnect)
+                this.open();
+        }
+        /**
+         * Whether the socket is currently disconnected
+         *
+         * @example
+         * const socket = io();
+         *
+         * socket.on("connect", () => {
+         *   console.log(socket.disconnected); // false
+         * });
+         *
+         * socket.on("disconnect", () => {
+         *   console.log(socket.disconnected); // true
+         * });
+         */
+        get disconnected() {
+            return !this.connected;
+        }
+        /**
+         * Subscribe to open, close and packet events
+         *
+         * @private
+         */
+        subEvents() {
+            if (this.subs)
+                return;
+            const io = this.io;
+            this.subs = [
+                on(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.
+         *
+         * @example
+         * const socket = io();
+         *
+         * console.log(socket.active); // true
+         *
+         * socket.on("disconnect", (reason) => {
+         *   if (reason === "io server disconnect") {
+         *     // the disconnection was initiated by the server, you need to manually reconnect
+         *     console.log(socket.active); // false
+         *   }
+         *   // else the socket will automatically try to reconnect
+         *   console.log(socket.active); // true
+         * });
+         */
+        get active() {
+            return !!this.subs;
+        }
+        /**
+         * "Opens" the socket.
+         *
+         * @example
+         * const socket = io({
+         *   autoConnect: false
+         * });
+         *
+         * socket.connect();
+         */
+        connect() {
+            if (this.connected)
+                return this;
+            this.subEvents();
+            if (!this.io["_reconnecting"])
+                this.io.open(); // ensure open
+            if ("open" === this.io._readyState)
+                this.onopen();
+            return this;
+        }
+        /**
+         * Alias for {@link connect()}.
+         */
+        open() {
+            return this.connect();
+        }
+        /**
+         * Sends a `message` event.
+         *
+         * This method mimics the WebSocket.send() method.
+         *
+         * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+         *
+         * @example
+         * socket.send("hello");
+         *
+         * // this is equivalent to
+         * socket.emit("message", "hello");
+         *
+         * @return self
+         */
+        send(...args) {
+            args.unshift("message");
+            this.emit.apply(this, args);
+            return this;
+        }
+        /**
+         * Override `emit`.
+         * If the event is in `events`, it's emitted normally.
+         *
+         * @example
+         * socket.emit("hello", "world");
+         *
+         * // all serializable datastructures are supported (no need to call JSON.stringify)
+         * socket.emit("hello", 1, "2", { 3: ["4"], 5: Uint8Array.from([6]) });
+         *
+         * // with an acknowledgement from the server
+         * socket.emit("hello", "world", (val) => {
+         *   // ...
+         * });
+         *
+         * @return self
+         */
+        emit(ev, ...args) {
+            var _a, _b, _c;
+            if (RESERVED_EVENTS.hasOwnProperty(ev)) {
+                throw new Error('"' + ev.toString() + '" is a reserved event name');
+            }
+            args.unshift(ev);
+            if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {
+                this._addToQueue(args);
+                return this;
+            }
+            const packet = {
+                type: PacketType.EVENT,
+                data: args,
+            };
+            packet.options = {};
+            packet.options.compress = this.flags.compress !== false;
+            // event ack callback
+            if ("function" === typeof args[args.length - 1]) {
+                const id = this.ids++;
+                const ack = args.pop();
+                this._registerAckCallback(id, ack);
+                packet.id = id;
+            }
+            const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;
+            const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());
+            const discardPacket = this.flags.volatile && !isTransportWritable;
+            if (discardPacket) ;
+            else if (isConnected) {
+                this.notifyOutgoingListeners(packet);
+                this.packet(packet);
+            }
+            else {
+                this.sendBuffer.push(packet);
+            }
+            this.flags = {};
+            return this;
+        }
+        /**
+         * @private
+         */
+        _registerAckCallback(id, ack) {
+            var _a;
+            const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;
+            if (timeout === undefined) {
+                this.acks[id] = ack;
+                return;
+            }
+            // @ts-ignore
+            const timer = this.io.setTimeoutFn(() => {
+                delete this.acks[id];
+                for (let i = 0; i < this.sendBuffer.length; i++) {
+                    if (this.sendBuffer[i].id === id) {
+                        this.sendBuffer.splice(i, 1);
+                    }
+                }
+                ack.call(this, new Error("operation has timed out"));
+            }, timeout);
+            const fn = (...args) => {
+                // @ts-ignore
+                this.io.clearTimeoutFn(timer);
+                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]) ;
+                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.
+         *
+         * @param packet
+         * @private
+         */
+        packet(packet) {
+            packet.nsp = this.nsp;
+            this.io._packet(packet);
+        }
+        /**
+         * Called upon engine `open`.
+         *
+         * @private
+         */
+        onopen() {
+            if (typeof this.auth == "function") {
+                this.auth((data) => {
+                    this._sendConnectPacket(data);
+                });
+            }
+            else {
+                this._sendConnectPacket(this.auth);
+            }
+        }
+        /**
+         * Sends a CONNECT packet to initiate the Socket.IO session.
+         *
+         * @param data
+         * @private
+         */
+        _sendConnectPacket(data) {
+            this.packet({
+                type: PacketType.CONNECT,
+                data: this._pid
+                    ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)
+                    : data,
+            });
+        }
+        /**
+         * Called upon engine or manager `error`.
+         *
+         * @param err
+         * @private
+         */
+        onerror(err) {
+            if (!this.connected) {
+                this.emitReserved("connect_error", err);
+            }
+        }
+        /**
+         * Called upon engine `close`.
+         *
+         * @param reason
+         * @param description
+         * @private
+         */
+        onclose(reason, description) {
+            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.
+         *
+         * @param packet
+         * @private
+         */
+        onpacket(packet) {
+            const sameNamespace = packet.nsp === this.nsp;
+            if (!sameNamespace)
+                return;
+            switch (packet.type) {
+                case PacketType.CONNECT:
+                    if (packet.data && packet.data.sid) {
+                        this.onconnect(packet.data.sid, packet.data.pid);
+                    }
+                    else {
+                        this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)"));
+                    }
+                    break;
+                case 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();
+                    const err = new Error(packet.data.message);
+                    // @ts-ignore
+                    err.data = packet.data.data;
+                    this.emitReserved("connect_error", err);
+                    break;
+            }
+        }
+        /**
+         * Called upon a server event.
+         *
+         * @param packet
+         * @private
+         */
+        onevent(packet) {
+            const args = packet.data || [];
+            if (null != packet.id) {
+                args.push(this.ack(packet.id));
+            }
+            if (this.connected) {
+                this.emitEvent(args);
+            }
+            else {
+                this.receiveBuffer.push(Object.freeze(args));
+            }
+        }
+        emitEvent(args) {
+            if (this._anyListeners && this._anyListeners.length) {
+                const listeners = this._anyListeners.slice();
+                for (const listener of listeners) {
+                    listener.apply(this, args);
+                }
+            }
+            super.emit.apply(this, args);
+            if (this._pid && args.length && typeof args[args.length - 1] === "string") {
+                this._lastOffset = args[args.length - 1];
+            }
+        }
+        /**
+         * Produces an ack callback to emit with an event.
+         *
+         * @private
+         */
+        ack(id) {
+            const self = this;
+            let sent = false;
+            return function (...args) {
+                // prevent double callbacks
+                if (sent)
+                    return;
+                sent = true;
+                self.packet({
+                    type: PacketType.ACK,
+                    id: id,
+                    data: args,
+                });
+            };
+        }
+        /**
+         * Called upon a server acknowledgement.
+         *
+         * @param packet
+         * @private
+         */
+        onack(packet) {
+            const ack = 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, 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._drainQueue(true);
+            this.emitReserved("connect");
+        }
+        /**
+         * Emit buffered events (received and emitted).
+         *
+         * @private
+         */
+        emitBuffered() {
+            this.receiveBuffer.forEach((args) => this.emitEvent(args));
+            this.receiveBuffer = [];
+            this.sendBuffer.forEach((packet) => {
+                this.notifyOutgoingListeners(packet);
+                this.packet(packet);
+            });
+            this.sendBuffer = [];
+        }
+        /**
+         * Called upon server disconnect.
+         *
+         * @private
+         */
+        ondisconnect() {
+            this.destroy();
+            this.onclose("io server disconnect");
+        }
+        /**
+         * Called upon forced client/server side disconnections,
+         * this method ensures the manager stops tracking us and
+         * that reconnections don't get triggered for this.
+         *
+         * @private
+         */
+        destroy() {
+            if (this.subs) {
+                // clean subscriptions to avoid reconnections
+                this.subs.forEach((subDestroy) => subDestroy());
+                this.subs = undefined;
+            }
+            this.io["_destroy"](this);
+        }
+        /**
+         * Disconnects the socket manually. In that case, the socket will not try to reconnect.
+         *
+         * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.
+         *
+         * @example
+         * const socket = io();
+         *
+         * socket.on("disconnect", (reason) => {
+         *   // console.log(reason); prints "io client disconnect"
+         * });
+         *
+         * socket.disconnect();
+         *
+         * @return self
+         */
+        disconnect() {
+            if (this.connected) {
+                this.packet({ type: PacketType.DISCONNECT });
+            }
+            // remove socket from pool
+            this.destroy();
+            if (this.connected) {
+                // fire events
+                this.onclose("io client disconnect");
+            }
+            return this;
+        }
+        /**
+         * Alias for {@link disconnect()}.
+         *
+         * @return self
+         */
+        close() {
+            return this.disconnect();
+        }
+        /**
+         * Sets the compress flag.
+         *
+         * @example
+         * socket.compress(false).emit("hello");
+         *
+         * @param compress - if `true`, compresses the sending data
+         * @return self
+         */
+        compress(compress) {
+            this.flags.compress = compress;
+            return this;
+        }
+        /**
+         * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not
+         * ready to send messages.
+         *
+         * @example
+         * socket.volatile.emit("hello"); // the server may or may not receive it
+         *
+         * @returns self
+         */
+        get volatile() {
+            this.flags.volatile = true;
+            return this;
+        }
+        /**
+         * Sets a modifier for a subsequent event emission that the callback will be called with an error when the
+         * given number of milliseconds have elapsed without an acknowledgement from the server:
+         *
+         * @example
+         * socket.timeout(5000).emit("my-event", (err) => {
+         *   if (err) {
+         *     // the server did not acknowledge the event in the given delay
+         *   }
+         * });
+         *
+         * @returns self
+         */
+        timeout(timeout) {
+            this.flags.timeout = timeout;
+            return this;
+        }
+        /**
+         * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+         * callback.
+         *
+         * @example
+         * socket.onAny((event, ...args) => {
+         *   console.log(`got ${event}`);
+         * });
+         *
+         * @param listener
+         */
+        onAny(listener) {
+            this._anyListeners = this._anyListeners || [];
+            this._anyListeners.push(listener);
+            return this;
+        }
+        /**
+         * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+         * callback. The listener is added to the beginning of the listeners array.
+         *
+         * @example
+         * socket.prependAny((event, ...args) => {
+         *   console.log(`got event ${event}`);
+         * });
+         *
+         * @param listener
+         */
+        prependAny(listener) {
+            this._anyListeners = this._anyListeners || [];
+            this._anyListeners.unshift(listener);
+            return this;
+        }
+        /**
+         * Removes the listener that will be fired when any event is emitted.
+         *
+         * @example
+         * const catchAllListener = (event, ...args) => {
+         *   console.log(`got event ${event}`);
+         * }
+         *
+         * socket.onAny(catchAllListener);
+         *
+         * // remove a specific listener
+         * socket.offAny(catchAllListener);
+         *
+         * // or remove all listeners
+         * socket.offAny();
+         *
+         * @param listener
+         */
+        offAny(listener) {
+            if (!this._anyListeners) {
+                return this;
+            }
+            if (listener) {
+                const listeners = this._anyListeners;
+                for (let i = 0; i < listeners.length; i++) {
+                    if (listener === listeners[i]) {
+                        listeners.splice(i, 1);
+                        return this;
+                    }
+                }
+            }
+            else {
+                this._anyListeners = [];
+            }
+            return this;
+        }
+        /**
+         * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+         * e.g. to remove listeners.
+         */
+        listenersAny() {
+            return this._anyListeners || [];
+        }
+        /**
+         * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+         * callback.
+         *
+         * Note: acknowledgements sent to the server are not included.
+         *
+         * @example
+         * socket.onAnyOutgoing((event, ...args) => {
+         *   console.log(`sent event ${event}`);
+         * });
+         *
+         * @param listener
+         */
+        onAnyOutgoing(listener) {
+            this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+            this._anyOutgoingListeners.push(listener);
+            return this;
+        }
+        /**
+         * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the
+         * callback. The listener is added to the beginning of the listeners array.
+         *
+         * Note: acknowledgements sent to the server are not included.
+         *
+         * @example
+         * socket.prependAnyOutgoing((event, ...args) => {
+         *   console.log(`sent event ${event}`);
+         * });
+         *
+         * @param listener
+         */
+        prependAnyOutgoing(listener) {
+            this._anyOutgoingListeners = this._anyOutgoingListeners || [];
+            this._anyOutgoingListeners.unshift(listener);
+            return this;
+        }
+        /**
+         * Removes the listener that will be fired when any event is emitted.
+         *
+         * @example
+         * const catchAllListener = (event, ...args) => {
+         *   console.log(`sent event ${event}`);
+         * }
+         *
+         * socket.onAnyOutgoing(catchAllListener);
+         *
+         * // remove a specific listener
+         * socket.offAnyOutgoing(catchAllListener);
+         *
+         * // or remove all listeners
+         * socket.offAnyOutgoing();
+         *
+         * @param [listener] - the catch-all listener (optional)
+         */
+        offAnyOutgoing(listener) {
+            if (!this._anyOutgoingListeners) {
+                return this;
+            }
+            if (listener) {
+                const listeners = this._anyOutgoingListeners;
+                for (let i = 0; i < listeners.length; i++) {
+                    if (listener === listeners[i]) {
+                        listeners.splice(i, 1);
+                        return this;
+                    }
+                }
+            }
+            else {
+                this._anyOutgoingListeners = [];
+            }
+            return this;
+        }
+        /**
+         * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,
+         * e.g. to remove listeners.
+         */
+        listenersAnyOutgoing() {
+            return this._anyOutgoingListeners || [];
+        }
+        /**
+         * Notify the listeners for each packet sent
+         *
+         * @param packet
+         *
+         * @private
+         */
+        notifyOutgoingListeners(packet) {
+            if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {
+                const listeners = this._anyOutgoingListeners.slice();
+                for (const listener of listeners) {
+                    listener.apply(this, packet.data);
+                }
+            }
+        }
+    }
+
+    /**
+     * Initialize backoff timer with `opts`.
+     *
+     * - `min` initial timeout in milliseconds [100]
+     * - `max` max timeout [10000]
+     * - `jitter` [0]
+     * - `factor` [2]
+     *
+     * @param {Object} opts
+     * @api public
+     */
+    function Backoff(opts) {
+        opts = opts || {};
+        this.ms = opts.min || 100;
+        this.max = opts.max || 10000;
+        this.factor = opts.factor || 2;
+        this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
+        this.attempts = 0;
+    }
+    /**
+     * Return the backoff duration.
+     *
+     * @return {Number}
+     * @api public
+     */
+    Backoff.prototype.duration = function () {
+        var ms = this.ms * Math.pow(this.factor, this.attempts++);
+        if (this.jitter) {
+            var rand = Math.random();
+            var deviation = Math.floor(rand * this.jitter * ms);
+            ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
+        }
+        return Math.min(ms, this.max) | 0;
+    };
+    /**
+     * Reset the number of attempts.
+     *
+     * @api public
+     */
+    Backoff.prototype.reset = function () {
+        this.attempts = 0;
+    };
+    /**
+     * Set the minimum duration
+     *
+     * @api public
+     */
+    Backoff.prototype.setMin = function (min) {
+        this.ms = min;
+    };
+    /**
+     * Set the maximum duration
+     *
+     * @api public
+     */
+    Backoff.prototype.setMax = function (max) {
+        this.max = max;
+    };
+    /**
+     * Set the jitter
+     *
+     * @api public
+     */
+    Backoff.prototype.setJitter = function (jitter) {
+        this.jitter = jitter;
+    };
+
+    class Manager extends Emitter {
+        constructor(uri, opts) {
+            var _a;
+            super();
+            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(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;
+            const _parser = opts.parser || parser;
+            this.encoder = new _parser.Encoder();
+            this.decoder = new _parser.Decoder();
+            this._autoConnect = opts.autoConnect !== false;
+            if (this._autoConnect)
+                this.open();
+        }
+        reconnection(v) {
+            if (!arguments.length)
+                return this._reconnection;
+            this._reconnection = !!v;
+            if (!v) {
+                this.skipReconnect = true;
+            }
+            return this;
+        }
+        reconnectionAttempts(v) {
+            if (v === undefined)
+                return this._reconnectionAttempts;
+            this._reconnectionAttempts = v;
+            return this;
+        }
+        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);
+            return this;
+        }
+        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);
+            return this;
+        }
+        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);
+            return this;
+        }
+        timeout(v) {
+            if (!arguments.length)
+                return this._timeout;
+            this._timeout = v;
+            return this;
+        }
+        /**
+         * Starts trying to reconnect if reconnection is enabled and we have not
+         * started reconnecting yet
+         *
+         * @private
+         */
+        maybeReconnectOnOpen() {
+            // Only try to reconnect if it's the first time we're connecting
+            if (!this._reconnecting &&
+                this._reconnection &&
+                this.backoff.attempts === 0) {
+                // keeps reconnection from firing twice for the same reconnection loop
+                this.reconnect();
+            }
+        }
+        /**
+         * Sets the current transport `socket`.
+         *
+         * @param {Function} fn - optional, callback
+         * @return self
+         * @public
+         */
+        open(fn) {
+            if (~this._readyState.indexOf("open"))
+                return this;
+            this.engine = new Socket$1(this.uri, this.opts);
+            const socket = this.engine;
+            const self = this;
+            this._readyState = "opening";
+            this.skipReconnect = false;
+            // emit `open`
+            const openSubDestroy = on(socket, "open", function () {
+                self.onopen();
+                fn && fn();
+            });
+            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
+                    this.maybeReconnectOnOpen();
+                }
+            };
+            // emit `error`
+            const errorSub = on(socket, "error", onError);
+            if (false !== this._timeout) {
+                const timeout = this._timeout;
+                // set timer
+                const timer = this.setTimeoutFn(() => {
+                    openSubDestroy();
+                    onError(new Error("timeout"));
+                    socket.close();
+                }, timeout);
+                if (this.opts.autoUnref) {
+                    timer.unref();
+                }
+                this.subs.push(() => {
+                    this.clearTimeoutFn(timer);
+                });
+            }
+            this.subs.push(openSubDestroy);
+            this.subs.push(errorSub);
+            return this;
+        }
+        /**
+         * Alias for open()
+         *
+         * @return self
+         * @public
+         */
+        connect(fn) {
+            return this.open(fn);
+        }
+        /**
+         * Called upon transport open.
+         *
+         * @private
+         */
+        onopen() {
+            // clear old subs
+            this.cleanup();
+            // mark as open
+            this._readyState = "open";
+            this.emitReserved("open");
+            // add new subs
+            const 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)), 
+            // @ts-ignore
+            on(this.decoder, "decoded", this.ondecoded.bind(this)));
+        }
+        /**
+         * Called upon a ping.
+         *
+         * @private
+         */
+        onping() {
+            this.emitReserved("ping");
+        }
+        /**
+         * Called with data.
+         *
+         * @private
+         */
+        ondata(data) {
+            try {
+                this.decoder.add(data);
+            }
+            catch (e) {
+                this.onclose("parse error", e);
+            }
+        }
+        /**
+         * Called when parser fully decodes a packet.
+         *
+         * @private
+         */
+        ondecoded(packet) {
+            // 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.
+         *
+         * @private
+         */
+        onerror(err) {
+            this.emitReserved("error", err);
+        }
+        /**
+         * Creates a new socket for the given `nsp`.
+         *
+         * @return {Socket}
+         * @public
+         */
+        socket(nsp, opts) {
+            let socket = this.nsps[nsp];
+            if (!socket) {
+                socket = new Socket(this, nsp, opts);
+                this.nsps[nsp] = socket;
+            }
+            else if (this._autoConnect && !socket.active) {
+                socket.connect();
+            }
+            return socket;
+        }
+        /**
+         * Called upon a socket close.
+         *
+         * @param socket
+         * @private
+         */
+        _destroy(socket) {
+            const nsps = Object.keys(this.nsps);
+            for (const nsp of nsps) {
+                const socket = this.nsps[nsp];
+                if (socket.active) {
+                    return;
+                }
+            }
+            this._close();
+        }
+        /**
+         * Writes a packet.
+         *
+         * @param packet
+         * @private
+         */
+        _packet(packet) {
+            const encodedPackets = this.encoder.encode(packet);
+            for (let i = 0; i < encodedPackets.length; i++) {
+                this.engine.write(encodedPackets[i], packet.options);
+            }
+        }
+        /**
+         * Clean up transport subscriptions and packet buffer.
+         *
+         * @private
+         */
+        cleanup() {
+            this.subs.forEach((subDestroy) => subDestroy());
+            this.subs.length = 0;
+            this.decoder.destroy();
+        }
+        /**
+         * Close the current socket.
+         *
+         * @private
+         */
+        _close() {
+            this.skipReconnect = true;
+            this._reconnecting = false;
+            this.onclose("forced close");
+        }
+        /**
+         * Alias for close()
+         *
+         * @private
+         */
+        disconnect() {
+            return this._close();
+        }
+        /**
+         * Called when:
+         *
+         * - the low-level engine is closed
+         * - the parser encountered a badly formatted packet
+         * - all sockets are disconnected
+         *
+         * @private
+         */
+        onclose(reason, description) {
+            var _a;
+            this.cleanup();
+            (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();
+            this.backoff.reset();
+            this._readyState = "closed";
+            this.emitReserved("close", reason, description);
+            if (this._reconnection && !this.skipReconnect) {
+                this.reconnect();
+            }
+        }
+        /**
+         * Attempt a reconnection.
+         *
+         * @private
+         */
+        reconnect() {
+            if (this._reconnecting || this.skipReconnect)
+                return this;
+            const self = this;
+            if (this.backoff.attempts >= this._reconnectionAttempts) {
+                this.backoff.reset();
+                this.emitReserved("reconnect_failed");
+                this._reconnecting = false;
+            }
+            else {
+                const delay = this.backoff.duration();
+                this._reconnecting = true;
+                const timer = this.setTimeoutFn(() => {
+                    if (self.skipReconnect)
+                        return;
+                    this.emitReserved("reconnect_attempt", self.backoff.attempts);
+                    // check again for the case socket closed in above events
+                    if (self.skipReconnect)
+                        return;
+                    self.open((err) => {
+                        if (err) {
+                            self._reconnecting = false;
+                            self.reconnect();
+                            this.emitReserved("reconnect_error", err);
+                        }
+                        else {
+                            self.onreconnect();
+                        }
+                    });
+                }, delay);
+                if (this.opts.autoUnref) {
+                    timer.unref();
+                }
+                this.subs.push(() => {
+                    this.clearTimeoutFn(timer);
+                });
+            }
+        }
+        /**
+         * Called upon successful reconnect.
+         *
+         * @private
+         */
+        onreconnect() {
+            const attempt = this.backoff.attempts;
+            this._reconnecting = false;
+            this.backoff.reset();
+            this.emitReserved("reconnect", attempt);
+        }
+    }
+
+    /**
+     * Managers cache.
+     */
+    const cache = {};
+    function lookup(uri, opts) {
+        if (typeof uri === "object") {
+            opts = uri;
+            uri = undefined;
+        }
+        opts = opts || {};
+        const parsed = url(uri, opts.path || "/socket.io");
+        const source = parsed.source;
+        const id = parsed.id;
+        const path = parsed.path;
+        const sameNamespace = cache[id] && path in cache[id]["nsps"];
+        const newConnection = opts.forceNew ||
+            opts["force new connection"] ||
+            false === opts.multiplex ||
+            sameNamespace;
+        let io;
+        if (newConnection) {
+            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
+    // namespace (e.g. `io.connect(...)`), for backward compatibility
+    Object.assign(lookup, {
+        Manager,
+        Socket,
+        io: lookup,
+        connect: lookup,
+    });
+
+    class SocketIOAdapter extends oox.SampleKeepAliveConnectionAdapter {
+        name = 'socketio';
+        OOXEvent = OOXEvent;
+        connectionId = 0;
+        newConnection(identify) {
+            const { id, name } = oox__namespace.config;
+            const headers = {
+                'x-caller': name,
+                'x-caller-id': id,
+            };
+            let mURL;
+            const connectionData = {
+                name: 'anonymous',
+                id: String(++this.connectionId),
+                adapter: this.name,
+                ip: '',
+                token: ''
+            };
+            if ('string' === typeof identify) {
+                mURL = genWebSocketURL(identify);
+            }
+            else if (identify instanceof URL) {
+                mURL = identify;
+            }
+            else if (identify.url) {
+                // KeepAliveConnectionData
+                Object.assign(connectionData, identify);
+                mURL = new URL(identify.url);
+                if (identify.token) {
+                    headers['x-token'] = identify.token;
+                }
+            }
+            else {
+                throw new Error('identify must be string, URL, or KeepAliveConnectionData');
+            }
+            const socket = lookup(mURL.origin, {
+                path: mURL.pathname,
+                extraHeaders: headers
+            });
+            const connection = new oox.KeepAliveConnection(this, socket, connectionData);
+            return connection;
+        }
+    }
+
+    exports.OOXEvent = OOXEvent;
+    exports.Socket = Socket;
+    exports.SocketIOAdapter = SocketIOAdapter;
+    exports.genWebSocketURL = genWebSocketURL;
+    exports.isWebSocketURL = isWebSocketURL;
+
+    return exports;
+
+})({}, oox);
+//# sourceMappingURL=browser.js.map