https://hooppy.ru/socket.io/socket.io.js

1/*!
2 * Socket.IO v3.1.2
3 * (c) 2014-2021 Guillermo Rauch
4 * Released under the MIT License.
5 */
6(function webpackUniversalModuleDefinition(root, factory) {
7	if(typeof exports === 'object' && typeof module === 'object')
8		module.exports = factory();
9	else if(typeof define === 'function' && define.amd)
10		define([], factory);
11	else if(typeof exports === 'object')
12		exports["io"] = factory();
13	else
14		root["io"] = factory();
15})(this, function() {
16return /******/ (function(modules) { // webpackBootstrap
17/******/ 	// The module cache
18/******/ 	var installedModules = {};
19/******/
20/******/ 	// The require function
21/******/ 	function __webpack_require__(moduleId) {
22/******/
23/******/ 		// Check if module is in cache
24/******/ 		if(installedModules[moduleId]) {
25/******/ 			return installedModules[moduleId].exports;
26/******/ 		}
27/******/ 		// Create a new module (and put it into the cache)
28/******/ 		var module = installedModules[moduleId] = {
29/******/ 			i: moduleId,
30/******/ 			l: false,
31/******/ 			exports: {}
32/******/ 		};
33/******/
34/******/ 		// Execute the module function
35/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
36/******/
37/******/ 		// Flag the module as loaded
38/******/ 		module.l = true;
39/******/
40/******/ 		// Return the exports of the module
41/******/ 		return module.exports;
42/******/ 	}
43/******/
44/******/
45/******/ 	// expose the modules object (__webpack_modules__)
46/******/ 	__webpack_require__.m = modules;
47/******/
48/******/ 	// expose the module cache
49/******/ 	__webpack_require__.c = installedModules;
50/******/
51/******/ 	// define getter function for harmony exports
52/******/ 	__webpack_require__.d = function(exports, name, getter) {
53/******/ 		if(!__webpack_require__.o(exports, name)) {
54/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
55/******/ 		}
56/******/ 	};
57/******/
58/******/ 	// define __esModule on exports
59/******/ 	__webpack_require__.r = function(exports) {
60/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
61/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
62/******/ 		}
63/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
64/******/ 	};
65/******/
66/******/ 	// create a fake namespace object
67/******/ 	// mode & 1: value is a module id, require it
68/******/ 	// mode & 2: merge all properties of value into the ns
69/******/ 	// mode & 4: return value when already ns object
70/******/ 	// mode & 8|1: behave like require
71/******/ 	__webpack_require__.t = function(value, mode) {
72/******/ 		if(mode & 1) value = __webpack_require__(value);
73/******/ 		if(mode & 8) return value;
74/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
75/******/ 		var ns = Object.create(null);
76/******/ 		__webpack_require__.r(ns);
77/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
78/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
79/******/ 		return ns;
80/******/ 	};
81/******/
82/******/ 	// getDefaultExport function for compatibility with non-harmony modules
83/******/ 	__webpack_require__.n = function(module) {
84/******/ 		var getter = module && module.__esModule ?
85/******/ 			function getDefault() { return module['default']; } :
86/******/ 			function getModuleExports() { return module; };
87/******/ 		__webpack_require__.d(getter, 'a', getter);
88/******/ 		return getter;
89/******/ 	};
90/******/
91/******/ 	// Object.prototype.hasOwnProperty.call
92/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
93/******/
94/******/ 	// __webpack_public_path__
95/******/ 	__webpack_require__.p = "";
96/******/
97/******/
98/******/ 	// Load entry module and return exports
99/******/ 	return __webpack_require__(__webpack_require__.s = "./build/index.js");
100/******/ })
101/************************************************************************/
102/******/ ({
103

221/***/ "./build/manager.js":
222/*!**************************!*\
223  !*** ./build/manager.js ***!
224  \**************************/
225/*! no static exports found */
226/***/ (function(module, exports, __webpack_require__) {
227
228"use strict";
229
230
231function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
232
233function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
234
235function _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); } }
236
237function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
238
239function _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); }
240
241function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
242
243function _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); }
244
245function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
246
247function _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); }; }
248
249function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
250
251function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
252
253function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
254
255function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
256
257Object.defineProperty(exports, "__esModule", {
258  value: true
259});
260exports.Manager = void 0;
261
262var eio = __webpack_require__(/*! engine.io-client */ "./node_modules/engine.io-client/lib/index.js");
263
264var socket_1 = __webpack_require__(/*! ./socket */ "./build/socket.js");
265
266var Emitter = __webpack_require__(/*! component-emitter */ "./node_modules/component-emitter/index.js");
267
268var parser = __webpack_require__(/*! socket.io-parser */ "./node_modules/socket.io-parser/dist/index.js");
269
270var on_1 = __webpack_require__(/*! ./on */ "./build/on.js");
271
272var Backoff = __webpack_require__(/*! backo2 */ "./node_modules/backo2/index.js");
273
274var debug = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("socket.io-client:manager");
275
276var Manager = /*#__PURE__*/function (_Emitter) {
277  _inherits(Manager, _Emitter);
278
279  var _super = _createSuper(Manager);
280
281  function Manager(uri, opts) {
282    var _this;
283
284    _classCallCheck(this, Manager);
285
286    _this = _super.call(this);
287    _this.nsps = {};
288    _this.subs = [];
289
290    if (uri && "object" === _typeof(uri)) {
291      opts = uri;
292      uri = undefined;
293    }
294
295    opts = opts || {};
296    opts.path = opts.path || "/socket.io";
297    _this.opts = opts;
298
299    _this.reconnection(opts.reconnection !== false);
300
301    _this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);
302
303    _this.reconnectionDelay(opts.reconnectionDelay || 1000);
304
305    _this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);
306
307    _this.randomizationFactor(opts.randomizationFactor || 0.5);
308
309    _this.backoff = new Backoff({
310      min: _this.reconnectionDelay(),
311      max: _this.reconnectionDelayMax(),
312      jitter: _this.randomizationFactor()
313    });
314
315    _this.timeout(null == opts.timeout ? 20000 : opts.timeout);
316
317    _this._readyState = "closed";
318    _this.uri = uri;
319
320    var _parser = opts.parser || parser;
321
322    _this.encoder = new _parser.Encoder();
323    _this.decoder = new _parser.Decoder();
324    _this._autoConnect = opts.autoConnect !== false;
325    if (_this._autoConnect) _this.open();
326    return _this;
327  }
328
329  _createClass(Manager, [{

772/***/ "./build/socket.js":
773/*!*************************!*\
774  !*** ./build/socket.js ***!
775  \*************************/
776/*! no static exports found */
777/***/ (function(module, exports, __webpack_require__) {
778
779"use strict";
780
781
782function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
783
784function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_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 s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
785
786function _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); }
787
788function _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; }
789
790function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
791
792function _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); } }
793
794function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
795
796function _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); }
797
798function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
799
800function _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); }
801
802function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
803
804function _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); }; }
805
806function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
807
808function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
809
810function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
811

