{"version":3,"sources":["webpack:///./node_modules/sha.js/sha.js","webpack:///./node_modules/socket.io-client/lib/socket.js","webpack:///./node_modules/socket.io-parser/node_modules/debug/src/debug.js","webpack:///./node_modules/sha.js/sha512.js","webpack:///./node_modules/socket.io-parser/index.js","webpack:///./node_modules/socket.io-parser/node_modules/component-emitter/index.js","webpack:///./node_modules/sha.js/index.js","webpack:///./node_modules/socket.io-parser/binary.js","webpack:///./node_modules/sha.js/sha224.js","webpack:///./node_modules/socket.io-client/lib/manager.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/sha.js/sha1.js","webpack:///./node_modules/socket.io-client/lib/index.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/semver/semver.js","webpack:///./node_modules/to-array/index.js","webpack:///./node_modules/socket.io-parser/node_modules/isarray/index.js","webpack:///./node_modules/sha.js/sha256.js","webpack:///./node_modules/sha.js/hash.js","webpack:///./node_modules/socket.io-parser/node_modules/ms/index.js","webpack:///./node_modules/sha.js/sha384.js","webpack:///./node_modules/socket.io-client/lib/url.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/socket.io-client/lib/on.js","webpack:///./node_modules/socket.io-client/node_modules/component-emitter/index.js","webpack:///./node_modules/socket.io-parser/node_modules/debug/src/browser.js","webpack:///./node_modules/socket.io-parser/is-buffer.js"],"names":["inherits","Hash","Buffer","K","W","Array","Sha","this","init","_w","call","rotl5","num","rotl30","ft","s","b","c","d","prototype","_a","_b","_c","_d","_e","_update","M","a","e","i","readInt32BE","j","t","_hash","H","allocUnsafe","writeInt32BE","module","exports","parser","Emitter","toArray","on","bind","debug","parseqs","hasBin","Socket","events","connect","connect_error","connect_timeout","connecting","disconnect","error","reconnect","reconnect_attempt","reconnect_failed","reconnect_error","reconnecting","ping","pong","emit","io","nsp","opts","json","ids","acks","receiveBuffer","sendBuffer","connected","disconnected","flags","query","autoConnect","open","subEvents","subs","readyState","onopen","send","args","arguments","unshift","apply","ev","hasOwnProperty","packet","type","undefined","binary","BINARY_EVENT","EVENT","data","options","compress","length","pop","id","push","encode","CONNECT","onclose","reason","onpacket","sameNamespace","rootNamespaceError","ERROR","onconnect","onevent","ACK","onack","BINARY_ACK","DISCONNECT","ondisconnect","ack","self","sent","emitBuffered","destroy","close","selectColor","namespace","hash","charCodeAt","colors","Math","abs","createDebug","prevTime","enabled","curr","Date","ms","diff","prev","coerce","index","replace","match","format","formatter","formatters","val","splice","formatArgs","logFn","log","console","useColors","color","instances","indexOf","enable","namespaces","save","names","skips","split","len","RegExp","substr","instance","disable","name","test","Error","stack","message","humanize","Sha512","Ch","x","y","z","maj","sigma0","xl","sigma1","Gamma0","Gamma0l","Gamma1","Gamma1l","getCarry","_ah","_bh","_ch","_dh","_eh","_fh","_gh","_hh","_al","_bl","_cl","_dl","_el","_fl","_gl","_hl","ah","bh","ch","dh","eh","fh","gh","hh","al","bl","cl","dl","el","fl","gl","hl","xh","gamma0","gamma0l","gamma1","gamma1l","Wi7h","Wi7l","Wi16h","Wi16l","Wil","Wih","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Kih","Kil","chh","chl","t1l","t1h","t2l","t2h","writeInt64BE","h","l","offset","isArray","isBuf","Encoder","protocol","types","Decoder","ERROR_PACKET","encodeAsString","obj","str","attachments","payload","tryStringify","JSON","stringify","encodeAsBinary","callback","writeEncoding","bloblessData","deconstruction","deconstructPacket","pack","buffers","removeBlobs","reconstructor","decodeString","p","Number","charAt","buf","next","tryParse","isPayloadValid","parse","BinaryReconstructor","reconPack","msg","encoding","add","base64","takeBinaryData","finishedReconstruction","binData","reconstructPacket","mixin","key","addEventListener","event","fn","_callbacks","once","off","removeListener","removeAllListeners","removeEventListener","cb","callbacks","slice","listeners","hasListeners","algorithm","toLowerCase","Algorithm","sha","sha1","sha224","sha256","sha384","sha512","toString","Object","withNativeBlob","Blob","withNativeFile","File","_deconstructPacket","placeholder","_placeholder","newData","_reconstructPacket","packetData","_removeBlobs","curKey","containingObject","pendingBlobs","fileReader","FileReader","onload","result","readAsArrayBuffer","Sha256","Sha224","_f","_g","_h","eio","Backoff","has","Manager","uri","path","nsps","reconnection","reconnectionAttempts","Infinity","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","min","max","jitter","timeout","lastPing","packetBuffer","_parser","encoder","decoder","emitAll","updateSocketIds","generateId","engine","v","_reconnection","_reconnectionAttempts","_reconnectionDelay","setMin","_randomizationFactor","setJitter","_reconnectionDelayMax","setMax","_timeout","maybeReconnectOnOpen","attempts","socket","skipReconnect","openSub","errorSub","cleanup","err","timer","setTimeout","clearTimeout","onping","onpong","ondata","ondecoded","onerror","onConnecting","encodedPackets","write","processPacketQueue","shift","subsLength","sub","reset","delay","duration","onreconnect","attempt","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","StringDecoder","nb","text","utf16Text","end","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","utf8CheckExtraBytes","r","copy","utf8Text","total","utf8End","n","Sha1","rotl1","url","lookup","cache","managers","parsed","source","newConnection","forceNew","multiplex","buffer","copyProps","src","dst","SafeBuffer","arg","encodingOrOffset","from","alloc","allocUnsafeSlow","create","TypeError","size","fill","SlowBuffer","process","NODE_DEBUG","SEMVER_SPEC_VERSION","MAX_LENGTH","MAX_SAFE_INTEGER","MAX_SAFE_COMPONENT_LENGTH","re","R","NUMERICIDENTIFIER","NUMERICIDENTIFIERLOOSE","NONNUMERICIDENTIFIER","MAINVERSION","MAINVERSIONLOOSE","PRERELEASEIDENTIFIER","PRERELEASEIDENTIFIERLOOSE","PRERELEASE","PRERELEASELOOSE","BUILDIDENTIFIER","BUILD","FULL","FULLPLAIN","LOOSEPLAIN","LOOSE","GTLT","XRANGEIDENTIFIERLOOSE","XRANGEIDENTIFIER","XRANGEPLAIN","XRANGEPLAINLOOSE","XRANGE","XRANGELOOSE","COERCE","LONETILDE","TILDETRIM","tildeTrimReplace","TILDE","TILDELOOSE","LONECARET","CARETTRIM","caretTrimReplace","CARET","CARETLOOSE","COMPARATORLOOSE","COMPARATOR","COMPARATORTRIM","comparatorTrimReplace","HYPHENRANGE","HYPHENRANGELOOSE","STAR","version","loose","includePrerelease","SemVer","er","valid","clean","trim","m","raw","major","minor","patch","prerelease","map","build","inc","release","identifier","version1","version2","eq","v1","v2","prefix","defaultResult","join","compare","other","compareMain","comparePre","compareIdentifiers","isNaN","numeric","anum","bnum","rcompareIdentifiers","compareLoose","rcompare","sort","list","rsort","gt","lt","neq","gte","lte","cmp","op","Comparator","comp","value","semver","ANY","operator","Range","range","set","parseRange","filter","toComparators","parseComparator","replaceCarets","replaceTildes","replaceXRanges","replaceStars","isX","replaceTilde","_","pr","ret","replaceCaret","replaceXRange","gtlt","xM","xm","xp","anyX","hyphenReplace","$0","fM","fm","fp","fpr","fb","to","tM","tm","tp","tpr","tb","testSet","allowed","satisfies","maxSatisfying","versions","maxSV","rangeObj","forEach","minSatisfying","minSV","minVersion","minver","comparators","comparator","compver","validRange","ltr","outside","gtr","hilo","gtfn","ltefn","ltfn","ecomp","high","low","intersects","r1","r2","rangeTmp","sameDirectionIncreasing","sameDirectionDecreasing","sameSemVer","differentDirectionsInclusive","oppositeDirectionsLessThan","oppositeDirectionsGreaterThan","comps","hr","compRe","some","thisComparators","every","thisComparator","rangeComparators","rangeComparator","array","arr","f","g","T1","T2","blockSize","finalSize","_block","_finalSize","_blockSize","_len","update","block","accum","assigned","remainder","digest","rem","bits","writeUInt32BE","lowBits","highBits","String","exec","parseFloat","fmtShort","round","fmtLong","plural","floor","ceil","long","SHA512","Sha384","parseuri","loc","location","host","port","ipv6","href","Stream","EE","EventEmitter","Readable","Writable","Duplex","Transform","PassThrough","pipe","dest","chunk","writable","pause","ondrain","readable","resume","_isStdio","onend","didOnEnd","listenerCount","window","navigator","userAgent","document","documentElement","style","WebkitAppearance","firebug","exception","table","parseInt","$1","lastC","Function","storage","removeItem","load","DEBUG","localstorage","localStorage","chrome","local","withNativeBuffer","isBuffer","withNativeArrayBuffer","ArrayBuffer","isView"],"mappings":"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","file":"js/chunk-vendors~ec8c427e.1cdd68cb.js","sourcesContent":["/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","\n/**\n * Module dependencies.\n */\n\nvar parser = require('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar toArray = require('to-array');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:socket');\nvar parseqs = require('parseqs');\nvar hasBin = require('has-binary2');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = Socket;\n\n/**\n * Internal events (blacklisted).\n * These events can't be emitted by the user.\n *\n * @api private\n */\n\nvar events = {\n  connect: 1,\n  connect_error: 1,\n  connect_timeout: 1,\n  connecting: 1,\n  disconnect: 1,\n  error: 1,\n  reconnect: 1,\n  reconnect_attempt: 1,\n  reconnect_failed: 1,\n  reconnect_error: 1,\n  reconnecting: 1,\n  ping: 1,\n  pong: 1\n};\n\n/**\n * Shortcut to `Emitter#emit`.\n */\n\nvar emit = Emitter.prototype.emit;\n\n/**\n * `Socket` constructor.\n *\n * @api public\n */\n\nfunction Socket (io, nsp, opts) {\n  this.io = io;\n  this.nsp = nsp;\n  this.json = this; // compat\n  this.ids = 0;\n  this.acks = {};\n  this.receiveBuffer = [];\n  this.sendBuffer = [];\n  this.connected = false;\n  this.disconnected = true;\n  this.flags = {};\n  if (opts && opts.query) {\n    this.query = opts.query;\n  }\n  if (this.io.autoConnect) this.open();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Subscribe to open, close and packet events\n *\n * @api private\n */\n\nSocket.prototype.subEvents = function () {\n  if (this.subs) return;\n\n  var io = this.io;\n  this.subs = [\n    on(io, 'open', bind(this, 'onopen')),\n    on(io, 'packet', bind(this, 'onpacket')),\n    on(io, 'close', bind(this, 'onclose'))\n  ];\n};\n\n/**\n * \"Opens\" the socket.\n *\n * @api public\n */\n\nSocket.prototype.open =\nSocket.prototype.connect = function () {\n  if (this.connected) return this;\n\n  this.subEvents();\n  this.io.open(); // ensure open\n  if ('open' === this.io.readyState) this.onopen();\n  this.emit('connecting');\n  return this;\n};\n\n/**\n * Sends a `message` event.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.send = function () {\n  var args = toArray(arguments);\n  args.unshift('message');\n  this.emit.apply(this, args);\n  return this;\n};\n\n/**\n * Override `emit`.\n * If the event is in `events`, it's emitted normally.\n *\n * @param {String} event name\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.emit = function (ev) {\n  if (events.hasOwnProperty(ev)) {\n    emit.apply(this, arguments);\n    return this;\n  }\n\n  var args = toArray(arguments);\n  var packet = {\n    type: (this.flags.binary !== undefined ? this.flags.binary : hasBin(args)) ? parser.BINARY_EVENT : parser.EVENT,\n    data: args\n  };\n\n  packet.options = {};\n  packet.options.compress = !this.flags || false !== this.flags.compress;\n\n  // event ack callback\n  if ('function' === typeof args[args.length - 1]) {\n    debug('emitting packet with ack id %d', this.ids);\n    this.acks[this.ids] = args.pop();\n    packet.id = this.ids++;\n  }\n\n  if (this.connected) {\n    this.packet(packet);\n  } else {\n    this.sendBuffer.push(packet);\n  }\n\n  this.flags = {};\n\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.packet = function (packet) {\n  packet.nsp = this.nsp;\n  this.io.packet(packet);\n};\n\n/**\n * Called upon engine `open`.\n *\n * @api private\n */\n\nSocket.prototype.onopen = function () {\n  debug('transport is open - connecting');\n\n  // write connect packet if necessary\n  if ('/' !== this.nsp) {\n    if (this.query) {\n      var query = typeof this.query === 'object' ? parseqs.encode(this.query) : this.query;\n      debug('sending connect packet with query %s', query);\n      this.packet({type: parser.CONNECT, query: query});\n    } else {\n      this.packet({type: parser.CONNECT});\n    }\n  }\n};\n\n/**\n * Called upon engine `close`.\n *\n * @param {String} reason\n * @api private\n */\n\nSocket.prototype.onclose = function (reason) {\n  debug('close (%s)', reason);\n  this.connected = false;\n  this.disconnected = true;\n  delete this.id;\n  this.emit('disconnect', reason);\n};\n\n/**\n * Called with socket packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onpacket = function (packet) {\n  var sameNamespace = packet.nsp === this.nsp;\n  var rootNamespaceError = packet.type === parser.ERROR && packet.nsp === '/';\n\n  if (!sameNamespace && !rootNamespaceError) return;\n\n  switch (packet.type) {\n    case parser.CONNECT:\n      this.onconnect();\n      break;\n\n    case parser.EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.BINARY_EVENT:\n      this.onevent(packet);\n      break;\n\n    case parser.ACK:\n      this.onack(packet);\n      break;\n\n    case parser.BINARY_ACK:\n      this.onack(packet);\n      break;\n\n    case parser.DISCONNECT:\n      this.ondisconnect();\n      break;\n\n    case parser.ERROR:\n      this.emit('error', packet.data);\n      break;\n  }\n};\n\n/**\n * Called upon a server event.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onevent = function (packet) {\n  var args = packet.data || [];\n  debug('emitting event %j', args);\n\n  if (null != packet.id) {\n    debug('attaching ack callback to event');\n    args.push(this.ack(packet.id));\n  }\n\n  if (this.connected) {\n    emit.apply(this, args);\n  } else {\n    this.receiveBuffer.push(args);\n  }\n};\n\n/**\n * Produces an ack callback to emit with an event.\n *\n * @api private\n */\n\nSocket.prototype.ack = function (id) {\n  var self = this;\n  var sent = false;\n  return function () {\n    // prevent double callbacks\n    if (sent) return;\n    sent = true;\n    var args = toArray(arguments);\n    debug('sending ack %j', args);\n\n    self.packet({\n      type: hasBin(args) ? parser.BINARY_ACK : parser.ACK,\n      id: id,\n      data: args\n    });\n  };\n};\n\n/**\n * Called upon a server acknowlegement.\n *\n * @param {Object} packet\n * @api private\n */\n\nSocket.prototype.onack = function (packet) {\n  var ack = this.acks[packet.id];\n  if ('function' === typeof ack) {\n    debug('calling ack %s with %j', packet.id, packet.data);\n    ack.apply(this, packet.data);\n    delete this.acks[packet.id];\n  } else {\n    debug('bad ack %s', packet.id);\n  }\n};\n\n/**\n * Called upon server connect.\n *\n * @api private\n */\n\nSocket.prototype.onconnect = function () {\n  this.connected = true;\n  this.disconnected = false;\n  this.emit('connect');\n  this.emitBuffered();\n};\n\n/**\n * Emit buffered events (received and emitted).\n *\n * @api private\n */\n\nSocket.prototype.emitBuffered = function () {\n  var i;\n  for (i = 0; i < this.receiveBuffer.length; i++) {\n    emit.apply(this, this.receiveBuffer[i]);\n  }\n  this.receiveBuffer = [];\n\n  for (i = 0; i < this.sendBuffer.length; i++) {\n    this.packet(this.sendBuffer[i]);\n  }\n  this.sendBuffer = [];\n};\n\n/**\n * Called upon server disconnect.\n *\n * @api private\n */\n\nSocket.prototype.ondisconnect = function () {\n  debug('server disconnect (%s)', this.nsp);\n  this.destroy();\n  this.onclose('io server disconnect');\n};\n\n/**\n * Called upon forced client/server side disconnections,\n * this method ensures the manager stops tracking us and\n * that reconnections don't get triggered for this.\n *\n * @api private.\n */\n\nSocket.prototype.destroy = function () {\n  if (this.subs) {\n    // clean subscriptions to avoid reconnections\n    for (var i = 0; i < this.subs.length; i++) {\n      this.subs[i].destroy();\n    }\n    this.subs = null;\n  }\n\n  this.io.destroy(this);\n};\n\n/**\n * Disconnects the socket manually.\n *\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.close =\nSocket.prototype.disconnect = function () {\n  if (this.connected) {\n    debug('performing disconnect (%s)', this.nsp);\n    this.packet({ type: parser.DISCONNECT });\n  }\n\n  // remove socket from pool\n  this.destroy();\n\n  if (this.connected) {\n    // fire events\n    this.onclose('io client disconnect');\n  }\n  return this;\n};\n\n/**\n * Sets the compress flag.\n *\n * @param {Boolean} if `true`, compresses the sending data\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.compress = function (compress) {\n  this.flags.compress = compress;\n  return this;\n};\n\n/**\n * Sets the binary flag\n *\n * @param {Boolean} whether the emitted data contains binary\n * @return {Socket} self\n * @api public\n */\n\nSocket.prototype.binary = function (binary) {\n  this.flags.binary = binary;\n  return this;\n};\n","\n/**\n * This is the common logic for both the Node.js and web browser\n * implementations of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = createDebug.debug = createDebug['default'] = createDebug;\nexports.coerce = coerce;\nexports.disable = disable;\nexports.enable = enable;\nexports.enabled = enabled;\nexports.humanize = require('ms');\n\n/**\n * Active `debug` instances.\n */\nexports.instances = [];\n\n/**\n * The currently active debug mode names, and names to skip.\n */\n\nexports.names = [];\nexports.skips = [];\n\n/**\n * Map of special \"%n\" handling functions, for the debug \"format\" argument.\n *\n * Valid key names are a single, lower or upper-case letter, i.e. \"n\" and \"N\".\n */\n\nexports.formatters = {};\n\n/**\n * Select a color.\n * @param {String} namespace\n * @return {Number}\n * @api private\n */\n\nfunction selectColor(namespace) {\n  var hash = 0, i;\n\n  for (i in namespace) {\n    hash  = ((hash << 5) - hash) + namespace.charCodeAt(i);\n    hash |= 0; // Convert to 32bit integer\n  }\n\n  return exports.colors[Math.abs(hash) % exports.colors.length];\n}\n\n/**\n * Create a debugger with the given `namespace`.\n *\n * @param {String} namespace\n * @return {Function}\n * @api public\n */\n\nfunction createDebug(namespace) {\n\n  var prevTime;\n\n  function debug() {\n    // disabled?\n    if (!debug.enabled) return;\n\n    var self = debug;\n\n    // set `diff` timestamp\n    var curr = +new Date();\n    var ms = curr - (prevTime || curr);\n    self.diff = ms;\n    self.prev = prevTime;\n    self.curr = curr;\n    prevTime = curr;\n\n    // turn the `arguments` into a proper Array\n    var args = new Array(arguments.length);\n    for (var i = 0; i < args.length; i++) {\n      args[i] = arguments[i];\n    }\n\n    args[0] = exports.coerce(args[0]);\n\n    if ('string' !== typeof args[0]) {\n      // anything else let's inspect with %O\n      args.unshift('%O');\n    }\n\n    // apply any `formatters` transformations\n    var index = 0;\n    args[0] = args[0].replace(/%([a-zA-Z%])/g, function(match, format) {\n      // if we encounter an escaped % then don't increase the array index\n      if (match === '%%') return match;\n      index++;\n      var formatter = exports.formatters[format];\n      if ('function' === typeof formatter) {\n        var val = args[index];\n        match = formatter.call(self, val);\n\n        // now we need to remove `args[index]` since it's inlined in the `format`\n        args.splice(index, 1);\n        index--;\n      }\n      return match;\n    });\n\n    // apply env-specific formatting (colors, etc.)\n    exports.formatArgs.call(self, args);\n\n    var logFn = debug.log || exports.log || console.log.bind(console);\n    logFn.apply(self, args);\n  }\n\n  debug.namespace = namespace;\n  debug.enabled = exports.enabled(namespace);\n  debug.useColors = exports.useColors();\n  debug.color = selectColor(namespace);\n  debug.destroy = destroy;\n\n  // env-specific initialization logic for debug instances\n  if ('function' === typeof exports.init) {\n    exports.init(debug);\n  }\n\n  exports.instances.push(debug);\n\n  return debug;\n}\n\nfunction destroy () {\n  var index = exports.instances.indexOf(this);\n  if (index !== -1) {\n    exports.instances.splice(index, 1);\n    return true;\n  } else {\n    return false;\n  }\n}\n\n/**\n * Enables a debug mode by namespaces. This can include modes\n * separated by a colon and wildcards.\n *\n * @param {String} namespaces\n * @api public\n */\n\nfunction enable(namespaces) {\n  exports.save(namespaces);\n\n  exports.names = [];\n  exports.skips = [];\n\n  var i;\n  var split = (typeof namespaces === 'string' ? namespaces : '').split(/[\\s,]+/);\n  var len = split.length;\n\n  for (i = 0; i < len; i++) {\n    if (!split[i]) continue; // ignore empty strings\n    namespaces = split[i].replace(/\\*/g, '.*?');\n    if (namespaces[0] === '-') {\n      exports.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));\n    } else {\n      exports.names.push(new RegExp('^' + namespaces + '$'));\n    }\n  }\n\n  for (i = 0; i < exports.instances.length; i++) {\n    var instance = exports.instances[i];\n    instance.enabled = exports.enabled(instance.namespace);\n  }\n}\n\n/**\n * Disable debug output.\n *\n * @api public\n */\n\nfunction disable() {\n  exports.enable('');\n}\n\n/**\n * Returns true if the given mode name is enabled, false otherwise.\n *\n * @param {String} name\n * @return {Boolean}\n * @api public\n */\n\nfunction enabled(name) {\n  if (name[name.length - 1] === '*') {\n    return true;\n  }\n  var i, len;\n  for (i = 0, len = exports.skips.length; i < len; i++) {\n    if (exports.skips[i].test(name)) {\n      return false;\n    }\n  }\n  for (i = 0, len = exports.names.length; i < len; i++) {\n    if (exports.names[i].test(name)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Coerce `val`.\n *\n * @param {Mixed} val\n * @return {Mixed}\n * @api private\n */\n\nfunction coerce(val) {\n  if (val instanceof Error) return val.stack || val.message;\n  return val;\n}\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n","\n/**\n * Module dependencies.\n */\n\nvar debug = require('debug')('socket.io-parser');\nvar Emitter = require('component-emitter');\nvar binary = require('./binary');\nvar isArray = require('isarray');\nvar isBuf = require('./is-buffer');\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = 4;\n\n/**\n * Packet types.\n *\n * @api public\n */\n\nexports.types = [\n  'CONNECT',\n  'DISCONNECT',\n  'EVENT',\n  'ACK',\n  'ERROR',\n  'BINARY_EVENT',\n  'BINARY_ACK'\n];\n\n/**\n * Packet type `connect`.\n *\n * @api public\n */\n\nexports.CONNECT = 0;\n\n/**\n * Packet type `disconnect`.\n *\n * @api public\n */\n\nexports.DISCONNECT = 1;\n\n/**\n * Packet type `event`.\n *\n * @api public\n */\n\nexports.EVENT = 2;\n\n/**\n * Packet type `ack`.\n *\n * @api public\n */\n\nexports.ACK = 3;\n\n/**\n * Packet type `error`.\n *\n * @api public\n */\n\nexports.ERROR = 4;\n\n/**\n * Packet type 'binary event'\n *\n * @api public\n */\n\nexports.BINARY_EVENT = 5;\n\n/**\n * Packet type `binary ack`. For acks with binary arguments.\n *\n * @api public\n */\n\nexports.BINARY_ACK = 6;\n\n/**\n * Encoder constructor.\n *\n * @api public\n */\n\nexports.Encoder = Encoder;\n\n/**\n * Decoder constructor.\n *\n * @api public\n */\n\nexports.Decoder = Decoder;\n\n/**\n * A socket.io Encoder instance\n *\n * @api public\n */\n\nfunction Encoder() {}\n\nvar ERROR_PACKET = exports.ERROR + '\"encode error\"';\n\n/**\n * Encode a packet as a single string if non-binary, or as a\n * buffer sequence, depending on packet type.\n *\n * @param {Object} obj - packet object\n * @param {Function} callback - function to handle encodings (likely engine.write)\n * @return Calls callback with Array of encodings\n * @api public\n */\n\nEncoder.prototype.encode = function(obj, callback){\n  debug('encoding packet %j', obj);\n\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    encodeAsBinary(obj, callback);\n  } else {\n    var encoding = encodeAsString(obj);\n    callback([encoding]);\n  }\n};\n\n/**\n * Encode packet as string.\n *\n * @param {Object} packet\n * @return {String} encoded\n * @api private\n */\n\nfunction encodeAsString(obj) {\n\n  // first is type\n  var str = '' + obj.type;\n\n  // attachments if we have them\n  if (exports.BINARY_EVENT === obj.type || exports.BINARY_ACK === obj.type) {\n    str += obj.attachments + '-';\n  }\n\n  // if we have a namespace other than `/`\n  // we append it followed by a comma `,`\n  if (obj.nsp && '/' !== obj.nsp) {\n    str += obj.nsp + ',';\n  }\n\n  // immediately followed by the id\n  if (null != obj.id) {\n    str += obj.id;\n  }\n\n  // json data\n  if (null != obj.data) {\n    var payload = tryStringify(obj.data);\n    if (payload !== false) {\n      str += payload;\n    } else {\n      return ERROR_PACKET;\n    }\n  }\n\n  debug('encoded %j as %s', obj, str);\n  return str;\n}\n\nfunction tryStringify(str) {\n  try {\n    return JSON.stringify(str);\n  } catch(e){\n    return false;\n  }\n}\n\n/**\n * Encode packet as 'buffer sequence' by removing blobs, and\n * deconstructing packet into object with placeholders and\n * a list of buffers.\n *\n * @param {Object} packet\n * @return {Buffer} encoded\n * @api private\n */\n\nfunction encodeAsBinary(obj, callback) {\n\n  function writeEncoding(bloblessData) {\n    var deconstruction = binary.deconstructPacket(bloblessData);\n    var pack = encodeAsString(deconstruction.packet);\n    var buffers = deconstruction.buffers;\n\n    buffers.unshift(pack); // add packet info to beginning of data list\n    callback(buffers); // write all the buffers\n  }\n\n  binary.removeBlobs(obj, writeEncoding);\n}\n\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n * @api public\n */\n\nfunction Decoder() {\n  this.reconstructor = null;\n}\n\n/**\n * Mix in `Emitter` with Decoder.\n */\n\nEmitter(Decoder.prototype);\n\n/**\n * Decodes an encoded packet string into packet JSON.\n *\n * @param {String} obj - encoded packet\n * @return {Object} packet\n * @api public\n */\n\nDecoder.prototype.add = function(obj) {\n  var packet;\n  if (typeof obj === 'string') {\n    packet = decodeString(obj);\n    if (exports.BINARY_EVENT === packet.type || exports.BINARY_ACK === packet.type) { // binary packet's json\n      this.reconstructor = new BinaryReconstructor(packet);\n\n      // no attachments, labeled binary but no binary data to follow\n      if (this.reconstructor.reconPack.attachments === 0) {\n        this.emit('decoded', packet);\n      }\n    } else { // non-binary full packet\n      this.emit('decoded', packet);\n    }\n  } else if (isBuf(obj) || obj.base64) { // raw binary data\n    if (!this.reconstructor) {\n      throw new Error('got binary data when not reconstructing a packet');\n    } else {\n      packet = this.reconstructor.takeBinaryData(obj);\n      if (packet) { // received final buffer\n        this.reconstructor = null;\n        this.emit('decoded', packet);\n      }\n    }\n  } else {\n    throw new Error('Unknown type: ' + obj);\n  }\n};\n\n/**\n * Decode a packet String (JSON data)\n *\n * @param {String} str\n * @return {Object} packet\n * @api private\n */\n\nfunction decodeString(str) {\n  var i = 0;\n  // look up type\n  var p = {\n    type: Number(str.charAt(0))\n  };\n\n  if (null == exports.types[p.type]) {\n    return error('unknown packet type ' + p.type);\n  }\n\n  // look up attachments if type binary\n  if (exports.BINARY_EVENT === p.type || exports.BINARY_ACK === p.type) {\n    var buf = '';\n    while (str.charAt(++i) !== '-') {\n      buf += str.charAt(i);\n      if (i == str.length) break;\n    }\n    if (buf != Number(buf) || str.charAt(i) !== '-') {\n      throw new Error('Illegal attachments');\n    }\n    p.attachments = Number(buf);\n  }\n\n  // look up namespace (if any)\n  if ('/' === str.charAt(i + 1)) {\n    p.nsp = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' === c) break;\n      p.nsp += c;\n      if (i === str.length) break;\n    }\n  } else {\n    p.nsp = '/';\n  }\n\n  // look up id\n  var next = str.charAt(i + 1);\n  if ('' !== next && Number(next) == next) {\n    p.id = '';\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      p.id += str.charAt(i);\n      if (i === str.length) break;\n    }\n    p.id = Number(p.id);\n  }\n\n  // look up json data\n  if (str.charAt(++i)) {\n    var payload = tryParse(str.substr(i));\n    var isPayloadValid = payload !== false && (p.type === exports.ERROR || isArray(payload));\n    if (isPayloadValid) {\n      p.data = payload;\n    } else {\n      return error('invalid payload');\n    }\n  }\n\n  debug('decoded %s as %j', str, p);\n  return p;\n}\n\nfunction tryParse(str) {\n  try {\n    return JSON.parse(str);\n  } catch(e){\n    return false;\n  }\n}\n\n/**\n * Deallocates a parser's resources\n *\n * @api public\n */\n\nDecoder.prototype.destroy = function() {\n  if (this.reconstructor) {\n    this.reconstructor.finishedReconstruction();\n  }\n};\n\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n * @api private\n */\n\nfunction BinaryReconstructor(packet) {\n  this.reconPack = packet;\n  this.buffers = [];\n}\n\n/**\n * Method to be called when binary data received from connection\n * after a BINARY_EVENT packet.\n *\n * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n * @return {null | Object} returns null if more binary data is expected or\n *   a reconstructed packet object if all buffers have been received.\n * @api private\n */\n\nBinaryReconstructor.prototype.takeBinaryData = function(binData) {\n  this.buffers.push(binData);\n  if (this.buffers.length === this.reconPack.attachments) { // done with buffer list\n    var packet = binary.reconstructPacket(this.reconPack, this.buffers);\n    this.finishedReconstruction();\n    return packet;\n  }\n  return null;\n};\n\n/**\n * Cleans up binary packet reconstruction variables.\n *\n * @api private\n */\n\nBinaryReconstructor.prototype.finishedReconstruction = function() {\n  this.reconPack = null;\n  this.buffers = [];\n};\n\nfunction error(msg) {\n  return {\n    type: exports.ERROR,\n    data: 'parser error: ' + msg\n  };\n}\n","\r\n/**\r\n * Expose `Emitter`.\r\n */\r\n\r\nif (typeof module !== 'undefined') {\r\n  module.exports = Emitter;\r\n}\r\n\r\n/**\r\n * Initialize a new `Emitter`.\r\n *\r\n * @api public\r\n */\r\n\r\nfunction Emitter(obj) {\r\n  if (obj) return mixin(obj);\r\n};\r\n\r\n/**\r\n * Mixin the emitter properties.\r\n *\r\n * @param {Object} obj\r\n * @return {Object}\r\n * @api private\r\n */\r\n\r\nfunction mixin(obj) {\r\n  for (var key in Emitter.prototype) {\r\n    obj[key] = Emitter.prototype[key];\r\n  }\r\n  return obj;\r\n}\r\n\r\n/**\r\n * Listen on the given `event` with `fn`.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.on =\r\nEmitter.prototype.addEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n    .push(fn);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Adds an `event` listener that will be invoked a single\r\n * time then automatically removed.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.once = function(event, fn){\r\n  function on() {\r\n    this.off(event, on);\r\n    fn.apply(this, arguments);\r\n  }\r\n\r\n  on.fn = fn;\r\n  this.on(event, on);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove the given callback for `event` or all\r\n * registered callbacks.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.off =\r\nEmitter.prototype.removeListener =\r\nEmitter.prototype.removeAllListeners =\r\nEmitter.prototype.removeEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n\r\n  // all\r\n  if (0 == arguments.length) {\r\n    this._callbacks = {};\r\n    return this;\r\n  }\r\n\r\n  // specific event\r\n  var callbacks = this._callbacks['$' + event];\r\n  if (!callbacks) return this;\r\n\r\n  // remove all handlers\r\n  if (1 == arguments.length) {\r\n    delete this._callbacks['$' + event];\r\n    return this;\r\n  }\r\n\r\n  // remove specific handler\r\n  var cb;\r\n  for (var i = 0; i < callbacks.length; i++) {\r\n    cb = callbacks[i];\r\n    if (cb === fn || cb.fn === fn) {\r\n      callbacks.splice(i, 1);\r\n      break;\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Emit `event` with the given args.\r\n *\r\n * @param {String} event\r\n * @param {Mixed} ...\r\n * @return {Emitter}\r\n */\r\n\r\nEmitter.prototype.emit = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  var args = [].slice.call(arguments, 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  if (callbacks) {\r\n    callbacks = callbacks.slice(0);\r\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n      callbacks[i].apply(this, args);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return array of callbacks for `event`.\r\n *\r\n * @param {String} event\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.listeners = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  return this._callbacks['$' + event] || [];\r\n};\r\n\r\n/**\r\n * Check if this emitter has `event` handlers.\r\n *\r\n * @param {String} event\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.hasListeners = function(event){\r\n  return !! this.listeners(event).length;\r\n};\r\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","/*global Blob,File*/\n\n/**\n * Module requirements\n */\n\nvar isArray = require('isarray');\nvar isBuf = require('./is-buffer');\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof Blob === 'function' || (typeof Blob !== 'undefined' && toString.call(Blob) === '[object BlobConstructor]');\nvar withNativeFile = typeof File === 'function' || (typeof File !== 'undefined' && toString.call(File) === '[object FileConstructor]');\n\n/**\n * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.\n * Anything with blobs or files should be fed through removeBlobs before coming\n * here.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @api public\n */\n\nexports.deconstructPacket = function(packet) {\n  var buffers = [];\n  var packetData = packet.data;\n  var pack = packet;\n  pack.data = _deconstructPacket(packetData, buffers);\n  pack.attachments = buffers.length; // number of binary 'attachments'\n  return {packet: pack, buffers: buffers};\n};\n\nfunction _deconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (isBuf(data)) {\n    var placeholder = { _placeholder: true, num: buffers.length };\n    buffers.push(data);\n    return placeholder;\n  } else if (isArray(data)) {\n    var newData = new Array(data.length);\n    for (var i = 0; i < data.length; i++) {\n      newData[i] = _deconstructPacket(data[i], buffers);\n    }\n    return newData;\n  } else if (typeof data === 'object' && !(data instanceof Date)) {\n    var newData = {};\n    for (var key in data) {\n      newData[key] = _deconstructPacket(data[key], buffers);\n    }\n    return newData;\n  }\n  return data;\n}\n\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @api public\n */\n\nexports.reconstructPacket = function(packet, buffers) {\n  packet.data = _reconstructPacket(packet.data, buffers);\n  packet.attachments = undefined; // no longer useful\n  return packet;\n};\n\nfunction _reconstructPacket(data, buffers) {\n  if (!data) return data;\n\n  if (data && data._placeholder) {\n    return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n  } else if (isArray(data)) {\n    for (var i = 0; i < data.length; i++) {\n      data[i] = _reconstructPacket(data[i], buffers);\n    }\n  } else if (typeof data === 'object') {\n    for (var key in data) {\n      data[key] = _reconstructPacket(data[key], buffers);\n    }\n  }\n\n  return data;\n}\n\n/**\n * Asynchronously removes Blobs or Files from data via\n * FileReader's readAsArrayBuffer method. Used before encoding\n * data as msgpack. Calls callback with the blobless data.\n *\n * @param {Object} data\n * @param {Function} callback\n * @api private\n */\n\nexports.removeBlobs = function(data, callback) {\n  function _removeBlobs(obj, curKey, containingObject) {\n    if (!obj) return obj;\n\n    // convert any blob\n    if ((withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File)) {\n      pendingBlobs++;\n\n      // async filereader\n      var fileReader = new FileReader();\n      fileReader.onload = function() { // this.result == arraybuffer\n        if (containingObject) {\n          containingObject[curKey] = this.result;\n        }\n        else {\n          bloblessData = this.result;\n        }\n\n        // if nothing pending its callback time\n        if(! --pendingBlobs) {\n          callback(bloblessData);\n        }\n      };\n\n      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer\n    } else if (isArray(obj)) { // handle array\n      for (var i = 0; i < obj.length; i++) {\n        _removeBlobs(obj[i], i, obj);\n      }\n    } else if (typeof obj === 'object' && !isBuf(obj)) { // and object\n      for (var key in obj) {\n        _removeBlobs(obj[key], key, obj);\n      }\n    }\n  }\n\n  var pendingBlobs = 0;\n  var bloblessData = data;\n  _removeBlobs(bloblessData);\n  if (!pendingBlobs) {\n    callback(bloblessData);\n  }\n};\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","\n/**\n * Module dependencies.\n */\n\nvar eio = require('engine.io-client');\nvar Socket = require('./socket');\nvar Emitter = require('component-emitter');\nvar parser = require('socket.io-parser');\nvar on = require('./on');\nvar bind = require('component-bind');\nvar debug = require('debug')('socket.io-client:manager');\nvar indexOf = require('indexof');\nvar Backoff = require('backo2');\n\n/**\n * IE6+ hasOwnProperty\n */\n\nvar has = Object.prototype.hasOwnProperty;\n\n/**\n * Module exports\n */\n\nmodule.exports = Manager;\n\n/**\n * `Manager` constructor.\n *\n * @param {String} engine instance or engine uri/opts\n * @param {Object} options\n * @api public\n */\n\nfunction Manager (uri, opts) {\n  if (!(this instanceof Manager)) return new Manager(uri, opts);\n  if (uri && ('object' === typeof uri)) {\n    opts = uri;\n    uri = undefined;\n  }\n  opts = opts || {};\n\n  opts.path = opts.path || '/socket.io';\n  this.nsps = {};\n  this.subs = [];\n  this.opts = opts;\n  this.reconnection(opts.reconnection !== false);\n  this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n  this.reconnectionDelay(opts.reconnectionDelay || 1000);\n  this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n  this.randomizationFactor(opts.randomizationFactor || 0.5);\n  this.backoff = new Backoff({\n    min: this.reconnectionDelay(),\n    max: this.reconnectionDelayMax(),\n    jitter: this.randomizationFactor()\n  });\n  this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n  this.readyState = 'closed';\n  this.uri = uri;\n  this.connecting = [];\n  this.lastPing = null;\n  this.encoding = false;\n  this.packetBuffer = [];\n  var _parser = opts.parser || parser;\n  this.encoder = new _parser.Encoder();\n  this.decoder = new _parser.Decoder();\n  this.autoConnect = opts.autoConnect !== false;\n  if (this.autoConnect) this.open();\n}\n\n/**\n * Propagate given event to sockets and emit on `this`\n *\n * @api private\n */\n\nManager.prototype.emitAll = function () {\n  this.emit.apply(this, arguments);\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].emit.apply(this.nsps[nsp], arguments);\n    }\n  }\n};\n\n/**\n * Update `socket.id` of all sockets\n *\n * @api private\n */\n\nManager.prototype.updateSocketIds = function () {\n  for (var nsp in this.nsps) {\n    if (has.call(this.nsps, nsp)) {\n      this.nsps[nsp].id = this.generateId(nsp);\n    }\n  }\n};\n\n/**\n * generate `socket.id` for the given `nsp`\n *\n * @param {String} nsp\n * @return {String}\n * @api private\n */\n\nManager.prototype.generateId = function (nsp) {\n  return (nsp === '/' ? '' : (nsp + '#')) + this.engine.id;\n};\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Manager.prototype);\n\n/**\n * Sets the `reconnection` config.\n *\n * @param {Boolean} true/false if it should automatically reconnect\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnection = function (v) {\n  if (!arguments.length) return this._reconnection;\n  this._reconnection = !!v;\n  return this;\n};\n\n/**\n * Sets the reconnection attempts config.\n *\n * @param {Number} max reconnection attempts before giving up\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionAttempts = function (v) {\n  if (!arguments.length) return this._reconnectionAttempts;\n  this._reconnectionAttempts = v;\n  return this;\n};\n\n/**\n * Sets the delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelay = function (v) {\n  if (!arguments.length) return this._reconnectionDelay;\n  this._reconnectionDelay = v;\n  this.backoff && this.backoff.setMin(v);\n  return this;\n};\n\nManager.prototype.randomizationFactor = function (v) {\n  if (!arguments.length) return this._randomizationFactor;\n  this._randomizationFactor = v;\n  this.backoff && this.backoff.setJitter(v);\n  return this;\n};\n\n/**\n * Sets the maximum delay between reconnections.\n *\n * @param {Number} delay\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.reconnectionDelayMax = function (v) {\n  if (!arguments.length) return this._reconnectionDelayMax;\n  this._reconnectionDelayMax = v;\n  this.backoff && this.backoff.setMax(v);\n  return this;\n};\n\n/**\n * Sets the connection timeout. `false` to disable\n *\n * @return {Manager} self or value\n * @api public\n */\n\nManager.prototype.timeout = function (v) {\n  if (!arguments.length) return this._timeout;\n  this._timeout = v;\n  return this;\n};\n\n/**\n * Starts trying to reconnect if reconnection is enabled and we have not\n * started reconnecting yet\n *\n * @api private\n */\n\nManager.prototype.maybeReconnectOnOpen = function () {\n  // Only try to reconnect if it's the first time we're connecting\n  if (!this.reconnecting && this._reconnection && this.backoff.attempts === 0) {\n    // keeps reconnection from firing twice for the same reconnection loop\n    this.reconnect();\n  }\n};\n\n/**\n * Sets the current transport `socket`.\n *\n * @param {Function} optional, callback\n * @return {Manager} self\n * @api public\n */\n\nManager.prototype.open =\nManager.prototype.connect = function (fn, opts) {\n  debug('readyState %s', this.readyState);\n  if (~this.readyState.indexOf('open')) return this;\n\n  debug('opening %s', this.uri);\n  this.engine = eio(this.uri, this.opts);\n  var socket = this.engine;\n  var self = this;\n  this.readyState = 'opening';\n  this.skipReconnect = false;\n\n  // emit `open`\n  var openSub = on(socket, 'open', function () {\n    self.onopen();\n    fn && fn();\n  });\n\n  // emit `connect_error`\n  var errorSub = on(socket, 'error', function (data) {\n    debug('connect_error');\n    self.cleanup();\n    self.readyState = 'closed';\n    self.emitAll('connect_error', data);\n    if (fn) {\n      var err = new Error('Connection error');\n      err.data = data;\n      fn(err);\n    } else {\n      // Only do this if there is no fn to handle the error\n      self.maybeReconnectOnOpen();\n    }\n  });\n\n  // emit `connect_timeout`\n  if (false !== this._timeout) {\n    var timeout = this._timeout;\n    debug('connect attempt will timeout after %d', timeout);\n\n    // set timer\n    var timer = setTimeout(function () {\n      debug('connect attempt timed out after %d', timeout);\n      openSub.destroy();\n      socket.close();\n      socket.emit('error', 'timeout');\n      self.emitAll('connect_timeout', timeout);\n    }, timeout);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n\n  this.subs.push(openSub);\n  this.subs.push(errorSub);\n\n  return this;\n};\n\n/**\n * Called upon transport open.\n *\n * @api private\n */\n\nManager.prototype.onopen = function () {\n  debug('open');\n\n  // clear old subs\n  this.cleanup();\n\n  // mark as open\n  this.readyState = 'open';\n  this.emit('open');\n\n  // add new subs\n  var socket = this.engine;\n  this.subs.push(on(socket, 'data', bind(this, 'ondata')));\n  this.subs.push(on(socket, 'ping', bind(this, 'onping')));\n  this.subs.push(on(socket, 'pong', bind(this, 'onpong')));\n  this.subs.push(on(socket, 'error', bind(this, 'onerror')));\n  this.subs.push(on(socket, 'close', bind(this, 'onclose')));\n  this.subs.push(on(this.decoder, 'decoded', bind(this, 'ondecoded')));\n};\n\n/**\n * Called upon a ping.\n *\n * @api private\n */\n\nManager.prototype.onping = function () {\n  this.lastPing = new Date();\n  this.emitAll('ping');\n};\n\n/**\n * Called upon a packet.\n *\n * @api private\n */\n\nManager.prototype.onpong = function () {\n  this.emitAll('pong', new Date() - this.lastPing);\n};\n\n/**\n * Called with data.\n *\n * @api private\n */\n\nManager.prototype.ondata = function (data) {\n  this.decoder.add(data);\n};\n\n/**\n * Called when parser fully decodes a packet.\n *\n * @api private\n */\n\nManager.prototype.ondecoded = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon socket error.\n *\n * @api private\n */\n\nManager.prototype.onerror = function (err) {\n  debug('error', err);\n  this.emitAll('error', err);\n};\n\n/**\n * Creates a new socket for the given `nsp`.\n *\n * @return {Socket}\n * @api public\n */\n\nManager.prototype.socket = function (nsp, opts) {\n  var socket = this.nsps[nsp];\n  if (!socket) {\n    socket = new Socket(this, nsp, opts);\n    this.nsps[nsp] = socket;\n    var self = this;\n    socket.on('connecting', onConnecting);\n    socket.on('connect', function () {\n      socket.id = self.generateId(nsp);\n    });\n\n    if (this.autoConnect) {\n      // manually call here since connecting event is fired before listening\n      onConnecting();\n    }\n  }\n\n  function onConnecting () {\n    if (!~indexOf(self.connecting, socket)) {\n      self.connecting.push(socket);\n    }\n  }\n\n  return socket;\n};\n\n/**\n * Called upon a socket close.\n *\n * @param {Socket} socket\n */\n\nManager.prototype.destroy = function (socket) {\n  var index = indexOf(this.connecting, socket);\n  if (~index) this.connecting.splice(index, 1);\n  if (this.connecting.length) return;\n\n  this.close();\n};\n\n/**\n * Writes a packet.\n *\n * @param {Object} packet\n * @api private\n */\n\nManager.prototype.packet = function (packet) {\n  debug('writing packet %j', packet);\n  var self = this;\n  if (packet.query && packet.type === 0) packet.nsp += '?' + packet.query;\n\n  if (!self.encoding) {\n    // encode, then write to engine with result\n    self.encoding = true;\n    this.encoder.encode(packet, function (encodedPackets) {\n      for (var i = 0; i < encodedPackets.length; i++) {\n        self.engine.write(encodedPackets[i], packet.options);\n      }\n      self.encoding = false;\n      self.processPacketQueue();\n    });\n  } else { // add packet to the queue\n    self.packetBuffer.push(packet);\n  }\n};\n\n/**\n * If packet buffer is non-empty, begins encoding the\n * next packet in line.\n *\n * @api private\n */\n\nManager.prototype.processPacketQueue = function () {\n  if (this.packetBuffer.length > 0 && !this.encoding) {\n    var pack = this.packetBuffer.shift();\n    this.packet(pack);\n  }\n};\n\n/**\n * Clean up transport subscriptions and packet buffer.\n *\n * @api private\n */\n\nManager.prototype.cleanup = function () {\n  debug('cleanup');\n\n  var subsLength = this.subs.length;\n  for (var i = 0; i < subsLength; i++) {\n    var sub = this.subs.shift();\n    sub.destroy();\n  }\n\n  this.packetBuffer = [];\n  this.encoding = false;\n  this.lastPing = null;\n\n  this.decoder.destroy();\n};\n\n/**\n * Close the current socket.\n *\n * @api private\n */\n\nManager.prototype.close =\nManager.prototype.disconnect = function () {\n  debug('disconnect');\n  this.skipReconnect = true;\n  this.reconnecting = false;\n  if ('opening' === this.readyState) {\n    // `onclose` will not fire because\n    // an open event never happened\n    this.cleanup();\n  }\n  this.backoff.reset();\n  this.readyState = 'closed';\n  if (this.engine) this.engine.close();\n};\n\n/**\n * Called upon engine close.\n *\n * @api private\n */\n\nManager.prototype.onclose = function (reason) {\n  debug('onclose');\n\n  this.cleanup();\n  this.backoff.reset();\n  this.readyState = 'closed';\n  this.emit('close', reason);\n\n  if (this._reconnection && !this.skipReconnect) {\n    this.reconnect();\n  }\n};\n\n/**\n * Attempt a reconnection.\n *\n * @api private\n */\n\nManager.prototype.reconnect = function () {\n  if (this.reconnecting || this.skipReconnect) return this;\n\n  var self = this;\n\n  if (this.backoff.attempts >= this._reconnectionAttempts) {\n    debug('reconnect failed');\n    this.backoff.reset();\n    this.emitAll('reconnect_failed');\n    this.reconnecting = false;\n  } else {\n    var delay = this.backoff.duration();\n    debug('will wait %dms before reconnect attempt', delay);\n\n    this.reconnecting = true;\n    var timer = setTimeout(function () {\n      if (self.skipReconnect) return;\n\n      debug('attempting reconnect');\n      self.emitAll('reconnect_attempt', self.backoff.attempts);\n      self.emitAll('reconnecting', self.backoff.attempts);\n\n      // check again for the case socket closed in above events\n      if (self.skipReconnect) return;\n\n      self.open(function (err) {\n        if (err) {\n          debug('reconnect attempt error');\n          self.reconnecting = false;\n          self.reconnect();\n          self.emitAll('reconnect_error', err.data);\n        } else {\n          debug('reconnect success');\n          self.onreconnect();\n        }\n      });\n    }, delay);\n\n    this.subs.push({\n      destroy: function () {\n        clearTimeout(timer);\n      }\n    });\n  }\n};\n\n/**\n * Called upon successful reconnect.\n *\n * @api private\n */\n\nManager.prototype.onreconnect = function () {\n  var attempt = this.backoff.attempts;\n  this.reconnecting = false;\n  this.backoff.reset();\n  this.updateSocketIds();\n  this.emitAll('reconnect', attempt);\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","\n/**\n * Module dependencies.\n */\n\nvar url = require('./url');\nvar parser = require('socket.io-parser');\nvar Manager = require('./manager');\nvar debug = require('debug')('socket.io-client');\n\n/**\n * Module exports.\n */\n\nmodule.exports = exports = lookup;\n\n/**\n * Managers cache.\n */\n\nvar cache = exports.managers = {};\n\n/**\n * Looks up an existing `Manager` for multiplexing.\n * If the user summons:\n *\n *   `io('http://localhost/a');`\n *   `io('http://localhost/b');`\n *\n * We reuse the existing instance based on same scheme/port/host,\n * and we initialize sockets for each namespace.\n *\n * @api public\n */\n\nfunction lookup (uri, opts) {\n  if (typeof uri === 'object') {\n    opts = uri;\n    uri = undefined;\n  }\n\n  opts = opts || {};\n\n  var parsed = url(uri);\n  var source = parsed.source;\n  var id = parsed.id;\n  var path = parsed.path;\n  var sameNamespace = cache[id] && path in cache[id].nsps;\n  var newConnection = opts.forceNew || opts['force new connection'] ||\n                      false === opts.multiplex || sameNamespace;\n\n  var io;\n\n  if (newConnection) {\n    debug('ignoring socket cache for %s', source);\n    io = Manager(source, opts);\n  } else {\n    if (!cache[id]) {\n      debug('new io instance for %s', source);\n      cache[id] = Manager(source, opts);\n    }\n    io = cache[id];\n  }\n  if (parsed.query && !opts.query) {\n    opts.query = parsed.query;\n  }\n  return io.socket(parsed.path, opts);\n}\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nexports.protocol = parser.protocol;\n\n/**\n * `connect`.\n *\n * @param {String} uri\n * @api public\n */\n\nexports.connect = lookup;\n\n/**\n * Expose constructors for standalone build.\n *\n * @api public\n */\n\nexports.Manager = require('./manager');\nexports.Socket = require('./socket');\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","exports = module.exports = SemVer\n\nvar debug\n/* istanbul ignore next */\nif (typeof process === 'object' &&\n    process.env &&\n    process.env.NODE_DEBUG &&\n    /\\bsemver\\b/i.test(process.env.NODE_DEBUG)) {\n  debug = function () {\n    var args = Array.prototype.slice.call(arguments, 0)\n    args.unshift('SEMVER')\n    console.log.apply(console, args)\n  }\n} else {\n  debug = function () {}\n}\n\n// Note: this is the semver.org version of the spec that it implements\n// Not necessarily the package version of this code.\nexports.SEMVER_SPEC_VERSION = '2.0.0'\n\nvar MAX_LENGTH = 256\nvar MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||\n  /* istanbul ignore next */ 9007199254740991\n\n// Max safe segment length for coercion.\nvar MAX_SAFE_COMPONENT_LENGTH = 16\n\n// The actual regexps go on exports.re\nvar re = exports.re = []\nvar src = exports.src = []\nvar R = 0\n\n// The following Regular Expressions can be used for tokenizing,\n// validating, and parsing SemVer version strings.\n\n// ## Numeric Identifier\n// A single `0`, or a non-zero digit followed by zero or more digits.\n\nvar NUMERICIDENTIFIER = R++\nsrc[NUMERICIDENTIFIER] = '0|[1-9]\\\\d*'\nvar NUMERICIDENTIFIERLOOSE = R++\nsrc[NUMERICIDENTIFIERLOOSE] = '[0-9]+'\n\n// ## Non-numeric Identifier\n// Zero or more digits, followed by a letter or hyphen, and then zero or\n// more letters, digits, or hyphens.\n\nvar NONNUMERICIDENTIFIER = R++\nsrc[NONNUMERICIDENTIFIER] = '\\\\d*[a-zA-Z-][a-zA-Z0-9-]*'\n\n// ## Main Version\n// Three dot-separated numeric identifiers.\n\nvar MAINVERSION = R++\nsrc[MAINVERSION] = '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')\\\\.' +\n                   '(' + src[NUMERICIDENTIFIER] + ')'\n\nvar MAINVERSIONLOOSE = R++\nsrc[MAINVERSIONLOOSE] = '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')\\\\.' +\n                        '(' + src[NUMERICIDENTIFIERLOOSE] + ')'\n\n// ## Pre-release Version Identifier\n// A numeric identifier, or a non-numeric identifier.\n\nvar PRERELEASEIDENTIFIER = R++\nsrc[PRERELEASEIDENTIFIER] = '(?:' + src[NUMERICIDENTIFIER] +\n                            '|' + src[NONNUMERICIDENTIFIER] + ')'\n\nvar PRERELEASEIDENTIFIERLOOSE = R++\nsrc[PRERELEASEIDENTIFIERLOOSE] = '(?:' + src[NUMERICIDENTIFIERLOOSE] +\n                                 '|' + src[NONNUMERICIDENTIFIER] + ')'\n\n// ## Pre-release Version\n// Hyphen, followed by one or more dot-separated pre-release version\n// identifiers.\n\nvar PRERELEASE = R++\nsrc[PRERELEASE] = '(?:-(' + src[PRERELEASEIDENTIFIER] +\n                  '(?:\\\\.' + src[PRERELEASEIDENTIFIER] + ')*))'\n\nvar PRERELEASELOOSE = R++\nsrc[PRERELEASELOOSE] = '(?:-?(' + src[PRERELEASEIDENTIFIERLOOSE] +\n                       '(?:\\\\.' + src[PRERELEASEIDENTIFIERLOOSE] + ')*))'\n\n// ## Build Metadata Identifier\n// Any combination of digits, letters, or hyphens.\n\nvar BUILDIDENTIFIER = R++\nsrc[BUILDIDENTIFIER] = '[0-9A-Za-z-]+'\n\n// ## Build Metadata\n// Plus sign, followed by one or more period-separated build metadata\n// identifiers.\n\nvar BUILD = R++\nsrc[BUILD] = '(?:\\\\+(' + src[BUILDIDENTIFIER] +\n             '(?:\\\\.' + src[BUILDIDENTIFIER] + ')*))'\n\n// ## Full Version String\n// A main version, followed optionally by a pre-release version and\n// build metadata.\n\n// Note that the only major, minor, patch, and pre-release sections of\n// the version string are capturing groups.  The build metadata is not a\n// capturing group, because it should not ever be used in version\n// comparison.\n\nvar FULL = R++\nvar FULLPLAIN = 'v?' + src[MAINVERSION] +\n                src[PRERELEASE] + '?' +\n                src[BUILD] + '?'\n\nsrc[FULL] = '^' + FULLPLAIN + '$'\n\n// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.\n// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty\n// common in the npm registry.\nvar LOOSEPLAIN = '[v=\\\\s]*' + src[MAINVERSIONLOOSE] +\n                 src[PRERELEASELOOSE] + '?' +\n                 src[BUILD] + '?'\n\nvar LOOSE = R++\nsrc[LOOSE] = '^' + LOOSEPLAIN + '$'\n\nvar GTLT = R++\nsrc[GTLT] = '((?:<|>)?=?)'\n\n// Something like \"2.*\" or \"1.2.x\".\n// Note that \"x.x\" is a valid xRange identifer, meaning \"any version\"\n// Only the first item is strictly required.\nvar XRANGEIDENTIFIERLOOSE = R++\nsrc[XRANGEIDENTIFIERLOOSE] = src[NUMERICIDENTIFIERLOOSE] + '|x|X|\\\\*'\nvar XRANGEIDENTIFIER = R++\nsrc[XRANGEIDENTIFIER] = src[NUMERICIDENTIFIER] + '|x|X|\\\\*'\n\nvar XRANGEPLAIN = R++\nsrc[XRANGEPLAIN] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:\\\\.(' + src[XRANGEIDENTIFIER] + ')' +\n                   '(?:' + src[PRERELEASE] + ')?' +\n                   src[BUILD] + '?' +\n                   ')?)?'\n\nvar XRANGEPLAINLOOSE = R++\nsrc[XRANGEPLAINLOOSE] = '[v=\\\\s]*(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:\\\\.(' + src[XRANGEIDENTIFIERLOOSE] + ')' +\n                        '(?:' + src[PRERELEASELOOSE] + ')?' +\n                        src[BUILD] + '?' +\n                        ')?)?'\n\nvar XRANGE = R++\nsrc[XRANGE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAIN] + '$'\nvar XRANGELOOSE = R++\nsrc[XRANGELOOSE] = '^' + src[GTLT] + '\\\\s*' + src[XRANGEPLAINLOOSE] + '$'\n\n// Coercion.\n// Extract anything that could conceivably be a part of a valid semver\nvar COERCE = R++\nsrc[COERCE] = '(?:^|[^\\\\d])' +\n              '(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '})' +\n              '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n              '(?:\\\\.(\\\\d{1,' + MAX_SAFE_COMPONENT_LENGTH + '}))?' +\n              '(?:$|[^\\\\d])'\n\n// Tilde ranges.\n// Meaning is \"reasonably at or greater than\"\nvar LONETILDE = R++\nsrc[LONETILDE] = '(?:~>?)'\n\nvar TILDETRIM = R++\nsrc[TILDETRIM] = '(\\\\s*)' + src[LONETILDE] + '\\\\s+'\nre[TILDETRIM] = new RegExp(src[TILDETRIM], 'g')\nvar tildeTrimReplace = '$1~'\n\nvar TILDE = R++\nsrc[TILDE] = '^' + src[LONETILDE] + src[XRANGEPLAIN] + '$'\nvar TILDELOOSE = R++\nsrc[TILDELOOSE] = '^' + src[LONETILDE] + src[XRANGEPLAINLOOSE] + '$'\n\n// Caret ranges.\n// Meaning is \"at least and backwards compatible with\"\nvar LONECARET = R++\nsrc[LONECARET] = '(?:\\\\^)'\n\nvar CARETTRIM = R++\nsrc[CARETTRIM] = '(\\\\s*)' + src[LONECARET] + '\\\\s+'\nre[CARETTRIM] = new RegExp(src[CARETTRIM], 'g')\nvar caretTrimReplace = '$1^'\n\nvar CARET = R++\nsrc[CARET] = '^' + src[LONECARET] + src[XRANGEPLAIN] + '$'\nvar CARETLOOSE = R++\nsrc[CARETLOOSE] = '^' + src[LONECARET] + src[XRANGEPLAINLOOSE] + '$'\n\n// A simple gt/lt/eq thing, or just \"\" to indicate \"any version\"\nvar COMPARATORLOOSE = R++\nsrc[COMPARATORLOOSE] = '^' + src[GTLT] + '\\\\s*(' + LOOSEPLAIN + ')$|^$'\nvar COMPARATOR = R++\nsrc[COMPARATOR] = '^' + src[GTLT] + '\\\\s*(' + FULLPLAIN + ')$|^$'\n\n// An expression to strip any whitespace between the gtlt and the thing\n// it modifies, so that `> 1.2.3` ==> `>1.2.3`\nvar COMPARATORTRIM = R++\nsrc[COMPARATORTRIM] = '(\\\\s*)' + src[GTLT] +\n                      '\\\\s*(' + LOOSEPLAIN + '|' + src[XRANGEPLAIN] + ')'\n\n// this one has to use the /g flag\nre[COMPARATORTRIM] = new RegExp(src[COMPARATORTRIM], 'g')\nvar comparatorTrimReplace = '$1$2$3'\n\n// Something like `1.2.3 - 1.2.4`\n// Note that these all use the loose form, because they'll be\n// checked against either the strict or loose comparator form\n// later.\nvar HYPHENRANGE = R++\nsrc[HYPHENRANGE] = '^\\\\s*(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s+-\\\\s+' +\n                   '(' + src[XRANGEPLAIN] + ')' +\n                   '\\\\s*$'\n\nvar HYPHENRANGELOOSE = R++\nsrc[HYPHENRANGELOOSE] = '^\\\\s*(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s+-\\\\s+' +\n                        '(' + src[XRANGEPLAINLOOSE] + ')' +\n                        '\\\\s*$'\n\n// Star ranges basically just allow anything at all.\nvar STAR = R++\nsrc[STAR] = '(<|>)?=?\\\\s*\\\\*'\n\n// Compile to actual regexp objects.\n// All are flag-free, unless they were created above with a flag.\nfor (var i = 0; i < R; i++) {\n  debug(i, src[i])\n  if (!re[i]) {\n    re[i] = new RegExp(src[i])\n  }\n}\n\nexports.parse = parse\nfunction parse (version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  if (version.length > MAX_LENGTH) {\n    return null\n  }\n\n  var r = options.loose ? re[LOOSE] : re[FULL]\n  if (!r.test(version)) {\n    return null\n  }\n\n  try {\n    return new SemVer(version, options)\n  } catch (er) {\n    return null\n  }\n}\n\nexports.valid = valid\nfunction valid (version, options) {\n  var v = parse(version, options)\n  return v ? v.version : null\n}\n\nexports.clean = clean\nfunction clean (version, options) {\n  var s = parse(version.trim().replace(/^[=v]+/, ''), options)\n  return s ? s.version : null\n}\n\nexports.SemVer = SemVer\n\nfunction SemVer (version, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n  if (version instanceof SemVer) {\n    if (version.loose === options.loose) {\n      return version\n    } else {\n      version = version.version\n    }\n  } else if (typeof version !== 'string') {\n    throw new TypeError('Invalid Version: ' + version)\n  }\n\n  if (version.length > MAX_LENGTH) {\n    throw new TypeError('version is longer than ' + MAX_LENGTH + ' characters')\n  }\n\n  if (!(this instanceof SemVer)) {\n    return new SemVer(version, options)\n  }\n\n  debug('SemVer', version, options)\n  this.options = options\n  this.loose = !!options.loose\n\n  var m = version.trim().match(options.loose ? re[LOOSE] : re[FULL])\n\n  if (!m) {\n    throw new TypeError('Invalid Version: ' + version)\n  }\n\n  this.raw = version\n\n  // these are actually numbers\n  this.major = +m[1]\n  this.minor = +m[2]\n  this.patch = +m[3]\n\n  if (this.major > MAX_SAFE_INTEGER || this.major < 0) {\n    throw new TypeError('Invalid major version')\n  }\n\n  if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {\n    throw new TypeError('Invalid minor version')\n  }\n\n  if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {\n    throw new TypeError('Invalid patch version')\n  }\n\n  // numberify any prerelease numeric ids\n  if (!m[4]) {\n    this.prerelease = []\n  } else {\n    this.prerelease = m[4].split('.').map(function (id) {\n      if (/^[0-9]+$/.test(id)) {\n        var num = +id\n        if (num >= 0 && num < MAX_SAFE_INTEGER) {\n          return num\n        }\n      }\n      return id\n    })\n  }\n\n  this.build = m[5] ? m[5].split('.') : []\n  this.format()\n}\n\nSemVer.prototype.format = function () {\n  this.version = this.major + '.' + this.minor + '.' + this.patch\n  if (this.prerelease.length) {\n    this.version += '-' + this.prerelease.join('.')\n  }\n  return this.version\n}\n\nSemVer.prototype.toString = function () {\n  return this.version\n}\n\nSemVer.prototype.compare = function (other) {\n  debug('SemVer.compare', this.version, this.options, other)\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  return this.compareMain(other) || this.comparePre(other)\n}\n\nSemVer.prototype.compareMain = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  return compareIdentifiers(this.major, other.major) ||\n         compareIdentifiers(this.minor, other.minor) ||\n         compareIdentifiers(this.patch, other.patch)\n}\n\nSemVer.prototype.comparePre = function (other) {\n  if (!(other instanceof SemVer)) {\n    other = new SemVer(other, this.options)\n  }\n\n  // NOT having a prerelease is > having one\n  if (this.prerelease.length && !other.prerelease.length) {\n    return -1\n  } else if (!this.prerelease.length && other.prerelease.length) {\n    return 1\n  } else if (!this.prerelease.length && !other.prerelease.length) {\n    return 0\n  }\n\n  var i = 0\n  do {\n    var a = this.prerelease[i]\n    var b = other.prerelease[i]\n    debug('prerelease compare', i, a, b)\n    if (a === undefined && b === undefined) {\n      return 0\n    } else if (b === undefined) {\n      return 1\n    } else if (a === undefined) {\n      return -1\n    } else if (a === b) {\n      continue\n    } else {\n      return compareIdentifiers(a, b)\n    }\n  } while (++i)\n}\n\n// preminor will bump the version up to the next minor release, and immediately\n// down to pre-release. premajor and prepatch work the same way.\nSemVer.prototype.inc = function (release, identifier) {\n  switch (release) {\n    case 'premajor':\n      this.prerelease.length = 0\n      this.patch = 0\n      this.minor = 0\n      this.major++\n      this.inc('pre', identifier)\n      break\n    case 'preminor':\n      this.prerelease.length = 0\n      this.patch = 0\n      this.minor++\n      this.inc('pre', identifier)\n      break\n    case 'prepatch':\n      // If this is already a prerelease, it will bump to the next version\n      // drop any prereleases that might already exist, since they are not\n      // relevant at this point.\n      this.prerelease.length = 0\n      this.inc('patch', identifier)\n      this.inc('pre', identifier)\n      break\n    // If the input is a non-prerelease version, this acts the same as\n    // prepatch.\n    case 'prerelease':\n      if (this.prerelease.length === 0) {\n        this.inc('patch', identifier)\n      }\n      this.inc('pre', identifier)\n      break\n\n    case 'major':\n      // If this is a pre-major version, bump up to the same major version.\n      // Otherwise increment major.\n      // 1.0.0-5 bumps to 1.0.0\n      // 1.1.0 bumps to 2.0.0\n      if (this.minor !== 0 ||\n          this.patch !== 0 ||\n          this.prerelease.length === 0) {\n        this.major++\n      }\n      this.minor = 0\n      this.patch = 0\n      this.prerelease = []\n      break\n    case 'minor':\n      // If this is a pre-minor version, bump up to the same minor version.\n      // Otherwise increment minor.\n      // 1.2.0-5 bumps to 1.2.0\n      // 1.2.1 bumps to 1.3.0\n      if (this.patch !== 0 || this.prerelease.length === 0) {\n        this.minor++\n      }\n      this.patch = 0\n      this.prerelease = []\n      break\n    case 'patch':\n      // If this is not a pre-release version, it will increment the patch.\n      // If it is a pre-release it will bump up to the same patch version.\n      // 1.2.0-5 patches to 1.2.0\n      // 1.2.0 patches to 1.2.1\n      if (this.prerelease.length === 0) {\n        this.patch++\n      }\n      this.prerelease = []\n      break\n    // This probably shouldn't be used publicly.\n    // 1.0.0 \"pre\" would become 1.0.0-0 which is the wrong direction.\n    case 'pre':\n      if (this.prerelease.length === 0) {\n        this.prerelease = [0]\n      } else {\n        var i = this.prerelease.length\n        while (--i >= 0) {\n          if (typeof this.prerelease[i] === 'number') {\n            this.prerelease[i]++\n            i = -2\n          }\n        }\n        if (i === -1) {\n          // didn't increment anything\n          this.prerelease.push(0)\n        }\n      }\n      if (identifier) {\n        // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n        // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n        if (this.prerelease[0] === identifier) {\n          if (isNaN(this.prerelease[1])) {\n            this.prerelease = [identifier, 0]\n          }\n        } else {\n          this.prerelease = [identifier, 0]\n        }\n      }\n      break\n\n    default:\n      throw new Error('invalid increment argument: ' + release)\n  }\n  this.format()\n  this.raw = this.version\n  return this\n}\n\nexports.inc = inc\nfunction inc (version, release, loose, identifier) {\n  if (typeof (loose) === 'string') {\n    identifier = loose\n    loose = undefined\n  }\n\n  try {\n    return new SemVer(version, loose).inc(release, identifier).version\n  } catch (er) {\n    return null\n  }\n}\n\nexports.diff = diff\nfunction diff (version1, version2) {\n  if (eq(version1, version2)) {\n    return null\n  } else {\n    var v1 = parse(version1)\n    var v2 = parse(version2)\n    var prefix = ''\n    if (v1.prerelease.length || v2.prerelease.length) {\n      prefix = 'pre'\n      var defaultResult = 'prerelease'\n    }\n    for (var key in v1) {\n      if (key === 'major' || key === 'minor' || key === 'patch') {\n        if (v1[key] !== v2[key]) {\n          return prefix + key\n        }\n      }\n    }\n    return defaultResult // may be undefined\n  }\n}\n\nexports.compareIdentifiers = compareIdentifiers\n\nvar numeric = /^[0-9]+$/\nfunction compareIdentifiers (a, b) {\n  var anum = numeric.test(a)\n  var bnum = numeric.test(b)\n\n  if (anum && bnum) {\n    a = +a\n    b = +b\n  }\n\n  return a === b ? 0\n    : (anum && !bnum) ? -1\n    : (bnum && !anum) ? 1\n    : a < b ? -1\n    : 1\n}\n\nexports.rcompareIdentifiers = rcompareIdentifiers\nfunction rcompareIdentifiers (a, b) {\n  return compareIdentifiers(b, a)\n}\n\nexports.major = major\nfunction major (a, loose) {\n  return new SemVer(a, loose).major\n}\n\nexports.minor = minor\nfunction minor (a, loose) {\n  return new SemVer(a, loose).minor\n}\n\nexports.patch = patch\nfunction patch (a, loose) {\n  return new SemVer(a, loose).patch\n}\n\nexports.compare = compare\nfunction compare (a, b, loose) {\n  return new SemVer(a, loose).compare(new SemVer(b, loose))\n}\n\nexports.compareLoose = compareLoose\nfunction compareLoose (a, b) {\n  return compare(a, b, true)\n}\n\nexports.rcompare = rcompare\nfunction rcompare (a, b, loose) {\n  return compare(b, a, loose)\n}\n\nexports.sort = sort\nfunction sort (list, loose) {\n  return list.sort(function (a, b) {\n    return exports.compare(a, b, loose)\n  })\n}\n\nexports.rsort = rsort\nfunction rsort (list, loose) {\n  return list.sort(function (a, b) {\n    return exports.rcompare(a, b, loose)\n  })\n}\n\nexports.gt = gt\nfunction gt (a, b, loose) {\n  return compare(a, b, loose) > 0\n}\n\nexports.lt = lt\nfunction lt (a, b, loose) {\n  return compare(a, b, loose) < 0\n}\n\nexports.eq = eq\nfunction eq (a, b, loose) {\n  return compare(a, b, loose) === 0\n}\n\nexports.neq = neq\nfunction neq (a, b, loose) {\n  return compare(a, b, loose) !== 0\n}\n\nexports.gte = gte\nfunction gte (a, b, loose) {\n  return compare(a, b, loose) >= 0\n}\n\nexports.lte = lte\nfunction lte (a, b, loose) {\n  return compare(a, b, loose) <= 0\n}\n\nexports.cmp = cmp\nfunction cmp (a, op, b, loose) {\n  switch (op) {\n    case '===':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a === b\n\n    case '!==':\n      if (typeof a === 'object')\n        a = a.version\n      if (typeof b === 'object')\n        b = b.version\n      return a !== b\n\n    case '':\n    case '=':\n    case '==':\n      return eq(a, b, loose)\n\n    case '!=':\n      return neq(a, b, loose)\n\n    case '>':\n      return gt(a, b, loose)\n\n    case '>=':\n      return gte(a, b, loose)\n\n    case '<':\n      return lt(a, b, loose)\n\n    case '<=':\n      return lte(a, b, loose)\n\n    default:\n      throw new TypeError('Invalid operator: ' + op)\n  }\n}\n\nexports.Comparator = Comparator\nfunction Comparator (comp, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (comp instanceof Comparator) {\n    if (comp.loose === !!options.loose) {\n      return comp\n    } else {\n      comp = comp.value\n    }\n  }\n\n  if (!(this instanceof Comparator)) {\n    return new Comparator(comp, options)\n  }\n\n  debug('comparator', comp, options)\n  this.options = options\n  this.loose = !!options.loose\n  this.parse(comp)\n\n  if (this.semver === ANY) {\n    this.value = ''\n  } else {\n    this.value = this.operator + this.semver.version\n  }\n\n  debug('comp', this)\n}\n\nvar ANY = {}\nComparator.prototype.parse = function (comp) {\n  var r = this.options.loose ? re[COMPARATORLOOSE] : re[COMPARATOR]\n  var m = comp.match(r)\n\n  if (!m) {\n    throw new TypeError('Invalid comparator: ' + comp)\n  }\n\n  this.operator = m[1]\n  if (this.operator === '=') {\n    this.operator = ''\n  }\n\n  // if it literally is just '>' or '' then allow anything.\n  if (!m[2]) {\n    this.semver = ANY\n  } else {\n    this.semver = new SemVer(m[2], this.options.loose)\n  }\n}\n\nComparator.prototype.toString = function () {\n  return this.value\n}\n\nComparator.prototype.test = function (version) {\n  debug('Comparator.test', version, this.options.loose)\n\n  if (this.semver === ANY) {\n    return true\n  }\n\n  if (typeof version === 'string') {\n    version = new SemVer(version, this.options)\n  }\n\n  return cmp(version, this.operator, this.semver, this.options)\n}\n\nComparator.prototype.intersects = function (comp, options) {\n  if (!(comp instanceof Comparator)) {\n    throw new TypeError('a Comparator is required')\n  }\n\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  var rangeTmp\n\n  if (this.operator === '') {\n    rangeTmp = new Range(comp.value, options)\n    return satisfies(this.value, rangeTmp, options)\n  } else if (comp.operator === '') {\n    rangeTmp = new Range(this.value, options)\n    return satisfies(comp.semver, rangeTmp, options)\n  }\n\n  var sameDirectionIncreasing =\n    (this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '>=' || comp.operator === '>')\n  var sameDirectionDecreasing =\n    (this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '<=' || comp.operator === '<')\n  var sameSemVer = this.semver.version === comp.semver.version\n  var differentDirectionsInclusive =\n    (this.operator === '>=' || this.operator === '<=') &&\n    (comp.operator === '>=' || comp.operator === '<=')\n  var oppositeDirectionsLessThan =\n    cmp(this.semver, '<', comp.semver, options) &&\n    ((this.operator === '>=' || this.operator === '>') &&\n    (comp.operator === '<=' || comp.operator === '<'))\n  var oppositeDirectionsGreaterThan =\n    cmp(this.semver, '>', comp.semver, options) &&\n    ((this.operator === '<=' || this.operator === '<') &&\n    (comp.operator === '>=' || comp.operator === '>'))\n\n  return sameDirectionIncreasing || sameDirectionDecreasing ||\n    (sameSemVer && differentDirectionsInclusive) ||\n    oppositeDirectionsLessThan || oppositeDirectionsGreaterThan\n}\n\nexports.Range = Range\nfunction Range (range, options) {\n  if (!options || typeof options !== 'object') {\n    options = {\n      loose: !!options,\n      includePrerelease: false\n    }\n  }\n\n  if (range instanceof Range) {\n    if (range.loose === !!options.loose &&\n        range.includePrerelease === !!options.includePrerelease) {\n      return range\n    } else {\n      return new Range(range.raw, options)\n    }\n  }\n\n  if (range instanceof Comparator) {\n    return new Range(range.value, options)\n  }\n\n  if (!(this instanceof Range)) {\n    return new Range(range, options)\n  }\n\n  this.options = options\n  this.loose = !!options.loose\n  this.includePrerelease = !!options.includePrerelease\n\n  // First, split based on boolean or ||\n  this.raw = range\n  this.set = range.split(/\\s*\\|\\|\\s*/).map(function (range) {\n    return this.parseRange(range.trim())\n  }, this).filter(function (c) {\n    // throw out any that are not relevant for whatever reason\n    return c.length\n  })\n\n  if (!this.set.length) {\n    throw new TypeError('Invalid SemVer Range: ' + range)\n  }\n\n  this.format()\n}\n\nRange.prototype.format = function () {\n  this.range = this.set.map(function (comps) {\n    return comps.join(' ').trim()\n  }).join('||').trim()\n  return this.range\n}\n\nRange.prototype.toString = function () {\n  return this.range\n}\n\nRange.prototype.parseRange = function (range) {\n  var loose = this.options.loose\n  range = range.trim()\n  // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`\n  var hr = loose ? re[HYPHENRANGELOOSE] : re[HYPHENRANGE]\n  range = range.replace(hr, hyphenReplace)\n  debug('hyphen replace', range)\n  // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`\n  range = range.replace(re[COMPARATORTRIM], comparatorTrimReplace)\n  debug('comparator trim', range, re[COMPARATORTRIM])\n\n  // `~ 1.2.3` => `~1.2.3`\n  range = range.replace(re[TILDETRIM], tildeTrimReplace)\n\n  // `^ 1.2.3` => `^1.2.3`\n  range = range.replace(re[CARETTRIM], caretTrimReplace)\n\n  // normalize spaces\n  range = range.split(/\\s+/).join(' ')\n\n  // At this point, the range is completely trimmed and\n  // ready to be split into comparators.\n\n  var compRe = loose ? re[COMPARATORLOOSE] : re[COMPARATOR]\n  var set = range.split(' ').map(function (comp) {\n    return parseComparator(comp, this.options)\n  }, this).join(' ').split(/\\s+/)\n  if (this.options.loose) {\n    // in loose mode, throw out any that are not valid comparators\n    set = set.filter(function (comp) {\n      return !!comp.match(compRe)\n    })\n  }\n  set = set.map(function (comp) {\n    return new Comparator(comp, this.options)\n  }, this)\n\n  return set\n}\n\nRange.prototype.intersects = function (range, options) {\n  if (!(range instanceof Range)) {\n    throw new TypeError('a Range is required')\n  }\n\n  return this.set.some(function (thisComparators) {\n    return thisComparators.every(function (thisComparator) {\n      return range.set.some(function (rangeComparators) {\n        return rangeComparators.every(function (rangeComparator) {\n          return thisComparator.intersects(rangeComparator, options)\n        })\n      })\n    })\n  })\n}\n\n// Mostly just for testing and legacy API reasons\nexports.toComparators = toComparators\nfunction toComparators (range, options) {\n  return new Range(range, options).set.map(function (comp) {\n    return comp.map(function (c) {\n      return c.value\n    }).join(' ').trim().split(' ')\n  })\n}\n\n// comprised of xranges, tildes, stars, and gtlt's at this point.\n// already replaced the hyphen ranges\n// turn into a set of JUST comparators.\nfunction parseComparator (comp, options) {\n  debug('comp', comp, options)\n  comp = replaceCarets(comp, options)\n  debug('caret', comp)\n  comp = replaceTildes(comp, options)\n  debug('tildes', comp)\n  comp = replaceXRanges(comp, options)\n  debug('xrange', comp)\n  comp = replaceStars(comp, options)\n  debug('stars', comp)\n  return comp\n}\n\nfunction isX (id) {\n  return !id || id.toLowerCase() === 'x' || id === '*'\n}\n\n// ~, ~> --> * (any, kinda silly)\n// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0\n// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0\n// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0\n// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0\n// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0\nfunction replaceTildes (comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceTilde(comp, options)\n  }).join(' ')\n}\n\nfunction replaceTilde (comp, options) {\n  var r = options.loose ? re[TILDELOOSE] : re[TILDE]\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('tilde', comp, _, M, m, p, pr)\n    var ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n    } else if (isX(p)) {\n      // ~1.2 == >=1.2.0 <1.3.0\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n    } else if (pr) {\n      debug('replaceTilde pr', pr)\n      ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n            ' <' + M + '.' + (+m + 1) + '.0'\n    } else {\n      // ~1.2.3 == >=1.2.3 <1.3.0\n      ret = '>=' + M + '.' + m + '.' + p +\n            ' <' + M + '.' + (+m + 1) + '.0'\n    }\n\n    debug('tilde return', ret)\n    return ret\n  })\n}\n\n// ^ --> * (any, kinda silly)\n// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0\n// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0\n// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0\n// ^1.2.3 --> >=1.2.3 <2.0.0\n// ^1.2.0 --> >=1.2.0 <2.0.0\nfunction replaceCarets (comp, options) {\n  return comp.trim().split(/\\s+/).map(function (comp) {\n    return replaceCaret(comp, options)\n  }).join(' ')\n}\n\nfunction replaceCaret (comp, options) {\n  debug('caret', comp, options)\n  var r = options.loose ? re[CARETLOOSE] : re[CARET]\n  return comp.replace(r, function (_, M, m, p, pr) {\n    debug('caret', comp, _, M, m, p, pr)\n    var ret\n\n    if (isX(M)) {\n      ret = ''\n    } else if (isX(m)) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n    } else if (isX(p)) {\n      if (M === '0') {\n        ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n      } else {\n        ret = '>=' + M + '.' + m + '.0 <' + (+M + 1) + '.0.0'\n      }\n    } else if (pr) {\n      debug('replaceCaret pr', pr)\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n                ' <' + M + '.' + m + '.' + (+p + 1)\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n                ' <' + M + '.' + (+m + 1) + '.0'\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p + '-' + pr +\n              ' <' + (+M + 1) + '.0.0'\n      }\n    } else {\n      debug('no pr')\n      if (M === '0') {\n        if (m === '0') {\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + m + '.' + (+p + 1)\n        } else {\n          ret = '>=' + M + '.' + m + '.' + p +\n                ' <' + M + '.' + (+m + 1) + '.0'\n        }\n      } else {\n        ret = '>=' + M + '.' + m + '.' + p +\n              ' <' + (+M + 1) + '.0.0'\n      }\n    }\n\n    debug('caret return', ret)\n    return ret\n  })\n}\n\nfunction replaceXRanges (comp, options) {\n  debug('replaceXRanges', comp, options)\n  return comp.split(/\\s+/).map(function (comp) {\n    return replaceXRange(comp, options)\n  }).join(' ')\n}\n\nfunction replaceXRange (comp, options) {\n  comp = comp.trim()\n  var r = options.loose ? re[XRANGELOOSE] : re[XRANGE]\n  return comp.replace(r, function (ret, gtlt, M, m, p, pr) {\n    debug('xRange', comp, ret, gtlt, M, m, p, pr)\n    var xM = isX(M)\n    var xm = xM || isX(m)\n    var xp = xm || isX(p)\n    var anyX = xp\n\n    if (gtlt === '=' && anyX) {\n      gtlt = ''\n    }\n\n    if (xM) {\n      if (gtlt === '>' || gtlt === '<') {\n        // nothing is allowed\n        ret = '<0.0.0'\n      } else {\n        // nothing is forbidden\n        ret = '*'\n      }\n    } else if (gtlt && anyX) {\n      // we know patch is an x, because we have any x at all.\n      // replace X with 0\n      if (xm) {\n        m = 0\n      }\n      p = 0\n\n      if (gtlt === '>') {\n        // >1 => >=2.0.0\n        // >1.2 => >=1.3.0\n        // >1.2.3 => >= 1.2.4\n        gtlt = '>='\n        if (xm) {\n          M = +M + 1\n          m = 0\n          p = 0\n        } else {\n          m = +m + 1\n          p = 0\n        }\n      } else if (gtlt === '<=') {\n        // <=0.7.x is actually <0.8.0, since any 0.7.x should\n        // pass.  Similarly, <=7.x is actually <8.0.0, etc.\n        gtlt = '<'\n        if (xm) {\n          M = +M + 1\n        } else {\n          m = +m + 1\n        }\n      }\n\n      ret = gtlt + M + '.' + m + '.' + p\n    } else if (xm) {\n      ret = '>=' + M + '.0.0 <' + (+M + 1) + '.0.0'\n    } else if (xp) {\n      ret = '>=' + M + '.' + m + '.0 <' + M + '.' + (+m + 1) + '.0'\n    }\n\n    debug('xRange return', ret)\n\n    return ret\n  })\n}\n\n// Because * is AND-ed with everything else in the comparator,\n// and '' means \"any version\", just remove the *s entirely.\nfunction replaceStars (comp, options) {\n  debug('replaceStars', comp, options)\n  // Looseness is ignored here.  star is always as loose as it gets!\n  return comp.trim().replace(re[STAR], '')\n}\n\n// This function is passed to string.replace(re[HYPHENRANGE])\n// M, m, patch, prerelease, build\n// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5\n// 1.2.3 - 3.4 => >=1.2.0 <3.5.0 Any 3.4.x will do\n// 1.2 - 3.4 => >=1.2.0 <3.5.0\nfunction hyphenReplace ($0,\n  from, fM, fm, fp, fpr, fb,\n  to, tM, tm, tp, tpr, tb) {\n  if (isX(fM)) {\n    from = ''\n  } else if (isX(fm)) {\n    from = '>=' + fM + '.0.0'\n  } else if (isX(fp)) {\n    from = '>=' + fM + '.' + fm + '.0'\n  } else {\n    from = '>=' + from\n  }\n\n  if (isX(tM)) {\n    to = ''\n  } else if (isX(tm)) {\n    to = '<' + (+tM + 1) + '.0.0'\n  } else if (isX(tp)) {\n    to = '<' + tM + '.' + (+tm + 1) + '.0'\n  } else if (tpr) {\n    to = '<=' + tM + '.' + tm + '.' + tp + '-' + tpr\n  } else {\n    to = '<=' + to\n  }\n\n  return (from + ' ' + to).trim()\n}\n\n// if ANY of the sets match ALL of its comparators, then pass\nRange.prototype.test = function (version) {\n  if (!version) {\n    return false\n  }\n\n  if (typeof version === 'string') {\n    version = new SemVer(version, this.options)\n  }\n\n  for (var i = 0; i < this.set.length; i++) {\n    if (testSet(this.set[i], version, this.options)) {\n      return true\n    }\n  }\n  return false\n}\n\nfunction testSet (set, version, options) {\n  for (var i = 0; i < set.length; i++) {\n    if (!set[i].test(version)) {\n      return false\n    }\n  }\n\n  if (version.prerelease.length && !options.includePrerelease) {\n    // Find the set of versions that are allowed to have prereleases\n    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0\n    // That should allow `1.2.3-pr.2` to pass.\n    // However, `1.2.4-alpha.notready` should NOT be allowed,\n    // even though it's within the range set by the comparators.\n    for (i = 0; i < set.length; i++) {\n      debug(set[i].semver)\n      if (set[i].semver === ANY) {\n        continue\n      }\n\n      if (set[i].semver.prerelease.length > 0) {\n        var allowed = set[i].semver\n        if (allowed.major === version.major &&\n            allowed.minor === version.minor &&\n            allowed.patch === version.patch) {\n          return true\n        }\n      }\n    }\n\n    // Version has a -pre, but it's not one of the ones we like.\n    return false\n  }\n\n  return true\n}\n\nexports.satisfies = satisfies\nfunction satisfies (version, range, options) {\n  try {\n    range = new Range(range, options)\n  } catch (er) {\n    return false\n  }\n  return range.test(version)\n}\n\nexports.maxSatisfying = maxSatisfying\nfunction maxSatisfying (versions, range, options) {\n  var max = null\n  var maxSV = null\n  try {\n    var rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!max || maxSV.compare(v) === -1) {\n        // compare(max, v, true)\n        max = v\n        maxSV = new SemVer(max, options)\n      }\n    }\n  })\n  return max\n}\n\nexports.minSatisfying = minSatisfying\nfunction minSatisfying (versions, range, options) {\n  var min = null\n  var minSV = null\n  try {\n    var rangeObj = new Range(range, options)\n  } catch (er) {\n    return null\n  }\n  versions.forEach(function (v) {\n    if (rangeObj.test(v)) {\n      // satisfies(v, range, options)\n      if (!min || minSV.compare(v) === 1) {\n        // compare(min, v, true)\n        min = v\n        minSV = new SemVer(min, options)\n      }\n    }\n  })\n  return min\n}\n\nexports.minVersion = minVersion\nfunction minVersion (range, loose) {\n  range = new Range(range, loose)\n\n  var minver = new SemVer('0.0.0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = new SemVer('0.0.0-0')\n  if (range.test(minver)) {\n    return minver\n  }\n\n  minver = null\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i]\n\n    comparators.forEach(function (comparator) {\n      // Clone to avoid manipulating the comparator's semver object.\n      var compver = new SemVer(comparator.semver.version)\n      switch (comparator.operator) {\n        case '>':\n          if (compver.prerelease.length === 0) {\n            compver.patch++\n          } else {\n            compver.prerelease.push(0)\n          }\n          compver.raw = compver.format()\n          /* fallthrough */\n        case '':\n        case '>=':\n          if (!minver || gt(minver, compver)) {\n            minver = compver\n          }\n          break\n        case '<':\n        case '<=':\n          /* Ignore maximum versions */\n          break\n        /* istanbul ignore next */\n        default:\n          throw new Error('Unexpected operation: ' + comparator.operator)\n      }\n    })\n  }\n\n  if (minver && range.test(minver)) {\n    return minver\n  }\n\n  return null\n}\n\nexports.validRange = validRange\nfunction validRange (range, options) {\n  try {\n    // Return '*' instead of '' so that truthiness works.\n    // This will throw if it's invalid anyway\n    return new Range(range, options).range || '*'\n  } catch (er) {\n    return null\n  }\n}\n\n// Determine if version is less than all the versions possible in the range\nexports.ltr = ltr\nfunction ltr (version, range, options) {\n  return outside(version, range, '<', options)\n}\n\n// Determine if version is greater than all the versions possible in the range.\nexports.gtr = gtr\nfunction gtr (version, range, options) {\n  return outside(version, range, '>', options)\n}\n\nexports.outside = outside\nfunction outside (version, range, hilo, options) {\n  version = new SemVer(version, options)\n  range = new Range(range, options)\n\n  var gtfn, ltefn, ltfn, comp, ecomp\n  switch (hilo) {\n    case '>':\n      gtfn = gt\n      ltefn = lte\n      ltfn = lt\n      comp = '>'\n      ecomp = '>='\n      break\n    case '<':\n      gtfn = lt\n      ltefn = gte\n      ltfn = gt\n      comp = '<'\n      ecomp = '<='\n      break\n    default:\n      throw new TypeError('Must provide a hilo val of \"<\" or \">\"')\n  }\n\n  // If it satisifes the range it is not outside\n  if (satisfies(version, range, options)) {\n    return false\n  }\n\n  // From now on, variable terms are as if we're in \"gtr\" mode.\n  // but note that everything is flipped for the \"ltr\" function.\n\n  for (var i = 0; i < range.set.length; ++i) {\n    var comparators = range.set[i]\n\n    var high = null\n    var low = null\n\n    comparators.forEach(function (comparator) {\n      if (comparator.semver === ANY) {\n        comparator = new Comparator('>=0.0.0')\n      }\n      high = high || comparator\n      low = low || comparator\n      if (gtfn(comparator.semver, high.semver, options)) {\n        high = comparator\n      } else if (ltfn(comparator.semver, low.semver, options)) {\n        low = comparator\n      }\n    })\n\n    // If the edge version comparator has a operator then our version\n    // isn't outside it\n    if (high.operator === comp || high.operator === ecomp) {\n      return false\n    }\n\n    // If the lowest version comparator has an operator and our version\n    // is less than it then it isn't higher than the range\n    if ((!low.operator || low.operator === comp) &&\n        ltefn(version, low.semver)) {\n      return false\n    } else if (low.operator === ecomp && ltfn(version, low.semver)) {\n      return false\n    }\n  }\n  return true\n}\n\nexports.prerelease = prerelease\nfunction prerelease (version, options) {\n  var parsed = parse(version, options)\n  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null\n}\n\nexports.intersects = intersects\nfunction intersects (r1, r2, options) {\n  r1 = new Range(r1, options)\n  r2 = new Range(r2, options)\n  return r1.intersects(r2)\n}\n\nexports.coerce = coerce\nfunction coerce (version) {\n  if (version instanceof SemVer) {\n    return version\n  }\n\n  if (typeof version !== 'string') {\n    return null\n  }\n\n  var match = version.match(re[COERCE])\n\n  if (match == null) {\n    return null\n  }\n\n  return parse(match[1] +\n    '.' + (match[2] || '0') +\n    '.' + (match[3] || '0'))\n}\n","module.exports = toArray\n\nfunction toArray(list, index) {\n    var array = []\n\n    index = index || 0\n\n    for (var i = index || 0; i < list.length; i++) {\n        array[i - index] = list[i]\n    }\n\n    return array\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","/**\n * Helpers.\n */\n\nvar s = 1000;\nvar m = s * 60;\nvar h = m * 60;\nvar d = h * 24;\nvar y = d * 365.25;\n\n/**\n * Parse or format the given `val`.\n *\n * Options:\n *\n *  - `long` verbose formatting [false]\n *\n * @param {String|Number} val\n * @param {Object} [options]\n * @throws {Error} throw an error if val is not a non-empty string or a number\n * @return {String|Number}\n * @api public\n */\n\nmodule.exports = function(val, options) {\n  options = options || {};\n  var type = typeof val;\n  if (type === 'string' && val.length > 0) {\n    return parse(val);\n  } else if (type === 'number' && isNaN(val) === false) {\n    return options.long ? fmtLong(val) : fmtShort(val);\n  }\n  throw new Error(\n    'val is not a non-empty string or a valid number. val=' +\n      JSON.stringify(val)\n  );\n};\n\n/**\n * Parse the given `str` and return milliseconds.\n *\n * @param {String} str\n * @return {Number}\n * @api private\n */\n\nfunction parse(str) {\n  str = String(str);\n  if (str.length > 100) {\n    return;\n  }\n  var match = /^((?:\\d+)?\\.?\\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|years?|yrs?|y)?$/i.exec(\n    str\n  );\n  if (!match) {\n    return;\n  }\n  var n = parseFloat(match[1]);\n  var type = (match[2] || 'ms').toLowerCase();\n  switch (type) {\n    case 'years':\n    case 'year':\n    case 'yrs':\n    case 'yr':\n    case 'y':\n      return n * y;\n    case 'days':\n    case 'day':\n    case 'd':\n      return n * d;\n    case 'hours':\n    case 'hour':\n    case 'hrs':\n    case 'hr':\n    case 'h':\n      return n * h;\n    case 'minutes':\n    case 'minute':\n    case 'mins':\n    case 'min':\n    case 'm':\n      return n * m;\n    case 'seconds':\n    case 'second':\n    case 'secs':\n    case 'sec':\n    case 's':\n      return n * s;\n    case 'milliseconds':\n    case 'millisecond':\n    case 'msecs':\n    case 'msec':\n    case 'ms':\n      return n;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Short format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtShort(ms) {\n  if (ms >= d) {\n    return Math.round(ms / d) + 'd';\n  }\n  if (ms >= h) {\n    return Math.round(ms / h) + 'h';\n  }\n  if (ms >= m) {\n    return Math.round(ms / m) + 'm';\n  }\n  if (ms >= s) {\n    return Math.round(ms / s) + 's';\n  }\n  return ms + 'ms';\n}\n\n/**\n * Long format for `ms`.\n *\n * @param {Number} ms\n * @return {String}\n * @api private\n */\n\nfunction fmtLong(ms) {\n  return plural(ms, d, 'day') ||\n    plural(ms, h, 'hour') ||\n    plural(ms, m, 'minute') ||\n    plural(ms, s, 'second') ||\n    ms + ' ms';\n}\n\n/**\n * Pluralization helper.\n */\n\nfunction plural(ms, n, name) {\n  if (ms < n) {\n    return;\n  }\n  if (ms < n * 1.5) {\n    return Math.floor(ms / n) + ' ' + name;\n  }\n  return Math.ceil(ms / n) + ' ' + name + 's';\n}\n","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","\n/**\n * Module dependencies.\n */\n\nvar parseuri = require('parseuri');\nvar debug = require('debug')('socket.io-client:url');\n\n/**\n * Module exports.\n */\n\nmodule.exports = url;\n\n/**\n * URL parser.\n *\n * @param {String} url\n * @param {Object} An object meant to mimic window.location.\n *                 Defaults to window.location.\n * @api public\n */\n\nfunction url (uri, loc) {\n  var obj = uri;\n\n  // default to window.location\n  loc = loc || (typeof location !== 'undefined' && location);\n  if (null == uri) uri = loc.protocol + '//' + loc.host;\n\n  // relative path support\n  if ('string' === typeof uri) {\n    if ('/' === uri.charAt(0)) {\n      if ('/' === uri.charAt(1)) {\n        uri = loc.protocol + uri;\n      } else {\n        uri = loc.host + uri;\n      }\n    }\n\n    if (!/^(https?|wss?):\\/\\//.test(uri)) {\n      debug('protocol-less url %s', uri);\n      if ('undefined' !== typeof loc) {\n        uri = loc.protocol + '//' + uri;\n      } else {\n        uri = 'https://' + uri;\n      }\n    }\n\n    // parse\n    debug('parse %s', uri);\n    obj = parseuri(uri);\n  }\n\n  // make sure we treat `localhost:80` and `localhost` equally\n  if (!obj.port) {\n    if (/^(http|ws)$/.test(obj.protocol)) {\n      obj.port = '80';\n    } else if (/^(http|ws)s$/.test(obj.protocol)) {\n      obj.port = '443';\n    }\n  }\n\n  obj.path = obj.path || '/';\n\n  var ipv6 = obj.host.indexOf(':') !== -1;\n  var host = ipv6 ? '[' + obj.host + ']' : obj.host;\n\n  // define unique id\n  obj.id = obj.protocol + '://' + host + ':' + obj.port;\n  // define href\n  obj.href = obj.protocol + '://' + host + (loc && loc.port === obj.port ? '' : (':' + obj.port));\n\n  return obj;\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","\n/**\n * Module exports.\n */\n\nmodule.exports = on;\n\n/**\n * Helper for subscriptions.\n *\n * @param {Object|EventEmitter} obj with `Emitter` mixin or `EventEmitter`\n * @param {String} event name\n * @param {Function} callback\n * @api public\n */\n\nfunction on (obj, ev, fn) {\n  obj.on(ev, fn);\n  return {\n    destroy: function () {\n      obj.removeListener(ev, fn);\n    }\n  };\n}\n","\r\n/**\r\n * Expose `Emitter`.\r\n */\r\n\r\nif (typeof module !== 'undefined') {\r\n  module.exports = Emitter;\r\n}\r\n\r\n/**\r\n * Initialize a new `Emitter`.\r\n *\r\n * @api public\r\n */\r\n\r\nfunction Emitter(obj) {\r\n  if (obj) return mixin(obj);\r\n};\r\n\r\n/**\r\n * Mixin the emitter properties.\r\n *\r\n * @param {Object} obj\r\n * @return {Object}\r\n * @api private\r\n */\r\n\r\nfunction mixin(obj) {\r\n  for (var key in Emitter.prototype) {\r\n    obj[key] = Emitter.prototype[key];\r\n  }\r\n  return obj;\r\n}\r\n\r\n/**\r\n * Listen on the given `event` with `fn`.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.on =\r\nEmitter.prototype.addEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\r\n    .push(fn);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Adds an `event` listener that will be invoked a single\r\n * time then automatically removed.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.once = function(event, fn){\r\n  function on() {\r\n    this.off(event, on);\r\n    fn.apply(this, arguments);\r\n  }\r\n\r\n  on.fn = fn;\r\n  this.on(event, on);\r\n  return this;\r\n};\r\n\r\n/**\r\n * Remove the given callback for `event` or all\r\n * registered callbacks.\r\n *\r\n * @param {String} event\r\n * @param {Function} fn\r\n * @return {Emitter}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.off =\r\nEmitter.prototype.removeListener =\r\nEmitter.prototype.removeAllListeners =\r\nEmitter.prototype.removeEventListener = function(event, fn){\r\n  this._callbacks = this._callbacks || {};\r\n\r\n  // all\r\n  if (0 == arguments.length) {\r\n    this._callbacks = {};\r\n    return this;\r\n  }\r\n\r\n  // specific event\r\n  var callbacks = this._callbacks['$' + event];\r\n  if (!callbacks) return this;\r\n\r\n  // remove all handlers\r\n  if (1 == arguments.length) {\r\n    delete this._callbacks['$' + event];\r\n    return this;\r\n  }\r\n\r\n  // remove specific handler\r\n  var cb;\r\n  for (var i = 0; i < callbacks.length; i++) {\r\n    cb = callbacks[i];\r\n    if (cb === fn || cb.fn === fn) {\r\n      callbacks.splice(i, 1);\r\n      break;\r\n    }\r\n  }\r\n  return this;\r\n};\r\n\r\n/**\r\n * Emit `event` with the given args.\r\n *\r\n * @param {String} event\r\n * @param {Mixed} ...\r\n * @return {Emitter}\r\n */\r\n\r\nEmitter.prototype.emit = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  var args = [].slice.call(arguments, 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  if (callbacks) {\r\n    callbacks = callbacks.slice(0);\r\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\r\n      callbacks[i].apply(this, args);\r\n    }\r\n  }\r\n\r\n  return this;\r\n};\r\n\r\n/**\r\n * Return array of callbacks for `event`.\r\n *\r\n * @param {String} event\r\n * @return {Array}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.listeners = function(event){\r\n  this._callbacks = this._callbacks || {};\r\n  return this._callbacks['$' + event] || [];\r\n};\r\n\r\n/**\r\n * Check if this emitter has `event` handlers.\r\n *\r\n * @param {String} event\r\n * @return {Boolean}\r\n * @api public\r\n */\r\n\r\nEmitter.prototype.hasListeners = function(event){\r\n  return !! this.listeners(event).length;\r\n};\r\n","/**\n * This is the web browser implementation of `debug()`.\n *\n * Expose `debug()` as the module.\n */\n\nexports = module.exports = require('./debug');\nexports.log = log;\nexports.formatArgs = formatArgs;\nexports.save = save;\nexports.load = load;\nexports.useColors = useColors;\nexports.storage = 'undefined' != typeof chrome\n               && 'undefined' != typeof chrome.storage\n                  ? chrome.storage.local\n                  : localstorage();\n\n/**\n * Colors.\n */\n\nexports.colors = [\n  '#0000CC', '#0000FF', '#0033CC', '#0033FF', '#0066CC', '#0066FF', '#0099CC',\n  '#0099FF', '#00CC00', '#00CC33', '#00CC66', '#00CC99', '#00CCCC', '#00CCFF',\n  '#3300CC', '#3300FF', '#3333CC', '#3333FF', '#3366CC', '#3366FF', '#3399CC',\n  '#3399FF', '#33CC00', '#33CC33', '#33CC66', '#33CC99', '#33CCCC', '#33CCFF',\n  '#6600CC', '#6600FF', '#6633CC', '#6633FF', '#66CC00', '#66CC33', '#9900CC',\n  '#9900FF', '#9933CC', '#9933FF', '#99CC00', '#99CC33', '#CC0000', '#CC0033',\n  '#CC0066', '#CC0099', '#CC00CC', '#CC00FF', '#CC3300', '#CC3333', '#CC3366',\n  '#CC3399', '#CC33CC', '#CC33FF', '#CC6600', '#CC6633', '#CC9900', '#CC9933',\n  '#CCCC00', '#CCCC33', '#FF0000', '#FF0033', '#FF0066', '#FF0099', '#FF00CC',\n  '#FF00FF', '#FF3300', '#FF3333', '#FF3366', '#FF3399', '#FF33CC', '#FF33FF',\n  '#FF6600', '#FF6633', '#FF9900', '#FF9933', '#FFCC00', '#FFCC33'\n];\n\n/**\n * Currently only WebKit-based Web Inspectors, Firefox >= v31,\n * and the Firebug extension (any Firefox version) are known\n * to support \"%c\" CSS customizations.\n *\n * TODO: add a `localStorage` variable to explicitly enable/disable colors\n */\n\nfunction useColors() {\n  // NB: In an Electron preload script, document will be defined but not fully\n  // initialized. Since we know we're in Chrome, we'll just detect this case\n  // explicitly\n  if (typeof window !== 'undefined' && window.process && window.process.type === 'renderer') {\n    return true;\n  }\n\n  // Internet Explorer and Edge do not support colors.\n  if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\\/(\\d+)/)) {\n    return false;\n  }\n\n  // is webkit? http://stackoverflow.com/a/16459606/376773\n  // document is undefined in react-native: https://github.com/facebook/react-native/pull/1632\n  return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||\n    // is firebug? http://stackoverflow.com/a/398120/376773\n    (typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||\n    // is firefox >= v31?\n    // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\\/(\\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||\n    // double check webkit in userAgent just in case we are in a worker\n    (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\\/(\\d+)/));\n}\n\n/**\n * Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.\n */\n\nexports.formatters.j = function(v) {\n  try {\n    return JSON.stringify(v);\n  } catch (err) {\n    return '[UnexpectedJSONParseError]: ' + err.message;\n  }\n};\n\n\n/**\n * Colorize log arguments if enabled.\n *\n * @api public\n */\n\nfunction formatArgs(args) {\n  var useColors = this.useColors;\n\n  args[0] = (useColors ? '%c' : '')\n    + this.namespace\n    + (useColors ? ' %c' : ' ')\n    + args[0]\n    + (useColors ? '%c ' : ' ')\n    + '+' + exports.humanize(this.diff);\n\n  if (!useColors) return;\n\n  var c = 'color: ' + this.color;\n  args.splice(1, 0, c, 'color: inherit')\n\n  // the final \"%c\" is somewhat tricky, because there could be other\n  // arguments passed either before or after the %c, so we need to\n  // figure out the correct index to insert the CSS into\n  var index = 0;\n  var lastC = 0;\n  args[0].replace(/%[a-zA-Z%]/g, function(match) {\n    if ('%%' === match) return;\n    index++;\n    if ('%c' === match) {\n      // we only are interested in the *last* %c\n      // (the user may have provided their own)\n      lastC = index;\n    }\n  });\n\n  args.splice(lastC, 0, c);\n}\n\n/**\n * Invokes `console.log()` when available.\n * No-op when `console.log` is not a \"function\".\n *\n * @api public\n */\n\nfunction log() {\n  // this hackery is required for IE8/9, where\n  // the `console.log` function doesn't have 'apply'\n  return 'object' === typeof console\n    && console.log\n    && Function.prototype.apply.call(console.log, console, arguments);\n}\n\n/**\n * Save `namespaces`.\n *\n * @param {String} namespaces\n * @api private\n */\n\nfunction save(namespaces) {\n  try {\n    if (null == namespaces) {\n      exports.storage.removeItem('debug');\n    } else {\n      exports.storage.debug = namespaces;\n    }\n  } catch(e) {}\n}\n\n/**\n * Load `namespaces`.\n *\n * @return {String} returns the previously persisted debug modes\n * @api private\n */\n\nfunction load() {\n  var r;\n  try {\n    r = exports.storage.debug;\n  } catch(e) {}\n\n  // If debug isn't set in LS, and we're in Electron, try to load $DEBUG\n  if (!r && typeof process !== 'undefined' && 'env' in process) {\n    r = process.env.DEBUG;\n  }\n\n  return r;\n}\n\n/**\n * Enable namespaces listed in `localStorage.debug` initially.\n */\n\nexports.enable(load());\n\n/**\n * Localstorage attempts to return the localstorage.\n *\n * This is necessary because safari throws\n * when a user disables cookies/localstorage\n * and you attempt to access it.\n *\n * @return {LocalStorage}\n * @api private\n */\n\nfunction localstorage() {\n  try {\n    return window.localStorage;\n  } catch (e) {}\n}\n","\nmodule.exports = isBuf;\n\nvar withNativeBuffer = typeof Buffer === 'function' && typeof Buffer.isBuffer === 'function';\nvar withNativeArrayBuffer = typeof ArrayBuffer === 'function';\n\nvar isView = function (obj) {\n  return typeof ArrayBuffer.isView === 'function' ? ArrayBuffer.isView(obj) : (obj.buffer instanceof ArrayBuffer);\n};\n\n/**\n * Returns true if obj is a buffer or an arraybuffer.\n *\n * @api private\n */\n\nfunction isBuf(obj) {\n  return (withNativeBuffer && Buffer.isBuffer(obj)) ||\n          (withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj)));\n}\n"],"sourceRoot":""}