HORIZON PROJECT

(function webpackUniversalModuleDefinition(root, factory) {

        if(typeof exports === 'object' && typeof module === 'object')

                module.exports = factory();

        else if(typeof define === 'function' && define.amd)

                define([], factory);

        else if(typeof exports === 'object')

                exports["eio"] = factory();

        else

                root["eio"] = factory();

})(this, function() {

return /******/ (function(modules) { // webpackBootstrap

/******/         // The module cache

/******/         var installedModules = {};

/******/         // The require function

/******/         function __webpack_require__(moduleId) {

/******/                 // Check if module is in cache

/******/                 if(installedModules[moduleId])

/******/                         return installedModules[moduleId].exports;

/******/                 // Create a new module (and put it into the cache)

/******/                 var module = installedModules[moduleId] = {

/******/                         exports: {},

/******/                         id: moduleId,

/******/                         loaded: false

/******/                 };

/******/                 // Execute the module function

/******/                 modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/                 // Flag the module as loaded

/******/                 module.loaded = true;

/******/                 // Return the exports of the module

/******/                 return module.exports;

/******/         }

/******/         // expose the modules object (__webpack_modules__)

/******/         __webpack_require__.m = modules;

/******/         // expose the module cache

/******/         __webpack_require__.c = installedModules;

/******/         // __webpack_public_path__

/******/         __webpack_require__.p = "";

/******/         // Load entry module and return exports

/******/         return __webpack_require__(0);

/******/ })

/************************************************************************/

/******/ ([

/* 0 */

/***/ function(module, exports, __webpack_require__) {

        'use strict';

        module.exports = __webpack_require__(1);

        /**

         * Exports parser

         *

         * @api public

         *

         */

        module.exports.parser = __webpack_require__(8);

/***/ },

/* 1 */

/***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function(global) {'use strict';

        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

        /**

         * Module dependencies.

         */

        var transports = __webpack_require__(2);

        var Emitter = __webpack_require__(18);

        var debug = __webpack_require__(22)('engine.io-client:socket');

        var index = __webpack_require__(29);

        var parser = __webpack_require__(8);

        var parseuri = __webpack_require__(30);

        var parseqs = __webpack_require__(19);

        /**

         * Module exports.

         */

        module.exports = Socket;

        /**

         * Socket constructor.

         *

         * @param {String|Object} uri or options

         * @param {Object} options

         * @api public

         */

        function Socket(uri, opts) {

          if (!(this instanceof Socket)) return new Socket(uri, opts);

          opts = opts || {};

          if (uri && 'object' === (typeof uri === 'undefined' ? 'undefined' : _typeof(uri))) {

            opts = uri;

            uri = null;

          }

          if (uri) {

            uri = parseuri(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 = parseuri(opts.host).host;

          }

          this.secure = null != opts.secure ? opts.secure : global.location && '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.agent = opts.agent || false;

          this.hostname = opts.hostname || (global.location ? location.hostname : 'localhost');

          this.port = opts.port || (global.location && location.port ? location.port : this.secure ? 443 : 80);

          this.query = opts.query || {};

          if ('string' === typeof this.query) this.query = parseqs.decode(this.query);

          this.upgrade = false !== opts.upgrade;

          this.path = (opts.path || '/engine.io').replace(/\/$/, '') + '/';

          this.forceJSONP = !!opts.forceJSONP;

          this.jsonp = false !== opts.jsonp;

          this.forceBase64 = !!opts.forceBase64;

          this.enablesXDR = !!opts.enablesXDR;

          this.timestampParam = opts.timestampParam || 't';

          this.timestampRequests = opts.timestampRequests;

          this.transports = opts.transports || ['polling', 'websocket'];

          this.transportOptions = opts.transportOptions || {};

          this.readyState = '';

          this.writeBuffer = [];

          this.prevBufferLen = 0;

          this.policyPort = opts.policyPort || 843;

          this.rememberUpgrade = opts.rememberUpgrade || false;

          this.binaryType = null;

          this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;

          this.perMessageDeflate = false !== opts.perMessageDeflate ? opts.perMessageDeflate || {} : false;

          if (true === this.perMessageDeflate) this.perMessageDeflate = {};

          if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {

            this.perMessageDeflate.threshold = 1024;

          }

          // SSL options for Node.js client

          this.pfx = opts.pfx || null;

          this.key = opts.key || null;

          this.passphrase = opts.passphrase || null;

          this.cert = opts.cert || null;

          this.ca = opts.ca || null;

          this.ciphers = opts.ciphers || null;

          this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? true : opts.rejectUnauthorized;

          this.forceNode = !!opts.forceNode;

          // other options for Node.js client

          var freeGlobal = (typeof global === 'undefined' ? 'undefined' : _typeof(global)) === 'object' && global;

          if (freeGlobal.global === freeGlobal) {

            if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {

              this.extraHeaders = opts.extraHeaders;

            }

            if (opts.localAddress) {

              this.localAddress = opts.localAddress;

            }

          }

          // set on handshake

          this.id = null;

          this.upgrades = null;

          this.pingInterval = null;

          this.pingTimeout = null;

          // set on heartbeat

          this.pingIntervalTimer = null;

          this.pingTimeoutTimer = null;

          this.open();

        }

        Socket.priorWebsocketSuccess = false;

        /**

         * Mix in `Emitter`.

         */

        Emitter(Socket.prototype);

        /**

         * Protocol version.

         *

         * @api public

         */

        Socket.protocol = parser.protocol; // this is an int

        /**

         * Expose deps for legacy compatibility

         * and standalone browser access.

         */

        Socket.Socket = Socket;

        Socket.Transport = __webpack_require__(7);

        Socket.transports = __webpack_require__(2);

        Socket.parser = __webpack_require__(8);

        /**

         * Creates transport of the given type.

         *

         * @param {String} transport name

         * @return {Transport}

         * @api private

         */

        Socket.prototype.createTransport = function (name) {

          debug('creating transport "%s"', name);

          var query = clone(this.query);

          // append engine.io protocol identifier

          query.EIO = parser.protocol;

          // transport name

          query.transport = name;

          // per-transport options

          var options = this.transportOptions[name] || {};

          // session id if we already have one

          if (this.id) query.sid = this.id;

          var transport = new transports[name]({

            query: query,

            socket: this,

            agent: options.agent || this.agent,

            hostname: options.hostname || this.hostname,

            port: options.port || this.port,

            secure: options.secure || this.secure,

            path: options.path || this.path,

            forceJSONP: options.forceJSONP || this.forceJSONP,

            jsonp: options.jsonp || this.jsonp,

            forceBase64: options.forceBase64 || this.forceBase64,

            enablesXDR: options.enablesXDR || this.enablesXDR,

            timestampRequests: options.timestampRequests || this.timestampRequests,

            timestampParam: options.timestampParam || this.timestampParam,

            policyPort: options.policyPort || this.policyPort,

            pfx: options.pfx || this.pfx,

            key: options.key || this.key,

            passphrase: options.passphrase || this.passphrase,

            cert: options.cert || this.cert,

            ca: options.ca || this.ca,

            ciphers: options.ciphers || this.ciphers,

            rejectUnauthorized: options.rejectUnauthorized || this.rejectUnauthorized,

            perMessageDeflate: options.perMessageDeflate || this.perMessageDeflate,

            extraHeaders: options.extraHeaders || this.extraHeaders,

            forceNode: options.forceNode || this.forceNode,

            localAddress: options.localAddress || this.localAddress,

            requestTimeout: options.requestTimeout || this.requestTimeout,

            protocols: options.protocols || void 0

          });

          return transport;

        };

        function clone(obj) {

          var o = {};

          for (var i in obj) {

            if (obj.hasOwnProperty(i)) {

              o[i] = obj[i];

            }

          }

          return o;

        }

        /**

         * Initializes transport to use and starts probe.

         *

         * @api private

         */

        Socket.prototype.open = function () {

          var transport;

          if (this.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

            var self = this;

            setTimeout(function () {

              self.emit('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)

          try {

            transport = this.createTransport(transport);

          } catch (e) {

            this.transports.shift();

            this.open();

            return;

          }

          transport.open();

          this.setTransport(transport);

        };

        /**

         * Sets the current transport. Disables the existing one (if any).

         *

         * @api private

         */

        Socket.prototype.setTransport = function (transport) {

          debug('setting transport %s', transport.name);

          var self = this;

          if (this.transport) {

            debug('clearing existing transport %s', this.transport.name);

            this.transport.removeAllListeners();

          }

          // set up transport

          this.transport = transport;

          // set up transport listeners

          transport.on('drain', function () {

            self.onDrain();

          }).on('packet', function (packet) {

            self.onPacket(packet);

          }).on('error', function (e) {

            self.onError(e);

          }).on('close', function () {

            self.onClose('transport close');

          });

        };

        /**

         * Probes a transport.

         *

         * @param {String} transport name

         * @api private

         */

        Socket.prototype.probe = function (name) {

          debug('probing transport "%s"', name);

          var transport = this.createTransport(name, { probe: 1 });

          var failed = false;

          var self = this;

          Socket.priorWebsocketSuccess = false;

          function onTransportOpen() {

            if (self.onlyBinaryUpgrades) {

              var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;

              failed = failed || upgradeLosesBinary;

            }

            if (failed) return;

            debug('probe transport "%s" opened', name);

            transport.send([{ type: 'ping', data: 'probe' }]);

            transport.once('packet', function (msg) {

              if (failed) return;

              if ('pong' === msg.type && 'probe' === msg.data) {

                debug('probe transport "%s" pong', name);

                self.upgrading = true;

                self.emit('upgrading', transport);

                if (!transport) return;

                Socket.priorWebsocketSuccess = 'websocket' === transport.name;

                debug('pausing current transport "%s"', self.transport.name);

                self.transport.pause(function () {

                  if (failed) return;

                  if ('closed' === self.readyState) return;

                  debug('changing transport and sending upgrade packet');

                  cleanup();

                  self.setTransport(transport);

                  transport.send([{ type: 'upgrade' }]);

                  self.emit('upgrade', transport);

                  transport = null;

                  self.upgrading = false;

                  self.flush();

                });

              } else {

                debug('probe transport "%s" failed', name);

                var err = new Error('probe error');

                err.transport = transport.name;

                self.emit('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

          function onerror(err) {

            var error = new Error('probe error: ' + err);

            error.transport = transport.name;

            freezeTransport();

            debug('probe transport "%s" failed because of error: %s', name, err);

            self.emit('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) {

              debug('"%s" works - aborting "%s"', to.name, transport.name);

              freezeTransport();

            }

          }

          // Remove all listeners on the transport and on self

          function cleanup() {

            transport.removeListener('open', onTransportOpen);

            transport.removeListener('error', onerror);

            transport.removeListener('close', onTransportClose);

            self.removeListener('close', onclose);

            self.removeListener('upgrading', onupgrade);

          }

          transport.once('open', onTransportOpen);

          transport.once('error', onerror);

          transport.once('close', onTransportClose);

          this.once('close', onclose);

          this.once('upgrading', onupgrade);

          transport.open();

        };

        /**

         * Called when connection is deemed open.

         *

         * @api public

         */

        Socket.prototype.onOpen = function () {

          debug('socket open');

          this.readyState = 'open';

          Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;

          this.emit('open');

          this.flush();

          // we check for `readyState` in case an `open`

          // listener already closed the socket

          if ('open' === this.readyState && this.upgrade && this.transport.pause) {

            debug('starting upgrade probes');

            for (var i = 0, l = this.upgrades.length; i < l; i++) {

              this.probe(this.upgrades[i]);

            }

          }

        };

        /**

         * Handles a packet.

         *

         * @api private

         */

        Socket.prototype.onPacket = function (packet) {

          if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {

            debug('socket receive: type "%s", data "%s"', packet.type, packet.data);

            this.emit('packet', packet);

            // Socket is live - any packet counts

            this.emit('heartbeat');

            switch (packet.type) {

              case 'open':

                this.onHandshake(JSON.parse(packet.data));

                break;

              case 'pong':

                this.setPing();

                this.emit('pong');

                break;

              case 'error':

                var err = new Error('server error');

                err.code = packet.data;

                this.onError(err);

                break;

              case 'message':

                this.emit('data', packet.data);

                this.emit('message', packet.data);

                break;

            }

          } else {

            debug('packet received with socket readyState "%s"', this.readyState);

          }

        };

        /**

         * Called upon handshake completion.

         *

         * @param {Object} handshake obj

         * @api private

         */

        Socket.prototype.onHandshake = function (data) {

          this.emit('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.onOpen();

          // In case open handler closes socket

          if ('closed' === this.readyState) return;

          this.setPing();

          // Prolong liveness of socket on heartbeat

          this.removeListener('heartbeat', this.onHeartbeat);

          this.on('heartbeat', this.onHeartbeat);

        };

        /**

         * Resets ping timeout.

         *

         * @api private

         */

        Socket.prototype.onHeartbeat = function (timeout) {

          clearTimeout(this.pingTimeoutTimer);

          var self = this;

          self.pingTimeoutTimer = setTimeout(function () {

            if ('closed' === self.readyState) return;

            self.onClose('ping timeout');

          }, timeout || self.pingInterval + self.pingTimeout);

        };

        /**

         * Pings server every `this.pingInterval` and expects response

         * within `this.pingTimeout` or closes connection.

         *

         * @api private

         */

        Socket.prototype.setPing = function () {

          var self = this;

          clearTimeout(self.pingIntervalTimer);

          self.pingIntervalTimer = setTimeout(function () {

            debug('writing ping packet - expecting pong within %sms', self.pingTimeout);

            self.ping();

            self.onHeartbeat(self.pingTimeout);

          }, self.pingInterval);

        };

        /**

        * Sends a ping packet.

        *

        * @api private

        */

        Socket.prototype.ping = function () {

          var self = this;

          this.sendPacket('ping', function () {

            self.emit('ping');

          });

        };

        /**

         * Called on `drain` event

         *

         * @api private

         */

        Socket.prototype.onDrain = function () {

          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.emit('drain');

          } else {

            this.flush();

          }

        };

        /**

         * Flush write buffers.

         *

         * @api private

         */

        Socket.prototype.flush = function () {

          if ('closed' !== this.readyState && this.transport.writable && !this.upgrading && this.writeBuffer.length) {

            debug('flushing %d packets in socket', this.writeBuffer.length);

            this.transport.send(this.writeBuffer);

            // keep track of current length of writeBuffer

            // splice writeBuffer and callbackBuffer on `drain`

            this.prevBufferLen = this.writeBuffer.length;

            this.emit('flush');

          }

        };

        /**

         * Sends a message.

         *

         * @param {String} message.

         * @param {Function} callback function.

         * @param {Object} options.

         * @return {Socket} for chaining.

         * @api public

         */

        Socket.prototype.write = Socket.prototype.send = function (msg, options, fn) {

          this.sendPacket('message', msg, options, fn);

          return this;

        };

        /**

         * Sends a packet.

         *

         * @param {String} packet type.

         * @param {String} data.

         * @param {Object} options.

         * @param {Function} callback function.

         * @api private

         */

        Socket.prototype.sendPacket = function (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.emit('packetCreate', packet);

          this.writeBuffer.push(packet);

          if (fn) this.once('flush', fn);

          this.flush();

        };

        /**

         * Closes the connection.

         *

         * @api private

         */

        Socket.prototype.close = function () {

          if ('opening' === this.readyState || 'open' === this.readyState) {

            this.readyState = 'closing';

            var self = this;

            if (this.writeBuffer.length) {

              this.once('drain', function () {

                if (this.upgrading) {

                  waitForUpgrade();

                } else {

                  close();

                }

              });

            } else if (this.upgrading) {

              waitForUpgrade();

            } else {

              close();

            }

          }

          function close() {

            self.onClose('forced close');

            debug('socket closing - telling transport to close');

            self.transport.close();

          }

          function cleanupAndClose() {

            self.removeListener('upgrade', cleanupAndClose);

            self.removeListener('upgradeError', cleanupAndClose);

            close();

          }

          function waitForUpgrade() {

            // wait for upgrade to finish since we can't send packets while pausing a transport

            self.once('upgrade', cleanupAndClose);

            self.once('upgradeError', cleanupAndClose);

          }

          return this;

        };

        /**

         * Called upon transport error

         *

         * @api private

         */

        Socket.prototype.onError = function (err) {

          debug('socket error %j', err);

          Socket.priorWebsocketSuccess = false;

          this.emit('error', err);

          this.onClose('transport error', err);

        };

        /**

         * Called upon transport close.

         *

         * @api private

         */

        Socket.prototype.onClose = function (reason, desc) {

          if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {

            debug('socket close with reason: "%s"', reason);

            var self = this;

            // clear timers

            clearTimeout(this.pingIntervalTimer);

            clearTimeout(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();

            // set ready state

            this.readyState = 'closed';

            // clear session id

            this.id = null;

            // emit close event

            this.emit('close', reason, desc);

            // clean buffers after, so users can still

            // grab the buffers on `close` event

            self.writeBuffer = [];

            self.prevBufferLen = 0;

          }

        };

        /**

         * Filters upgrades, returning only those matching client transports.

         *

         * @param {Array} server upgrades

         * @api private

         *

         */

        Socket.prototype.filterUpgrades = function (upgrades) {

          var filteredUpgrades = [];

          for (var i = 0, j = upgrades.length; i < j; i++) {

            if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);

          }

          return filteredUpgrades;

        };

        /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },

/* 2 */

/***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function(global) {'use strict';

        /**

         * Module dependencies

         */

        var XMLHttpRequest = __webpack_require__(3);

        var XHR = __webpack_require__(5);

        var JSONP = __webpack_require__(26);

        var websocket = __webpack_require__(27);

        /**

         * Export transports.

         */

        exports.polling = polling;

        exports.websocket = websocket;

        /**

         * Polling transport polymorphic constructor.

         * Decides on xhr vs jsonp based on feature detection.

         *

         * @api private

         */

        function polling(opts) {

          var xhr;

          var xd = false;

          var xs = false;

          var jsonp = false !== opts.jsonp;

          if (global.location) {

            var isSSL = 'https:' === location.protocol;

            var port = location.port;

            // some user agents have empty `location.port`

            if (!port) {

              port = isSSL ? 443 : 80;

            }

            xd = opts.hostname !== location.hostname || port !== opts.port;

            xs = opts.secure !== isSSL;

          }

          opts.xdomain = xd;

          opts.xscheme = xs;

          xhr = new XMLHttpRequest(opts);

          if ('open' in xhr && !opts.forceJSONP) {

            return new XHR(opts);

          } else {

            if (!jsonp) throw new Error('JSONP disabled');

            return new JSONP(opts);

          }

        }

        /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },

/* 3 */

/***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function(global) {'use strict';

        // browser shim for xmlhttprequest module

        var hasCORS = __webpack_require__(4);

        module.exports = function (opts) {

          var xdomain = opts.xdomain;

          // scheme must be same when usign XDomainRequest

          // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx

          var xscheme = opts.xscheme;

          // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.

          // https://github.com/Automattic/engine.io-client/pull/217

          var enablesXDR = opts.enablesXDR;

          // XMLHttpRequest can be disabled on IE

          try {

            if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {

              return new XMLHttpRequest();

            }

          } catch (e) {}

          // Use XDomainRequest for IE8 if enablesXDR is true

          // because loading bar keeps flashing when using jsonp-polling

          // https://github.com/yujiosaka/socke.io-ie8-loading-example

          try {

            if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {

              return new XDomainRequest();

            }

          } catch (e) {}

          if (!xdomain) {

            try {

              return new global[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');

            } catch (e) {}

          }

        };

        /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },

/* 4 */

/***/ function(module, exports) {

        /**

         * Module exports.

         *

         * Logic borrowed from Modernizr:

         *

         *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js

         */

        try {

          module.exports = typeof XMLHttpRequest !== 'undefined' &&

            'withCredentials' in new XMLHttpRequest();

        } catch (err) {

          // if XMLHttp support is disabled in IE then it will throw

          // when trying to create

          module.exports = false;

        }

/***/ },

/* 5 */

/***/ function(module, exports, __webpack_require__) {

        /* WEBPACK VAR INJECTION */(function(global) {'use strict';

        /**

         * Module requirements.

         */

        var XMLHttpRequest = __webpack_require__(3);

        var Polling = __webpack_require__(6);

        var Emitter = __webpack_require__(18);

        var inherit = __webpack_require__(20);

        var debug = __webpack_require__(22)('engine.io-client:polling-xhr');

        /**

         * Module exports.

         */

        module.exports = XHR;

        module.exports.Request = Request;

        /**

         * Empty function

         */

        function empty() {}

        /**

         * XHR Polling constructor.

         *

         * @param {Object} opts

         * @api public

         */

        function XHR(opts) {

          Polling.call(this, opts);

          this.requestTimeout = opts.requestTimeout;

          this.extraHeaders = opts.extraHeaders;

          if (global.location) {

            var isSSL = 'https:' === location.protocol;

            var port = location.port;

            // some user agents have empty `location.port`

            if (!port) {

              port = isSSL ? 443 : 80;

            }

            this.xd = opts.hostname !== global.location.hostname || port !== opts.port;

            this.xs = opts.secure !== isSSL;

          }

        }

        /**

         * Inherits from Polling.

         */

        inherit(XHR, Polling);

        /**

         * XHR supports binary

         */

        XHR.prototype.supportsBinary = true;

        /**

         * Creates a request.

         *

         * @param {String} method

         * @api private

         */

        XHR.prototype.request = function (opts) {

          opts = opts || {};

          opts.uri = this.uri();

          opts.xd = this.xd;

          opts.xs = this.xs;

          opts.agent = this.agent || false;

          opts.supportsBinary = this.supportsBinary;

          opts.enablesXDR = this.enablesXDR;

          // SSL options for Node.js client

          opts.pfx = this.pfx;

          opts.key = this.key;

          opts.passphrase = this.passphrase;

          opts.cert = this.cert;

          opts.ca = this.ca;

          opts.ciphers = this.ciphers;

          opts.rejectUnauthorized = this.rejectUnauthorized;

          opts.requestTimeout = this.requestTimeout;

          // other options for Node.js client

          opts.extraHeaders = this.extraHeaders;

          return new Request(opts);

        };

        /**

         * Sends data.

         *

         * @param {String} data to send.

         * @param {Function} called upon flush.

         * @api private

         */

        XHR.prototype.doWrite = function (data, fn) {

          var isBinary = typeof data !== 'string' && data !== undefined;

          var req = this.request({ method: 'POST', data: data, isBinary: isBinary });

          var self = this;

          req.on('success', fn);

          req.on('error', function (err) {

            self.onError('xhr post error', err);

          });

          this.sendXhr = req;

        };

        /**

         * Starts a poll cycle.

         *

         * @api private

         */

        XHR.prototype.doPoll = function () {

          debug('xhr poll');

          var req = this.request();

          var self = this;

          req.on('data', function (data) {

            self.onData(data);

          });

          req.on('error', function (err) {

            self.onError('xhr poll error', err);

          });

          this.pollXhr = req;

        };

        /**

         * Request constructor

         *

         * @param {Object} options

         * @api public

         */

        function Request(opts) {

          this.method = opts.method || 'GET';

          this.uri = opts.uri;

          this.xd = !!opts.xd;

          this.xs = !!opts.xs;

          this.async = false !== opts.async;

          this.data = undefined !== opts.data ? opts.data : null;

          this.agent = opts.agent;

          this.isBinary = opts.isBinary;

          this.supportsBinary = opts.supportsBinary;

          this.enablesXDR = opts.enablesXDR;

          this.requestTimeout = opts.requestTimeout;

          // SSL options for Node.js client

          this.pfx = opts.pfx;

          this.key = opts.key;

          this.passphrase = opts.passphrase;

          this.cert = opts.cert;

          this.ca = opts.ca;

          this.ciphers = opts.ciphers;

          this.rejectUnauthorized = opts.rejectUnauthorized;

          // other options for Node.js client

          this.extraHeaders = opts.extraHeaders;

          this.create();

        }

        /**

         * Mix in `Emitter`.

         */

        Emitter(Request.prototype);

        /**

         * Creates the XHR object and sends the request.

         *

         * @api private

         */

        Request.prototype.create = function () {

          var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };

          // SSL options for Node.js client

          opts.pfx = this.pfx;

          opts.key = this.key;

          opts.passphrase = this.passphrase;

          opts.cert = this.cert;

          opts.ca = this.ca;

          opts.ciphers = this.ciphers;

          opts.rejectUnauthorized = this.rejectUnauthorized;

          var xhr = this.xhr = new XMLHttpRequest(opts);

          var self = this;

          try {

            debug('xhr open %s: %s', this.method, this.uri);

            xhr.open(this.method, this.uri, this.async);

            try {

              if (this.extraHeaders) {

                xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);

                for (var i in this.extraHeaders) {

                  if (this.extraHeaders.hasOwnProperty(i)) {

                    xhr.setRequestHeader(i, this.extraHeaders[i]);

                  }

                }

              }

            } catch (e) {}

            if ('POST' === this.method) {

              try {

                if (this.isBinary) {

                  xhr.setRequestHeader('Content-type', 'application/octet-stream');

                } else {

                  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 = true;

            }

            if (this.requestTimeout) {

              xhr.timeout = this.requestTimeout;

            }

            if (this.hasXDR()) {

              xhr.onload = function () {

                self.onLoad();

              };

              xhr.onerror = function () {

                self.onError(xhr.responseText);

              };

            } else {

              xhr.onreadystatechange = function () {

                if (xhr.readyState === 2) {

                  try {

                    var contentType = xhr.getResponseHeader('Content-Type');

                    if (self.supportsBinary && contentType === 'application/octet-stream') {

                      xhr.responseType = 'arraybuffer';

                    }

                  } catch (e) {}

                }

                if (4 !== xhr.readyState) return;

                if (200 === xhr.status || 1223 === xhr.status) {

                  self.onLoad();

                } else {

                  // make sure the `error` event handler that's user-set

                  // does not throw in the same tick and gets caught here

                  setTimeout(function () {

                    self.onError(xhr.status);

                  }, 0);

                }

              };

            }

            debug('xhr data %s', this.data);

            xhr.send(this.data);

          } catch (e) {

            // Need to defer since .create() is called directly fhrom the constructor

            // and thus the 'error' event can only be only bound *after* this exception

            // occurs.  Therefore, also, we cannot throw here at all.

            setTimeout(function () {