{"version":3,"sources":["webpack:///./node_modules/socket.io-parser/node_modules/debug/src/debug.js","webpack:///./node_modules/engine.io-parser/lib/keys.js","webpack:///./node_modules/has-cors/index.js","webpack:///./node_modules/blob/index.js","webpack:///./node_modules/engine.io-client/lib/xmlhttprequest.js","webpack:///./node_modules/engine.io-client/lib/transports/polling-xhr.js","webpack:///./node_modules/engine.io-client/lib/transports/polling.js","webpack:///./node_modules/engine.io-client/node_modules/component-emitter/index.js","webpack:///./node_modules/socket.io-client/lib/url.js","webpack:///./node_modules/engine.io-parser/lib/browser.js","webpack:///./node_modules/base64-arraybuffer/lib/base64-arraybuffer.js","webpack:///./node_modules/socket.io-client/lib/socket.js","webpack:///./node_modules/socket.io-client/node_modules/debug/src/browser.js","webpack:///./node_modules/engine.io-client/node_modules/debug/src/debug.js","webpack:///./node_modules/indexof/index.js","webpack:///./node_modules/component-inherit/index.js","webpack:///./node_modules/custom-event-polyfill/polyfill.js","webpack:///./node_modules/ieee754/index.js","webpack:///./node_modules/after/index.js","webpack:///./node_modules/socket.io-parser/node_modules/ms/index.js","webpack:///./node_modules/node-libs-browser/node_modules/buffer/index.js","webpack:///./node_modules/socket.io-parser/binary.js","webpack:///./node_modules/socket.io-client/lib/index.js","webpack:///./node_modules/socket.io-parser/is-buffer.js","webpack:///./node_modules/engine.io-client/lib/transports/polling-jsonp.js","webpack:///./node_modules/socket.io-client/node_modules/component-emitter/index.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/socket.io-parser/node_modules/debug/src/browser.js","webpack:///./node_modules/parseuri/index.js","webpack:///./node_modules/engine.io-client/lib/transports/index.js","webpack:///./node_modules/engine.io-client/lib/socket.js","webpack:///./node_modules/socket.io-client/node_modules/ms/index.js","webpack:///./node_modules/socket.io-client/lib/manager.js","webpack:///./node_modules/engine.io-client/lib/transports/websocket.js","webpack:///./node_modules/to-array/index.js","webpack:///./node_modules/clsx/dist/clsx.m.js","webpack:///./node_modules/react-toastify/dist/react-toastify.esm.js","webpack:///./node_modules/whatwg-fetch/fetch.js","webpack:///./node_modules/engine.io-parser/lib/utf8.js","webpack:///./node_modules/parseqs/index.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/socket.io-parser/index.js","webpack:///./node_modules/arraybuffer.slice/index.js","webpack:///./node_modules/engine.io-client/node_modules/ms/index.js","webpack:///./node_modules/component-bind/index.js","webpack:///./node_modules/engine.io-client/lib/index.js","webpack:///./node_modules/socket.io-client/node_modules/debug/src/debug.js","webpack:///./node_modules/has-binary2/node_modules/isarray/index.js","webpack:///./node_modules/yeast/index.js","webpack:///./node_modules/intersection-observer/intersection-observer.js","webpack:///./node_modules/socket.io-parser/node_modules/isarray/index.js","webpack:///./node_modules/socket.io-client/lib/on.js","webpack:///./node_modules/has-binary2/index.js","webpack:///./node_modules/engine.io-client/lib/transport.js","webpack:///./node_modules/engine.io-client/node_modules/debug/src/browser.js","webpack:///./node_modules/component-emitter/index.js","webpack:///./node_modules/backo2/index.js"],"names":["createDebug","namespace","prevTime","debug","enabled","self","curr","Date","ms","diff","prev","args","Array","arguments","length","i","exports","coerce","unshift","index","replace","match","format","formatter","formatters","val","call","splice","formatArgs","logFn","log","console","bind","apply","useColors","color","hash","charCodeAt","colors","Math","abs","selectColor","destroy","init","instances","push","indexOf","this","module","Error","stack","message","disable","enable","namespaces","save","names","skips","split","len","RegExp","substr","instance","name","test","humanize","Object","keys","obj","arr","has","prototype","hasOwnProperty","XMLHttpRequest","err","BlobBuilder","WebKitBlobBuilder","MSBlobBuilder","MozBlobBuilder","blobSupported","Blob","size","e","blobSupportsArrayBufferView","Uint8Array","blobBuilderSupported","append","getBlob","mapArrayBufferViews","ary","map","chunk","buffer","ArrayBuffer","buf","byteLength","copy","set","byteOffset","BlobBuilderConstructor","options","bb","forEach","part","type","BlobConstructor","hasCORS","opts","xdomain","xscheme","enablesXDR","XDomainRequest","concat","join","Polling","Emitter","inherit","empty","XHR","requestTimeout","extraHeaders","location","isSSL","protocol","port","xd","hostname","xs","secure","Request","method","uri","async","data","undefined","agent","isBinary","supportsBinary","pfx","key","passphrase","cert","ca","ciphers","rejectUnauthorized","create","request","doWrite","fn","req","on","onError","sendXhr","doPoll","onData","pollXhr","xhr","open","setDisableHeaderCheck","setRequestHeader","withCredentials","timeout","hasXDR","onload","onLoad","onerror","responseText","onreadystatechange","readyState","contentType","getResponseHeader","responseType","status","setTimeout","send","document","requestsCount","requests","onSuccess","emit","cleanup","fromError","abort","response","attachEvent","unloadHandler","addEventListener","terminationEvent","Transport","parseqs","parser","yeast","hasXHR2","forceBase64","doOpen","poll","pause","onPause","polling","writable","total","once","decodePayload","socket","binaryType","packet","onOpen","onClose","onPacket","doClose","close","write","packets","callbackfn","encodePayload","query","schema","timestampRequests","timestampParam","sid","b64","encode","Number","path","mixin","event","_callbacks","off","removeListener","removeAllListeners","removeEventListener","cb","callbacks","slice","listeners","hasListeners","parseuri","loc","host","charAt","id","href","base64encoder","hasBinary","sliceBuffer","after","utf8","isAndroid","navigator","userAgent","isPhantomJS","dontSendBlobs","ping","pong","upgrade","noop","packetslist","each","done","result","next","eachWithIndex","el","error","msg","encodePacket","utf8encode","callback","encodeBase64Packet","contentArray","resultBuffer","encodeArrayBuffer","fr","FileReader","readAsArrayBuffer","encodeBlobAsArrayBuffer","blob","encodeBlob","base64","encodeBase64Object","encoded","String","strict","b64data","readAsDataURL","fromCharCode","typed","basic","btoa","decodePacket","utf8decode","decodeBase64Packet","decode","tryDecode","substring","rest","encodePayloadAsBlob","encodePayloadAsArrayBuffer","doneCallback","setLengthHeader","results","decodePayloadAsBinary","n","l","chr","encodedPackets","totalLength","reduce","acc","p","toString","resultArray","bufferIndex","isString","ab","view","lenStr","parseInt","binaryIdentifier","lengthAry","bufferTail","buffers","tailArray","msgLength","chars","lookup","arraybuffer","bytes","encoded1","encoded2","encoded3","encoded4","bufferLength","toArray","hasBin","Socket","events","connect","connect_error","connect_timeout","connecting","disconnect","reconnect","reconnect_attempt","reconnect_failed","reconnect_error","reconnecting","io","nsp","json","ids","acks","receiveBuffer","sendBuffer","connected","disconnected","flags","autoConnect","subEvents","subs","onopen","ev","binary","BINARY_EVENT","EVENT","compress","pop","CONNECT","onclose","reason","onpacket","sameNamespace","rootNamespaceError","ERROR","onconnect","onevent","ACK","BINARY_ACK","onack","DISCONNECT","ondisconnect","ack","sent","emitBuffered","load","r","storage","process","DEBUG","Function","c","lastC","removeItem","window","toLowerCase","documentElement","style","WebkitAppearance","firebug","exception","table","$1","chrome","local","localStorage","localstorage","j","v","JSON","stringify","a","b","constructor","ce","CustomEvent","cancelable","preventDefault","defaultPrevented","params","evt","origPrevent","bubbles","createEvent","initCustomEvent","detail","defineProperty","get","Event","read","offset","isLE","mLen","nBytes","m","eLen","eMax","eBias","nBits","d","s","NaN","Infinity","pow","value","rt","isNaN","floor","LN2","count","err_cb","bail","proxy","h","y","plural","ceil","str","exec","parseFloat","parse","long","round","fmtShort","ieee754","isArray","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","RangeError","__proto__","arg","encodingOrOffset","allocUnsafe","from","TypeError","array","fromArrayLike","fromArrayBuffer","string","encoding","isEncoding","actual","fromString","isBuffer","checked","fromObject","assertSize","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","latin1Write","base64Write","ucs2Write","units","hi","lo","utf16leToBytes","fromByteArray","min","res","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","codePoint","bytesPerSequence","codePoints","MAX_ARGUMENTS_LENGTH","decodeCodePointsArray","SlowBuffer","alloc","INSPECT_MAX_BYTES","global","foo","subarray","typedArraySupport","poolSize","_augment","Symbol","species","configurable","fill","allocUnsafeSlow","_isBuffer","compare","x","list","pos","swap16","swap32","swap64","equals","inspect","max","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","_arr","ret","out","toHex","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","code","INVALID_BASE64_RE","leadSurrogate","toByteArray","trim","stringtrim","base64clean","src","dst","isBuf","withNativeBlob","withNativeFile","File","_deconstructPacket","placeholder","_placeholder","num","newData","_reconstructPacket","deconstructPacket","packetData","pack","attachments","reconstructPacket","removeBlobs","pendingBlobs","bloblessData","_removeBlobs","curKey","containingObject","fileReader","url","Manager","cache","managers","source","nsps","forceNew","multiplex","withNativeBuffer","withNativeArrayBuffer","JSONPPolling","rNewline","rEscapedNewline","glob","___eio","script","parentNode","removeChild","form","iframe","createElement","insertAt","getElementsByTagName","insertBefore","head","body","appendChild","area","iframeId","className","position","top","left","setAttribute","complete","initIframe","html","action","submit","re","parts","authority","ipv6uri","JSONP","websocket","jsonp","forceJSONP","transports","transportOptions","writeBuffer","prevBufferLen","policyPort","rememberUpgrade","onlyBinaryUpgrades","perMessageDeflate","threshold","forceNode","isReactNative","product","localAddress","upgrades","pingInterval","pingTimeout","pingIntervalTimer","pingTimeoutTimer","priorWebsocketSuccess","createTransport","o","clone","EIO","transport","protocols","shift","setTransport","onDrain","probe","failed","onTransportOpen","upgradeLosesBinary","upgrading","flush","freezeTransport","onTransportClose","onupgrade","to","onHandshake","setPing","filterUpgrades","onHeartbeat","clearTimeout","sendPacket","waitForUpgrade","cleanupAndClose","desc","filteredUpgrades","eio","Backoff","reconnection","reconnectionAttempts","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","jitter","lastPing","packetBuffer","_parser","encoder","Encoder","decoder","Decoder","emitAll","updateSocketIds","generateId","engine","_reconnection","_reconnectionAttempts","_reconnectionDelay","setMin","_randomizationFactor","setJitter","_reconnectionDelayMax","setMax","_timeout","maybeReconnectOnOpen","attempts","skipReconnect","openSub","errorSub","timer","onping","onpong","ondata","add","ondecoded","onConnecting","processPacketQueue","subsLength","reset","delay","duration","onreconnect","attempt","BrowserWebSocket","NodeWebSocket","WebSocket","MozWebSocket","WebSocketImpl","WS","usingBrowserWebSocket","check","headers","ws","supports","addEventListeners","onmessage","toVal","mix","k","tmp","_extends","assign","_objectWithoutPropertiesLoose","excluded","sourceKeys","isNum","isBool","isStr","isFn","parseClassName","isToastIdValid","toastId","canUseDom","canBeRendered","content","POSITION","TOP_LEFT","TOP_RIGHT","TOP_CENTER","BOTTOM_LEFT","BOTTOM_RIGHT","BOTTOM_CENTER","TYPE","INFO","SUCCESS","WARNING","DEFAULT","cssTransition","_ref","enter","exit","_ref$appendPosition","appendPosition","_ref$collapse","collapse","_ref$collapseDuration","collapseDuration","_ref2","children","preventExitTransition","nodeRef","isIn","enterClassName","exitClassName","baseClassName","animationStep","onEntered","current","node","onExited","scrollHeight","requestAnimationFrame","minHeight","height","transition","padding","margin","collapseToast","onExit","Fragment","eventManager","Map","emitQueue","filter","cancelEmit","timers","_this","_len","_key","useKeeper","refresh","ref","reducer","state","staleId","_excluded","useToastContainer","props","forceUpdate","_useReducer2","toast","dispatch","containerRef","toastCount","queue","collection","toastKey","displayedToast","containerId","isToastActive","getToast","clearWaitingQueue","removeToast","dequeueToast","_queue$shift","appendToast","toastContent","toastProps","buildToast","_ref3","updateId","enableMultiContainer","isNotValid","closeToast","isNotAnUpdate","toastAutoClose","containerAutoClose","isLoading","theme","icon","closeButton","rtl","toastClassName","bodyClassName","toastStyle","bodyStyle","onClick","pauseOnHover","pauseOnFocusLoss","draggable","draggablePercent","draggableDirection","closeOnClick","progressClassName","progressStyle","autoClose","hideProgressBar","progress","role","deleteToast","queueLen","freeSlot","toDequeue","removeFromCollection","getToastToRender","toastToRender","toastList","newestOnTop","reverse","_toast","getX","targetTouches","clientX","getY","clientY","useToast","_useState","isRunning","setIsRunning","_useState2","setPreventExitTransition","toastRef","drag","delta","removalDistance","canCloseOnClick","canDrag","boundingRect","syncProps","onDragStart","getBoundingClientRect","nativeEvent","offsetWidth","offsetHeight","onDragTransitionEnd","_drag$boundingRect","bottom","right","pauseToast","playToast","onDragMove","transform","opacity","onDragEnd","hasFocus","bindFocusEvents","eventHandlers","onMouseDown","onTouchStart","onMouseUp","onTouchEnd","onMouseEnter","onMouseLeave","CloseButton","_ref$ariaLabel","ariaLabel","stopPropagation","viewBox","fillRule","ProgressBar","_cx","_animationEvent","hide","userStyle","controlledProgress","animationDuration","animationPlayState","defaultClassName","classNames","animationEvent","defaultProps","_excluded$1","width","Icons","info","warning","success","spinner","_cx2","_useToast","Transition","cssClasses","isProgressControlled","maybeIcon","iconProps","Icon","renderCloseButton","Bounce","_useToastContainer","getClassName","containerStyle","pointerEvents","latestInstance","containerDomNode","containerConfig","containers","lazy","generateToastId","random","getToastId","dispatchToast","mergeOptions","createToastByType","loading","promise","pending","render","resetParams","resolver","input","update","then","warn","dark","dismiss","isActive","container","oldOptions","oldContent","nextOptions","onChange","configure","config","containerInstance","item","support","viewClasses","isArrayBufferView","normalizeName","normalizeValue","iteratorFor","items","iterator","Headers","header","getOwnPropertyNames","consumed","bodyUsed","Promise","reject","fileReaderReady","reader","resolve","readBlobAsArrayBuffer","bufferClone","Body","_initBody","_bodyInit","_bodyText","isPrototypeOf","_bodyBlob","FormData","_bodyFormData","URLSearchParams","DataView","_bodyArrayBuffer","rejected","arrayBuffer","text","readAsText","readArrayBufferAsText","formData","oldValue","thisArg","values","entries","methods","upcased","credentials","mode","signal","toUpperCase","referrer","decodeURIComponent","Response","bodyInit","ok","statusText","redirectStatuses","redirect","DOMException","fetch","aborted","abortXhr","rawHeaders","getAllResponseHeaders","line","responseURL","ontimeout","onabort","polyfill","byteCount","byteIndex","stringFromCharCode","ucs2decode","extra","output","counter","checkScalarValue","createByte","encodeCodePoint","symbol","readContinuationByte","continuationByte","decodeSymbol","byte1","version","byteString","ucs2encode","encodeURIComponent","qs","qry","pairs","pair","lens","getLens","validLen","placeHoldersLen","Arr","_byteLength","curByte","revLookup","uint8","extraBytes","maxChunkLength","len2","encodeChunk","types","ERROR_PACKET","encodeAsString","payload","tryStringify","reconstructor","BinaryReconstructor","reconPack","writeEncoding","deconstruction","encodeAsBinary","tryParse","decodeString","takeBinaryData","finishedReconstruction","binData","abv","ii","alphabet","seed","now","decoded","IntersectionObserverEntry","intersectionRatio","registry","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","_observationTargets","some","element","nodeType","_registerInstance","entry","_monitorIntersections","_checkForIntersections","unobserve","_unmonitorIntersections","_unregisterInstance","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","sort","t","_parseRootMargin","opt_rootMargin","margins","unit","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","targetRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","time","performance","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","rect1","rect2","parent","getParentNode","atRoot","parentRect","parentComputedStyle","root","overflow","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","targetArea","intersectionArea","toFixed","opt_options","rootMargin","opt_useCapture","detatchEvent","child","assignedSlot","description","factor","rand","deviation"],"mappings":"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","file":"script/chunks/chunk.vendors~campaigns~default~info~login~mytradera~resolution~selling.c320a6d520.js","sourcesContent":["\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","\n/**\n * Gets the keys for an object.\n *\n * @return {Array} keys\n * @api private\n */\n\nmodule.exports = Object.keys || function keys (obj){\n  var arr = [];\n  var has = Object.prototype.hasOwnProperty;\n\n  for (var i in obj) {\n    if (has.call(obj, i)) {\n      arr.push(i);\n    }\n  }\n  return arr;\n};\n","\n/**\n * Module exports.\n *\n * Logic borrowed from Modernizr:\n *\n *   - https://github.com/Modernizr/Modernizr/blob/master/feature-detects/cors.js\n */\n\ntry {\n  module.exports = typeof XMLHttpRequest !== 'undefined' &&\n    'withCredentials' in new XMLHttpRequest();\n} catch (err) {\n  // if XMLHttp support is disabled in IE then it will throw\n  // when trying to create\n  module.exports = false;\n}\n","/**\r\n * Create a blob builder even when vendor prefixes exist\r\n */\r\n\r\nvar BlobBuilder = typeof BlobBuilder !== 'undefined' ? BlobBuilder :\r\n  typeof WebKitBlobBuilder !== 'undefined' ? WebKitBlobBuilder :\r\n  typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder :\r\n  typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : \r\n  false;\r\n\r\n/**\r\n * Check if Blob constructor is supported\r\n */\r\n\r\nvar blobSupported = (function() {\r\n  try {\r\n    var a = new Blob(['hi']);\r\n    return a.size === 2;\r\n  } catch(e) {\r\n    return false;\r\n  }\r\n})();\r\n\r\n/**\r\n * Check if Blob constructor supports ArrayBufferViews\r\n * Fails in Safari 6, so we need to map to ArrayBuffers there.\r\n */\r\n\r\nvar blobSupportsArrayBufferView = blobSupported && (function() {\r\n  try {\r\n    var b = new Blob([new Uint8Array([1,2])]);\r\n    return b.size === 2;\r\n  } catch(e) {\r\n    return false;\r\n  }\r\n})();\r\n\r\n/**\r\n * Check if BlobBuilder is supported\r\n */\r\n\r\nvar blobBuilderSupported = BlobBuilder\r\n  && BlobBuilder.prototype.append\r\n  && BlobBuilder.prototype.getBlob;\r\n\r\n/**\r\n * Helper function that maps ArrayBufferViews to ArrayBuffers\r\n * Used by BlobBuilder constructor and old browsers that didn't\r\n * support it in the Blob constructor.\r\n */\r\n\r\nfunction mapArrayBufferViews(ary) {\r\n  return ary.map(function(chunk) {\r\n    if (chunk.buffer instanceof ArrayBuffer) {\r\n      var buf = chunk.buffer;\r\n\r\n      // if this is a subarray, make a copy so we only\r\n      // include the subarray region from the underlying buffer\r\n      if (chunk.byteLength !== buf.byteLength) {\r\n        var copy = new Uint8Array(chunk.byteLength);\r\n        copy.set(new Uint8Array(buf, chunk.byteOffset, chunk.byteLength));\r\n        buf = copy.buffer;\r\n      }\r\n\r\n      return buf;\r\n    }\r\n\r\n    return chunk;\r\n  });\r\n}\r\n\r\nfunction BlobBuilderConstructor(ary, options) {\r\n  options = options || {};\r\n\r\n  var bb = new BlobBuilder();\r\n  mapArrayBufferViews(ary).forEach(function(part) {\r\n    bb.append(part);\r\n  });\r\n\r\n  return (options.type) ? bb.getBlob(options.type) : bb.getBlob();\r\n};\r\n\r\nfunction BlobConstructor(ary, options) {\r\n  return new Blob(mapArrayBufferViews(ary), options || {});\r\n};\r\n\r\nif (typeof Blob !== 'undefined') {\r\n  BlobBuilderConstructor.prototype = Blob.prototype;\r\n  BlobConstructor.prototype = Blob.prototype;\r\n}\r\n\r\nmodule.exports = (function() {\r\n  if (blobSupported) {\r\n    return blobSupportsArrayBufferView ? Blob : BlobConstructor;\r\n  } else if (blobBuilderSupported) {\r\n    return BlobBuilderConstructor;\r\n  } else {\r\n    return undefined;\r\n  }\r\n})();\r\n","// browser shim for xmlhttprequest module\n\nvar hasCORS = require('has-cors');\n\nmodule.exports = function (opts) {\n  var xdomain = opts.xdomain;\n\n  // scheme must be same when usign XDomainRequest\n  // http://blogs.msdn.com/b/ieinternals/archive/2010/05/13/xdomainrequest-restrictions-limitations-and-workarounds.aspx\n  var xscheme = opts.xscheme;\n\n  // XDomainRequest has a flow of not sending cookie, therefore it should be disabled as a default.\n  // https://github.com/Automattic/engine.io-client/pull/217\n  var enablesXDR = opts.enablesXDR;\n\n  // XMLHttpRequest can be disabled on IE\n  try {\n    if ('undefined' !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n      return new XMLHttpRequest();\n    }\n  } catch (e) { }\n\n  // Use XDomainRequest for IE8 if enablesXDR is true\n  // because loading bar keeps flashing when using jsonp-polling\n  // https://github.com/yujiosaka/socke.io-ie8-loading-example\n  try {\n    if ('undefined' !== typeof XDomainRequest && !xscheme && enablesXDR) {\n      return new XDomainRequest();\n    }\n  } catch (e) { }\n\n  if (!xdomain) {\n    try {\n      return new self[['Active'].concat('Object').join('X')]('Microsoft.XMLHTTP');\n    } catch (e) { }\n  }\n};\n","/* global attachEvent */\n\n/**\n * Module requirements.\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar Polling = require('./polling');\nvar Emitter = require('component-emitter');\nvar inherit = require('component-inherit');\nvar debug = require('debug')('engine.io-client:polling-xhr');\n\n/**\n * Module exports.\n */\n\nmodule.exports = XHR;\nmodule.exports.Request = Request;\n\n/**\n * Empty function\n */\n\nfunction empty () {}\n\n/**\n * XHR Polling constructor.\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction XHR (opts) {\n  Polling.call(this, opts);\n  this.requestTimeout = opts.requestTimeout;\n  this.extraHeaders = opts.extraHeaders;\n\n  if (typeof location !== 'undefined') {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    this.xd = (typeof location !== 'undefined' && opts.hostname !== location.hostname) ||\n      port !== opts.port;\n    this.xs = opts.secure !== isSSL;\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(XHR, Polling);\n\n/**\n * XHR supports binary\n */\n\nXHR.prototype.supportsBinary = true;\n\n/**\n * Creates a request.\n *\n * @param {String} method\n * @api private\n */\n\nXHR.prototype.request = function (opts) {\n  opts = opts || {};\n  opts.uri = this.uri();\n  opts.xd = this.xd;\n  opts.xs = this.xs;\n  opts.agent = this.agent || false;\n  opts.supportsBinary = this.supportsBinary;\n  opts.enablesXDR = this.enablesXDR;\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  opts.requestTimeout = this.requestTimeout;\n\n  // other options for Node.js client\n  opts.extraHeaders = this.extraHeaders;\n\n  return new Request(opts);\n};\n\n/**\n * Sends data.\n *\n * @param {String} data to send.\n * @param {Function} called upon flush.\n * @api private\n */\n\nXHR.prototype.doWrite = function (data, fn) {\n  var isBinary = typeof data !== 'string' && data !== undefined;\n  var req = this.request({ method: 'POST', data: data, isBinary: isBinary });\n  var self = this;\n  req.on('success', fn);\n  req.on('error', function (err) {\n    self.onError('xhr post error', err);\n  });\n  this.sendXhr = req;\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nXHR.prototype.doPoll = function () {\n  debug('xhr poll');\n  var req = this.request();\n  var self = this;\n  req.on('data', function (data) {\n    self.onData(data);\n  });\n  req.on('error', function (err) {\n    self.onError('xhr poll error', err);\n  });\n  this.pollXhr = req;\n};\n\n/**\n * Request constructor\n *\n * @param {Object} options\n * @api public\n */\n\nfunction Request (opts) {\n  this.method = opts.method || 'GET';\n  this.uri = opts.uri;\n  this.xd = !!opts.xd;\n  this.xs = !!opts.xs;\n  this.async = false !== opts.async;\n  this.data = undefined !== opts.data ? opts.data : null;\n  this.agent = opts.agent;\n  this.isBinary = opts.isBinary;\n  this.supportsBinary = opts.supportsBinary;\n  this.enablesXDR = opts.enablesXDR;\n  this.requestTimeout = opts.requestTimeout;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n\n  this.create();\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Request.prototype);\n\n/**\n * Creates the XHR object and sends the request.\n *\n * @api private\n */\n\nRequest.prototype.create = function () {\n  var opts = { agent: this.agent, xdomain: this.xd, xscheme: this.xs, enablesXDR: this.enablesXDR };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n\n  var xhr = this.xhr = new XMLHttpRequest(opts);\n  var self = this;\n\n  try {\n    debug('xhr open %s: %s', this.method, this.uri);\n    xhr.open(this.method, this.uri, this.async);\n    try {\n      if (this.extraHeaders) {\n        xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n        for (var i in this.extraHeaders) {\n          if (this.extraHeaders.hasOwnProperty(i)) {\n            xhr.setRequestHeader(i, this.extraHeaders[i]);\n          }\n        }\n      }\n    } catch (e) {}\n\n    if ('POST' === this.method) {\n      try {\n        if (this.isBinary) {\n          xhr.setRequestHeader('Content-type', 'application/octet-stream');\n        } else {\n          xhr.setRequestHeader('Content-type', 'text/plain;charset=UTF-8');\n        }\n      } catch (e) {}\n    }\n\n    try {\n      xhr.setRequestHeader('Accept', '*/*');\n    } catch (e) {}\n\n    // ie6 check\n    if ('withCredentials' in xhr) {\n      xhr.withCredentials = true;\n    }\n\n    if (this.requestTimeout) {\n      xhr.timeout = this.requestTimeout;\n    }\n\n    if (this.hasXDR()) {\n      xhr.onload = function () {\n        self.onLoad();\n      };\n      xhr.onerror = function () {\n        self.onError(xhr.responseText);\n      };\n    } else {\n      xhr.onreadystatechange = function () {\n        if (xhr.readyState === 2) {\n          try {\n            var contentType = xhr.getResponseHeader('Content-Type');\n            if (self.supportsBinary && contentType === 'application/octet-stream') {\n              xhr.responseType = 'arraybuffer';\n            }\n          } catch (e) {}\n        }\n        if (4 !== xhr.readyState) return;\n        if (200 === xhr.status || 1223 === xhr.status) {\n          self.onLoad();\n        } else {\n          // make sure the `error` event handler that's user-set\n          // does not throw in the same tick and gets caught here\n          setTimeout(function () {\n            self.onError(xhr.status);\n          }, 0);\n        }\n      };\n    }\n\n    debug('xhr data %s', this.data);\n    xhr.send(this.data);\n  } catch (e) {\n    // Need to defer since .create() is called directly fhrom the constructor\n    // and thus the 'error' event can only be only bound *after* this exception\n    // occurs.  Therefore, also, we cannot throw here at all.\n    setTimeout(function () {\n      self.onError(e);\n    }, 0);\n    return;\n  }\n\n  if (typeof document !== 'undefined') {\n    this.index = Request.requestsCount++;\n    Request.requests[this.index] = this;\n  }\n};\n\n/**\n * Called upon successful response.\n *\n * @api private\n */\n\nRequest.prototype.onSuccess = function () {\n  this.emit('success');\n  this.cleanup();\n};\n\n/**\n * Called if we have data.\n *\n * @api private\n */\n\nRequest.prototype.onData = function (data) {\n  this.emit('data', data);\n  this.onSuccess();\n};\n\n/**\n * Called upon error.\n *\n * @api private\n */\n\nRequest.prototype.onError = function (err) {\n  this.emit('error', err);\n  this.cleanup(true);\n};\n\n/**\n * Cleans up house.\n *\n * @api private\n */\n\nRequest.prototype.cleanup = function (fromError) {\n  if ('undefined' === typeof this.xhr || null === this.xhr) {\n    return;\n  }\n  // xmlhttprequest\n  if (this.hasXDR()) {\n    this.xhr.onload = this.xhr.onerror = empty;\n  } else {\n    this.xhr.onreadystatechange = empty;\n  }\n\n  if (fromError) {\n    try {\n      this.xhr.abort();\n    } catch (e) {}\n  }\n\n  if (typeof document !== 'undefined') {\n    delete Request.requests[this.index];\n  }\n\n  this.xhr = null;\n};\n\n/**\n * Called upon load.\n *\n * @api private\n */\n\nRequest.prototype.onLoad = function () {\n  var data;\n  try {\n    var contentType;\n    try {\n      contentType = this.xhr.getResponseHeader('Content-Type');\n    } catch (e) {}\n    if (contentType === 'application/octet-stream') {\n      data = this.xhr.response || this.xhr.responseText;\n    } else {\n      data = this.xhr.responseText;\n    }\n  } catch (e) {\n    this.onError(e);\n  }\n  if (null != data) {\n    this.onData(data);\n  }\n};\n\n/**\n * Check if it has XDomainRequest.\n *\n * @api private\n */\n\nRequest.prototype.hasXDR = function () {\n  return typeof XDomainRequest !== 'undefined' && !this.xs && this.enablesXDR;\n};\n\n/**\n * Aborts the request.\n *\n * @api public\n */\n\nRequest.prototype.abort = function () {\n  this.cleanup();\n};\n\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\n\nRequest.requestsCount = 0;\nRequest.requests = {};\n\nif (typeof document !== 'undefined') {\n  if (typeof attachEvent === 'function') {\n    attachEvent('onunload', unloadHandler);\n  } else if (typeof addEventListener === 'function') {\n    var terminationEvent = 'onpagehide' in self ? 'pagehide' : 'unload';\n    addEventListener(terminationEvent, unloadHandler, false);\n  }\n}\n\nfunction unloadHandler () {\n  for (var i in Request.requests) {\n    if (Request.requests.hasOwnProperty(i)) {\n      Request.requests[i].abort();\n    }\n  }\n}\n","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parseqs = require('parseqs');\nvar parser = require('engine.io-parser');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:polling');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Polling;\n\n/**\n * Is XHR2 supported?\n */\n\nvar hasXHR2 = (function () {\n  var XMLHttpRequest = require('xmlhttprequest-ssl');\n  var xhr = new XMLHttpRequest({ xdomain: false });\n  return null != xhr.responseType;\n})();\n\n/**\n * Polling interface.\n *\n * @param {Object} opts\n * @api private\n */\n\nfunction Polling (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (!hasXHR2 || forceBase64) {\n    this.supportsBinary = false;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(Polling, Transport);\n\n/**\n * Transport name.\n */\n\nPolling.prototype.name = 'polling';\n\n/**\n * Opens the socket (triggers polling). We write a PING message to determine\n * when the transport is open.\n *\n * @api private\n */\n\nPolling.prototype.doOpen = function () {\n  this.poll();\n};\n\n/**\n * Pauses polling.\n *\n * @param {Function} callback upon buffers are flushed and transport is paused\n * @api private\n */\n\nPolling.prototype.pause = function (onPause) {\n  var self = this;\n\n  this.readyState = 'pausing';\n\n  function pause () {\n    debug('paused');\n    self.readyState = 'paused';\n    onPause();\n  }\n\n  if (this.polling || !this.writable) {\n    var total = 0;\n\n    if (this.polling) {\n      debug('we are currently polling - waiting to pause');\n      total++;\n      this.once('pollComplete', function () {\n        debug('pre-pause polling complete');\n        --total || pause();\n      });\n    }\n\n    if (!this.writable) {\n      debug('we are currently writing - waiting to pause');\n      total++;\n      this.once('drain', function () {\n        debug('pre-pause writing complete');\n        --total || pause();\n      });\n    }\n  } else {\n    pause();\n  }\n};\n\n/**\n * Starts polling cycle.\n *\n * @api public\n */\n\nPolling.prototype.poll = function () {\n  debug('polling');\n  this.polling = true;\n  this.doPoll();\n  this.emit('poll');\n};\n\n/**\n * Overloads onData to detect payloads.\n *\n * @api private\n */\n\nPolling.prototype.onData = function (data) {\n  var self = this;\n  debug('polling got data %s', data);\n  var callback = function (packet, index, total) {\n    // if its the first message we consider the transport open\n    if ('opening' === self.readyState) {\n      self.onOpen();\n    }\n\n    // if its a close packet, we close the ongoing requests\n    if ('close' === packet.type) {\n      self.onClose();\n      return false;\n    }\n\n    // otherwise bypass onData and handle the message\n    self.onPacket(packet);\n  };\n\n  // decode payload\n  parser.decodePayload(data, this.socket.binaryType, callback);\n\n  // if an event did not trigger closing\n  if ('closed' !== this.readyState) {\n    // if we got data we're not polling\n    this.polling = false;\n    this.emit('pollComplete');\n\n    if ('open' === this.readyState) {\n      this.poll();\n    } else {\n      debug('ignoring poll - transport state \"%s\"', this.readyState);\n    }\n  }\n};\n\n/**\n * For polling, send a close packet.\n *\n * @api private\n */\n\nPolling.prototype.doClose = function () {\n  var self = this;\n\n  function close () {\n    debug('writing close packet');\n    self.write([{ type: 'close' }]);\n  }\n\n  if ('open' === this.readyState) {\n    debug('transport open - closing');\n    close();\n  } else {\n    // in case we're trying to close while\n    // handshaking is in progress (GH-164)\n    debug('transport not open - deferring close');\n    this.once('open', close);\n  }\n};\n\n/**\n * Writes a packets payload.\n *\n * @param {Array} data packets\n * @param {Function} drain callback\n * @api private\n */\n\nPolling.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n  var callbackfn = function () {\n    self.writable = true;\n    self.emit('drain');\n  };\n\n  parser.encodePayload(packets, this.supportsBinary, function (data) {\n    self.doWrite(data, callbackfn);\n  });\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nPolling.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'https' : 'http';\n  var port = '';\n\n  // cache busting is forced\n  if (false !== this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  if (!this.supportsBinary && !query.sid) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // avoid port if default for schema\n  if (this.port && (('https' === schema && Number(this.port) !== 443) ||\n     ('http' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\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/**\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","/**\n * Module dependencies.\n */\n\nvar keys = require('./keys');\nvar hasBinary = require('has-binary2');\nvar sliceBuffer = require('arraybuffer.slice');\nvar after = require('after');\nvar utf8 = require('./utf8');\n\nvar base64encoder;\nif (typeof ArrayBuffer !== 'undefined') {\n  base64encoder = require('base64-arraybuffer');\n}\n\n/**\n * Check if we are running an android browser. That requires us to use\n * ArrayBuffer with polling transports...\n *\n * http://ghinda.net/jpeg-blob-ajax-android/\n */\n\nvar isAndroid = typeof navigator !== 'undefined' && /Android/i.test(navigator.userAgent);\n\n/**\n * Check if we are running in PhantomJS.\n * Uploading a Blob with PhantomJS does not work correctly, as reported here:\n * https://github.com/ariya/phantomjs/issues/11395\n * @type boolean\n */\nvar isPhantomJS = typeof navigator !== 'undefined' && /PhantomJS/i.test(navigator.userAgent);\n\n/**\n * When true, avoids using Blobs to encode payloads.\n * @type boolean\n */\nvar dontSendBlobs = isAndroid || isPhantomJS;\n\n/**\n * Current protocol version.\n */\n\nexports.protocol = 3;\n\n/**\n * Packet types.\n */\n\nvar packets = exports.packets = {\n    open:     0    // non-ws\n  , close:    1    // non-ws\n  , ping:     2\n  , pong:     3\n  , message:  4\n  , upgrade:  5\n  , noop:     6\n};\n\nvar packetslist = keys(packets);\n\n/**\n * Premade error packet.\n */\n\nvar err = { type: 'error', data: 'parser error' };\n\n/**\n * Create a blob api even for blob builder when vendor prefixes exist\n */\n\nvar Blob = require('blob');\n\n/**\n * Encodes a packet.\n *\n *     <packet type id> [ <data> ]\n *\n * Example:\n *\n *     5hello world\n *     3\n *     4\n *\n * Binary is encoded in an identical principle\n *\n * @api private\n */\n\nexports.encodePacket = function (packet, supportsBinary, utf8encode, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = false;\n  }\n\n  if (typeof utf8encode === 'function') {\n    callback = utf8encode;\n    utf8encode = null;\n  }\n\n  var data = (packet.data === undefined)\n    ? undefined\n    : packet.data.buffer || packet.data;\n\n  if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer) {\n    return encodeArrayBuffer(packet, supportsBinary, callback);\n  } else if (typeof Blob !== 'undefined' && data instanceof Blob) {\n    return encodeBlob(packet, supportsBinary, callback);\n  }\n\n  // might be an object with { base64: true, data: dataAsBase64String }\n  if (data && data.base64) {\n    return encodeBase64Object(packet, callback);\n  }\n\n  // Sending data as a utf-8 string\n  var encoded = packets[packet.type];\n\n  // data fragment is optional\n  if (undefined !== packet.data) {\n    encoded += utf8encode ? utf8.encode(String(packet.data), { strict: false }) : String(packet.data);\n  }\n\n  return callback('' + encoded);\n\n};\n\nfunction encodeBase64Object(packet, callback) {\n  // packet data is an object { base64: true, data: dataAsBase64String }\n  var message = 'b' + exports.packets[packet.type] + packet.data.data;\n  return callback(message);\n}\n\n/**\n * Encode packet helpers for binary types\n */\n\nfunction encodeArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var data = packet.data;\n  var contentArray = new Uint8Array(data);\n  var resultBuffer = new Uint8Array(1 + data.byteLength);\n\n  resultBuffer[0] = packets[packet.type];\n  for (var i = 0; i < contentArray.length; i++) {\n    resultBuffer[i+1] = contentArray[i];\n  }\n\n  return callback(resultBuffer.buffer);\n}\n\nfunction encodeBlobAsArrayBuffer(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  var fr = new FileReader();\n  fr.onload = function() {\n    exports.encodePacket({ type: packet.type, data: fr.result }, supportsBinary, true, callback);\n  };\n  return fr.readAsArrayBuffer(packet.data);\n}\n\nfunction encodeBlob(packet, supportsBinary, callback) {\n  if (!supportsBinary) {\n    return exports.encodeBase64Packet(packet, callback);\n  }\n\n  if (dontSendBlobs) {\n    return encodeBlobAsArrayBuffer(packet, supportsBinary, callback);\n  }\n\n  var length = new Uint8Array(1);\n  length[0] = packets[packet.type];\n  var blob = new Blob([length.buffer, packet.data]);\n\n  return callback(blob);\n}\n\n/**\n * Encodes a packet with binary data in a base64 string\n *\n * @param {Object} packet, has `type` and `data`\n * @return {String} base64 encoded message\n */\n\nexports.encodeBase64Packet = function(packet, callback) {\n  var message = 'b' + exports.packets[packet.type];\n  if (typeof Blob !== 'undefined' && packet.data instanceof Blob) {\n    var fr = new FileReader();\n    fr.onload = function() {\n      var b64 = fr.result.split(',')[1];\n      callback(message + b64);\n    };\n    return fr.readAsDataURL(packet.data);\n  }\n\n  var b64data;\n  try {\n    b64data = String.fromCharCode.apply(null, new Uint8Array(packet.data));\n  } catch (e) {\n    // iPhone Safari doesn't let you apply with typed arrays\n    var typed = new Uint8Array(packet.data);\n    var basic = new Array(typed.length);\n    for (var i = 0; i < typed.length; i++) {\n      basic[i] = typed[i];\n    }\n    b64data = String.fromCharCode.apply(null, basic);\n  }\n  message += btoa(b64data);\n  return callback(message);\n};\n\n/**\n * Decodes a packet. Changes format to Blob if requested.\n *\n * @return {Object} with `type` and `data` (if any)\n * @api private\n */\n\nexports.decodePacket = function (data, binaryType, utf8decode) {\n  if (data === undefined) {\n    return err;\n  }\n  // String data\n  if (typeof data === 'string') {\n    if (data.charAt(0) === 'b') {\n      return exports.decodeBase64Packet(data.substr(1), binaryType);\n    }\n\n    if (utf8decode) {\n      data = tryDecode(data);\n      if (data === false) {\n        return err;\n      }\n    }\n    var type = data.charAt(0);\n\n    if (Number(type) != type || !packetslist[type]) {\n      return err;\n    }\n\n    if (data.length > 1) {\n      return { type: packetslist[type], data: data.substring(1) };\n    } else {\n      return { type: packetslist[type] };\n    }\n  }\n\n  var asArray = new Uint8Array(data);\n  var type = asArray[0];\n  var rest = sliceBuffer(data, 1);\n  if (Blob && binaryType === 'blob') {\n    rest = new Blob([rest]);\n  }\n  return { type: packetslist[type], data: rest };\n};\n\nfunction tryDecode(data) {\n  try {\n    data = utf8.decode(data, { strict: false });\n  } catch (e) {\n    return false;\n  }\n  return data;\n}\n\n/**\n * Decodes a packet encoded in a base64 string\n *\n * @param {String} base64 encoded message\n * @return {Object} with `type` and `data` (if any)\n */\n\nexports.decodeBase64Packet = function(msg, binaryType) {\n  var type = packetslist[msg.charAt(0)];\n  if (!base64encoder) {\n    return { type: type, data: { base64: true, data: msg.substr(1) } };\n  }\n\n  var data = base64encoder.decode(msg.substr(1));\n\n  if (binaryType === 'blob' && Blob) {\n    data = new Blob([data]);\n  }\n\n  return { type: type, data: data };\n};\n\n/**\n * Encodes multiple messages (payload).\n *\n *     <length>:data\n *\n * Example:\n *\n *     11:hello world2:hi\n *\n * If any contents are binary, they will be encoded as base64 strings. Base64\n * encoded strings are marked with a b before the length specifier\n *\n * @param {Array} packets\n * @api private\n */\n\nexports.encodePayload = function (packets, supportsBinary, callback) {\n  if (typeof supportsBinary === 'function') {\n    callback = supportsBinary;\n    supportsBinary = null;\n  }\n\n  var isBinary = hasBinary(packets);\n\n  if (supportsBinary && isBinary) {\n    if (Blob && !dontSendBlobs) {\n      return exports.encodePayloadAsBlob(packets, callback);\n    }\n\n    return exports.encodePayloadAsArrayBuffer(packets, callback);\n  }\n\n  if (!packets.length) {\n    return callback('0:');\n  }\n\n  function setLengthHeader(message) {\n    return message.length + ':' + message;\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, !isBinary ? false : supportsBinary, false, function(message) {\n      doneCallback(null, setLengthHeader(message));\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(results.join(''));\n  });\n};\n\n/**\n * Async array map using after\n */\n\nfunction map(ary, each, done) {\n  var result = new Array(ary.length);\n  var next = after(ary.length, done);\n\n  var eachWithIndex = function(i, el, cb) {\n    each(el, function(error, msg) {\n      result[i] = msg;\n      cb(error, result);\n    });\n  };\n\n  for (var i = 0; i < ary.length; i++) {\n    eachWithIndex(i, ary[i], next);\n  }\n}\n\n/*\n * Decodes data when a payload is maybe expected. Possible binary contents are\n * decoded from their base64 representation\n *\n * @param {String} data, callback method\n * @api public\n */\n\nexports.decodePayload = function (data, binaryType, callback) {\n  if (typeof data !== 'string') {\n    return exports.decodePayloadAsBinary(data, binaryType, callback);\n  }\n\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var packet;\n  if (data === '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n  var length = '', n, msg;\n\n  for (var i = 0, l = data.length; i < l; i++) {\n    var chr = data.charAt(i);\n\n    if (chr !== ':') {\n      length += chr;\n      continue;\n    }\n\n    if (length === '' || (length != (n = Number(length)))) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    msg = data.substr(i + 1, n);\n\n    if (length != msg.length) {\n      // parser error - ignoring payload\n      return callback(err, 0, 1);\n    }\n\n    if (msg.length) {\n      packet = exports.decodePacket(msg, binaryType, false);\n\n      if (err.type === packet.type && err.data === packet.data) {\n        // parser error in individual packet - ignoring payload\n        return callback(err, 0, 1);\n      }\n\n      var ret = callback(packet, i + n, l);\n      if (false === ret) return;\n    }\n\n    // advance cursor\n    i += n;\n    length = '';\n  }\n\n  if (length !== '') {\n    // parser error - ignoring payload\n    return callback(err, 0, 1);\n  }\n\n};\n\n/**\n * Encodes multiple messages (payload) as binary.\n *\n * <1 = binary, 0 = string><number from 0-9><number from 0-9>[...]<number\n * 255><data>\n *\n * Example:\n * 1 3 255 1 2 3, if the binary contents are interpreted as 8 bit integers\n *\n * @param {Array} packets\n * @return {ArrayBuffer} encoded payload\n * @api private\n */\n\nexports.encodePayloadAsArrayBuffer = function(packets, callback) {\n  if (!packets.length) {\n    return callback(new ArrayBuffer(0));\n  }\n\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(data) {\n      return doneCallback(null, data);\n    });\n  }\n\n  map(packets, encodeOne, function(err, encodedPackets) {\n    var totalLength = encodedPackets.reduce(function(acc, p) {\n      var len;\n      if (typeof p === 'string'){\n        len = p.length;\n      } else {\n        len = p.byteLength;\n      }\n      return acc + len.toString().length + len + 2; // string/binary identifier + separator = 2\n    }, 0);\n\n    var resultArray = new Uint8Array(totalLength);\n\n    var bufferIndex = 0;\n    encodedPackets.forEach(function(p) {\n      var isString = typeof p === 'string';\n      var ab = p;\n      if (isString) {\n        var view = new Uint8Array(p.length);\n        for (var i = 0; i < p.length; i++) {\n          view[i] = p.charCodeAt(i);\n        }\n        ab = view.buffer;\n      }\n\n      if (isString) { // not true binary\n        resultArray[bufferIndex++] = 0;\n      } else { // true binary\n        resultArray[bufferIndex++] = 1;\n      }\n\n      var lenStr = ab.byteLength.toString();\n      for (var i = 0; i < lenStr.length; i++) {\n        resultArray[bufferIndex++] = parseInt(lenStr[i]);\n      }\n      resultArray[bufferIndex++] = 255;\n\n      var view = new Uint8Array(ab);\n      for (var i = 0; i < view.length; i++) {\n        resultArray[bufferIndex++] = view[i];\n      }\n    });\n\n    return callback(resultArray.buffer);\n  });\n};\n\n/**\n * Encode as Blob\n */\n\nexports.encodePayloadAsBlob = function(packets, callback) {\n  function encodeOne(packet, doneCallback) {\n    exports.encodePacket(packet, true, true, function(encoded) {\n      var binaryIdentifier = new Uint8Array(1);\n      binaryIdentifier[0] = 1;\n      if (typeof encoded === 'string') {\n        var view = new Uint8Array(encoded.length);\n        for (var i = 0; i < encoded.length; i++) {\n          view[i] = encoded.charCodeAt(i);\n        }\n        encoded = view.buffer;\n        binaryIdentifier[0] = 0;\n      }\n\n      var len = (encoded instanceof ArrayBuffer)\n        ? encoded.byteLength\n        : encoded.size;\n\n      var lenStr = len.toString();\n      var lengthAry = new Uint8Array(lenStr.length + 1);\n      for (var i = 0; i < lenStr.length; i++) {\n        lengthAry[i] = parseInt(lenStr[i]);\n      }\n      lengthAry[lenStr.length] = 255;\n\n      if (Blob) {\n        var blob = new Blob([binaryIdentifier.buffer, lengthAry.buffer, encoded]);\n        doneCallback(null, blob);\n      }\n    });\n  }\n\n  map(packets, encodeOne, function(err, results) {\n    return callback(new Blob(results));\n  });\n};\n\n/*\n * Decodes data when a payload is maybe expected. Strings are decoded by\n * interpreting each byte as a key code for entries marked to start with 0. See\n * description of encodePayloadAsBinary\n *\n * @param {ArrayBuffer} data, callback method\n * @api public\n */\n\nexports.decodePayloadAsBinary = function (data, binaryType, callback) {\n  if (typeof binaryType === 'function') {\n    callback = binaryType;\n    binaryType = null;\n  }\n\n  var bufferTail = data;\n  var buffers = [];\n\n  while (bufferTail.byteLength > 0) {\n    var tailArray = new Uint8Array(bufferTail);\n    var isString = tailArray[0] === 0;\n    var msgLength = '';\n\n    for (var i = 1; ; i++) {\n      if (tailArray[i] === 255) break;\n\n      // 310 = char length of Number.MAX_VALUE\n      if (msgLength.length > 310) {\n        return callback(err, 0, 1);\n      }\n\n      msgLength += tailArray[i];\n    }\n\n    bufferTail = sliceBuffer(bufferTail, 2 + msgLength.length);\n    msgLength = parseInt(msgLength);\n\n    var msg = sliceBuffer(bufferTail, 0, msgLength);\n    if (isString) {\n      try {\n        msg = String.fromCharCode.apply(null, new Uint8Array(msg));\n      } catch (e) {\n        // iPhone Safari doesn't let you apply to typed arrays\n        var typed = new Uint8Array(msg);\n        msg = '';\n        for (var i = 0; i < typed.length; i++) {\n          msg += String.fromCharCode(typed[i]);\n        }\n      }\n    }\n\n    buffers.push(msg);\n    bufferTail = sliceBuffer(bufferTail, msgLength);\n  }\n\n  var total = buffers.length;\n  buffers.forEach(function(buffer, i) {\n    callback(exports.decodePacket(buffer, binaryType, true), i, total);\n  });\n};\n","/*\n * base64-arraybuffer\n * https://github.com/niklasvh/base64-arraybuffer\n *\n * Copyright (c) 2012 Niklas von Hertzen\n * Licensed under the MIT license.\n */\n(function(){\n  \"use strict\";\n\n  var chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n\n  // Use a lookup table to find the index.\n  var lookup = new Uint8Array(256);\n  for (var i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n  }\n\n  exports.encode = function(arraybuffer) {\n    var bytes = new Uint8Array(arraybuffer),\n    i, len = bytes.length, base64 = \"\";\n\n    for (i = 0; i < len; i+=3) {\n      base64 += chars[bytes[i] >> 2];\n      base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n      base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n      base64 += chars[bytes[i + 2] & 63];\n    }\n\n    if ((len % 3) === 2) {\n      base64 = base64.substring(0, base64.length - 1) + \"=\";\n    } else if (len % 3 === 1) {\n      base64 = base64.substring(0, base64.length - 2) + \"==\";\n    }\n\n    return base64;\n  };\n\n  exports.decode =  function(base64) {\n    var bufferLength = base64.length * 0.75,\n    len = base64.length, i, p = 0,\n    encoded1, encoded2, encoded3, encoded4;\n\n    if (base64[base64.length - 1] === \"=\") {\n      bufferLength--;\n      if (base64[base64.length - 2] === \"=\") {\n        bufferLength--;\n      }\n    }\n\n    var arraybuffer = new ArrayBuffer(bufferLength),\n    bytes = new Uint8Array(arraybuffer);\n\n    for (i = 0; i < len; i+=4) {\n      encoded1 = lookup[base64.charCodeAt(i)];\n      encoded2 = lookup[base64.charCodeAt(i+1)];\n      encoded3 = lookup[base64.charCodeAt(i+2)];\n      encoded4 = lookup[base64.charCodeAt(i+3)];\n\n      bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n      bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n      bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n\n    return arraybuffer;\n  };\n})();\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 * 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","\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","\nvar indexOf = [].indexOf;\n\nmodule.exports = function(arr, obj){\n  if (indexOf) return arr.indexOf(obj);\n  for (var i = 0; i < arr.length; ++i) {\n    if (arr[i] === obj) return i;\n  }\n  return -1;\n};","\nmodule.exports = function(a, b){\n  var fn = function(){};\n  fn.prototype = b.prototype;\n  a.prototype = new fn;\n  a.prototype.constructor = a;\n};","// Polyfill for creating CustomEvents on IE9/10/11\n\n// code pulled from:\n// https://github.com/d4tocchini/customevent-polyfill\n// https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent#Polyfill\n\n(function() {\n  if (typeof window === 'undefined') {\n    return;\n  }\n\n  try {\n    var ce = new window.CustomEvent('test', { cancelable: true });\n    ce.preventDefault();\n    if (ce.defaultPrevented !== true) {\n      // IE has problems with .preventDefault() on custom events\n      // http://stackoverflow.com/questions/23349191\n      throw new Error('Could not prevent default');\n    }\n  } catch (e) {\n    var CustomEvent = function(event, params) {\n      var evt, origPrevent;\n      params = params || {};\n      params.bubbles = !!params.bubbles;\n      params.cancelable = !!params.cancelable;\n\n      evt = document.createEvent('CustomEvent');\n      evt.initCustomEvent(\n        event,\n        params.bubbles,\n        params.cancelable,\n        params.detail\n      );\n      origPrevent = evt.preventDefault;\n      evt.preventDefault = function() {\n        origPrevent.call(this);\n        try {\n          Object.defineProperty(this, 'defaultPrevented', {\n            get: function() {\n              return true;\n            }\n          });\n        } catch (e) {\n          this.defaultPrevented = true;\n        }\n      };\n      return evt;\n    };\n\n    CustomEvent.prototype = window.Event.prototype;\n    window.CustomEvent = CustomEvent; // expose definition to window\n  }\n})();\n","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","module.exports = after\n\nfunction after(count, callback, err_cb) {\n    var bail = false\n    err_cb = err_cb || noop\n    proxy.count = count\n\n    return (count === 0) ? callback() : proxy\n\n    function proxy(err, result) {\n        if (proxy.count <= 0) {\n            throw new Error('after called too many times')\n        }\n        --proxy.count\n\n        // after first error, rest are passed to err_cb\n        if (err) {\n            bail = true\n            callback(err)\n            // future error callbacks will go to error handler\n            callback = err_cb\n        } else if (proxy.count === 0 && !bail) {\n            callback(null, result)\n        }\n    }\n}\n\nfunction noop() {}\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","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\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/**\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","\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","/**\n * Module requirements.\n */\n\nvar Polling = require('./polling');\nvar inherit = require('component-inherit');\n\n/**\n * Module exports.\n */\n\nmodule.exports = JSONPPolling;\n\n/**\n * Cached regular expressions.\n */\n\nvar rNewline = /\\n/g;\nvar rEscapedNewline = /\\\\n/g;\n\n/**\n * Global JSONP callbacks.\n */\n\nvar callbacks;\n\n/**\n * Noop.\n */\n\nfunction empty () { }\n\n/**\n * Until https://github.com/tc39/proposal-global is shipped.\n */\nfunction glob () {\n  return typeof self !== 'undefined' ? self\n      : typeof window !== 'undefined' ? window\n      : typeof global !== 'undefined' ? global : {};\n}\n\n/**\n * JSONP Polling constructor.\n *\n * @param {Object} opts.\n * @api public\n */\n\nfunction JSONPPolling (opts) {\n  Polling.call(this, opts);\n\n  this.query = this.query || {};\n\n  // define global callbacks array if not present\n  // we do this here (lazily) to avoid unneeded global pollution\n  if (!callbacks) {\n    // we need to consider multiple engines in the same page\n    var global = glob();\n    callbacks = global.___eio = (global.___eio || []);\n  }\n\n  // callback identifier\n  this.index = callbacks.length;\n\n  // add callback to jsonp global\n  var self = this;\n  callbacks.push(function (msg) {\n    self.onData(msg);\n  });\n\n  // append to query string\n  this.query.j = this.index;\n\n  // prevent spurious errors from being emitted when the window is unloaded\n  if (typeof addEventListener === 'function') {\n    addEventListener('beforeunload', function () {\n      if (self.script) self.script.onerror = empty;\n    }, false);\n  }\n}\n\n/**\n * Inherits from Polling.\n */\n\ninherit(JSONPPolling, Polling);\n\n/*\n * JSONP only supports binary as base64 encoded strings\n */\n\nJSONPPolling.prototype.supportsBinary = false;\n\n/**\n * Closes the socket.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doClose = function () {\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  if (this.form) {\n    this.form.parentNode.removeChild(this.form);\n    this.form = null;\n    this.iframe = null;\n  }\n\n  Polling.prototype.doClose.call(this);\n};\n\n/**\n * Starts a poll cycle.\n *\n * @api private\n */\n\nJSONPPolling.prototype.doPoll = function () {\n  var self = this;\n  var script = document.createElement('script');\n\n  if (this.script) {\n    this.script.parentNode.removeChild(this.script);\n    this.script = null;\n  }\n\n  script.async = true;\n  script.src = this.uri();\n  script.onerror = function (e) {\n    self.onError('jsonp poll error', e);\n  };\n\n  var insertAt = document.getElementsByTagName('script')[0];\n  if (insertAt) {\n    insertAt.parentNode.insertBefore(script, insertAt);\n  } else {\n    (document.head || document.body).appendChild(script);\n  }\n  this.script = script;\n\n  var isUAgecko = 'undefined' !== typeof navigator && /gecko/i.test(navigator.userAgent);\n\n  if (isUAgecko) {\n    setTimeout(function () {\n      var iframe = document.createElement('iframe');\n      document.body.appendChild(iframe);\n      document.body.removeChild(iframe);\n    }, 100);\n  }\n};\n\n/**\n * Writes with a hidden iframe.\n *\n * @param {String} data to send\n * @param {Function} called upon flush.\n * @api private\n */\n\nJSONPPolling.prototype.doWrite = function (data, fn) {\n  var self = this;\n\n  if (!this.form) {\n    var form = document.createElement('form');\n    var area = document.createElement('textarea');\n    var id = this.iframeId = 'eio_iframe_' + this.index;\n    var iframe;\n\n    form.className = 'socketio';\n    form.style.position = 'absolute';\n    form.style.top = '-1000px';\n    form.style.left = '-1000px';\n    form.target = id;\n    form.method = 'POST';\n    form.setAttribute('accept-charset', 'utf-8');\n    area.name = 'd';\n    form.appendChild(area);\n    document.body.appendChild(form);\n\n    this.form = form;\n    this.area = area;\n  }\n\n  this.form.action = this.uri();\n\n  function complete () {\n    initIframe();\n    fn();\n  }\n\n  function initIframe () {\n    if (self.iframe) {\n      try {\n        self.form.removeChild(self.iframe);\n      } catch (e) {\n        self.onError('jsonp polling iframe removal error', e);\n      }\n    }\n\n    try {\n      // ie6 dynamic iframes with target=\"\" support (thanks Chris Lambacher)\n      var html = '<iframe src=\"javascript:0\" name=\"' + self.iframeId + '\">';\n      iframe = document.createElement(html);\n    } catch (e) {\n      iframe = document.createElement('iframe');\n      iframe.name = self.iframeId;\n      iframe.src = 'javascript:0';\n    }\n\n    iframe.id = self.iframeId;\n\n    self.form.appendChild(iframe);\n    self.iframe = iframe;\n  }\n\n  initIframe();\n\n  // escape \\n to prevent it from being converted into \\r\\n by some UAs\n  // double escaping is required for escaped new lines because unescaping of new lines can be done safely on server-side\n  data = data.replace(rEscapedNewline, '\\\\\\n');\n  this.area.value = data.replace(rNewline, '\\\\n');\n\n  try {\n    this.form.submit();\n  } catch (e) {}\n\n  if (this.iframe.attachEvent) {\n    this.iframe.onreadystatechange = function () {\n      if (self.iframe.readyState === 'complete') {\n        complete();\n      }\n    };\n  } else {\n    this.iframe.onload = complete;\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 toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\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","/**\r\n * Parses an URI\r\n *\r\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\r\n * @api private\r\n */\r\n\r\nvar re = /^(?:(?![^:@]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\r\n\r\nvar parts = [\r\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\r\n];\r\n\r\nmodule.exports = function parseuri(str) {\r\n    var src = str,\r\n        b = str.indexOf('['),\r\n        e = str.indexOf(']');\r\n\r\n    if (b != -1 && e != -1) {\r\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\r\n    }\r\n\r\n    var m = re.exec(str || ''),\r\n        uri = {},\r\n        i = 14;\r\n\r\n    while (i--) {\r\n        uri[parts[i]] = m[i] || '';\r\n    }\r\n\r\n    if (b != -1 && e != -1) {\r\n        uri.source = src;\r\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\r\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\r\n        uri.ipv6uri = true;\r\n    }\r\n\r\n    return uri;\r\n};\r\n","/**\n * Module dependencies\n */\n\nvar XMLHttpRequest = require('xmlhttprequest-ssl');\nvar XHR = require('./polling-xhr');\nvar JSONP = require('./polling-jsonp');\nvar websocket = require('./websocket');\n\n/**\n * Export transports.\n */\n\nexports.polling = polling;\nexports.websocket = websocket;\n\n/**\n * Polling transport polymorphic constructor.\n * Decides on xhr vs jsonp based on feature detection.\n *\n * @api private\n */\n\nfunction polling (opts) {\n  var xhr;\n  var xd = false;\n  var xs = false;\n  var jsonp = false !== opts.jsonp;\n\n  if (typeof location !== 'undefined') {\n    var isSSL = 'https:' === location.protocol;\n    var port = location.port;\n\n    // some user agents have empty `location.port`\n    if (!port) {\n      port = isSSL ? 443 : 80;\n    }\n\n    xd = opts.hostname !== location.hostname || port !== opts.port;\n    xs = opts.secure !== isSSL;\n  }\n\n  opts.xdomain = xd;\n  opts.xscheme = xs;\n  xhr = new XMLHttpRequest(opts);\n\n  if ('open' in xhr && !opts.forceJSONP) {\n    return new XHR(opts);\n  } else {\n    if (!jsonp) throw new Error('JSONP disabled');\n    return new JSONP(opts);\n  }\n}\n","/**\n * Module dependencies.\n */\n\nvar transports = require('./transports/index');\nvar Emitter = require('component-emitter');\nvar debug = require('debug')('engine.io-client:socket');\nvar index = require('indexof');\nvar parser = require('engine.io-parser');\nvar parseuri = require('parseuri');\nvar parseqs = require('parseqs');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Socket;\n\n/**\n * Socket constructor.\n *\n * @param {String|Object} uri or options\n * @param {Object} options\n * @api public\n */\n\nfunction Socket (uri, opts) {\n  if (!(this instanceof Socket)) return new Socket(uri, opts);\n\n  opts = opts || {};\n\n  if (uri && 'object' === typeof uri) {\n    opts = uri;\n    uri = null;\n  }\n\n  if (uri) {\n    uri = parseuri(uri);\n    opts.hostname = uri.host;\n    opts.secure = uri.protocol === 'https' || uri.protocol === 'wss';\n    opts.port = uri.port;\n    if (uri.query) opts.query = uri.query;\n  } else if (opts.host) {\n    opts.hostname = parseuri(opts.host).host;\n  }\n\n  this.secure = null != opts.secure ? opts.secure\n    : (typeof location !== 'undefined' && 'https:' === location.protocol);\n\n  if (opts.hostname && !opts.port) {\n    // if no port is specified manually, use the protocol default\n    opts.port = this.secure ? '443' : '80';\n  }\n\n  this.agent = opts.agent || false;\n  this.hostname = opts.hostname ||\n    (typeof location !== 'undefined' ? location.hostname : 'localhost');\n  this.port = opts.port || (typeof location !== 'undefined' && location.port\n      ? location.port\n      : (this.secure ? 443 : 80));\n  this.query = opts.query || {};\n  if ('string' === typeof this.query) this.query = parseqs.decode(this.query);\n  this.upgrade = false !== opts.upgrade;\n  this.path = (opts.path || '/engine.io').replace(/\\/$/, '') + '/';\n  this.forceJSONP = !!opts.forceJSONP;\n  this.jsonp = false !== opts.jsonp;\n  this.forceBase64 = !!opts.forceBase64;\n  this.enablesXDR = !!opts.enablesXDR;\n  this.timestampParam = opts.timestampParam || 't';\n  this.timestampRequests = opts.timestampRequests;\n  this.transports = opts.transports || ['polling', 'websocket'];\n  this.transportOptions = opts.transportOptions || {};\n  this.readyState = '';\n  this.writeBuffer = [];\n  this.prevBufferLen = 0;\n  this.policyPort = opts.policyPort || 843;\n  this.rememberUpgrade = opts.rememberUpgrade || false;\n  this.binaryType = null;\n  this.onlyBinaryUpgrades = opts.onlyBinaryUpgrades;\n  this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || {}) : false;\n\n  if (true === this.perMessageDeflate) this.perMessageDeflate = {};\n  if (this.perMessageDeflate && null == this.perMessageDeflate.threshold) {\n    this.perMessageDeflate.threshold = 1024;\n  }\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx || null;\n  this.key = opts.key || null;\n  this.passphrase = opts.passphrase || null;\n  this.cert = opts.cert || null;\n  this.ca = opts.ca || null;\n  this.ciphers = opts.ciphers || null;\n  this.rejectUnauthorized = opts.rejectUnauthorized === undefined ? true : opts.rejectUnauthorized;\n  this.forceNode = !!opts.forceNode;\n\n  // detect ReactNative environment\n  this.isReactNative = (typeof navigator !== 'undefined' && typeof navigator.product === 'string' && navigator.product.toLowerCase() === 'reactnative');\n\n  // other options for Node.js or ReactNative client\n  if (typeof self === 'undefined' || this.isReactNative) {\n    if (opts.extraHeaders && Object.keys(opts.extraHeaders).length > 0) {\n      this.extraHeaders = opts.extraHeaders;\n    }\n\n    if (opts.localAddress) {\n      this.localAddress = opts.localAddress;\n    }\n  }\n\n  // set on handshake\n  this.id = null;\n  this.upgrades = null;\n  this.pingInterval = null;\n  this.pingTimeout = null;\n\n  // set on heartbeat\n  this.pingIntervalTimer = null;\n  this.pingTimeoutTimer = null;\n\n  this.open();\n}\n\nSocket.priorWebsocketSuccess = false;\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Socket.prototype);\n\n/**\n * Protocol version.\n *\n * @api public\n */\n\nSocket.protocol = parser.protocol; // this is an int\n\n/**\n * Expose deps for legacy compatibility\n * and standalone browser access.\n */\n\nSocket.Socket = Socket;\nSocket.Transport = require('./transport');\nSocket.transports = require('./transports/index');\nSocket.parser = require('engine.io-parser');\n\n/**\n * Creates transport of the given type.\n *\n * @param {String} transport name\n * @return {Transport}\n * @api private\n */\n\nSocket.prototype.createTransport = function (name) {\n  debug('creating transport \"%s\"', name);\n  var query = clone(this.query);\n\n  // append engine.io protocol identifier\n  query.EIO = parser.protocol;\n\n  // transport name\n  query.transport = name;\n\n  // per-transport options\n  var options = this.transportOptions[name] || {};\n\n  // session id if we already have one\n  if (this.id) query.sid = this.id;\n\n  var transport = new transports[name]({\n    query: query,\n    socket: this,\n    agent: options.agent || this.agent,\n    hostname: options.hostname || this.hostname,\n    port: options.port || this.port,\n    secure: options.secure || this.secure,\n    path: options.path || this.path,\n    forceJSONP: options.forceJSONP || this.forceJSONP,\n    jsonp: options.jsonp || this.jsonp,\n    forceBase64: options.forceBase64 || this.forceBase64,\n    enablesXDR: options.enablesXDR || this.enablesXDR,\n    timestampRequests: options.timestampRequests || this.timestampRequests,\n    timestampParam: options.timestampParam || this.timestampParam,\n    policyPort: options.policyPort || this.policyPort,\n    pfx: options.pfx || this.pfx,\n    key: options.key || this.key,\n    passphrase: options.passphrase || this.passphrase,\n    cert: options.cert || this.cert,\n    ca: options.ca || this.ca,\n    ciphers: options.ciphers || this.ciphers,\n    rejectUnauthorized: options.rejectUnauthorized || this.rejectUnauthorized,\n    perMessageDeflate: options.perMessageDeflate || this.perMessageDeflate,\n    extraHeaders: options.extraHeaders || this.extraHeaders,\n    forceNode: options.forceNode || this.forceNode,\n    localAddress: options.localAddress || this.localAddress,\n    requestTimeout: options.requestTimeout || this.requestTimeout,\n    protocols: options.protocols || void (0),\n    isReactNative: this.isReactNative\n  });\n\n  return transport;\n};\n\nfunction clone (obj) {\n  var o = {};\n  for (var i in obj) {\n    if (obj.hasOwnProperty(i)) {\n      o[i] = obj[i];\n    }\n  }\n  return o;\n}\n\n/**\n * Initializes transport to use and starts probe.\n *\n * @api private\n */\nSocket.prototype.open = function () {\n  var transport;\n  if (this.rememberUpgrade && Socket.priorWebsocketSuccess && this.transports.indexOf('websocket') !== -1) {\n    transport = 'websocket';\n  } else if (0 === this.transports.length) {\n    // Emit error on next tick so it can be listened to\n    var self = this;\n    setTimeout(function () {\n      self.emit('error', 'No transports available');\n    }, 0);\n    return;\n  } else {\n    transport = this.transports[0];\n  }\n  this.readyState = 'opening';\n\n  // Retry with the next transport if the transport is disabled (jsonp: false)\n  try {\n    transport = this.createTransport(transport);\n  } catch (e) {\n    this.transports.shift();\n    this.open();\n    return;\n  }\n\n  transport.open();\n  this.setTransport(transport);\n};\n\n/**\n * Sets the current transport. Disables the existing one (if any).\n *\n * @api private\n */\n\nSocket.prototype.setTransport = function (transport) {\n  debug('setting transport %s', transport.name);\n  var self = this;\n\n  if (this.transport) {\n    debug('clearing existing transport %s', this.transport.name);\n    this.transport.removeAllListeners();\n  }\n\n  // set up transport\n  this.transport = transport;\n\n  // set up transport listeners\n  transport\n  .on('drain', function () {\n    self.onDrain();\n  })\n  .on('packet', function (packet) {\n    self.onPacket(packet);\n  })\n  .on('error', function (e) {\n    self.onError(e);\n  })\n  .on('close', function () {\n    self.onClose('transport close');\n  });\n};\n\n/**\n * Probes a transport.\n *\n * @param {String} transport name\n * @api private\n */\n\nSocket.prototype.probe = function (name) {\n  debug('probing transport \"%s\"', name);\n  var transport = this.createTransport(name, { probe: 1 });\n  var failed = false;\n  var self = this;\n\n  Socket.priorWebsocketSuccess = false;\n\n  function onTransportOpen () {\n    if (self.onlyBinaryUpgrades) {\n      var upgradeLosesBinary = !this.supportsBinary && self.transport.supportsBinary;\n      failed = failed || upgradeLosesBinary;\n    }\n    if (failed) return;\n\n    debug('probe transport \"%s\" opened', name);\n    transport.send([{ type: 'ping', data: 'probe' }]);\n    transport.once('packet', function (msg) {\n      if (failed) return;\n      if ('pong' === msg.type && 'probe' === msg.data) {\n        debug('probe transport \"%s\" pong', name);\n        self.upgrading = true;\n        self.emit('upgrading', transport);\n        if (!transport) return;\n        Socket.priorWebsocketSuccess = 'websocket' === transport.name;\n\n        debug('pausing current transport \"%s\"', self.transport.name);\n        self.transport.pause(function () {\n          if (failed) return;\n          if ('closed' === self.readyState) return;\n          debug('changing transport and sending upgrade packet');\n\n          cleanup();\n\n          self.setTransport(transport);\n          transport.send([{ type: 'upgrade' }]);\n          self.emit('upgrade', transport);\n          transport = null;\n          self.upgrading = false;\n          self.flush();\n        });\n      } else {\n        debug('probe transport \"%s\" failed', name);\n        var err = new Error('probe error');\n        err.transport = transport.name;\n        self.emit('upgradeError', err);\n      }\n    });\n  }\n\n  function freezeTransport () {\n    if (failed) return;\n\n    // Any callback called by transport should be ignored since now\n    failed = true;\n\n    cleanup();\n\n    transport.close();\n    transport = null;\n  }\n\n  // Handle any error that happens while probing\n  function onerror (err) {\n    var error = new Error('probe error: ' + err);\n    error.transport = transport.name;\n\n    freezeTransport();\n\n    debug('probe transport \"%s\" failed because of error: %s', name, err);\n\n    self.emit('upgradeError', error);\n  }\n\n  function onTransportClose () {\n    onerror('transport closed');\n  }\n\n  // When the socket is closed while we're probing\n  function onclose () {\n    onerror('socket closed');\n  }\n\n  // When the socket is upgraded while we're probing\n  function onupgrade (to) {\n    if (transport && to.name !== transport.name) {\n      debug('\"%s\" works - aborting \"%s\"', to.name, transport.name);\n      freezeTransport();\n    }\n  }\n\n  // Remove all listeners on the transport and on self\n  function cleanup () {\n    transport.removeListener('open', onTransportOpen);\n    transport.removeListener('error', onerror);\n    transport.removeListener('close', onTransportClose);\n    self.removeListener('close', onclose);\n    self.removeListener('upgrading', onupgrade);\n  }\n\n  transport.once('open', onTransportOpen);\n  transport.once('error', onerror);\n  transport.once('close', onTransportClose);\n\n  this.once('close', onclose);\n  this.once('upgrading', onupgrade);\n\n  transport.open();\n};\n\n/**\n * Called when connection is deemed open.\n *\n * @api public\n */\n\nSocket.prototype.onOpen = function () {\n  debug('socket open');\n  this.readyState = 'open';\n  Socket.priorWebsocketSuccess = 'websocket' === this.transport.name;\n  this.emit('open');\n  this.flush();\n\n  // we check for `readyState` in case an `open`\n  // listener already closed the socket\n  if ('open' === this.readyState && this.upgrade && this.transport.pause) {\n    debug('starting upgrade probes');\n    for (var i = 0, l = this.upgrades.length; i < l; i++) {\n      this.probe(this.upgrades[i]);\n    }\n  }\n};\n\n/**\n * Handles a packet.\n *\n * @api private\n */\n\nSocket.prototype.onPacket = function (packet) {\n  if ('opening' === this.readyState || 'open' === this.readyState ||\n      'closing' === this.readyState) {\n    debug('socket receive: type \"%s\", data \"%s\"', packet.type, packet.data);\n\n    this.emit('packet', packet);\n\n    // Socket is live - any packet counts\n    this.emit('heartbeat');\n\n    switch (packet.type) {\n      case 'open':\n        this.onHandshake(JSON.parse(packet.data));\n        break;\n\n      case 'pong':\n        this.setPing();\n        this.emit('pong');\n        break;\n\n      case 'error':\n        var err = new Error('server error');\n        err.code = packet.data;\n        this.onError(err);\n        break;\n\n      case 'message':\n        this.emit('data', packet.data);\n        this.emit('message', packet.data);\n        break;\n    }\n  } else {\n    debug('packet received with socket readyState \"%s\"', this.readyState);\n  }\n};\n\n/**\n * Called upon handshake completion.\n *\n * @param {Object} handshake obj\n * @api private\n */\n\nSocket.prototype.onHandshake = function (data) {\n  this.emit('handshake', data);\n  this.id = data.sid;\n  this.transport.query.sid = data.sid;\n  this.upgrades = this.filterUpgrades(data.upgrades);\n  this.pingInterval = data.pingInterval;\n  this.pingTimeout = data.pingTimeout;\n  this.onOpen();\n  // In case open handler closes socket\n  if ('closed' === this.readyState) return;\n  this.setPing();\n\n  // Prolong liveness of socket on heartbeat\n  this.removeListener('heartbeat', this.onHeartbeat);\n  this.on('heartbeat', this.onHeartbeat);\n};\n\n/**\n * Resets ping timeout.\n *\n * @api private\n */\n\nSocket.prototype.onHeartbeat = function (timeout) {\n  clearTimeout(this.pingTimeoutTimer);\n  var self = this;\n  self.pingTimeoutTimer = setTimeout(function () {\n    if ('closed' === self.readyState) return;\n    self.onClose('ping timeout');\n  }, timeout || (self.pingInterval + self.pingTimeout));\n};\n\n/**\n * Pings server every `this.pingInterval` and expects response\n * within `this.pingTimeout` or closes connection.\n *\n * @api private\n */\n\nSocket.prototype.setPing = function () {\n  var self = this;\n  clearTimeout(self.pingIntervalTimer);\n  self.pingIntervalTimer = setTimeout(function () {\n    debug('writing ping packet - expecting pong within %sms', self.pingTimeout);\n    self.ping();\n    self.onHeartbeat(self.pingTimeout);\n  }, self.pingInterval);\n};\n\n/**\n* Sends a ping packet.\n*\n* @api private\n*/\n\nSocket.prototype.ping = function () {\n  var self = this;\n  this.sendPacket('ping', function () {\n    self.emit('ping');\n  });\n};\n\n/**\n * Called on `drain` event\n *\n * @api private\n */\n\nSocket.prototype.onDrain = function () {\n  this.writeBuffer.splice(0, this.prevBufferLen);\n\n  // setting prevBufferLen = 0 is very important\n  // for example, when upgrading, upgrade packet is sent over,\n  // and a nonzero prevBufferLen could cause problems on `drain`\n  this.prevBufferLen = 0;\n\n  if (0 === this.writeBuffer.length) {\n    this.emit('drain');\n  } else {\n    this.flush();\n  }\n};\n\n/**\n * Flush write buffers.\n *\n * @api private\n */\n\nSocket.prototype.flush = function () {\n  if ('closed' !== this.readyState && this.transport.writable &&\n    !this.upgrading && this.writeBuffer.length) {\n    debug('flushing %d packets in socket', this.writeBuffer.length);\n    this.transport.send(this.writeBuffer);\n    // keep track of current length of writeBuffer\n    // splice writeBuffer and callbackBuffer on `drain`\n    this.prevBufferLen = this.writeBuffer.length;\n    this.emit('flush');\n  }\n};\n\n/**\n * Sends a message.\n *\n * @param {String} message.\n * @param {Function} callback function.\n * @param {Object} options.\n * @return {Socket} for chaining.\n * @api public\n */\n\nSocket.prototype.write =\nSocket.prototype.send = function (msg, options, fn) {\n  this.sendPacket('message', msg, options, fn);\n  return this;\n};\n\n/**\n * Sends a packet.\n *\n * @param {String} packet type.\n * @param {String} data.\n * @param {Object} options.\n * @param {Function} callback function.\n * @api private\n */\n\nSocket.prototype.sendPacket = function (type, data, options, fn) {\n  if ('function' === typeof data) {\n    fn = data;\n    data = undefined;\n  }\n\n  if ('function' === typeof options) {\n    fn = options;\n    options = null;\n  }\n\n  if ('closing' === this.readyState || 'closed' === this.readyState) {\n    return;\n  }\n\n  options = options || {};\n  options.compress = false !== options.compress;\n\n  var packet = {\n    type: type,\n    data: data,\n    options: options\n  };\n  this.emit('packetCreate', packet);\n  this.writeBuffer.push(packet);\n  if (fn) this.once('flush', fn);\n  this.flush();\n};\n\n/**\n * Closes the connection.\n *\n * @api private\n */\n\nSocket.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.readyState = 'closing';\n\n    var self = this;\n\n    if (this.writeBuffer.length) {\n      this.once('drain', function () {\n        if (this.upgrading) {\n          waitForUpgrade();\n        } else {\n          close();\n        }\n      });\n    } else if (this.upgrading) {\n      waitForUpgrade();\n    } else {\n      close();\n    }\n  }\n\n  function close () {\n    self.onClose('forced close');\n    debug('socket closing - telling transport to close');\n    self.transport.close();\n  }\n\n  function cleanupAndClose () {\n    self.removeListener('upgrade', cleanupAndClose);\n    self.removeListener('upgradeError', cleanupAndClose);\n    close();\n  }\n\n  function waitForUpgrade () {\n    // wait for upgrade to finish since we can't send packets while pausing a transport\n    self.once('upgrade', cleanupAndClose);\n    self.once('upgradeError', cleanupAndClose);\n  }\n\n  return this;\n};\n\n/**\n * Called upon transport error\n *\n * @api private\n */\n\nSocket.prototype.onError = function (err) {\n  debug('socket error %j', err);\n  Socket.priorWebsocketSuccess = false;\n  this.emit('error', err);\n  this.onClose('transport error', err);\n};\n\n/**\n * Called upon transport close.\n *\n * @api private\n */\n\nSocket.prototype.onClose = function (reason, desc) {\n  if ('opening' === this.readyState || 'open' === this.readyState || 'closing' === this.readyState) {\n    debug('socket close with reason: \"%s\"', reason);\n    var self = this;\n\n    // clear timers\n    clearTimeout(this.pingIntervalTimer);\n    clearTimeout(this.pingTimeoutTimer);\n\n    // stop event from firing again for transport\n    this.transport.removeAllListeners('close');\n\n    // ensure transport won't stay open\n    this.transport.close();\n\n    // ignore further transport communication\n    this.transport.removeAllListeners();\n\n    // set ready state\n    this.readyState = 'closed';\n\n    // clear session id\n    this.id = null;\n\n    // emit close event\n    this.emit('close', reason, desc);\n\n    // clean buffers after, so users can still\n    // grab the buffers on `close` event\n    self.writeBuffer = [];\n    self.prevBufferLen = 0;\n  }\n};\n\n/**\n * Filters upgrades, returning only those matching client transports.\n *\n * @param {Array} server upgrades\n * @api private\n *\n */\n\nSocket.prototype.filterUpgrades = function (upgrades) {\n  var filteredUpgrades = [];\n  for (var i = 0, j = upgrades.length; i < j; i++) {\n    if (~index(this.transports, upgrades[i])) filteredUpgrades.push(upgrades[i]);\n  }\n  return filteredUpgrades;\n};\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","\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","/**\n * Module dependencies.\n */\n\nvar Transport = require('../transport');\nvar parser = require('engine.io-parser');\nvar parseqs = require('parseqs');\nvar inherit = require('component-inherit');\nvar yeast = require('yeast');\nvar debug = require('debug')('engine.io-client:websocket');\n\nvar BrowserWebSocket, NodeWebSocket;\n\nif (typeof WebSocket !== 'undefined') {\n  BrowserWebSocket = WebSocket;\n} else if (typeof self !== 'undefined') {\n  BrowserWebSocket = self.WebSocket || self.MozWebSocket;\n} else {\n  try {\n    NodeWebSocket = require('ws');\n  } catch (e) { }\n}\n\n/**\n * Get either the `WebSocket` or `MozWebSocket` globals\n * in the browser or try to resolve WebSocket-compatible\n * interface exposed by `ws` for Node-like environment.\n */\n\nvar WebSocketImpl = BrowserWebSocket || NodeWebSocket;\n\n/**\n * Module exports.\n */\n\nmodule.exports = WS;\n\n/**\n * WebSocket transport constructor.\n *\n * @api {Object} connection options\n * @api public\n */\n\nfunction WS (opts) {\n  var forceBase64 = (opts && opts.forceBase64);\n  if (forceBase64) {\n    this.supportsBinary = false;\n  }\n  this.perMessageDeflate = opts.perMessageDeflate;\n  this.usingBrowserWebSocket = BrowserWebSocket && !opts.forceNode;\n  this.protocols = opts.protocols;\n  if (!this.usingBrowserWebSocket) {\n    WebSocketImpl = NodeWebSocket;\n  }\n  Transport.call(this, opts);\n}\n\n/**\n * Inherits from Transport.\n */\n\ninherit(WS, Transport);\n\n/**\n * Transport name.\n *\n * @api public\n */\n\nWS.prototype.name = 'websocket';\n\n/*\n * WebSockets support binary\n */\n\nWS.prototype.supportsBinary = true;\n\n/**\n * Opens socket.\n *\n * @api private\n */\n\nWS.prototype.doOpen = function () {\n  if (!this.check()) {\n    // let probe timeout\n    return;\n  }\n\n  var uri = this.uri();\n  var protocols = this.protocols;\n  var opts = {\n    agent: this.agent,\n    perMessageDeflate: this.perMessageDeflate\n  };\n\n  // SSL options for Node.js client\n  opts.pfx = this.pfx;\n  opts.key = this.key;\n  opts.passphrase = this.passphrase;\n  opts.cert = this.cert;\n  opts.ca = this.ca;\n  opts.ciphers = this.ciphers;\n  opts.rejectUnauthorized = this.rejectUnauthorized;\n  if (this.extraHeaders) {\n    opts.headers = this.extraHeaders;\n  }\n  if (this.localAddress) {\n    opts.localAddress = this.localAddress;\n  }\n\n  try {\n    this.ws =\n      this.usingBrowserWebSocket && !this.isReactNative\n        ? protocols\n          ? new WebSocketImpl(uri, protocols)\n          : new WebSocketImpl(uri)\n        : new WebSocketImpl(uri, protocols, opts);\n  } catch (err) {\n    return this.emit('error', err);\n  }\n\n  if (this.ws.binaryType === undefined) {\n    this.supportsBinary = false;\n  }\n\n  if (this.ws.supports && this.ws.supports.binary) {\n    this.supportsBinary = true;\n    this.ws.binaryType = 'nodebuffer';\n  } else {\n    this.ws.binaryType = 'arraybuffer';\n  }\n\n  this.addEventListeners();\n};\n\n/**\n * Adds event listeners to the socket\n *\n * @api private\n */\n\nWS.prototype.addEventListeners = function () {\n  var self = this;\n\n  this.ws.onopen = function () {\n    self.onOpen();\n  };\n  this.ws.onclose = function () {\n    self.onClose();\n  };\n  this.ws.onmessage = function (ev) {\n    self.onData(ev.data);\n  };\n  this.ws.onerror = function (e) {\n    self.onError('websocket error', e);\n  };\n};\n\n/**\n * Writes data to socket.\n *\n * @param {Array} array of packets.\n * @api private\n */\n\nWS.prototype.write = function (packets) {\n  var self = this;\n  this.writable = false;\n\n  // encodePacket efficient as it uses WS framing\n  // no need for encodePayload\n  var total = packets.length;\n  for (var i = 0, l = total; i < l; i++) {\n    (function (packet) {\n      parser.encodePacket(packet, self.supportsBinary, function (data) {\n        if (!self.usingBrowserWebSocket) {\n          // always create a new object (GH-437)\n          var opts = {};\n          if (packet.options) {\n            opts.compress = packet.options.compress;\n          }\n\n          if (self.perMessageDeflate) {\n            var len = 'string' === typeof data ? Buffer.byteLength(data) : data.length;\n            if (len < self.perMessageDeflate.threshold) {\n              opts.compress = false;\n            }\n          }\n        }\n\n        // Sometimes the websocket has already been closed but the browser didn't\n        // have a chance of informing us about it yet, in that case send will\n        // throw an error\n        try {\n          if (self.usingBrowserWebSocket) {\n            // TypeError is thrown when passing the second argument on Safari\n            self.ws.send(data);\n          } else {\n            self.ws.send(data, opts);\n          }\n        } catch (e) {\n          debug('websocket closed before onclose event');\n        }\n\n        --total || done();\n      });\n    })(packets[i]);\n  }\n\n  function done () {\n    self.emit('flush');\n\n    // fake drain\n    // defer to next tick to allow Socket to clear writeBuffer\n    setTimeout(function () {\n      self.writable = true;\n      self.emit('drain');\n    }, 0);\n  }\n};\n\n/**\n * Called upon close\n *\n * @api private\n */\n\nWS.prototype.onClose = function () {\n  Transport.prototype.onClose.call(this);\n};\n\n/**\n * Closes socket.\n *\n * @api private\n */\n\nWS.prototype.doClose = function () {\n  if (typeof this.ws !== 'undefined') {\n    this.ws.close();\n  }\n};\n\n/**\n * Generates uri for connection.\n *\n * @api private\n */\n\nWS.prototype.uri = function () {\n  var query = this.query || {};\n  var schema = this.secure ? 'wss' : 'ws';\n  var port = '';\n\n  // avoid port if default for schema\n  if (this.port && (('wss' === schema && Number(this.port) !== 443) ||\n    ('ws' === schema && Number(this.port) !== 80))) {\n    port = ':' + this.port;\n  }\n\n  // append timestamp to URI\n  if (this.timestampRequests) {\n    query[this.timestampParam] = yeast();\n  }\n\n  // communicate binary support capabilities\n  if (!this.supportsBinary) {\n    query.b64 = 1;\n  }\n\n  query = parseqs.encode(query);\n\n  // prepend ? to query\n  if (query.length) {\n    query = '?' + query;\n  }\n\n  var ipv6 = this.hostname.indexOf(':') !== -1;\n  return schema + '://' + (ipv6 ? '[' + this.hostname + ']' : this.hostname) + port + this.path + query;\n};\n\n/**\n * Feature detection for WebSocket.\n *\n * @return {Boolean} whether this transport is available.\n * @api public\n */\n\nWS.prototype.check = function () {\n  return !!WebSocketImpl && !('__initialize' in WebSocketImpl && this.name === WS.prototype.name);\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","function toVal(mix) {\n\tvar k, y, str='';\n\n\tif (typeof mix === 'string' || typeof mix === 'number') {\n\t\tstr += mix;\n\t} else if (typeof mix === 'object') {\n\t\tif (Array.isArray(mix)) {\n\t\t\tfor (k=0; k < mix.length; k++) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tif (y = toVal(mix[k])) {\n\t\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\t\tstr += y;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor (k in mix) {\n\t\t\t\tif (mix[k]) {\n\t\t\t\t\tstr && (str += ' ');\n\t\t\t\t\tstr += k;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn str;\n}\n\nexport default function () {\n\tvar i=0, tmp, x, str='';\n\twhile (i < arguments.length) {\n\t\tif (tmp = arguments[i++]) {\n\t\t\tif (x = toVal(tmp)) {\n\t\t\t\tstr && (str += ' ');\n\t\t\t\tstr += x\n\t\t\t}\n\t\t}\n\t}\n\treturn str;\n}\n","import React__default, { isValidElement, useRef, useLayoutEffect, useEffect, useReducer, cloneElement, useState, createElement } from 'react';\nimport cx from 'clsx';\nimport { render } from 'react-dom';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction isNum(v) {\n  return typeof v === 'number' && !isNaN(v);\n}\nfunction isBool(v) {\n  return typeof v === 'boolean';\n}\nfunction isStr(v) {\n  return typeof v === 'string';\n}\nfunction isFn(v) {\n  return typeof v === 'function';\n}\nfunction parseClassName(v) {\n  return isStr(v) || isFn(v) ? v : null;\n}\nfunction isToastIdValid(toastId) {\n  return toastId === 0 || toastId;\n}\nfunction getAutoCloseDelay(toastAutoClose, containerAutoClose) {\n  return toastAutoClose === false || isNum(toastAutoClose) && toastAutoClose > 0 ? toastAutoClose : containerAutoClose;\n}\nvar canUseDom = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction canBeRendered(content) {\n  return isValidElement(content) || isStr(content) || isFn(content) || isNum(content);\n}\n\nvar POSITION = {\n  TOP_LEFT: 'top-left',\n  TOP_RIGHT: 'top-right',\n  TOP_CENTER: 'top-center',\n  BOTTOM_LEFT: 'bottom-left',\n  BOTTOM_RIGHT: 'bottom-right',\n  BOTTOM_CENTER: 'bottom-center'\n};\nvar TYPE = {\n  INFO: 'info',\n  SUCCESS: 'success',\n  WARNING: 'warning',\n  ERROR: 'error',\n  DEFAULT: 'default'\n};\n\n/**\r\n * Used to collapse toast after exit animation\r\n */\nfunction collapseToast(node, done, duration\n/* COLLAPSE_DURATION */\n) {\n  if (duration === void 0) {\n    duration = 300;\n  }\n\n  var scrollHeight = node.scrollHeight,\n      style = node.style;\n  requestAnimationFrame(function () {\n    style.minHeight = 'initial';\n    style.height = scrollHeight + 'px';\n    style.transition = \"all \" + duration + \"ms\";\n    requestAnimationFrame(function () {\n      style.height = '0';\n      style.padding = '0';\n      style.margin = '0';\n      setTimeout(done, duration);\n    });\n  });\n}\n\n/**\r\n * Css animation that just work.\r\n * You could use animate.css for instance\r\n *\r\n *\r\n * ```\r\n * cssTransition({\r\n *   enter: \"animate__animated animate__bounceIn\",\r\n *   exit: \"animate__animated animate__bounceOut\"\r\n * })\r\n * ```\r\n *\r\n */\n\nfunction cssTransition(_ref) {\n  var enter = _ref.enter,\n      exit = _ref.exit,\n      _ref$appendPosition = _ref.appendPosition,\n      appendPosition = _ref$appendPosition === void 0 ? false : _ref$appendPosition,\n      _ref$collapse = _ref.collapse,\n      collapse = _ref$collapse === void 0 ? true : _ref$collapse,\n      _ref$collapseDuration = _ref.collapseDuration,\n      collapseDuration = _ref$collapseDuration === void 0 ? 300 : _ref$collapseDuration;\n  return function ToastTransition(_ref2) {\n    var children = _ref2.children,\n        position = _ref2.position,\n        preventExitTransition = _ref2.preventExitTransition,\n        done = _ref2.done,\n        nodeRef = _ref2.nodeRef,\n        isIn = _ref2.isIn;\n    var enterClassName = appendPosition ? enter + \"--\" + position : enter;\n    var exitClassName = appendPosition ? exit + \"--\" + position : exit;\n    var baseClassName = useRef();\n    var animationStep = useRef(0\n    /* Enter */\n    );\n    useLayoutEffect(function () {\n      onEnter();\n    }, []);\n    useEffect(function () {\n      if (!isIn) preventExitTransition ? onExited() : onExit();\n    }, [isIn]);\n\n    function onEnter() {\n      var node = nodeRef.current;\n      baseClassName.current = node.className;\n      node.className += \" \" + enterClassName;\n      node.addEventListener('animationend', onEntered);\n    }\n\n    function onEntered(e) {\n      if (e.target !== nodeRef.current) return;\n      var node = nodeRef.current;\n      node.removeEventListener('animationend', onEntered);\n\n      if (animationStep.current === 0\n      /* Enter */\n      ) {\n          node.className = baseClassName.current;\n        }\n    }\n\n    function onExit() {\n      animationStep.current = 1\n      /* Exit */\n      ;\n      var node = nodeRef.current;\n      node.className += \" \" + exitClassName;\n      node.addEventListener('animationend', onExited);\n    }\n\n    function onExited() {\n      var node = nodeRef.current;\n      node.removeEventListener('animationend', onExited);\n      collapse ? collapseToast(node, done, collapseDuration) : done();\n    }\n\n    return React__default.createElement(React__default.Fragment, null, children);\n  };\n}\n\nvar eventManager = {\n  list: /*#__PURE__*/new Map(),\n  emitQueue: /*#__PURE__*/new Map(),\n  on: function on(event, callback) {\n    this.list.has(event) || this.list.set(event, []);\n    this.list.get(event).push(callback);\n    return this;\n  },\n  off: function off(event, callback) {\n    if (callback) {\n      var cb = this.list.get(event).filter(function (cb) {\n        return cb !== callback;\n      });\n      this.list.set(event, cb);\n      return this;\n    }\n\n    this.list[\"delete\"](event);\n    return this;\n  },\n  cancelEmit: function cancelEmit(event) {\n    var timers = this.emitQueue.get(event);\n\n    if (timers) {\n      timers.forEach(clearTimeout);\n      this.emitQueue[\"delete\"](event);\n    }\n\n    return this;\n  },\n\n  /**\r\n   * Enqueue the event at the end of the call stack\r\n   * Doing so let the user call toast as follow:\r\n   * toast('1')\r\n   * toast('2')\r\n   * toast('3')\r\n   * Without setTimemout the code above will not work\r\n   */\n  emit: function emit(event) {\n    var _this = this;\n\n    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      args[_key - 1] = arguments[_key];\n    }\n\n    this.list.has(event) && this.list.get(event).forEach(function (callback) {\n      var timer = setTimeout(function () {\n        // @ts-ignore\n        callback.apply(void 0, args);\n      }, 0);\n      _this.emitQueue.has(event) || _this.emitQueue.set(event, []);\n\n      _this.emitQueue.get(event).push(timer);\n    });\n  }\n};\n\n/**\r\n * `useKeeper` is a helper around `useRef`.\r\n *\r\n * You don't need to access the `.current`property to get the value\r\n * If refresh is set to true. The ref will be updated every render\r\n */\n\nfunction useKeeper(arg, refresh) {\n  if (refresh === void 0) {\n    refresh = false;\n  }\n\n  var ref = useRef(arg);\n  useEffect(function () {\n    if (refresh) ref.current = arg;\n  });\n  return ref.current;\n}\n\nfunction reducer(state, action) {\n  switch (action.type) {\n    case 0\n    /* ADD */\n    :\n      return [].concat(state, [action.toastId]).filter(function (id) {\n        return id !== action.staleId;\n      });\n\n    case 1\n    /* REMOVE */\n    :\n      return isToastIdValid(action.toastId) ? state.filter(function (id) {\n        return id !== action.toastId;\n      }) : [];\n  }\n}\n\nvar _excluded = [\"delay\", \"staleId\"];\nfunction useToastContainer(props) {\n  var _useReducer = useReducer(function (x) {\n    return x + 1;\n  }, 0),\n      forceUpdate = _useReducer[1];\n\n  var _useReducer2 = useReducer(reducer, []),\n      toast = _useReducer2[0],\n      dispatch = _useReducer2[1];\n\n  var containerRef = useRef(null);\n  var toastCount = useKeeper(0);\n  var queue = useKeeper([]);\n  var collection = useKeeper({});\n  var instance = useKeeper({\n    toastKey: 1,\n    displayedToast: 0,\n    props: props,\n    containerId: null,\n    isToastActive: isToastActive,\n    getToast: function getToast(id) {\n      return collection[id] || null;\n    }\n  });\n  useEffect(function () {\n    instance.containerId = props.containerId;\n    eventManager.cancelEmit(3\n    /* WillUnmount */\n    ).on(0\n    /* Show */\n    , buildToast).on(1\n    /* Clear */\n    , function (toastId) {\n      return containerRef.current && removeToast(toastId);\n    }).on(5\n    /* ClearWaitingQueue */\n    , clearWaitingQueue).emit(2\n    /* DidMount */\n    , instance);\n    return function () {\n      return eventManager.emit(3\n      /* WillUnmount */\n      , instance);\n    };\n  }, []);\n  useEffect(function () {\n    instance.isToastActive = isToastActive;\n    instance.displayedToast = toast.length;\n    eventManager.emit(4\n    /* Change */\n    , toast.length, props.containerId);\n  }, [toast]);\n  useEffect(function () {\n    instance.props = props;\n  });\n\n  function isToastActive(id) {\n    return toast.indexOf(id) !== -1;\n  }\n\n  function clearWaitingQueue(_ref) {\n    var containerId = _ref.containerId;\n    var limit = instance.props.limit;\n\n    if (limit && (!containerId || instance.containerId === containerId)) {\n      toastCount -= queue.length;\n      queue = [];\n    }\n  }\n\n  function removeToast(toastId) {\n    dispatch({\n      type: 1\n      /* REMOVE */\n      ,\n      toastId: toastId\n    });\n  }\n\n  function dequeueToast() {\n    var _queue$shift = queue.shift(),\n        toastContent = _queue$shift.toastContent,\n        toastProps = _queue$shift.toastProps,\n        staleId = _queue$shift.staleId;\n\n    appendToast(toastContent, toastProps, staleId);\n  }\n  /**\r\n   * check if a container is attached to the dom\r\n   * check for multi-container, build only if associated\r\n   * check for duplicate toastId if no update\r\n   */\n\n\n  function isNotValid(_ref2) {\n    var containerId = _ref2.containerId,\n        toastId = _ref2.toastId,\n        updateId = _ref2.updateId;\n    return !containerRef.current || instance.props.enableMultiContainer && containerId !== instance.props.containerId || collection[toastId] && updateId == null ? true : false;\n  } // this function and all the function called inside needs to rely on ref(`useKeeper`)\n\n\n  function buildToast(content, _ref3) {\n    var delay = _ref3.delay,\n        staleId = _ref3.staleId,\n        options = _objectWithoutPropertiesLoose(_ref3, _excluded);\n\n    if (!canBeRendered(content) || isNotValid(options)) return;\n    var toastId = options.toastId,\n        updateId = options.updateId,\n        data = options.data;\n    var props = instance.props;\n\n    var closeToast = function closeToast() {\n      return removeToast(toastId);\n    };\n\n    var isNotAnUpdate = options.updateId == null;\n    if (isNotAnUpdate) toastCount++;\n    var toastProps = {\n      toastId: toastId,\n      updateId: updateId,\n      isLoading: options.isLoading,\n      theme: options.theme || props.theme,\n      icon: options.icon || props.icon,\n      isIn: false,\n      key: options.key || instance.toastKey++,\n      type: options.type,\n      closeToast: closeToast,\n      closeButton: options.closeButton,\n      rtl: props.rtl,\n      position: options.position || props.position,\n      transition: options.transition || props.transition,\n      className: parseClassName(options.className || props.toastClassName),\n      bodyClassName: parseClassName(options.bodyClassName || props.bodyClassName),\n      style: options.style || props.toastStyle,\n      bodyStyle: options.bodyStyle || props.bodyStyle,\n      onClick: options.onClick || props.onClick,\n      pauseOnHover: isBool(options.pauseOnHover) ? options.pauseOnHover : props.pauseOnHover,\n      pauseOnFocusLoss: isBool(options.pauseOnFocusLoss) ? options.pauseOnFocusLoss : props.pauseOnFocusLoss,\n      draggable: isBool(options.draggable) ? options.draggable : props.draggable,\n      draggablePercent: isNum(options.draggablePercent) ? options.draggablePercent : props.draggablePercent,\n      draggableDirection: options.draggableDirection || props.draggableDirection,\n      closeOnClick: isBool(options.closeOnClick) ? options.closeOnClick : props.closeOnClick,\n      progressClassName: parseClassName(options.progressClassName || props.progressClassName),\n      progressStyle: options.progressStyle || props.progressStyle,\n      autoClose: options.isLoading ? false : getAutoCloseDelay(options.autoClose, props.autoClose),\n      hideProgressBar: isBool(options.hideProgressBar) ? options.hideProgressBar : props.hideProgressBar,\n      progress: options.progress,\n      role: isStr(options.role) ? options.role : props.role,\n      deleteToast: function deleteToast() {\n        removeFromCollection(toastId);\n      }\n    };\n    if (isFn(options.onOpen)) toastProps.onOpen = options.onOpen;\n    if (isFn(options.onClose)) toastProps.onClose = options.onClose; //  tweak for vertical dragging\n\n    if (toastProps.draggableDirection === \"y\"\n    /* Y */\n    && toastProps.draggablePercent === 80\n    /* DRAGGABLE_PERCENT */\n    ) {\n        toastProps.draggablePercent *= 1.5;\n      }\n\n    var closeButton = props.closeButton;\n\n    if (options.closeButton === false || canBeRendered(options.closeButton)) {\n      closeButton = options.closeButton;\n    } else if (options.closeButton === true) {\n      closeButton = canBeRendered(props.closeButton) ? props.closeButton : true;\n    }\n\n    toastProps.closeButton = closeButton;\n    var toastContent = content;\n\n    if (isValidElement(content) && !isStr(content.type)) {\n      toastContent = cloneElement(content, {\n        closeToast: closeToast,\n        toastProps: toastProps,\n        data: data\n      });\n    } else if (isFn(content)) {\n      toastContent = content({\n        closeToast: closeToast,\n        toastProps: toastProps,\n        data: data\n      });\n    } // not handling limit + delay by design. Waiting for user feedback first\n\n\n    if (props.limit && props.limit > 0 && toastCount > props.limit && isNotAnUpdate) {\n      queue.push({\n        toastContent: toastContent,\n        toastProps: toastProps,\n        staleId: staleId\n      });\n    } else if (isNum(delay) && delay > 0) {\n      setTimeout(function () {\n        appendToast(toastContent, toastProps, staleId);\n      }, delay);\n    } else {\n      appendToast(toastContent, toastProps, staleId);\n    }\n  }\n\n  function appendToast(content, toastProps, staleId) {\n    var toastId = toastProps.toastId;\n    if (staleId) delete collection[staleId];\n    collection[toastId] = {\n      content: content,\n      props: toastProps\n    };\n    dispatch({\n      type: 0\n      /* ADD */\n      ,\n      toastId: toastId,\n      staleId: staleId\n    });\n  }\n\n  function removeFromCollection(toastId) {\n    delete collection[toastId];\n    var queueLen = queue.length;\n    toastCount = isToastIdValid(toastId) ? toastCount - 1 : toastCount - instance.displayedToast;\n    if (toastCount < 0) toastCount = 0;\n\n    if (queueLen > 0) {\n      var freeSlot = isToastIdValid(toastId) ? 1 : instance.props.limit;\n\n      if (queueLen === 1 || freeSlot === 1) {\n        instance.displayedToast++;\n        dequeueToast();\n      } else {\n        var toDequeue = freeSlot > queueLen ? queueLen : freeSlot;\n        instance.displayedToast = toDequeue;\n\n        for (var i = 0; i < toDequeue; i++) {\n          dequeueToast();\n        }\n      }\n    } else {\n      forceUpdate();\n    }\n  }\n\n  function getToastToRender(cb) {\n    var toastToRender = {};\n    var toastList = props.newestOnTop ? Object.keys(collection).reverse() : Object.keys(collection);\n\n    for (var i = 0; i < toastList.length; i++) {\n      var _toast = collection[toastList[i]];\n      var position = _toast.props.position;\n      toastToRender[position] || (toastToRender[position] = []);\n      toastToRender[position].push(_toast);\n    }\n\n    return Object.keys(toastToRender).map(function (p) {\n      return cb(p, toastToRender[p]);\n    });\n  }\n\n  return {\n    getToastToRender: getToastToRender,\n    collection: collection,\n    containerRef: containerRef,\n    isToastActive: isToastActive\n  };\n}\n\nfunction getX(e) {\n  return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientX : e.clientX;\n}\n\nfunction getY(e) {\n  return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientY : e.clientY;\n}\n\nfunction useToast(props) {\n  var _useState = useState(true),\n      isRunning = _useState[0],\n      setIsRunning = _useState[1];\n\n  var _useState2 = useState(false),\n      preventExitTransition = _useState2[0],\n      setPreventExitTransition = _useState2[1];\n\n  var toastRef = useRef(null);\n  var drag = useKeeper({\n    start: 0,\n    x: 0,\n    y: 0,\n    delta: 0,\n    removalDistance: 0,\n    canCloseOnClick: true,\n    canDrag: false,\n    boundingRect: null\n  });\n  var syncProps = useKeeper(props, true);\n  var autoClose = props.autoClose,\n      pauseOnHover = props.pauseOnHover,\n      closeToast = props.closeToast,\n      onClick = props.onClick,\n      closeOnClick = props.closeOnClick;\n  useEffect(function () {\n    if (isFn(props.onOpen)) props.onOpen(isValidElement(props.children) && props.children.props);\n    return function () {\n      if (isFn(syncProps.onClose)) syncProps.onClose(isValidElement(syncProps.children) && syncProps.children.props);\n    };\n  }, []);\n  useEffect(function () {\n    props.draggable && bindDragEvents();\n    return function () {\n      props.draggable && unbindDragEvents();\n    };\n  }, [props.draggable]);\n  useEffect(function () {\n    props.pauseOnFocusLoss && bindFocusEvents();\n    return function () {\n      props.pauseOnFocusLoss && unbindFocusEvents();\n    };\n  }, [props.pauseOnFocusLoss]);\n\n  function onDragStart(e) {\n    if (props.draggable) {\n      var toast = toastRef.current;\n      drag.canCloseOnClick = true;\n      drag.canDrag = true;\n      drag.boundingRect = toast.getBoundingClientRect();\n      toast.style.transition = '';\n      drag.x = getX(e.nativeEvent);\n      drag.y = getY(e.nativeEvent);\n\n      if (props.draggableDirection === \"x\"\n      /* X */\n      ) {\n          drag.start = drag.x;\n          drag.removalDistance = toast.offsetWidth * (props.draggablePercent / 100);\n        } else {\n        drag.start = drag.y;\n        drag.removalDistance = toast.offsetHeight * (props.draggablePercent / 100);\n      }\n    }\n  }\n\n  function onDragTransitionEnd() {\n    if (drag.boundingRect) {\n      var _drag$boundingRect = drag.boundingRect,\n          top = _drag$boundingRect.top,\n          bottom = _drag$boundingRect.bottom,\n          left = _drag$boundingRect.left,\n          right = _drag$boundingRect.right;\n\n      if (props.pauseOnHover && drag.x >= left && drag.x <= right && drag.y >= top && drag.y <= bottom) {\n        pauseToast();\n      } else {\n        playToast();\n      }\n    }\n  }\n\n  function playToast() {\n    setIsRunning(true);\n  }\n\n  function pauseToast() {\n    setIsRunning(false);\n  }\n\n  function bindFocusEvents() {\n    if (!document.hasFocus()) pauseToast();\n    window.addEventListener('focus', playToast);\n    window.addEventListener('blur', pauseToast);\n  }\n\n  function unbindFocusEvents() {\n    window.removeEventListener('focus', playToast);\n    window.removeEventListener('blur', pauseToast);\n  }\n\n  function bindDragEvents() {\n    document.addEventListener('mousemove', onDragMove);\n    document.addEventListener('mouseup', onDragEnd);\n    document.addEventListener('touchmove', onDragMove);\n    document.addEventListener('touchend', onDragEnd);\n  }\n\n  function unbindDragEvents() {\n    document.removeEventListener('mousemove', onDragMove);\n    document.removeEventListener('mouseup', onDragEnd);\n    document.removeEventListener('touchmove', onDragMove);\n    document.removeEventListener('touchend', onDragEnd);\n  }\n\n  function onDragMove(e) {\n    if (drag.canDrag) {\n      e.preventDefault();\n      var toast = toastRef.current;\n      if (isRunning) pauseToast();\n      drag.x = getX(e);\n      drag.y = getY(e);\n\n      if (props.draggableDirection === \"x\"\n      /* X */\n      ) {\n          drag.delta = drag.x - drag.start;\n        } else {\n        drag.delta = drag.y - drag.start;\n      } // prevent false positif during a toast click\n\n\n      if (drag.start !== drag.x) drag.canCloseOnClick = false;\n      toast.style.transform = \"translate\" + props.draggableDirection + \"(\" + drag.delta + \"px)\";\n      toast.style.opacity = \"\" + (1 - Math.abs(drag.delta / drag.removalDistance));\n    }\n  }\n\n  function onDragEnd() {\n    var toast = toastRef.current;\n\n    if (drag.canDrag) {\n      drag.canDrag = false;\n\n      if (Math.abs(drag.delta) > drag.removalDistance) {\n        setPreventExitTransition(true);\n        props.closeToast();\n        return;\n      }\n\n      toast.style.transition = 'transform 0.2s, opacity 0.2s';\n      toast.style.transform = \"translate\" + props.draggableDirection + \"(0)\";\n      toast.style.opacity = '1';\n    }\n  }\n\n  var eventHandlers = {\n    onMouseDown: onDragStart,\n    onTouchStart: onDragStart,\n    onMouseUp: onDragTransitionEnd,\n    onTouchEnd: onDragTransitionEnd\n  };\n\n  if (autoClose && pauseOnHover) {\n    eventHandlers.onMouseEnter = pauseToast;\n    eventHandlers.onMouseLeave = playToast;\n  } // prevent toast from closing when user drags the toast\n\n\n  if (closeOnClick) {\n    eventHandlers.onClick = function (e) {\n      onClick && onClick(e);\n      drag.canCloseOnClick && closeToast();\n    };\n  }\n\n  return {\n    playToast: playToast,\n    pauseToast: pauseToast,\n    isRunning: isRunning,\n    preventExitTransition: preventExitTransition,\n    toastRef: toastRef,\n    eventHandlers: eventHandlers\n  };\n}\n\nfunction CloseButton(_ref) {\n  var closeToast = _ref.closeToast,\n      theme = _ref.theme,\n      _ref$ariaLabel = _ref.ariaLabel,\n      ariaLabel = _ref$ariaLabel === void 0 ? 'close' : _ref$ariaLabel;\n  return createElement(\"button\", {\n    className: \"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__close-button \" + \"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__close-button--\" + theme,\n    type: \"button\",\n    onClick: function onClick(e) {\n      e.stopPropagation();\n      closeToast(e);\n    },\n    \"aria-label\": ariaLabel\n  }, createElement(\"svg\", {\n    \"aria-hidden\": \"true\",\n    viewBox: \"0 0 14 16\"\n  }, createElement(\"path\", {\n    fillRule: \"evenodd\",\n    d: \"M7.71 8.23l3.75 3.75-1.48 1.48-3.75-3.75-3.75 3.75L1 11.98l3.75-3.75L1 4.48 2.48 3l3.75 3.75L9.98 3l1.48 1.48-3.75 3.75z\"\n  })));\n}\n\nfunction ProgressBar(_ref) {\n  var _cx, _animationEvent;\n\n  var delay = _ref.delay,\n      isRunning = _ref.isRunning,\n      closeToast = _ref.closeToast,\n      type = _ref.type,\n      hide = _ref.hide,\n      className = _ref.className,\n      userStyle = _ref.style,\n      controlledProgress = _ref.controlledProgress,\n      progress = _ref.progress,\n      rtl = _ref.rtl,\n      isIn = _ref.isIn,\n      theme = _ref.theme;\n\n  var style = _extends({}, userStyle, {\n    animationDuration: delay + \"ms\",\n    animationPlayState: isRunning ? 'running' : 'paused',\n    opacity: hide ? 0 : 1\n  });\n\n  if (controlledProgress) style.transform = \"scaleX(\" + progress + \")\";\n  var defaultClassName = cx(\"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar\", controlledProgress ? \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar--controlled\" : \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar--animated\", \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar-theme--\" + theme, \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar--\" + type, (_cx = {}, _cx[\"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__progress-bar--rtl\"] = rtl, _cx));\n  var classNames = isFn(className) ? className({\n    rtl: rtl,\n    type: type,\n    defaultClassName: defaultClassName\n  }) : cx(defaultClassName, className); // 🧐 controlledProgress is derived from progress\n  // so if controlledProgress is set\n  // it means that this is also the case for progress\n\n  var animationEvent = (_animationEvent = {}, _animationEvent[controlledProgress && progress >= 1 ? 'onTransitionEnd' : 'onAnimationEnd'] = controlledProgress && progress < 1 ? null : function () {\n    isIn && closeToast();\n  }, _animationEvent); // TODO: add aria-valuenow, aria-valuemax, aria-valuemin\n\n  return createElement(\"div\", Object.assign({\n    role: \"progressbar\",\n    \"aria-hidden\": hide ? 'true' : 'false',\n    \"aria-label\": \"notification timer\",\n    className: classNames,\n    style: style\n  }, animationEvent));\n}\nProgressBar.defaultProps = {\n  type: TYPE.DEFAULT,\n  hide: false\n};\n\nvar _excluded$1 = [\"theme\", \"type\"];\n\nvar Svg = function Svg(_ref) {\n  var theme = _ref.theme,\n      type = _ref.type,\n      rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);\n\n  return React__default.createElement(\"svg\", Object.assign({\n    viewBox: \"0 0 24 24\",\n    width: \"100%\",\n    height: \"100%\",\n    fill: theme === 'colored' ? 'currentColor' : \"var(--toastify-icon-color-\" + type + \")\"\n  }, rest));\n};\n\nfunction Warning(props) {\n  return React__default.createElement(Svg, Object.assign({}, props), React__default.createElement(\"path\", {\n    d: \"M23.32 17.191L15.438 2.184C14.728.833 13.416 0 11.996 0c-1.42 0-2.733.833-3.443 2.184L.533 17.448a4.744 4.744 0 000 4.368C1.243 23.167 2.555 24 3.975 24h16.05C22.22 24 24 22.044 24 19.632c0-.904-.251-1.746-.68-2.44zm-9.622 1.46c0 1.033-.724 1.823-1.698 1.823s-1.698-.79-1.698-1.822v-.043c0-1.028.724-1.822 1.698-1.822s1.698.79 1.698 1.822v.043zm.039-12.285l-.84 8.06c-.057.581-.408.943-.897.943-.49 0-.84-.367-.896-.942l-.84-8.065c-.057-.624.25-1.095.779-1.095h1.91c.528.005.84.476.784 1.1z\"\n  }));\n}\n\nfunction Info(props) {\n  return React__default.createElement(Svg, Object.assign({}, props), React__default.createElement(\"path\", {\n    d: \"M12 0a12 12 0 1012 12A12.013 12.013 0 0012 0zm.25 5a1.5 1.5 0 11-1.5 1.5 1.5 1.5 0 011.5-1.5zm2.25 13.5h-4a1 1 0 010-2h.75a.25.25 0 00.25-.25v-4.5a.25.25 0 00-.25-.25h-.75a1 1 0 010-2h1a2 2 0 012 2v4.75a.25.25 0 00.25.25h.75a1 1 0 110 2z\"\n  }));\n}\n\nfunction Success(props) {\n  return React__default.createElement(Svg, Object.assign({}, props), React__default.createElement(\"path\", {\n    d: \"M12 0a12 12 0 1012 12A12.014 12.014 0 0012 0zm6.927 8.2l-6.845 9.289a1.011 1.011 0 01-1.43.188l-4.888-3.908a1 1 0 111.25-1.562l4.076 3.261 6.227-8.451a1 1 0 111.61 1.183z\"\n  }));\n}\n\nfunction Error(props) {\n  return React__default.createElement(Svg, Object.assign({}, props), React__default.createElement(\"path\", {\n    d: \"M11.983 0a12.206 12.206 0 00-8.51 3.653A11.8 11.8 0 000 12.207 11.779 11.779 0 0011.8 24h.214A12.111 12.111 0 0024 11.791 11.766 11.766 0 0011.983 0zM10.5 16.542a1.476 1.476 0 011.449-1.53h.027a1.527 1.527 0 011.523 1.47 1.475 1.475 0 01-1.449 1.53h-.027a1.529 1.529 0 01-1.523-1.47zM11 12.5v-6a1 1 0 012 0v6a1 1 0 11-2 0z\"\n  }));\n}\n\nfunction Spinner() {\n  return React__default.createElement(\"div\", {\n    className: \"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__spinner\"\n  });\n}\n\nvar Icons = {\n  info: Info,\n  warning: Warning,\n  success: Success,\n  error: Error,\n  spinner: Spinner\n};\n\nvar Toast = function Toast(props) {\n  var _cx, _cx2;\n\n  var _useToast = useToast(props),\n      isRunning = _useToast.isRunning,\n      preventExitTransition = _useToast.preventExitTransition,\n      toastRef = _useToast.toastRef,\n      eventHandlers = _useToast.eventHandlers;\n\n  var closeButton = props.closeButton,\n      children = props.children,\n      autoClose = props.autoClose,\n      onClick = props.onClick,\n      type = props.type,\n      hideProgressBar = props.hideProgressBar,\n      closeToast = props.closeToast,\n      Transition = props.transition,\n      position = props.position,\n      className = props.className,\n      style = props.style,\n      bodyClassName = props.bodyClassName,\n      bodyStyle = props.bodyStyle,\n      progressClassName = props.progressClassName,\n      progressStyle = props.progressStyle,\n      updateId = props.updateId,\n      role = props.role,\n      progress = props.progress,\n      rtl = props.rtl,\n      toastId = props.toastId,\n      deleteToast = props.deleteToast,\n      isIn = props.isIn,\n      isLoading = props.isLoading,\n      icon = props.icon,\n      theme = props.theme;\n  var defaultClassName = cx(\"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__toast\", \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__toast-theme--\" + theme, \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__toast--\" + type, (_cx = {}, _cx[\"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__toast--rtl\"] = rtl, _cx));\n  var cssClasses = isFn(className) ? className({\n    rtl: rtl,\n    position: position,\n    type: type,\n    defaultClassName: defaultClassName\n  }) : cx(defaultClassName, className);\n  var isProgressControlled = !!progress;\n  var maybeIcon = Icons[type];\n  var iconProps = {\n    theme: theme,\n    type: type\n  };\n  var Icon = maybeIcon && maybeIcon(iconProps);\n\n  if (icon === false) {\n    Icon = void 0;\n  } else if (isFn(icon)) {\n    Icon = icon(iconProps);\n  } else if (isValidElement(icon)) {\n    Icon = cloneElement(icon, iconProps);\n  } else if (isStr(icon)) {\n    Icon = icon;\n  } else if (isLoading) {\n    Icon = Icons.spinner();\n  }\n\n  function renderCloseButton(closeButton) {\n    if (!closeButton) return;\n    var props = {\n      closeToast: closeToast,\n      type: type,\n      theme: theme\n    };\n    if (isFn(closeButton)) return closeButton(props);\n    if (isValidElement(closeButton)) return cloneElement(closeButton, props);\n  }\n\n  return createElement(Transition, {\n    isIn: isIn,\n    done: deleteToast,\n    position: position,\n    preventExitTransition: preventExitTransition,\n    nodeRef: toastRef\n  }, createElement(\"div\", Object.assign({\n    id: toastId,\n    onClick: onClick,\n    className: cssClasses\n  }, eventHandlers, {\n    style: style,\n    ref: toastRef\n  }), createElement(\"div\", Object.assign({}, isIn && {\n    role: role\n  }, {\n    className: isFn(bodyClassName) ? bodyClassName({\n      type: type\n    }) : cx(\"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__toast-body\", bodyClassName),\n    style: bodyStyle\n  }), Icon && createElement(\"div\", {\n    className: cx(\"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__toast-icon\", (_cx2 = {}, _cx2[\"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"--animate-icon \" + \"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__zoom-enter\"] = !isLoading, _cx2))\n  }, Icon), createElement(\"div\", null, children)), renderCloseButton(closeButton), (autoClose || isProgressControlled) && createElement(ProgressBar, Object.assign({}, updateId && !isProgressControlled ? {\n    key: \"pb-\" + updateId\n  } : {}, {\n    rtl: rtl,\n    theme: theme,\n    delay: autoClose,\n    isRunning: isRunning,\n    isIn: isIn,\n    closeToast: closeToast,\n    hide: hideProgressBar,\n    type: type,\n    style: progressStyle,\n    className: progressClassName,\n    controlledProgress: isProgressControlled,\n    progress: progress\n  }))));\n};\n\nvar Bounce = /*#__PURE__*/cssTransition({\n  enter: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__bounce-enter\",\n  exit: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__bounce-exit\",\n  appendPosition: true\n});\nvar Slide = /*#__PURE__*/cssTransition({\n  enter: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__slide-enter\",\n  exit: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__slide-exit\",\n  appendPosition: true\n});\nvar Zoom = /*#__PURE__*/cssTransition({\n  enter: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__zoom-enter\",\n  exit: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__zoom-exit\"\n});\nvar Flip = /*#__PURE__*/cssTransition({\n  enter: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__flip-enter\",\n  exit: \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"--animate \" + \"Toastify\"\n  /* CSS_NAMESPACE */\n  + \"__flip-exit\"\n});\n\nvar ToastContainer = function ToastContainer(props) {\n  var _useToastContainer = useToastContainer(props),\n      getToastToRender = _useToastContainer.getToastToRender,\n      containerRef = _useToastContainer.containerRef,\n      isToastActive = _useToastContainer.isToastActive;\n\n  var className = props.className,\n      style = props.style,\n      rtl = props.rtl,\n      containerId = props.containerId;\n\n  function getClassName(position) {\n    var _cx;\n\n    var defaultClassName = cx(\"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__toast-container\", \"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__toast-container--\" + position, (_cx = {}, _cx[\"Toastify\"\n    /* CSS_NAMESPACE */\n    + \"__toast-container--rtl\"] = rtl, _cx));\n    return isFn(className) ? className({\n      position: position,\n      rtl: rtl,\n      defaultClassName: defaultClassName\n    }) : cx(defaultClassName, parseClassName(className));\n  }\n\n  return createElement(\"div\", {\n    ref: containerRef,\n    className: \"Toastify\"\n    /* CSS_NAMESPACE */\n    ,\n    id: containerId\n  }, getToastToRender(function (position, toastList) {\n    var containerStyle = toastList.length === 0 ? _extends({}, style, {\n      pointerEvents: 'none'\n    }) : _extends({}, style);\n    return createElement(\"div\", {\n      className: getClassName(position),\n      style: containerStyle,\n      key: \"container-\" + position\n    }, toastList.map(function (_ref) {\n      var content = _ref.content,\n          toastProps = _ref.props;\n      return createElement(Toast, Object.assign({}, toastProps, {\n        isIn: isToastActive(toastProps.toastId),\n        key: \"toast-\" + toastProps.key,\n        closeButton: toastProps.closeButton === true ? CloseButton : toastProps.closeButton\n      }), content);\n    }));\n  }));\n};\nToastContainer.defaultProps = {\n  position: POSITION.TOP_RIGHT,\n  transition: Bounce,\n  rtl: false,\n  autoClose: 5000,\n  hideProgressBar: false,\n  closeButton: CloseButton,\n  pauseOnHover: true,\n  pauseOnFocusLoss: true,\n  closeOnClick: true,\n  newestOnTop: false,\n  draggable: true,\n  draggablePercent: 80\n  /* DRAGGABLE_PERCENT */\n  ,\n  draggableDirection: \"x\"\n  /* X */\n  ,\n  role: 'alert',\n  theme: 'light'\n};\n\nvar containers = /*#__PURE__*/new Map();\nvar latestInstance;\nvar containerDomNode;\nvar containerConfig;\nvar queue = [];\nvar lazy = false;\n/**\r\n * Check whether any container is currently mounted in the DOM\r\n */\n\nfunction isAnyContainerMounted() {\n  return containers.size > 0;\n}\n/**\r\n * Get the toast by id, given it's in the DOM, otherwise returns null\r\n */\n\n\nfunction getToast(toastId, _ref) {\n  var containerId = _ref.containerId;\n  var container = containers.get(containerId || latestInstance);\n  if (!container) return null;\n  return container.getToast(toastId);\n}\n/**\r\n * Generate a random toastId\r\n */\n\n\nfunction generateToastId() {\n  return Math.random().toString(36).substr(2, 9);\n}\n/**\r\n * Generate a toastId or use the one provided\r\n */\n\n\nfunction getToastId(options) {\n  if (options && (isStr(options.toastId) || isNum(options.toastId))) {\n    return options.toastId;\n  }\n\n  return generateToastId();\n}\n/**\r\n * If the container is not mounted, the toast is enqueued and\r\n * the container lazy mounted\r\n */\n\n\nfunction dispatchToast(content, options) {\n  if (isAnyContainerMounted()) {\n    eventManager.emit(0\n    /* Show */\n    , content, options);\n  } else {\n    queue.push({\n      content: content,\n      options: options\n    });\n\n    if (lazy && canUseDom) {\n      lazy = false;\n      containerDomNode = document.createElement('div');\n      document.body.appendChild(containerDomNode);\n      render(createElement(ToastContainer, Object.assign({}, containerConfig)), containerDomNode);\n    }\n  }\n\n  return options.toastId;\n}\n/**\r\n * Merge provided options with the defaults settings and generate the toastId\r\n */\n\n\nfunction mergeOptions(type, options) {\n  return _extends({}, options, {\n    type: options && options.type || type,\n    toastId: getToastId(options)\n  });\n}\n\nvar createToastByType = function createToastByType(type) {\n  return function (content, options) {\n    return dispatchToast(content, mergeOptions(type, options));\n  };\n};\n\nvar toast = function toast(content, options) {\n  return dispatchToast(content, mergeOptions(TYPE.DEFAULT, options));\n};\n\ntoast.loading = function (content, options) {\n  return dispatchToast(content, mergeOptions(TYPE.DEFAULT, _extends({\n    isLoading: true,\n    autoClose: false,\n    closeOnClick: false,\n    closeButton: false,\n    draggable: false\n  }, options)));\n};\n\nfunction handlePromise(promise, _ref2, options) {\n  var pending = _ref2.pending,\n      error = _ref2.error,\n      success = _ref2.success;\n  var id = isStr(pending) ? toast.loading(pending, options) : toast.loading(pending.render, _extends({}, options, pending));\n  var resetParams = {\n    isLoading: null,\n    autoClose: null,\n    closeOnClick: null,\n    closeButton: null,\n    draggable: null\n  };\n\n  var resolver = function resolver(type, input, result) {\n    var params = isStr(input) ? {\n      render: input\n    } : input;\n    toast.update(id, _extends({\n      type: type\n    }, resetParams, options, params, {\n      data: result\n    }));\n    return result;\n  };\n\n  var p = isFn(promise) ? promise() : promise;\n  p.then(function (result) {\n    return resolver('success', success, result);\n  })[\"catch\"](function (err) {\n    return resolver('error', error, err);\n  });\n  return p;\n}\n\ntoast.promise = handlePromise;\ntoast.success = /*#__PURE__*/createToastByType(TYPE.SUCCESS);\ntoast.info = /*#__PURE__*/createToastByType(TYPE.INFO);\ntoast.error = /*#__PURE__*/createToastByType(TYPE.ERROR);\ntoast.warning = /*#__PURE__*/createToastByType(TYPE.WARNING);\ntoast.warn = toast.warning;\n\ntoast.dark = function (content, options) {\n  return dispatchToast(content, mergeOptions(TYPE.DEFAULT, _extends({\n    theme: 'dark'\n  }, options)));\n};\n/**\r\n * Remove toast programmaticaly\r\n */\n\n\ntoast.dismiss = function (id) {\n  return eventManager.emit(1\n  /* Clear */\n  , id);\n};\n/**\r\n * Clear waiting queue when limit is used\r\n */\n\n\ntoast.clearWaitingQueue = function (params) {\n  if (params === void 0) {\n    params = {};\n  }\n\n  return eventManager.emit(5\n  /* ClearWaitingQueue */\n  , params);\n};\n/**\r\n * return true if one container is displaying the toast\r\n */\n\n\ntoast.isActive = function (id) {\n  var isToastActive = false;\n  containers.forEach(function (container) {\n    if (container.isToastActive && container.isToastActive(id)) {\n      isToastActive = true;\n    }\n  });\n  return isToastActive;\n};\n\ntoast.update = function (toastId, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  // if you call toast and toast.update directly nothing will be displayed\n  // this is why I defered the update\n  setTimeout(function () {\n    var toast = getToast(toastId, options);\n\n    if (toast) {\n      var oldOptions = toast.props,\n          oldContent = toast.content;\n\n      var nextOptions = _extends({}, oldOptions, options, {\n        toastId: options.toastId || toastId,\n        updateId: generateToastId()\n      });\n\n      if (nextOptions.toastId !== toastId) nextOptions.staleId = toastId;\n      var content = nextOptions.render || oldContent;\n      delete nextOptions.render;\n      dispatchToast(content, nextOptions);\n    }\n  }, 0);\n};\n/**\r\n * Used for controlled progress bar.\r\n */\n\n\ntoast.done = function (id) {\n  toast.update(id, {\n    progress: 1\n  });\n};\n/**\r\n * Track changes. The callback get the number of toast displayed\r\n *\r\n */\n\n\ntoast.onChange = function (callback) {\n  if (isFn(callback)) {\n    eventManager.on(4\n    /* Change */\n    , callback);\n  }\n\n  return function () {\n    isFn(callback) && eventManager.off(4\n    /* Change */\n    , callback);\n  };\n};\n/**\r\n * Configure the ToastContainer when lazy mounted\r\n */\n\n\ntoast.configure = function (config) {\n  if (config === void 0) {\n    config = {};\n  }\n\n  lazy = true;\n  containerConfig = config;\n};\n\ntoast.POSITION = POSITION;\ntoast.TYPE = TYPE;\n/**\r\n * Wait until the ToastContainer is mounted to dispatch the toast\r\n * and attach isActive method\r\n */\n\neventManager.on(2\n/* DidMount */\n, function (containerInstance) {\n  latestInstance = containerInstance.containerId || containerInstance;\n  containers.set(latestInstance, containerInstance);\n  queue.forEach(function (item) {\n    eventManager.emit(0\n    /* Show */\n    , item.content, item.options);\n  });\n  queue = [];\n}).on(3\n/* WillUnmount */\n, function (containerInstance) {\n  containers[\"delete\"](containerInstance.containerId || containerInstance);\n\n  if (containers.size === 0) {\n    eventManager.off(0\n    /* Show */\n    ).off(1\n    /* Clear */\n    ).off(5\n    /* ClearWaitingQueue */\n    );\n  }\n\n  if (canUseDom && containerDomNode) {\n    document.body.removeChild(containerDomNode);\n  }\n});\n\nexport { Bounce, Flip, Icons, Slide, ToastContainer, Zoom, collapseToast, cssTransition, toast, useToast, useToastContainer };\n//# sourceMappingURL=react-toastify.esm.js.map\n","var support = {\n  searchParams: 'URLSearchParams' in self,\n  iterable: 'Symbol' in self && 'iterator' in Symbol,\n  blob:\n    'FileReader' in self &&\n    'Blob' in self &&\n    (function() {\n      try {\n        new Blob()\n        return true\n      } catch (e) {\n        return false\n      }\n    })(),\n  formData: 'FormData' in self,\n  arrayBuffer: 'ArrayBuffer' in self\n}\n\nfunction isDataView(obj) {\n  return obj && DataView.prototype.isPrototypeOf(obj)\n}\n\nif (support.arrayBuffer) {\n  var viewClasses = [\n    '[object Int8Array]',\n    '[object Uint8Array]',\n    '[object Uint8ClampedArray]',\n    '[object Int16Array]',\n    '[object Uint16Array]',\n    '[object Int32Array]',\n    '[object Uint32Array]',\n    '[object Float32Array]',\n    '[object Float64Array]'\n  ]\n\n  var isArrayBufferView =\n    ArrayBuffer.isView ||\n    function(obj) {\n      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n    }\n}\n\nfunction normalizeName(name) {\n  if (typeof name !== 'string') {\n    name = String(name)\n  }\n  if (/[^a-z0-9\\-#$%&'*+.^_`|~]/i.test(name)) {\n    throw new TypeError('Invalid character in header field name')\n  }\n  return name.toLowerCase()\n}\n\nfunction normalizeValue(value) {\n  if (typeof value !== 'string') {\n    value = String(value)\n  }\n  return value\n}\n\n// Build a destructive iterator for the value list\nfunction iteratorFor(items) {\n  var iterator = {\n    next: function() {\n      var value = items.shift()\n      return {done: value === undefined, value: value}\n    }\n  }\n\n  if (support.iterable) {\n    iterator[Symbol.iterator] = function() {\n      return iterator\n    }\n  }\n\n  return iterator\n}\n\nexport function Headers(headers) {\n  this.map = {}\n\n  if (headers instanceof Headers) {\n    headers.forEach(function(value, name) {\n      this.append(name, value)\n    }, this)\n  } else if (Array.isArray(headers)) {\n    headers.forEach(function(header) {\n      this.append(header[0], header[1])\n    }, this)\n  } else if (headers) {\n    Object.getOwnPropertyNames(headers).forEach(function(name) {\n      this.append(name, headers[name])\n    }, this)\n  }\n}\n\nHeaders.prototype.append = function(name, value) {\n  name = normalizeName(name)\n  value = normalizeValue(value)\n  var oldValue = this.map[name]\n  this.map[name] = oldValue ? oldValue + ', ' + value : value\n}\n\nHeaders.prototype['delete'] = function(name) {\n  delete this.map[normalizeName(name)]\n}\n\nHeaders.prototype.get = function(name) {\n  name = normalizeName(name)\n  return this.has(name) ? this.map[name] : null\n}\n\nHeaders.prototype.has = function(name) {\n  return this.map.hasOwnProperty(normalizeName(name))\n}\n\nHeaders.prototype.set = function(name, value) {\n  this.map[normalizeName(name)] = normalizeValue(value)\n}\n\nHeaders.prototype.forEach = function(callback, thisArg) {\n  for (var name in this.map) {\n    if (this.map.hasOwnProperty(name)) {\n      callback.call(thisArg, this.map[name], name, this)\n    }\n  }\n}\n\nHeaders.prototype.keys = function() {\n  var items = []\n  this.forEach(function(value, name) {\n    items.push(name)\n  })\n  return iteratorFor(items)\n}\n\nHeaders.prototype.values = function() {\n  var items = []\n  this.forEach(function(value) {\n    items.push(value)\n  })\n  return iteratorFor(items)\n}\n\nHeaders.prototype.entries = function() {\n  var items = []\n  this.forEach(function(value, name) {\n    items.push([name, value])\n  })\n  return iteratorFor(items)\n}\n\nif (support.iterable) {\n  Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n}\n\nfunction consumed(body) {\n  if (body.bodyUsed) {\n    return Promise.reject(new TypeError('Already read'))\n  }\n  body.bodyUsed = true\n}\n\nfunction fileReaderReady(reader) {\n  return new Promise(function(resolve, reject) {\n    reader.onload = function() {\n      resolve(reader.result)\n    }\n    reader.onerror = function() {\n      reject(reader.error)\n    }\n  })\n}\n\nfunction readBlobAsArrayBuffer(blob) {\n  var reader = new FileReader()\n  var promise = fileReaderReady(reader)\n  reader.readAsArrayBuffer(blob)\n  return promise\n}\n\nfunction readBlobAsText(blob) {\n  var reader = new FileReader()\n  var promise = fileReaderReady(reader)\n  reader.readAsText(blob)\n  return promise\n}\n\nfunction readArrayBufferAsText(buf) {\n  var view = new Uint8Array(buf)\n  var chars = new Array(view.length)\n\n  for (var i = 0; i < view.length; i++) {\n    chars[i] = String.fromCharCode(view[i])\n  }\n  return chars.join('')\n}\n\nfunction bufferClone(buf) {\n  if (buf.slice) {\n    return buf.slice(0)\n  } else {\n    var view = new Uint8Array(buf.byteLength)\n    view.set(new Uint8Array(buf))\n    return view.buffer\n  }\n}\n\nfunction Body() {\n  this.bodyUsed = false\n\n  this._initBody = function(body) {\n    this._bodyInit = body\n    if (!body) {\n      this._bodyText = ''\n    } else if (typeof body === 'string') {\n      this._bodyText = body\n    } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n      this._bodyBlob = body\n    } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n      this._bodyFormData = body\n    } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n      this._bodyText = body.toString()\n    } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n      this._bodyArrayBuffer = bufferClone(body.buffer)\n      // IE 10-11 can't handle a DataView body.\n      this._bodyInit = new Blob([this._bodyArrayBuffer])\n    } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n      this._bodyArrayBuffer = bufferClone(body)\n    } else {\n      this._bodyText = body = Object.prototype.toString.call(body)\n    }\n\n    if (!this.headers.get('content-type')) {\n      if (typeof body === 'string') {\n        this.headers.set('content-type', 'text/plain;charset=UTF-8')\n      } else if (this._bodyBlob && this._bodyBlob.type) {\n        this.headers.set('content-type', this._bodyBlob.type)\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n      }\n    }\n  }\n\n  if (support.blob) {\n    this.blob = function() {\n      var rejected = consumed(this)\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return Promise.resolve(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as blob')\n      } else {\n        return Promise.resolve(new Blob([this._bodyText]))\n      }\n    }\n\n    this.arrayBuffer = function() {\n      if (this._bodyArrayBuffer) {\n        return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n      } else {\n        return this.blob().then(readBlobAsArrayBuffer)\n      }\n    }\n  }\n\n  this.text = function() {\n    var rejected = consumed(this)\n    if (rejected) {\n      return rejected\n    }\n\n    if (this._bodyBlob) {\n      return readBlobAsText(this._bodyBlob)\n    } else if (this._bodyArrayBuffer) {\n      return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n    } else if (this._bodyFormData) {\n      throw new Error('could not read FormData body as text')\n    } else {\n      return Promise.resolve(this._bodyText)\n    }\n  }\n\n  if (support.formData) {\n    this.formData = function() {\n      return this.text().then(decode)\n    }\n  }\n\n  this.json = function() {\n    return this.text().then(JSON.parse)\n  }\n\n  return this\n}\n\n// HTTP methods whose capitalization should be normalized\nvar methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\nfunction normalizeMethod(method) {\n  var upcased = method.toUpperCase()\n  return methods.indexOf(upcased) > -1 ? upcased : method\n}\n\nexport function Request(input, options) {\n  options = options || {}\n  var body = options.body\n\n  if (input instanceof Request) {\n    if (input.bodyUsed) {\n      throw new TypeError('Already read')\n    }\n    this.url = input.url\n    this.credentials = input.credentials\n    if (!options.headers) {\n      this.headers = new Headers(input.headers)\n    }\n    this.method = input.method\n    this.mode = input.mode\n    this.signal = input.signal\n    if (!body && input._bodyInit != null) {\n      body = input._bodyInit\n      input.bodyUsed = true\n    }\n  } else {\n    this.url = String(input)\n  }\n\n  this.credentials = options.credentials || this.credentials || 'same-origin'\n  if (options.headers || !this.headers) {\n    this.headers = new Headers(options.headers)\n  }\n  this.method = normalizeMethod(options.method || this.method || 'GET')\n  this.mode = options.mode || this.mode || null\n  this.signal = options.signal || this.signal\n  this.referrer = null\n\n  if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n    throw new TypeError('Body not allowed for GET or HEAD requests')\n  }\n  this._initBody(body)\n}\n\nRequest.prototype.clone = function() {\n  return new Request(this, {body: this._bodyInit})\n}\n\nfunction decode(body) {\n  var form = new FormData()\n  body\n    .trim()\n    .split('&')\n    .forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n  return form\n}\n\nfunction parseHeaders(rawHeaders) {\n  var headers = new Headers()\n  // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n  // https://tools.ietf.org/html/rfc7230#section-3.2\n  var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ')\n  preProcessedHeaders.split(/\\r?\\n/).forEach(function(line) {\n    var parts = line.split(':')\n    var key = parts.shift().trim()\n    if (key) {\n      var value = parts.join(':').trim()\n      headers.append(key, value)\n    }\n  })\n  return headers\n}\n\nBody.call(Request.prototype)\n\nexport function Response(bodyInit, options) {\n  if (!options) {\n    options = {}\n  }\n\n  this.type = 'default'\n  this.status = options.status === undefined ? 200 : options.status\n  this.ok = this.status >= 200 && this.status < 300\n  this.statusText = 'statusText' in options ? options.statusText : 'OK'\n  this.headers = new Headers(options.headers)\n  this.url = options.url || ''\n  this._initBody(bodyInit)\n}\n\nBody.call(Response.prototype)\n\nResponse.prototype.clone = function() {\n  return new Response(this._bodyInit, {\n    status: this.status,\n    statusText: this.statusText,\n    headers: new Headers(this.headers),\n    url: this.url\n  })\n}\n\nResponse.error = function() {\n  var response = new Response(null, {status: 0, statusText: ''})\n  response.type = 'error'\n  return response\n}\n\nvar redirectStatuses = [301, 302, 303, 307, 308]\n\nResponse.redirect = function(url, status) {\n  if (redirectStatuses.indexOf(status) === -1) {\n    throw new RangeError('Invalid status code')\n  }\n\n  return new Response(null, {status: status, headers: {location: url}})\n}\n\nexport var DOMException = self.DOMException\ntry {\n  new DOMException()\n} catch (err) {\n  DOMException = function(message, name) {\n    this.message = message\n    this.name = name\n    var error = Error(message)\n    this.stack = error.stack\n  }\n  DOMException.prototype = Object.create(Error.prototype)\n  DOMException.prototype.constructor = DOMException\n}\n\nexport function fetch(input, init) {\n  return new Promise(function(resolve, reject) {\n    var request = new Request(input, init)\n\n    if (request.signal && request.signal.aborted) {\n      return reject(new DOMException('Aborted', 'AbortError'))\n    }\n\n    var xhr = new XMLHttpRequest()\n\n    function abortXhr() {\n      xhr.abort()\n    }\n\n    xhr.onload = function() {\n      var options = {\n        status: xhr.status,\n        statusText: xhr.statusText,\n        headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n      }\n      options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')\n      var body = 'response' in xhr ? xhr.response : xhr.responseText\n      resolve(new Response(body, options))\n    }\n\n    xhr.onerror = function() {\n      reject(new TypeError('Network request failed'))\n    }\n\n    xhr.ontimeout = function() {\n      reject(new TypeError('Network request failed'))\n    }\n\n    xhr.onabort = function() {\n      reject(new DOMException('Aborted', 'AbortError'))\n    }\n\n    xhr.open(request.method, request.url, true)\n\n    if (request.credentials === 'include') {\n      xhr.withCredentials = true\n    } else if (request.credentials === 'omit') {\n      xhr.withCredentials = false\n    }\n\n    if ('responseType' in xhr && support.blob) {\n      xhr.responseType = 'blob'\n    }\n\n    request.headers.forEach(function(value, name) {\n      xhr.setRequestHeader(name, value)\n    })\n\n    if (request.signal) {\n      request.signal.addEventListener('abort', abortXhr)\n\n      xhr.onreadystatechange = function() {\n        // DONE (success or failure)\n        if (xhr.readyState === 4) {\n          request.signal.removeEventListener('abort', abortXhr)\n        }\n      }\n    }\n\n    xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n  })\n}\n\nfetch.polyfill = true\n\nif (!self.fetch) {\n  self.fetch = fetch\n  self.Headers = Headers\n  self.Request = Request\n  self.Response = Response\n}\n","/*! https://mths.be/utf8js v2.1.2 by @mathias */\n\nvar stringFromCharCode = String.fromCharCode;\n\n// Taken from https://mths.be/punycode\nfunction ucs2decode(string) {\n\tvar output = [];\n\tvar counter = 0;\n\tvar length = string.length;\n\tvar value;\n\tvar extra;\n\twhile (counter < length) {\n\t\tvalue = string.charCodeAt(counter++);\n\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t// high surrogate, and there is a next character\n\t\t\textra = string.charCodeAt(counter++);\n\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t} else {\n\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\toutput.push(value);\n\t\t\t\tcounter--;\n\t\t\t}\n\t\t} else {\n\t\t\toutput.push(value);\n\t\t}\n\t}\n\treturn output;\n}\n\n// Taken from https://mths.be/punycode\nfunction ucs2encode(array) {\n\tvar length = array.length;\n\tvar index = -1;\n\tvar value;\n\tvar output = '';\n\twhile (++index < length) {\n\t\tvalue = array[index];\n\t\tif (value > 0xFFFF) {\n\t\t\tvalue -= 0x10000;\n\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t}\n\t\toutput += stringFromCharCode(value);\n\t}\n\treturn output;\n}\n\nfunction checkScalarValue(codePoint, strict) {\n\tif (codePoint >= 0xD800 && codePoint <= 0xDFFF) {\n\t\tif (strict) {\n\t\t\tthrow Error(\n\t\t\t\t'Lone surrogate U+' + codePoint.toString(16).toUpperCase() +\n\t\t\t\t' is not a scalar value'\n\t\t\t);\n\t\t}\n\t\treturn false;\n\t}\n\treturn true;\n}\n/*--------------------------------------------------------------------------*/\n\nfunction createByte(codePoint, shift) {\n\treturn stringFromCharCode(((codePoint >> shift) & 0x3F) | 0x80);\n}\n\nfunction encodeCodePoint(codePoint, strict) {\n\tif ((codePoint & 0xFFFFFF80) == 0) { // 1-byte sequence\n\t\treturn stringFromCharCode(codePoint);\n\t}\n\tvar symbol = '';\n\tif ((codePoint & 0xFFFFF800) == 0) { // 2-byte sequence\n\t\tsymbol = stringFromCharCode(((codePoint >> 6) & 0x1F) | 0xC0);\n\t}\n\telse if ((codePoint & 0xFFFF0000) == 0) { // 3-byte sequence\n\t\tif (!checkScalarValue(codePoint, strict)) {\n\t\t\tcodePoint = 0xFFFD;\n\t\t}\n\t\tsymbol = stringFromCharCode(((codePoint >> 12) & 0x0F) | 0xE0);\n\t\tsymbol += createByte(codePoint, 6);\n\t}\n\telse if ((codePoint & 0xFFE00000) == 0) { // 4-byte sequence\n\t\tsymbol = stringFromCharCode(((codePoint >> 18) & 0x07) | 0xF0);\n\t\tsymbol += createByte(codePoint, 12);\n\t\tsymbol += createByte(codePoint, 6);\n\t}\n\tsymbol += stringFromCharCode((codePoint & 0x3F) | 0x80);\n\treturn symbol;\n}\n\nfunction utf8encode(string, opts) {\n\topts = opts || {};\n\tvar strict = false !== opts.strict;\n\n\tvar codePoints = ucs2decode(string);\n\tvar length = codePoints.length;\n\tvar index = -1;\n\tvar codePoint;\n\tvar byteString = '';\n\twhile (++index < length) {\n\t\tcodePoint = codePoints[index];\n\t\tbyteString += encodeCodePoint(codePoint, strict);\n\t}\n\treturn byteString;\n}\n\n/*--------------------------------------------------------------------------*/\n\nfunction readContinuationByte() {\n\tif (byteIndex >= byteCount) {\n\t\tthrow Error('Invalid byte index');\n\t}\n\n\tvar continuationByte = byteArray[byteIndex] & 0xFF;\n\tbyteIndex++;\n\n\tif ((continuationByte & 0xC0) == 0x80) {\n\t\treturn continuationByte & 0x3F;\n\t}\n\n\t// If we end up here, it’s not a continuation byte\n\tthrow Error('Invalid continuation byte');\n}\n\nfunction decodeSymbol(strict) {\n\tvar byte1;\n\tvar byte2;\n\tvar byte3;\n\tvar byte4;\n\tvar codePoint;\n\n\tif (byteIndex > byteCount) {\n\t\tthrow Error('Invalid byte index');\n\t}\n\n\tif (byteIndex == byteCount) {\n\t\treturn false;\n\t}\n\n\t// Read first byte\n\tbyte1 = byteArray[byteIndex] & 0xFF;\n\tbyteIndex++;\n\n\t// 1-byte sequence (no continuation bytes)\n\tif ((byte1 & 0x80) == 0) {\n\t\treturn byte1;\n\t}\n\n\t// 2-byte sequence\n\tif ((byte1 & 0xE0) == 0xC0) {\n\t\tbyte2 = readContinuationByte();\n\t\tcodePoint = ((byte1 & 0x1F) << 6) | byte2;\n\t\tif (codePoint >= 0x80) {\n\t\t\treturn codePoint;\n\t\t} else {\n\t\t\tthrow Error('Invalid continuation byte');\n\t\t}\n\t}\n\n\t// 3-byte sequence (may include unpaired surrogates)\n\tif ((byte1 & 0xF0) == 0xE0) {\n\t\tbyte2 = readContinuationByte();\n\t\tbyte3 = readContinuationByte();\n\t\tcodePoint = ((byte1 & 0x0F) << 12) | (byte2 << 6) | byte3;\n\t\tif (codePoint >= 0x0800) {\n\t\t\treturn checkScalarValue(codePoint, strict) ? codePoint : 0xFFFD;\n\t\t} else {\n\t\t\tthrow Error('Invalid continuation byte');\n\t\t}\n\t}\n\n\t// 4-byte sequence\n\tif ((byte1 & 0xF8) == 0xF0) {\n\t\tbyte2 = readContinuationByte();\n\t\tbyte3 = readContinuationByte();\n\t\tbyte4 = readContinuationByte();\n\t\tcodePoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0C) |\n\t\t\t(byte3 << 0x06) | byte4;\n\t\tif (codePoint >= 0x010000 && codePoint <= 0x10FFFF) {\n\t\t\treturn codePoint;\n\t\t}\n\t}\n\n\tthrow Error('Invalid UTF-8 detected');\n}\n\nvar byteArray;\nvar byteCount;\nvar byteIndex;\nfunction utf8decode(byteString, opts) {\n\topts = opts || {};\n\tvar strict = false !== opts.strict;\n\n\tbyteArray = ucs2decode(byteString);\n\tbyteCount = byteArray.length;\n\tbyteIndex = 0;\n\tvar codePoints = [];\n\tvar tmp;\n\twhile ((tmp = decodeSymbol(strict)) !== false) {\n\t\tcodePoints.push(tmp);\n\t}\n\treturn ucs2encode(codePoints);\n}\n\nmodule.exports = {\n\tversion: '2.1.2',\n\tencode: utf8encode,\n\tdecode: utf8decode\n};\n","/**\r\n * Compiles a querystring\r\n * Returns string representation of the object\r\n *\r\n * @param {Object}\r\n * @api private\r\n */\r\n\r\nexports.encode = function (obj) {\r\n  var str = '';\r\n\r\n  for (var i in obj) {\r\n    if (obj.hasOwnProperty(i)) {\r\n      if (str.length) str += '&';\r\n      str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\r\n    }\r\n  }\r\n\r\n  return str;\r\n};\r\n\r\n/**\r\n * Parses a simple querystring into an object\r\n *\r\n * @param {String} qs\r\n * @api private\r\n */\r\n\r\nexports.decode = function(qs){\r\n  var qry = {};\r\n  var pairs = qs.split('&');\r\n  for (var i = 0, l = pairs.length; i < l; i++) {\r\n    var pair = pairs[i].split('=');\r\n    qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\r\n  }\r\n  return qry;\r\n};\r\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\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 start = i + 1;\n    while (str.charAt(++i) !== '-' && i != str.length) {}\n    var buf = str.substring(start, i);\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    var start = i + 1;\n    while (++i) {\n      var c = str.charAt(i);\n      if (',' === c) break;\n      if (i === str.length) break;\n    }\n    p.nsp = str.substring(start, i);\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    var start = i + 1;\n    while (++i) {\n      var c = str.charAt(i);\n      if (null == c || Number(c) != c) {\n        --i;\n        break;\n      }\n      if (i === str.length) break;\n    }\n    p.id = Number(str.substring(start, i + 1));\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","/**\n * An abstraction for slicing an arraybuffer even when\n * ArrayBuffer.prototype.slice is not supported\n *\n * @api public\n */\n\nmodule.exports = function(arraybuffer, start, end) {\n  var bytes = arraybuffer.byteLength;\n  start = start || 0;\n  end = end || bytes;\n\n  if (arraybuffer.slice) { return arraybuffer.slice(start, end); }\n\n  if (start < 0) { start += bytes; }\n  if (end < 0) { end += bytes; }\n  if (end > bytes) { end = bytes; }\n\n  if (start >= bytes || start >= end || bytes === 0) {\n    return new ArrayBuffer(0);\n  }\n\n  var abv = new Uint8Array(arraybuffer);\n  var result = new Uint8Array(end - start);\n  for (var i = start, ii = 0; i < end; i++, ii++) {\n    result[ii] = abv[i];\n  }\n  return result.buffer;\n};\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","/**\n * Slice reference.\n */\n\nvar slice = [].slice;\n\n/**\n * Bind `obj` to `fn`.\n *\n * @param {Object} obj\n * @param {Function|String} fn or string\n * @return {Function}\n * @api public\n */\n\nmodule.exports = function(obj, fn){\n  if ('string' == typeof fn) fn = obj[fn];\n  if ('function' != typeof fn) throw new Error('bind() requires a function');\n  var args = slice.call(arguments, 2);\n  return function(){\n    return fn.apply(obj, args.concat(slice.call(arguments)));\n  }\n};\n","\nmodule.exports = require('./socket');\n\n/**\n * Exports parser\n *\n * @api public\n *\n */\nmodule.exports.parser = require('engine.io-parser');\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 toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","'use strict';\n\nvar alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_'.split('')\n  , length = 64\n  , map = {}\n  , seed = 0\n  , i = 0\n  , prev;\n\n/**\n * Return a string representing the specified number.\n *\n * @param {Number} num The number to convert.\n * @returns {String} The string representation of the number.\n * @api public\n */\nfunction encode(num) {\n  var encoded = '';\n\n  do {\n    encoded = alphabet[num % length] + encoded;\n    num = Math.floor(num / length);\n  } while (num > 0);\n\n  return encoded;\n}\n\n/**\n * Return the integer value specified by the given string.\n *\n * @param {String} str The string to convert.\n * @returns {Number} The integer value represented by the string.\n * @api public\n */\nfunction decode(str) {\n  var decoded = 0;\n\n  for (i = 0; i < str.length; i++) {\n    decoded = decoded * length + map[str.charAt(i)];\n  }\n\n  return decoded;\n}\n\n/**\n * Yeast: A tiny growing id generator.\n *\n * @returns {String} A unique id.\n * @api public\n */\nfunction yeast() {\n  var now = encode(+new Date());\n\n  if (now !== prev) return seed = 0, prev = now;\n  return now +'.'+ encode(seed++);\n}\n\n//\n// Map each character to its index.\n//\nfor (; i < length; i++) map[alphabet[i]] = i;\n\n//\n// Expose the `yeast`, `encode` and `decode` functions.\n//\nyeast.encode = encode;\nyeast.decode = decode;\nmodule.exports = yeast;\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * A local reference to the document.\n */\nvar document = window.document;\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  if (parent && parent.assignedSlot) {\n    // If the parent is distributed in a <slot>, return the parent of a slot.\n    return parent.assignedSlot.parentNode;\n  }\n\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\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","/* global Blob File */\n\n/*\n * Module requirements.\n */\n\nvar isArray = require('isarray');\n\nvar toString = Object.prototype.toString;\nvar withNativeBlob = typeof Blob === 'function' ||\n                        typeof Blob !== 'undefined' && toString.call(Blob) === '[object BlobConstructor]';\nvar withNativeFile = typeof File === 'function' ||\n                        typeof File !== 'undefined' && toString.call(File) === '[object FileConstructor]';\n\n/**\n * Module exports.\n */\n\nmodule.exports = hasBinary;\n\n/**\n * Checks for binary data.\n *\n * Supports Buffer, ArrayBuffer, Blob and File.\n *\n * @param {Object} anything\n * @api public\n */\n\nfunction hasBinary (obj) {\n  if (!obj || typeof obj !== 'object') {\n    return false;\n  }\n\n  if (isArray(obj)) {\n    for (var i = 0, l = obj.length; i < l; i++) {\n      if (hasBinary(obj[i])) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  if ((typeof Buffer === 'function' && Buffer.isBuffer && Buffer.isBuffer(obj)) ||\n    (typeof ArrayBuffer === 'function' && obj instanceof ArrayBuffer) ||\n    (withNativeBlob && obj instanceof Blob) ||\n    (withNativeFile && obj instanceof File)\n  ) {\n    return true;\n  }\n\n  // see: https://github.com/Automattic/has-binary/pull/4\n  if (obj.toJSON && typeof obj.toJSON === 'function' && arguments.length === 1) {\n    return hasBinary(obj.toJSON(), true);\n  }\n\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n      return true;\n    }\n  }\n\n  return false;\n}\n","/**\n * Module dependencies.\n */\n\nvar parser = require('engine.io-parser');\nvar Emitter = require('component-emitter');\n\n/**\n * Module exports.\n */\n\nmodule.exports = Transport;\n\n/**\n * Transport abstract constructor.\n *\n * @param {Object} options.\n * @api private\n */\n\nfunction Transport (opts) {\n  this.path = opts.path;\n  this.hostname = opts.hostname;\n  this.port = opts.port;\n  this.secure = opts.secure;\n  this.query = opts.query;\n  this.timestampParam = opts.timestampParam;\n  this.timestampRequests = opts.timestampRequests;\n  this.readyState = '';\n  this.agent = opts.agent || false;\n  this.socket = opts.socket;\n  this.enablesXDR = opts.enablesXDR;\n\n  // SSL options for Node.js client\n  this.pfx = opts.pfx;\n  this.key = opts.key;\n  this.passphrase = opts.passphrase;\n  this.cert = opts.cert;\n  this.ca = opts.ca;\n  this.ciphers = opts.ciphers;\n  this.rejectUnauthorized = opts.rejectUnauthorized;\n  this.forceNode = opts.forceNode;\n\n  // results of ReactNative environment detection\n  this.isReactNative = opts.isReactNative;\n\n  // other options for Node.js client\n  this.extraHeaders = opts.extraHeaders;\n  this.localAddress = opts.localAddress;\n}\n\n/**\n * Mix in `Emitter`.\n */\n\nEmitter(Transport.prototype);\n\n/**\n * Emits an error.\n *\n * @param {String} str\n * @return {Transport} for chaining\n * @api public\n */\n\nTransport.prototype.onError = function (msg, desc) {\n  var err = new Error(msg);\n  err.type = 'TransportError';\n  err.description = desc;\n  this.emit('error', err);\n  return this;\n};\n\n/**\n * Opens the transport.\n *\n * @api public\n */\n\nTransport.prototype.open = function () {\n  if ('closed' === this.readyState || '' === this.readyState) {\n    this.readyState = 'opening';\n    this.doOpen();\n  }\n\n  return this;\n};\n\n/**\n * Closes the transport.\n *\n * @api private\n */\n\nTransport.prototype.close = function () {\n  if ('opening' === this.readyState || 'open' === this.readyState) {\n    this.doClose();\n    this.onClose();\n  }\n\n  return this;\n};\n\n/**\n * Sends multiple packets.\n *\n * @param {Array} packets\n * @api private\n */\n\nTransport.prototype.send = function (packets) {\n  if ('open' === this.readyState) {\n    this.write(packets);\n  } else {\n    throw new Error('Transport not open');\n  }\n};\n\n/**\n * Called upon open\n *\n * @api private\n */\n\nTransport.prototype.onOpen = function () {\n  this.readyState = 'open';\n  this.writable = true;\n  this.emit('open');\n};\n\n/**\n * Called with data.\n *\n * @param {String} data\n * @api private\n */\n\nTransport.prototype.onData = function (data) {\n  var packet = parser.decodePacket(data, this.socket.binaryType);\n  this.onPacket(packet);\n};\n\n/**\n * Called with a decoded packet.\n */\n\nTransport.prototype.onPacket = function (packet) {\n  this.emit('packet', packet);\n};\n\n/**\n * Called upon close.\n *\n * @api private\n */\n\nTransport.prototype.onClose = function () {\n  this.readyState = 'closed';\n  this.emit('close');\n};\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","\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\r\n  // Remove event specific arrays for event types that no\r\n  // one is subscribed for to avoid memory leak.\r\n  if (callbacks.length === 0) {\r\n    delete this._callbacks['$' + event];\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\r\n  var args = new Array(arguments.length - 1)\r\n    , callbacks = this._callbacks['$' + event];\r\n\r\n  for (var i = 1; i < arguments.length; i++) {\r\n    args[i - 1] = arguments[i];\r\n  }\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/**\n * Expose `Backoff`.\n */\n\nmodule.exports = Backoff;\n\n/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\n\nfunction Backoff(opts) {\n  opts = opts || {};\n  this.ms = opts.min || 100;\n  this.max = opts.max || 10000;\n  this.factor = opts.factor || 2;\n  this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n  this.attempts = 0;\n}\n\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\n\nBackoff.prototype.duration = function(){\n  var ms = this.ms * Math.pow(this.factor, this.attempts++);\n  if (this.jitter) {\n    var rand =  Math.random();\n    var deviation = Math.floor(rand * this.jitter * ms);\n    ms = (Math.floor(rand * 10) & 1) == 0  ? ms - deviation : ms + deviation;\n  }\n  return Math.min(ms, this.max) | 0;\n};\n\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\n\nBackoff.prototype.reset = function(){\n  this.attempts = 0;\n};\n\n/**\n * Set the minimum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMin = function(min){\n  this.ms = min;\n};\n\n/**\n * Set the maximum duration\n *\n * @api public\n */\n\nBackoff.prototype.setMax = function(max){\n  this.max = max;\n};\n\n/**\n * Set the jitter\n *\n * @api public\n */\n\nBackoff.prototype.setJitter = function(jitter){\n  this.jitter = jitter;\n};\n\n"],"sourceRoot":""}