1438/***/ "./build/url.js":
1439/*!**********************!*\
1440  !*** ./build/url.js ***!
1441  \**********************/
1442/*! no static exports found */
1443/***/ (function(module, exports, __webpack_require__) {
1444
1445"use strict";
1446
1447
1448Object.defineProperty(exports, "__esModule", {
1449  value: true
1450});
1451exports.url = void 0;
1452
1453var parseuri = __webpack_require__(/*! parseuri */ "./node_modules/parseuri/index.js");
1454
1455var debug = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("socket.io-client:url");
1456/**
1457 * URL parser.
1458 *
1459 * @param uri - url
1460 * @param path - the request path of the connection
1461 * @param loc - An object meant to mimic window.location.
1462 *        Defaults to window.location.
1463 * @public
1464 */
1465
1466
1467function url(uri) {
1468  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
1469  var loc = arguments.length > 2 ? arguments[2] : undefined;
1470  var obj = uri; // default to window.location
1471
1472  loc = loc || typeof location !== "undefined" && location;
1473  if (null == uri) uri = loc.protocol + "//" + loc.host; // relative path support
1474
1475  if (typeof uri === "string") {
1476    if ("/" === uri.charAt(0)) {
1477      if ("/" === uri.charAt(1)) {
1478        uri = loc.protocol + uri;
1479      } else {
1480        uri = loc.host + uri;
1481      }
1482    }
1483
1484    if (!/^(https?|wss?):\/\//.test(uri)) {
1485      debug("protocol-less url %s", uri);
1486
1487      if ("undefined" !== typeof loc) {
1488        uri = loc.protocol + "//" + uri;
1489      } else {
1490        uri = "https://" + uri;
1491      }
1492    } // parse
1493
1494
1495    debug("parse %s", uri);
1496    obj = parseuri(uri);
1497  } // make sure we treat `localhost:80` and `localhost` equally
1498
1499
1500  if (!obj.port) {
1501    if (/^(http|ws)$/.test(obj.protocol)) {
1502      obj.port = "80";
1503    } else if (/^(http|ws)s$/.test(obj.protocol)) {
1504      obj.port = "443";
1505    }
1506  }
1507
1508  obj.path = obj.path || "/";
1509  var ipv6 = obj.host.indexOf(":") !== -1;
1510  var host = ipv6 ? "[" + obj.host + "]" : obj.host; // define unique id
1511
1512  obj.id = obj.protocol + "://" + host + ":" + obj.port + path; // define href
1513
1514  obj.href = obj.protocol + "://" + host + (loc && loc.port === obj.port ? "" : ":" + obj.port);
1515  return obj;
1516}
1517
1518exports.url = url;
1519
1520/***/ }),
1521

1522/***/ "./node_modules/backo2/index.js":
1523/*!**************************************!*\
1524  !*** ./node_modules/backo2/index.js ***!
1525  \**************************************/
1526/*! no static exports found */
1527/***/ (function(module, exports) {
1528
1529/**
1530 * Expose `Backoff`.
1531 */
1532module.exports = Backoff;
1533/**
1534 * Initialize backoff timer with `opts`.
1535 *
1536 * - `min` initial timeout in milliseconds [100]
1537 * - `max` max timeout [10000]
1538 * - `jitter` [0]
1539 * - `factor` [2]
1540 *
1541 * @param {Object} opts
1542 * @api public
1543 */
1544
1545function Backoff(opts) {
1546  opts = opts || {};
1547  this.ms = opts.min || 100;
1548  this.max = opts.max || 10000;
1549  this.factor = opts.factor || 2;
1550  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
1551  this.attempts = 0;
1552}
1553/**
1554 * Return the backoff duration.
1555 *
1556 * @return {Number}
1557 * @api public
1558 */
1559
1560
1561Backoff.prototype.duration = function () {
1562  var ms = this.ms * Math.pow(this.factor, this.attempts++);
1563
1564  if (this.jitter) {
1565    var rand = Math.random();
1566    var deviation = Math.floor(rand * this.jitter * ms);
1567    ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
1568  }
1569
1570  return Math.min(ms, this.max) | 0;
1571};
1572/**
1573 * Reset the number of attempts.
1574 *
1575 * @api public
1576 */
1577
1578
1579Backoff.prototype.reset = function () {
1580  this.attempts = 0;
1581};
1582/**
1583 * Set the minimum duration
1584 *
1585 * @api public
1586 */
1587
1588
1589Backoff.prototype.setMin = function (min) {
1590  this.ms = min;
1591};
1592/**
1593 * Set the maximum duration
1594 *
1595 * @api public
1596 */
1597
1598
1599Backoff.prototype.setMax = function (max) {
1600  this.max = max;
1601};
1602/**
1603 * Set the jitter
1604 *
1605 * @api public
1606 */
1607
1608
1609Backoff.prototype.setJitter = function (jitter) {
1610  this.jitter = jitter;
1611};
1612
1613/***/ }),
1614

