diff --git a/static/js/socket.io.js b/static/js/socket.io.js index a2b0af2d..785e9d42 100644 --- a/static/js/socket.io.js +++ b/static/js/socket.io.js @@ -1,4440 +1,4887 @@ /*! - * Socket.IO v4.5.0 - * (c) 2014-2022 Guillermo Rauch + * Socket.IO v4.8.4 + * (c) 2014-2026 Guillermo Rauch * Released under the MIT License. */ (function (global, factory) { - typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : - typeof define === 'function' && define.amd ? define(factory) : - (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.io = factory()); - })(this, (function () { 'use strict'; - - function _typeof(obj) { - "@babel/helpers - typeof"; - - if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { - _typeof = function (obj) { - return typeof obj; + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.io = factory()); +})(this, (function () { 'use strict'; + + function _arrayLikeToArray(r, a) { + (null == a || a > r.length) && (a = r.length); + for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; + return n; + } + function _arrayWithoutHoles(r) { + if (Array.isArray(r)) return _arrayLikeToArray(r); + } + function _construct(t, e, r) { + if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); + var o = [null]; + o.push.apply(o, e); + var p = new (t.bind.apply(t, o))(); + return r && _setPrototypeOf(p, r.prototype), p; + } + function _defineProperties(e, r) { + for (var t = 0; t < r.length; t++) { + var o = r[t]; + o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); + } + } + function _createClass(e, r, t) { + return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { + writable: !1 + }), e; + } + function _createForOfIteratorHelper(r, e) { + var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; + if (!t) { + if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { + t && (r = t); + var n = 0, + F = function () {}; + return { + s: F, + n: function () { + return n >= r.length ? { + done: !0 + } : { + done: !1, + value: r[n++] + }; + }, + e: function (r) { + throw r; + }, + f: F }; + } + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + var o, + a = !0, + u = !1; + return { + s: function () { + t = t.call(r); + }, + n: function () { + var r = t.next(); + return a = r.done, r; + }, + e: function (r) { + u = !0, o = r; + }, + f: function () { + try { + a || null == t.return || t.return(); + } finally { + if (u) throw o; + } + } + }; + } + function _extends() { + return _extends = Object.assign ? Object.assign.bind() : function (n) { + for (var e = 1; e < arguments.length; e++) { + var t = arguments[e]; + for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); + } + return n; + }, _extends.apply(null, arguments); + } + function _getPrototypeOf(t) { + return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { + return t.__proto__ || Object.getPrototypeOf(t); + }, _getPrototypeOf(t); + } + function _inheritsLoose(t, o) { + t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); + } + function _isNativeFunction(t) { + try { + return -1 !== Function.toString.call(t).indexOf("[native code]"); + } catch (n) { + return "function" == typeof t; + } + } + function _isNativeReflectConstruct() { + try { + var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); + } catch (t) {} + return (_isNativeReflectConstruct = function () { + return !!t; + })(); + } + function _iterableToArray(r) { + if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); + } + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _setPrototypeOf(t, e) { + return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { + return t.__proto__ = e, t; + }, _setPrototypeOf(t, e); + } + function _toConsumableArray(r) { + return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); + } + function _toPrimitive(t, r) { + if ("object" != typeof t || !t) return t; + var e = t[Symbol.toPrimitive]; + if (void 0 !== e) { + var i = e.call(t, r || "default"); + if ("object" != typeof i) return i; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return ("string" === r ? String : Number)(t); + } + function _toPropertyKey(t) { + var i = _toPrimitive(t, "string"); + return "symbol" == typeof i ? i : i + ""; + } + function _typeof(o) { + "@babel/helpers - typeof"; + + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { + return typeof o; + } : function (o) { + return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; + }, _typeof(o); + } + function _unsupportedIterableToArray(r, a) { + if (r) { + if ("string" == typeof r) return _arrayLikeToArray(r, a); + var t = {}.toString.call(r).slice(8, -1); + return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; + } + } + function _wrapNativeSuper(t) { + var r = "function" == typeof Map ? new Map() : void 0; + return _wrapNativeSuper = function (t) { + if (null === t || !_isNativeFunction(t)) return t; + if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); + if (void 0 !== r) { + if (r.has(t)) return r.get(t); + r.set(t, Wrapper); + } + function Wrapper() { + return _construct(t, arguments, _getPrototypeOf(this).constructor); + } + return Wrapper.prototype = Object.create(t.prototype, { + constructor: { + value: Wrapper, + enumerable: !1, + writable: !0, + configurable: !0 + } + }), _setPrototypeOf(Wrapper, t); + }, _wrapNativeSuper(t); + } + + var 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"; + var PACKET_TYPES_REVERSE = Object.create(null); + Object.keys(PACKET_TYPES).forEach(function (key) { + PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key; + }); + var ERROR_PACKET = { + type: "error", + data: "parser error" + }; + + var withNativeBlob$1 = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]"; + var withNativeArrayBuffer$2 = typeof ArrayBuffer === "function"; + // ArrayBuffer.isView method is not defined in IE10 + var isView$1 = function isView(obj) { + return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer; + }; + var encodePacket = function encodePacket(_ref, supportsBinary, callback) { + var type = _ref.type, + data = _ref.data; + if (withNativeBlob$1 && data instanceof Blob) { + if (supportsBinary) { + return callback(data); } else { - _typeof = function (obj) { - return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; - }; + return encodeBlobAsBase64(data, callback); } - - return _typeof(obj); - } - - function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); + } else if (withNativeArrayBuffer$2 && (data instanceof ArrayBuffer || isView$1(data))) { + if (supportsBinary) { + return callback(data); + } else { + return encodeBlobAsBase64(new Blob([data]), callback); } } - - function _defineProperties(target, props) { - for (var i = 0; i < props.length; i++) { - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); + // plain string + return callback(PACKET_TYPES[type] + (data || "")); + }; + var encodeBlobAsBase64 = function encodeBlobAsBase64(data, callback) { + var fileReader = new FileReader(); + fileReader.onload = function () { + var content = fileReader.result.split(",")[1]; + callback("b" + (content || "")); + }; + return fileReader.readAsDataURL(data); + }; + function toArray(data) { + if (data instanceof Uint8Array) { + return data; + } else if (data instanceof ArrayBuffer) { + return new Uint8Array(data); + } else { + return new Uint8Array(data.buffer, data.byteOffset, data.byteLength); + } + } + var TEXT_ENCODER; + function encodePacketToBinary(packet, callback) { + if (withNativeBlob$1 && packet.data instanceof Blob) { + return packet.data.arrayBuffer().then(toArray).then(callback); + } else if (withNativeArrayBuffer$2 && (packet.data instanceof ArrayBuffer || isView$1(packet.data))) { + return callback(toArray(packet.data)); + } + encodePacket(packet, false, function (encoded) { + if (!TEXT_ENCODER) { + TEXT_ENCODER = new TextEncoder(); + } + callback(TEXT_ENCODER.encode(encoded)); + }); + } + + // imported from https://github.com/socketio/base64-arraybuffer + var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; + // Use a lookup table to find the index. + var lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256); + for (var i = 0; i < chars.length; i++) { + lookup$1[chars.charCodeAt(i)] = i; + } + var decode$1 = function decode(base64) { + var bufferLength = base64.length * 0.75, + len = base64.length, + i, + p = 0, + encoded1, + encoded2, + encoded3, + encoded4; + if (base64[base64.length - 1] === '=') { + bufferLength--; + if (base64[base64.length - 2] === '=') { + bufferLength--; } } - - function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; + var arraybuffer = new ArrayBuffer(bufferLength), + bytes = new Uint8Array(arraybuffer); + for (i = 0; i < len; i += 4) { + encoded1 = lookup$1[base64.charCodeAt(i)]; + encoded2 = lookup$1[base64.charCodeAt(i + 1)]; + encoded3 = lookup$1[base64.charCodeAt(i + 2)]; + encoded4 = lookup$1[base64.charCodeAt(i + 3)]; + bytes[p++] = encoded1 << 2 | encoded2 >> 4; + bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; } - - function _extends() { - _extends = Object.assign || function (target) { - for (var i = 1; i < arguments.length; i++) { - var source = arguments[i]; - - for (var key in source) { - if (Object.prototype.hasOwnProperty.call(source, key)) { - target[key] = source[key]; + return arraybuffer; + }; + + var withNativeArrayBuffer$1 = typeof ArrayBuffer === "function"; + var decodePacket = function decodePacket(encodedPacket, binaryType) { + if (typeof encodedPacket !== "string") { + return { + type: "message", + data: mapBinary(encodedPacket, binaryType) + }; + } + var type = encodedPacket.charAt(0); + if (type === "b") { + return { + type: "message", + data: decodeBase64Packet(encodedPacket.substring(1), binaryType) + }; + } + var packetType = PACKET_TYPES_REVERSE[type]; + if (!packetType) { + return ERROR_PACKET; + } + return encodedPacket.length > 1 ? { + type: PACKET_TYPES_REVERSE[type], + data: encodedPacket.substring(1) + } : { + type: PACKET_TYPES_REVERSE[type] + }; + }; + var decodeBase64Packet = function decodeBase64Packet(data, binaryType) { + if (withNativeArrayBuffer$1) { + var decoded = decode$1(data); + return mapBinary(decoded, binaryType); + } else { + return { + base64: true, + data: data + }; // fallback for old browsers + } + }; + var mapBinary = function 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; + } + } + }; + + var SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text + var encodePayload = function encodePayload(packets, callback) { + // some packets may be added to the array while encoding, so the initial length must be saved + var length = packets.length; + var encodedPackets = new Array(length); + var count = 0; + packets.forEach(function (packet, i) { + // force base64 encoding for binary packets + encodePacket(packet, false, function (encodedPacket) { + encodedPackets[i] = encodedPacket; + if (++count === length) { + callback(encodedPackets.join(SEPARATOR)); + } + }); + }); + }; + var decodePayload = function decodePayload(encodedPayload, binaryType) { + var encodedPackets = encodedPayload.split(SEPARATOR); + var packets = []; + for (var i = 0; i < encodedPackets.length; i++) { + var decodedPacket = decodePacket(encodedPackets[i], binaryType); + packets.push(decodedPacket); + if (decodedPacket.type === "error") { + break; + } + } + return packets; + }; + function createPacketEncoderStream() { + return new TransformStream({ + transform: function transform(packet, controller) { + encodePacketToBinary(packet, function (encodedPacket) { + var payloadLength = encodedPacket.length; + var 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); + var view = new DataView(header.buffer); + view.setUint8(0, 126); + view.setUint16(1, payloadLength); + } else { + header = new Uint8Array(9); + var _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); + }); + } + }); + } + var TEXT_DECODER; + function totalLength(chunks) { + return chunks.reduce(function (acc, chunk) { + return acc + chunk.length; + }, 0); + } + function concatChunks(chunks, size) { + if (chunks[0].length === size) { + return chunks.shift(); + } + var buffer = new Uint8Array(size); + var j = 0; + for (var 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(); + } + var chunks = []; + var state = 0 /* State.READ_HEADER */; + var expectedLength = -1; + var isBinary = false; + return new TransformStream({ + transform: function transform(chunk, controller) { + chunks.push(chunk); + while (true) { + if (state === 0 /* State.READ_HEADER */) { + if (totalLength(chunks) < 1) { + break; + } + var 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; + } + var 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; + } + var _headerArray = concatChunks(chunks, 8); + var view = new DataView(_headerArray.buffer, _headerArray.byteOffset, _headerArray.length); + var 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; + } + var 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; + } + } + } + }); + } + var protocol$1 = 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; + }; + + var nextTick = function () { + var isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function"; + if (isPromiseAvailable) { + return function (cb) { + return Promise.resolve().then(cb); + }; + } else { + return function (cb, setTimeoutFn) { + return setTimeoutFn(cb, 0); + }; + } + }(); + var globalThisShim = function () { + if (typeof self !== "undefined") { + return self; + } else if (typeof window !== "undefined") { + return window; + } else { + return Function("return this")(); + } + }(); + var defaultBinaryType = "arraybuffer"; + function createCookieJar() {} + + function pick(obj) { + for (var _len = arguments.length, attr = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + attr[_key - 1] = arguments[_key]; + } + return attr.reduce(function (acc, k) { + if (obj.hasOwnProperty(k)) { + acc[k] = obj[k]; + } + return acc; + }, {}); + } + // Keep a reference to the real timeout functions so they can be used when overridden + var NATIVE_SET_TIMEOUT = globalThisShim.setTimeout; + var 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) + var BASE64_OVERHEAD = 1.33; + // we could also have used `new Blob([obj]).size`, but it isn't supported in IE9 + function byteLength(obj) { + if (typeof obj === "string") { + return utf8Length(obj); + } + // arraybuffer or blob + return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD); + } + function utf8Length(str) { + var c = 0, + length = 0; + for (var i = 0, l = str.length; i < l; i++) { + c = str.charCodeAt(i); + if (c < 0x80) { + length += 1; + } else if (c < 0x800) { + 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) { + var str = ''; + for (var i in obj) { + if (obj.hasOwnProperty(i)) { + if (str.length) str += '&'; + str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]); + } + } + return str; + } + /** + * Parses a simple querystring into an object + * + * @param {String} qs + * @api private + */ + function decode(qs) { + var qry = {}; + var pairs = qs.split('&'); + for (var i = 0, l = pairs.length; i < l; i++) { + var pair = pairs[i].split('='); + qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]); + } + return qry; + } + + var TransportError = /*#__PURE__*/function (_Error) { + function TransportError(reason, description, context) { + var _this; + _this = _Error.call(this, reason) || this; + _this.description = description; + _this.context = context; + _this.type = "TransportError"; + return _this; + } + _inheritsLoose(TransportError, _Error); + return TransportError; + }( /*#__PURE__*/_wrapNativeSuper(Error)); + var Transport = /*#__PURE__*/function (_Emitter) { + /** + * Transport abstract constructor. + * + * @param {Object} opts - options + * @protected + */ + function Transport(opts) { + var _this2; + _this2 = _Emitter.call(this) || this; + _this2.writable = false; + installTimerFunctions(_this2, opts); + _this2.opts = opts; + _this2.query = opts.query; + _this2.socket = opts.socket; + _this2.supportsBinary = !opts.forceBase64; + return _this2; + } + /** + * Emits an error. + * + * @param {String} reason + * @param description + * @param context - the error context + * @return {Transport} for chaining + * @protected + */ + _inheritsLoose(Transport, _Emitter); + var _proto = Transport.prototype; + _proto.onError = function onError(reason, description, context) { + _Emitter.prototype.emitReserved.call(this, "error", new TransportError(reason, description, context)); + return this; + } + /** + * Opens the transport. + */; + _proto.open = function open() { + this.readyState = "opening"; + this.doOpen(); + return this; + } + /** + * Closes the transport. + */; + _proto.close = function close() { + if (this.readyState === "opening" || this.readyState === "open") { + this.doClose(); + this.onClose(); + } + return this; + } + /** + * Sends multiple packets. + * + * @param {Array} packets + */; + _proto.send = function send(packets) { + if (this.readyState === "open") { + this.write(packets); + } + } + /** + * Called upon open + * + * @protected + */; + _proto.onOpen = function onOpen() { + this.readyState = "open"; + this.writable = true; + _Emitter.prototype.emitReserved.call(this, "open"); + } + /** + * Called with data. + * + * @param {String} data + * @protected + */; + _proto.onData = function onData(data) { + var packet = decodePacket(data, this.socket.binaryType); + this.onPacket(packet); + } + /** + * Called with a decoded packet. + * + * @protected + */; + _proto.onPacket = function onPacket(packet) { + _Emitter.prototype.emitReserved.call(this, "packet", packet); + } + /** + * Called upon close. + * + * @protected + */; + _proto.onClose = function onClose(details) { + this.readyState = "closed"; + _Emitter.prototype.emitReserved.call(this, "close", details); + } + /** + * Pauses the transport, in order not to lose packets during an upgrade. + * + * @param onPause + */; + _proto.pause = function pause(onPause) {}; + _proto.createUri = function createUri(schema) { + var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + return schema + "://" + this._hostname() + this._port() + this.opts.path + this._query(query); + }; + _proto._hostname = function _hostname() { + var hostname = this.opts.hostname; + return hostname.indexOf(":") === -1 ? hostname : "[" + hostname + "]"; + }; + _proto._port = function _port() { + if (this.opts.port && (this.opts.secure && Number(this.opts.port) !== 443 || !this.opts.secure && Number(this.opts.port) !== 80)) { + return ":" + this.opts.port; + } else { + return ""; + } + }; + _proto._query = function _query(query) { + var encodedQuery = encode(query); + return encodedQuery.length ? "?" + encodedQuery : ""; + }; + return Transport; + }(Emitter); + + var Polling = /*#__PURE__*/function (_Transport) { + function Polling() { + var _this; + _this = _Transport.apply(this, arguments) || this; + _this._polling = false; + return _this; + } + _inheritsLoose(Polling, _Transport); + var _proto = Polling.prototype; + /** + * Opens the socket (triggers polling). We write a PING message to determine + * when the transport is open. + * + * @protected + */ + _proto.doOpen = function doOpen() { + this._poll(); + } + /** + * Pauses polling. + * + * @param {Function} onPause - callback upon buffers are flushed and transport is paused + * @package + */; + _proto.pause = function pause(onPause) { + var _this2 = this; + this.readyState = "pausing"; + var pause = function pause() { + _this2.readyState = "paused"; + onPause(); + }; + if (this._polling || !this.writable) { + var total = 0; + if (this._polling) { + total++; + this.once("pollComplete", function () { + --total || pause(); + }); + } + if (!this.writable) { + total++; + this.once("drain", function () { + --total || pause(); + }); + } + } else { + pause(); + } + } + /** + * Starts polling cycle. + * + * @private + */; + _proto._poll = function _poll() { + this._polling = true; + this.doPoll(); + this.emitReserved("poll"); + } + /** + * Overloads onData to detect payloads. + * + * @protected + */; + _proto.onData = function onData(data) { + var _this3 = this; + var callback = function callback(packet) { + // if its the first message we consider the transport open + if ("opening" === _this3.readyState && packet.type === "open") { + _this3.onOpen(); + } + // if its a close packet, we close the ongoing requests + if ("close" === packet.type) { + _this3.onClose({ + description: "transport closed by the server" + }); + return false; + } + // otherwise bypass onData and handle the message + _this3.onPacket(packet); + }; + // decode payload + decodePayload(data, this.socket.binaryType).forEach(callback); + // if an event did not trigger closing + 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 + */; + _proto.doClose = function doClose() { + var _this4 = this; + var close = function close() { + _this4.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 + */; + _proto.write = function write(packets) { + var _this5 = this; + this.writable = false; + encodePayload(packets, function (data) { + _this5.doWrite(data, function () { + _this5.writable = true; + _this5.emitReserved("drain"); + }); + }); + } + /** + * Generates uri for connection. + * + * @private + */; + _proto.uri = function uri() { + var schema = this.opts.secure ? "https" : "http"; + var 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); + }; + return _createClass(Polling, [{ + key: "name", + get: function get() { + return "polling"; + } + }]); + }(Transport); + + // imported from https://github.com/component/has-cors + var value = false; + try { + value = typeof XMLHttpRequest !== 'undefined' && 'withCredentials' in new XMLHttpRequest(); + } catch (err) { + // if XMLHttp support is disabled in IE then it will throw + // when trying to create + } + var hasCORS = value; + + function empty() {} + var BaseXHR = /*#__PURE__*/function (_Polling) { + /** + * XHR Polling constructor. + * + * @param {Object} opts + * @package + */ + function BaseXHR(opts) { + var _this; + _this = _Polling.call(this, opts) || this; + if (typeof location !== "undefined") { + var isSSL = "https:" === location.protocol; + var port = location.port; + // some user agents have empty `location.port` + if (!port) { + port = isSSL ? "443" : "80"; + } + _this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port; + } + return _this; + } + /** + * Sends data. + * + * @param {String} data - data to send. + * @param {Function} fn - called upon flush. + * @private + */ + _inheritsLoose(BaseXHR, _Polling); + var _proto = BaseXHR.prototype; + _proto.doWrite = function doWrite(data, fn) { + var _this2 = this; + var req = this.request({ + method: "POST", + data: data + }); + req.on("success", fn); + req.on("error", function (xhrStatus, context) { + _this2.onError("xhr post error", xhrStatus, context); + }); + } + /** + * Starts a poll cycle. + * + * @private + */; + _proto.doPoll = function doPoll() { + var _this3 = this; + var req = this.request(); + req.on("data", this.onData.bind(this)); + req.on("error", function (xhrStatus, context) { + _this3.onError("xhr poll error", xhrStatus, context); + }); + this.pollXhr = req; + }; + return BaseXHR; + }(Polling); + var Request = /*#__PURE__*/function (_Emitter) { + /** + * Request constructor + * + * @param {Object} options + * @package + */ + function Request(createRequest, uri, opts) { + var _this4; + _this4 = _Emitter.call(this) || this; + _this4.createRequest = createRequest; + installTimerFunctions(_this4, opts); + _this4._opts = opts; + _this4._method = opts.method || "GET"; + _this4._uri = uri; + _this4._data = undefined !== opts.data ? opts.data : null; + _this4._create(); + return _this4; + } + /** + * Creates the XHR object and sends the request. + * + * @private + */ + _inheritsLoose(Request, _Emitter); + var _proto2 = Request.prototype; + _proto2._create = function _create() { + var _this5 = this; + var _a; + var opts = pick(this._opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref"); + opts.xdomain = !!this._opts.xd; + var 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 (var i in this._opts.extraHeaders) { + if (this._opts.extraHeaders.hasOwnProperty(i)) { + xhr.setRequestHeader(i, this._opts.extraHeaders[i]); + } } } - } - - return target; - }; - - return _extends.apply(this, arguments); - } - - function _inherits(subClass, superClass) { - if (typeof superClass !== "function" && superClass !== null) { - throw new TypeError("Super expression must either be null or a function"); - } - - subClass.prototype = Object.create(superClass && superClass.prototype, { - constructor: { - value: subClass, - writable: true, - configurable: true - } - }); - if (superClass) _setPrototypeOf(subClass, superClass); - } - - function _getPrototypeOf(o) { - _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { - return o.__proto__ || Object.getPrototypeOf(o); - }; - return _getPrototypeOf(o); - } - - function _setPrototypeOf(o, p) { - _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { - o.__proto__ = p; - return o; - }; - - return _setPrototypeOf(o, p); - } - - function _isNativeReflectConstruct() { - if (typeof Reflect === "undefined" || !Reflect.construct) return false; - if (Reflect.construct.sham) return false; - if (typeof Proxy === "function") return true; - - try { - Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); - return true; - } catch (e) { - return false; - } - } - - function _construct(Parent, args, Class) { - if (_isNativeReflectConstruct()) { - _construct = Reflect.construct; - } else { - _construct = function _construct(Parent, args, Class) { - var a = [null]; - a.push.apply(a, args); - var Constructor = Function.bind.apply(Parent, a); - var instance = new Constructor(); - if (Class) _setPrototypeOf(instance, Class.prototype); - return instance; - }; - } - - return _construct.apply(null, arguments); - } - - function _isNativeFunction(fn) { - return Function.toString.call(fn).indexOf("[native code]") !== -1; - } - - function _wrapNativeSuper(Class) { - var _cache = typeof Map === "function" ? new Map() : undefined; - - _wrapNativeSuper = function _wrapNativeSuper(Class) { - if (Class === null || !_isNativeFunction(Class)) return Class; - - if (typeof Class !== "function") { - throw new TypeError("Super expression must either be null or a function"); - } - - if (typeof _cache !== "undefined") { - if (_cache.has(Class)) return _cache.get(Class); - - _cache.set(Class, Wrapper); - } - - function Wrapper() { - return _construct(Class, arguments, _getPrototypeOf(this).constructor); - } - - Wrapper.prototype = Object.create(Class.prototype, { - constructor: { - value: Wrapper, - enumerable: false, - writable: true, - configurable: true - } - }); - return _setPrototypeOf(Wrapper, Class); - }; - - return _wrapNativeSuper(Class); - } - - function _assertThisInitialized(self) { - if (self === void 0) { - throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); - } - - return self; - } - - function _possibleConstructorReturn(self, call) { - if (call && (typeof call === "object" || typeof call === "function")) { - return call; - } else if (call !== void 0) { - throw new TypeError("Derived constructors may only return object or undefined"); - } - - return _assertThisInitialized(self); - } - - function _createSuper(Derived) { - var hasNativeReflectConstruct = _isNativeReflectConstruct(); - - return function _createSuperInternal() { - var Super = _getPrototypeOf(Derived), - result; - - if (hasNativeReflectConstruct) { - var NewTarget = _getPrototypeOf(this).constructor; - - result = Reflect.construct(Super, arguments, NewTarget); - } else { - result = Super.apply(this, arguments); - } - - return _possibleConstructorReturn(this, result); - }; - } - - function _superPropBase(object, property) { - while (!Object.prototype.hasOwnProperty.call(object, property)) { - object = _getPrototypeOf(object); - if (object === null) break; - } - - return object; - } - - function _get(target, property, receiver) { - if (typeof Reflect !== "undefined" && Reflect.get) { - _get = Reflect.get; - } else { - _get = function _get(target, property, receiver) { - var base = _superPropBase(target, property); - - if (!base) return; - var desc = Object.getOwnPropertyDescriptor(base, property); - - if (desc.get) { - return desc.get.call(receiver); - } - - return desc.value; - }; - } - - return _get(target, property, receiver || target); - } - - function _unsupportedIterableToArray(o, minLen) { - if (!o) return; - if (typeof o === "string") return _arrayLikeToArray(o, minLen); - var n = Object.prototype.toString.call(o).slice(8, -1); - if (n === "Object" && o.constructor) n = o.constructor.name; - if (n === "Map" || n === "Set") return Array.from(o); - if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); - } - - function _arrayLikeToArray(arr, len) { - if (len == null || len > arr.length) len = arr.length; - - for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; - - return arr2; - } - - function _createForOfIteratorHelper(o, allowArrayLike) { - var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; - - if (!it) { - if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { - if (it) o = it; - var i = 0; - - var F = function () {}; - - return { - s: F, - n: function () { - if (i >= o.length) return { - done: true - }; - return { - done: false, - value: o[i++] - }; - }, - e: function (e) { - throw e; - }, - f: F - }; - } - - throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); - } - - var normalCompletion = true, - didErr = false, - err; - return { - s: function () { - it = it.call(o); - }, - n: function () { - var step = it.next(); - normalCompletion = step.done; - return step; - }, - e: function (e) { - didErr = true; - err = e; - }, - f: function () { + } catch (e) {} + if ("POST" === this._method) { try { - if (!normalCompletion && it.return != null) it.return(); - } finally { - if (didErr) throw err; - } + xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8"); + } catch (e) {} } - }; - } - - var 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"; - var PACKET_TYPES_REVERSE = Object.create(null); - Object.keys(PACKET_TYPES).forEach(function (key) { - PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key; - }); - var ERROR_PACKET = { - type: "error", - data: "parser error" - }; - - var withNativeBlob$1 = typeof Blob === "function" || typeof Blob !== "undefined" && Object.prototype.toString.call(Blob) === "[object BlobConstructor]"; - var withNativeArrayBuffer$2 = typeof ArrayBuffer === "function"; // ArrayBuffer.isView method is not defined in IE10 - - var isView$1 = function isView(obj) { - return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj && obj.buffer instanceof ArrayBuffer; - }; - - var encodePacket = function encodePacket(_ref, supportsBinary, callback) { - var type = _ref.type, - data = _ref.data; - - 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 || "")); - }; - - var encodeBlobAsBase64 = function encodeBlobAsBase64(data, callback) { - var fileReader = new FileReader(); - - fileReader.onload = function () { - var content = fileReader.result.split(",")[1]; - callback("b" + content); - }; - - return fileReader.readAsDataURL(data); - }; - - /* - * base64-arraybuffer 1.0.1 - * Copyright (c) 2022 Niklas von Hertzen - * Released under MIT License - */ - var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; // Use a lookup table to find the index. - - var lookup$1 = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256); - - for (var i$1 = 0; i$1 < chars.length; i$1++) { - lookup$1[chars.charCodeAt(i$1)] = i$1; - } - - var decode$1 = function decode(base64) { - var bufferLength = base64.length * 0.75, - len = base64.length, - i, - p = 0, - encoded1, - encoded2, - encoded3, - encoded4; - - if (base64[base64.length - 1] === '=') { - bufferLength--; - - if (base64[base64.length - 2] === '=') { - bufferLength--; - } - } - - var arraybuffer = new ArrayBuffer(bufferLength), - bytes = new Uint8Array(arraybuffer); - - for (i = 0; i < len; i += 4) { - encoded1 = lookup$1[base64.charCodeAt(i)]; - encoded2 = lookup$1[base64.charCodeAt(i + 1)]; - encoded3 = lookup$1[base64.charCodeAt(i + 2)]; - encoded4 = lookup$1[base64.charCodeAt(i + 3)]; - bytes[p++] = encoded1 << 2 | encoded2 >> 4; - bytes[p++] = (encoded2 & 15) << 4 | encoded3 >> 2; - bytes[p++] = (encoded3 & 3) << 6 | encoded4 & 63; - } - - return arraybuffer; - }; - - var withNativeArrayBuffer$1 = typeof ArrayBuffer === "function"; - - var decodePacket = function decodePacket(encodedPacket, binaryType) { - if (typeof encodedPacket !== "string") { - return { - type: "message", - data: mapBinary(encodedPacket, binaryType) - }; - } - - var type = encodedPacket.charAt(0); - - if (type === "b") { - return { - type: "message", - data: decodeBase64Packet(encodedPacket.substring(1), binaryType) - }; - } - - var packetType = PACKET_TYPES_REVERSE[type]; - - if (!packetType) { - return ERROR_PACKET; - } - - return encodedPacket.length > 1 ? { - type: PACKET_TYPES_REVERSE[type], - data: encodedPacket.substring(1) - } : { - type: PACKET_TYPES_REVERSE[type] - }; - }; - - var decodeBase64Packet = function decodeBase64Packet(data, binaryType) { - if (withNativeArrayBuffer$1) { - var decoded = decode$1(data); - return mapBinary(decoded, binaryType); - } else { - return { - base64: true, - data: data - }; // fallback for old browsers - } - }; - - var mapBinary = function mapBinary(data, binaryType) { - switch (binaryType) { - case "blob": - return data instanceof ArrayBuffer ? new Blob([data]) : data; - - case "arraybuffer": - default: - return data; - // assuming the data is already an ArrayBuffer - } - }; - - var SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text - - var encodePayload = function encodePayload(packets, callback) { - // some packets may be added to the array while encoding, so the initial length must be saved - var length = packets.length; - var encodedPackets = new Array(length); - var count = 0; - packets.forEach(function (packet, i) { - // force base64 encoding for binary packets - encodePacket(packet, false, function (encodedPacket) { - encodedPackets[i] = encodedPacket; - - if (++count === length) { - callback(encodedPackets.join(SEPARATOR)); - } - }); - }); - }; - - var decodePayload = function decodePayload(encodedPayload, binaryType) { - var encodedPackets = encodedPayload.split(SEPARATOR); - var packets = []; - - for (var i = 0; i < encodedPackets.length; i++) { - var decodedPacket = decodePacket(encodedPackets[i], binaryType); - packets.push(decodedPacket); - - if (decodedPacket.type === "error") { - break; - } - } - - return packets; - }; - - var protocol$1 = 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; - }; - - var globalThis = (function () { - if (typeof self !== "undefined") { - return self; - } else if (typeof window !== "undefined") { - return window; - } else { - return Function("return this")(); - } - })(); - - function pick(obj) { - for (var _len = arguments.length, attr = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { - attr[_key - 1] = arguments[_key]; - } - - return attr.reduce(function (acc, k) { - if (obj.hasOwnProperty(k)) { - acc[k] = obj[k]; - } - - return acc; - }, {}); - } // Keep a reference to the real timeout functions so they can be used when overridden - - var NATIVE_SET_TIMEOUT = setTimeout; - var NATIVE_CLEAR_TIMEOUT = clearTimeout; - function installTimerFunctions(obj, opts) { - if (opts.useNativeTimers) { - obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis); - obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis); - } else { - obj.setTimeoutFn = setTimeout.bind(globalThis); - obj.clearTimeoutFn = clearTimeout.bind(globalThis); - } - } // base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64) - - var BASE64_OVERHEAD = 1.33; // we could also have used `new Blob([obj]).size`, but it isn't supported in IE9 - - function byteLength(obj) { - if (typeof obj === "string") { - return utf8Length(obj); - } // arraybuffer or blob - - - return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD); - } - - function utf8Length(str) { - var c = 0, - length = 0; - - for (var i = 0, l = str.length; i < l; i++) { - c = str.charCodeAt(i); - - if (c < 0x80) { - length += 1; - } else if (c < 0x800) { - length += 2; - } else if (c < 0xd800 || c >= 0xe000) { - length += 3; - } else { - i++; - length += 4; - } - } - - return length; - } - - var TransportError = /*#__PURE__*/function (_Error) { - _inherits(TransportError, _Error); - - var _super = _createSuper(TransportError); - - function TransportError(reason, description, context) { - var _this; - - _classCallCheck(this, TransportError); - - _this = _super.call(this, reason); - _this.description = description; - _this.context = context; - _this.type = "TransportError"; - return _this; - } - - return TransportError; - }( /*#__PURE__*/_wrapNativeSuper(Error)); - - var Transport = /*#__PURE__*/function (_Emitter) { - _inherits(Transport, _Emitter); - - var _super2 = _createSuper(Transport); - - /** - * Transport abstract constructor. - * - * @param {Object} options. - * @api private - */ - function Transport(opts) { - var _this2; - - _classCallCheck(this, Transport); - - _this2 = _super2.call(this); - _this2.writable = false; - installTimerFunctions(_assertThisInitialized(_this2), opts); - _this2.opts = opts; - _this2.query = opts.query; - _this2.readyState = ""; - _this2.socket = opts.socket; - return _this2; - } - /** - * Emits an error. - * - * @param {String} reason - * @param description - * @param context - the error context - * @return {Transport} for chaining - * @api protected - */ - - - _createClass(Transport, [{ - key: "onError", - value: function onError(reason, description, context) { - _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "error", new TransportError(reason, description, context)); - - return this; - } - /** - * Opens the transport. - * - * @api public - */ - - }, { - key: "open", - value: function open() { - if ("closed" === this.readyState || "" === this.readyState) { - this.readyState = "opening"; - this.doOpen(); - } - - return this; - } - /** - * Closes the transport. - * - * @api public - */ - - }, { - key: "close", - value: function close() { - if ("opening" === this.readyState || "open" === this.readyState) { - this.doClose(); - this.onClose(); - } - - return this; - } - /** - * Sends multiple packets. - * - * @param {Array} packets - * @api public - */ - - }, { - key: "send", - value: function send(packets) { - if ("open" === this.readyState) { - this.write(packets); - } - } - /** - * Called upon open - * - * @api protected - */ - - }, { - key: "onOpen", - value: function onOpen() { - this.readyState = "open"; - this.writable = true; - - _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "open"); - } - /** - * Called with data. - * - * @param {String} data - * @api protected - */ - - }, { - key: "onData", - value: function onData(data) { - var packet = decodePacket(data, this.socket.binaryType); - this.onPacket(packet); - } - /** - * Called with a decoded packet. - * - * @api protected - */ - - }, { - key: "onPacket", - value: function onPacket(packet) { - _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "packet", packet); - } - /** - * Called upon close. - * - * @api protected - */ - - }, { - key: "onClose", - value: function onClose(details) { - this.readyState = "closed"; - - _get(_getPrototypeOf(Transport.prototype), "emitReserved", this).call(this, "close", details); - } - }]); - - return Transport; - }(Emitter); - - // imported from https://github.com/unshiftio/yeast - - var alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split(''), - length = 64, - map = {}; - var seed = 0, - i = 0, - prev; - /** - * Return a string representing the specified number. - * - * @param {Number} num The number to convert. - * @returns {String} The string representation of the number. - * @api public - */ - - function encode$1(num) { - var encoded = ''; - - do { - encoded = alphabet[num % length] + encoded; - num = Math.floor(num / length); - } while (num > 0); - - return encoded; - } - /** - * Yeast: A tiny growing id generator. - * - * @returns {String} A unique id. - * @api public - */ - - function yeast() { - var now = encode$1(+new Date()); - if (now !== prev) return seed = 0, prev = now; - return now + '.' + encode$1(seed++); - } // - // Map each character to its index. - // - - for (; i < length; i++) { - map[alphabet[i]] = i; - } - - // imported from https://github.com/galkn/querystring - - /** - * Compiles a querystring - * Returns string representation of the object - * - * @param {Object} - * @api private - */ - function encode(obj) { - var str = ''; - - for (var i in obj) { - if (obj.hasOwnProperty(i)) { - if (str.length) str += '&'; - str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]); - } - } - - return str; - } - /** - * Parses a simple querystring into an object - * - * @param {String} qs - * @api private - */ - - function decode(qs) { - var qry = {}; - var pairs = qs.split('&'); - - for (var i = 0, l = pairs.length; i < l; i++) { - var pair = pairs[i].split('='); - qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]); - } - - return qry; - } - - // imported from https://github.com/component/has-cors - var value = false; - - try { - value = typeof XMLHttpRequest !== 'undefined' && 'withCredentials' in new XMLHttpRequest(); - } catch (err) {// if XMLHttp support is disabled in IE then it will throw - // when trying to create - } - - var hasCORS = value; - - // browser shim for xmlhttprequest module - function XMLHttpRequest$1 (opts) { - var xdomain = opts.xdomain; // XMLHttpRequest can be disabled on IE - - try { - if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) { - return new XMLHttpRequest(); - } - } catch (e) {} - - if (!xdomain) { try { - return new globalThis[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP"); + 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 = function () { + var _a; + if (xhr.readyState === 3) { + (_a = _this5._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) { + _this5._onLoad(); + } else { + // make sure the `error` event handler that's user-set + // does not throw in the same tick and gets caught here + _this5.setTimeoutFn(function () { + _this5._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(function () { + _this5._onError(e); + }, 0); + return; + } + if (typeof document !== "undefined") { + this._index = Request.requestsCount++; + Request.requests[this._index] = this; + } + } + /** + * Called upon error. + * + * @private + */; + _proto2._onError = function _onError(err) { + this.emitReserved("error", err, this._xhr); + this._cleanup(true); + } + /** + * Cleans up house. + * + * @private + */; + _proto2._cleanup = function _cleanup(fromError) { + if ("undefined" === typeof this._xhr || null === this._xhr) { + return; + } + this._xhr.onreadystatechange = empty; + if (fromError) { + try { + this._xhr.abort(); } catch (e) {} } + if (typeof document !== "undefined") { + delete Request.requests[this._index]; + } + this._xhr = null; } - - function empty() {} - - var hasXHR2 = function () { - var xhr = new XMLHttpRequest$1({ - xdomain: false - }); - return null != xhr.responseType; - }(); - - var Polling = /*#__PURE__*/function (_Transport) { - _inherits(Polling, _Transport); - - var _super = _createSuper(Polling); - - /** - * XHR Polling constructor. - * - * @param {Object} opts - * @api public - */ - function Polling(opts) { - var _this; - - _classCallCheck(this, Polling); - - _this = _super.call(this, opts); - _this.polling = false; - - if (typeof location !== "undefined") { - var isSSL = "https:" === location.protocol; - var port = location.port; // some user agents have empty `location.port` - - if (!port) { - port = isSSL ? "443" : "80"; - } - - _this.xd = typeof location !== "undefined" && opts.hostname !== location.hostname || port !== opts.port; - _this.xs = opts.secure !== isSSL; - } - /** - * XHR supports binary - */ - - - var forceBase64 = opts && opts.forceBase64; - _this.supportsBinary = hasXHR2 && !forceBase64; - return _this; - } - /** - * Transport name. - */ - - - _createClass(Polling, [{ - key: "name", - get: function get() { - return "polling"; - } - /** - * Opens the socket (triggers polling). We write a PING message to determine - * when the transport is open. - * - * @api private - */ - - }, { - key: "doOpen", - value: function doOpen() { - this.poll(); - } - /** - * Pauses polling. - * - * @param {Function} callback upon buffers are flushed and transport is paused - * @api private - */ - - }, { - key: "pause", - value: function pause(onPause) { - var _this2 = this; - - this.readyState = "pausing"; - - var pause = function pause() { - _this2.readyState = "paused"; - onPause(); - }; - - if (this.polling || !this.writable) { - var total = 0; - - if (this.polling) { - total++; - this.once("pollComplete", function () { - --total || pause(); - }); - } - - if (!this.writable) { - total++; - this.once("drain", function () { - --total || pause(); - }); - } - } else { - pause(); - } - } - /** - * Starts polling cycle. - * - * @api public - */ - - }, { - key: "poll", - value: function poll() { - this.polling = true; - this.doPoll(); - this.emitReserved("poll"); - } - /** - * Overloads onData to detect payloads. - * - * @api private - */ - - }, { - key: "onData", - value: function onData(data) { - var _this3 = this; - - var callback = function callback(packet) { - // if its the first message we consider the transport open - if ("opening" === _this3.readyState && packet.type === "open") { - _this3.onOpen(); - } // if its a close packet, we close the ongoing requests - - - if ("close" === packet.type) { - _this3.onClose({ - description: "transport closed by the server" - }); - - return false; - } // otherwise bypass onData and handle the message - - - _this3.onPacket(packet); - }; // decode payload - - - decodePayload(data, this.socket.binaryType).forEach(callback); // if an event did not trigger closing - - 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. - * - * @api private - */ - - }, { - key: "doClose", - value: function doClose() { - var _this4 = this; - - var close = function close() { - _this4.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} data packets - * @param {Function} drain callback - * @api private - */ - - }, { - key: "write", - value: function write(packets) { - var _this5 = this; - - this.writable = false; - encodePayload(packets, function (data) { - _this5.doWrite(data, function () { - _this5.writable = true; - - _this5.emitReserved("drain"); - }); - }); - } - /** - * Generates uri for connection. - * - * @api private - */ - - }, { - key: "uri", - value: function uri() { - var query = this.query || {}; - var schema = this.opts.secure ? "https" : "http"; - var port = ""; // cache busting is forced - - if (false !== this.opts.timestampRequests) { - query[this.opts.timestampParam] = yeast(); - } - - if (!this.supportsBinary && !query.sid) { - query.b64 = 1; - } // avoid port if default for schema - - - if (this.opts.port && ("https" === schema && Number(this.opts.port) !== 443 || "http" === schema && Number(this.opts.port) !== 80)) { - port = ":" + this.opts.port; - } - - var encodedQuery = encode(query); - var ipv6 = this.opts.hostname.indexOf(":") !== -1; - return schema + "://" + (ipv6 ? "[" + this.opts.hostname + "]" : this.opts.hostname) + port + this.opts.path + (encodedQuery.length ? "?" + encodedQuery : ""); - } - /** - * Creates a request. - * - * @param {String} method - * @api private - */ - - }, { - key: "request", - value: function request() { - var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; - - _extends(opts, { - xd: this.xd, - xs: this.xs - }, this.opts); - - return new Request(this.uri(), opts); - } - /** - * Sends data. - * - * @param {String} data to send. - * @param {Function} called upon flush. - * @api private - */ - - }, { - key: "doWrite", - value: function doWrite(data, fn) { - var _this6 = this; - - var req = this.request({ - method: "POST", - data: data - }); - req.on("success", fn); - req.on("error", function (xhrStatus, context) { - _this6.onError("xhr post error", xhrStatus, context); - }); - } - /** - * Starts a poll cycle. - * - * @api private - */ - - }, { - key: "doPoll", - value: function doPoll() { - var _this7 = this; - - var req = this.request(); - req.on("data", this.onData.bind(this)); - req.on("error", function (xhrStatus, context) { - _this7.onError("xhr poll error", xhrStatus, context); - }); - this.pollXhr = req; - } - }]); - - return Polling; - }(Transport); - var Request = /*#__PURE__*/function (_Emitter) { - _inherits(Request, _Emitter); - - var _super2 = _createSuper(Request); - - /** - * Request constructor - * - * @param {Object} options - * @api public - */ - function Request(uri, opts) { - var _this8; - - _classCallCheck(this, Request); - - _this8 = _super2.call(this); - installTimerFunctions(_assertThisInitialized(_this8), opts); - _this8.opts = opts; - _this8.method = opts.method || "GET"; - _this8.uri = uri; - _this8.async = false !== opts.async; - _this8.data = undefined !== opts.data ? opts.data : null; - - _this8.create(); - - return _this8; - } - /** - * Creates the XHR object and sends the request. - * - * @api private - */ - - - _createClass(Request, [{ - key: "create", - value: function create() { - var _this9 = this; - - var opts = pick(this.opts, "agent", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "autoUnref"); - opts.xdomain = !!this.opts.xd; - opts.xscheme = !!this.opts.xs; - var xhr = this.xhr = new XMLHttpRequest$1(opts); - - try { - xhr.open(this.method, this.uri, this.async); - - try { - if (this.opts.extraHeaders) { - xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true); - - for (var i in this.opts.extraHeaders) { - if (this.opts.extraHeaders.hasOwnProperty(i)) { - xhr.setRequestHeader(i, this.opts.extraHeaders[i]); - } - } - } - } catch (e) {} - - if ("POST" === this.method) { - try { - xhr.setRequestHeader("Content-type", "text/plain;charset=UTF-8"); - } catch (e) {} - } - - try { - xhr.setRequestHeader("Accept", "*/*"); - } catch (e) {} // ie6 check - - - if ("withCredentials" in xhr) { - xhr.withCredentials = this.opts.withCredentials; - } - - if (this.opts.requestTimeout) { - xhr.timeout = this.opts.requestTimeout; - } - - xhr.onreadystatechange = function () { - if (4 !== xhr.readyState) return; - - if (200 === xhr.status || 1223 === xhr.status) { - _this9.onLoad(); - } else { - // make sure the `error` event handler that's user-set - // does not throw in the same tick and gets caught here - _this9.setTimeoutFn(function () { - _this9.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(function () { - _this9.onError(e); - }, 0); - return; - } - - if (typeof document !== "undefined") { - this.index = Request.requestsCount++; - Request.requests[this.index] = this; - } - } - /** - * Called upon error. - * - * @api private - */ - - }, { - key: "onError", - value: function onError(err) { - this.emitReserved("error", err, this.xhr); - this.cleanup(true); - } - /** - * Cleans up house. - * - * @api private - */ - - }, { - key: "cleanup", - value: function cleanup(fromError) { - if ("undefined" === typeof this.xhr || null === this.xhr) { - return; - } - - this.xhr.onreadystatechange = empty; - - if (fromError) { - try { - this.xhr.abort(); - } catch (e) {} - } - - if (typeof document !== "undefined") { - delete Request.requests[this.index]; - } - - this.xhr = null; - } - /** - * Called upon load. - * - * @api private - */ - - }, { - key: "onLoad", - value: function onLoad() { - var data = this.xhr.responseText; - - if (data !== null) { - this.emitReserved("data", data); - this.emitReserved("success"); - this.cleanup(); - } - } - /** - * Aborts the request. - * - * @api public - */ - - }, { - key: "abort", - value: function abort() { - this.cleanup(); - } - }]); - - return Request; - }(Emitter); - 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") { - var terminationEvent = "onpagehide" in globalThis ? "pagehide" : "unload"; - addEventListener(terminationEvent, unloadHandler, false); - } - } - - function unloadHandler() { - for (var i in Request.requests) { - if (Request.requests.hasOwnProperty(i)) { - Request.requests[i].abort(); - } - } - } - - var nextTick = function () { - var isPromiseAvailable = typeof Promise === "function" && typeof Promise.resolve === "function"; - - if (isPromiseAvailable) { - return function (cb) { - return Promise.resolve().then(cb); - }; - } else { - return function (cb, setTimeoutFn) { - return setTimeoutFn(cb, 0); - }; - } - }(); - var WebSocket = globalThis.WebSocket || globalThis.MozWebSocket; - var usingBrowserWebSocket = true; - var defaultBinaryType = "arraybuffer"; - - var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative"; - var WS = /*#__PURE__*/function (_Transport) { - _inherits(WS, _Transport); - - var _super = _createSuper(WS); - - /** - * WebSocket transport constructor. - * - * @api {Object} connection options - * @api public - */ - function WS(opts) { - var _this; - - _classCallCheck(this, WS); - - _this = _super.call(this, opts); - _this.supportsBinary = !opts.forceBase64; - return _this; - } - /** - * Transport name. - * - * @api public - */ - - - _createClass(WS, [{ - key: "name", - get: function get() { - return "websocket"; - } - /** - * Opens socket. - * - * @api private - */ - - }, { - key: "doOpen", - value: function doOpen() { - if (!this.check()) { - // let probe timeout - return; - } - - var uri = this.uri(); - var protocols = this.opts.protocols; // React Native only supports the 'headers' option, and will print a warning if anything else is passed - - var opts = isReactNative ? {} : pick(this.opts, "agent", "perMessageDeflate", "pfx", "key", "passphrase", "cert", "ca", "ciphers", "rejectUnauthorized", "localAddress", "protocolVersion", "origin", "maxPayload", "family", "checkServerIdentity"); - - if (this.opts.extraHeaders) { - opts.headers = this.opts.extraHeaders; - } - - try { - this.ws = usingBrowserWebSocket && !isReactNative ? protocols ? new WebSocket(uri, protocols) : new WebSocket(uri) : new WebSocket(uri, protocols, opts); - } catch (err) { - return this.emitReserved("error", err); - } - - this.ws.binaryType = this.socket.binaryType || defaultBinaryType; - this.addEventListeners(); - } - /** - * Adds event listeners to the socket - * - * @api private - */ - - }, { - key: "addEventListeners", - value: function addEventListeners() { - var _this2 = this; - - this.ws.onopen = function () { - if (_this2.opts.autoUnref) { - _this2.ws._socket.unref(); - } - - _this2.onOpen(); - }; - - this.ws.onclose = function (closeEvent) { - return _this2.onClose({ - description: "websocket connection closed", - context: closeEvent - }); - }; - - this.ws.onmessage = function (ev) { - return _this2.onData(ev.data); - }; - - this.ws.onerror = function (e) { - return _this2.onError("websocket error", e); - }; - } - /** - * Writes data to socket. - * - * @param {Array} array of packets. - * @api private - */ - - }, { - key: "write", - value: function write(packets) { - var _this3 = this; - - this.writable = false; // encodePacket efficient as it uses WS framing - // no need for encodePayload - - var _loop = function _loop(i) { - var packet = packets[i]; - var lastPacket = i === packets.length - 1; - encodePacket(packet, _this3.supportsBinary, function (data) { - // always create a new object (GH-437) - var opts = {}; - // have a chance of informing us about it yet, in that case send will - // throw an error - - - try { - if (usingBrowserWebSocket) { - // TypeError is thrown when passing the second argument on Safari - _this3.ws.send(data); - } - } catch (e) {} - - if (lastPacket) { - // fake drain - // defer to next tick to allow Socket to clear writeBuffer - nextTick(function () { - _this3.writable = true; - - _this3.emitReserved("drain"); - }, _this3.setTimeoutFn); - } - }); - }; - - for (var i = 0; i < packets.length; i++) { - _loop(i); - } - } - /** - * Closes socket. - * - * @api private - */ - - }, { - key: "doClose", - value: function doClose() { - if (typeof this.ws !== "undefined") { - this.ws.close(); - this.ws = null; - } - } - /** - * Generates uri for connection. - * - * @api private - */ - - }, { - key: "uri", - value: function uri() { - var query = this.query || {}; - var schema = this.opts.secure ? "wss" : "ws"; - var port = ""; // avoid port if default for schema - - if (this.opts.port && ("wss" === schema && Number(this.opts.port) !== 443 || "ws" === schema && Number(this.opts.port) !== 80)) { - port = ":" + this.opts.port; - } // append timestamp to URI - - - if (this.opts.timestampRequests) { - query[this.opts.timestampParam] = yeast(); - } // communicate binary support capabilities - - - if (!this.supportsBinary) { - query.b64 = 1; - } - - var encodedQuery = encode(query); - var ipv6 = this.opts.hostname.indexOf(":") !== -1; - return schema + "://" + (ipv6 ? "[" + this.opts.hostname + "]" : this.opts.hostname) + port + this.opts.path + (encodedQuery.length ? "?" + encodedQuery : ""); - } - /** - * Feature detection for WebSocket. - * - * @return {Boolean} whether this transport is available. - * @api public - */ - - }, { - key: "check", - value: function check() { - return !!WebSocket && !("__initialize" in WebSocket && this.name === WS.prototype.name); - } - }]); - - return WS; - }(Transport); - - var transports = { - websocket: WS, - polling: Polling - }; - - // imported from https://github.com/galkn/parseuri - - /** - * Parses an URI + * Called upon load. * - * @author Steven Levithan (MIT license) - * @api private - */ - var re = /^(?:(?![^:@]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/; - var parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor']; - function parse(str) { - var 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); + * @private + */; + _proto2._onLoad = function _onLoad() { + var data = this._xhr.responseText; + if (data !== null) { + this.emitReserved("data", data); + this.emitReserved("success"); + this._cleanup(); } - - var 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) { - var regx = /\/{2,9}/g, - names = path.replace(regx, "/").split("/"); - - if (path.substr(0, 1) == '/' || path.length === 0) { - names.splice(0, 1); - } - - if (path.substr(path.length - 1, 1) == '/') { - names.splice(names.length - 1, 1); - } - - return names; + /** + * Aborts the request. + * + * @package + */; + _proto2.abort = function abort() { + this._cleanup(); + }; + return Request; + }(Emitter); + 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") { + var terminationEvent = "onpagehide" in globalThisShim ? "pagehide" : "unload"; + addEventListener(terminationEvent, unloadHandler, false); } - - function queryKey(uri, query) { - var data = {}; - query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) { - if ($1) { - data[$1] = $2; - } - }); - return data; - } - - var Socket$1 = /*#__PURE__*/function (_Emitter) { - _inherits(Socket, _Emitter); - - var _super = _createSuper(Socket); - - /** - * Socket constructor. - * - * @param {String|Object} uri or options - * @param {Object} opts - options - * @api public - */ - function Socket(uri) { - var _this; - - var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; - - _classCallCheck(this, Socket); - - _this = _super.call(this); - - if (uri && "object" === _typeof(uri)) { - opts = uri; - uri = null; - } - - if (uri) { - uri = parse(uri); - opts.hostname = uri.host; - opts.secure = uri.protocol === "https" || uri.protocol === "wss"; - opts.port = uri.port; - if (uri.query) opts.query = uri.query; - } else if (opts.host) { - opts.hostname = parse(opts.host).host; - } - - installTimerFunctions(_assertThisInitialized(_this), opts); - _this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol; - - if (opts.hostname && !opts.port) { - // if no port is specified manually, use the protocol default - opts.port = _this.secure ? "443" : "80"; - } - - _this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost"); - _this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : _this.secure ? "443" : "80"); - _this.transports = opts.transports || ["polling", "websocket"]; - _this.readyState = ""; - _this.writeBuffer = []; - _this.prevBufferLen = 0; - _this.opts = _extends({ - path: "/engine.io", - agent: false, - withCredentials: false, - upgrade: true, - timestampParam: "t", - rememberUpgrade: false, - rejectUnauthorized: true, - perMessageDeflate: { - threshold: 1024 - }, - transportOptions: {}, - closeOnBeforeunload: true - }, opts); - _this.opts.path = _this.opts.path.replace(/\/$/, "") + "/"; - - if (typeof _this.opts.query === "string") { - _this.opts.query = decode(_this.opts.query); - } // set on handshake - - - _this.id = null; - _this.upgrades = null; - _this.pingInterval = null; - _this.pingTimeout = null; // set on heartbeat - - _this.pingTimeoutTimer = null; - - if (typeof addEventListener === "function") { - if (_this.opts.closeOnBeforeunload) { - // Firefox closes the connection when the "beforeunload" event is emitted but not Chrome. This event listener - // ensures every browser behaves the same (no "disconnect" event at the Socket.IO level when the page is - // closed/reloaded) - addEventListener("beforeunload", function () { - if (_this.transport) { - // silently close the transport - _this.transport.removeAllListeners(); - - _this.transport.close(); - } - }, false); - } - - if (_this.hostname !== "localhost") { - _this.offlineEventListener = function () { - _this.onClose("transport close", { - description: "network connection lost" - }); - }; - - addEventListener("offline", _this.offlineEventListener, false); - } - } - - _this.open(); - - return _this; + } + function unloadHandler() { + for (var i in Request.requests) { + if (Request.requests.hasOwnProperty(i)) { + Request.requests[i].abort(); } - /** - * Creates transport of the given type. - * - * @param {String} transport name - * @return {Transport} - * @api private - */ - - - _createClass(Socket, [{ - key: "createTransport", - value: function createTransport(name) { - var query = _extends({}, this.opts.query); // append engine.io protocol identifier - - - query.EIO = protocol$1; // transport name - - query.transport = name; // session id if we already have one - - if (this.id) query.sid = this.id; - - var opts = _extends({}, this.opts.transportOptions[name], this.opts, { - query: query, - socket: this, - hostname: this.hostname, - secure: this.secure, - port: this.port - }); - - return new transports[name](opts); + } + } + var hasXHR2 = function () { + var 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 + */ + var XHR = /*#__PURE__*/function (_BaseXHR) { + function XHR(opts) { + var _this6; + _this6 = _BaseXHR.call(this, opts) || this; + var forceBase64 = opts && opts.forceBase64; + _this6.supportsBinary = hasXHR2 && !forceBase64; + return _this6; + } + _inheritsLoose(XHR, _BaseXHR); + var _proto3 = XHR.prototype; + _proto3.request = function request() { + var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + _extends(opts, { + xd: this.xd + }, this.opts); + return new Request(newRequest, this.uri(), opts); + }; + return XHR; + }(BaseXHR); + function newRequest(opts) { + var xdomain = opts.xdomain; + // XMLHttpRequest can be disabled on IE + try { + if ("undefined" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) { + return new XMLHttpRequest(); + } + } catch (e) {} + if (!xdomain) { + try { + return new globalThisShim[["Active"].concat("Object").join("X")]("Microsoft.XMLHTTP"); + } catch (e) {} + } + } + + // detect ReactNative environment + var isReactNative = typeof navigator !== "undefined" && typeof navigator.product === "string" && navigator.product.toLowerCase() === "reactnative"; + var BaseWS = /*#__PURE__*/function (_Transport) { + function BaseWS() { + return _Transport.apply(this, arguments) || this; + } + _inheritsLoose(BaseWS, _Transport); + var _proto = BaseWS.prototype; + _proto.doOpen = function doOpen() { + var uri = this.uri(); + var protocols = this.opts.protocols; + // React Native only supports the 'headers' option, and will print a warning if anything else is passed + var 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 + */; + _proto.addEventListeners = function addEventListeners() { + var _this = this; + this.ws.onopen = function () { + if (_this.opts.autoUnref) { + _this.ws._socket.unref(); } - /** - * Initializes transport to use and starts probe. - * - * @api private - */ - - }, { - key: "open", - value: function open() { - var _this2 = this; - - var transport; - - if (this.opts.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1) { - transport = "websocket"; - } else if (0 === this.transports.length) { - // Emit error on next tick so it can be listened to - this.setTimeoutFn(function () { - _this2.emitReserved("error", "No transports available"); - }, 0); - return; - } else { - transport = this.transports[0]; - } - - this.readyState = "opening"; // Retry with the next transport if the transport is disabled (jsonp: false) - + _this.onOpen(); + }; + this.ws.onclose = function (closeEvent) { + return _this.onClose({ + description: "websocket connection closed", + context: closeEvent + }); + }; + this.ws.onmessage = function (ev) { + return _this.onData(ev.data); + }; + this.ws.onerror = function (e) { + return _this.onError("websocket error", e); + }; + }; + _proto.write = function write(packets) { + var _this2 = this; + this.writable = false; + // encodePacket efficient as it uses WS framing + // no need for encodePayload + var _loop = function _loop() { + var packet = packets[i]; + var lastPacket = i === packets.length - 1; + encodePacket(packet, _this2.supportsBinary, function (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 { - transport = this.createTransport(transport); - } catch (e) { - this.transports.shift(); - this.open(); - return; + _this2.doWrite(packet, data); + } catch (e) {} + if (lastPacket) { + // fake drain + // defer to next tick to allow Socket to clear writeBuffer + nextTick(function () { + _this2.writable = true; + _this2.emitReserved("drain"); + }, _this2.setTimeoutFn); } - - transport.open(); - this.setTransport(transport); - } - /** - * Sets the current transport. Disables the existing one (if any). - * - * @api private - */ - - }, { - key: "setTransport", - value: function setTransport(transport) { - var _this3 = this; - - if (this.transport) { - this.transport.removeAllListeners(); - } // set up transport - - - this.transport = transport; // set up transport listeners - - transport.on("drain", this.onDrain.bind(this)).on("packet", this.onPacket.bind(this)).on("error", this.onError.bind(this)).on("close", function (reason) { - return _this3.onClose("transport close", reason); - }); - } - /** - * Probes a transport. - * - * @param {String} transport name - * @api private - */ - - }, { - key: "probe", - value: function probe(name) { - var _this4 = this; - - var transport = this.createTransport(name); - var failed = false; - Socket.priorWebsocketSuccess = false; - - var onTransportOpen = function onTransportOpen() { - if (failed) return; - transport.send([{ - type: "ping", - data: "probe" - }]); - transport.once("packet", function (msg) { - if (failed) return; - - if ("pong" === msg.type && "probe" === msg.data) { - _this4.upgrading = true; - - _this4.emitReserved("upgrading", transport); - - if (!transport) return; - Socket.priorWebsocketSuccess = "websocket" === transport.name; - - _this4.transport.pause(function () { - if (failed) return; - if ("closed" === _this4.readyState) return; - cleanup(); - - _this4.setTransport(transport); - - transport.send([{ - type: "upgrade" - }]); - - _this4.emitReserved("upgrade", transport); - - transport = null; - _this4.upgrading = false; - - _this4.flush(); - }); - } else { - var err = new Error("probe error"); // @ts-ignore - - err.transport = transport.name; - - _this4.emitReserved("upgradeError", err); + }); + }; + for (var i = 0; i < packets.length; i++) { + _loop(); + } + }; + _proto.doClose = function doClose() { + if (typeof this.ws !== "undefined") { + this.ws.onerror = function () {}; + this.ws.close(); + this.ws = null; + } + } + /** + * Generates uri for connection. + * + * @private + */; + _proto.uri = function uri() { + var schema = this.opts.secure ? "wss" : "ws"; + var 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); + }; + return _createClass(BaseWS, [{ + key: "name", + get: function get() { + return "websocket"; + } + }]); + }(Transport); + var 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 + */ + var WS = /*#__PURE__*/function (_BaseWS) { + function WS() { + return _BaseWS.apply(this, arguments) || this; + } + _inheritsLoose(WS, _BaseWS); + var _proto2 = WS.prototype; + _proto2.createSocket = function createSocket(uri, protocols, opts) { + return !isReactNative ? protocols ? new WebSocketCtor(uri, protocols) : new WebSocketCtor(uri) : new WebSocketCtor(uri, protocols, opts); + }; + _proto2.doWrite = function doWrite(_packet, data) { + this.ws.send(data); + }; + return WS; + }(BaseWS); + + /** + * 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 + */ + var WT = /*#__PURE__*/function (_Transport) { + function WT() { + return _Transport.apply(this, arguments) || this; + } + _inheritsLoose(WT, _Transport); + var _proto = WT.prototype; + _proto.doOpen = function doOpen() { + var _this = this; + 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(function () { + _this.onClose(); + })["catch"](function (err) { + _this.onError("webtransport error", err); + }); + // note: we could have used async/await, but that would require some additional polyfills + this._transport.ready.then(function () { + _this._transport.createBidirectionalStream().then(function (stream) { + var decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, _this.socket.binaryType); + var reader = stream.readable.pipeThrough(decoderStream).getReader(); + var encoderStream = createPacketEncoderStream(); + encoderStream.readable.pipeTo(stream.writable); + _this._writer = encoderStream.writable.getWriter(); + var read = function read() { + reader.read().then(function (_ref) { + var done = _ref.done, + value = _ref.value; + if (done) { + return; } + _this.onPacket(value); + read(); + })["catch"](function (err) {}); + }; + read(); + var packet = { + type: "open" + }; + if (_this.query.sid) { + packet.data = "{\"sid\":\"".concat(_this.query.sid, "\"}"); + } + _this._writer.write(packet).then(function () { + return _this.onOpen(); + }); + }); + }); + }; + _proto.write = function write(packets) { + var _this2 = this; + this.writable = false; + var _loop = function _loop() { + var packet = packets[i]; + var lastPacket = i === packets.length - 1; + _this2._writer.write(packet).then(function () { + if (lastPacket) { + nextTick(function () { + _this2.writable = true; + _this2.emitReserved("drain"); + }, _this2.setTimeoutFn); + } + }); + }; + for (var i = 0; i < packets.length; i++) { + _loop(); + } + }; + _proto.doClose = function doClose() { + var _a; + (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close(); + }; + return _createClass(WT, [{ + key: "name", + get: function get() { + return "webtransport"; + } + }]); + }(Transport); + + var 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 (MIT license) + * @api private + */ + var re = /^(?:(?![^:@\/?#]+:[^:@\/]*@)(http|https|ws|wss):\/\/)?((?:(([^:@\/?#]*)(?::([^:@\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/; + var parts = ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor']; + function parse(str) { + if (str.length > 8000) { + throw "URI too long"; + } + var 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); + } + var 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) { + var 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) { + var data = {}; + query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) { + if ($1) { + data[$1] = $2; + } + }); + return data; + } + + var withEventListeners = typeof addEventListener === "function" && typeof removeEventListener === "function"; + var 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", function () { + OFFLINE_EVENT_LISTENERS.forEach(function (listener) { + return 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 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"); + * }); + * + */ + var Socket$1 = /*#__PURE__*/function (_Emitter) { + function Socket(uri) { + var _this; + var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var _a, _b; + _this = _Emitter.call(this) || this; + _this.binaryType = defaultBinaryType; + _this.writeBuffer = []; + _this._prevBufferLen = 0; + _this._upgrades = []; + _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) { + var 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"); + if (opts.transportImplementations && opts.transports) { + throw new Error("specifying both 'transportImplementations' and 'transports' options is not supported"); + } + if (opts.transportImplementations || ((_a = opts.transports) === null || _a === void 0 ? void 0 : _a.length) && typeof opts.transports[0] === "function") { + // 'transports' option as an array of transport implementations is kept for backward compatibility + _this.transports = []; + _this._transportsByName = Object.create(null); + ((_b = opts.transportImplementations) !== null && _b !== void 0 ? _b : opts.transports).forEach(function (t) { + var transportName = t.prototype.name; + _this.transports.push(transportName); + _this._transportsByName[transportName] = t; + }); + } else { + _this.transports = opts.transports ? _toConsumableArray(opts.transports) : ["polling", "websocket", "webtransport"]; + _this._transportsByName = transports; + } + _this.opts = _extends({ + 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 = function () { + if (_this.transport) { + // silently close the transport + _this.transport.removeAllListeners(); + _this.transport.close(); + } + }; + addEventListener("beforeunload", _this._beforeunloadEventListener, false); + } + if (_this.hostname !== "localhost") { + _this._offlineEventListener = function () { + _this._onClose("transport close", { + description: "network connection lost" }); }; - - 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 - - - var onerror = function onerror(err) { - var error = new Error("probe error: " + err); // @ts-ignore - - error.transport = transport.name; - freezeTransport(); - - _this4.emitReserved("upgradeError", error); - }; - - function onTransportClose() { - onerror("transport closed"); - } // When the socket is closed while we're probing - - - 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 - - - var cleanup = function cleanup() { - transport.removeListener("open", onTransportOpen); - transport.removeListener("error", onerror); - transport.removeListener("close", onTransportClose); - - _this4.off("close", onclose); - - _this4.off("upgrading", onupgrade); - }; - - transport.once("open", onTransportOpen); - transport.once("error", onerror); - transport.once("close", onTransportClose); - this.once("close", onclose); - this.once("upgrading", onupgrade); - transport.open(); + OFFLINE_EVENT_LISTENERS.push(_this._offlineEventListener); } - /** - * Called when connection is deemed open. - * - * @api private - */ - - }, { - key: "onOpen", - value: function onOpen() { - this.readyState = "open"; - Socket.priorWebsocketSuccess = "websocket" === this.transport.name; - this.emitReserved("open"); - this.flush(); // we check for `readyState` in case an `open` - // listener already closed the socket - - if ("open" === this.readyState && this.opts.upgrade && this.transport.pause) { - var i = 0; - var l = this.upgrades.length; - - for (; i < l; i++) { - this.probe(this.upgrades[i]); - } - } - } - /** - * Handles a packet. - * - * @api private - */ - - }, { - key: "onPacket", - value: function onPacket(packet) { - if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { - this.emitReserved("packet", packet); // Socket is live - any packet counts - - this.emitReserved("heartbeat"); - - switch (packet.type) { - case "open": - this.onHandshake(JSON.parse(packet.data)); - break; - - case "ping": - this.resetPingTimeout(); - this.sendPacket("pong"); - this.emitReserved("ping"); - this.emitReserved("pong"); - break; - - case "error": - var err = new Error("server error"); // @ts-ignore - - 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 - * @api private - */ - - }, { - key: "onHandshake", - value: function onHandshake(data) { - this.emitReserved("handshake", data); - this.id = data.sid; - this.transport.query.sid = data.sid; - this.upgrades = this.filterUpgrades(data.upgrades); - this.pingInterval = data.pingInterval; - this.pingTimeout = data.pingTimeout; - this.maxPayload = data.maxPayload; - this.onOpen(); // In case open handler closes socket - - if ("closed" === this.readyState) return; - this.resetPingTimeout(); - } - /** - * Sets and resets ping timeout timer based on server pings. - * - * @api private - */ - - }, { - key: "resetPingTimeout", - value: function resetPingTimeout() { - var _this5 = this; - - this.clearTimeoutFn(this.pingTimeoutTimer); - this.pingTimeoutTimer = this.setTimeoutFn(function () { - _this5.onClose("ping timeout"); - }, this.pingInterval + this.pingTimeout); - - if (this.opts.autoUnref) { - this.pingTimeoutTimer.unref(); - } - } - /** - * Called on `drain` event - * - * @api private - */ - - }, { - key: "onDrain", - value: function 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"); + } + if (_this.opts.withCredentials) { + _this._cookieJar = createCookieJar(); + } + _this._open(); + return _this; + } + /** + * Creates transport of the given type. + * + * @param {String} name - transport name + * @return {Transport} + * @private + */ + _inheritsLoose(Socket, _Emitter); + var _proto = Socket.prototype; + _proto.createTransport = function createTransport(name) { + var query = _extends({}, this.opts.query); + // append engine.io protocol identifier + query.EIO = protocol$1; + // transport name + query.transport = name; + // session id if we already have one + if (this.id) query.sid = this.id; + var opts = _extends({}, this.opts, { + query: 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 + */; + _proto._open = function _open() { + var _this2 = this; + if (this.transports.length === 0) { + // Emit error on next tick so it can be listened to + this.setTimeoutFn(function () { + _this2.emitReserved("error", "No transports available"); + }, 0); + return; + } + var transportName = this.opts.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1 ? "websocket" : this.transports[0]; + this.readyState = "opening"; + var transport = this.createTransport(transportName); + transport.open(); + this.setTransport(transport); + } + /** + * Sets the current transport. Disables the existing one (if any). + * + * @private + */; + _proto.setTransport = function setTransport(transport) { + var _this3 = this; + 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", function (reason) { + return _this3._onClose("transport close", reason); + }); + } + /** + * Probes a transport. + * + * @param {String} name - transport name + * @private + */; + _proto._probe = function _probe(name) { + var _this4 = this; + var transport = this.createTransport(name); + var failed = false; + Socket.priorWebsocketSuccess = false; + var onTransportOpen = function onTransportOpen() { + if (failed) return; + transport.send([{ + type: "ping", + data: "probe" + }]); + transport.once("packet", function (msg) { + if (failed) return; + if ("pong" === msg.type && "probe" === msg.data) { + _this4.upgrading = true; + _this4.emitReserved("upgrading", transport); + if (!transport) return; + Socket.priorWebsocketSuccess = "websocket" === transport.name; + _this4.transport.pause(function () { + if (failed) return; + if ("closed" === _this4.readyState) return; + cleanup(); + _this4.setTransport(transport); + transport.send([{ + type: "upgrade" + }]); + _this4.emitReserved("upgrade", transport); + transport = null; + _this4.upgrading = false; + _this4.flush(); + }); } else { - this.flush(); + var err = new Error("probe error"); + // @ts-ignore + err.transport = transport.name; + _this4.emitReserved("upgradeError", err); } + }); + }; + function freezeTransport() { + if (failed) return; + // Any callback called by transport should be ignored since now + failed = true; + cleanup(); + transport.close(); + transport = null; + } + // Handle any error that happens while probing + var onerror = function onerror(err) { + var error = new Error("probe error: " + err); + // @ts-ignore + error.transport = transport.name; + freezeTransport(); + _this4.emitReserved("upgradeError", error); + }; + function onTransportClose() { + onerror("transport closed"); + } + // When the socket is closed while we're probing + function onclose() { + onerror("socket closed"); + } + // When the socket is upgraded while we're probing + function onupgrade(to) { + if (transport && to.name !== transport.name) { + freezeTransport(); } - /** - * Flush write buffers. - * - * @api private - */ - - }, { - key: "flush", - value: function flush() { - if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) { - var packets = this.getWritablePackets(); - this.transport.send(packets); // keep track of current length of writeBuffer - // splice writeBuffer and callbackBuffer on `drain` - - this.prevBufferLen = packets.length; - this.emitReserved("flush"); + } + // Remove all listeners on the transport and on self + var cleanup = function cleanup() { + transport.removeListener("open", onTransportOpen); + transport.removeListener("error", onerror); + transport.removeListener("close", onTransportClose); + _this4.off("close", onclose); + _this4.off("upgrading", onupgrade); + }; + transport.once("open", onTransportOpen); + transport.once("error", onerror); + transport.once("close", onTransportClose); + this.once("close", onclose); + this.once("upgrading", onupgrade); + if (this._upgrades.indexOf("webtransport") !== -1 && name !== "webtransport") { + // favor WebTransport + this.setTimeoutFn(function () { + if (!failed) { + transport.open(); } + }, 200); + } else { + transport.open(); + } + } + /** + * Called when connection is deemed open. + * + * @private + */; + _proto.onOpen = function onOpen() { + this.readyState = "open"; + Socket.priorWebsocketSuccess = "websocket" === this.transport.name; + this.emitReserved("open"); + this.flush(); + if ("open" === this.readyState && this.opts.upgrade) { + for (var i = 0; i < this._upgrades.length; i++) { + this._probe(this._upgrades[i]); } - /** - * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP - * long-polling) - * - * @private - */ - - }, { - key: "getWritablePackets", - value: function getWritablePackets() { - var shouldCheckPayloadSize = this.maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1; - - if (!shouldCheckPayloadSize) { - return this.writeBuffer; - } - - var payloadSize = 1; // first packet type - - for (var i = 0; i < this.writeBuffer.length; i++) { - var data = this.writeBuffer[i].data; - - if (data) { - payloadSize += byteLength(data); - } - - if (i > 0 && payloadSize > this.maxPayload) { - return this.writeBuffer.slice(0, i); - } - - payloadSize += 2; // separator + packet type - } - - return this.writeBuffer; + } + } + /** + * Handles a packet. + * + * @private + */; + _proto._onPacket = function _onPacket(packet) { + if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { + this.emitReserved("packet", packet); + // Socket is live - any packet counts + this.emitReserved("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": + var err = new Error("server error"); + // @ts-ignore + err.code = packet.data; + this._onError(err); + break; + case "message": + this.emitReserved("data", packet.data); + this.emitReserved("message", packet.data); + break; } - /** - * Sends a message. - * - * @param {String} message. - * @param {Function} callback function. - * @param {Object} options. - * @return {Socket} for chaining. - * @api public - */ - - }, { - key: "write", - value: function write(msg, options, fn) { - this.sendPacket("message", msg, options, fn); - return this; + } + } + /** + * Called upon handshake completion. + * + * @param {Object} data - handshake obj + * @private + */; + _proto.onHandshake = function onHandshake(data) { + this.emitReserved("handshake", data); + this.id = data.sid; + this.transport.query.sid = data.sid; + this._upgrades = this._filterUpgrades(data.upgrades); + this._pingInterval = data.pingInterval; + this._pingTimeout = data.pingTimeout; + this._maxPayload = data.maxPayload; + this.onOpen(); + // In case open handler closes socket + if ("closed" === this.readyState) return; + this._resetPingTimeout(); + } + /** + * Sets and resets ping timeout timer based on server pings. + * + * @private + */; + _proto._resetPingTimeout = function _resetPingTimeout() { + var _this5 = this; + this.clearTimeoutFn(this._pingTimeoutTimer); + var delay = this._pingInterval + this._pingTimeout; + this._pingTimeoutTime = Date.now() + delay; + this._pingTimeoutTimer = this.setTimeoutFn(function () { + _this5._onClose("ping timeout"); + }, delay); + if (this.opts.autoUnref) { + this._pingTimeoutTimer.unref(); + } + } + /** + * Called on `drain` event + * + * @private + */; + _proto._onDrain = function _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 + */; + _proto.flush = function flush() { + if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) { + var packets = this._getWritablePackets(); + this.transport.send(packets); + // keep track of current length of writeBuffer + // 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 + */; + _proto._getWritablePackets = function _getWritablePackets() { + var shouldCheckPayloadSize = this._maxPayload && this.transport.name === "polling" && this.writeBuffer.length > 1; + if (!shouldCheckPayloadSize) { + return this.writeBuffer; + } + var payloadSize = 1; // first packet type + for (var i = 0; i < this.writeBuffer.length; i++) { + var data = this.writeBuffer[i].data; + if (data) { + payloadSize += byteLength(data); } - }, { - key: "send", - value: function send(msg, options, fn) { - this.sendPacket("message", msg, options, fn); - return this; + if (i > 0 && payloadSize > this._maxPayload) { + return this.writeBuffer.slice(0, i); } - /** - * Sends a packet. - * - * @param {String} packet type. - * @param {String} data. - * @param {Object} options. - * @param {Function} callback function. - * @api private - */ - - }, { - key: "sendPacket", - value: function 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; - var 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. - * - * @api public - */ - - }, { - key: "close", - value: function close() { - var _this6 = this; - - var close = function close() { - _this6.onClose("forced close"); - - _this6.transport.close(); - }; - - var cleanupAndClose = function cleanupAndClose() { - _this6.off("upgrade", cleanupAndClose); - - _this6.off("upgradeError", cleanupAndClose); - - close(); - }; - - var waitForUpgrade = function waitForUpgrade() { - // wait for upgrade to finish since we can't send packets while pausing a transport - _this6.once("upgrade", cleanupAndClose); - - _this6.once("upgradeError", cleanupAndClose); - }; - - if ("opening" === this.readyState || "open" === this.readyState) { - this.readyState = "closing"; - - if (this.writeBuffer.length) { - this.once("drain", function () { - if (_this6.upgrading) { - waitForUpgrade(); - } else { - close(); - } - }); - } else if (this.upgrading) { + 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 */; + _proto._hasPingExpired = function _hasPingExpired() { + var _this6 = this; + if (!this._pingTimeoutTime) return true; + var hasExpired = Date.now() > this._pingTimeoutTime; + if (hasExpired) { + this._pingTimeoutTime = 0; + nextTick(function () { + _this6._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. + */; + _proto.write = function 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. + */; + _proto.send = function 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 + */; + _proto._sendPacket = function _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; + var 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. + */; + _proto.close = function close() { + var _this7 = this; + var close = function close() { + _this7._onClose("forced close"); + _this7.transport.close(); + }; + var cleanupAndClose = function cleanupAndClose() { + _this7.off("upgrade", cleanupAndClose); + _this7.off("upgradeError", cleanupAndClose); + close(); + }; + var waitForUpgrade = function waitForUpgrade() { + // wait for upgrade to finish since we can't send packets while pausing a transport + _this7.once("upgrade", cleanupAndClose); + _this7.once("upgradeError", cleanupAndClose); + }; + if ("opening" === this.readyState || "open" === this.readyState) { + this.readyState = "closing"; + if (this.writeBuffer.length) { + this.once("drain", function () { + if (_this7.upgrading) { waitForUpgrade(); } else { close(); } - } - - return this; - } - /** - * Called upon transport error - * - * @api private - */ - - }, { - key: "onError", - value: function onError(err) { - Socket.priorWebsocketSuccess = false; - this.emitReserved("error", err); - this.onClose("transport error", err); - } - /** - * Called upon transport close. - * - * @api private - */ - - }, { - key: "onClose", - value: function onClose(reason, description) { - if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { - // clear timers - this.clearTimeoutFn(this.pingTimeoutTimer); // stop event from firing again for transport - - this.transport.removeAllListeners("close"); // ensure transport won't stay open - - this.transport.close(); // ignore further transport communication - - this.transport.removeAllListeners(); - - if (typeof removeEventListener === "function") { - removeEventListener("offline", this.offlineEventListener, false); - } // set ready state - - - this.readyState = "closed"; // clear session id - - this.id = null; // emit close event - - this.emitReserved("close", reason, description); // clean buffers after, so users can still - // grab the buffers on `close` event - - this.writeBuffer = []; - this.prevBufferLen = 0; - } - } - /** - * Filters upgrades, returning only those matching client transports. - * - * @param {Array} server upgrades - * @api private - * - */ - - }, { - key: "filterUpgrades", - value: function filterUpgrades(upgrades) { - var filteredUpgrades = []; - var i = 0; - var j = upgrades.length; - - for (; i < j; i++) { - if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]); - } - - return filteredUpgrades; - } - }]); - - return Socket; - }(Emitter); - Socket$1.protocol = protocol$1; - - /** - * 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) { - var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; - var loc = arguments.length > 2 ? arguments[2] : undefined; - var obj = uri; // default to window.location - - 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"; + }); + } else if (this.upgrading) { + waitForUpgrade(); + } else { + close(); } } - - obj.path = obj.path || "/"; - var ipv6 = obj.host.indexOf(":") !== -1; - var host = ipv6 ? "[" + obj.host + "]" : obj.host; // define unique id - - obj.id = obj.protocol + "://" + host + ":" + obj.port + path; // define href - - obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port); - return obj; + return this; } - - var withNativeArrayBuffer = typeof ArrayBuffer === "function"; - - var isView = function isView(obj) { - return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer; - }; - - var toString = Object.prototype.toString; - var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]"; - var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]"; /** - * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File. + * Called upon transport error * * @private - */ - - function isBinary(obj) { - return withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)) || withNativeBlob && obj instanceof Blob || withNativeFile && obj instanceof File; + */; + _proto._onError = function _onError(err) { + Socket.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); } - function hasBinary(obj, toJSON) { - if (!obj || _typeof(obj) !== "object") { - return false; - } - - if (Array.isArray(obj)) { - for (var i = 0, l = obj.length; i < l; i++) { - if (hasBinary(obj[i])) { - return true; - } - } - - return false; - } - - if (isBinary(obj)) { - return true; - } - - if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) { - return hasBinary(obj.toJSON(), true); - } - - for (var key in obj) { - if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) { - return true; - } - } - - return false; - } - /** - * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder. + * Called upon transport close. * - * @param {Object} packet - socket.io event packet - * @return {Object} with deconstructed packet and list of buffers - * @public - */ - - function deconstructPacket(packet) { - var buffers = []; - var packetData = packet.data; - var pack = packet; - pack.data = _deconstructPacket(packetData, buffers); - pack.attachments = buffers.length; // number of binary 'attachments' - - return { - packet: pack, - buffers: buffers - }; - } - - function _deconstructPacket(data, buffers) { - if (!data) return data; - - if (isBinary(data)) { - var placeholder = { - _placeholder: true, - num: buffers.length - }; - buffers.push(data); - return placeholder; - } else if (Array.isArray(data)) { - var newData = new Array(data.length); - - for (var i = 0; i < data.length; i++) { - newData[i] = _deconstructPacket(data[i], buffers); - } - - return newData; - } else if (_typeof(data) === "object" && !(data instanceof Date)) { - var _newData = {}; - - for (var key in data) { - if (Object.prototype.hasOwnProperty.call(data, key)) { - _newData[key] = _deconstructPacket(data[key], buffers); + * @private + */; + _proto._onClose = function _onClose(reason, description) { + if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) { + // clear timers + this.clearTimeoutFn(this._pingTimeoutTimer); + // stop event from firing again for transport + this.transport.removeAllListeners("close"); + // ensure transport won't stay open + this.transport.close(); + // ignore further transport communication + this.transport.removeAllListeners(); + if (withEventListeners) { + if (this._beforeunloadEventListener) { + removeEventListener("beforeunload", this._beforeunloadEventListener, false); } - } - - 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); - packet.attachments = undefined; // no longer useful - - return packet; - } - - function _reconstructPacket(data, buffers) { - if (!data) return data; - - if (data && data._placeholder) { - return buffers[data.num]; // appropriate buffer (should be natural order anyway) - } else if (Array.isArray(data)) { - for (var i = 0; i < data.length; i++) { - data[i] = _reconstructPacket(data[i], buffers); - } - } else if (_typeof(data) === "object") { - for (var key in data) { - if (Object.prototype.hasOwnProperty.call(data, key)) { - data[key] = _reconstructPacket(data[key], buffers); - } - } - } - - return data; - } - - /** - * Protocol version. - * - * @public - */ - - var protocol = 5; - 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 - */ - - - var Encoder = /*#__PURE__*/function () { - /** - * Encoder constructor - * - * @param {function} replacer - custom replacer to pass down to JSON.parse - */ - function Encoder(replacer) { - _classCallCheck(this, Encoder); - - 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 - */ - - - _createClass(Encoder, [{ - key: "encode", - value: function encode(obj) { - if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) { - if (hasBinary(obj)) { - obj.type = obj.type === PacketType.EVENT ? PacketType.BINARY_EVENT : PacketType.BINARY_ACK; - return this.encodeAsBinary(obj); + if (this._offlineEventListener) { + var i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener); + if (i !== -1) { + OFFLINE_EVENT_LISTENERS.splice(i, 1); } } - - return [this.encodeAsString(obj)]; } - /** - * Encode packet as string. - */ - - }, { - key: "encodeAsString", - value: function encodeAsString(obj) { - // first is type - var str = "" + obj.type; // attachments if we have them - - 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. - */ - - }, { - key: "encodeAsBinary", - value: function encodeAsBinary(obj) { - var deconstruction = deconstructPacket(obj); - var pack = this.encodeAsString(deconstruction.packet); - var buffers = deconstruction.buffers; - buffers.unshift(pack); // add packet info to beginning of data list - - return buffers; // write all the buffers - } - }]); - - return Encoder; - }(); - /** - * A socket.io Decoder instance - * - * @return {Object} decoder - */ - - var Decoder = /*#__PURE__*/function (_Emitter) { - _inherits(Decoder, _Emitter); - - var _super = _createSuper(Decoder); - - /** - * Decoder constructor - * - * @param {function} reviver - custom reviver to pass down to JSON.stringify - */ - function Decoder(reviver) { - var _this; - - _classCallCheck(this, Decoder); - - _this = _super.call(this); - _this.reviver = reviver; - return _this; + // 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; } - /** - * Decodes an encoded packet string into packet JSON. - * - * @param {String} obj - encoded packet - */ - - - _createClass(Decoder, [{ - key: "add", - value: function add(obj) { - var packet; - - if (typeof obj === "string") { - packet = this.decodeString(obj); - - if (packet.type === PacketType.BINARY_EVENT || packet.type === PacketType.BINARY_ACK) { - // binary packet's json - this.reconstructor = new BinaryReconstructor(packet); // no attachments, labeled binary but no binary data to follow - - if (packet.attachments === 0) { - _get(_getPrototypeOf(Decoder.prototype), "emitReserved", this).call(this, "decoded", packet); - } - } else { - // non-binary full packet - _get(_getPrototypeOf(Decoder.prototype), "emitReserved", this).call(this, "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; - - _get(_getPrototypeOf(Decoder.prototype), "emitReserved", this).call(this, "decoded", packet); - } - } + } + /** + * Filters upgrades, returning only those matching client transports. + * + * @param {Array} upgrades - server upgrades + * @private + */; + _proto._filterUpgrades = function _filterUpgrades(upgrades) { + var filteredUpgrades = []; + for (var i = 0; i < upgrades.length; i++) { + if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]); + } + return filteredUpgrades; + }; + return Socket; + }(Emitter); + Socket$1.protocol = protocol$1; + + Socket$1.protocol; + + function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; + } + + var browser = {exports: {}}; + + var ms; + var hasRequiredMs; + function requireMs() { + if (hasRequiredMs) return ms; + hasRequiredMs = 1; + var s = 1000; + var m = s * 60; + var h = m * 60; + var d = h * 24; + var w = d * 7; + var y = d * 365.25; + + /** + * Parse or format the given `val`. + * + * Options: + * + * - `long` verbose formatting [false] + * + * @param {String|Number} val + * @param {Object} [options] + * @throws {Error} throw an error if val is not a non-empty string or a number + * @return {String|Number} + * @api public + */ + + ms = function ms(val, options) { + options = options || {}; + var type = _typeof(val); + if (type === 'string' && val.length > 0) { + return parse(val); + } else if (type === 'number' && isFinite(val)) { + return options["long"] ? fmtLong(val) : fmtShort(val); + } + throw new Error('val is not a non-empty string or a valid number. val=' + JSON.stringify(val)); + }; + + /** + * Parse the given `str` and return milliseconds. + * + * @param {String} str + * @return {Number} + * @api private + */ + + function parse(str) { + str = String(str); + if (str.length > 100) { + return; + } + var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(str); + if (!match) { + return; + } + var n = parseFloat(match[1]); + var type = (match[2] || 'ms').toLowerCase(); + switch (type) { + case 'years': + case 'year': + case 'yrs': + case 'yr': + case 'y': + return n * y; + case 'weeks': + case 'week': + case 'w': + return n * w; + case 'days': + case 'day': + case 'd': + return n * d; + case 'hours': + case 'hour': + case 'hrs': + case 'hr': + case 'h': + return n * h; + case 'minutes': + case 'minute': + case 'mins': + case 'min': + case 'm': + return n * m; + case 'seconds': + case 'second': + case 'secs': + case 'sec': + case 's': + return n * s; + case 'milliseconds': + case 'millisecond': + case 'msecs': + case 'msec': + case 'ms': + return n; + default: + return undefined; + } + } + + /** + * Short format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + + function fmtShort(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return Math.round(ms / d) + 'd'; + } + if (msAbs >= h) { + return Math.round(ms / h) + 'h'; + } + if (msAbs >= m) { + return Math.round(ms / m) + 'm'; + } + if (msAbs >= s) { + return Math.round(ms / s) + 's'; + } + return ms + 'ms'; + } + + /** + * Long format for `ms`. + * + * @param {Number} ms + * @return {String} + * @api private + */ + + function fmtLong(ms) { + var msAbs = Math.abs(ms); + if (msAbs >= d) { + return plural(ms, msAbs, d, 'day'); + } + if (msAbs >= h) { + return plural(ms, msAbs, h, 'hour'); + } + if (msAbs >= m) { + return plural(ms, msAbs, m, 'minute'); + } + if (msAbs >= s) { + return plural(ms, msAbs, s, 'second'); + } + return ms + ' ms'; + } + + /** + * Pluralization helper. + */ + + function plural(ms, msAbs, n, name) { + var isPlural = msAbs >= n * 1.5; + return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : ''); + } + return ms; + } + + /** + * This is the common logic for both the Node.js and web browser + * implementations of `debug()`. + */ + + function setup(env) { + createDebug.debug = createDebug; + createDebug["default"] = createDebug; + createDebug.coerce = coerce; + createDebug.disable = disable; + createDebug.enable = enable; + createDebug.enabled = enabled; + createDebug.humanize = requireMs(); + createDebug.destroy = destroy; + Object.keys(env).forEach(function (key) { + createDebug[key] = env[key]; + }); + + /** + * The currently active debug mode names, and names to skip. + */ + + createDebug.names = []; + createDebug.skips = []; + + /** + * Map of special "%n" handling functions, for the debug "format" argument. + * + * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N". + */ + createDebug.formatters = {}; + + /** + * Selects a color for a debug namespace + * @param {String} namespace The namespace string for the debug instance to be colored + * @return {Number|String} An ANSI color code for the given namespace + * @api private + */ + function selectColor(namespace) { + var hash = 0; + for (var i = 0; i < namespace.length; i++) { + hash = (hash << 5) - hash + namespace.charCodeAt(i); + hash |= 0; // Convert to 32bit integer + } + return createDebug.colors[Math.abs(hash) % createDebug.colors.length]; + } + createDebug.selectColor = selectColor; + + /** + * Create a debugger with the given `namespace`. + * + * @param {String} namespace + * @return {Function} + * @api public + */ + function createDebug(namespace) { + var prevTime; + var enableOverride = null; + var namespacesCache; + var enabledCache; + function debug() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + // Disabled? + if (!debug.enabled) { + return; + } + var self = debug; + + // Set `diff` timestamp + var curr = Number(new Date()); + var ms = curr - (prevTime || curr); + self.diff = ms; + self.prev = prevTime; + self.curr = curr; + prevTime = curr; + args[0] = createDebug.coerce(args[0]); + if (typeof args[0] !== 'string') { + // Anything else let's inspect with %O + args.unshift('%O'); + } + + // Apply any `formatters` transformations + var index = 0; + args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) { + // If we encounter an escaped % then don't increase the array index + if (match === '%%') { + return '%'; + } + index++; + var formatter = createDebug.formatters[format]; + if (typeof formatter === 'function') { + var val = args[index]; + match = formatter.call(self, val); + + // Now we need to remove `args[index]` since it's inlined in the `format` + args.splice(index, 1); + index--; + } + return match; + }); + + // Apply env-specific formatting (colors, etc.) + createDebug.formatArgs.call(self, args); + var logFn = self.log || createDebug.log; + logFn.apply(self, args); + } + debug.namespace = namespace; + debug.useColors = createDebug.useColors(); + debug.color = createDebug.selectColor(namespace); + debug.extend = extend; + debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release. + + Object.defineProperty(debug, 'enabled', { + enumerable: true, + configurable: false, + get: function get() { + if (enableOverride !== null) { + return enableOverride; + } + if (namespacesCache !== createDebug.namespaces) { + namespacesCache = createDebug.namespaces; + enabledCache = createDebug.enabled(namespace); + } + return enabledCache; + }, + set: function set(v) { + enableOverride = v; + } + }); + + // Env-specific initialization logic for debug instances + if (typeof createDebug.init === 'function') { + createDebug.init(debug); + } + return debug; + } + function extend(namespace, delimiter) { + var newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace); + newDebug.log = this.log; + return newDebug; + } + + /** + * Enables a debug mode by namespaces. This can include modes + * separated by a colon and wildcards. + * + * @param {String} namespaces + * @api public + */ + function enable(namespaces) { + createDebug.save(namespaces); + createDebug.namespaces = namespaces; + createDebug.names = []; + createDebug.skips = []; + var split = (typeof namespaces === 'string' ? namespaces : '').trim().replace(/\s+/g, ',').split(',').filter(Boolean); + var _iterator = _createForOfIteratorHelper(split), + _step; + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var ns = _step.value; + if (ns[0] === '-') { + createDebug.skips.push(ns.slice(1)); } else { - throw new Error("Unknown type: " + obj); + createDebug.names.push(ns); } } - /** - * Decode a packet String (JSON data) - * - * @param {String} str - * @return {Object} packet - */ - - }, { - key: "decodeString", - value: function decodeString(str) { - var i = 0; // look up type - - var p = { - type: Number(str.charAt(0)) - }; - - if (PacketType[p.type] === undefined) { - throw new Error("unknown packet type " + p.type); - } // look up attachments if type binary - - - if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) { - var start = i + 1; - - while (str.charAt(++i) !== "-" && i != str.length) {} - - var buf = str.substring(start, i); - - if (buf != Number(buf) || str.charAt(i) !== "-") { - throw new Error("Illegal attachments"); - } - - p.attachments = Number(buf); - } // look up namespace (if any) - - - if ("/" === str.charAt(i + 1)) { - var _start = i + 1; - - while (++i) { - var c = str.charAt(i); - if ("," === c) break; - if (i === str.length) break; - } - - p.nsp = str.substring(_start, i); + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } + + /** + * Checks if the given string matches a namespace template, honoring + * asterisks as wildcards. + * + * @param {String} search + * @param {String} template + * @return {Boolean} + */ + function matchesTemplate(search, template) { + var searchIndex = 0; + var templateIndex = 0; + var starIndex = -1; + var matchIndex = 0; + while (searchIndex < search.length) { + if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === '*')) { + // Match character or proceed with wildcard + if (template[templateIndex] === '*') { + starIndex = templateIndex; + matchIndex = searchIndex; + templateIndex++; // Skip the '*' } else { - p.nsp = "/"; - } // look up id - - - var next = str.charAt(i + 1); - - if ("" !== next && Number(next) == next) { - var _start2 = i + 1; - - while (++i) { - var _c = str.charAt(i); - - if (null == _c || Number(_c) != _c) { - --i; - break; - } - - if (i === str.length) break; - } - - p.id = Number(str.substring(_start2, i + 1)); - } // look up json data - - - if (str.charAt(++i)) { - var payload = this.tryParse(str.substr(i)); - - if (Decoder.isPayloadValid(p.type, payload)) { - p.data = payload; - } else { - throw new Error("invalid payload"); - } + searchIndex++; + templateIndex++; } - - return p; + } else if (starIndex !== -1) { + // eslint-disable-line no-negated-condition + // Backtrack to the last '*' and try to match more characters + templateIndex = starIndex + 1; + matchIndex++; + searchIndex = matchIndex; + } else { + return false; // No match } - }, { - key: "tryParse", - value: function tryParse(str) { - try { - return JSON.parse(str, this.reviver); - } catch (e) { + } + + // Handle trailing '*' in template + while (templateIndex < template.length && template[templateIndex] === '*') { + templateIndex++; + } + return templateIndex === template.length; + } + + /** + * Disable debug output. + * + * @return {String} namespaces + * @api public + */ + function disable() { + var namespaces = [].concat(_toConsumableArray(createDebug.names), _toConsumableArray(createDebug.skips.map(function (namespace) { + return '-' + namespace; + }))).join(','); + createDebug.enable(''); + return namespaces; + } + + /** + * Returns true if the given mode name is enabled, false otherwise. + * + * @param {String} name + * @return {Boolean} + * @api public + */ + function enabled(name) { + var _iterator2 = _createForOfIteratorHelper(createDebug.skips), + _step2; + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var skip = _step2.value; + if (matchesTemplate(name, skip)) { return false; } } - }, { - key: "destroy", - value: - /** - * Deallocates a parser's resources - */ - function destroy() { - if (this.reconstructor) { - this.reconstructor.finishedReconstruction(); - } - } - }], [{ - key: "isPayloadValid", - value: function isPayloadValid(type, payload) { - switch (type) { - case PacketType.CONNECT: - return _typeof(payload) === "object"; - - case PacketType.DISCONNECT: - return payload === undefined; - - case PacketType.CONNECT_ERROR: - return typeof payload === "string" || _typeof(payload) === "object"; - - case PacketType.EVENT: - case PacketType.BINARY_EVENT: - return Array.isArray(payload) && payload.length > 0; - - case PacketType.ACK: - case PacketType.BINARY_ACK: - return Array.isArray(payload); - } - } - }]); - - return Decoder; - }(Emitter); - /** - * 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 - */ - - var BinaryReconstructor = /*#__PURE__*/function () { - function BinaryReconstructor(packet) { - _classCallCheck(this, BinaryReconstructor); - - this.packet = packet; - this.buffers = []; - this.reconPack = packet; + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); } - /** - * 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. - */ - - - _createClass(BinaryReconstructor, [{ - key: "takeBinaryData", - value: function takeBinaryData(binData) { - this.buffers.push(binData); - - if (this.buffers.length === this.reconPack.attachments) { - // done with buffer list - var packet = reconstructPacket(this.reconPack, this.buffers); - this.finishedReconstruction(); - return packet; + var _iterator3 = _createForOfIteratorHelper(createDebug.names), + _step3; + try { + for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) { + var ns = _step3.value; + if (matchesTemplate(name, ns)) { + return true; } - - return null; } - /** - * Cleans up binary packet reconstruction variables. - */ - - }, { - key: "finishedReconstruction", - value: function finishedReconstruction() { - this.reconPack = null; - this.buffers = []; + } catch (err) { + _iterator3.e(err); + } finally { + _iterator3.f(); + } + return false; + } + + /** + * Coerce `val`. + * + * @param {Mixed} val + * @return {Mixed} + * @api private + */ + function coerce(val) { + if (val instanceof Error) { + return val.stack || val.message; + } + return val; + } + + /** + * XXX DO NOT USE. This is a temporary stub function. + * XXX It WILL be removed in the next major release. + */ + function destroy() { + console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'); + } + createDebug.enable(createDebug.load()); + return createDebug; + } + var common = setup; + + /* eslint-env browser */ + browser.exports; + (function (module, exports) { + /** + * This is the web browser implementation of `debug()`. + */ + + exports.formatArgs = formatArgs; + exports.save = save; + exports.load = load; + exports.useColors = useColors; + exports.storage = localstorage(); + exports.destroy = function () { + var warned = false; + return function () { + if (!warned) { + warned = true; + console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.'); } - }]); - - return BinaryReconstructor; + }; }(); - - var parser = /*#__PURE__*/Object.freeze({ - __proto__: null, - protocol: protocol, - get PacketType () { return PacketType; }, - Encoder: Encoder, - Decoder: Decoder - }); - - function on(obj, ev, fn) { - obj.on(ev, fn); - return function subDestroy() { - obj.off(ev, fn); + + /** + * Colors. + */ + + exports.colors = ['#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC', '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF', '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC', '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF', '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC', '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033', '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366', '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933', '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC', '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF', '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33']; + + /** + * Currently only WebKit-based Web Inspectors, Firefox >= v31, + * and the Firebug extension (any Firefox version) are known + * to support "%c" CSS customizations. + * + * TODO: add a `localStorage` variable to explicitly enable/disable colors + */ + + // eslint-disable-next-line complexity + function useColors() { + // NB: In an Electron preload script, document will be defined but not fully + // initialized. Since we know we're in Chrome, we'll just detect this case + // explicitly + if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) { + return true; + } + + // Internet Explorer and Edge do not support colors. + if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) { + return false; + } + var m; + + // Is webkit? http://stackoverflow.com/a/16459606/376773 + // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632 + // eslint-disable-next-line no-return-assign + return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || + // Is firebug? http://stackoverflow.com/a/398120/376773 + typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || + // Is firefox >= v31? + // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages + typeof navigator !== 'undefined' && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || + // Double check webkit in userAgent just in case we are in a worker + typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/); + } + + /** + * Colorize log arguments if enabled. + * + * @api public + */ + + function formatArgs(args) { + args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff); + if (!this.useColors) { + return; + } + var c = 'color: ' + this.color; + args.splice(1, 0, c, 'color: inherit'); + + // The final "%c" is somewhat tricky, because there could be other + // arguments passed either before or after the %c, so we need to + // figure out the correct index to insert the CSS into + var index = 0; + var lastC = 0; + args[0].replace(/%[a-zA-Z%]/g, function (match) { + if (match === '%%') { + return; + } + index++; + if (match === '%c') { + // We only are interested in the *last* %c + // (the user may have provided their own) + lastC = index; + } + }); + args.splice(lastC, 0, c); + } + + /** + * Invokes `console.debug()` when available. + * No-op when `console.debug` is not a "function". + * If `console.debug` is not available, falls back + * to `console.log`. + * + * @api public + */ + exports.log = console.debug || console.log || function () {}; + + /** + * Save `namespaces`. + * + * @param {String} namespaces + * @api private + */ + function save(namespaces) { + try { + if (namespaces) { + exports.storage.setItem('debug', namespaces); + } else { + exports.storage.removeItem('debug'); + } + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + } + + /** + * Load `namespaces`. + * + * @return {String} returns the previously persisted debug modes + * @api private + */ + function load() { + var r; + try { + r = exports.storage.getItem('debug') || exports.storage.getItem('DEBUG'); + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + + // If debug isn't set in LS, and we're in Electron, try to load $DEBUG + if (!r && typeof process !== 'undefined' && 'env' in process) { + r = process.env.DEBUG; + } + return r; + } + + /** + * Localstorage attempts to return the localstorage. + * + * This is necessary because safari throws + * when a user disables cookies/localstorage + * and you attempt to access it. + * + * @return {LocalStorage} + * @api private + */ + + function localstorage() { + try { + // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context + // The Browser also has localStorage in the global context. + return localStorage; + } catch (error) { + // Swallow + // XXX (@Qix-) should we be logging these? + } + } + module.exports = common(exports); + var formatters = module.exports.formatters; + + /** + * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default. + */ + + formatters.j = function (v) { + try { + return JSON.stringify(v); + } catch (error) { + return '[UnexpectedJSONParseError]: ' + error.message; + } + }; + })(browser, browser.exports); + var browserExports = browser.exports; + var debugModule = /*@__PURE__*/getDefaultExportFromCjs(browserExports); + + var debug$3 = debugModule("socket.io-client:url"); // debug() + /** + * 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) { + var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ""; + var loc = arguments.length > 2 ? arguments[2] : undefined; + var obj = uri; + // default to window.location + 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)) { + debug$3("protocol-less url %s", uri); + if ("undefined" !== typeof loc) { + uri = loc.protocol + "//" + uri; + } else { + uri = "https://" + uri; + } + } + // parse + debug$3("parse %s", uri); + 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 || "/"; + var ipv6 = obj.host.indexOf(":") !== -1; + var host = ipv6 ? "[" + obj.host + "]" : obj.host; + // define unique id + obj.id = obj.protocol + "://" + host + ":" + obj.port + path; + // define href + obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port); + return obj; + } + + var withNativeArrayBuffer = typeof ArrayBuffer === "function"; + var isView = function isView(obj) { + return typeof ArrayBuffer.isView === "function" ? ArrayBuffer.isView(obj) : obj.buffer instanceof ArrayBuffer; + }; + var toString = Object.prototype.toString; + var withNativeBlob = typeof Blob === "function" || typeof Blob !== "undefined" && toString.call(Blob) === "[object BlobConstructor]"; + var withNativeFile = typeof File === "function" || typeof File !== "undefined" && toString.call(File) === "[object FileConstructor]"; + /** + * 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 (var i = 0, l = obj.length; i < l; i++) { + if (hasBinary(obj[i])) { + return true; + } + } + return false; + } + if (isBinary(obj)) { + return true; + } + if (obj.toJSON && typeof obj.toJSON === "function" && arguments.length === 1) { + return hasBinary(obj.toJSON(), true); + } + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) { + return true; + } + } + return false; + } + + /** + * 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) { + var buffers = []; + var packetData = packet.data; + var pack = packet; + pack.data = _deconstructPacket(packetData, buffers); + pack.attachments = buffers.length; // number of binary 'attachments' + return { + packet: pack, + buffers: buffers + }; + } + function _deconstructPacket(data, buffers, toJSON) { + if (!data) return data; + if (isBinary(data)) { + var placeholder = { + _placeholder: true, + num: buffers.length + }; + buffers.push(data); + return placeholder; + } else if (Array.isArray(data)) { + var newData = new Array(data.length); + for (var i = 0; i < data.length; i++) { + newData[i] = _deconstructPacket(data[i], buffers); + } + return newData; + } else if (_typeof(data) === "object" && !(data instanceof Date)) { + if (data.toJSON && typeof data.toJSON === "function" && !toJSON) { + return _deconstructPacket(data.toJSON(), buffers, true); + } + var _newData = {}; + for (var 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) { + var isIndexValid = typeof data.num === "number" && data.num >= 0 && data.num < buffers.length; + if (isIndexValid) { + return buffers[data.num]; // appropriate buffer (should be natural order anyway) + } else { + throw new Error("illegal attachments"); + } + } else if (Array.isArray(data)) { + for (var i = 0; i < data.length; i++) { + data[i] = _reconstructPacket(data[i], buffers); + } + } else if (_typeof(data) === "object") { + for (var 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. + */ + var 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 + ]; + /** + * Protocol version. + * + * @public + */ + var protocol = 5; + 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 + */ + var Encoder = /*#__PURE__*/function () { + /** + * Encoder constructor + * + * @param {function} replacer - custom replacer to pass down to JSON.parse + */ + function Encoder(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 + */ + var _proto = Encoder.prototype; + _proto.encode = function 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. + */; + _proto.encodeAsString = function encodeAsString(obj) { + // first is type + var str = "" + obj.type; + // attachments if we have them + if (obj.type === PacketType.BINARY_EVENT || obj.type === PacketType.BINARY_ACK) { + str += obj.attachments + "-"; + } + // if we have a namespace other than `/` + // 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. + */; + _proto.encodeAsBinary = function encodeAsBinary(obj) { + var deconstruction = deconstructPacket(obj); + var pack = this.encodeAsString(deconstruction.packet); + var buffers = deconstruction.buffers; + buffers.unshift(pack); // add packet info to beginning of data list + return buffers; // write all the buffers + }; + return Encoder; + }(); + /** + * A socket.io Decoder instance + * + * @return {Object} decoder + */ + var Decoder = /*#__PURE__*/function (_Emitter) { + /** + * Decoder constructor + */ + function Decoder(opts) { + var _this; + _this = _Emitter.call(this) || this; + _this.opts = _extends({ + reviver: undefined, + maxAttachments: 10 + }, typeof opts === "function" ? { + reviver: opts + } : opts); + return _this; + } + /** + * Decodes an encoded packet string into packet JSON. + * + * @param {String} obj - encoded packet + */ + _inheritsLoose(Decoder, _Emitter); + var _proto2 = Decoder.prototype; + _proto2.add = function add(obj) { + var packet; + if (typeof obj === "string") { + if (this.reconstructor) { + throw new Error("got plaintext data when reconstructing a packet"); + } + packet = this.decodeString(obj); + var isBinaryEvent = packet.type === PacketType.BINARY_EVENT; + if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) { + packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK; + // binary packet's json + this.reconstructor = new BinaryReconstructor(packet); + } else { + // non-binary full packet + _Emitter.prototype.emitReserved.call(this, "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; + _Emitter.prototype.emitReserved.call(this, "decoded", packet); + } + } + } else { + throw new Error("Unknown type: " + obj); + } + } + /** + * Decode a packet String (JSON data) + * + * @param {String} str + * @return {Object} packet + */; + _proto2.decodeString = function decodeString(str) { + var i = 0; + // look up type + var p = { + type: Number(str.charAt(0)) + }; + if (PacketType[p.type] === undefined) { + throw new Error("unknown packet type " + p.type); + } + // look up attachments if type binary + if (p.type === PacketType.BINARY_EVENT || p.type === PacketType.BINARY_ACK) { + var start = i + 1; + while (str.charAt(++i) !== "-" && i != str.length) {} + var buf = str.substring(start, i); + if (buf != Number(buf) || str.charAt(i) !== "-") { + throw new Error("Illegal attachments"); + } + var n = Number(buf); + if (!isInteger(n) || n < 1) { + 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)) { + var _start = i + 1; + while (++i) { + var c = str.charAt(i); + if ("," === c) break; + if (i === str.length) break; + } + p.nsp = str.substring(_start, i); + } else { + p.nsp = "/"; + } + // look up id + var next = str.charAt(i + 1); + if ("" !== next && Number(next) == next) { + var _start2 = i + 1; + while (++i) { + var _c = str.charAt(i); + if (null == _c || Number(_c) != _c) { + --i; + break; + } + if (i === str.length) break; + } + p.id = Number(str.substring(_start2, i + 1)); + } + // look up json data + if (str.charAt(++i)) { + var payload = this.tryParse(str.substr(i)); + if (Decoder.isPayloadValid(p.type, payload)) { + p.data = payload; + } else { + throw new Error("invalid payload"); + } + } + return p; + }; + _proto2.tryParse = function tryParse(str) { + try { + return JSON.parse(str, this.opts.reviver); + } catch (e) { + return false; + } + }; + Decoder.isPayloadValid = function 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 + */; + _proto2.destroy = function destroy() { + if (this.reconstructor) { + this.reconstructor.finishedReconstruction(); + this.reconstructor = null; + } + }; + return Decoder; + }(Emitter); + /** + * 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 + */ + var BinaryReconstructor = /*#__PURE__*/function () { + function BinaryReconstructor(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. + */ + var _proto3 = BinaryReconstructor.prototype; + _proto3.takeBinaryData = function takeBinaryData(binData) { + this.buffers.push(binData); + if (this.buffers.length === this.reconPack.attachments) { + // done with buffer list + var packet = reconstructPacket(this.reconPack, this.buffers); + this.finishedReconstruction(); + return packet; + } + return null; + } + /** + * Cleans up binary packet reconstruction variables. + */; + _proto3.finishedReconstruction = function finishedReconstruction() { + this.reconPack = null; + this.buffers = []; + }; + return BinaryReconstructor; + }(); + function isNamespaceValid(nsp) { + return typeof nsp === "string"; + } + // see https://caniuse.com/mdn-javascript_builtins_number_isinteger + var isInteger = Number.isInteger || function (value) { + return typeof value === "number" && isFinite(value) && Math.floor(value) === value; + }; + function isAckIdValid(id) { + return id === undefined || isInteger(id); + } + // 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]"; + } + function isDataValid(type, payload) { + switch (type) { + case PacketType.CONNECT: + return payload === undefined || isObject(payload); + case PacketType.DISCONNECT: + return payload === undefined; + case PacketType.EVENT: + return Array.isArray(payload) && (typeof payload[0] === "number" || typeof payload[0] === "string" && RESERVED_EVENTS$1.indexOf(payload[0]) === -1); + case PacketType.ACK: + return Array.isArray(payload); + case PacketType.CONNECT_ERROR: + return typeof payload === "string" || isObject(payload); + default: + return false; + } + } + function isPacketValid(packet) { + return isNamespaceValid(packet.nsp) && isAckIdValid(packet.id) && isDataValid(packet.type, packet.data); + } + + var parser = /*#__PURE__*/Object.freeze({ + __proto__: null, + protocol: protocol, + get PacketType () { return PacketType; }, + Encoder: Encoder, + Decoder: Decoder, + isPacketValid: isPacketValid + }); + + function on(obj, ev, fn) { + obj.on(ev, fn); + return function subDestroy() { + obj.off(ev, fn); + }; + } + + var debug$2 = debugModule("socket.io-client:socket"); // debug() + /** + * Internal events. + * These events can't be emitted by the user. + */ + var 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}`); + * }); + */ + var Socket = /*#__PURE__*/function (_Emitter) { + /** + * `Socket` constructor. + */ + function Socket(io, nsp, opts) { + var _this; + _this = _Emitter.call(this) || this; + /** + * Whether the socket is currently connected to the server. + * + * @example + * const socket = io(); + * + * socket.on("connect", () => { + * console.log(socket.connected); // true + * }); + * + * socket.on("disconnect", () => { + * console.log(socket.connected); // false + * }); + */ + _this.connected = false; + /** + * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will + * be transmitted by the server. + */ + _this.recovered = false; + /** + * Buffer for packets received before the CONNECT packet + */ + _this.receiveBuffer = []; + /** + * Buffer for packets that will be sent once the socket is connected + */ + _this.sendBuffer = []; + /** + * The queue of packets to be sent with retry in case of failure. + * + * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order. + * @private + */ + _this._queue = []; + /** + * A sequence to generate the ID of the {@link QueuedPacket}. + * @private + */ + _this._queueSeq = 0; + _this.ids = 0; + /** + * 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 = _extends({}, opts); + if (_this.io._autoConnect) _this.open(); + return _this; + } + /** + * Whether the socket is currently disconnected + * + * @example + * const socket = io(); + * + * socket.on("connect", () => { + * console.log(socket.disconnected); // false + * }); + * + * socket.on("disconnect", () => { + * console.log(socket.disconnected); // true + * }); + */ + _inheritsLoose(Socket, _Emitter); + var _proto = Socket.prototype; + /** + * Subscribe to open, close and packet events + * + * @private + */ + _proto.subEvents = function subEvents() { + if (this.subs) return; + var 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 + * }); + */; + /** + * "Opens" the socket. + * + * @example + * const socket = io({ + * autoConnect: false + * }); + * + * socket.connect(); + */ + _proto.connect = function connect() { + if (this.connected) return this; + this.subEvents(); + if (!this.io["_reconnecting"]) this.io.open(); // ensure open + if ("open" === this.io._readyState) this.onopen(); + return this; + } + /** + * Alias for {@link connect()}. + */; + _proto.open = function 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 + */; + _proto.send = function send() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + args.unshift("message"); + this.emit.apply(this, args); + return this; + } + /** + * 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 + */; + _proto.emit = function emit(ev) { + var _a, _b, _c; + if (RESERVED_EVENTS.hasOwnProperty(ev)) { + throw new Error('"' + ev.toString() + '" is a reserved event name'); + } + for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { + args[_key2 - 1] = arguments[_key2]; + } + args.unshift(ev); + if (this._opts.retries && !this.flags.fromQueue && !this.flags["volatile"]) { + this._addToQueue(args); + return this; + } + var packet = { + type: PacketType.EVENT, + data: args + }; + packet.options = {}; + packet.options.compress = this.flags.compress !== false; + // event ack callback + if ("function" === typeof args[args.length - 1]) { + var id = this.ids++; + debug$2("emitting packet with ack id %d", id); + var ack = args.pop(); + this._registerAckCallback(id, ack); + packet.id = id; + } + var isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable; + var isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired()); + var discardPacket = this.flags["volatile"] && !isTransportWritable; + if (discardPacket) { + debug$2("discard packet as the transport is not currently writable"); + } else if (isConnected) { + this.notifyOutgoingListeners(packet); + this.packet(packet); + } else { + this.sendBuffer.push(packet); + } + this.flags = {}; + return this; + } + /** + * @private + */; + _proto._registerAckCallback = function _registerAckCallback(id, ack) { + var _this2 = this; + var _a; + var timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout; + if (timeout === undefined) { + this.acks[id] = ack; + return; + } + // @ts-ignore + var timer = this.io.setTimeoutFn(function () { + delete _this2.acks[id]; + for (var i = 0; i < _this2.sendBuffer.length; i++) { + if (_this2.sendBuffer[i].id === id) { + debug$2("removing packet with ack id %d from the buffer", id); + _this2.sendBuffer.splice(i, 1); + } + } + debug$2("event with ack id %d has timed out after %d ms", id, timeout); + ack.call(_this2, new Error("operation has timed out")); + }, timeout); + var fn = function fn() { + // @ts-ignore + _this2.io.clearTimeoutFn(timer); + for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { + args[_key3] = arguments[_key3]; + } + ack.apply(_this2, 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 + */; + _proto.emitWithAck = function emitWithAck(ev) { + var _this3 = this; + for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) { + args[_key4 - 1] = arguments[_key4]; + } + return new Promise(function (resolve, reject) { + var fn = function fn(arg1, arg2) { + return arg1 ? reject(arg1) : resolve(arg2); + }; + fn.withError = true; + args.push(fn); + _this3.emit.apply(_this3, [ev].concat(args)); + }); + } + /** + * Add the packet to the queue. + * @param args + * @private + */; + _proto._addToQueue = function _addToQueue(args) { + var _this4 = this; + var ack; + if (typeof args[args.length - 1] === "function") { + ack = args.pop(); + } + var packet = { + id: this._queueSeq++, + tryCount: 0, + pending: false, + args: args, + flags: _extends({ + fromQueue: true + }, this.flags) + }; + args.push(function (err) { + if (packet !== _this4._queue[0]) { + return debug$2("packet [%d] already acknowledged", packet.id); + } + var hasError = err !== null; + if (hasError) { + if (packet.tryCount > _this4._opts.retries) { + debug$2("packet [%d] is discarded after %d tries", packet.id, packet.tryCount); + _this4._queue.shift(); + if (ack) { + ack(err); + } + } + } else { + debug$2("packet [%d] was successfully sent", packet.id); + _this4._queue.shift(); + if (ack) { + for (var _len5 = arguments.length, responseArgs = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) { + responseArgs[_key5 - 1] = arguments[_key5]; + } + ack.apply(void 0, [null].concat(responseArgs)); + } + } + packet.pending = false; + return _this4._drainQueue(); + }); + this._queue.push(packet); + this._drainQueue(); + } + /** + * Send the first packet of the queue, and wait for an acknowledgement from the server. + * @param force - whether to resend a packet that has not been acknowledged yet + * + * @private + */; + _proto._drainQueue = function _drainQueue() { + var force = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; + debug$2("draining queue"); + if (!this.connected || this._queue.length === 0) { + return; + } + var packet = this._queue[0]; + if (packet.pending && !force) { + debug$2("packet [%d] has already been sent and is waiting for an ack", packet.id); + return; + } + packet.pending = true; + packet.tryCount++; + debug$2("sending packet [%d] (try n°%d)", packet.id, packet.tryCount); + this.flags = packet.flags; + this.emit.apply(this, packet.args); + } + /** + * Sends a packet. + * + * @param packet + * @private + */; + _proto.packet = function packet(_packet) { + _packet.nsp = this.nsp; + this.io._packet(_packet); + } + /** + * Called upon engine `open`. + * + * @private + */; + _proto.onopen = function onopen() { + var _this5 = this; + debug$2("transport is open - connecting"); + if (typeof this.auth == "function") { + this.auth(function (data) { + _this5._sendConnectPacket(data); + }); + } else { + this._sendConnectPacket(this.auth); + } + } + /** + * Sends a CONNECT packet to initiate the Socket.IO session. + * + * @param data + * @private + */; + _proto._sendConnectPacket = function _sendConnectPacket(data) { + this.packet({ + type: PacketType.CONNECT, + data: this._pid ? _extends({ + pid: this._pid, + offset: this._lastOffset + }, data) : data + }); + } + /** + * Called upon engine or manager `error`. + * + * @param err + * @private + */; + _proto.onerror = function onerror(err) { + if (!this.connected) { + this.emitReserved("connect_error", err); + } + } + /** + * Called upon engine `close`. + * + * @param reason + * @param description + * @private + */; + _proto.onclose = function onclose(reason, description) { + debug$2("close (%s)", reason); + 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 + */; + _proto._clearAcks = function _clearAcks() { + var _this6 = this; + Object.keys(this.acks).forEach(function (id) { + var isBuffered = _this6.sendBuffer.some(function (packet) { + return String(packet.id) === id; + }); + if (!isBuffered) { + // note: handlers that do not accept an error as first argument are ignored here + var ack = _this6.acks[id]; + delete _this6.acks[id]; + if (ack.withError) { + ack.call(_this6, new Error("socket has been disconnected")); + } + } + }); + } + /** + * Called with socket packet. + * + * @param packet + * @private + */; + _proto.onpacket = function onpacket(packet) { + var 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(); + var err = new Error(packet.data.message); + err.data = packet.data.data; + this.emitReserved("connect_error", err); + break; + } + } + /** + * Called upon a server event. + * + * @param packet + * @private + */; + _proto.onevent = function onevent(packet) { + var args = packet.data || []; + debug$2("emitting event %j", args); + if (null != packet.id) { + debug$2("attaching ack callback to event"); + args.push(this.ack(packet.id)); + } + if (this.connected) { + this.emitEvent(args); + } else { + this.receiveBuffer.push(Object.freeze(args)); + } + }; + _proto.emitEvent = function emitEvent(args) { + if (this._anyListeners && this._anyListeners.length) { + var listeners = this._anyListeners.slice(); + var _iterator = _createForOfIteratorHelper(listeners), + _step; + try { + for (_iterator.s(); !(_step = _iterator.n()).done;) { + var listener = _step.value; + listener.apply(this, args); + } + } catch (err) { + _iterator.e(err); + } finally { + _iterator.f(); + } + } + _Emitter.prototype.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 + */; + _proto.ack = function ack(id) { + var self = this; + var sent = false; + return function () { + // prevent double callbacks + if (sent) return; + sent = true; + for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) { + args[_key6] = arguments[_key6]; + } + debug$2("sending ack %j", args); + self.packet({ + type: PacketType.ACK, + id: id, + data: args + }); }; } - /** - * Internal events. - * These events can't be emitted by the user. - */ - - var 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 - }); - var Socket = /*#__PURE__*/function (_Emitter) { - _inherits(Socket, _Emitter); - - var _super = _createSuper(Socket); - - /** - * `Socket` constructor. - * - * @public - */ - function Socket(io, nsp, opts) { - var _this; - - _classCallCheck(this, Socket); - - _this = _super.call(this); - _this.connected = false; - _this.receiveBuffer = []; - _this.sendBuffer = []; - _this.ids = 0; - _this.acks = {}; - _this.flags = {}; - _this.io = io; - _this.nsp = nsp; - - if (opts && opts.auth) { - _this.auth = opts.auth; - } - - if (_this.io._autoConnect) _this.open(); - return _this; + * Called upon a server acknowledgement. + * + * @param packet + * @private + */; + _proto.onack = function onack(packet) { + var ack = this.acks[packet.id]; + if (typeof ack !== "function") { + debug$2("bad ack %s", packet.id); + return; } - /** - * Whether the socket is currently disconnected - */ - - - _createClass(Socket, [{ - key: "disconnected", - get: function get() { - return !this.connected; - } - /** - * Subscribe to open, close and packet events - * - * @private - */ - - }, { - key: "subEvents", - value: function subEvents() { - if (this.subs) return; - var 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 - */ - - }, { - key: "active", - get: function get() { - return !!this.subs; - } - /** - * "Opens" the socket. - * - * @public - */ - - }, { - key: "connect", - value: function connect() { - if (this.connected) return this; - this.subEvents(); - if (!this.io["_reconnecting"]) this.io.open(); // ensure open - - if ("open" === this.io._readyState) this.onopen(); - return this; - } - /** - * Alias for connect() - */ - - }, { - key: "open", - value: function open() { - return this.connect(); - } - /** - * Sends a `message` event. - * - * @return self - * @public - */ - - }, { - key: "send", - value: function send() { - for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { - args[_key] = arguments[_key]; - } - - args.unshift("message"); - this.emit.apply(this, args); - return this; - } - /** - * Override `emit`. - * If the event is in `events`, it's emitted normally. - * - * @return self - * @public - */ - - }, { - key: "emit", - value: function emit(ev) { - if (RESERVED_EVENTS.hasOwnProperty(ev)) { - throw new Error('"' + ev + '" is a reserved event name'); - } - - for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) { - args[_key2 - 1] = arguments[_key2]; - } - - args.unshift(ev); - var 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]) { - var id = this.ids++; - var ack = args.pop(); - - this._registerAckCallback(id, ack); - - packet.id = id; - } - - var isTransportWritable = this.io.engine && this.io.engine.transport && this.io.engine.transport.writable; - var discardPacket = this.flags["volatile"] && (!isTransportWritable || !this.connected); - - if (discardPacket) ; else if (this.connected) { - this.notifyOutgoingListeners(packet); - this.packet(packet); - } else { - this.sendBuffer.push(packet); - } - - this.flags = {}; - return this; - } - /** - * @private - */ - - }, { - key: "_registerAckCallback", - value: function _registerAckCallback(id, ack) { - var _this2 = this; - - var timeout = this.flags.timeout; - - if (timeout === undefined) { - this.acks[id] = ack; - return; - } // @ts-ignore - - - var timer = this.io.setTimeoutFn(function () { - delete _this2.acks[id]; - - for (var i = 0; i < _this2.sendBuffer.length; i++) { - if (_this2.sendBuffer[i].id === id) { - _this2.sendBuffer.splice(i, 1); - } - } - - ack.call(_this2, new Error("operation has timed out")); - }, timeout); - - this.acks[id] = function () { - // @ts-ignore - _this2.io.clearTimeoutFn(timer); - - for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) { - args[_key3] = arguments[_key3]; - } - - ack.apply(_this2, [null].concat(args)); - }; - } - /** - * Sends a packet. - * - * @param packet - * @private - */ - - }, { - key: "packet", - value: function packet(_packet) { - _packet.nsp = this.nsp; - - this.io._packet(_packet); - } - /** - * Called upon engine `open`. - * - * @private - */ - - }, { - key: "onopen", - value: function onopen() { - var _this3 = this; - - if (typeof this.auth == "function") { - this.auth(function (data) { - _this3.packet({ - type: PacketType.CONNECT, - data: data - }); - }); - } else { - this.packet({ - type: PacketType.CONNECT, - data: this.auth - }); - } - } - /** - * Called upon engine or manager `error`. - * - * @param err - * @private - */ - - }, { - key: "onerror", - value: function onerror(err) { - if (!this.connected) { - this.emitReserved("connect_error", err); - } - } - /** - * Called upon engine `close`. - * - * @param reason - * @param description - * @private - */ - - }, { - key: "onclose", - value: function onclose(reason, description) { - this.connected = false; - delete this.id; - this.emitReserved("disconnect", reason, description); - } - /** - * Called with socket packet. - * - * @param packet - * @private - */ - - }, { - key: "onpacket", - value: function onpacket(packet) { - var sameNamespace = packet.nsp === this.nsp; - if (!sameNamespace) return; - - switch (packet.type) { - case PacketType.CONNECT: - if (packet.data && packet.data.sid) { - var id = packet.data.sid; - this.onconnect(id); - } else { - this.emitReserved("connect_error", new Error("It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)")); - } - - break; - - case PacketType.EVENT: - case PacketType.BINARY_EVENT: - this.onevent(packet); - break; - - case PacketType.ACK: - case PacketType.BINARY_ACK: - this.onack(packet); - break; - - case PacketType.DISCONNECT: - this.ondisconnect(); - break; - - case PacketType.CONNECT_ERROR: - this.destroy(); - var err = new Error(packet.data.message); // @ts-ignore - - err.data = packet.data.data; - this.emitReserved("connect_error", err); - break; - } - } - /** - * Called upon a server event. - * - * @param packet - * @private - */ - - }, { - key: "onevent", - value: function onevent(packet) { - var args = packet.data || []; - - if (null != packet.id) { - args.push(this.ack(packet.id)); - } - - if (this.connected) { - this.emitEvent(args); - } else { - this.receiveBuffer.push(Object.freeze(args)); - } - } - }, { - key: "emitEvent", - value: function emitEvent(args) { - if (this._anyListeners && this._anyListeners.length) { - var listeners = this._anyListeners.slice(); - - var _iterator = _createForOfIteratorHelper(listeners), - _step; - - try { - for (_iterator.s(); !(_step = _iterator.n()).done;) { - var listener = _step.value; - listener.apply(this, args); - } - } catch (err) { - _iterator.e(err); - } finally { - _iterator.f(); - } - } - - _get(_getPrototypeOf(Socket.prototype), "emit", this).apply(this, args); - } - /** - * Produces an ack callback to emit with an event. - * - * @private - */ - - }, { - key: "ack", - value: function ack(id) { - var self = this; - var sent = false; - return function () { - // prevent double callbacks - if (sent) return; - sent = true; - - for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) { - args[_key4] = arguments[_key4]; - } - - self.packet({ - type: PacketType.ACK, - id: id, - data: args - }); - }; - } - /** - * Called upon a server acknowlegement. - * - * @param packet - * @private - */ - - }, { - key: "onack", - value: function onack(packet) { - var ack = this.acks[packet.id]; - - if ("function" === typeof ack) { - ack.apply(this, packet.data); - delete this.acks[packet.id]; - } - } - /** - * Called upon server connect. - * - * @private - */ - - }, { - key: "onconnect", - value: function onconnect(id) { - this.id = id; - this.connected = true; - this.emitBuffered(); - this.emitReserved("connect"); - } - /** - * Emit buffered events (received and emitted). - * - * @private - */ - - }, { - key: "emitBuffered", - value: function emitBuffered() { - var _this4 = this; - - this.receiveBuffer.forEach(function (args) { - return _this4.emitEvent(args); - }); - this.receiveBuffer = []; - this.sendBuffer.forEach(function (packet) { - _this4.notifyOutgoingListeners(packet); - - _this4.packet(packet); - }); - this.sendBuffer = []; - } - /** - * Called upon server disconnect. - * - * @private - */ - - }, { - key: "ondisconnect", - value: function 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 - */ - - }, { - key: "destroy", - value: function destroy() { - if (this.subs) { - // clean subscriptions to avoid reconnections - this.subs.forEach(function (subDestroy) { - return subDestroy(); - }); - this.subs = undefined; - } - - this.io["_destroy"](this); - } - /** - * Disconnects the socket manually. - * - * @return self - * @public - */ - - }, { - key: "disconnect", - value: function 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 disconnect() - * - * @return self - * @public - */ - - }, { - key: "close", - value: function close() { - return this.disconnect(); - } - /** - * Sets the compress flag. - * - * @param compress - if `true`, compresses the sending data - * @return self - * @public - */ - - }, { - key: "compress", - value: function 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. - * - * @returns self - * @public - */ - - }, { - key: "volatile", - get: function get() { - 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: - * - * ``` - * socket.timeout(5000).emit("my-event", (err) => { - * if (err) { - * // the server did not acknowledge the event in the given delay - * } - * }); - * ``` - * - * @returns self - * @public - */ - - }, { - key: "timeout", - value: function timeout(_timeout) { - 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. - * - * @param listener - * @public - */ - - }, { - key: "onAny", - value: function onAny(listener) { - this._anyListeners = this._anyListeners || []; - - this._anyListeners.push(listener); - - return this; - } - /** - * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the - * callback. The listener is added to the beginning of the listeners array. - * - * @param listener - * @public - */ - - }, { - key: "prependAny", - value: function prependAny(listener) { - this._anyListeners = this._anyListeners || []; - - this._anyListeners.unshift(listener); - - return this; - } - /** - * Removes the listener that will be fired when any event is emitted. - * - * @param listener - * @public - */ - - }, { - key: "offAny", - value: function offAny(listener) { - if (!this._anyListeners) { - return this; - } - - if (listener) { - var listeners = this._anyListeners; - - for (var i = 0; i < listeners.length; i++) { - if (listener === listeners[i]) { - listeners.splice(i, 1); - 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. - * - * @public - */ - - }, { - key: "listenersAny", - value: function 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. - * - * @param listener - * - * 

