{"version":3,"file":"vendors/vendors-main-socket.js.bundle.js","mappings":"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","sources":["webpack://typescript/./node_modules/socket.io-client/build/cjs/socket.js","webpack://typescript/./node_modules/engine.io-client/build/cjs/socket.js"],"sourcesContent":["\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Socket = void 0;\nconst socket_io_parser_1 = require(\"socket.io-parser\");\nconst on_js_1 = require(\"./on.js\");\nconst component_emitter_1 = require(\"@socket.io/component-emitter\");\nconst debug_1 = __importDefault(require(\"debug\")); // debug()\nconst debug = (0, debug_1.default)(\"socket.io-client:socket\"); // debug()\n/**\n * Internal events.\n * These events can't be emitted by the user.\n */\nconst RESERVED_EVENTS = Object.freeze({\n    connect: 1,\n    connect_error: 1,\n    disconnect: 1,\n    disconnecting: 1,\n    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener\n    newListener: 1,\n    removeListener: 1,\n});\n/**\n * A Socket is the fundamental class for interacting with the server.\n *\n * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.\n *\n * @example\n * const socket = io();\n *\n * socket.on(\"connect\", () => {\n *   console.log(\"connected\");\n * });\n *\n * // send an event to the server\n * socket.emit(\"foo\", \"bar\");\n *\n * socket.on(\"foobar\", () => {\n *   // an event was received from the server\n * });\n *\n * // upon disconnection\n * socket.on(\"disconnect\", (reason) => {\n *   console.log(`disconnected due to ${reason}`);\n * });\n */\nclass Socket extends component_emitter_1.Emitter {\n    /**\n     * `Socket` constructor.\n     */\n    constructor(io, nsp, opts) {\n        super();\n        /**\n         * Whether the socket is currently connected to the server.\n         *\n         * @example\n         * const socket = io();\n         *\n         * socket.on(\"connect\", () => {\n         *   console.log(socket.connected); // true\n         * });\n         *\n         * socket.on(\"disconnect\", () => {\n         *   console.log(socket.connected); // false\n         * });\n         */\n        this.connected = false;\n        /**\n         * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will\n         * be transmitted by the server.\n         */\n        this.recovered = false;\n        /**\n         * Buffer for packets received before the CONNECT packet\n         */\n        this.receiveBuffer = [];\n        /**\n         * Buffer for packets that will be sent once the socket is connected\n         */\n        this.sendBuffer = [];\n        /**\n         * The queue of packets to be sent with retry in case of failure.\n         *\n         * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.\n         * @private\n         */\n        this._queue = [];\n        /**\n         * A sequence to generate the ID of the {@link QueuedPacket}.\n         * @private\n         */\n        this._queueSeq = 0;\n        this.ids = 0;\n        /**\n         * A map containing acknowledgement handlers.\n         *\n         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:\n         *\n         * - `socket.emit(\"test\", (err, value) => { ... })` with `ackTimeout` option\n         * - `socket.timeout(5000).emit(\"test\", (err, value) => { ... })`\n         * - `const value = await socket.emitWithAck(\"test\")`\n         *\n         * From those that don't:\n         *\n         * - `socket.emit(\"test\", (value) => { ... });`\n         *\n         * In the first case, the handlers will be called with an error when:\n         *\n         * - the timeout is reached\n         * - the socket gets disconnected\n         *\n         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive\n         * an acknowledgement from the server.\n         *\n         * @private\n         */\n        this.acks = {};\n        this.flags = {};\n        this.io = io;\n        this.nsp = nsp;\n        if (opts && opts.auth) {\n            this.auth = opts.auth;\n        }\n        this._opts = Object.assign({}, opts);\n        if (this.io._autoConnect)\n            this.open();\n    }\n    /**\n     * Whether the socket is currently disconnected\n     *\n     * @example\n     * const socket = io();\n     *\n     * socket.on(\"connect\", () => {\n     *   console.log(socket.disconnected); // false\n     * });\n     *\n     * socket.on(\"disconnect\", () => {\n     *   console.log(socket.disconnected); // true\n     * });\n     */\n    get disconnected() {\n        return !this.connected;\n    }\n    /**\n     * Subscribe to open, close and packet events\n     *\n     * @private\n     */\n    subEvents() {\n        if (this.subs)\n            return;\n        const io = this.io;\n        this.subs = [\n            (0, on_js_1.on)(io, \"open\", this.onopen.bind(this)),\n            (0, on_js_1.on)(io, \"packet\", this.onpacket.bind(this)),\n            (0, on_js_1.on)(io, \"error\", this.onerror.bind(this)),\n            (0, on_js_1.on)(io, \"close\", this.onclose.bind(this)),\n        ];\n    }\n    /**\n     * Whether the Socket will try to reconnect when its Manager connects or reconnects.\n     *\n     * @example\n     * const socket = io();\n     *\n     * console.log(socket.active); // true\n     *\n     * socket.on(\"disconnect\", (reason) => {\n     *   if (reason === \"io server disconnect\") {\n     *     // the disconnection was initiated by the server, you need to manually reconnect\n     *     console.log(socket.active); // false\n     *   }\n     *   // else the socket will automatically try to reconnect\n     *   console.log(socket.active); // true\n     * });\n     */\n    get active() {\n        return !!this.subs;\n    }\n    /**\n     * \"Opens\" the socket.\n     *\n     * @example\n     * const socket = io({\n     *   autoConnect: false\n     * });\n     *\n     * socket.connect();\n     */\n    connect() {\n        if (this.connected)\n            return this;\n        this.subEvents();\n        if (!this.io[\"_reconnecting\"])\n            this.io.open(); // ensure open\n        if (\"open\" === this.io._readyState)\n            this.onopen();\n        return this;\n    }\n    /**\n     * Alias for {@link connect()}.\n     */\n    open() {\n        return this.connect();\n    }\n    /**\n     * Sends a `message` event.\n     *\n     * This method mimics the WebSocket.send() method.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send\n     *\n     * @example\n     * socket.send(\"hello\");\n     *\n     * // this is equivalent to\n     * socket.emit(\"message\", \"hello\");\n     *\n     * @return self\n     */\n    send(...args) {\n        args.unshift(\"message\");\n        this.emit.apply(this, args);\n        return this;\n    }\n    /**\n     * Override `emit`.\n     * If the event is in `events`, it's emitted normally.\n     *\n     * @example\n     * socket.emit(\"hello\", \"world\");\n     *\n     * // all serializable datastructures are supported (no need to call JSON.stringify)\n     * socket.emit(\"hello\", 1, \"2\", { 3: [\"4\"], 5: Uint8Array.from([6]) });\n     *\n     * // with an acknowledgement from the server\n     * socket.emit(\"hello\", \"world\", (val) => {\n     *   // ...\n     * });\n     *\n     * @return self\n     */\n    emit(ev, ...args) {\n        var _a, _b, _c;\n        if (RESERVED_EVENTS.hasOwnProperty(ev)) {\n            throw new Error('\"' + ev.toString() + '\" is a reserved event name');\n        }\n        args.unshift(ev);\n        if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {\n            this._addToQueue(args);\n            return this;\n        }\n        const packet = {\n            type: socket_io_parser_1.PacketType.EVENT,\n            data: args,\n        };\n        packet.options = {};\n        packet.options.compress = this.flags.compress !== false;\n        // event ack callback\n        if (\"function\" === typeof args[args.length - 1]) {\n            const id = this.ids++;\n            debug(\"emitting packet with ack id %d\", id);\n            const ack = args.pop();\n            this._registerAckCallback(id, ack);\n            packet.id = id;\n        }\n        const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;\n        const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());\n        const discardPacket = this.flags.volatile && !isTransportWritable;\n        if (discardPacket) {\n            debug(\"discard packet as the transport is not currently writable\");\n        }\n        else if (isConnected) {\n            this.notifyOutgoingListeners(packet);\n            this.packet(packet);\n        }\n        else {\n            this.sendBuffer.push(packet);\n        }\n        this.flags = {};\n        return this;\n    }\n    /**\n     * @private\n     */\n    _registerAckCallback(id, ack) {\n        var _a;\n        const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;\n        if (timeout === undefined) {\n            this.acks[id] = ack;\n            return;\n        }\n        // @ts-ignore\n        const timer = this.io.setTimeoutFn(() => {\n            delete this.acks[id];\n            for (let i = 0; i < this.sendBuffer.length; i++) {\n                if (this.sendBuffer[i].id === id) {\n                    debug(\"removing packet with ack id %d from the buffer\", id);\n                    this.sendBuffer.splice(i, 1);\n                }\n            }\n            debug(\"event with ack id %d has timed out after %d ms\", id, timeout);\n            ack.call(this, new Error(\"operation has timed out\"));\n        }, timeout);\n        const fn = (...args) => {\n            // @ts-ignore\n            this.io.clearTimeoutFn(timer);\n            ack.apply(this, args);\n        };\n        fn.withError = true;\n        this.acks[id] = fn;\n    }\n    /**\n     * Emits an event and waits for an acknowledgement\n     *\n     * @example\n     * // without timeout\n     * const response = await socket.emitWithAck(\"hello\", \"world\");\n     *\n     * // with a specific timeout\n     * try {\n     *   const response = await socket.timeout(1000).emitWithAck(\"hello\", \"world\");\n     * } catch (err) {\n     *   // the server did not acknowledge the event in the given delay\n     * }\n     *\n     * @return a Promise that will be fulfilled when the server acknowledges the event\n     */\n    emitWithAck(ev, ...args) {\n        return new Promise((resolve, reject) => {\n            const fn = (arg1, arg2) => {\n                return arg1 ? reject(arg1) : resolve(arg2);\n            };\n            fn.withError = true;\n            args.push(fn);\n            this.emit(ev, ...args);\n        });\n    }\n    /**\n     * Add the packet to the queue.\n     * @param args\n     * @private\n     */\n    _addToQueue(args) {\n        let ack;\n        if (typeof args[args.length - 1] === \"function\") {\n            ack = args.pop();\n        }\n        const packet = {\n            id: this._queueSeq++,\n            tryCount: 0,\n            pending: false,\n            args,\n            flags: Object.assign({ fromQueue: true }, this.flags),\n        };\n        args.push((err, ...responseArgs) => {\n            if (packet !== this._queue[0]) {\n                // the packet has already been acknowledged\n                return;\n            }\n            const hasError = err !== null;\n            if (hasError) {\n                if (packet.tryCount > this._opts.retries) {\n                    debug(\"packet [%d] is discarded after %d tries\", packet.id, packet.tryCount);\n                    this._queue.shift();\n                    if (ack) {\n                        ack(err);\n                    }\n                }\n            }\n            else {\n                debug(\"packet [%d] was successfully sent\", packet.id);\n                this._queue.shift();\n                if (ack) {\n                    ack(null, ...responseArgs);\n                }\n            }\n            packet.pending = false;\n            return this._drainQueue();\n        });\n        this._queue.push(packet);\n        this._drainQueue();\n    }\n    /**\n     * Send the first packet of the queue, and wait for an acknowledgement from the server.\n     * @param force - whether to resend a packet that has not been acknowledged yet\n     *\n     * @private\n     */\n    _drainQueue(force = false) {\n        debug(\"draining queue\");\n        if (!this.connected || this._queue.length === 0) {\n            return;\n        }\n        const packet = this._queue[0];\n        if (packet.pending && !force) {\n            debug(\"packet [%d] has already been sent and is waiting for an ack\", packet.id);\n            return;\n        }\n        packet.pending = true;\n        packet.tryCount++;\n        debug(\"sending packet [%d] (try n°%d)\", packet.id, packet.tryCount);\n        this.flags = packet.flags;\n        this.emit.apply(this, packet.args);\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param packet\n     * @private\n     */\n    packet(packet) {\n        packet.nsp = this.nsp;\n        this.io._packet(packet);\n    }\n    /**\n     * Called upon engine `open`.\n     *\n     * @private\n     */\n    onopen() {\n        debug(\"transport is open - connecting\");\n        if (typeof this.auth == \"function\") {\n            this.auth((data) => {\n                this._sendConnectPacket(data);\n            });\n        }\n        else {\n            this._sendConnectPacket(this.auth);\n        }\n    }\n    /**\n     * Sends a CONNECT packet to initiate the Socket.IO session.\n     *\n     * @param data\n     * @private\n     */\n    _sendConnectPacket(data) {\n        this.packet({\n            type: socket_io_parser_1.PacketType.CONNECT,\n            data: this._pid\n                ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)\n                : data,\n        });\n    }\n    /**\n     * Called upon engine or manager `error`.\n     *\n     * @param err\n     * @private\n     */\n    onerror(err) {\n        if (!this.connected) {\n            this.emitReserved(\"connect_error\", err);\n        }\n    }\n    /**\n     * Called upon engine `close`.\n     *\n     * @param reason\n     * @param description\n     * @private\n     */\n    onclose(reason, description) {\n        debug(\"close (%s)\", reason);\n        this.connected = false;\n        delete this.id;\n        this.emitReserved(\"disconnect\", reason, description);\n        this._clearAcks();\n    }\n    /**\n     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from\n     * the server.\n     *\n     * @private\n     */\n    _clearAcks() {\n        Object.keys(this.acks).forEach((id) => {\n            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);\n            if (!isBuffered) {\n                // note: handlers that do not accept an error as first argument are ignored here\n                const ack = this.acks[id];\n                delete this.acks[id];\n                if (ack.withError) {\n                    ack.call(this, new Error(\"socket has been disconnected\"));\n                }\n            }\n        });\n    }\n    /**\n     * Called with socket packet.\n     *\n     * @param packet\n     * @private\n     */\n    onpacket(packet) {\n        const sameNamespace = packet.nsp === this.nsp;\n        if (!sameNamespace)\n            return;\n        switch (packet.type) {\n            case socket_io_parser_1.PacketType.CONNECT:\n                if (packet.data && packet.data.sid) {\n                    this.onconnect(packet.data.sid, packet.data.pid);\n                }\n                else {\n                    this.emitReserved(\"connect_error\", new Error(\"It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)\"));\n                }\n                break;\n            case socket_io_parser_1.PacketType.EVENT:\n            case socket_io_parser_1.PacketType.BINARY_EVENT:\n                this.onevent(packet);\n                break;\n            case socket_io_parser_1.PacketType.ACK:\n            case socket_io_parser_1.PacketType.BINARY_ACK:\n                this.onack(packet);\n                break;\n            case socket_io_parser_1.PacketType.DISCONNECT:\n                this.ondisconnect();\n                break;\n            case socket_io_parser_1.PacketType.CONNECT_ERROR:\n                this.destroy();\n                const err = new Error(packet.data.message);\n                // @ts-ignore\n                err.data = packet.data.data;\n                this.emitReserved(\"connect_error\", err);\n                break;\n        }\n    }\n    /**\n     * Called upon a server event.\n     *\n     * @param packet\n     * @private\n     */\n    onevent(packet) {\n        const args = packet.data || [];\n        debug(\"emitting event %j\", args);\n        if (null != packet.id) {\n            debug(\"attaching ack callback to event\");\n            args.push(this.ack(packet.id));\n        }\n        if (this.connected) {\n            this.emitEvent(args);\n        }\n        else {\n            this.receiveBuffer.push(Object.freeze(args));\n        }\n    }\n    emitEvent(args) {\n        if (this._anyListeners && this._anyListeners.length) {\n            const listeners = this._anyListeners.slice();\n            for (const listener of listeners) {\n                listener.apply(this, args);\n            }\n        }\n        super.emit.apply(this, args);\n        if (this._pid && args.length && typeof args[args.length - 1] === \"string\") {\n            this._lastOffset = args[args.length - 1];\n        }\n    }\n    /**\n     * Produces an ack callback to emit with an event.\n     *\n     * @private\n     */\n    ack(id) {\n        const self = this;\n        let sent = false;\n        return function (...args) {\n            // prevent double callbacks\n            if (sent)\n                return;\n            sent = true;\n            debug(\"sending ack %j\", args);\n            self.packet({\n                type: socket_io_parser_1.PacketType.ACK,\n                id: id,\n                data: args,\n            });\n        };\n    }\n    /**\n     * Called upon a server acknowledgement.\n     *\n     * @param packet\n     * @private\n     */\n    onack(packet) {\n        const ack = this.acks[packet.id];\n        if (typeof ack !== \"function\") {\n            debug(\"bad ack %s\", packet.id);\n            return;\n        }\n        delete this.acks[packet.id];\n        debug(\"calling ack %s with %j\", packet.id, packet.data);\n        // @ts-ignore FIXME ack is incorrectly inferred as 'never'\n        if (ack.withError) {\n            packet.data.unshift(null);\n        }\n        // @ts-ignore\n        ack.apply(this, packet.data);\n    }\n    /**\n     * Called upon server connect.\n     *\n     * @private\n     */\n    onconnect(id, pid) {\n        debug(\"socket connected with id %s\", id);\n        this.id = id;\n        this.recovered = pid && this._pid === pid;\n        this._pid = pid; // defined only if connection state recovery is enabled\n        this.connected = true;\n        this.emitBuffered();\n        this.emitReserved(\"connect\");\n        this._drainQueue(true);\n    }\n    /**\n     * Emit buffered events (received and emitted).\n     *\n     * @private\n     */\n    emitBuffered() {\n        this.receiveBuffer.forEach((args) => this.emitEvent(args));\n        this.receiveBuffer = [];\n        this.sendBuffer.forEach((packet) => {\n            this.notifyOutgoingListeners(packet);\n            this.packet(packet);\n        });\n        this.sendBuffer = [];\n    }\n    /**\n     * Called upon server disconnect.\n     *\n     * @private\n     */\n    ondisconnect() {\n        debug(\"server disconnect (%s)\", this.nsp);\n        this.destroy();\n        this.onclose(\"io server disconnect\");\n    }\n    /**\n     * Called upon forced client/server side disconnections,\n     * this method ensures the manager stops tracking us and\n     * that reconnections don't get triggered for this.\n     *\n     * @private\n     */\n    destroy() {\n        if (this.subs) {\n            // clean subscriptions to avoid reconnections\n            this.subs.forEach((subDestroy) => subDestroy());\n            this.subs = undefined;\n        }\n        this.io[\"_destroy\"](this);\n    }\n    /**\n     * Disconnects the socket manually. In that case, the socket will not try to reconnect.\n     *\n     * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.\n     *\n     * @example\n     * const socket = io();\n     *\n     * socket.on(\"disconnect\", (reason) => {\n     *   // console.log(reason); prints \"io client disconnect\"\n     * });\n     *\n     * socket.disconnect();\n     *\n     * @return self\n     */\n    disconnect() {\n        if (this.connected) {\n            debug(\"performing disconnect (%s)\", this.nsp);\n            this.packet({ type: socket_io_parser_1.PacketType.DISCONNECT });\n        }\n        // remove socket from pool\n        this.destroy();\n        if (this.connected) {\n            // fire events\n            this.onclose(\"io client disconnect\");\n        }\n        return this;\n    }\n    /**\n     * Alias for {@link disconnect()}.\n     *\n     * @return self\n     */\n    close() {\n        return this.disconnect();\n    }\n    /**\n     * Sets the compress flag.\n     *\n     * @example\n     * socket.compress(false).emit(\"hello\");\n     *\n     * @param compress - if `true`, compresses the sending data\n     * @return self\n     */\n    compress(compress) {\n        this.flags.compress = compress;\n        return this;\n    }\n    /**\n     * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not\n     * ready to send messages.\n     *\n     * @example\n     * socket.volatile.emit(\"hello\"); // the server may or may not receive it\n     *\n     * @returns self\n     */\n    get volatile() {\n        this.flags.volatile = true;\n        return this;\n    }\n    /**\n     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the\n     * given number of milliseconds have elapsed without an acknowledgement from the server:\n     *\n     * @example\n     * socket.timeout(5000).emit(\"my-event\", (err) => {\n     *   if (err) {\n     *     // the server did not acknowledge the event in the given delay\n     *   }\n     * });\n     *\n     * @returns self\n     */\n    timeout(timeout) {\n        this.flags.timeout = timeout;\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback.\n     *\n     * @example\n     * socket.onAny((event, ...args) => {\n     *   console.log(`got ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    onAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.push(listener);\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback. The listener is added to the beginning of the listeners array.\n     *\n     * @example\n     * socket.prependAny((event, ...args) => {\n     *   console.log(`got event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    prependAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.unshift(listener);\n        return this;\n    }\n    /**\n     * Removes the listener that will be fired when any event is emitted.\n     *\n     * @example\n     * const catchAllListener = (event, ...args) => {\n     *   console.log(`got event ${event}`);\n     * }\n     *\n     * socket.onAny(catchAllListener);\n     *\n     * // remove a specific listener\n     * socket.offAny(catchAllListener);\n     *\n     * // or remove all listeners\n     * socket.offAny();\n     *\n     * @param listener\n     */\n    offAny(listener) {\n        if (!this._anyListeners) {\n            return this;\n        }\n        if (listener) {\n            const listeners = this._anyListeners;\n            for (let i = 0; i < listeners.length; i++) {\n                if (listener === listeners[i]) {\n                    listeners.splice(i, 1);\n                    return this;\n                }\n            }\n        }\n        else {\n            this._anyListeners = [];\n        }\n        return this;\n    }\n    /**\n     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n     * e.g. to remove listeners.\n     */\n    listenersAny() {\n        return this._anyListeners || [];\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback.\n     *\n     * Note: acknowledgements sent to the server are not included.\n     *\n     * @example\n     * socket.onAnyOutgoing((event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    onAnyOutgoing(listener) {\n        this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n        this._anyOutgoingListeners.push(listener);\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback. The listener is added to the beginning of the listeners array.\n     *\n     * Note: acknowledgements sent to the server are not included.\n     *\n     * @example\n     * socket.prependAnyOutgoing((event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    prependAnyOutgoing(listener) {\n        this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n        this._anyOutgoingListeners.unshift(listener);\n        return this;\n    }\n    /**\n     * Removes the listener that will be fired when any event is emitted.\n     *\n     * @example\n     * const catchAllListener = (event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * }\n     *\n     * socket.onAnyOutgoing(catchAllListener);\n     *\n     * // remove a specific listener\n     * socket.offAnyOutgoing(catchAllListener);\n     *\n     * // or remove all listeners\n     * socket.offAnyOutgoing();\n     *\n     * @param [listener] - the catch-all listener (optional)\n     */\n    offAnyOutgoing(listener) {\n        if (!this._anyOutgoingListeners) {\n            return this;\n        }\n        if (listener) {\n            const listeners = this._anyOutgoingListeners;\n            for (let i = 0; i < listeners.length; i++) {\n                if (listener === listeners[i]) {\n                    listeners.splice(i, 1);\n                    return this;\n                }\n            }\n        }\n        else {\n            this._anyOutgoingListeners = [];\n        }\n        return this;\n    }\n    /**\n     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n     * e.g. to remove listeners.\n     */\n    listenersAnyOutgoing() {\n        return this._anyOutgoingListeners || [];\n    }\n    /**\n     * Notify the listeners for each packet sent\n     *\n     * @param packet\n     *\n     * @private\n     */\n    notifyOutgoingListeners(packet) {\n        if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {\n            const listeners = this._anyOutgoingListeners.slice();\n            for (const listener of listeners) {\n                listener.apply(this, packet.data);\n            }\n        }\n    }\n}\nexports.Socket = Socket;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Socket = exports.SocketWithUpgrade = exports.SocketWithoutUpgrade = void 0;\nconst index_js_1 = require(\"./transports/index.js\");\nconst util_js_1 = require(\"./util.js\");\nconst parseqs_js_1 = require(\"./contrib/parseqs.js\");\nconst parseuri_js_1 = require(\"./contrib/parseuri.js\");\nconst component_emitter_1 = require(\"@socket.io/component-emitter\");\nconst engine_io_parser_1 = require(\"engine.io-parser\");\nconst globals_node_js_1 = require(\"./globals.node.js\");\nconst debug_1 = __importDefault(require(\"debug\")); // debug()\nconst debug = (0, debug_1.default)(\"engine.io-client:socket\"); // debug()\nconst withEventListeners = typeof addEventListener === \"function\" &&\n    typeof removeEventListener === \"function\";\nconst OFFLINE_EVENT_LISTENERS = [];\nif (withEventListeners) {\n    // within a ServiceWorker, any event handler for the 'offline' event must be added on the initial evaluation of the\n    // script, so we create one single event listener here which will forward the event to the socket instances\n    addEventListener(\"offline\", () => {\n        debug(\"closing %d connection(s) because the network was lost\", OFFLINE_EVENT_LISTENERS.length);\n        OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());\n    }, false);\n}\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that\n * successfully establishes the connection.\n *\n * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.\n *\n * @example\n * import { SocketWithoutUpgrade, WebSocket } from \"engine.io-client\";\n *\n * const socket = new SocketWithoutUpgrade({\n *   transports: [WebSocket]\n * });\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithUpgrade\n * @see Socket\n */\nclass SocketWithoutUpgrade extends component_emitter_1.Emitter {\n    /**\n     * Socket constructor.\n     *\n     * @param {String|Object} uri - uri or options\n     * @param {Object} opts - options\n     */\n    constructor(uri, opts) {\n        super();\n        this.binaryType = globals_node_js_1.defaultBinaryType;\n        this.writeBuffer = [];\n        this._prevBufferLen = 0;\n        this._pingInterval = -1;\n        this._pingTimeout = -1;\n        this._maxPayload = -1;\n        /**\n         * The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the\n         * callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.\n         */\n        this._pingTimeoutTime = Infinity;\n        if (uri && \"object\" === typeof uri) {\n            opts = uri;\n            uri = null;\n        }\n        if (uri) {\n            const parsedUri = (0, parseuri_js_1.parse)(uri);\n            opts.hostname = parsedUri.host;\n            opts.secure =\n                parsedUri.protocol === \"https\" || parsedUri.protocol === \"wss\";\n            opts.port = parsedUri.port;\n            if (parsedUri.query)\n                opts.query = parsedUri.query;\n        }\n        else if (opts.host) {\n            opts.hostname = (0, parseuri_js_1.parse)(opts.host).host;\n        }\n        (0, util_js_1.installTimerFunctions)(this, opts);\n        this.secure =\n            null != opts.secure\n                ? opts.secure\n                : typeof location !== \"undefined\" && \"https:\" === location.protocol;\n        if (opts.hostname && !opts.port) {\n            // if no port is specified manually, use the protocol default\n            opts.port = this.secure ? \"443\" : \"80\";\n        }\n        this.hostname =\n            opts.hostname ||\n                (typeof location !== \"undefined\" ? location.hostname : \"localhost\");\n        this.port =\n            opts.port ||\n                (typeof location !== \"undefined\" && location.port\n                    ? location.port\n                    : this.secure\n                        ? \"443\"\n                        : \"80\");\n        this.transports = [];\n        this._transportsByName = {};\n        opts.transports.forEach((t) => {\n            const transportName = t.prototype.name;\n            this.transports.push(transportName);\n            this._transportsByName[transportName] = t;\n        });\n        this.opts = Object.assign({\n            path: \"/engine.io\",\n            agent: false,\n            withCredentials: false,\n            upgrade: true,\n            timestampParam: \"t\",\n            rememberUpgrade: false,\n            addTrailingSlash: true,\n            rejectUnauthorized: true,\n            perMessageDeflate: {\n                threshold: 1024,\n            },\n            transportOptions: {},\n            closeOnBeforeunload: false,\n        }, opts);\n        this.opts.path =\n            this.opts.path.replace(/\\/$/, \"\") +\n                (this.opts.addTrailingSlash ? \"/\" : \"\");\n        if (typeof this.opts.query === \"string\") {\n            this.opts.query = (0, parseqs_js_1.decode)(this.opts.query);\n        }\n        if (withEventListeners) {\n            if (this.opts.closeOnBeforeunload) {\n                // Firefox closes the connection when the \"beforeunload\" event is emitted but not Chrome. This event listener\n                // ensures every browser behaves the same (no \"disconnect\" event at the Socket.IO level when the page is\n                // closed/reloaded)\n                this._beforeunloadEventListener = () => {\n                    if (this.transport) {\n                        // silently close the transport\n                        this.transport.removeAllListeners();\n                        this.transport.close();\n                    }\n                };\n                addEventListener(\"beforeunload\", this._beforeunloadEventListener, false);\n            }\n            if (this.hostname !== \"localhost\") {\n                debug(\"adding listener for the 'offline' event\");\n                this._offlineEventListener = () => {\n                    this._onClose(\"transport close\", {\n                        description: \"network connection lost\",\n                    });\n                };\n                OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);\n            }\n        }\n        if (this.opts.withCredentials) {\n            this._cookieJar = (0, globals_node_js_1.createCookieJar)();\n        }\n        this._open();\n    }\n    /**\n     * Creates transport of the given type.\n     *\n     * @param {String} name - transport name\n     * @return {Transport}\n     * @private\n     */\n    createTransport(name) {\n        debug('creating transport \"%s\"', name);\n        const query = Object.assign({}, this.opts.query);\n        // append engine.io protocol identifier\n        query.EIO = engine_io_parser_1.protocol;\n        // transport name\n        query.transport = name;\n        // session id if we already have one\n        if (this.id)\n            query.sid = this.id;\n        const opts = Object.assign({}, this.opts, {\n            query,\n            socket: this,\n            hostname: this.hostname,\n            secure: this.secure,\n            port: this.port,\n        }, this.opts.transportOptions[name]);\n        debug(\"options: %j\", opts);\n        return new this._transportsByName[name](opts);\n    }\n    /**\n     * Initializes transport to use and starts probe.\n     *\n     * @private\n     */\n    _open() {\n        if (this.transports.length === 0) {\n            // Emit error on next tick so it can be listened to\n            this.setTimeoutFn(() => {\n                this.emitReserved(\"error\", \"No transports available\");\n            }, 0);\n            return;\n        }\n        const transportName = this.opts.rememberUpgrade &&\n            SocketWithoutUpgrade.priorWebsocketSuccess &&\n            this.transports.indexOf(\"websocket\") !== -1\n            ? \"websocket\"\n            : this.transports[0];\n        this.readyState = \"opening\";\n        const transport = this.createTransport(transportName);\n        transport.open();\n        this.setTransport(transport);\n    }\n    /**\n     * Sets the current transport. Disables the existing one (if any).\n     *\n     * @private\n     */\n    setTransport(transport) {\n        debug(\"setting transport %s\", transport.name);\n        if (this.transport) {\n            debug(\"clearing existing transport %s\", this.transport.name);\n            this.transport.removeAllListeners();\n        }\n        // set up transport\n        this.transport = transport;\n        // set up transport listeners\n        transport\n            .on(\"drain\", this._onDrain.bind(this))\n            .on(\"packet\", this._onPacket.bind(this))\n            .on(\"error\", this._onError.bind(this))\n            .on(\"close\", (reason) => this._onClose(\"transport close\", reason));\n    }\n    /**\n     * Called when connection is deemed open.\n     *\n     * @private\n     */\n    onOpen() {\n        debug(\"socket open\");\n        this.readyState = \"open\";\n        SocketWithoutUpgrade.priorWebsocketSuccess =\n            \"websocket\" === this.transport.name;\n        this.emitReserved(\"open\");\n        this.flush();\n    }\n    /**\n     * Handles a packet.\n     *\n     * @private\n     */\n    _onPacket(packet) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n            this.emitReserved(\"packet\", packet);\n            // Socket is live - any packet counts\n            this.emitReserved(\"heartbeat\");\n            switch (packet.type) {\n                case \"open\":\n                    this.onHandshake(JSON.parse(packet.data));\n                    break;\n                case \"ping\":\n                    this._sendPacket(\"pong\");\n                    this.emitReserved(\"ping\");\n                    this.emitReserved(\"pong\");\n                    this._resetPingTimeout();\n                    break;\n                case \"error\":\n                    const err = new Error(\"server error\");\n                    // @ts-ignore\n                    err.code = packet.data;\n                    this._onError(err);\n                    break;\n                case \"message\":\n                    this.emitReserved(\"data\", packet.data);\n                    this.emitReserved(\"message\", packet.data);\n                    break;\n            }\n        }\n        else {\n            debug('packet received with socket readyState \"%s\"', this.readyState);\n        }\n    }\n    /**\n     * Called upon handshake completion.\n     *\n     * @param {Object} data - handshake obj\n     * @private\n     */\n    onHandshake(data) {\n        this.emitReserved(\"handshake\", data);\n        this.id = data.sid;\n        this.transport.query.sid = data.sid;\n        this._pingInterval = data.pingInterval;\n        this._pingTimeout = data.pingTimeout;\n        this._maxPayload = data.maxPayload;\n        this.onOpen();\n        // In case open handler closes socket\n        if (\"closed\" === this.readyState)\n            return;\n        this._resetPingTimeout();\n    }\n    /**\n     * Sets and resets ping timeout timer based on server pings.\n     *\n     * @private\n     */\n    _resetPingTimeout() {\n        this.clearTimeoutFn(this._pingTimeoutTimer);\n        const delay = this._pingInterval + this._pingTimeout;\n        this._pingTimeoutTime = Date.now() + delay;\n        this._pingTimeoutTimer = this.setTimeoutFn(() => {\n            this._onClose(\"ping timeout\");\n        }, delay);\n        if (this.opts.autoUnref) {\n            this._pingTimeoutTimer.unref();\n        }\n    }\n    /**\n     * Called on `drain` event\n     *\n     * @private\n     */\n    _onDrain() {\n        this.writeBuffer.splice(0, this._prevBufferLen);\n        // setting prevBufferLen = 0 is very important\n        // for example, when upgrading, upgrade packet is sent over,\n        // and a nonzero prevBufferLen could cause problems on `drain`\n        this._prevBufferLen = 0;\n        if (0 === this.writeBuffer.length) {\n            this.emitReserved(\"drain\");\n        }\n        else {\n            this.flush();\n        }\n    }\n    /**\n     * Flush write buffers.\n     *\n     * @private\n     */\n    flush() {\n        if (\"closed\" !== this.readyState &&\n            this.transport.writable &&\n            !this.upgrading &&\n            this.writeBuffer.length) {\n            const packets = this._getWritablePackets();\n            debug(\"flushing %d packets in socket\", packets.length);\n            this.transport.send(packets);\n            // keep track of current length of writeBuffer\n            // splice writeBuffer and callbackBuffer on `drain`\n            this._prevBufferLen = packets.length;\n            this.emitReserved(\"flush\");\n        }\n    }\n    /**\n     * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP\n     * long-polling)\n     *\n     * @private\n     */\n    _getWritablePackets() {\n        const shouldCheckPayloadSize = this._maxPayload &&\n            this.transport.name === \"polling\" &&\n            this.writeBuffer.length > 1;\n        if (!shouldCheckPayloadSize) {\n            return this.writeBuffer;\n        }\n        let payloadSize = 1; // first packet type\n        for (let i = 0; i < this.writeBuffer.length; i++) {\n            const data = this.writeBuffer[i].data;\n            if (data) {\n                payloadSize += (0, util_js_1.byteLength)(data);\n            }\n            if (i > 0 && payloadSize > this._maxPayload) {\n                debug(\"only send %d out of %d packets\", i, this.writeBuffer.length);\n                return this.writeBuffer.slice(0, i);\n            }\n            payloadSize += 2; // separator + packet type\n        }\n        debug(\"payload size is %d (max: %d)\", payloadSize, this._maxPayload);\n        return this.writeBuffer;\n    }\n    /**\n     * Checks whether the heartbeat timer has expired but the socket has not yet been notified.\n     *\n     * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the\n     * `write()` method then the message would not be buffered by the Socket.IO client.\n     *\n     * @return {boolean}\n     * @private\n     */\n    /* private */ _hasPingExpired() {\n        if (!this._pingTimeoutTime)\n            return true;\n        const hasExpired = Date.now() > this._pingTimeoutTime;\n        if (hasExpired) {\n            debug(\"throttled timer detected, scheduling connection close\");\n            this._pingTimeoutTime = 0;\n            (0, globals_node_js_1.nextTick)(() => {\n                this._onClose(\"ping timeout\");\n            }, this.setTimeoutFn);\n        }\n        return hasExpired;\n    }\n    /**\n     * Sends a message.\n     *\n     * @param {String} msg - message.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @return {Socket} for chaining.\n     */\n    write(msg, options, fn) {\n        this._sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    /**\n     * Sends a message. Alias of {@link Socket#write}.\n     *\n     * @param {String} msg - message.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @return {Socket} for chaining.\n     */\n    send(msg, options, fn) {\n        this._sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param {String} type: packet type.\n     * @param {String} data.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @private\n     */\n    _sendPacket(type, data, options, fn) {\n        if (\"function\" === typeof data) {\n            fn = data;\n            data = undefined;\n        }\n        if (\"function\" === typeof options) {\n            fn = options;\n            options = null;\n        }\n        if (\"closing\" === this.readyState || \"closed\" === this.readyState) {\n            return;\n        }\n        options = options || {};\n        options.compress = false !== options.compress;\n        const packet = {\n            type: type,\n            data: data,\n            options: options,\n        };\n        this.emitReserved(\"packetCreate\", packet);\n        this.writeBuffer.push(packet);\n        if (fn)\n            this.once(\"flush\", fn);\n        this.flush();\n    }\n    /**\n     * Closes the connection.\n     */\n    close() {\n        const close = () => {\n            this._onClose(\"forced close\");\n            debug(\"socket closing - telling transport to close\");\n            this.transport.close();\n        };\n        const cleanupAndClose = () => {\n            this.off(\"upgrade\", cleanupAndClose);\n            this.off(\"upgradeError\", cleanupAndClose);\n            close();\n        };\n        const waitForUpgrade = () => {\n            // wait for upgrade to finish since we can't send packets while pausing a transport\n            this.once(\"upgrade\", cleanupAndClose);\n            this.once(\"upgradeError\", cleanupAndClose);\n        };\n        if (\"opening\" === this.readyState || \"open\" === this.readyState) {\n            this.readyState = \"closing\";\n            if (this.writeBuffer.length) {\n                this.once(\"drain\", () => {\n                    if (this.upgrading) {\n                        waitForUpgrade();\n                    }\n                    else {\n                        close();\n                    }\n                });\n            }\n            else if (this.upgrading) {\n                waitForUpgrade();\n            }\n            else {\n                close();\n            }\n        }\n        return this;\n    }\n    /**\n     * Called upon transport error\n     *\n     * @private\n     */\n    _onError(err) {\n        debug(\"socket error %j\", err);\n        SocketWithoutUpgrade.priorWebsocketSuccess = false;\n        if (this.opts.tryAllTransports &&\n            this.transports.length > 1 &&\n            this.readyState === \"opening\") {\n            debug(\"trying next transport\");\n            this.transports.shift();\n            return this._open();\n        }\n        this.emitReserved(\"error\", err);\n        this._onClose(\"transport error\", err);\n    }\n    /**\n     * Called upon transport close.\n     *\n     * @private\n     */\n    _onClose(reason, description) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            debug('socket close with reason: \"%s\"', reason);\n            // clear timers\n            this.clearTimeoutFn(this._pingTimeoutTimer);\n            // stop event from firing again for transport\n            this.transport.removeAllListeners(\"close\");\n            // ensure transport won't stay open\n            this.transport.close();\n            // ignore further transport communication\n            this.transport.removeAllListeners();\n            if (withEventListeners) {\n                if (this._beforeunloadEventListener) {\n                    removeEventListener(\"beforeunload\", this._beforeunloadEventListener, false);\n                }\n                if (this._offlineEventListener) {\n                    const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);\n                    if (i !== -1) {\n                        debug(\"removing listener for the 'offline' event\");\n                        OFFLINE_EVENT_LISTENERS.splice(i, 1);\n                    }\n                }\n            }\n            // set ready state\n            this.readyState = \"closed\";\n            // clear session id\n            this.id = null;\n            // emit close event\n            this.emitReserved(\"close\", reason, description);\n            // clean buffers after, so users can still\n            // grab the buffers on `close` event\n            this.writeBuffer = [];\n            this._prevBufferLen = 0;\n        }\n    }\n}\nexports.SocketWithoutUpgrade = SocketWithoutUpgrade;\nSocketWithoutUpgrade.protocol = engine_io_parser_1.protocol;\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes with an upgrade mechanism, which means that once the connection is established with the first\n * low-level transport, it will try to upgrade to a better transport.\n *\n * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.\n *\n * @example\n * import { SocketWithUpgrade, WebSocket } from \"engine.io-client\";\n *\n * const socket = new SocketWithUpgrade({\n *   transports: [WebSocket]\n * });\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithoutUpgrade\n * @see Socket\n */\nclass SocketWithUpgrade extends SocketWithoutUpgrade {\n    constructor() {\n        super(...arguments);\n        this._upgrades = [];\n    }\n    onOpen() {\n        super.onOpen();\n        if (\"open\" === this.readyState && this.opts.upgrade) {\n            debug(\"starting upgrade probes\");\n            for (let i = 0; i < this._upgrades.length; i++) {\n                this._probe(this._upgrades[i]);\n            }\n        }\n    }\n    /**\n     * Probes a transport.\n     *\n     * @param {String} name - transport name\n     * @private\n     */\n    _probe(name) {\n        debug('probing transport \"%s\"', name);\n        let transport = this.createTransport(name);\n        let failed = false;\n        SocketWithoutUpgrade.priorWebsocketSuccess = false;\n        const onTransportOpen = () => {\n            if (failed)\n                return;\n            debug('probe transport \"%s\" opened', name);\n            transport.send([{ type: \"ping\", data: \"probe\" }]);\n            transport.once(\"packet\", (msg) => {\n                if (failed)\n                    return;\n                if (\"pong\" === msg.type && \"probe\" === msg.data) {\n                    debug('probe transport \"%s\" pong', name);\n                    this.upgrading = true;\n                    this.emitReserved(\"upgrading\", transport);\n                    if (!transport)\n                        return;\n                    SocketWithoutUpgrade.priorWebsocketSuccess =\n                        \"websocket\" === transport.name;\n                    debug('pausing current transport \"%s\"', this.transport.name);\n                    this.transport.pause(() => {\n                        if (failed)\n                            return;\n                        if (\"closed\" === this.readyState)\n                            return;\n                        debug(\"changing transport and sending upgrade packet\");\n                        cleanup();\n                        this.setTransport(transport);\n                        transport.send([{ type: \"upgrade\" }]);\n                        this.emitReserved(\"upgrade\", transport);\n                        transport = null;\n                        this.upgrading = false;\n                        this.flush();\n                    });\n                }\n                else {\n                    debug('probe transport \"%s\" failed', name);\n                    const err = new Error(\"probe error\");\n                    // @ts-ignore\n                    err.transport = transport.name;\n                    this.emitReserved(\"upgradeError\", err);\n                }\n            });\n        };\n        function freezeTransport() {\n            if (failed)\n                return;\n            // Any callback called by transport should be ignored since now\n            failed = true;\n            cleanup();\n            transport.close();\n            transport = null;\n        }\n        // Handle any error that happens while probing\n        const onerror = (err) => {\n            const error = new Error(\"probe error: \" + err);\n            // @ts-ignore\n            error.transport = transport.name;\n            freezeTransport();\n            debug('probe transport \"%s\" failed because of error: %s', name, err);\n            this.emitReserved(\"upgradeError\", error);\n        };\n        function onTransportClose() {\n            onerror(\"transport closed\");\n        }\n        // When the socket is closed while we're probing\n        function onclose() {\n            onerror(\"socket closed\");\n        }\n        // When the socket is upgraded while we're probing\n        function onupgrade(to) {\n            if (transport && to.name !== transport.name) {\n                debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n                freezeTransport();\n            }\n        }\n        // Remove all listeners on the transport and on self\n        const cleanup = () => {\n            transport.removeListener(\"open\", onTransportOpen);\n            transport.removeListener(\"error\", onerror);\n            transport.removeListener(\"close\", onTransportClose);\n            this.off(\"close\", onclose);\n            this.off(\"upgrading\", onupgrade);\n        };\n        transport.once(\"open\", onTransportOpen);\n        transport.once(\"error\", onerror);\n        transport.once(\"close\", onTransportClose);\n        this.once(\"close\", onclose);\n        this.once(\"upgrading\", onupgrade);\n        if (this._upgrades.indexOf(\"webtransport\") !== -1 &&\n            name !== \"webtransport\") {\n            // favor WebTransport\n            this.setTimeoutFn(() => {\n                if (!failed) {\n                    transport.open();\n                }\n            }, 200);\n        }\n        else {\n            transport.open();\n        }\n    }\n    onHandshake(data) {\n        this._upgrades = this._filterUpgrades(data.upgrades);\n        super.onHandshake(data);\n    }\n    /**\n     * Filters upgrades, returning only those matching client transports.\n     *\n     * @param {Array} upgrades - server upgrades\n     * @private\n     */\n    _filterUpgrades(upgrades) {\n        const filteredUpgrades = [];\n        for (let i = 0; i < upgrades.length; i++) {\n            if (~this.transports.indexOf(upgrades[i]))\n                filteredUpgrades.push(upgrades[i]);\n        }\n        return filteredUpgrades;\n    }\n}\nexports.SocketWithUpgrade = SocketWithUpgrade;\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes with an upgrade mechanism, which means that once the connection is established with the first\n * low-level transport, it will try to upgrade to a better transport.\n *\n * @example\n * import { Socket } from \"engine.io-client\";\n *\n * const socket = new Socket();\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithoutUpgrade\n * @see SocketWithUpgrade\n */\nclass Socket extends SocketWithUpgrade {\n    constructor(uri, opts = {}) {\n        const o = typeof uri === \"object\" ? uri : opts;\n        if (!o.transports ||\n            (o.transports && typeof o.transports[0] === \"string\")) {\n            o.transports = (o.transports || [\"polling\", \"websocket\", \"webtransport\"])\n                .map((transportName) => index_js_1.transports[transportName])\n                .filter((t) => !!t);\n        }\n        super(uri, o);\n    }\n}\nexports.Socket = Socket;\n"],"names":["__importDefault","this","mod","__esModule","Object","defineProperty","exports","value","Socket","socket_io_parser_1","on_js_1","component_emitter_1","debug","default","RESERVED_EVENTS","freeze","connect","connect_error","disconnect","disconnecting","newListener","removeListener","Emitter","constructor","io","nsp","opts","super","connected","recovered","receiveBuffer","sendBuffer","_queue","_queueSeq","ids","acks","flags","auth","_opts","assign","_autoConnect","open","disconnected","subEvents","subs","on","onopen","bind","onpacket","onerror","onclose","active","_readyState","send","args","unshift","emit","apply","ev","_a","_b","_c","hasOwnProperty","Error","toString","retries","fromQueue","volatile","_addToQueue","packet","type","PacketType","EVENT","data","options","compress","length","id","ack","pop","_registerAckCallback","isTransportWritable","engine","transport","writable","isConnected","_hasPingExpired","notifyOutgoingListeners","push","timeout","ackTimeout","undefined","timer","setTimeoutFn","i","splice","call","fn","clearTimeoutFn","withError","emitWithAck","Promise","resolve","reject","arg1","arg2","tryCount","pending","err","responseArgs","shift","_drainQueue","force","_packet","_sendConnectPacket","CONNECT","_pid","pid","offset","_lastOffset","emitReserved","reason","description","_clearAcks","keys","forEach","some","String","sid","onconnect","BINARY_EVENT","onevent","ACK","BINARY_ACK","onack","DISCONNECT","ondisconnect","CONNECT_ERROR","destroy","message","emitEvent","_anyListeners","listeners","slice","listener","self","sent","emitBuffered","subDestroy","close","onAny","prependAny","offAny","listenersAny","onAnyOutgoing","_anyOutgoingListeners","prependAnyOutgoing","offAnyOutgoing","listenersAnyOutgoing","SocketWithUpgrade","SocketWithoutUpgrade","index_js_1","util_js_1","parseqs_js_1","parseuri_js_1","engine_io_parser_1","globals_node_js_1","withEventListeners","addEventListener","removeEventListener","OFFLINE_EVENT_LISTENERS","uri","binaryType","defaultBinaryType","writeBuffer","_prevBufferLen","_pingInterval","_pingTimeout","_maxPayload","_pingTimeoutTime","Infinity","parsedUri","parse","hostname","host","secure","protocol","port","query","installTimerFunctions","location","transports","_transportsByName","t","transportName","prototype","name","path","agent","withCredentials","upgrade","timestampParam","rememberUpgrade","addTrailingSlash","rejectUnauthorized","perMessageDeflate","threshold","transportOptions","closeOnBeforeunload","replace","decode","_beforeunloadEventListener","removeAllListeners","_offlineEventListener","_onClose","_cookieJar","createCookieJar","_open","createTransport","EIO","socket","priorWebsocketSuccess","indexOf","readyState","setTransport","_onDrain","_onPacket","_onError","onOpen","flush","onHandshake","JSON","_sendPacket","_resetPingTimeout","code","pingInterval","pingTimeout","maxPayload","_pingTimeoutTimer","delay","Date","now","autoUnref","unref","upgrading","packets","_getWritablePackets","payloadSize","byteLength","hasExpired","nextTick","write","msg","once","cleanupAndClose","off","waitForUpgrade","tryAllTransports","arguments","_upgrades","_probe","failed","onTransportOpen","pause","cleanup","freezeTransport","error","onTransportClose","onupgrade","to","_filterUpgrades","upgrades","filteredUpgrades","o","map","filter"],"sourceRoot":""}