1615/***/ "./node_modules/component-emitter/index.js":
1616/*!*************************************************!*\
1617  !*** ./node_modules/component-emitter/index.js ***!
1618  \*************************************************/
1619/*! no static exports found */
1620/***/ (function(module, exports, __webpack_require__) {
1621
1622/**
1623 * Expose `Emitter`.
1624 */
1625if (true) {
1626  module.exports = Emitter;
1627}
1628/**
1629 * Initialize a new `Emitter`.
1630 *
1631 * @api public
1632 */
1633
1634
1635function Emitter(obj) {
1636  if (obj) return mixin(obj);
1637}
1638
1639;
1640/**
1641 * Mixin the emitter properties.
1642 *
1643 * @param {Object} obj
1644 * @return {Object}
1645 * @api private
1646 */
1647
1648function mixin(obj) {
1649  for (var key in Emitter.prototype) {
1650    obj[key] = Emitter.prototype[key];
1651  }
1652
1653  return obj;
1654}
1655/**
1656 * Listen on the given `event` with `fn`.
1657 *
1658 * @param {String} event
1659 * @param {Function} fn
1660 * @return {Emitter}
1661 * @api public
1662 */
1663
1664
1665Emitter.prototype.on = Emitter.prototype.addEventListener = function (event, fn) {
1666  this._callbacks = this._callbacks || {};
1667  (this._callbacks['$' + event] = this._callbacks['$' + event] || []).push(fn);
1668  return this;
1669};
1670/**
1671 * Adds an `event` listener that will be invoked a single
1672 * time then automatically removed.
1673 *
1674 * @param {String} event
1675 * @param {Function} fn
1676 * @return {Emitter}
1677 * @api public
1678 */
1679
1680
1681Emitter.prototype.once = function (event, fn) {
1682  function on() {
1683    this.off(event, on);
1684    fn.apply(this, arguments);
1685  }
1686
1687  on.fn = fn;
1688  this.on(event, on);
1689  return this;
1690};
1691/**
1692 * Remove the given callback for `event` or all
1693 * registered callbacks.
1694 *
1695 * @param {String} event
1696 * @param {Function} fn
1697 * @return {Emitter}
1698 * @api public
1699 */
1700
1701
1702Emitter.prototype.off = Emitter.prototype.removeListener = Emitter.prototype.removeAllListeners = Emitter.prototype.removeEventListener = function (event, fn) {
1703  this._callbacks = this._callbacks || {}; // all
1704
1705  if (0 == arguments.length) {
1706    this._callbacks = {};
1707    return this;
1708  } // specific event
1709
1710
1711  var callbacks = this._callbacks['$' + event];
1712  if (!callbacks) return this; // remove all handlers
1713
1714  if (1 == arguments.length) {
1715    delete this._callbacks['$' + event];
1716    return this;
1717  } // remove specific handler
1718
1719
1720  var cb;
1721
1722  for (var i = 0; i < callbacks.length; i++) {
1723    cb = callbacks[i];
1724
1725    if (cb === fn || cb.fn === fn) {
1726      callbacks.splice(i, 1);
1727      break;
1728    }
1729  } // Remove event specific arrays for event types that no
1730  // one is subscribed for to avoid memory leak.
1731
1732
1733  if (callbacks.length === 0) {
1734    delete this._callbacks['$' + event];
1735  }
1736
1737  return this;
1738};
1739/**
1740 * Emit `event` with the given args.
1741 *
1742 * @param {String} event
1743 * @param {Mixed} ...
1744 * @return {Emitter}
1745 */
1746
1747
1748Emitter.prototype.emit = function (event) {
1749  this._callbacks = this._callbacks || {};
1750  var args = new Array(arguments.length - 1),
1751      callbacks = this._callbacks['$' + event];
1752
1753  for (var i = 1; i < arguments.length; i++) {
1754    args[i - 1] = arguments[i];
1755  }
1756
1757  if (callbacks) {
1758    callbacks = callbacks.slice(0);
1759
1760    for (var i = 0, len = callbacks.length; i < len; ++i) {
1761      callbacks[i].apply(this, args);
1762    }
1763  }
1764
1765  return this;
1766};
1767/**
1768 * Return array of callbacks for `event`.
1769 *
1770 * @param {String} event
1771 * @return {Array}
1772 * @api public
1773 */
1774
1775
1776Emitter.prototype.listeners = function (event) {
1777  this._callbacks = this._callbacks || {};
1778  return this._callbacks['$' + event] || [];
1779};
1780/**
1781 * Check if this emitter has `event` handlers.
1782 *
1783 * @param {String} event
1784 * @return {Boolean}
1785 * @api public
1786 */
1787
1788
1789Emitter.prototype.hasListeners = function (event) {
1790  return !!this.listeners(event).length;
1791};
1792
1793/***/ }),
1794

1795/***/ "./node_modules/debug/src/browser.js":
1796/*!*******************************************!*\
1797  !*** ./node_modules/debug/src/browser.js ***!
1798  \*******************************************/
1799/*! no static exports found */
1800/***/ (function(module, exports, __webpack_require__) {
1801
1802/* eslint-env browser */
1803
1804/**
1805 * This is the web browser implementation of `debug()`.
1806 */
1807exports.formatArgs = formatArgs;
1808exports.save = save;
1809exports.load = load;
1810exports.useColors = useColors;
1811exports.storage = localstorage();
1812
1813exports.destroy = function () {
1814  var warned = false;
1815  return function () {
1816    if (!warned) {
1817      warned = true;
1818      console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
1819    }
1820  };
1821}();
1822/**
1823 * Colors.
1824 */
1825
1826
1827exports.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'];
1828/**
1829 * Currently only WebKit-based Web Inspectors, Firefox >= v31,
1830 * and the Firebug extension (any Firefox version) are known
1831 * to support "%c" CSS customizations.
1832 *
1833 * TODO: add a `localStorage` variable to explicitly enable/disable colors
1834 */
1835// eslint-disable-next-line complexity
1836
1837function useColors() {
1838  // NB: In an Electron preload script, document will be defined but not fully
1839  // initialized. Since we know we're in Chrome, we'll just detect this case
1840  // explicitly
1841  if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
1842    return true;
1843  } // Internet Explorer and Edge do not support colors.
1844
1845
1846  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
1847    return false;
1848  } // Is webkit? http://stackoverflow.com/a/16459606/376773
1849  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
1850
1851
1852  return typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
1853  typeof window !== 'undefined' && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
1854  // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
1855  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
1856  typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
1857}
1858/**
1859 * Colorize log arguments if enabled.
1860 *
1861 * @api public
1862 */
1863
1864
1865function formatArgs(args) {
1866  args[0] = (this.useColors ? '%c' : '') + this.namespace + (this.useColors ? ' %c' : ' ') + args[0] + (this.useColors ? '%c ' : ' ') + '+' + module.exports.humanize(this.diff);
1867
1868  if (!this.useColors) {
1869    return;
1870  }
1871
1872  var c = 'color: ' + this.color;
1873  args.splice(1, 0, c, 'color: inherit'); // The final "%c" is somewhat tricky, because there could be other
1874  // arguments passed either before or after the %c, so we need to
1875  // figure out the correct index to insert the CSS into
1876
1877  var index = 0;
1878  var lastC = 0;
1879  args[0].replace(/%[a-zA-Z%]/g, function (match) {
1880    if (match === '%%') {
1881      return;
1882    }
1883
1884    index++;
1885
1886    if (match === '%c') {
1887      // We only are interested in the *last* %c
1888      // (the user may have provided their own)
1889      lastC = index;
1890    }
1891  });
1892  args.splice(lastC, 0, c);
1893}
1894/**
1895 * Invokes `console.debug()` when available.
1896 * No-op when `console.debug` is not a "function".
1897 * If `console.debug` is not available, falls back
1898 * to `console.log`.
1899 *
1900 * @api public
1901 */
1902
1903
1904exports.log = console.debug || console.log || function () {};
1905/**
1906 * Save `namespaces`.
1907 *
1908 * @param {String} namespaces
1909 * @api private
1910 */
1911
1912
1913function save(namespaces) {
1914  try {
1915    if (namespaces) {
1916      exports.storage.setItem('debug', namespaces);
1917    } else {
1918      exports.storage.removeItem('debug');
1919    }
1920  } catch (error) {// Swallow
1921    // XXX (@Qix-) should we be logging these?
1922  }
1923}
1924/**
1925 * Load `namespaces`.
1926 *
1927 * @return {String} returns the previously persisted debug modes
1928 * @api private
1929 */
1930
1931
1932function load() {
1933  var r;
1934
1935  try {
1936    r = exports.storage.getItem('debug');
1937  } catch (error) {// Swallow
1938    // XXX (@Qix-) should we be logging these?
1939  } // If debug isn't set in LS, and we're in Electron, try to load $DEBUG
1940
1941
1942  if (!r && typeof process !== 'undefined' && 'env' in process) {
1943    r = process.env.DEBUG;
1944  }
1945
1946  return r;
1947}
1948/**
1949 * Localstorage attempts to return the localstorage.
1950 *
1951 * This is necessary because safari throws
1952 * when a user disables cookies/localstorage
1953 * and you attempt to access it.
1954 *
1955 * @return {LocalStorage}
1956 * @api private
1957 */
1958
1959
1960function localstorage() {
1961  try {
1962    // TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
1963    // The Browser also has localStorage in the global context.
1964    return localStorage;
1965  } catch (error) {// Swallow
1966    // XXX (@Qix-) should we be logging these?
1967  }
1968}
1969
1970module.exports = __webpack_require__(/*! ./common */ "./node_modules/debug/src/common.js")(exports);
1971var formatters = module.exports.formatters;
1972/**
1973 * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
1974 */
1975
1976formatters.j = function (v) {
1977  try {
1978    return JSON.stringify(v);
1979  } catch (error) {
1980    return '[UnexpectedJSONParseError]: ' + error.message;
1981  }
1982};
1983
1984/***/ }),
1985