-         *
-         * socket.onAnyOutgoing((event, ...args) => {
-         *   console.log(event);
-         * });
-         *
-         *
- * - * @public - */ - - }, { - key: "onAnyOutgoing", - value: function onAnyOutgoing(listener) { - this._anyOutgoingListeners = this._anyOutgoingListeners || []; - - this._anyOutgoingListeners.push(listener); - - return this; - } - /** - * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the - * callback. The listener is added to the beginning of the listeners array. - * - * @param listener - * - * 

-         *
-         * socket.prependAnyOutgoing((event, ...args) => {
-         *   console.log(event);
-         * });
-         *
-         *
- * - * @public - */ - - }, { - key: "prependAnyOutgoing", - value: function prependAnyOutgoing(listener) { - this._anyOutgoingListeners = this._anyOutgoingListeners || []; - - this._anyOutgoingListeners.unshift(listener); - - return this; - } - /** - * Removes the listener that will be fired when any event is emitted. - * - * @param listener - * - * 

-         *
-         * const handler = (event, ...args) => {
-         *   console.log(event);
-         * }
-         *
-         * socket.onAnyOutgoing(handler);
-         *
-         * // then later
-         * socket.offAnyOutgoing(handler);
-         *
-         *
- * - * @public - */ - - }, { - key: "offAnyOutgoing", - value: function offAnyOutgoing(listener) { - if (!this._anyOutgoingListeners) { - return this; - } - - if (listener) { - var listeners = this._anyOutgoingListeners; - - for (var i = 0; i < listeners.length; i++) { - if (listener === listeners[i]) { - listeners.splice(i, 1); - 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. - * - * @public - */ - - }, { - key: "listenersAnyOutgoing", - value: function listenersAnyOutgoing() { - return this._anyOutgoingListeners || []; - } - /** - * Notify the listeners for each packet sent - * - * @param packet - * - * @private - */ - - }, { - key: "notifyOutgoingListeners", - value: function notifyOutgoingListeners(packet) { - if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) { - var listeners = this._anyOutgoingListeners.slice(); - - var _iterator2 = _createForOfIteratorHelper(listeners), - _step2; - - try { - for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { - var listener = _step2.value; - listener.apply(this, packet.data); - } - } catch (err) { - _iterator2.e(err); - } finally { - _iterator2.f(); - } - } - } - }]); - - return Socket; - }(Emitter); - - /** - * 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; + delete this.acks[packet.id]; + debug$2("calling ack %s with %j", packet.id, packet.data); + // @ts-ignore FIXME ack is incorrectly inferred as 'never' + if (ack.withError) { + packet.data.unshift(null); + } + // @ts-ignore + ack.apply(this, packet.data); } /** - * Return the backoff duration. + * Called upon server connect. * - * @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; - }; + * @private + */; + _proto.onconnect = function onconnect(id, pid) { + debug$2("socket connected with id %s", id); + 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"); + } /** - * Reset the number of attempts. + * Emit buffered events (received and emitted). * - * @api public - */ - - - Backoff.prototype.reset = function () { - this.attempts = 0; - }; + * @private + */; + _proto.emitBuffered = function emitBuffered() { + var _this7 = this; + this.receiveBuffer.forEach(function (args) { + return _this7.emitEvent(args); + }); + this.receiveBuffer = []; + this.sendBuffer.forEach(function (packet) { + _this7.notifyOutgoingListeners(packet); + _this7.packet(packet); + }); + this.sendBuffer = []; + } /** - * Set the minimum duration + * Called upon server disconnect. * - * @api public - */ - - - Backoff.prototype.setMin = function (min) { - this.ms = min; - }; + * @private + */; + _proto.ondisconnect = function ondisconnect() { + debug$2("server disconnect (%s)", this.nsp); + this.destroy(); + this.onclose("io server disconnect"); + } /** - * Set the maximum duration + * Called upon forced client/server side disconnections, + * this method ensures the manager stops tracking us and + * that reconnections don't get triggered for this. * - * @api public - */ - - - Backoff.prototype.setMax = function (max) { - this.max = max; - }; - /** - * Set the jitter - * - * @api public - */ - - - Backoff.prototype.setJitter = function (jitter) { - this.jitter = jitter; - }; - - var Manager = /*#__PURE__*/function (_Emitter) { - _inherits(Manager, _Emitter); - - var _super = _createSuper(Manager); - - function Manager(uri, opts) { - var _this; - - _classCallCheck(this, Manager); - - var _a; - - _this = _super.call(this); - _this.nsps = {}; - _this.subs = []; - - if (uri && "object" === _typeof(uri)) { - opts = uri; - uri = undefined; - } - - opts = opts || {}; - opts.path = opts.path || "/socket.io"; - _this.opts = opts; - installTimerFunctions(_assertThisInitialized(_this), opts); - - _this.reconnection(opts.reconnection !== false); - - _this.reconnectionAttempts(opts.reconnectionAttempts || Infinity); - - _this.reconnectionDelay(opts.reconnectionDelay || 1000); - - _this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000); - - _this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5); - - _this.backoff = new Backoff({ - min: _this.reconnectionDelay(), - max: _this.reconnectionDelayMax(), - jitter: _this.randomizationFactor() + * @private + */; + _proto.destroy = function destroy() { + if (this.subs) { + // clean subscriptions to avoid reconnections + this.subs.forEach(function (subDestroy) { + return subDestroy(); }); - - _this.timeout(null == opts.timeout ? 20000 : opts.timeout); - - _this._readyState = "closed"; - _this.uri = uri; - - var _parser = opts.parser || parser; - - _this.encoder = new _parser.Encoder(); - _this.decoder = new _parser.Decoder(); - _this._autoConnect = opts.autoConnect !== false; - if (_this._autoConnect) _this.open(); - return _this; + this.subs = undefined; } - - _createClass(Manager, [{ - key: "reconnection", - value: function reconnection(v) { - if (!arguments.length) return this._reconnection; - this._reconnection = !!v; - return this; - } - }, { - key: "reconnectionAttempts", - value: function reconnectionAttempts(v) { - if (v === undefined) return this._reconnectionAttempts; - this._reconnectionAttempts = v; - return this; - } - }, { - key: "reconnectionDelay", - value: function reconnectionDelay(v) { - var _a; - - if (v === undefined) return this._reconnectionDelay; - this._reconnectionDelay = v; - (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v); - return this; - } - }, { - key: "randomizationFactor", - value: function randomizationFactor(v) { - var _a; - - if (v === undefined) return this._randomizationFactor; - this._randomizationFactor = v; - (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v); - return this; - } - }, { - key: "reconnectionDelayMax", - value: function reconnectionDelayMax(v) { - var _a; - - if (v === undefined) return this._reconnectionDelayMax; - this._reconnectionDelayMax = v; - (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v); - return this; - } - }, { - key: "timeout", - value: function 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 - */ - - }, { - key: "maybeReconnectOnOpen", - value: function 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 - */ - - }, { - key: "open", - value: function open(fn) { - var _this2 = this; - - if (~this._readyState.indexOf("open")) return this; - this.engine = new Socket$1(this.uri, this.opts); - var socket = this.engine; - var self = this; - this._readyState = "opening"; - this.skipReconnect = false; // emit `open` - - var openSubDestroy = on(socket, "open", function () { - self.onopen(); - fn && fn(); - }); // emit `error` - - var errorSub = on(socket, "error", function (err) { - self.cleanup(); - self._readyState = "closed"; - - _this2.emitReserved("error", err); - - if (fn) { - fn(err); - } else { - // Only do this if there is no fn to handle the error - self.maybeReconnectOnOpen(); - } - }); - - if (false !== this._timeout) { - var timeout = this._timeout; - - if (timeout === 0) { - openSubDestroy(); // prevents a race condition with the 'open' event - } // set timer - - - var timer = this.setTimeoutFn(function () { - openSubDestroy(); - socket.close(); // @ts-ignore - - socket.emit("error", new Error("timeout")); - }, timeout); - - if (this.opts.autoUnref) { - timer.unref(); - } - - this.subs.push(function subDestroy() { - clearTimeout(timer); - }); - } - - this.subs.push(openSubDestroy); - this.subs.push(errorSub); - return this; - } - /** - * Alias for open() - * - * @return self - * @public - */ - - }, { - key: "connect", - value: function connect(fn) { - return this.open(fn); - } - /** - * Called upon transport open. - * - * @private - */ - - }, { - key: "onopen", - value: function onopen() { - // clear old subs - this.cleanup(); // mark as open - - this._readyState = "open"; - this.emitReserved("open"); // add new subs - - var socket = this.engine; - this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), on(this.decoder, "decoded", this.ondecoded.bind(this))); - } - /** - * Called upon a ping. - * - * @private - */ - - }, { - key: "onping", - value: function onping() { - this.emitReserved("ping"); - } - /** - * Called with data. - * - * @private - */ - - }, { - key: "ondata", - value: function ondata(data) { - this.decoder.add(data); - } - /** - * Called when parser fully decodes a packet. - * - * @private - */ - - }, { - key: "ondecoded", - value: function ondecoded(packet) { - this.emitReserved("packet", packet); - } - /** - * Called upon socket error. - * - * @private - */ - - }, { - key: "onerror", - value: function onerror(err) { - this.emitReserved("error", err); - } - /** - * Creates a new socket for the given `nsp`. - * - * @return {Socket} - * @public - */ - - }, { - key: "socket", - value: function socket(nsp, opts) { - var socket = this.nsps[nsp]; - - if (!socket) { - socket = new Socket(this, nsp, opts); - this.nsps[nsp] = socket; - } - - return socket; - } - /** - * Called upon a socket close. - * - * @param socket - * @private - */ - - }, { - key: "_destroy", - value: function _destroy(socket) { - var nsps = Object.keys(this.nsps); - - for (var _i = 0, _nsps = nsps; _i < _nsps.length; _i++) { - var nsp = _nsps[_i]; - var _socket = this.nsps[nsp]; - - if (_socket.active) { - return; - } - } - - this._close(); - } - /** - * Writes a packet. - * - * @param packet - * @private - */ - - }, { - key: "_packet", - value: function _packet(packet) { - var encodedPackets = this.encoder.encode(packet); - - for (var i = 0; i < encodedPackets.length; i++) { - this.engine.write(encodedPackets[i], packet.options); - } - } - /** - * Clean up transport subscriptions and packet buffer. - * - * @private - */ - - }, { - key: "cleanup", - value: function cleanup() { - this.subs.forEach(function (subDestroy) { - return subDestroy(); - }); - this.subs.length = 0; - this.decoder.destroy(); - } - /** - * Close the current socket. - * - * @private - */ - - }, { - key: "_close", - value: function _close() { - this.skipReconnect = true; - this._reconnecting = false; - this.onclose("forced close"); - if (this.engine) this.engine.close(); - } - /** - * Alias for close() - * - * @private - */ - - }, { - key: "disconnect", - value: function disconnect() { - return this._close(); - } - /** - * Called upon engine close. - * - * @private - */ - - }, { - key: "onclose", - value: function onclose(reason, description) { - this.cleanup(); - this.backoff.reset(); - this._readyState = "closed"; - this.emitReserved("close", reason, description); - - if (this._reconnection && !this.skipReconnect) { - this.reconnect(); - } - } - /** - * Attempt a reconnection. - * - * @private - */ - - }, { - key: "reconnect", - value: function reconnect() { - var _this3 = this; - - if (this._reconnecting || this.skipReconnect) return this; - var self = this; - - if (this.backoff.attempts >= this._reconnectionAttempts) { - this.backoff.reset(); - this.emitReserved("reconnect_failed"); - this._reconnecting = false; - } else { - var delay = this.backoff.duration(); - this._reconnecting = true; - var timer = this.setTimeoutFn(function () { - if (self.skipReconnect) return; - - _this3.emitReserved("reconnect_attempt", self.backoff.attempts); // check again for the case socket closed in above events - - - if (self.skipReconnect) return; - self.open(function (err) { - if (err) { - self._reconnecting = false; - self.reconnect(); - - _this3.emitReserved("reconnect_error", err); - } else { - self.onreconnect(); - } - }); - }, delay); - - if (this.opts.autoUnref) { - timer.unref(); - } - - this.subs.push(function subDestroy() { - clearTimeout(timer); - }); - } - } - /** - * Called upon successful reconnect. - * - * @private - */ - - }, { - key: "onreconnect", - value: function onreconnect() { - var attempt = this.backoff.attempts; - this._reconnecting = false; - this.backoff.reset(); - this.emitReserved("reconnect", attempt); - } - }]); - - return Manager; - }(Emitter); - + this.io["_destroy"](this); + } /** - * Managers cache. + * 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 + */; + _proto.disconnect = function disconnect() { + if (this.connected) { + debug$2("performing disconnect (%s)", this.nsp); + 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 + */; + _proto.close = function close() { + return this.disconnect(); + } + /** + * Sets the compress flag. + * + * @example + * socket.compress(false).emit("hello"); + * + * @param compress - if `true`, compresses the sending data + * @return self + */; + _proto.compress = function 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 + */; + /** + * 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 */ - - var cache = {}; - - function lookup(uri, opts) { - if (_typeof(uri) === "object") { + _proto.timeout = function 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 + */; + _proto.onAny = function onAny(listener) { + this._anyListeners = this._anyListeners || []; + this._anyListeners.push(listener); + return this; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. The listener is added to the beginning of the listeners array. + * + * @example + * socket.prependAny((event, ...args) => { + * console.log(`got event ${event}`); + * }); + * + * @param listener + */; + _proto.prependAny = function prependAny(listener) { + this._anyListeners = this._anyListeners || []; + this._anyListeners.unshift(listener); + return this; + } + /** + * Removes the listener that will be fired when any event is emitted. + * + * @example + * const catchAllListener = (event, ...args) => { + * console.log(`got event ${event}`); + * } + * + * socket.onAny(catchAllListener); + * + * // remove a specific listener + * socket.offAny(catchAllListener); + * + * // or remove all listeners + * socket.offAny(); + * + * @param listener + */; + _proto.offAny = function offAny(listener) { + if (!this._anyListeners) { + return this; + } + if (listener) { + var listeners = this._anyListeners; + for (var i = 0; i < listeners.length; i++) { + if (listener === listeners[i]) { + listeners.splice(i, 1); + 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. + */; + _proto.listenersAny = function 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 + */; + _proto.onAnyOutgoing = function onAnyOutgoing(listener) { + this._anyOutgoingListeners = this._anyOutgoingListeners || []; + this._anyOutgoingListeners.push(listener); + return this; + } + /** + * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the + * callback. The listener is added to the beginning of the listeners array. + * + * Note: acknowledgements sent to the server are not included. + * + * @example + * socket.prependAnyOutgoing((event, ...args) => { + * console.log(`sent event ${event}`); + * }); + * + * @param listener + */; + _proto.prependAnyOutgoing = function prependAnyOutgoing(listener) { + this._anyOutgoingListeners = this._anyOutgoingListeners || []; + this._anyOutgoingListeners.unshift(listener); + return this; + } + /** + * Removes the listener that will be fired when any event is emitted. + * + * @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) + */; + _proto.offAnyOutgoing = function offAnyOutgoing(listener) { + if (!this._anyOutgoingListeners) { + return this; + } + if (listener) { + var listeners = this._anyOutgoingListeners; + for (var i = 0; i < listeners.length; i++) { + if (listener === listeners[i]) { + listeners.splice(i, 1); + 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. + */; + _proto.listenersAnyOutgoing = function listenersAnyOutgoing() { + return this._anyOutgoingListeners || []; + } + /** + * Notify the listeners for each packet sent + * + * @param packet + * + * @private + */; + _proto.notifyOutgoingListeners = function notifyOutgoingListeners(packet) { + if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) { + var listeners = this._anyOutgoingListeners.slice(); + var _iterator2 = _createForOfIteratorHelper(listeners), + _step2; + try { + for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { + var listener = _step2.value; + listener.apply(this, packet.data); + } + } catch (err) { + _iterator2.e(err); + } finally { + _iterator2.f(); + } + } + }; + return _createClass(Socket, [{ + key: "disconnected", + get: function get() { + return !this.connected; + } + }, { + key: "active", + get: function get() { + return !!this.subs; + } + }, { + key: "volatile", + get: function get() { + this.flags["volatile"] = true; + return this; + } + }]); + }(Emitter); + + /** + * 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; + }; + + var debug$1 = debugModule("socket.io-client:manager"); // debug() + var Manager = /*#__PURE__*/function (_Emitter) { + function Manager(uri, opts) { + var _this; + var _a; + _this = _Emitter.call(this) || this; + _this.nsps = {}; + _this.subs = []; + if (uri && "object" === _typeof(uri)) { opts = uri; uri = undefined; } - opts = opts || {}; - var parsed = url(uri, opts.path || "/socket.io"); - var source = parsed.source; - var id = parsed.id; - var path = parsed.path; - var sameNamespace = cache[id] && path in cache[id]["nsps"]; - var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace; - var io; - - if (newConnection) { - io = new Manager(source, opts); - } else { - if (!cache[id]) { - cache[id] = new Manager(source, opts); + 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; + var _parser = opts.parser || parser; + _this.encoder = new _parser.Encoder(); + _this.decoder = new _parser.Decoder(); + _this._autoConnect = opts.autoConnect !== false; + if (_this._autoConnect) _this.open(); + return _this; + } + _inheritsLoose(Manager, _Emitter); + var _proto = Manager.prototype; + _proto.reconnection = function reconnection(v) { + if (!arguments.length) return this._reconnection; + this._reconnection = !!v; + if (!v) { + this.skipReconnect = true; + } + return this; + }; + _proto.reconnectionAttempts = function reconnectionAttempts(v) { + if (v === undefined) return this._reconnectionAttempts; + this._reconnectionAttempts = v; + return this; + }; + _proto.reconnectionDelay = function reconnectionDelay(v) { + var _a; + if (v === undefined) return this._reconnectionDelay; + this._reconnectionDelay = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v); + return this; + }; + _proto.randomizationFactor = function randomizationFactor(v) { + var _a; + if (v === undefined) return this._randomizationFactor; + this._randomizationFactor = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v); + return this; + }; + _proto.reconnectionDelayMax = function reconnectionDelayMax(v) { + var _a; + if (v === undefined) return this._reconnectionDelayMax; + this._reconnectionDelayMax = v; + (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v); + return this; + }; + _proto.timeout = function 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 + */; + _proto.maybeReconnectOnOpen = function 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 + */; + _proto.open = function open(fn) { + var _this2 = this; + debug$1("readyState %s", this._readyState); + if (~this._readyState.indexOf("open")) return this; + debug$1("opening %s", this.uri); + this.engine = new Socket$1(this.uri, this.opts); + var socket = this.engine; + var self = this; + this._readyState = "opening"; + this.skipReconnect = false; + // emit `open` + var openSubDestroy = on(socket, "open", function () { + self.onopen(); + fn && fn(); + }); + var onError = function onError(err) { + debug$1("error"); + _this2.cleanup(); + _this2._readyState = "closed"; + _this2.emitReserved("error", err); + if (fn) { + fn(err); + } else { + // Only do this if there is no fn to handle the error + _this2.maybeReconnectOnOpen(); } - - io = cache[id]; + }; + // emit `error` + var errorSub = on(socket, "error", onError); + if (false !== this._timeout) { + var timeout = this._timeout; + debug$1("connect attempt will timeout after %d", timeout); + // set timer + var timer = this.setTimeoutFn(function () { + debug$1("connect attempt timed out after %d", timeout); + openSubDestroy(); + onError(new Error("timeout")); + socket.close(); + }, timeout); + if (this.opts.autoUnref) { + timer.unref(); + } + this.subs.push(function () { + _this2.clearTimeoutFn(timer); + }); } - - if (parsed.query && !opts.query) { - opts.query = parsed.queryKey; + this.subs.push(openSubDestroy); + this.subs.push(errorSub); + return this; + } + /** + * Alias for open() + * + * @return self + * @public + */; + _proto.connect = function connect(fn) { + return this.open(fn); + } + /** + * Called upon transport open. + * + * @private + */; + _proto.onopen = function onopen() { + debug$1("open"); + // clear old subs + this.cleanup(); + // mark as open + this._readyState = "open"; + this.emitReserved("open"); + // add new subs + var socket = this.engine; + this.subs.push(on(socket, "ping", this.onping.bind(this)), on(socket, "data", this.ondata.bind(this)), on(socket, "error", this.onerror.bind(this)), on(socket, "close", this.onclose.bind(this)), + // @ts-ignore + on(this.decoder, "decoded", this.ondecoded.bind(this))); + } + /** + * Called upon a ping. + * + * @private + */; + _proto.onping = function onping() { + this.emitReserved("ping"); + } + /** + * Called with data. + * + * @private + */; + _proto.ondata = function ondata(data) { + try { + this.decoder.add(data); + } catch (e) { + this.onclose("parse error", e); } - - 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 - - - _extends(lookup, { - Manager: Manager, - Socket: Socket, - io: lookup, - connect: lookup - }); - - return lookup; - - })); - //# sourceMappingURL=socket.io.js.map \ No newline at end of file + } + /** + * Called when parser fully decodes a packet. + * + * @private + */; + _proto.ondecoded = function ondecoded(packet) { + var _this3 = this; + // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a "parse error" + nextTick(function () { + _this3.emitReserved("packet", packet); + }, this.setTimeoutFn); + } + /** + * Called upon socket error. + * + * @private + */; + _proto.onerror = function onerror(err) { + debug$1("error", err); + this.emitReserved("error", err); + } + /** + * Creates a new socket for the given `nsp`. + * + * @return {Socket} + * @public + */; + _proto.socket = function socket(nsp, opts) { + var socket = this.nsps[nsp]; + if (!socket) { + socket = new Socket(this, nsp, opts); + this.nsps[nsp] = socket; + } else if (this._autoConnect && !socket.active) { + socket.connect(); + } + return socket; + } + /** + * Called upon a socket close. + * + * @param socket + * @private + */; + _proto._destroy = function _destroy(socket) { + var nsps = Object.keys(this.nsps); + for (var _i = 0, _nsps = nsps; _i < _nsps.length; _i++) { + var nsp = _nsps[_i]; + var _socket = this.nsps[nsp]; + if (_socket.active) { + debug$1("socket %s is still active, skipping close", nsp); + return; + } + } + this._close(); + } + /** + * Writes a packet. + * + * @param packet + * @private + */; + _proto._packet = function _packet(packet) { + debug$1("writing packet %j", packet); + var encodedPackets = this.encoder.encode(packet); + for (var i = 0; i < encodedPackets.length; i++) { + this.engine.write(encodedPackets[i], packet.options); + } + } + /** + * Clean up transport subscriptions and packet buffer. + * + * @private + */; + _proto.cleanup = function cleanup() { + debug$1("cleanup"); + this.subs.forEach(function (subDestroy) { + return subDestroy(); + }); + this.subs.length = 0; + this.decoder.destroy(); + } + /** + * Close the current socket. + * + * @private + */; + _proto._close = function _close() { + debug$1("disconnect"); + this.skipReconnect = true; + this._reconnecting = false; + this.onclose("forced close"); + } + /** + * Alias for close() + * + * @private + */; + _proto.disconnect = function disconnect() { + return this._close(); + } + /** + * Called when: + * + * - the low-level engine is closed + * - the parser encountered a badly formatted packet + * - all sockets are disconnected + * + * @private + */; + _proto.onclose = function onclose(reason, description) { + var _a; + debug$1("closed due to %s", reason); + 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 + */; + _proto.reconnect = function reconnect() { + var _this4 = this; + if (this._reconnecting || this.skipReconnect) return this; + var self = this; + if (this.backoff.attempts >= this._reconnectionAttempts) { + debug$1("reconnect failed"); + this.backoff.reset(); + this.emitReserved("reconnect_failed"); + this._reconnecting = false; + } else { + var delay = this.backoff.duration(); + debug$1("will wait %dms before reconnect attempt", delay); + this._reconnecting = true; + var timer = this.setTimeoutFn(function () { + if (self.skipReconnect) return; + debug$1("attempting reconnect"); + _this4.emitReserved("reconnect_attempt", self.backoff.attempts); + // check again for the case socket closed in above events + if (self.skipReconnect) return; + self.open(function (err) { + if (err) { + debug$1("reconnect attempt error"); + self._reconnecting = false; + self.reconnect(); + _this4.emitReserved("reconnect_error", err); + } else { + debug$1("reconnect success"); + self.onreconnect(); + } + }); + }, delay); + if (this.opts.autoUnref) { + timer.unref(); + } + this.subs.push(function () { + _this4.clearTimeoutFn(timer); + }); + } + } + /** + * Called upon successful reconnect. + * + * @private + */; + _proto.onreconnect = function onreconnect() { + var attempt = this.backoff.attempts; + this._reconnecting = false; + this.backoff.reset(); + this.emitReserved("reconnect", attempt); + }; + return Manager; + }(Emitter); + + var debug = debugModule("socket.io-client"); // debug() + /** + * Managers cache. + */ + var cache = {}; + function lookup(uri, opts) { + if (_typeof(uri) === "object") { + opts = uri; + uri = undefined; + } + opts = opts || {}; + var parsed = url(uri, opts.path || "/socket.io"); + var source = parsed.source; + var id = parsed.id; + var path = parsed.path; + var sameNamespace = cache[id] && path in cache[id]["nsps"]; + var newConnection = opts.forceNew || opts["force new connection"] || false === opts.multiplex || sameNamespace; + var io; + if (newConnection) { + debug("ignoring socket cache for %s", source); + io = new Manager(source, opts); + } else { + if (!cache[id]) { + debug("new io instance for %s", source); + 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 + _extends(lookup, { + Manager: Manager, + Socket: Socket, + io: lookup, + connect: lookup + }); + + return lookup; + +})); +//# sourceMappingURL=socket.io.js.map