1986/***/ "./node_modules/debug/src/common.js":
1987/*!******************************************!*\
1988  !*** ./node_modules/debug/src/common.js ***!
1989  \******************************************/
1990/*! no static exports found */
1991/***/ (function(module, exports, __webpack_require__) {
1992
1993function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
1994
1995function _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."); }
1996
1997function _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); }
1998
1999function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
2000
2001function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
2002
2003function _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; }
2004
2005/**
2006 * This is the common logic for both the Node.js and web browser
2007 * implementations of `debug()`.
2008 */
2009function setup(env) {
2010  createDebug.debug = createDebug;
2011  createDebug["default"] = createDebug;
2012  createDebug.coerce = coerce;
2013  createDebug.disable = disable;
2014  createDebug.enable = enable;
2015  createDebug.enabled = enabled;
2016  createDebug.humanize = __webpack_require__(/*! ms */ "./node_modules/ms/index.js");
2017  createDebug.destroy = destroy;
2018  Object.keys(env).forEach(function (key) {
2019    createDebug[key] = env[key];
2020  });
2021  /**
2022  * The currently active debug mode names, and names to skip.
2023  */
2024
2025  createDebug.names = [];
2026  createDebug.skips = [];
2027  /**
2028  * Map of special "%n" handling functions, for the debug "format" argument.
2029  *
2030  * Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
2031  */
2032
2033  createDebug.formatters = {};
2034  /**
2035  * Selects a color for a debug namespace
2036  * @param {String} namespace The namespace string for the for the debug instance to be colored
2037  * @return {Number|String} An ANSI color code for the given namespace
2038  * @api private
2039  */
2040
2041  function selectColor(namespace) {
2042    var hash = 0;
2043
2044    for (var i = 0; i < namespace.length; i++) {
2045      hash = (hash << 5) - hash + namespace.charCodeAt(i);
2046      hash |= 0; // Convert to 32bit integer
2047    }
2048
2049    return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
2050  }
2051
2052  createDebug.selectColor = selectColor;
2053  /**
2054  * Create a debugger with the given `namespace`.
2055  *
2056  * @param {String} namespace
2057  * @return {Function}
2058  * @api public
2059  */
2060
2061  function createDebug(namespace) {
2062    var prevTime;
2063    var enableOverride = null;
2064
2065    function debug() {
2066      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
2067        args[_key] = arguments[_key];
2068      }
2069
2070      // Disabled?
2071      if (!debug.enabled) {
2072        return;
2073      }
2074
2075      var self = debug; // Set `diff` timestamp
2076
2077      var curr = Number(new Date());
2078      var ms = curr - (prevTime || curr);
2079      self.diff = ms;
2080      self.prev = prevTime;
2081      self.curr = curr;
2082      prevTime = curr;
2083      args[0] = createDebug.coerce(args[0]);
2084
2085      if (typeof args[0] !== 'string') {
2086        // Anything else let's inspect with %O
2087        args.unshift('%O');
2088      } // Apply any `formatters` transformations
2089
2090
2091      var index = 0;
2092      args[0] = args[0].replace(/%([a-zA-Z%])/g, function (match, format) {
2093        // If we encounter an escaped % then don't increase the array index
2094        if (match === '%%') {
2095          return '%';
2096        }
2097
2098        index++;
2099        var formatter = createDebug.formatters[format];
2100
2101        if (typeof formatter === 'function') {
2102          var val = args[index];
2103          match = formatter.call(self, val); // Now we need to remove `args[index]` since it's inlined in the `format`
2104
2105          args.splice(index, 1);
2106          index--;
2107        }
2108
2109        return match;
2110      }); // Apply env-specific formatting (colors, etc.)
2111
2112      createDebug.formatArgs.call(self, args);
2113      var logFn = self.log || createDebug.log;
2114      logFn.apply(self, args);
2115    }
2116
2117    debug.namespace = namespace;
2118    debug.useColors = createDebug.useColors();
2119    debug.color = createDebug.selectColor(namespace);
2120    debug.extend = extend;
2121    debug.destroy = createDebug.destroy; // XXX Temporary. Will be removed in the next major release.
2122
2123    Object.defineProperty(debug, 'enabled', {
2124      enumerable: true,
2125      configurable: false,
2126      get: function get() {
2127        return enableOverride === null ? createDebug.enabled(namespace) : enableOverride;
2128      },
2129      set: function set(v) {
2130        enableOverride = v;
2131      }
2132    }); // Env-specific initialization logic for debug instances
2133
2134    if (typeof createDebug.init === 'function') {
2135      createDebug.init(debug);
2136    }
2137
2138    return debug;
2139  }
2140
2141  function extend(namespace, delimiter) {
2142    var newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
2143    newDebug.log = this.log;
2144    return newDebug;
2145  }
2146  /**
2147  * Enables a debug mode by namespaces. This can include modes
2148  * separated by a colon and wildcards.
2149  *
2150  * @param {String} namespaces
2151  * @api public
2152  */
2153
2154
2155  function enable(namespaces) {
2156    createDebug.save(namespaces);
2157    createDebug.names = [];
2158    createDebug.skips = [];
2159    var i;
2160    var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
2161    var len = split.length;
2162
2163    for (i = 0; i < len; i++) {
2164      if (!split[i]) {
2165        // ignore empty strings
2166        continue;
2167      }
2168
2169      namespaces = split[i].replace(/\*/g, '.*?');
2170
2171      if (namespaces[0] === '-') {
2172        createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
2173      } else {
2174        createDebug.names.push(new RegExp('^' + namespaces + '$'));
2175      }
2176    }
2177  }
2178  /**
2179  * Disable debug output.
2180  *
2181  * @return {String} namespaces
2182  * @api public
2183  */
2184
2185
2186  function disable() {
2187    var namespaces = [].concat(_toConsumableArray(createDebug.names.map(toNamespace)), _toConsumableArray(createDebug.skips.map(toNamespace).map(function (namespace) {
2188      return '-' + namespace;
2189    }))).join(',');
2190    createDebug.enable('');
2191    return namespaces;
2192  }
2193  /**
2194  * Returns true if the given mode name is enabled, false otherwise.
2195  *
2196  * @param {String} name
2197  * @return {Boolean}
2198  * @api public
2199  */
2200
2201
2202  function enabled(name) {
2203    if (name[name.length - 1] === '*') {
2204      return true;
2205    }
2206
2207    var i;
2208    var len;
2209
2210    for (i = 0, len = createDebug.skips.length; i < len; i++) {
2211      if (createDebug.skips[i].test(name)) {
2212        return false;
2213      }
2214    }
2215
2216    for (i = 0, len = createDebug.names.length; i < len; i++) {
2217      if (createDebug.names[i].test(name)) {
2218        return true;
2219      }
2220    }
2221
2222    return false;
2223  }
2224  /**
2225  * Convert regexp to namespace
2226  *
2227  * @param {RegExp} regxep
2228  * @return {String} namespace
2229  * @api private
2230  */
2231
2232
2233  function toNamespace(regexp) {
2234    return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, '*');
2235  }
2236  /**
2237  * Coerce `val`.
2238  *
2239  * @param {Mixed} val
2240  * @return {Mixed}
2241  * @api private
2242  */
2243
2244
2245  function coerce(val) {
2246    if (val instanceof Error) {
2247      return val.stack || val.message;
2248    }
2249
2250    return val;
2251  }
2252  /**
2253  * XXX DO NOT USE. This is a temporary stub function.
2254  * XXX It WILL be removed in the next major release.
2255  */
2256
2257
2258  function destroy() {
2259    console.warn('Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.');
2260  }
2261
2262  createDebug.enable(createDebug.load());
2263  return createDebug;
2264}
2265
2266module.exports = setup;
2267
2268/***/ }),
2269

2270/***/ "./node_modules/engine.io-client/lib/globalThis.browser.js":
2271/*!*****************************************************************!*\
2272  !*** ./node_modules/engine.io-client/lib/globalThis.browser.js ***!
2273  \*****************************************************************/
2274/*! no static exports found */
2275/***/ (function(module, exports) {
2276
2277module.exports = function () {
2278  if (typeof self !== "undefined") {
2279    return self;
2280  } else if (typeof window !== "undefined") {
2281    return window;
2282  } else {
2283    return Function("return this")();
2284  }
2285}();
2286
2287/***/ }),
2288

2289/***/ "./node_modules/engine.io-client/lib/index.js":
2290/*!****************************************************!*\
2291  !*** ./node_modules/engine.io-client/lib/index.js ***!
2292  \****************************************************/
2293/*! no static exports found */
2294/***/ (function(module, exports, __webpack_require__) {
2295
2296var Socket = __webpack_require__(/*! ./socket */ "./node_modules/engine.io-client/lib/socket.js");
2297
2298module.exports = function (uri, opts) {
2299  return new Socket(uri, opts);
2300};
2301/**
2302 * Expose deps for legacy compatibility
2303 * and standalone browser access.
2304 */
2305
2306
2307module.exports.Socket = Socket;
2308module.exports.protocol = Socket.protocol; // this is an int
2309
2310module.exports.Transport = __webpack_require__(/*! ./transport */ "./node_modules/engine.io-client/lib/transport.js");
2311module.exports.transports = __webpack_require__(/*! ./transports/index */ "./node_modules/engine.io-client/lib/transports/index.js");
2312module.exports.parser = __webpack_require__(/*! engine.io-parser */ "./node_modules/engine.io-parser/lib/index.js");
2313
2314/***/ }),
2315

2316/***/ "./node_modules/engine.io-client/lib/socket.js":
2317/*!*****************************************************!*\
2318  !*** ./node_modules/engine.io-client/lib/socket.js ***!
2319  \*****************************************************/
2320/*! no static exports found */
2321/***/ (function(module, exports, __webpack_require__) {
2322
2323function _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 target; }; return _extends.apply(this, arguments); }
2324
2325function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
2326
2327function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
2328
2329function _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); } }
2330
2331function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
2332
2333function _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); }
2334
2335function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
2336
2337function _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); }; }
2338
2339function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
2340
2341function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
2342
2343function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
2344
2345function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
2346
2347var transports = __webpack_require__(/*! ./transports/index */ "./node_modules/engine.io-client/lib/transports/index.js");
2348
2349var Emitter = __webpack_require__(/*! component-emitter */ "./node_modules/component-emitter/index.js");
2350
2351var debug = __webpack_require__(/*! debug */ "./node_modules/debug/src/browser.js")("engine.io-client:socket");
2352
2353var parser = __webpack_require__(/*! engine.io-parser */ "./node_modules/engine.io-parser/lib/index.js");
2354
2355var parseuri = __webpack_require__(/*! parseuri */ "./node_modules/parseuri/index.js");
2356
2357var parseqs = __webpack_require__(/*! parseqs */ "./node_modules/parseqs/index.js");
2358
2359var Socket = /*#__PURE__*/function (_Emitter) {
2360  _inherits(Socket, _Emitter);
2361
2362  var _super = _createSuper(Socket);
2363
2364  /**
2365   * Socket constructor.
2366   *
2367   * @param {String|Object} uri or options
2368   * @param {Object} options
2369   * @api public
2370   */
2371  function Socket(uri) {
2372    var _this;
2373
2374    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
2375
2376    _classCallCheck(this, Socket);
2377
2378    _this = _super.call(this);
2379
2380    if (uri && "object" === _typeof(uri)) {
2381      opts = uri;
2382      uri = null;
2383    }
2384
2385    if (uri) {
2386      uri = parseuri(uri);
2387      opts.hostname = uri.host;
2388      opts.secure = uri.protocol === "https" || uri.protocol === "wss";
2389      opts.port = uri.port;
2390      if (uri.query) opts.query = uri.query;
2391    } else if (opts.host) {
2392      opts.hostname = parseuri(opts.host).host;
2393    }
2394
2395    _this.secure = null != opts.secure ? opts.secure : typeof location !== "undefined" && "https:" === location.protocol;
2396
2397    if (opts.hostname && !opts.port) {
2398      // if no port is specified manually, use the protocol default
2399      opts.port = _this.secure ? "443" : "80";
2400    }
2401
2402    _this.hostname = opts.hostname || (typeof location !== "undefined" ? location.hostname : "localhost");
2403    _this.port = opts.port || (typeof location !== "undefined" && location.port ? location.port : _this.secure ? 443 : 80);
2404    _this.transports = opts.transports || ["polling", "websocket"];
2405    _this.readyState = "";
2406    _this.writeBuffer = [];
2407    _this.prevBufferLen = 0;
2408    _this.opts = _extends({
2409      path: "/engine.io",
2410      agent: false,
2411      withCredentials: false,
2412      upgrade: true,
2413      jsonp: true,
2414      timestampParam: "t",
2415      rememberUpgrade: false,
2416      rejectUnauthorized: true,
2417      perMessageDeflate: {
2418        threshold: 1024
2419      },
2420      transportOptions: {}
2421    }, opts);
2422    _this.opts.path = _this.opts.path.replace(/\/$/, "") + "/";
2423
2424    if (typeof _this.opts.query === "string") {
2425      _this.opts.query = parseqs.decode(_this.opts.query);
2426    } // set on handshake
2427
2428
2429    _this.id = null;
2430    _this.upgrades = null;
2431    _this.pingInterval = null;
2432    _this.pingTimeout = null; // set on heartbeat
2433
2434    _this.pingTimeoutTimer = null;
2435
2436    if (typeof addEventListener === "function") {
2437      addEventListener("beforeunload", function () {
2438        if (_this.transport) {
2439          // silently close the transport
2440          _this.transport.removeAllListeners();
2441
2442          _this.transport.close();
2443        }
2444      }, false);
2445    }
2446
2447    _this.open();
2448
2449    return _this;
2450  }
2451  /**
2452   * Creates transport of the given type.
2453   *
2454   * @param {String} transport name
2455   * @return {Transport}
2456   * @api private
2457   */
2458
2459
2460  _createClass(Socket, [{
2461    key: "createTransport",
2462    value: function createTransport(name) {
2463      debug('creating transport "%s"', name);
2464      var query = clone(this.opts.query); // append engine.io protocol identifier
2465
2466      query.EIO = parser.protocol; // transport name
2467
2468      query.transport = name; // session id if we already have one
2469
2470      if (this.id) query.sid = this.id;
2471
2472      var opts = _extends({}, this.opts.transportOptions[name], this.opts, {
2473        query: query,
2474        socket: this,
2475        hostname: this.hostname,
2476        secure: this.secure,
2477        port: this.port
2478      });
2479
2480      debug("options: %j", opts);
2481      return new transports[name](opts);
2482    }
2483    /**
2484     * Initializes transport to use and starts probe.
2485     *
2486     * @api private
2487     */
2488
2489  }, {
2490    key: "open",
2491    value: function open() {
2492      var transport;
2493
2494      if (this.opts.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf("websocket") !== -1) {
2495        transport = "websocket";
2496      } else if (0 === this.transports.length) {
2497        // Emit error on next tick so it can be listened to
2498        var self = this;
2499        setTimeout(function () {
2500          self.emit("error", "No transports available");
2501        }, 0);
2502        return;
2503      } else {
2504        transport = this.transports[0];
2505      }
2506
2507      this.readyState = "opening"; // Retry with the next transport if the transport is disabled (jsonp: false)
2508
2509      try {
2510        transport = this.createTransport(transport);
2511      } catch (e) {
2512        debug("error while creating transport: %s", e);
2513        this.transports.shift();
2514        this.open();
2515        return;
2516      }
2517
2518      transport.open();
2519      this.setTransport(transport);
2520    }
2521    /**
2522     * Sets the current transport. Disables the existing one (if any).
2523     *
2524     * @api private
2525     */
2526
2527  }, {
2528    key: "setTransport",
2529    value: function setTransport(transport) {
2530      debug("setting transport %s", transport.name);
2531      var self = this;
2532
2533      if (this.transport) {
2534        debug("clearing existing transport %s", this.transport.name);
2535        this.transport.removeAllListeners();
2536      } // set up transport
2537
2538
2539      this.transport = transport; // set up transport listeners
2540
2541      transport.on("drain", function () {
2542        self.onDrain();
2543      }).on("packet", function (packet) {
2544        self.onPacket(packet);
2545      }).on("error", function (e) {
2546        self.onError(e);
2547      }).on("close", function () {
2548        self.onClose("transport close");
2549      });
2550    }
2551    /**
2552     * Probes a transport.
2553     *
2554     * @param {String} transport name
2555     * @api private
2556     */
2557
2558  }, {
2559    key: "probe",
2560    value: function probe(name) {
2561      debug('probing transport "%s"', name);
2562      var transport = this.createTransport(name, {
2563        probe: 1
2564      });
2565      var failed = false;
2566      var self = this;
2567      Socket.priorWebsocketSuccess = false;
2568
2569      function onTransportOpen() {
2570        if (self.onlyBinaryUpgrades) {
2571          var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;
2572          failed = failed || upgradeLosesBinary;
2573        }
2574
2575        if (failed) return;
2576        debug('probe transport "%s" opened', name);
2577        transport.send([{
2578          type: "ping",
2579          data: "probe"
2580        }]);
2581        transport.once("packet", function (msg) {
2582          if (failed) return;
2583
2584          if ("pong" === msg.type && "probe" === msg.data) {
2585            debug('probe transport "%s" pong', name);
2586            self.upgrading = true;
2587            self.emit("upgrading", transport);
2588            if (!transport) return;
2589            Socket.priorWebsocketSuccess = "websocket" === transport.name;
2590            debug('pausing current transport "%s"', self.transport.name);
2591            self.transport.pause(function () {
2592              if (failed) return;
2593              if ("closed" === self.readyState) return;
2594              debug("changing transport and sending upgrade packet");
2595              cleanup();
2596              self.setTransport(transport);
2597              transport.send([{
2598                type: "upgrade"
2599              }]);
2600              self.emit("upgrade", transport);
2601              transport = null;
2602              self.upgrading = false;
2603              self.flush();
2604            });
2605          } else {
2606            debug('probe transport "%s" failed', name);
2607            var err = new Error("probe error");
2608            err.transport = transport.name;
2609            self.emit("upgradeError", err);
2610          }
2611        });
2612      }
2613
2614      function freezeTransport() {
2615        if (failed) return; // Any callback called by transport should be ignored since now
2616
2617        failed = true;
2618        cleanup();
2619        transport.close();
2620        transport = null;
2621      } // Handle any error that happens while probing
2622
2623
2624      function onerror(err) {
2625        var error = new Error("probe error: " + err);
2626        error.transport = transport.name;
2627        freezeTransport();
2628        debug('probe transport "%s" failed because of error: %s', name, err);
2629        self.emit("upgradeError", error);
2630      }
2631
2632      function onTransportClose() {
2633        onerror("transport closed");
2634      } // When the socket is closed while we're probing
2635
2636
2637      function onclose() {
2638        onerror("socket closed");
2639      } // When the socket is upgraded while we're probing
2640
2641
2642      function onupgrade(to) {
2643        if (transport && to.name !== transport.name) {
2644          debug('"%s" works - aborting "%s"', to.name, transport.name);
2645          freezeTransport();
2646        }
2647      } // Remove all listeners on the transport and on self
2648
2649
2650      function cleanup() {
2651        transport.removeListener("open", onTransportOpen);
2652        transport.removeListener("error", onerror);
2653        transport.removeListener("close", onTransportClose);
2654        self.removeListener("close", onclose);
2655        self.removeListener("upgrading", onupgrade);
2656      }
2657
2658      transport.once("open", onTransportOpen);
2659      transport.once("error", onerror);
2660      transport.once("close", onTransportClose);
2661      this.once("close", onclose);
2662      this.once("upgrading", onupgrade);
2663      transport.open();
2664    }
2665    /**
2666     * Called when connection is deemed open.
2667     *
2668     * @api public
2669     */
2670
2671  }, {
2672    key: "onOpen",
2673    value: function onOpen() {
2674      debug("socket open");
2675      this.readyState = "open";
2676      Socket.priorWebsocketSuccess = "websocket" === this.transport.name;
2677      this.emit("open");
2678      this.flush(); // we check for `readyState` in case an `open`
2679      // listener already closed the socket
2680
2681      if ("open" === this.readyState && this.opts.upgrade && this.transport.pause) {
2682        debug("starting upgrade probes");
2683        var i = 0;
2684        var l = this.upgrades.length;
2685
2686        for (; i < l; i++) {
2687          this.probe(this.upgrades[i]);
2688        }
2689      }
2690    }
2691    /**
2692     * Handles a packet.
2693     *
2694     * @api private
2695     */
2696
2697  }, {
2698    key: "onPacket",
2699    value: function onPacket(packet) {
2700      if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
2701        debug('socket receive: type "%s", data "%s"', packet.type, packet.data);
2702        this.emit("packet", packet); // Socket is live - any packet counts
2703
2704        this.emit("heartbeat");
2705
2706        switch (packet.type) {
2707          case "open":
2708            this.onHandshake(JSON.parse(packet.data));
2709            break;
2710
2711          case "ping":
2712            this.resetPingTimeout();
2713            this.sendPacket("pong");
2714            this.emit("pong");
2715            break;
2716
2717          case "error":
2718            var err = new Error("server error");
2719            err.code = packet.data;
2720            this.onError(err);
2721            break;
2722
2723          case "message":
2724            this.emit("data", packet.data);
2725            this.emit("message", packet.data);
2726            break;
2727        }
2728      } else {
2729        debug('packet received with socket readyState "%s"', this.readyState);
2730      }
2731    }
2732    /**
2733     * Called upon handshake completion.
2734     *
2735     * @param {Object} handshake obj
2736     * @api private
2737     */
2738
2739  }, {
2740    key: "onHandshake",
2741    value: function onHandshake(data) {
2742      this.emit("handshake", data);
2743      this.id = data.sid;
2744      this.transport.query.sid = data.sid;
2745      this.upgrades = this.filterUpgrades(data.upgrades);
2746      this.pingInterval = data.pingInterval;
2747      this.pingTimeout = data.pingTimeout;
2748      this.onOpen(); // In case open handler closes socket
2749
2750      if ("closed" === this.readyState) return;
2751      this.resetPingTimeout();
2752    }
2753    /**
2754     * Sets and resets ping timeout timer based on server pings.
2755     *
2756     * @api private
2757     */
2758
2759  }, {
2760    key: "resetPingTimeout",
2761    value: function resetPingTimeout() {
2762      var _this2 = this;
2763
2764      clearTimeout(this.pingTimeoutTimer);
2765      this.pingTimeoutTimer = setTimeout(function () {
2766        _this2.onClose("ping timeout");
2767      }, this.pingInterval + this.pingTimeout);
2768    }
2769    /**
2770     * Called on `drain` event
2771     *
2772     * @api private
2773     */
2774
2775  }, {
2776    key: "onDrain",
2777    value: function onDrain() {
2778      this.writeBuffer.splice(0, this.prevBufferLen); // setting prevBufferLen = 0 is very important
2779      // for example, when upgrading, upgrade packet is sent over,
2780      // and a nonzero prevBufferLen could cause problems on `drain`
2781
2782      this.prevBufferLen = 0;
2783
2784      if (0 === this.writeBuffer.length) {
2785        this.emit("drain");
2786      } else {
2787        this.flush();
2788      }
2789    }
2790    /**
2791     * Flush write buffers.
2792     *
2793     * @api private
2794     */
2795
2796  }, {
2797    key: "flush",
2798    value: function flush() {
2799      if ("closed" !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {
2800        debug("flushing %d packets in socket", this.writeBuffer.length);
2801        this.transport.send(this.writeBuffer); // keep track of current length of writeBuffer
2802        // splice writeBuffer and callbackBuffer on `drain`
2803
2804        this.prevBufferLen = this.writeBuffer.length;
2805        this.emit("flush");
2806      }
2807    }
2808    /**
2809     * Sends a message.
2810     *
2811     * @param {String} message.
2812     * @param {Function} callback function.
2813     * @param {Object} options.
2814     * @return {Socket} for chaining.
2815     * @api public
2816     */
2817
2818  }, {
2819    key: "write",
2820    value: function write(msg, options, fn) {
2821      this.sendPacket("message", msg, options, fn);
2822      return this;
2823    }
2824  }, {
2825    key: "send",
2826    value: function send(msg, options, fn) {
2827      this.sendPacket("message", msg, options, fn);
2828      return this;
2829    }
2830    /**
2831     * Sends a packet.
2832     *
2833     * @param {String} packet type.
2834     * @param {String} data.
2835     * @param {Object} options.
2836     * @param {Function} callback function.
2837     * @api private
2838     */
2839
2840  }, {
2841    key: "sendPacket",
2842    value: function sendPacket(type, data, options, fn) {
2843      if ("function" === typeof data) {
2844        fn = data;
2845        data = undefined;
2846      }
2847
2848      if ("function" === typeof options) {
2849        fn = options;
2850        options = null;
2851      }
2852
2853      if ("closing" === this.readyState || "closed" === this.readyState) {
2854        return;
2855      }
2856
2857      options = options || {};
2858      options.compress = false !== options.compress;
2859      var packet = {
2860        type: type,
2861        data: data,
2862        options: options
2863      };
2864      this.emit("packetCreate", packet);
2865      this.writeBuffer.push(packet);
2866      if (fn) this.once("flush", fn);
2867      this.flush();
2868    }
2869    /**
2870     * Closes the connection.
2871     *
2872     * @api private
2873     */
2874
2875  }, {
2876    key: "close",
2877    value: function close() {
2878      var self = this;
2879
2880      if ("opening" === this.readyState || "open" === this.readyState) {
2881        this.readyState = "closing";
2882
2883        if (this.writeBuffer.length) {
2884          this.once("drain", function () {
2885            if (this.upgrading) {
2886              waitForUpgrade();
2887            } else {
2888              close();
2889            }
2890          });
2891        } else if (this.upgrading) {
2892          waitForUpgrade();
2893        } else {
2894          close();
2895        }
2896      }
2897
2898      function close() {
2899        self.onClose("forced close");
2900        debug("socket closing - telling transport to close");
2901        self.transport.close();
2902      }
2903
2904      function cleanupAndClose() {
2905        self.removeListener("upgrade", cleanupAndClose);
2906        self.removeListener("upgradeError", cleanupAndClose);
2907        close();
2908      }
2909
2910      function waitForUpgrade() {
2911        // wait for upgrade to finish since we can't send packets while pausing a transport
2912        self.once("upgrade", cleanupAndClose);
2913        self.once("upgradeError", cleanupAndClose);
2914      }
2915
2916      return this;
2917    }
2918    /**
2919     * Called upon transport error
2920     *
2921     * @api private
2922     */
2923
2924  }, {
2925    key: "onError",
2926    value: function onError(err) {
2927      debug("socket error %j", err);
2928      Socket.priorWebsocketSuccess = false;
2929      this.emit("error", err);
2930      this.onClose("transport error", err);
2931    }
2932    /**
2933     * Called upon transport close.
2934     *
2935     * @api private
2936     */
2937
2938  }, {
2939    key: "onClose",
2940    value: function onClose(reason, desc) {
2941      if ("opening" === this.readyState || "open" === this.readyState || "closing" === this.readyState) {
2942        debug('socket close with reason: "%s"', reason);
2943        var self = this; // clear timers
2944
2945        clearTimeout(this.pingIntervalTimer);
2946        clearTimeout(this.pingTimeoutTimer); // stop event from firing again for transport
2947
2948        this.transport.removeAllListeners("close"); // ensure transport won't stay open
2949
2950        this.transport.close(); // ignore further transport communication
2951
2952        this.transport.removeAllListeners(); // set ready state
2953
2954        this.readyState = "closed"; // clear session id
2955
2956        this.id = null; // emit close event
2957
2958        this.emit("close", reason, desc); // clean buffers after, so users can still
2959        // grab the buffers on `close` event
2960
2961        self.writeBuffer = [];
2962        self.prevBufferLen = 0;
2963      }
2964    }
2965    /**
2966     * Filters upgrades, returning only those matching client transports.
2967     *
2968     * @param {Array} server upgrades
2969     * @api private
2970     *
2971     */
2972
2973  }, {
2974    key: "filterUpgrades",
2975    value: function filterUpgrades(upgrades) {
2976      var filteredUpgrades = [];
2977      var i = 0;
2978      var j = upgrades.length;
2979
2980      for (; i < j; i++) {
2981        if (~this.transports.indexOf(upgrades[i])) filteredUpgrades.push(upgrades[i]);
2982      }
2983
2984      return filteredUpgrades;
2985    }
2986  }]);
2987
2988  return Socket;
2989}(Emitter);
2990
2991Socket.priorWebsocketSuccess = false;
2992/**
2993 * Protocol version.
2994 *
2995 * @api public
2996 */
2997
2998Socket.protocol = parser.protocol; // this is an int
2999
3000function clone(obj) {
3001  var o = {};
3002
3003  for (var i in obj) {
3004    if (obj.hasOwnProperty(i)) {
3005      o[i] = obj[i];
3006    }
3007  }
3008
3009  return o;
3010}
3011
3012module.exports = Socket;
3013
3014/***/ }),
3015